From 252bbf67aaf50efddc7846845c759c18b119f5e1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C5=81ukasz=20Kryczka?=
 <60490378+kryczkal@users.noreply.github.com>
Date: Fri, 5 Dec 2025 22:49:02 +0100
Subject: [PATCH 01/56] Kryczkal/io 01 (#226)

Super small PR for making a generic SerialDriver.
This was created with the intention of integrating the IO Stream API /
MultiplexerWriter into the current Trace framework / print / etc. But I
decided what's already there, can just stay for now. I'm just going to
implement the new Console using this API.
This is the leftover from this idea, before I stopped myself. The lone
generic UART16550 driver (can be used to writing to QEMU)
---
 kernel/arch/x86_64/src/hal/impl/io.hpp   |  29 +++++
 kernel/src/drivers/serial/uart_16550.cpp | 144 +++++++++++++++++++++++
 kernel/src/drivers/serial/uart_16550.hpp |  64 ++++++++++
 kernel/src/hal/api/io.hpp                |  25 ++++
 kernel/src/hal/io.hpp                    |  15 +++
 kernel/src/io/error.hpp                  |   4 +-
 kernel/src/io/register.hpp               |  49 ++++++++
 kernel/src/modules/memory.hpp            |   1 +
 8 files changed, 329 insertions(+), 2 deletions(-)
 create mode 100644 kernel/arch/x86_64/src/hal/impl/io.hpp
 create mode 100644 kernel/src/drivers/serial/uart_16550.cpp
 create mode 100644 kernel/src/drivers/serial/uart_16550.hpp
 create mode 100644 kernel/src/hal/api/io.hpp
 create mode 100644 kernel/src/hal/io.hpp
 create mode 100644 kernel/src/io/register.hpp

diff --git a/kernel/arch/x86_64/src/hal/impl/io.hpp b/kernel/arch/x86_64/src/hal/impl/io.hpp
new file mode 100644
index 00000000..0e4e2c5a
--- /dev/null
+++ b/kernel/arch/x86_64/src/hal/impl/io.hpp
@@ -0,0 +1,29 @@
+#ifndef KERNEL_ARCH_X86_64_SRC_HAL_IMPL_IO_HPP_
+#define KERNEL_ARCH_X86_64_SRC_HAL_IMPL_IO_HPP_
+
+#include <hal/api/io.hpp>
+
+#include <limits.hpp>
+
+#include "include/io.hpp"
+
+namespace arch
+{
+
+template <IoT T>
+void IoWrite(size_t addr, T value)
+{
+    ASSERT_LE(addr, std::numeric_limits<u16>::max());
+    io::out(static_cast<u16>(addr), value);
+}
+
+template <IoT T>
+T IoRead(size_t addr)
+{
+    ASSERT_LE(addr, std::numeric_limits<u16>::max());
+    return io::in<T>(static_cast<u16>(addr));
+}
+
+}  // namespace arch
+
+#endif /* KERNEL_ARCH_X86_64_SRC_HAL_IMPL_IO_HPP_ */
diff --git a/kernel/src/drivers/serial/uart_16550.cpp b/kernel/src/drivers/serial/uart_16550.cpp
new file mode 100644
index 00000000..ddb722ff
--- /dev/null
+++ b/kernel/src/drivers/serial/uart_16550.cpp
@@ -0,0 +1,144 @@
+#include "drivers/serial/uart_16550.hpp"
+
+#include <hal/sync.hpp>
+#include <io/error.hpp>
+
+#include <assert.h>
+#include <bits_ext.hpp>
+
+namespace Drivers::Serial
+{
+
+// ----------------------------------------------------------------------------
+// Register Offsets & Bit Definitions
+// ----------------------------------------------------------------------------
+
+static constexpr size_t kRegData       = 0;
+static constexpr size_t kRegIntEnable  = 1;
+static constexpr size_t kRegFifoCtrl   = 2;
+static constexpr size_t kRegLineCtrl   = 3;
+static constexpr size_t kRegModemCtrl  = 4;
+static constexpr size_t kRegLineStatus = 5;
+
+// Line Control Register Bits
+static constexpr u8 kLcrDataBits8  = 0x03;  // 8 bits per character
+static constexpr u8 kLcrStopBits1  = 0x00;  // 1 stop bit
+static constexpr u8 kLcrParityNone = 0x00;  // No parity
+static constexpr u8 kLcrDlab       = 0x80;  // Divisor Latch Access Bit
+
+// FIFO Control Register Bits
+static constexpr u8 kFcrEnable    = 0x01;
+static constexpr u8 kFcrClearRx   = 0x02;
+static constexpr u8 kFcrClearTx   = 0x04;
+static constexpr u8 kFcrTrigger14 = 0xC0;  // 14-byte trigger level
+
+// Modem Control Register Bits
+static constexpr u8 kMcrDtr  = 0x01;  // Data Terminal Ready
+static constexpr u8 kMcrRts  = 0x02;  // Request To Send
+static constexpr u8 kMcrOut2 = 0x08;  // Aux Output 2 (Used for IRQs)
+
+// Line Status Register Bits
+static constexpr u8 kLsrDataReady = 0x01;
+static constexpr u8 kLsrTxEmpty   = 0x20;  // Transmit Holding Register Empty
+
+// Base clock for UART (115200 Hz)
+static constexpr u32 kUartBaseClock = 115200;
+
+// ----------------------------------------------------------------------------
+// Implementation
+// ----------------------------------------------------------------------------
+
+Uart16550::Uart16550(size_t base_addr)
+    : data_reg_(base_addr, kRegData),
+      int_enable_reg_(base_addr, kRegIntEnable),
+      fifo_ctrl_reg_(base_addr, kRegFifoCtrl),
+      line_ctrl_reg_(base_addr, kRegLineCtrl),
+      modem_ctrl_reg_(base_addr, kRegModemCtrl),
+      line_status_reg_(base_addr, kRegLineStatus)
+{
+}
+
+void Uart16550::Init(uint32_t baud_rate)
+{
+    // Disable interrupts initially
+    int_enable_reg_.Write<u8>(0x00);
+
+    // Set Baud Rate
+    SetBaudRate(baud_rate);
+
+    // Set Frame Format: 8 bits, 1 stop bit, no parity (8N1)
+    // We clear DLAB here as well (bit 7 = 0)
+    line_ctrl_reg_.Write<u8>(kLcrDataBits8 | kLcrStopBits1 | kLcrParityNone);
+
+    // Enable and Clear FIFOs
+    fifo_ctrl_reg_.Write<u8>(kFcrEnable | kFcrClearRx | kFcrClearTx | kFcrTrigger14);
+
+    // Enable RTS/DTR and Out2 (needed for interrupts on some boards, generally good practice)
+    modem_ctrl_reg_.Write<u8>(kMcrDtr | kMcrRts | kMcrOut2);
+}
+
+void Uart16550::SetBaudRate(uint32_t baud_rate)
+{
+    R_ASSERT_NOT_ZERO(baud_rate);
+
+    u32 divisor = kUartBaseClock / baud_rate;
+
+    // Enable DLAB to set divisor
+    u8 lcr = line_ctrl_reg_.Read<u8>();
+    line_ctrl_reg_.Write<u8>(lcr | kLcrDlab);
+
+    // Write divisor (Low byte then High byte)
+    data_reg_.Write<u8>(static_cast<u8>(divisor & kBitMask8));
+    int_enable_reg_.Write<u8>(static_cast<u8>((divisor >> 8) & kBitMask8));
+
+    // Disable DLAB (restore previous LCR state, ensuring bit 7 is 0)
+    line_ctrl_reg_.Write<u8>(lcr & ~kLcrDlab);
+}
+
+bool Uart16550::IsTransmitEmpty() const { return (line_status_reg_.Read<u8>() & kLsrTxEmpty) != 0; }
+
+bool Uart16550::IsDataReady() const { return (line_status_reg_.Read<u8>() & kLsrDataReady) != 0; }
+
+IO::IoResult Uart16550::Read(std::span<byte> buffer)
+{
+    size_t bytes_read = 0;
+
+    for (size_t i = 0; i < buffer.size(); ++i) {
+        // If the hardware has no data, we stop immediately.
+        if (!IsDataReady()) {
+            // If we haven't read anything yet, tell the caller to try again later.
+            if (bytes_read == 0) {
+                return std::unexpected(IO::Error::Retry);
+            }
+            // Otherwise, return what we managed to grab so far (short read).
+            break;
+        }
+
+        buffer[i] = static_cast<byte>(data_reg_.Read<u8>());
+        bytes_read++;
+    }
+
+    return bytes_read;
+}
+
+IO::IoResult Uart16550::Write(std::span<const byte> buffer)
+{
+    size_t bytes_written = 0;
+
+    for (const byte b : buffer) {
+        // If the transmit holding register/FIFO is full, stop.
+        if (!IsTransmitEmpty()) {
+            if (bytes_written == 0) {
+                return std::unexpected(IO::Error::Retry);
+            }
+            break;
+        }
+
+        data_reg_.Write<u8>(static_cast<u8>(b));
+        bytes_written++;
+    }
+
+    return bytes_written;
+}
+
+}  // namespace Drivers::Serial
diff --git a/kernel/src/drivers/serial/uart_16550.hpp b/kernel/src/drivers/serial/uart_16550.hpp
new file mode 100644
index 00000000..847a6c08
--- /dev/null
+++ b/kernel/src/drivers/serial/uart_16550.hpp
@@ -0,0 +1,64 @@
+#ifndef KERNEL_SRC_DRIVERS_SERIAL_UART_16550_HPP_
+#define KERNEL_SRC_DRIVERS_SERIAL_UART_16550_HPP_
+
+#include <io/register.hpp>
+#include <io/stream.hpp>
+#include <types.hpp>
+
+namespace Drivers::Serial
+{
+
+class Uart16550 final : public IO::IStream
+{
+    public:
+    // Standard COM ports base addresses for reference
+    static constexpr size_t kCom1Base = 0x3F8;
+    static constexpr size_t kCom2Base = 0x2F8;
+
+    explicit Uart16550(size_t base_addr);
+
+    /**
+     * @brief Initializes the UART controller.
+     * Sets baud rate, frame format (8N1), and enables FIFO.
+     * @param baud_rate Target baud rate (e.g., 38400, 115200).
+     */
+    void Init(uint32_t baud_rate = 38400);
+
+    // IO::IStream implementation
+    IO::IoResult Write(std::span<const byte> buffer) override;
+    IO::IoResult Read(std::span<byte> buffer) override;
+
+    private:
+    // ------------------------------
+    // Registers
+    // ------------------------------
+
+    // Read/Write Data (DLAB=0) or Divisor Low (DLAB=1)
+    IO::Register data_reg_;
+
+    // Interrupt Enable (DLAB=0) or Divisor High (DLAB=1)
+    IO::Register int_enable_reg_;
+
+    // FIFO Control (Write) / ISR (Read)
+    IO::Register fifo_ctrl_reg_;
+
+    // Line Control Register
+    IO::Register line_ctrl_reg_;
+
+    // Modem Control Register
+    IO::Register modem_ctrl_reg_;
+
+    // Line Status Register
+    IO::Register line_status_reg_;
+
+    // ------------------------------
+    // Helpers
+    // ------------------------------
+    NODISCARD bool IsTransmitEmpty() const;
+    NODISCARD bool IsDataReady() const;
+    void SetBaudRate(uint32_t baud_rate);
+};
+
+}  // namespace Drivers::Serial
+
+#endif  // KERNEL_SRC_DRIVERS_SERIAL_UART_16550_HPP_
diff --git a/kernel/src/hal/api/io.hpp b/kernel/src/hal/api/io.hpp
new file mode 100644
index 00000000..0e8a43d0
--- /dev/null
+++ b/kernel/src/hal/api/io.hpp
@@ -0,0 +1,25 @@
+#ifndef KERNEL_SRC_HAL_API_IO_HPP_
+#define KERNEL_SRC_HAL_API_IO_HPP_
+
+#include <concepts.hpp>
+#include <types.hpp>
+
+namespace arch
+{
+
+template <typename T>
+concept IoT = std::is_same_v<T, u8> || std::is_same_v<T, u16> || std::is_same_v<T, u32>;
+
+template <IoT T>
+void IoWrite(size_t addr, T value);
+template <IoT T>
+T IoRead(size_t addr);
+
+}  // namespace arch
+
+namespace hal
+{
+using arch::IoT;
+}
+
+#endif  // KERNEL_SRC_HAL_API_IO_HPP_
diff --git a/kernel/src/hal/io.hpp b/kernel/src/hal/io.hpp
new file mode 100644
index 00000000..1d71bfcb
--- /dev/null
+++ b/kernel/src/hal/io.hpp
@@ -0,0 +1,15 @@
+#ifndef KERNEL_SRC_HAL_IO_HPP_
+#define KERNEL_SRC_HAL_IO_HPP_
+
+#include <hal/impl/io.hpp>
+
+namespace hal
+{
+
+using arch::IoRead;
+using arch::IoT;
+using arch::IoWrite;
+
+}  // namespace hal
+
+#endif  // KERNEL_SRC_HAL_IO_HPP_
diff --git a/kernel/src/io/error.hpp b/kernel/src/io/error.hpp
index 08bb0dca..9607d92e 100644
--- a/kernel/src/io/error.hpp
+++ b/kernel/src/io/error.hpp
@@ -1,7 +1,7 @@
 #ifndef KERNEL_SRC_IO_ERROR_HPP_
 #define KERNEL_SRC_IO_ERROR_HPP_
 
-namespace Io
+namespace IO
 {
 
 enum class Error {
@@ -14,4 +14,4 @@ enum class Error {
 
 }
 
-#endif /* KERNEL_SRC_IO_ERROR_HPP_ */
+#endif  // KERNEL_SRC_IO_ERROR_HPP_
diff --git a/kernel/src/io/register.hpp b/kernel/src/io/register.hpp
new file mode 100644
index 00000000..98a2f1d4
--- /dev/null
+++ b/kernel/src/io/register.hpp
@@ -0,0 +1,49 @@
+#ifndef KERNEL_SRC_IO_REGISTER_HPP_
+#define KERNEL_SRC_IO_REGISTER_HPP_
+
+#include "hal/io.hpp"
+
+namespace IO
+{
+
+/**
+ * @class Register
+ * @brief Abstraction for a specific hardware I/O register or port.
+ *
+ * This class encapsulates the address of a hardware register (e.g., an I/O port number
+ * on x86 or a physical memory address on MMIO architectures) and provides a type-safe
+ * interface for data access.
+ *
+ * It acts as a wrapper around the Hardware Abstraction Layer (HAL), delegating
+ * specific read/write instructions (like `inb`/`outb` or volatile pointer access)
+ * to `hal::IoRead` and `hal::IoWrite`. This allows device drivers to remain
+ * architecture-agnostic.
+ *
+ * @note Operations are restricted to valid I/O types (u8, u16, u32) via the
+ *       `hal::IoT` concept.
+ */
+class Register
+{
+    public:
+    explicit Register(size_t addr) : addr_{addr} {};
+    Register(size_t base_addr, size_t offset) : addr_{base_addr + offset} {};
+
+    template <hal::IoT T>
+    void Write(T val) const
+    {
+        hal::IoWrite(addr_, val);
+    }
+
+    template <hal::IoT T>
+    T Read() const
+    {
+        return hal::IoRead<T>(addr_);
+    }
+
+    private:
+    size_t addr_;
+};
+
+}  // namespace IO
+
+#endif  // KERNEL_SRC_IO_REGISTER_HPP_
diff --git a/kernel/src/modules/memory.hpp b/kernel/src/modules/memory.hpp
index e0de6af8..592c8b1d 100644
--- a/kernel/src/modules/memory.hpp
+++ b/kernel/src/modules/memory.hpp
@@ -5,6 +5,7 @@
 
 #include "boot_args.hpp"
 #include "hal/boot_args.hpp"
+#include "hal/io.hpp"
 #include "hal/mmu.hpp"
 #include "hal/tlb.hpp"
 #include "mem/heap.hpp"

From bfae95dea0afdd66a7a1c68e0c7cf69c9cc6816c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C5=81ukasz=20Kryczka?=
 <60490378+kryczkal@users.noreply.github.com>
Date: Sat, 6 Dec 2025 12:20:51 +0100
Subject: [PATCH 02/56] Kryczkal/framebuffer (#227)

## Problem
We want to have a graphic IO with the kernel.

## Solution
<img width="1188" height="734" alt="image"
src="https://github.com/user-attachments/assets/673284b0-f99a-4c25-8135-eb2380a505e9"
/>

- Implement a driver for Framebuffer.
- Enable framebuffer finding in boot modules.
- Init Framebuffer from KernelArgs
- Implement a Video module
- Create an abstract non-owning Surface type (for double/tripple
buffering)
- Create a painter class that knows how to paint a Surface.
- Implement Graphics related primitives
---
 .../x86_64/boot/lib/abi/transition_data.hpp   |  19 ++
 .../x86_64/boot/lib/multiboot2/multiboot2.h   |   4 +-
 .../loader_32/build/multiboot_header.nasm     |   4 +-
 .../arch/x86_64/boot/loader_64/src/main.cpp   |  89 ++++++++-
 kernel/arch/x86_64/src/drivers/vga/vga.cpp    | 187 ------------------
 kernel/arch/x86_64/src/drivers/vga/vga.hpp    |  25 ---
 kernel/arch/x86_64/src/hal/impl/terminal.hpp  |  10 -
 kernel/src/boot_args.cpp                      |  48 +++++
 kernel/src/boot_args.hpp                      |  21 +-
 kernel/src/drivers/video/framebuffer.cpp      |  33 ++++
 kernel/src/drivers/video/framebuffer.hpp      |  41 ++++
 kernel/src/graphics/color.hpp                 |  38 ++++
 kernel/src/graphics/painter.cpp               | 118 +++++++++++
 kernel/src/graphics/painter.hpp               |  39 ++++
 kernel/src/graphics/surface.hpp               |  92 +++++++++
 kernel/src/hal/api/boot_args.hpp              |  19 +-
 kernel/src/init.cpp                           |  15 +-
 kernel/src/kernel.cpp                         |  31 +++
 kernel/src/modules/video.cpp                  |  36 ++++
 kernel/src/modules/video.hpp                  |  34 ++++
 kernel/src/trace_framework.hpp                |   5 +
 21 files changed, 660 insertions(+), 248 deletions(-)
 delete mode 100644 kernel/arch/x86_64/src/drivers/vga/vga.cpp
 delete mode 100644 kernel/arch/x86_64/src/drivers/vga/vga.hpp
 create mode 100644 kernel/src/drivers/video/framebuffer.cpp
 create mode 100644 kernel/src/drivers/video/framebuffer.hpp
 create mode 100644 kernel/src/graphics/color.hpp
 create mode 100644 kernel/src/graphics/painter.cpp
 create mode 100644 kernel/src/graphics/painter.hpp
 create mode 100644 kernel/src/graphics/surface.hpp
 create mode 100644 kernel/src/modules/video.cpp
 create mode 100644 kernel/src/modules/video.hpp

diff --git a/kernel/arch/x86_64/boot/lib/abi/transition_data.hpp b/kernel/arch/x86_64/boot/lib/abi/transition_data.hpp
index fc3f495c..8944153e 100644
--- a/kernel/arch/x86_64/boot/lib/abi/transition_data.hpp
+++ b/kernel/arch/x86_64/boot/lib/abi/transition_data.hpp
@@ -18,14 +18,33 @@ struct alignas(64) TransitionData {
 };
 
 struct PACK alignas(64) KernelArguments {
+    /// Kernel Mem Layout
     u64 kernel_start_addr;
     u64 kernel_end_addr;
 
+    /// VMem
     u64 pml_4_table_phys_addr;
 
+    /// Memory Bitmap
     u64 mem_info_bitmap_addr;
     u64 mem_info_total_pages;
 
+    /// Framebuffer
+    u64 fb_addr;
+    u32 fb_width;
+    u32 fb_height;
+    u32 fb_pitch;
+    u32 fb_bpp;  // Bits per pixel
+
+    // RGB Format
+    u8 fb_red_pos;
+    u8 fb_red_mask;
+    u8 fb_green_pos;
+    u8 fb_green_mask;
+    u8 fb_blue_pos;
+    u8 fb_blue_mask;
+
+    /// Multiboot
     u64 multiboot_info_addr;
     u64 multiboot_header_start_addr;
     u64 multiboot_header_end_addr;
diff --git a/kernel/arch/x86_64/boot/lib/multiboot2/multiboot2.h b/kernel/arch/x86_64/boot/lib/multiboot2/multiboot2.h
index d08dcba4..0e1879c2 100644
--- a/kernel/arch/x86_64/boot/lib/multiboot2/multiboot2.h
+++ b/kernel/arch/x86_64/boot/lib/multiboot2/multiboot2.h
@@ -271,9 +271,7 @@ struct TagFramebufferCommon {
     static constexpr u8 kFramebufferTypeEgaText = 2;
 };
 
-struct TagFramebuffer {
-    struct TagFramebufferCommon common;
-
+struct TagFramebuffer : public TagFramebufferCommon {
     union {
         struct {
             u16 framebuffer_palette_num_colors;
diff --git a/kernel/arch/x86_64/boot/loader_32/build/multiboot_header.nasm b/kernel/arch/x86_64/boot/loader_32/build/multiboot_header.nasm
index 97663235..fb43a08f 100644
--- a/kernel/arch/x86_64/boot/loader_32/build/multiboot_header.nasm
+++ b/kernel/arch/x86_64/boot/loader_32/build/multiboot_header.nasm
@@ -53,6 +53,8 @@
           MULTIBOOT_CONSOLE_FLAGS_CONSOLE_REQUIRED equ 1
           MULTIBOOT_CONSOLE_FLAGS_EGA_TEXT_SUPPORTED equ 2
 
+          FRAMEBUFFER_REQUIRED_DEPTH equ 32
+
 ; Multiboot header
           section   .multiboot
           align 8
@@ -80,7 +82,7 @@ multiboot_start:
           dd (.framebuffer_tag_end - .framebuffer_tag_start)
           dd 0 ; width  - no preference
           dd 0 ; height - no preference
-          dd 0 ; depth  - no preference
+          dd FRAMEBUFFER_REQUIRED_DEPTH ; depth
 .framebuffer_tag_end:
 
           ; End tag (required)
diff --git a/kernel/arch/x86_64/boot/loader_64/src/main.cpp b/kernel/arch/x86_64/boot/loader_64/src/main.cpp
index 8238d66d..68d7b9a1 100644
--- a/kernel/arch/x86_64/boot/loader_64/src/main.cpp
+++ b/kernel/arch/x86_64/boot/loader_64/src/main.cpp
@@ -175,15 +175,15 @@ static void EstablishDirectMemMapping(MemoryManagers &mms)
     );
 }
 
-NO_RET static void TransitionToKernel(
-    u64 kernel_entry_point, const TransitionData *transition_data,
-    const KernelModuleInfo &kernel_info, MemoryManagers mem_managers
+static void PrepareKernelArgs(
+    const TransitionData *transition_data, const KernelModuleInfo &kernel_info,
+    MemoryManagers mem_managers, MultibootInfo &multiboot_info
 )
 {
     auto &pmm = mem_managers.pmm;
     auto &vmm = mem_managers.vmm;
 
-    TRACE_INFO("Preparing to transition to kernel...");
+    TRACE_INFO("Preparing kernel arguments...");
 
     // Prepare parameters for the kernel
     gKernelInitialParams.kernel_start_addr           = kernel_info.lower_bound;
@@ -196,6 +196,64 @@ NO_RET static void TransitionToKernel(
     gKernelInitialParams.mem_info_total_pages  = pmm.GetTotalPages();
     gKernelInitialParams.pml_4_table_phys_addr = vmm.GetPml4Table().Value();
 
+    // Framebuffer
+    auto fb_tag_res = multiboot_info.FindTag<TagFramebuffer>();
+    if (fb_tag_res) {
+        const auto *fb_tag = fb_tag_res.value();
+        bool is_rgb        = fb_tag->framebuffer_type == TagFramebufferCommon::kFramebufferTypeRgb;
+        bool is_32bpp      = fb_tag->framebuffer_bpp == 32;
+
+        if (is_rgb && is_32bpp) {
+            gKernelInitialParams.fb_addr   = fb_tag->framebuffer_addr;
+            gKernelInitialParams.fb_width  = fb_tag->framebuffer_width;
+            gKernelInitialParams.fb_height = fb_tag->framebuffer_height;
+            gKernelInitialParams.fb_pitch  = fb_tag->framebuffer_pitch;
+            gKernelInitialParams.fb_bpp    = fb_tag->framebuffer_bpp;
+
+            gKernelInitialParams.fb_red_pos    = fb_tag->framebuffer_red_field_position;
+            gKernelInitialParams.fb_red_mask   = fb_tag->framebuffer_red_mask_size;
+            gKernelInitialParams.fb_green_pos  = fb_tag->framebuffer_green_field_position;
+            gKernelInitialParams.fb_green_mask = fb_tag->framebuffer_green_mask_size;
+            gKernelInitialParams.fb_blue_pos   = fb_tag->framebuffer_blue_field_position;
+            gKernelInitialParams.fb_blue_mask  = fb_tag->framebuffer_blue_mask_size;
+
+            TRACE_INFO(
+                "Framebuffer found: addr=0x%llX, res=%dx%d, bpp=%d", gKernelInitialParams.fb_addr,
+                gKernelInitialParams.fb_width, gKernelInitialParams.fb_height,
+                gKernelInitialParams.fb_bpp
+            );
+        } else {
+            TRACE_WARNING(
+                "Framebuffer found but not RGB 32-bit (type=%d, bpp=%d). Ignoring.",
+                fb_tag->framebuffer_type, fb_tag->framebuffer_bpp
+            );
+            gKernelInitialParams.fb_addr   = 0;
+            gKernelInitialParams.fb_width  = 0;
+            gKernelInitialParams.fb_height = 0;
+            gKernelInitialParams.fb_pitch  = 0;
+            gKernelInitialParams.fb_bpp    = 0;
+        }
+    } else {
+        TRACE_WARNING(
+            "No framebuffer tag found in multiboot info, framebuffer will not be available"
+        );
+        gKernelInitialParams.fb_addr   = 0;
+        gKernelInitialParams.fb_width  = 0;
+        gKernelInitialParams.fb_height = 0;
+        gKernelInitialParams.fb_pitch  = 0;
+        gKernelInitialParams.fb_bpp    = 0;
+    }
+}
+
+NO_RET static void TransitionToKernel(
+    u64 kernel_entry_point, const TransitionData *transition_data,
+    const KernelModuleInfo &kernel_info, MemoryManagers mem_managers
+)
+{
+    auto &pmm = mem_managers.pmm;
+
+    TRACE_INFO("Preparing to transition to kernel...");
+
     const u64 ld_start_addr    = reinterpret_cast<u64>(loader_64_start);
     const u64 ld_end_addr      = reinterpret_cast<u64>(loader_64_end);
     const u64 al_ld_start_addr = AlignDown(ld_start_addr, PageSize<PageSizeTag::k4Kb>());
@@ -212,12 +270,29 @@ NO_RET static void TransitionToKernel(
         "    mem_info_total_pages:        %llu\n"
         "    multiboot_info_addr:         0x%llX\n"
         "    multiboot_header_start_addr: 0x%llX\n"
-        "    multiboot_header_end_addr:   0x%llX\n",
+        "    multiboot_header_end_addr:   0x%llX\n"
+        "  Framebuffer Arguments:\n"
+        "    fb_addr:                     0x%llX\n"
+        "    fb_width:                    %u\n"
+        "    fb_height:                   %u\n"
+        "    fb_pitch:                    %u\n"
+        "    fb_bpp:                      %u\n"
+        "    fb_red_pos:                  %hhu\n"
+        "    fb_red_mask:                 %hhu\n"
+        "    fb_green_pos:                %hhu\n"
+        "    fb_green_mask:               %hhu\n"
+        "    fb_blue_pos:                 %hhu\n"
+        "    fb_blue_mask:                %hhu\n",
         gKernelInitialParams.kernel_start_addr, gKernelInitialParams.kernel_end_addr,
         gKernelInitialParams.pml_4_table_phys_addr, gKernelInitialParams.mem_info_bitmap_addr,
         gKernelInitialParams.mem_info_total_pages, gKernelInitialParams.multiboot_info_addr,
         gKernelInitialParams.multiboot_header_start_addr,
-        gKernelInitialParams.multiboot_header_end_addr
+        gKernelInitialParams.multiboot_header_end_addr, gKernelInitialParams.fb_addr,
+        gKernelInitialParams.fb_width, gKernelInitialParams.fb_height,
+        gKernelInitialParams.fb_pitch, gKernelInitialParams.fb_bpp, gKernelInitialParams.fb_red_pos,
+        gKernelInitialParams.fb_red_mask, gKernelInitialParams.fb_green_pos,
+        gKernelInitialParams.fb_green_mask, gKernelInitialParams.fb_blue_pos,
+        gKernelInitialParams.fb_blue_mask
     );
 
     TRACE_INFO("Jumping to kernel at entry point: 0x%llX", kernel_entry_point);
@@ -240,5 +315,7 @@ extern "C" void MainLoader64(TransitionData *transition_data)
 
     EstablishDirectMemMapping(mms);
 
+    PrepareKernelArgs(transition_data, kernel_info, mms, multiboot_info);
+
     TransitionToKernel(kernel_entry_point, transition_data, kernel_info, mms);
 }
diff --git a/kernel/arch/x86_64/src/drivers/vga/vga.cpp b/kernel/arch/x86_64/src/drivers/vga/vga.cpp
deleted file mode 100644
index 7310c7d0..00000000
--- a/kernel/arch/x86_64/src/drivers/vga/vga.cpp
+++ /dev/null
@@ -1,187 +0,0 @@
-/* internal includes */
-#include "drivers/vga/vga.hpp"
-#include <string.h>
-#include <defines.hpp>
-#include <types.hpp>
-
-/**
- * @file vga.cpp
- * @brief Implementation of VGA text mode terminal driver
- */
-
-// ------------------------------
-// Types and variables
-// ------------------------------
-
-/**
- * @name VGA Hardware Text Mode Colors
- * Standard 16-color VGA text mode palette
- * @{
- */
-enum VgaColor {
-    VGA_COLOR_BLACK         = 0,   ///< Standard black
-    VGA_COLOR_BLUE          = 1,   ///< Standard blue
-    VGA_COLOR_GREEN         = 2,   ///< Standard green
-    VGA_COLOR_CYAN          = 3,   ///< Standard cyan
-    VGA_COLOR_RED           = 4,   ///< Standard red
-    VGA_COLOR_MAGENTA       = 5,   ///< Standard magenta
-    VGA_COLOR_BROWN         = 6,   ///< Standard brown
-    VGA_COLOR_LIGHT_GREY    = 7,   ///< Standard light grey
-    VGA_COLOR_DARK_GREY     = 8,   ///< Standard dark grey
-    VGA_COLOR_LIGHT_BLUE    = 9,   ///< Bright blue
-    VGA_COLOR_LIGHT_GREEN   = 10,  ///< Bright green
-    VGA_COLOR_LIGHT_CYAN    = 11,  ///< Bright cyan
-    VGA_COLOR_LIGHT_RED     = 12,  ///< Bright red
-    VGA_COLOR_LIGHT_MAGENTA = 13,  ///< Bright magenta
-    VGA_COLOR_LIGHT_BROWN   = 14,  ///< Yellow (bright brown)
-    VGA_COLOR_WHITE         = 15,  ///< Bright white
-};
-/** @} */
-
-/**
- * @name VGA Display Constants
- * Standard VGA text mode dimensions
- * @{
- */
-static constexpr size_t kVgaWidth  = 80;  ///< Standard VGA text mode width
-static constexpr size_t kVgaHeight = 25;  ///< Standard VGA text mode height
-/** @} */
-
-/**
- * @name Terminal State Variables
- * Global state tracking for the terminal
- * @{
- */
-static size_t g_TerminalRow;        ///< Current cursor row position
-static size_t g_TerminalColumn;     ///< Current cursor column position
-static uint8_t g_TerminalColor;     ///< Current text color attributes
-static uint16_t *g_TerminalBuffer;  ///< Pointer to VGA memory buffer (0xB8000)
-/** @} */
-
-/**
- * @brief Create a VGA color attribute byte
- *
- * @param fg Foreground color
- * @param bg Background color
- * @return Combined color attribute byte
- *
- * Combines foreground and background colors into a single byte
- * where the background color is in the high nibble.
- */
-static FORCE_INLINE_F uint8_t VgaEntryColor(const VgaColor fg, const VgaColor bg)
-{
-    return fg | bg << 4;
-}
-
-/**
- * @brief Create a VGA character entry
- *
- * @param uc Character to display
- * @param color Color attribute byte
- * @return Combined VGA character entry
- *
- * Creates a 16-bit VGA character entry with the character in the low byte
- * and the color attribute in the high byte.
- */
-static FORCE_INLINE_F uint16_t VgaEntry(const unsigned char uc, const uint8_t color)
-{
-    return static_cast<uint16_t>(uc) | static_cast<uint16_t>(color) << 8;
-}
-
-/**
- * @brief Initialize the VGA text mode terminal
- *
- * Sets up a 80x25 text mode display with light grey text on black background.
- * Clears the screen and positions the cursor at (0,0).
- */
-void VgaTerminalInit()
-{
-    g_TerminalRow    = 0;
-    g_TerminalColumn = 0;
-    g_TerminalColor  = VgaEntryColor(VGA_COLOR_LIGHT_GREY, VGA_COLOR_BLACK);
-    g_TerminalBuffer = reinterpret_cast<uint16_t *>(0xB8000);
-
-    for (size_t y = 0; y < kVgaHeight; y++) {
-        for (size_t x = 0; x < kVgaWidth; x++) {
-            const size_t index      = y * kVgaWidth + x;
-            g_TerminalBuffer[index] = VgaEntry(' ', g_TerminalColor);
-        }
-    }
-}
-
-/**
- * @brief Set the current text color
- *
- * @param color Combined foreground and background color value
- *              (foreground in lower 4 bits, background in upper 4 bits)
- */
-void VgaTerminalSetColor(const uint8_t color) { g_TerminalColor = color; }
-
-/**
- * @brief Write a character with specified color at given coordinates
- *
- * @param c Character to display
- * @param color Color attribute for the character
- * @param x X-coordinate (0 to 79)
- * @param y Y-coordinate (0 to 24)
- */
-void VgaTerminalPutEntryAt(const char c, const uint8_t color, const size_t x, const size_t y)
-{
-    const size_t index      = y * kVgaWidth + x;
-    g_TerminalBuffer[index] = VgaEntry(c, color);
-}
-
-/**
- * @brief Write a character at the current cursor position
- *
- * @param c Character to display
- *
- * Automatically advances the cursor and handles wraparound
- * when reaching the end of a line or screen.
- */
-void VgaTerminalPutChar(const char c)
-{
-    VgaTerminalPutEntryAt(c, g_TerminalColor, g_TerminalColumn, g_TerminalRow);
-    if (++g_TerminalColumn == kVgaWidth) {
-        g_TerminalColumn = 0;
-        if (++g_TerminalRow == kVgaHeight)
-            g_TerminalRow = 0;
-    }
-}
-
-/**
- * @brief Write a string of specified length
- *
- * @param data Pointer to the string data
- * @param size Number of characters to write
- */
-void VgaTerminalWrite(const char *data, const size_t size)
-{
-    for (size_t i = 0; i < size; i++) VgaTerminalPutChar(data[i]);
-}
-
-/**
- * @brief Write a null-terminated string in default color (light grey on black)
- *
- * @param data Pointer to the null-terminated string
- */
-void VgaTerminalWriteString(const char *data)
-{
-    VgaTerminalSetColor(VgaEntryColor(VGA_COLOR_LIGHT_GREY, VGA_COLOR_BLACK));
-    VgaTerminalWrite(data, strlen(data));
-}
-
-/**
- * @brief Write a null-terminated string in error color (light red on black)
- *
- * @param data Pointer to the null-terminated string
- *
- * Temporarily changes color to light red, writes the string,
- * then restores the previous color.
- */
-void VgaTerminalWriteError(const char *data)
-{
-    VgaTerminalSetColor(VgaEntryColor(VGA_COLOR_LIGHT_RED, VGA_COLOR_BLACK));
-    VgaTerminalWrite(data, strlen(data));
-    VgaTerminalSetColor(VgaEntryColor(VGA_COLOR_LIGHT_GREY, VGA_COLOR_BLACK));
-}
diff --git a/kernel/arch/x86_64/src/drivers/vga/vga.hpp b/kernel/arch/x86_64/src/drivers/vga/vga.hpp
deleted file mode 100644
index bf4cf2f0..00000000
--- a/kernel/arch/x86_64/src/drivers/vga/vga.hpp
+++ /dev/null
@@ -1,25 +0,0 @@
-#ifndef KERNEL_ARCH_X86_64_SRC_DRIVERS_VGA_VGA_HPP_
-#define KERNEL_ARCH_X86_64_SRC_DRIVERS_VGA_VGA_HPP_
-
-#include <types.hpp>
-
-/**
- * @file vga.hpp
- * @brief Interface for VGA text mode terminal driver
- *
- * This header provides the interface for initializing and controlling a VGA text mode
- * terminal. It supports basic text output operations with color control in a
- * standard 80x25 text mode display.
- */
-
-extern "C" {
-void VgaTerminalInit();
-void VgaTerminalSetColor(uint8_t color);
-void VgaTerminalPutEntryAt(char c, uint8_t color, size_t x, size_t y);
-void VgaTerminalPutChar(char c);
-void VgaTerminalWrite(const char *data, size_t size);
-void VgaTerminalWriteString(const char *data);
-void VgaTerminalWriteError(const char *data);
-}
-
-#endif  // KERNEL_ARCH_X86_64_SRC_DRIVERS_VGA_VGA_HPP_
diff --git a/kernel/arch/x86_64/src/hal/impl/terminal.hpp b/kernel/arch/x86_64/src/hal/impl/terminal.hpp
index 512ece14..e1f89036 100644
--- a/kernel/arch/x86_64/src/hal/impl/terminal.hpp
+++ b/kernel/arch/x86_64/src/hal/impl/terminal.hpp
@@ -7,7 +7,6 @@
 #include <todo.hpp>
 
 #include "drivers/serial/qemu.hpp"
-#include "drivers/vga/vga.hpp"
 
 namespace arch
 {
@@ -21,9 +20,6 @@ WRAP_CALL void TerminalInit()
 
 WRAP_CALL void TerminalPutChar(const char c)
 {
-    /* Put char to VGA terminal -> when multiboot allows: TODO */
-    // VgaTerminalPutChar(c);
-
     if constexpr (FeatureEnabled<FeatureFlag::kDebugOutput>) {
         QemuTerminalPutChar(c);
     }
@@ -31,9 +27,6 @@ WRAP_CALL void TerminalPutChar(const char c)
 
 WRAP_CALL void TerminalWriteString(const char *data)
 {
-    /* Write string to VGA terminal -> when multiboot allows: TODO */
-    // VgaTerminalWriteString(data);
-
     if constexpr (FeatureEnabled<FeatureFlag::kDebugOutput>) {
         QemuTerminalWriteString(data);
     }
@@ -41,9 +34,6 @@ WRAP_CALL void TerminalWriteString(const char *data)
 
 WRAP_CALL void TerminalWriteError(const char *data)
 {
-    /* Write error string to VGA terminal -> when multiboot allows: TODO */
-    // VgaTerminalWriteError(data);
-
     if constexpr (FeatureEnabled<FeatureFlag::kDebugOutput>) {
         QemuTerminalWriteString(data);
     }
diff --git a/kernel/src/boot_args.cpp b/kernel/src/boot_args.cpp
index c469d200..44fc65a5 100644
--- a/kernel/src/boot_args.cpp
+++ b/kernel/src/boot_args.cpp
@@ -4,6 +4,7 @@
 #include "boot_args.hpp"
 #include "hal/boot_args.hpp"
 #include "mem/types.hpp"
+#include "trace_framework.hpp"
 
 using namespace Mem;
 
@@ -19,6 +20,20 @@ BootArguments SanitizeBootArgs(const hal::RawBootArguments &raw_args)
     );
     R_ASSERT_GT(raw_args.mem_info_total_pages, 0UL, "Total memory pages is zero.");
 
+    FramebufferArgs fb_args{
+        .base_address    = UptrToPtr<void>(raw_args.fb_addr),
+        .width           = raw_args.fb_width,
+        .height          = raw_args.fb_height,
+        .pitch           = raw_args.fb_pitch,
+        .bpp             = raw_args.fb_bpp,
+        .red_pos         = raw_args.fb_red_pos,
+        .red_mask_size   = raw_args.fb_red_mask,
+        .green_pos       = raw_args.fb_green_pos,
+        .green_mask_size = raw_args.fb_green_mask,
+        .blue_pos        = raw_args.fb_blue_pos,
+        .blue_mask_size  = raw_args.fb_blue_mask,
+    };
+
     BootArguments sanitized_k_args{
         .kernel_start      = UptrToPtr<void>(raw_args.kernel_start_addr),
         .kernel_end        = UptrToPtr<void>(raw_args.kernel_end_addr),
@@ -26,7 +41,40 @@ BootArguments SanitizeBootArgs(const hal::RawBootArguments &raw_args)
         .mem_bitmap        = UptrToPtr<void>(raw_args.mem_info_bitmap_phys_addr),
         .total_page_frames = static_cast<size_t>(raw_args.mem_info_total_pages),
         .multiboot_info    = UptrToPtr<void>(raw_args.multiboot_info_phys_addr),
+        .fb_args           = fb_args,
     };
 
+    DEBUG_INFO_BOOT("Sanitized boot arguments:");
+    DEBUG_INFO_BOOT(
+        "  Boot Arguments:\n"
+        "    kernel_start:       %p\n"
+        "    kernel_end:         %p\n"
+        "    root_page_table:    %p\n"
+        "    mem_bitmap:         %p\n"
+        "    total_page_frames:  %zu\n"
+        "    multiboot_info:     %p\n"
+        "  Framebuffer Arguments:\n"
+        "    base_address:       %p\n"
+        "    width:              %u\n"
+        "    height:             %u\n"
+        "    pitch:              %u\n"
+        "    bpp:                %u\n"
+        "    red_pos:            %hhu\n"
+        "    red_mask_size:      %hhu\n"
+        "    green_pos:          %hhu\n"
+        "    green_mask_size:    %hhu\n"
+        "    blue_pos:           %hhu\n"
+        "    blue_mask_size:     %hhu\n",
+        sanitized_k_args.kernel_start, sanitized_k_args.kernel_end,
+        sanitized_k_args.root_page_table, sanitized_k_args.mem_bitmap,
+        sanitized_k_args.total_page_frames, sanitized_k_args.multiboot_info,
+        sanitized_k_args.fb_args.base_address, sanitized_k_args.fb_args.width,
+        sanitized_k_args.fb_args.height, sanitized_k_args.fb_args.pitch,
+        sanitized_k_args.fb_args.bpp, sanitized_k_args.fb_args.red_pos,
+        sanitized_k_args.fb_args.red_mask_size, sanitized_k_args.fb_args.green_pos,
+        sanitized_k_args.fb_args.green_mask_size, sanitized_k_args.fb_args.blue_pos,
+        sanitized_k_args.fb_args.blue_mask_size
+    );
+
     return sanitized_k_args;
 }
diff --git a/kernel/src/boot_args.hpp b/kernel/src/boot_args.hpp
index 5ecb805b..6830646a 100644
--- a/kernel/src/boot_args.hpp
+++ b/kernel/src/boot_args.hpp
@@ -1,9 +1,23 @@
-#ifndef ALKOS_KERNEL_INCLUDE_BOOT_ARGS_HPP_
-#define ALKOS_KERNEL_INCLUDE_BOOT_ARGS_HPP_
+#ifndef KERNEL_SRC_BOOT_ARGS_HPP_
+#define KERNEL_SRC_BOOT_ARGS_HPP_
 
 #include "hal/boot_args.hpp"
 #include "mem/types.hpp"
 
+struct FramebufferArgs {
+    Mem::PPtr<void> base_address;
+    u32 width;
+    u32 height;
+    u32 pitch;
+    u32 bpp;
+    u8 red_pos;
+    u8 red_mask_size;
+    u8 green_pos;
+    u8 green_mask_size;
+    u8 blue_pos;
+    u8 blue_mask_size;
+};
+
 struct BootArguments {
     Mem::VPtr<void> kernel_start;
     Mem::VPtr<void> kernel_end;
@@ -11,8 +25,9 @@ struct BootArguments {
     Mem::PPtr<void> mem_bitmap;
     size_t total_page_frames;
     Mem::PPtr<void> multiboot_info;
+    FramebufferArgs fb_args;
 };
 
 BootArguments SanitizeBootArgs(const hal::RawBootArguments &raw_args);
 
-#endif  // ALKOS_KERNEL_INCLUDE_BOOT_ARGS_HPP_
+#endif  // KERNEL_SRC_BOOT_ARGS_HPP_
diff --git a/kernel/src/drivers/video/framebuffer.cpp b/kernel/src/drivers/video/framebuffer.cpp
new file mode 100644
index 00000000..cc116da9
--- /dev/null
+++ b/kernel/src/drivers/video/framebuffer.cpp
@@ -0,0 +1,33 @@
+#include "drivers/video/framebuffer.hpp"
+#include "defines.hpp"
+#include "mem/heap.hpp"
+#include "trace_framework.hpp"
+
+using namespace Drivers::Video;
+
+void Framebuffer::Init(Graphics::Surface s, Graphics::PixelFormat pf, Mem::Heap &hp)
+{
+    front_surface_ = s;
+    format_        = pf;
+
+    // Backbuffer allocation
+    size_t width       = front_surface_.GetWidth();
+    size_t height      = front_surface_.GetHeight();
+    size_t buffer_size = width * height * sizeof(u32);
+
+    auto alloc_res = hp.Malloc(buffer_size);
+    if (!alloc_res) {
+        TRACE_WARN_VIDEO("Backbuffer allocation failed, running in single-buffer mode");
+        return;
+    }
+
+    backbuffer_mem_ = static_cast<Mem::VPtr<u32>>(*alloc_res);
+    back_surface_   = Graphics::Surface(backbuffer_mem_, width, height, width * sizeof(u32));
+}
+
+void Framebuffer::Flush()
+{
+    if (back_surface_.IsValid()) {
+        front_surface_.CopyFrom(back_surface_);
+    }
+}
diff --git a/kernel/src/drivers/video/framebuffer.hpp b/kernel/src/drivers/video/framebuffer.hpp
new file mode 100644
index 00000000..184fffea
--- /dev/null
+++ b/kernel/src/drivers/video/framebuffer.hpp
@@ -0,0 +1,41 @@
+#ifndef KERNEL_SRC_DRIVERS_VIDEO_FRAMEBUFFER_HPP_
+#define KERNEL_SRC_DRIVERS_VIDEO_FRAMEBUFFER_HPP_
+
+#include <expected.hpp>
+#include "graphics/color.hpp"
+#include "graphics/surface.hpp"
+#include "mem/heap.hpp"
+
+namespace Drivers::Video
+{
+
+class Framebuffer
+{
+    public:
+    Framebuffer() = default;
+
+    void Init(Graphics::Surface s, Graphics::PixelFormat pf, Mem::Heap &hp);
+
+    // Swap the backbuffer to the front (physical) buffer
+    void Flush();
+
+    // Accessors
+    NODISCARD Graphics::Surface &GetSurface()
+    {
+        return back_surface_.IsValid() ? back_surface_ : front_surface_;
+    }
+    NODISCARD Graphics::Surface &GetFrontSurface() { return front_surface_; }
+    NODISCARD const Graphics::PixelFormat &GetFormat() const { return format_; }
+
+    private:
+    Graphics::Surface front_surface_{};  // Physical VRAM
+    Graphics::Surface back_surface_{};   // RAM Buffer
+    Graphics::PixelFormat format_{};
+
+    // We own the backbuffer memory
+    Mem::VPtr<u32> backbuffer_mem_{nullptr};
+};
+
+}  // namespace Drivers::Video
+
+#endif  // KERNEL_SRC_DRIVERS_VIDEO_FRAMEBUFFER_HPP_
diff --git a/kernel/src/graphics/color.hpp b/kernel/src/graphics/color.hpp
new file mode 100644
index 00000000..1b728229
--- /dev/null
+++ b/kernel/src/graphics/color.hpp
@@ -0,0 +1,38 @@
+#ifndef KERNEL_SRC_GRAPHICS_COLOR_HPP_
+#define KERNEL_SRC_GRAPHICS_COLOR_HPP_
+
+#include <defines.hpp>
+#include <types.hpp>
+
+namespace Graphics
+{
+
+struct PACK Color {
+    u8 r;
+    u8 g;
+    u8 b;
+    u8 a;
+
+    constexpr Color(u8 r, u8 g, u8 b, u8 a = 255) : r(r), g(g), b(b), a(a) {}
+    constexpr Color() : r(0), g(0), b(0), a(255) {}
+
+    static constexpr Color Red() { return {255, 0, 0, 255}; }
+    static constexpr Color Green() { return {0, 255, 0, 255}; }
+    static constexpr Color Blue() { return {0, 0, 255, 255}; }
+    static constexpr Color White() { return {255, 255, 255, 255}; }
+    static constexpr Color Black() { return {0, 0, 0, 255}; }
+};
+
+struct PixelFormat {
+    u8 red_pos;
+    u8 red_mask_size;
+    u8 green_pos;
+    u8 green_mask_size;
+    u8 blue_pos;
+    u8 blue_mask_size;
+    // We currently assume 32-bpp
+};
+
+}  // namespace Graphics
+
+#endif  // KERNEL_SRC_GRAPHICS_COLOR_HPP_
diff --git a/kernel/src/graphics/painter.cpp b/kernel/src/graphics/painter.cpp
new file mode 100644
index 00000000..4017039e
--- /dev/null
+++ b/kernel/src/graphics/painter.cpp
@@ -0,0 +1,118 @@
+#include "graphics/painter.hpp"
+#include <string.h>
+#include <algorithm.hpp>
+
+namespace Graphics
+{
+
+Painter::Painter(Surface &target, const PixelFormat &format) : target_(target), format_(format)
+{
+    ASSERT_TRUE(target_.IsValid(), "Painter initialized with invalid surface");
+    SetColor(Color::White());
+}
+
+void Painter::SetColor(Color color) { packed_color_ = PackColor(color); }
+
+u32 Painter::PackColor(Color c) const
+{
+    const u32 r_mask = (1 << format_.red_mask_size) - 1;
+    const u32 g_mask = (1 << format_.green_mask_size) - 1;
+    const u32 b_mask = (1 << format_.blue_mask_size) - 1;
+
+    return (static_cast<u32>(c.r & r_mask) << format_.red_pos) |
+           (static_cast<u32>(c.g & g_mask) << format_.green_pos) |
+           (static_cast<u32>(c.b & b_mask) << format_.blue_pos);
+}
+
+void Painter::DrawPixel(i32 x, i32 y)
+{
+    if (x < 0 || y < 0 || static_cast<u32>(x) >= target_.GetWidth() ||
+        static_cast<u32>(y) >= target_.GetHeight()) {
+        return;
+    }
+    target_.Pixel(static_cast<u32>(x), static_cast<u32>(y)) = packed_color_;
+}
+
+void Painter::FillScanline(u32 *dest, u32 count, u32 color)
+{
+    // Check for byte-repeating pattern for memset optimization
+    // e.g. 0x00000000, 0xFFFFFFFF, 0xABABABAB
+    if ((color & 0xFF) == ((color >> 8) & 0xFF) && (color & 0xFF) == ((color >> 16) & 0xFF) &&
+        (color & 0xFF) == ((color >> 24) & 0xFF)) {
+        memset(dest, color & 0xFF, count * sizeof(u32));
+    } else {
+        // Compiler auto-vectorization usually handles this loop well
+        for (u32 i = 0; i < count; ++i) {
+            dest[i] = color;
+        }
+    }
+}
+
+void Painter::Clear(Color color)
+{
+    u32 raw    = PackColor(color);
+    u32 height = target_.GetHeight();
+    u32 width  = target_.GetWidth();
+    u32 pitch  = target_.GetPitch();
+
+    // Optimization: if buffer is contiguous (pitch == width * 4 for 32bpp)
+    // we can clear it in one go.
+    if (pitch == width * sizeof(u32)) {
+        FillScanline(target_.GetScanline(0), width * height, raw);
+    } else {
+        for (u32 y = 0; y < height; ++y) {
+            FillScanline(target_.GetScanline(y), width, raw);
+        }
+    }
+}
+
+void Painter::FillRect(i32 x, i32 y, i32 w, i32 h)
+{
+    // Clipping Logic
+    if (x < 0) {
+        w += x;
+        x = 0;
+    }
+    if (y < 0) {
+        h += y;
+        y = 0;
+    }
+
+    if (static_cast<u32>(x) >= target_.GetWidth()) {
+        return;
+    }
+    if (static_cast<u32>(y) >= target_.GetHeight()) {
+        return;
+    }
+
+    // Clamp width/height to edges
+    if (static_cast<u32>(x + w) > target_.GetWidth()) {
+        w = target_.GetWidth() - x;
+    }
+    if (static_cast<u32>(y + h) > target_.GetHeight()) {
+        h = target_.GetHeight() - y;
+    }
+
+    if (w <= 0 || h <= 0) {
+        return;
+    }
+
+    for (i32 row = 0; row < h; ++row) {
+        u32 *line = target_.GetScanline(static_cast<u32>(y + row));
+        FillScanline(line + x, static_cast<u32>(w), packed_color_);
+    }
+}
+
+void Painter::DrawRect(i32 x, i32 y, i32 w, i32 h)
+{
+    // Top
+    FillRect(x, y, w, 1);
+    // Bottom
+    FillRect(x, y + h - 1, w, 1);
+    // Left
+    FillRect(x, y, 1, h);
+    // Right
+    FillRect(x + w - 1, y, 1, h);
+}
+
+}  // namespace Graphics
diff --git a/kernel/src/graphics/painter.hpp b/kernel/src/graphics/painter.hpp
new file mode 100644
index 00000000..4265af7d
--- /dev/null
+++ b/kernel/src/graphics/painter.hpp
@@ -0,0 +1,39 @@
+#ifndef KERNEL_SRC_GRAPHICS_PAINTER_HPP_
+#define KERNEL_SRC_GRAPHICS_PAINTER_HPP_
+
+#include "graphics/color.hpp"
+#include "graphics/surface.hpp"
+
+namespace Graphics
+{
+
+class Painter
+{
+    public:
+    Painter(Surface &target, const PixelFormat &format);
+
+    void SetColor(Color color);
+
+    // -------------------------------------------------------------------------
+    // Primitives
+    // -------------------------------------------------------------------------
+
+    void Clear(Color color);
+
+    // Safe drawing with clipping
+    void DrawPixel(i32 x, i32 y);
+    void DrawRect(i32 x, i32 y, i32 w, i32 h);
+    void FillRect(i32 x, i32 y, i32 w, i32 h);
+
+    private:
+    void FillScanline(u32 *dest, u32 count, u32 color);
+    NODISCARD FORCE_INLINE_F u32 PackColor(Color c) const;
+
+    Surface &target_;
+    PixelFormat format_;
+    u32 packed_color_;
+};
+
+}  // namespace Graphics
+
+#endif  // KERNEL_SRC_GRAPHICS_PAINTER_HPP_
diff --git a/kernel/src/graphics/surface.hpp b/kernel/src/graphics/surface.hpp
new file mode 100644
index 00000000..54b2dd4c
--- /dev/null
+++ b/kernel/src/graphics/surface.hpp
@@ -0,0 +1,92 @@
+#ifndef KERNEL_SRC_GRAPHICS_SURFACE_HPP_
+#define KERNEL_SRC_GRAPHICS_SURFACE_HPP_
+
+#include <assert.h>
+#include <mem/types.hpp>
+#include <types.hpp>
+
+namespace Graphics
+{
+
+/**
+ * @brief A non-owning view into a linear framebuffer or memory buffer.
+ * Assumes 32-bit pixel depth (BPP).
+ */
+class Surface
+{
+    public:
+    Surface() = default;
+
+    Surface(Mem::VPtr<u32> buffer, u32 width, u32 height, u32 pitch_bytes)
+        : buffer_(buffer), width_(width), height_(height), pitch_bytes_(pitch_bytes)
+    {
+        R_ASSERT_NOT_NULL(buffer_);
+        R_ASSERT_NOT_ZERO(width_);
+        R_ASSERT_NOT_ZERO(height_);
+        R_ASSERT_NOT_ZERO(pitch_bytes_);
+    }
+
+    // -------------------------------------------------------------------------
+    // Methods
+    // -------------------------------------------------------------------------
+
+    void CopyFrom(const Surface &src)
+    {
+        // TODO: support clipping/scaling
+        ASSERT_EQ(width_, src.width_);
+        ASSERT_EQ(height_, src.height_);
+
+        for (u32 y = 0; y < height_; ++y) {
+            u32 *dest_row      = GetScanline(y);
+            const u32 *src_row = src.GetScanline(y);
+
+            // We use the width for the copy size, not the pitch,
+            // to handle stride differences correctly.
+            memcpy(dest_row, src_row, width_ * sizeof(u32));
+        }
+    }
+
+    // -------------------------------------------------------------------------
+    // Fast Accessors
+    // -------------------------------------------------------------------------
+
+    NODISCARD FORCE_INLINE_F Mem::VPtr<u32> GetScanline(u32 y)
+    {
+        ASSERT_LT(y, height_);
+        // Pointer arithmetic on byte level for pitch
+        uptr addr = Mem::PtrToUptr(buffer_) + (static_cast<size_t>(y) * pitch_bytes_);
+        return Mem::UptrToPtr<u32>(addr);
+    }
+
+    NODISCARD FORCE_INLINE_F const Mem::VPtr<u32> GetScanline(u32 y) const
+    {
+        ASSERT_LT(y, height_);
+        uptr addr = Mem::PtrToUptr(buffer_) + (static_cast<size_t>(y) * pitch_bytes_);
+        return Mem::UptrToPtr<u32>(addr);
+    }
+
+    FORCE_INLINE_F u32 &Pixel(u32 x, u32 y)
+    {
+        ASSERT_LT(x, width_);
+        return GetScanline(y)[x];
+    }
+
+    // -------------------------------------------------------------------------
+    // Properties
+    // -------------------------------------------------------------------------
+
+    NODISCARD FORCE_INLINE_F u32 GetWidth() const { return width_; }
+    NODISCARD FORCE_INLINE_F u32 GetHeight() const { return height_; }
+    NODISCARD FORCE_INLINE_F u32 GetPitch() const { return pitch_bytes_; }
+    NODISCARD FORCE_INLINE_F bool IsValid() const { return buffer_ != nullptr; }
+
+    private:
+    Mem::VPtr<u32> buffer_{nullptr};
+    u32 width_{0};
+    u32 height_{0};
+    u32 pitch_bytes_{0};  // Stride in bytes
+};
+
+}  // namespace Graphics
+
+#endif  // KERNEL_SRC_GRAPHICS_SURFACE_HPP_
diff --git a/kernel/src/hal/api/boot_args.hpp b/kernel/src/hal/api/boot_args.hpp
index ab8d11b5..314a3d5f 100644
--- a/kernel/src/hal/api/boot_args.hpp
+++ b/kernel/src/hal/api/boot_args.hpp
@@ -7,14 +7,31 @@
 namespace arch
 {
 struct RawBootArguments;
-struct PACK RawBootArgumentsAPI {
+struct RawBootArgumentsAPI {
+    /// Mem Layout
     u64 kernel_start_addr;
     u64 kernel_end_addr;
 
+    /// VMem
     u64 page_table_phys_addr;
 
+    // Mem Bitmap
     u64 mem_info_bitmap_phys_addr;
     u64 mem_info_total_pages;
+
+    // Framebuffer
+    u64 fb_addr;
+    u32 fb_width;
+    u32 fb_height;
+    u32 fb_pitch;
+    u32 fb_bpp;
+
+    u8 fb_red_pos;
+    u8 fb_red_mask;
+    u8 fb_green_pos;
+    u8 fb_green_mask;
+    u8 fb_blue_pos;
+    u8 fb_blue_mask;
 };
 }  // namespace arch
 
diff --git a/kernel/src/init.cpp b/kernel/src/init.cpp
index 6e84ee6a..5a43010f 100644
--- a/kernel/src/init.cpp
+++ b/kernel/src/init.cpp
@@ -10,6 +10,7 @@
 #include "modules/hardware.hpp"
 #include "modules/memory.hpp"
 #include "modules/timing.hpp"
+#include "modules/video.hpp"
 #include "trace_framework.hpp"
 
 /* GCC CXX provided function initializing global constructors */
@@ -26,18 +27,6 @@ void KernelInit(const hal::RawBootArguments &raw_args)
     hal::ArchInit(raw_args);
 
     BootArguments args = SanitizeBootArgs(raw_args);
-    DEBUG_INFO_BOOT("Sanitized boot arguments received by kernel:");
-    DEBUG_INFO_BOOT(
-        "  Boot Arguments:\n"
-        "    kernel_start:       0x%p\n"
-        "    kernel_end:         0x%p\n"
-        "    root_page_table:    0x%p\n"
-        "    mem_bitmap:         0x%p\n"
-        "    total_page_frames:  %zu\n"
-        "    multiboot_info:     0x%p\n",
-        args.kernel_start, args.kernel_end, args.root_page_table, args.mem_bitmap,
-        args.total_page_frames, args.multiboot_info
-    );
 
     MemoryModule::Init(args);
 
@@ -65,4 +54,6 @@ void KernelInit(const hal::RawBootArguments &raw_args)
     // TimingModule::Init();
 
     MemoryModule::Get().RegisterPageFault(HardwareModule::Get());
+
+    VideoModule::Init(args, MemoryModule::Get().GetHeap());
 }
diff --git a/kernel/src/kernel.cpp b/kernel/src/kernel.cpp
index 1e863cc3..d5f2f473 100644
--- a/kernel/src/kernel.cpp
+++ b/kernel/src/kernel.cpp
@@ -8,8 +8,10 @@
 #include <hal/debug.hpp>
 
 #include "boot_args.hpp"
+#include "graphics/painter.hpp"
 #include "hal/boot_args.hpp"
 #include "mem/heap.hpp"
+#include "modules/video.hpp"
 #include "todo.hpp"
 
 extern void KernelInit(const hal::RawBootArguments &);
@@ -19,6 +21,7 @@ static void KernelRun()
     TRACE_INFO_GENERAL("Hello from AlkOS!");
     trace::DumpAllBuffersOnFailure();
     TODO_MMU_MINIMAL
+
     // static constexpr size_t kBuffSize = 256;
     // char buff[kBuffSize];
     //
@@ -26,6 +29,34 @@ static void KernelRun()
     // strftime(buff, kBuffSize, "%Y-%m-%d %H:%M:%S", localtime(&t));
     //
     // KernelTraceSuccess("Hello from AlkOS! Today we have: %s", buff);
+
+    auto &video  = VideoModule::Get();
+    auto &screen = video.GetScreen();
+    auto fmt     = video.GetFormat();
+
+    Graphics::Painter p(screen, fmt);
+
+    // Animation Loop
+    i32 x     = 0;
+    i32 y     = 0;
+    u16 speed = 1;
+    while (true) {
+        p.Clear(Graphics::Color::Black());
+        p.SetColor(Graphics::Color::Green());
+        p.FillRect(x, 100, 50, 50);
+        p.SetColor(Graphics::Color::Blue());
+        p.FillRect(100, y, 70, 70);
+        video.Flush();
+
+        x += (speed / 255) + 1;
+        y += (speed / 255) + 1;
+        x = x % screen.GetWidth();
+        y = y % screen.GetHeight();
+
+        // crude delay
+        for (volatile int i = 0; i < 1000000; i++);
+        speed = speed + 80;
+    }
 }
 
 extern "C" void KernelMain(const hal::RawBootArguments *raw_args)
diff --git a/kernel/src/modules/video.cpp b/kernel/src/modules/video.cpp
new file mode 100644
index 00000000..49782801
--- /dev/null
+++ b/kernel/src/modules/video.cpp
@@ -0,0 +1,36 @@
+#include "modules/video.hpp"
+#include "graphics/painter.hpp"
+#include "mem/types.hpp"
+#include "trace_framework.hpp"
+
+using namespace Graphics;
+using namespace Drivers;
+using namespace Mem;
+
+internal::VideoModule::VideoModule(const BootArguments &args, Heap &hp) noexcept
+{
+    DEBUG_INFO_GENERAL("VideoModule::VideoModule()");
+
+    const auto &fb_args = args.fb_args;
+    auto *fb_pptr       = static_cast<PPtr<u32>>(fb_args.base_address);
+
+    R_ASSERT_NOT_NULL(fb_pptr, "VideoModule: Framebuffer is null");
+
+    auto s  = Surface(Mem::PhysToVirt(fb_pptr), fb_args.width, fb_args.height, fb_args.pitch);
+    auto pf = PixelFormat{
+        .red_pos         = fb_args.red_pos,
+        .red_mask_size   = fb_args.red_mask_size,
+        .green_pos       = fb_args.green_pos,
+        .green_mask_size = fb_args.green_mask_size,
+        .blue_pos        = fb_args.blue_pos,
+        .blue_mask_size  = fb_args.blue_mask_size,
+    };
+
+    Framebuffer_.Init(s, pf, hp);
+    Graphics::Surface &screen = GetScreen();
+    R_ASSERT_TRUE(screen.IsValid());
+
+    Graphics::Painter p(screen, Framebuffer_.GetFormat());
+    p.Clear(Graphics::Color::Black());
+    Flush();
+}
diff --git a/kernel/src/modules/video.hpp b/kernel/src/modules/video.hpp
new file mode 100644
index 00000000..cdfa5639
--- /dev/null
+++ b/kernel/src/modules/video.hpp
@@ -0,0 +1,34 @@
+#ifndef KERNEL_SRC_MODULES_VIDEO_HPP_
+#define KERNEL_SRC_MODULES_VIDEO_HPP_
+
+#include <template_lib.hpp>
+
+#include "boot_args.hpp"
+#include "drivers/video/framebuffer.hpp"
+#include "modules/helpers.hpp"
+
+namespace internal
+{
+
+class VideoModule : template_lib::StaticSingletonHelper
+{
+    protected:
+    explicit VideoModule(const BootArguments &args, Mem::Heap &hp) noexcept;
+
+    DEFINE_MODULE_FIELD(Drivers::Video, Framebuffer);
+
+    public:
+    /// Returns the Surface for the physical screen
+    Graphics::Surface &GetScreen() { return Framebuffer_.GetSurface(); }
+
+    /// Returns the format required by the hardware (used to init Painters)
+    const Graphics::PixelFormat &GetFormat() const { return Framebuffer_.GetFormat(); }
+
+    void Flush() { Framebuffer_.Flush(); }
+};
+
+}  // namespace internal
+
+using VideoModule = template_lib::StaticSingleton<internal::VideoModule>;
+
+#endif  // KERNEL_SRC_MODULES_VIDEO_HPP_
diff --git a/kernel/src/trace_framework.hpp b/kernel/src/trace_framework.hpp
index 350902cb..d49f37ac 100644
--- a/kernel/src/trace_framework.hpp
+++ b/kernel/src/trace_framework.hpp
@@ -38,6 +38,7 @@ enum class TraceModule {
     kGeneral,
     kTime,
     kLast,
+    kVideo,
 };
 
 // ------------------------------
@@ -99,6 +100,10 @@ CREATE_TRACE_HELPERS(kGeneral, GENERAL)
 CREATE_DEBUG_HELPERS(kTime, TIME)
 CREATE_TRACE_HELPERS(kTime, TIME)
 
+// VIDEO
+CREATE_DEBUG_HELPERS(kVideo, VIDEO)
+CREATE_TRACE_HELPERS(kVideo, VIDEO)
+
 #include "trace_framework.tpp"
 
 #endif  // KERNEL_SRC_TRACE_FRAMEWORK_HPP_

From b1064d0b71f33b541a19e7dbff87db74d0ba079d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C5=81ukasz=20Kryczka?=
 <60490378+kryczkal@users.noreply.github.com>
Date: Sun, 7 Dec 2025 17:39:28 +0100
Subject: [PATCH 03/56] Kryczkal/console-01 (#228)

## Problem
There is no way to display text on the screen

## Solution
Implement font support in the kernel,
`Font` is a concept of an object that returns `Glyphs`
`Glyphs` are bitmaps of speciifc "characters". These are then handled by
`Painter` to draw them on a `Surfrace`.
- Added support for PSF2 type fonts, so they can be easily added to the
kernel.
 - Added drdos8x8 as a font

 No truetype font support. No fancy stuff. Just plain old bitmasks


<img width="1384" height="888" alt="image"
src="https://github.com/user-attachments/assets/d2031e9a-ebc4-4f63-9e37-1b782a7cd9a6"
/>
<img width="1290" height="914" alt="image"
src="https://github.com/user-attachments/assets/c3cef99b-65b0-4fef-a449-54671a4f2a57"
/>

## Note
This is not an implementation of a Console yet. A console would be a
`Writer` that you just put text into and don't care about where it's
gonna be on screen, at what position to display it etc.
This is just adding `DrawString` to `Painter` class.

Console is still on the way
---
 .concat.conf                                  |   2 -
 kernel/src/graphics/font/glyph.hpp            |  23 ++
 kernel/src/graphics/font/psf2_font.hpp        |  94 +++++
 kernel/src/graphics/fonts/drdos8x8.hpp        | 321 ++++++++++++++++++
 kernel/src/graphics/geometry.hpp              |  38 +++
 kernel/src/graphics/painter.cpp               |  29 +-
 kernel/src/graphics/painter.hpp               |  41 ++-
 kernel/src/graphics/painter.tpp               |  70 ++++
 kernel/src/io/register.hpp                    |  10 +-
 kernel/src/kernel.cpp                         |  33 +-
 .../data_structures/array_structures.hpp      |  16 +-
 11 files changed, 646 insertions(+), 31 deletions(-)
 delete mode 100644 .concat.conf
 create mode 100644 kernel/src/graphics/font/glyph.hpp
 create mode 100644 kernel/src/graphics/font/psf2_font.hpp
 create mode 100644 kernel/src/graphics/fonts/drdos8x8.hpp
 create mode 100644 kernel/src/graphics/geometry.hpp
 create mode 100644 kernel/src/graphics/painter.tpp

diff --git a/.concat.conf b/.concat.conf
deleted file mode 100644
index eb1182c1..00000000
--- a/.concat.conf
+++ /dev/null
@@ -1,2 +0,0 @@
-alkos/
-scripts/
diff --git a/kernel/src/graphics/font/glyph.hpp b/kernel/src/graphics/font/glyph.hpp
new file mode 100644
index 00000000..5a5d5b17
--- /dev/null
+++ b/kernel/src/graphics/font/glyph.hpp
@@ -0,0 +1,23 @@
+#ifndef KERNEL_SRC_GRAPHICS_FONT_GLYPH_HPP_
+#define KERNEL_SRC_GRAPHICS_FONT_GLYPH_HPP_
+
+#include <types.hpp>
+
+namespace Graphics
+{
+
+/**
+ * @brief Represents a lightweight view into a specific character's bitmap data.
+ * This struct does not own the memory.
+ */
+struct Glyph {
+    const byte *buffer;  // Pointer to the raw bitmap bits
+    u32 width;           // Width of the glyph in pixels
+    u32 height;          // Height of the glyph in pixels
+    u32 stride;          // Number of bytes per row in the buffer
+    u32 advance;         // Horizontal pixels to advance cursor after drawing
+};
+
+}  // namespace Graphics
+
+#endif  // KERNEL_SRC_GRAPHICS_FONT_GLYPH_HPP_
diff --git a/kernel/src/graphics/font/psf2_font.hpp b/kernel/src/graphics/font/psf2_font.hpp
new file mode 100644
index 00000000..491ff543
--- /dev/null
+++ b/kernel/src/graphics/font/psf2_font.hpp
@@ -0,0 +1,94 @@
+#ifndef KERNEL_SRC_GRAPHICS_FONT_PSF2_FONT_HPP_
+#define KERNEL_SRC_GRAPHICS_FONT_PSF2_FONT_HPP_
+
+#include <assert.h>
+#include <defines.hpp>
+#include <span.hpp>
+#include <types.hpp>
+#include "graphics/font/glyph.hpp"
+
+namespace Graphics
+{
+
+/**
+ * @brief PC Screen Font v2 Header Layout
+ */
+struct PACK Psf2Header {
+    u32 magic;        // Magic bytes: 0x864ab572 (Little Endian)
+    u32 version;      // Zero
+    u32 header_size;  // Offset to glyphs
+    u32 flags;        // Font flags
+    u32 length;       // Number of glyphs
+    u32 char_size;    // Number of bytes per glyph
+    u32 height;       // Height in pixels
+    u32 width;        // Width in pixels
+};
+
+/**
+ * @brief Zero-overhead parser for PSF2 font data.
+ * @note This class does not own the data buffer.
+ */
+class Psf2Font
+{
+    public:
+    static constexpr u32 kPsf2Magic = 0x864ab572;
+
+    constexpr Psf2Font(std::span<const u8> data) : data_(data)
+    {
+        // TODO: In a constexpr context, static assert
+        // TODO: Runtime checks can be added if instantiated dynamically.
+    }
+
+    [[nodiscard]] FORCE_INLINE_F const Psf2Header &Header() const
+    {
+        return *reinterpret_cast<const Psf2Header *>(data_.data());
+    }
+
+    [[nodiscard]] bool IsValid() const
+    {
+        if (data_.size() < sizeof(Psf2Header)) {
+            return false;
+        }
+        return Header().magic == kPsf2Magic;
+    }
+
+    [[nodiscard]] FORCE_INLINE_F u32 GetWidth() const { return Header().width; }
+    [[nodiscard]] FORCE_INLINE_F u32 GetHeight() const { return Header().height; }
+
+    /**
+     * @brief Retrieves the bitmap view for a specific character.
+     * @param c The character code (ASCII/Extended ASCII).
+     * @return Glyph structure containing geometry and data pointer.
+     */
+    [[nodiscard]] Glyph GetGlyph(char c) const
+    {
+        const auto &hdr = Header();
+        u32 index       = static_cast<u8>(c);
+
+        // Fallback for out of range
+        if (index >= hdr.length) {
+            index = 0;
+        }
+
+        const u8 *glyph_start = data_.data() + hdr.header_size + (index * hdr.char_size);
+
+        // PSF2 rows are byte-aligned.
+        // Stride = ceil(width / 8)
+        u32 stride = (hdr.width + 7) >> 3;
+
+        return Glyph{
+            .buffer  = glyph_start,
+            .width   = hdr.width,
+            .height  = hdr.height,
+            .stride  = stride,
+            .advance = hdr.width  // PSF2 is fundamentally a fixed-width format
+        };
+    }
+
+    private:
+    std::span<const u8> data_;
+};
+
+}  // namespace Graphics
+
+#endif  // KERNEL_SRC_GRAPHICS_FONT_PSF2_FONT_HPP_
diff --git a/kernel/src/graphics/fonts/drdos8x8.hpp b/kernel/src/graphics/fonts/drdos8x8.hpp
new file mode 100644
index 00000000..59e49902
--- /dev/null
+++ b/kernel/src/graphics/fonts/drdos8x8.hpp
@@ -0,0 +1,321 @@
+#ifndef KERNEL_SRC_GRAPHICS_FONTS_DRDOS8X8_HPP_
+#define KERNEL_SRC_GRAPHICS_FONTS_DRDOS8X8_HPP_
+
+// Converted via `xxd -i`
+static constexpr unsigned char drdos8x8_psfu[] = {
+    0x72, 0xb5, 0x4a, 0x86, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0xc0, 0x01, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7e, 0x81, 0xa5, 0x81, 0xbd, 0x99, 0x81, 0x7e,
+    0x7e, 0xff, 0xdb, 0xff, 0xc3, 0xe7, 0xff, 0x7e, 0x6c, 0xfe, 0xfe, 0xfe, 0x7c, 0x38, 0x10, 0x00,
+    0x10, 0x38, 0x7c, 0xfe, 0x7c, 0x38, 0x10, 0x00, 0x18, 0x3c, 0x3c, 0xe7, 0xe7, 0x18, 0x3c, 0x00,
+    0x10, 0x38, 0x7c, 0xfe, 0x7c, 0x10, 0x38, 0x00, 0x00, 0x00, 0x18, 0x3c, 0x18, 0x00, 0x00, 0x00,
+    0xff, 0xff, 0xe7, 0xc3, 0xe7, 0xff, 0xff, 0xff, 0x00, 0x00, 0x18, 0x24, 0x18, 0x00, 0x00, 0x00,
+    0xff, 0xff, 0xe7, 0xdb, 0xe7, 0xff, 0xff, 0xff, 0x1c, 0x0c, 0x10, 0x7c, 0x82, 0x82, 0x7c, 0x00,
+    0x7c, 0x82, 0x82, 0x7c, 0x10, 0x38, 0x10, 0x00, 0x00, 0x1f, 0x1e, 0x10, 0x10, 0xf0, 0xe0, 0x00,
+    0x00, 0x3e, 0x3e, 0x22, 0x2e, 0xec, 0xc0, 0x00, 0x10, 0x54, 0x38, 0x6c, 0x38, 0x54, 0x10, 0x00,
+    0x00, 0x40, 0x70, 0x7c, 0x70, 0x40, 0x00, 0x00, 0x00, 0x04, 0x1c, 0x7c, 0x1c, 0x04, 0x00, 0x00,
+    0x18, 0x3c, 0x7e, 0x18, 0x18, 0x7e, 0x3c, 0x18, 0x28, 0x28, 0x28, 0x28, 0x28, 0x00, 0x28, 0x00,
+    0x7f, 0xdb, 0xdb, 0x5b, 0x1b, 0x1b, 0x1b, 0x1b, 0x3c, 0x42, 0x78, 0x24, 0x24, 0x1e, 0x42, 0x3c,
+    0x00, 0x00, 0x00, 0x00, 0xfe, 0xfe, 0xfe, 0x00, 0x18, 0x3c, 0x7e, 0x18, 0x7e, 0x3c, 0x18, 0x7e,
+    0x18, 0x3c, 0x7e, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 0x7e, 0x3c, 0x18,
+    0x00, 0x18, 0x0c, 0xfe, 0x0c, 0x18, 0x00, 0x00, 0x00, 0x30, 0x60, 0xfe, 0x60, 0x30, 0x00, 0x00,
+    0x00, 0x00, 0xc0, 0xc0, 0xc0, 0xfe, 0x00, 0x00, 0x00, 0x24, 0x66, 0xff, 0x66, 0x24, 0x00, 0x00,
+    0x00, 0x18, 0x18, 0x3c, 0x3c, 0x7e, 0x7e, 0x00, 0x00, 0x7e, 0x7e, 0x3c, 0x3c, 0x18, 0x18, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x3c, 0x3c, 0x18, 0x18, 0x00, 0x18, 0x00,
+    0x6c, 0x6c, 0x6c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x44, 0x44, 0xfe, 0x44, 0xfe, 0x44, 0x44, 0x00,
+    0x30, 0x7c, 0xc0, 0x78, 0x0c, 0xf8, 0x30, 0x00, 0x00, 0xc6, 0xcc, 0x18, 0x30, 0x66, 0xc6, 0x00,
+    0x38, 0x6c, 0x38, 0x76, 0xdc, 0xcc, 0x76, 0x00, 0x70, 0x30, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x18, 0x30, 0x60, 0x60, 0x60, 0x30, 0x18, 0x00, 0x60, 0x30, 0x18, 0x18, 0x18, 0x30, 0x60, 0x00,
+    0x00, 0xcc, 0x78, 0xfe, 0x78, 0xcc, 0x00, 0x00, 0x00, 0x30, 0x30, 0xfc, 0x30, 0x30, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x30, 0x60, 0x00, 0x00, 0x00, 0xfc, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x30, 0x00, 0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0, 0x80, 0x00,
+    0x7c, 0xc6, 0xce, 0xd6, 0xe6, 0xc6, 0x7c, 0x00, 0x30, 0x70, 0x30, 0x30, 0x30, 0x30, 0xfc, 0x00,
+    0x78, 0xcc, 0x0c, 0x38, 0x60, 0xc0, 0xfc, 0x00, 0x78, 0xcc, 0x0c, 0x38, 0x0c, 0xcc, 0x78, 0x00,
+    0x1c, 0x34, 0x6c, 0xcc, 0xfe, 0x0c, 0x0c, 0x00, 0xfc, 0xc0, 0xf8, 0x0c, 0x0c, 0xcc, 0x78, 0x00,
+    0x38, 0x60, 0xc0, 0xf8, 0xcc, 0xcc, 0x78, 0x00, 0xfc, 0x0c, 0x0c, 0x18, 0x30, 0x60, 0x60, 0x00,
+    0x78, 0xcc, 0xcc, 0x78, 0xcc, 0xcc, 0x78, 0x00, 0x78, 0xcc, 0xcc, 0x7c, 0x0c, 0x18, 0x70, 0x00,
+    0x00, 0x00, 0x30, 0x30, 0x00, 0x30, 0x30, 0x00, 0x00, 0x00, 0x30, 0x30, 0x00, 0x70, 0x30, 0x60,
+    0x18, 0x30, 0x60, 0xc0, 0x60, 0x30, 0x18, 0x00, 0x00, 0x00, 0xfc, 0x00, 0xfc, 0x00, 0x00, 0x00,
+    0x60, 0x30, 0x18, 0x0c, 0x18, 0x30, 0x60, 0x00, 0x78, 0xcc, 0x0c, 0x18, 0x30, 0x00, 0x30, 0x00,
+    0x7c, 0x82, 0x9e, 0xb6, 0x9e, 0x80, 0x78, 0x00, 0x30, 0x78, 0xcc, 0xcc, 0xfc, 0xcc, 0xcc, 0x00,
+    0xfc, 0x66, 0x66, 0x7c, 0x66, 0x66, 0xfc, 0x00, 0x3c, 0x66, 0xc0, 0xc0, 0xc0, 0x66, 0x3c, 0x00,
+    0xf8, 0x6c, 0x66, 0x66, 0x66, 0x6c, 0xf8, 0x00, 0xfe, 0xc2, 0xc8, 0xf8, 0xc8, 0xc2, 0xfe, 0x00,
+    0xfe, 0xc2, 0xc8, 0xf8, 0xc8, 0xc0, 0xc0, 0x00, 0x3c, 0x66, 0xc0, 0xc0, 0xce, 0x66, 0x3e, 0x00,
+    0xc6, 0xc6, 0xc6, 0xfe, 0xc6, 0xc6, 0xc6, 0x00, 0x3c, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3c, 0x00,
+    0x0e, 0x06, 0x06, 0x06, 0x66, 0x66, 0x3c, 0x00, 0xc6, 0xcc, 0xd8, 0xf0, 0xd8, 0xcc, 0xc6, 0x00,
+    0xf0, 0x60, 0x60, 0x60, 0x60, 0x62, 0xfe, 0x00, 0x82, 0xc6, 0xee, 0xd6, 0xd6, 0xc6, 0xc6, 0x00,
+    0xc6, 0xe6, 0xf6, 0xde, 0xce, 0xc6, 0xc6, 0x00, 0x38, 0x6c, 0xc6, 0xc6, 0xc6, 0x6c, 0x38, 0x00,
+    0xfc, 0x66, 0x66, 0x66, 0x7c, 0x60, 0xf0, 0x00, 0x38, 0x6c, 0xc6, 0xc6, 0xd6, 0x6c, 0x3c, 0x06,
+    0xf8, 0xcc, 0xcc, 0xf8, 0xd8, 0xcc, 0xc6, 0x00, 0x7c, 0xc6, 0xe0, 0x3c, 0x06, 0xc6, 0x7c, 0x00,
+    0x7e, 0x5a, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00,
+    0xc6, 0xc6, 0xc6, 0xc6, 0x6c, 0x38, 0x10, 0x00, 0xc6, 0xc6, 0xc6, 0xd6, 0xd6, 0x6c, 0x6c, 0x00,
+    0xc6, 0xc6, 0x6c, 0x38, 0x6c, 0xc6, 0xc6, 0x00, 0x66, 0x66, 0x66, 0x3c, 0x18, 0x18, 0x18, 0x00,
+    0xfe, 0x8c, 0x18, 0x30, 0x60, 0xc2, 0xfe, 0x00, 0x3c, 0x30, 0x30, 0x30, 0x30, 0x30, 0x3c, 0x00,
+    0xc0, 0x60, 0x30, 0x18, 0x0c, 0x06, 0x02, 0x00, 0x3c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x3c, 0x00,
+    0x10, 0x38, 0x6c, 0xc6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe,
+    0x38, 0x30, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0x0c, 0x7c, 0xcc, 0x76, 0x00,
+    0xe0, 0x60, 0x7c, 0x66, 0x66, 0x66, 0xdc, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0xc0, 0xc6, 0x7c, 0x00,
+    0x1c, 0x0c, 0x7c, 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00, 0x3c, 0x66, 0x7e, 0x60, 0x3c, 0x00,
+    0x1c, 0x36, 0x30, 0x7e, 0x30, 0x30, 0x30, 0x00, 0x00, 0x00, 0x76, 0xcc, 0xcc, 0x7c, 0x0c, 0xf8,
+    0x60, 0x60, 0x7c, 0x66, 0x66, 0x66, 0x66, 0x00, 0x18, 0x00, 0x38, 0x18, 0x18, 0x18, 0x7e, 0x00,
+    0x0c, 0x00, 0x3c, 0x0c, 0x0c, 0x0c, 0x6c, 0x38, 0x60, 0x60, 0x66, 0x6c, 0x78, 0x6c, 0x66, 0x00,
+    0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x7e, 0x00, 0x00, 0x00, 0xcc, 0xfe, 0xd6, 0xd6, 0xc6, 0x00,
+    0x00, 0x00, 0xdc, 0x66, 0x66, 0x66, 0x66, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0x7c, 0x00,
+    0x00, 0x00, 0xdc, 0x66, 0x66, 0x7c, 0x60, 0xe0, 0x00, 0x00, 0x76, 0xcc, 0xcc, 0x7c, 0x0c, 0x0e,
+    0x00, 0x00, 0xdc, 0x66, 0x60, 0x60, 0xf0, 0x00, 0x00, 0x00, 0x3e, 0x60, 0x3c, 0x06, 0x7c, 0x00,
+    0x00, 0x30, 0x7e, 0x30, 0x30, 0x36, 0x1c, 0x00, 0x00, 0x00, 0xcc, 0xcc, 0xcc, 0xcc, 0x76, 0x00,
+    0x00, 0x00, 0x66, 0x66, 0x66, 0x3c, 0x18, 0x00, 0x00, 0x00, 0xc6, 0xd6, 0xd6, 0x6c, 0x6c, 0x00,
+    0x00, 0x00, 0xc6, 0x6c, 0x38, 0x6c, 0xc6, 0x00, 0x00, 0x00, 0x66, 0x66, 0x66, 0x3c, 0x18, 0x70,
+    0x00, 0x00, 0x7e, 0x4c, 0x18, 0x32, 0x7e, 0x00, 0x0e, 0x18, 0x18, 0x70, 0x18, 0x18, 0x0e, 0x00,
+    0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x70, 0x18, 0x18, 0x0e, 0x18, 0x18, 0x70, 0x00,
+    0x62, 0x92, 0x8c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x38, 0x6c, 0xc6, 0xc6, 0xc6, 0xfe, 0x00,
+    0x3c, 0x66, 0xc0, 0xc0, 0x66, 0x3c, 0x0c, 0x38, 0x66, 0x00, 0x66, 0x66, 0x66, 0x66, 0x7e, 0x00,
+    0x06, 0x08, 0x3c, 0x66, 0x7e, 0x60, 0x3c, 0x00, 0x18, 0x66, 0x00, 0x3c, 0x06, 0x76, 0x3e, 0x00,
+    0x66, 0x00, 0x3c, 0x06, 0x3e, 0x66, 0x3e, 0x00, 0x20, 0x10, 0x3c, 0x06, 0x3e, 0x66, 0x3e, 0x00,
+    0x08, 0x14, 0x3c, 0x06, 0x3e, 0x66, 0x3e, 0x00, 0x00, 0x00, 0x3e, 0x60, 0x60, 0x3e, 0x0c, 0x38,
+    0x18, 0x66, 0x00, 0x3c, 0x6e, 0x60, 0x3c, 0x00, 0x66, 0x00, 0x3c, 0x66, 0x7e, 0x60, 0x3c, 0x00,
+    0x20, 0x10, 0x3c, 0x66, 0x7e, 0x60, 0x3c, 0x00, 0x66, 0x00, 0x38, 0x18, 0x18, 0x18, 0x7e, 0x00,
+    0x18, 0x66, 0x00, 0x38, 0x18, 0x18, 0x7e, 0x00, 0x20, 0x10, 0x38, 0x18, 0x18, 0x18, 0x7e, 0x00,
+    0x66, 0x18, 0x3c, 0x66, 0x66, 0x7e, 0x66, 0x00, 0x3c, 0x66, 0x3c, 0x66, 0x66, 0x7e, 0x66, 0x00,
+    0x06, 0x0c, 0x7e, 0x60, 0x7c, 0x60, 0x7e, 0x00, 0x00, 0x00, 0xec, 0x12, 0x7e, 0x90, 0xee, 0x00,
+    0x3e, 0x6c, 0xcc, 0xfe, 0xcc, 0xcc, 0xce, 0x00, 0x18, 0x66, 0x00, 0x3c, 0x66, 0x66, 0x3c, 0x00,
+    0x66, 0x00, 0x3c, 0x66, 0x66, 0x66, 0x3c, 0x00, 0x60, 0x10, 0x3c, 0x66, 0x66, 0x66, 0x3c, 0x00,
+    0x18, 0x66, 0x00, 0x66, 0x66, 0x66, 0x3e, 0x00, 0x60, 0x10, 0x66, 0x66, 0x66, 0x66, 0x3e, 0x00,
+    0x66, 0x00, 0x66, 0x66, 0x66, 0x3c, 0x18, 0x70, 0x63, 0x1c, 0x36, 0x63, 0x63, 0x36, 0x1c, 0x00,
+    0x66, 0x00, 0x66, 0x66, 0x66, 0x66, 0x3c, 0x00, 0x18, 0x18, 0x3c, 0x60, 0x60, 0x3c, 0x18, 0x18,
+    0x1c, 0x36, 0x30, 0x7c, 0x30, 0x20, 0x7e, 0x00, 0x66, 0x66, 0x3c, 0x7e, 0x18, 0x7e, 0x18, 0x18,
+    0xf0, 0xd8, 0xd8, 0xfc, 0xce, 0xcc, 0xce, 0x00, 0x0e, 0x18, 0x18, 0x7e, 0x18, 0x18, 0x70, 0x00,
+    0x06, 0x08, 0x3c, 0x06, 0x3e, 0x66, 0x3e, 0x00, 0x06, 0x08, 0x38, 0x18, 0x18, 0x18, 0x7e, 0x00,
+    0x06, 0x08, 0x3c, 0x66, 0x66, 0x66, 0x3c, 0x00, 0x06, 0x08, 0x66, 0x66, 0x66, 0x66, 0x3e, 0x00,
+    0x72, 0x4e, 0x00, 0x7c, 0x66, 0x66, 0x66, 0x00, 0x32, 0x4c, 0xe6, 0xb6, 0xda, 0xce, 0xc6, 0x00,
+    0x78, 0x0c, 0x7c, 0xcc, 0x7c, 0x00, 0xfc, 0x00, 0x78, 0xcc, 0xcc, 0xcc, 0x78, 0x00, 0xfc, 0x00,
+    0x00, 0x30, 0x00, 0x30, 0x60, 0xc0, 0xcc, 0x78, 0x00, 0x00, 0x00, 0xfc, 0xc0, 0xc0, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0xfc, 0x0c, 0x0c, 0x00, 0x00, 0x80, 0x80, 0x80, 0xbc, 0x86, 0x1c, 0x30, 0x3e,
+    0x80, 0x80, 0x80, 0x8e, 0x96, 0x26, 0x3e, 0x06, 0x00, 0x30, 0x00, 0x30, 0x30, 0x78, 0x78, 0x30,
+    0x00, 0x00, 0x36, 0x6c, 0xd8, 0x6c, 0x36, 0x00, 0x00, 0x00, 0xd8, 0x6c, 0x36, 0x6c, 0xd8, 0x00,
+    0x22, 0x88, 0x22, 0x88, 0x22, 0x88, 0x22, 0x88, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa,
+    0xbb, 0xee, 0xbb, 0xee, 0xbb, 0xee, 0xbb, 0xee, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+    0x18, 0x18, 0x18, 0x18, 0xf8, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xf8, 0x18, 0xf8, 0x18, 0x18,
+    0x36, 0x36, 0x36, 0x36, 0xf6, 0x36, 0x36, 0x36, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x36, 0x36, 0x36,
+    0x00, 0x00, 0x00, 0xf8, 0x18, 0xf8, 0x18, 0x18, 0x36, 0x36, 0x36, 0xf6, 0x06, 0xf6, 0x36, 0x36,
+    0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x00, 0x00, 0x00, 0xfe, 0x06, 0xf6, 0x36, 0x36,
+    0x36, 0x36, 0x36, 0xf6, 0x06, 0xfe, 0x00, 0x00, 0x36, 0x36, 0x36, 0x36, 0xfe, 0x00, 0x00, 0x00,
+    0x18, 0x18, 0x18, 0xf8, 0x18, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x18, 0x18, 0x18,
+    0x18, 0x18, 0x18, 0x18, 0x1f, 0x00, 0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 0xff, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0xff, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x1f, 0x18, 0x18, 0x18,
+    0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 0xff, 0x18, 0x18, 0x18,
+    0x18, 0x18, 0x18, 0x1f, 0x18, 0x1f, 0x18, 0x18, 0x36, 0x36, 0x36, 0x36, 0x37, 0x36, 0x36, 0x36,
+    0x36, 0x36, 0x36, 0x37, 0x30, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x30, 0x37, 0x36, 0x36,
+    0x36, 0x36, 0x36, 0xf7, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xf7, 0x36, 0x36,
+    0x36, 0x36, 0x36, 0x37, 0x30, 0x37, 0x36, 0x36, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00,
+    0x36, 0x36, 0x36, 0xf7, 0x00, 0xf7, 0x36, 0x36, 0x18, 0x18, 0x18, 0xff, 0x00, 0xff, 0x00, 0x00,
+    0x36, 0x36, 0x36, 0x36, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x18, 0x18,
+    0x00, 0x00, 0x00, 0x00, 0xff, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x3f, 0x00, 0x00, 0x00,
+    0x18, 0x18, 0x18, 0x1f, 0x18, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x18, 0x1f, 0x18, 0x18,
+    0x00, 0x00, 0x00, 0x00, 0x3f, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0xff, 0x36, 0x36, 0x36,
+    0x18, 0x18, 0x18, 0xff, 0x18, 0xff, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xf8, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x1f, 0x18, 0x18, 0x18, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0,
+    0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x76, 0xdc, 0xc8, 0xdc, 0x76, 0x00, 0x78, 0xcc, 0xd8, 0xcc, 0xcc, 0xf8, 0xc0, 0xc0,
+    0xfe, 0xc6, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0x00, 0x00, 0x00, 0xfe, 0x6c, 0x6c, 0x6c, 0x66, 0x00,
+    0xfe, 0x60, 0x30, 0x18, 0x30, 0x60, 0xfe, 0x00, 0x00, 0x00, 0x7e, 0xc8, 0xcc, 0xcc, 0x78, 0x00,
+    0x00, 0x00, 0xcc, 0xcc, 0xcc, 0xf8, 0xc0, 0x80, 0x00, 0x00, 0xfe, 0x30, 0x30, 0x30, 0x1c, 0x00,
+    0x3c, 0x18, 0x7e, 0xc3, 0x7e, 0x18, 0x3c, 0x00, 0x38, 0x6c, 0xc6, 0xfe, 0xc6, 0x6c, 0x38, 0x00,
+    0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0x6c, 0xee, 0x00, 0x1c, 0x30, 0x18, 0x7c, 0xcc, 0xcc, 0x78, 0x00,
+    0x00, 0x00, 0x66, 0xdb, 0xdb, 0x66, 0x00, 0x00, 0x03, 0x06, 0x7e, 0xdb, 0xdb, 0x7e, 0x60, 0xc0,
+    0x3c, 0x60, 0xc0, 0xfc, 0xc0, 0x60, 0x3c, 0x00, 0x78, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0x00,
+    0x00, 0xfc, 0x00, 0xfc, 0x00, 0xfc, 0x00, 0x00, 0x30, 0x30, 0xfc, 0x30, 0x30, 0x00, 0xfc, 0x00,
+    0x60, 0x30, 0x1c, 0x30, 0x60, 0x00, 0xfc, 0x00, 0x18, 0x30, 0xe0, 0x30, 0x18, 0x00, 0xfc, 0x00,
+    0x0e, 0x1b, 0x1b, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xd8, 0xd8, 0x70,
+    0x30, 0x30, 0x00, 0xfc, 0x00, 0x30, 0x30, 0x00, 0x00, 0x72, 0x9c, 0x00, 0x72, 0x9c, 0x00, 0x00,
+    0x38, 0x6c, 0x6c, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x30, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x08, 0x08, 0x88, 0xc8, 0x68, 0x38, 0x18,
+    0x78, 0x6c, 0x6c, 0x6c, 0x6c, 0x00, 0x00, 0x00, 0x78, 0x0c, 0x38, 0x60, 0x7c, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x78, 0x78, 0x78, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x06, 0x7c, 0xce, 0xd6, 0xe6, 0x7c, 0xc0, 0x06, 0x7c, 0xce, 0xde, 0xf6, 0xe6, 0x7c, 0xc0,
+    0x00, 0x00, 0x44, 0x6c, 0x38, 0x6c, 0x44, 0x00, 0x7e, 0x81, 0xb9, 0xad, 0xb9, 0xa5, 0x81, 0x7e,
+    0x30, 0x60, 0x30, 0x78, 0xcc, 0xfc, 0xcc, 0x00, 0x78, 0xcc, 0x30, 0x78, 0xcc, 0xfc, 0xcc, 0x00,
+    0x30, 0x18, 0x30, 0x78, 0xcc, 0xfc, 0xcc, 0x00, 0x7e, 0x81, 0x9d, 0xa1, 0xa1, 0x9d, 0x81, 0x7e,
+    0x72, 0x4e, 0x00, 0x3c, 0x06, 0x76, 0x3e, 0x00, 0x72, 0x4e, 0x18, 0x3c, 0x66, 0x7e, 0x66, 0x00,
+    0x42, 0x3c, 0x66, 0x66, 0x66, 0x3c, 0x42, 0x00, 0x34, 0x18, 0x2c, 0x06, 0x7e, 0xc6, 0x7c, 0x00,
+    0xf8, 0x6c, 0x66, 0xf6, 0x66, 0x6c, 0xf8, 0x00, 0x38, 0x6c, 0xfe, 0xc0, 0xf8, 0xc0, 0xfe, 0x00,
+    0xc6, 0x00, 0xfe, 0xc0, 0xf8, 0xc0, 0xfe, 0x00, 0x30, 0x18, 0xfe, 0xc0, 0xf8, 0xc0, 0xfe, 0x00,
+    0x00, 0x00, 0x00, 0x10, 0x30, 0x10, 0x38, 0x00, 0x0c, 0x18, 0x3c, 0x18, 0x18, 0x18, 0x3c, 0x00,
+    0x3c, 0x66, 0x3c, 0x18, 0x18, 0x18, 0x3c, 0x00, 0x66, 0x00, 0x3c, 0x18, 0x18, 0x18, 0x3c, 0x00,
+    0x18, 0x18, 0x18, 0x00, 0x18, 0x18, 0x18, 0x00, 0x30, 0x18, 0x3c, 0x18, 0x18, 0x18, 0x3c, 0x00,
+    0x0c, 0x18, 0x7c, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x7c, 0xc6, 0x7c, 0xc6, 0xc6, 0xc6, 0x7c, 0x00,
+    0x60, 0x30, 0x7c, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x72, 0x9c, 0x00, 0x7c, 0xc6, 0xc6, 0x7c, 0x00,
+    0x72, 0x9c, 0x7c, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0xf0, 0x60, 0x7c, 0x66, 0x66, 0x7c, 0x60, 0xf0,
+    0xf0, 0x60, 0x7c, 0x66, 0x7c, 0x60, 0xf0, 0x00, 0x0c, 0x18, 0x66, 0x66, 0x66, 0x66, 0x3c, 0x00,
+    0x3c, 0x66, 0x00, 0x66, 0x66, 0x66, 0x3c, 0x00, 0x30, 0x18, 0x00, 0x66, 0x66, 0x66, 0x3c, 0x00,
+    0x0c, 0x18, 0x00, 0x66, 0x66, 0x3c, 0x18, 0x70, 0x0c, 0x18, 0x66, 0x66, 0x3c, 0x18, 0x18, 0x00,
+    0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x00, 0xfe,
+    0xc0, 0x20, 0xc0, 0x2e, 0xd6, 0x26, 0x3e, 0x06, 0x4c, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0xc6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x60, 0x20, 0x20, 0x70, 0x00, 0x00, 0x00,
+    0xe0, 0x10, 0x60, 0x10, 0xe0, 0x00, 0x00, 0x00, 0xfc, 0xc0, 0xc0, 0xfc, 0xc6, 0xc6, 0xfc, 0x00,
+    0xfe, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0x00, 0x7e, 0x66, 0x66, 0x66, 0x66, 0x66, 0xff, 0xc3,
+    0xdb, 0xdb, 0x7e, 0x18, 0x7e, 0xdb, 0xdb, 0x00, 0x3c, 0x66, 0x06, 0x3c, 0x06, 0xc6, 0x7c, 0x00,
+    0xc6, 0xce, 0xde, 0xf6, 0xe6, 0xc6, 0xc6, 0x00, 0xd6, 0xce, 0xde, 0xf6, 0xe6, 0xc6, 0xc6, 0x00,
+    0x0e, 0x1e, 0x36, 0x66, 0xc6, 0xc6, 0xc6, 0x00, 0xfe, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x00,
+    0xc6, 0xc6, 0xc6, 0x7e, 0x06, 0xc6, 0x7c, 0x00, 0x10, 0x7c, 0xd6, 0xd6, 0xd6, 0x7c, 0x10, 0x00,
+    0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xfe, 0x03, 0xc6, 0xc6, 0xc6, 0x7e, 0x06, 0x06, 0x06, 0x00,
+    0xd6, 0xd6, 0xd6, 0xd6, 0xd6, 0xd6, 0xfe, 0x00, 0xd6, 0xd6, 0xd6, 0xd6, 0xd6, 0xd6, 0xfe, 0x03,
+    0xe0, 0xe0, 0x60, 0x7c, 0x66, 0x66, 0x7c, 0x00, 0xc2, 0xc2, 0xc2, 0xf2, 0xda, 0xda, 0xf2, 0x00,
+    0xc0, 0xc0, 0xc0, 0xfc, 0xc6, 0xc6, 0xfc, 0x00, 0x7c, 0xc6, 0x06, 0x3e, 0x06, 0xc6, 0x7c, 0x00,
+    0xce, 0xdb, 0xdb, 0xfb, 0xdb, 0xdb, 0xce, 0x00, 0x7e, 0xc6, 0xc6, 0x7e, 0x36, 0x66, 0xc6, 0x00,
+    0x06, 0x7c, 0xc0, 0xfc, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0xfc, 0xc6, 0xfc, 0xc6, 0xfc, 0x00,
+    0x00, 0x00, 0xfe, 0xc0, 0xc0, 0xc0, 0xc0, 0x00, 0x00, 0x00, 0x7e, 0x66, 0x66, 0x66, 0xff, 0xc3,
+    0x00, 0x00, 0xdb, 0x7e, 0x18, 0x7e, 0xdb, 0x00, 0x00, 0x00, 0x7c, 0x86, 0x3c, 0x86, 0x7c, 0x00,
+    0x00, 0x00, 0xce, 0xde, 0xf6, 0xe6, 0xc6, 0x00, 0x38, 0x00, 0xce, 0xde, 0xf6, 0xe6, 0xc6, 0x00,
+    0x00, 0x00, 0xc6, 0xcc, 0xf8, 0xcc, 0xc6, 0x00, 0x00, 0x00, 0x1e, 0x36, 0x66, 0xc6, 0xc6, 0x00,
+    0x00, 0x00, 0x82, 0xc6, 0xee, 0xfe, 0xd6, 0x00, 0x00, 0x00, 0xc6, 0xc6, 0xfe, 0xc6, 0xc6, 0x00,
+    0x00, 0x00, 0xfe, 0xc6, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00, 0x7e, 0x18, 0x18, 0x18, 0x18, 0x00,
+    0x00, 0x00, 0xc6, 0xc6, 0x7e, 0x06, 0x7c, 0x00, 0x00, 0x10, 0x7c, 0xd6, 0xd6, 0x7c, 0x10, 0x10,
+    0x00, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xfe, 0x03, 0x00, 0x00, 0xc6, 0xc6, 0x7e, 0x06, 0x06, 0x00,
+    0x00, 0x00, 0xd6, 0xd6, 0xd6, 0xd6, 0xfe, 0x00, 0x00, 0x00, 0xd6, 0xd6, 0xd6, 0xd6, 0xfe, 0x03,
+    0x00, 0x00, 0xe0, 0xe0, 0x7c, 0x66, 0x7c, 0x00, 0x00, 0x00, 0xc2, 0xc2, 0xf2, 0xda, 0xf2, 0x00,
+    0x00, 0x00, 0xc0, 0xc0, 0xfc, 0xc6, 0xfc, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0x1e, 0xc6, 0x7c, 0x00,
+    0x00, 0x00, 0xce, 0xdb, 0xfb, 0xdb, 0xce, 0x00, 0x00, 0x00, 0x7e, 0xc6, 0x7e, 0x66, 0xc6, 0x00,
+    0x7c, 0xc6, 0xc0, 0xf8, 0xc0, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x7c, 0xc2, 0xf8, 0xc2, 0x7c, 0x00,
+    0x28, 0xc6, 0xc6, 0x7e, 0x06, 0xc6, 0x7c, 0x00, 0x96, 0xd9, 0xd6, 0xb0, 0xb7, 0x90, 0x90, 0x00,
+    0x06, 0x0e, 0x1e, 0x36, 0x7e, 0xc6, 0xc6, 0x00, 0xfc, 0x66, 0x7c, 0x66, 0x66, 0x66, 0xfc, 0x00,
+    0xfe, 0x62, 0x78, 0x60, 0x60, 0x62, 0xfe, 0x00, 0xe6, 0x6c, 0x78, 0x7c, 0x66, 0x66, 0xe6, 0x00,
+    0x82, 0xc6, 0xee, 0xfe, 0xd6, 0xd6, 0xd6, 0x00, 0xc6, 0xc6, 0xfe, 0xc6, 0xc6, 0xc6, 0xc6, 0x00,
+    0x30, 0x78, 0xcc, 0xcc, 0xcc, 0x78, 0x30, 0x00, 0xfc, 0x66, 0x7c, 0x60, 0x60, 0x60, 0xf0, 0x00,
+    0x7e, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3c, 0x00, 0x7c, 0xc6, 0xc0, 0xc0, 0xc6, 0xc6, 0x7c, 0x00,
+    0x82, 0xc6, 0x6c, 0x38, 0x6c, 0xc6, 0x82, 0x00, 0x00, 0x00, 0xfe, 0x06, 0xfe, 0xc6, 0xfe, 0x00,
+    0x00, 0x00, 0xfe, 0xc6, 0xfe, 0xc0, 0xfe, 0x00, 0x00, 0x00, 0x38, 0x6c, 0xc6, 0x6c, 0x38, 0x00,
+    0x00, 0x00, 0xfc, 0xc6, 0xfc, 0xc0, 0xc0, 0x00, 0x00, 0x00, 0xfe, 0xc2, 0xc0, 0xc2, 0xfe, 0x00,
+    0x00, 0x00, 0xc6, 0xee, 0x38, 0xee, 0xc6, 0x00, 0x00, 0x00, 0xf0, 0x60, 0x7c, 0x66, 0xfc, 0x00,
+    0x6c, 0x00, 0xc6, 0xc6, 0x7e, 0x06, 0x7c, 0x00, 0xc6, 0xc6, 0x7c, 0x6c, 0x7c, 0xc6, 0xc6, 0x00,
+    0x38, 0x6c, 0x00, 0x7c, 0xc0, 0xc0, 0x7c, 0x00, 0x7c, 0x82, 0x7c, 0xc6, 0xc0, 0xc6, 0x7c, 0x00,
+    0x00, 0x30, 0x00, 0x7c, 0xc0, 0xc0, 0x7c, 0x00, 0x18, 0x00, 0x7c, 0xc6, 0xc0, 0xc6, 0x7c, 0x00,
+    0x30, 0x00, 0x78, 0x30, 0x30, 0x30, 0x78, 0x00, 0x38, 0x6c, 0x00, 0x7e, 0xcc, 0x7c, 0x0c, 0xf8,
+    0x7c, 0x82, 0x7c, 0xc0, 0xce, 0xc6, 0x7e, 0x00, 0x1c, 0x36, 0x00, 0x1e, 0x0c, 0x0c, 0xcc, 0x78,
+    0xc6, 0x7c, 0x7c, 0xc0, 0xce, 0xc6, 0x7e, 0x00, 0x6c, 0x38, 0x00, 0x7e, 0xcc, 0x7c, 0x0c, 0xf8,
+    0x3c, 0x66, 0x00, 0x66, 0x66, 0x7e, 0x66, 0x00, 0x38, 0x6c, 0x00, 0xe0, 0x7c, 0x66, 0xe6, 0x00,
+    0x3c, 0x66, 0x1c, 0x0c, 0x0c, 0xcc, 0x78, 0x00, 0x00, 0x7c, 0xc0, 0x78, 0x0c, 0xf8, 0x30, 0xe0,
+    0x78, 0xcc, 0x60, 0x38, 0xcc, 0x78, 0x30, 0xe0, 0x38, 0x6c, 0x7e, 0xc0, 0x7c, 0x06, 0xfc, 0x00,
+    0x38, 0x6c, 0x3c, 0x60, 0x38, 0x0c, 0x78, 0x00, 0x18, 0x00, 0x7c, 0xc0, 0xce, 0xc6, 0x7e, 0x00,
+    0x00, 0x18, 0x00, 0x7e, 0xcc, 0x7c, 0x0c, 0xf8, 0x66, 0xff, 0x66, 0x7e, 0x66, 0x66, 0x66, 0x00,
+    0x60, 0xfe, 0x60, 0x7c, 0x66, 0x66, 0x66, 0x00, 0x6c, 0x38, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00,
+    0x6c, 0x38, 0x00, 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x38, 0x6c, 0x6c, 0x78, 0xe0, 0x66, 0x3c, 0x00,
+    0xc0, 0x80, 0x7c, 0x66, 0x66, 0x66, 0x66, 0x00, 0x00, 0x66, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x38, 0x18, 0x18, 0x18, 0x7e, 0x00, 0x00, 0x18, 0x00, 0x7e, 0x0c, 0x30, 0x7e, 0x00,
+    0x30, 0x00, 0xfe, 0x8c, 0x38, 0x62, 0xfe, 0x00, 0x30, 0x00, 0xcc, 0xcc, 0xcc, 0xcc, 0x76, 0x00,
+    0x08, 0x10, 0x00, 0x7c, 0xc0, 0xc0, 0x7c, 0x00, 0x38, 0x1a, 0x1c, 0x38, 0x58, 0x18, 0x7e, 0x00,
+    0x24, 0x48, 0x7c, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x24, 0x48, 0x00, 0x7c, 0xc6, 0xc6, 0x7c, 0x00,
+    0x08, 0x10, 0xfe, 0x8c, 0x38, 0x62, 0xfe, 0x00, 0x04, 0x08, 0x7c, 0xc6, 0xc0, 0xc6, 0x7c, 0x00,
+    0x20, 0x40, 0xf0, 0x60, 0x60, 0x62, 0xfe, 0x00, 0x08, 0x10, 0x38, 0x18, 0x18, 0x18, 0x7e, 0x00,
+    0x90, 0x60, 0xf0, 0x60, 0x60, 0x62, 0xfe, 0x00, 0x48, 0x30, 0x38, 0x18, 0x18, 0x18, 0x7e, 0x00,
+    0x08, 0x10, 0x7e, 0xc0, 0x7c, 0x06, 0xfc, 0x00, 0x08, 0x10, 0x3c, 0x60, 0x3c, 0x06, 0x3c, 0x00,
+    0x24, 0x18, 0x7e, 0x5a, 0x18, 0x18, 0x18, 0x00, 0x48, 0x30, 0x30, 0x7e, 0x30, 0x30, 0x1c, 0x00,
+    0x78, 0x34, 0x38, 0x70, 0xb0, 0x32, 0x7e, 0x00, 0x48, 0x30, 0x00, 0x7c, 0xc0, 0xc0, 0x7c, 0x00,
+    0x30, 0x78, 0xcc, 0xfc, 0xcc, 0xcc, 0x18, 0x0e, 0x00, 0x78, 0x0c, 0x7c, 0xcc, 0x76, 0x18, 0x0e,
+    0x48, 0x30, 0xfe, 0x8c, 0x38, 0x62, 0xfe, 0x00, 0x24, 0x18, 0x00, 0x7e, 0x0c, 0x30, 0x7e, 0x00,
+    0xfe, 0xc2, 0xf8, 0xc0, 0xc2, 0xfe, 0x18, 0x0e, 0x00, 0x3c, 0x66, 0x7e, 0x60, 0x3c, 0x18, 0x0e,
+    0x08, 0x10, 0x00, 0x7e, 0x0c, 0x30, 0x7e, 0x00, 0x44, 0x38, 0x7c, 0xc6, 0xc0, 0xc6, 0x7c, 0x00,
+    0x48, 0x30, 0xfe, 0xc2, 0xf8, 0xc2, 0xfe, 0x00, 0x48, 0x30, 0x78, 0xcc, 0xcc, 0xfc, 0xcc, 0x00,
+    0x48, 0x30, 0x78, 0x0c, 0x7c, 0xcc, 0x76, 0x00, 0x48, 0x30, 0xfc, 0x66, 0x66, 0x66, 0xfc, 0x00,
+    0x24, 0x18, 0x0c, 0x7c, 0xcc, 0xcc, 0x76, 0x00, 0x24, 0x18, 0xe6, 0xf6, 0xde, 0xce, 0xc6, 0x00,
+    0x24, 0x18, 0x3c, 0x66, 0x7e, 0x60, 0x3c, 0x00, 0x7e, 0x5a, 0x18, 0x18, 0x18, 0x18, 0x0c, 0x38,
+    0x10, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x08, 0x10, 0xe6, 0xf6, 0xde, 0xce, 0xc6, 0x00,
+    0x08, 0x10, 0xdc, 0x66, 0x66, 0x66, 0x66, 0x00, 0x24, 0x18, 0xdc, 0x66, 0x66, 0x66, 0x66, 0x00,
+    0x24, 0x18, 0x7e, 0xc0, 0x3c, 0x06, 0xfc, 0x00, 0x24, 0x18, 0x3c, 0x60, 0x3c, 0x06, 0x3c, 0x00,
+    0x10, 0x20, 0xf8, 0xcc, 0xf8, 0xcc, 0xc6, 0x00, 0x08, 0x10, 0xdc, 0x66, 0x60, 0x60, 0xf0, 0x00,
+    0x24, 0x48, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x30, 0x7e, 0x30, 0x36, 0x1c, 0x0c, 0x38,
+    0x24, 0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x1c,
+    0x24, 0x48, 0xcc, 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x90, 0x60, 0xf8, 0xcc, 0xf8, 0xcc, 0xc6, 0x00,
+    0x24, 0x18, 0xdc, 0x66, 0x60, 0x60, 0xf0, 0x00, 0x00, 0x6c, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0xff, 0x01, 0xff, 0x02, 0xff, 0x03, 0xff, 0x04, 0xff, 0x05, 0xff, 0x06, 0xff, 0x07, 0xff,
+    0x08, 0xff, 0x09, 0xff, 0x0a, 0xff, 0x0b, 0xff, 0x0c, 0xff, 0x0d, 0xff, 0x0e, 0xff, 0x0f, 0xff,
+    0x10, 0xff, 0x11, 0xff, 0x12, 0xff, 0x13, 0xff, 0x14, 0xc2, 0xb6, 0xff, 0x15, 0xc2, 0xa7, 0xff,
+    0x16, 0xff, 0x17, 0xff, 0x18, 0xff, 0x19, 0xff, 0x1a, 0xff, 0x1b, 0xff, 0x1c, 0xff, 0x1d, 0xff,
+    0x1e, 0xff, 0x1f, 0xff, 0x20, 0xc2, 0xa0, 0xe2, 0x80, 0x80, 0xe2, 0x80, 0x81, 0xe2, 0x80, 0x82,
+    0xe2, 0x80, 0x83, 0xe2, 0x80, 0x84, 0xe2, 0x80, 0x85, 0xe2, 0x80, 0x86, 0xe2, 0x80, 0x87, 0xe2,
+    0x80, 0x88, 0xe2, 0x80, 0x89, 0xe2, 0x80, 0x8a, 0xe2, 0x80, 0xaf, 0xff, 0x21, 0xff, 0x22, 0xff,
+    0x23, 0xff, 0x24, 0xff, 0x25, 0xff, 0x26, 0xff, 0x27, 0xff, 0x28, 0xff, 0x29, 0xff, 0x2a, 0xff,
+    0x2b, 0xff, 0x2c, 0xff, 0x2d, 0xff, 0x2e, 0xff, 0x2f, 0xff, 0x30, 0xff, 0x31, 0xff, 0x32, 0xff,
+    0x33, 0xff, 0x34, 0xff, 0x35, 0xff, 0x36, 0xff, 0x37, 0xff, 0x38, 0xff, 0x39, 0xff, 0x3a, 0xff,
+    0x3b, 0xff, 0x3c, 0xff, 0x3d, 0xff, 0x3e, 0xff, 0x3f, 0xff, 0x40, 0xff, 0x41, 0xff, 0x42, 0xff,
+    0x43, 0xff, 0x44, 0xff, 0x45, 0xff, 0x46, 0xff, 0x47, 0xff, 0x48, 0xff, 0x49, 0xff, 0x4a, 0xff,
+    0x4b, 0xff, 0x4c, 0xff, 0x4d, 0xff, 0x4e, 0xff, 0x4f, 0xff, 0x50, 0xff, 0x51, 0xff, 0x52, 0xff,
+    0x53, 0xff, 0x54, 0xff, 0x55, 0xff, 0x56, 0xff, 0x57, 0xff, 0x58, 0xff, 0x59, 0xff, 0x5a, 0xff,
+    0x5b, 0xff, 0x5c, 0xff, 0x5d, 0xff, 0x5e, 0xff, 0x5f, 0xff, 0x60, 0xff, 0x61, 0xff, 0x62, 0xff,
+    0x63, 0xff, 0x64, 0xff, 0x65, 0xff, 0x66, 0xff, 0x67, 0xff, 0x68, 0xff, 0x69, 0xff, 0x6a, 0xff,
+    0x6b, 0xff, 0x6c, 0xff, 0x6d, 0xff, 0x6e, 0xff, 0x6f, 0xff, 0x70, 0xff, 0x71, 0xff, 0x72, 0xff,
+    0x73, 0xff, 0x74, 0xff, 0x75, 0xff, 0x76, 0xff, 0x77, 0xff, 0x78, 0xff, 0x79, 0xff, 0x7a, 0xff,
+    0x7b, 0xff, 0x7c, 0xff, 0x7d, 0xff, 0x7e, 0xff, 0x7f, 0xff, 0xc3, 0x87, 0xff, 0xc3, 0xbc, 0xff,
+    0xc3, 0xa9, 0xff, 0xc3, 0xa2, 0xff, 0xc3, 0xa4, 0xff, 0xc3, 0xa0, 0xff, 0xc3, 0xa5, 0xff, 0xc3,
+    0xa7, 0xff, 0xc3, 0xaa, 0xff, 0xc3, 0xab, 0xd1, 0x91, 0xff, 0xc3, 0xa8, 0xff, 0xc3, 0xaf, 0xd1,
+    0x97, 0xff, 0xc3, 0xae, 0xff, 0xc3, 0xac, 0xff, 0xc3, 0x84, 0xff, 0xc3, 0x85, 0xff, 0xc3, 0x89,
+    0xff, 0xc3, 0xa6, 0xff, 0xc3, 0x86, 0xff, 0xc3, 0xb4, 0xff, 0xc3, 0xb6, 0xff, 0xc3, 0xb2, 0xff,
+    0xc3, 0xbb, 0xff, 0xc3, 0xb9, 0xff, 0xc3, 0xbf, 0xff, 0xc3, 0x96, 0xff, 0xc3, 0x9c, 0xff, 0xc2,
+    0xa2, 0xff, 0xc2, 0xa3, 0xff, 0xc2, 0xa5, 0xff, 0xe2, 0x82, 0xa7, 0xff, 0xc6, 0x92, 0xff, 0xc3,
+    0xa1, 0xff, 0xc3, 0xad, 0xff, 0xc3, 0xb3, 0xff, 0xc3, 0xba, 0xff, 0xc3, 0xb1, 0xff, 0xc3, 0x91,
+    0xff, 0xc2, 0xaa, 0xff, 0xc2, 0xba, 0xff, 0xc2, 0xbf, 0xff, 0xe2, 0x8c, 0x90, 0xff, 0xc2, 0xac,
+    0xff, 0xc2, 0xbd, 0xff, 0xc2, 0xbc, 0xff, 0xc2, 0xa1, 0xff, 0xc2, 0xab, 0xff, 0xc2, 0xbb, 0xff,
+    0xe2, 0x96, 0x91, 0xff, 0xe2, 0x96, 0x92, 0xff, 0xe2, 0x96, 0x93, 0xff, 0xe2, 0x94, 0x82, 0xff,
+    0xe2, 0x94, 0xa4, 0xff, 0xe2, 0x95, 0xa1, 0xff, 0xe2, 0x95, 0xa2, 0xff, 0xe2, 0x95, 0x96, 0xff,
+    0xe2, 0x95, 0x95, 0xff, 0xe2, 0x95, 0xa3, 0xff, 0xe2, 0x95, 0x91, 0xff, 0xe2, 0x95, 0x97, 0xff,
+    0xe2, 0x95, 0x9d, 0xff, 0xe2, 0x95, 0x9c, 0xff, 0xe2, 0x95, 0x9b, 0xff, 0xe2, 0x94, 0x90, 0xff,
+    0xe2, 0x94, 0x94, 0xff, 0xe2, 0x94, 0xb4, 0xff, 0xe2, 0x94, 0xac, 0xff, 0xe2, 0x94, 0x9c, 0xff,
+    0xe2, 0x94, 0x80, 0xff, 0xe2, 0x94, 0xbc, 0xff, 0xe2, 0x95, 0x9e, 0xff, 0xe2, 0x95, 0x9f, 0xff,
+    0xe2, 0x95, 0x9a, 0xff, 0xe2, 0x95, 0x94, 0xff, 0xe2, 0x95, 0xa9, 0xff, 0xe2, 0x95, 0xa6, 0xff,
+    0xe2, 0x95, 0xa0, 0xff, 0xe2, 0x95, 0x90, 0xff, 0xe2, 0x95, 0xac, 0xff, 0xe2, 0x95, 0xa7, 0xff,
+    0xe2, 0x95, 0xa8, 0xff, 0xe2, 0x95, 0xa4, 0xff, 0xe2, 0x95, 0xa5, 0xff, 0xe2, 0x95, 0x99, 0xff,
+    0xe2, 0x95, 0x98, 0xff, 0xe2, 0x95, 0x92, 0xff, 0xe2, 0x95, 0x93, 0xff, 0xe2, 0x95, 0xab, 0xff,
+    0xe2, 0x95, 0xaa, 0xff, 0xe2, 0x94, 0x98, 0xff, 0xe2, 0x94, 0x8c, 0xff, 0xe2, 0x96, 0x88, 0xff,
+    0xe2, 0x96, 0x84, 0xff, 0xe2, 0x96, 0x8c, 0xff, 0xe2, 0x96, 0x90, 0xff, 0xe2, 0x96, 0x80, 0xff,
+    0xce, 0xb1, 0xff, 0xc3, 0x9f, 0xff, 0xce, 0x93, 0xff, 0xcf, 0x80, 0xff, 0xce, 0xa3, 0xff, 0xcf,
+    0x83, 0xff, 0xc2, 0xb5, 0xff, 0xcf, 0x84, 0xff, 0xce, 0xa6, 0xff, 0xce, 0x98, 0xff, 0xce, 0xa9,
+    0xff, 0xce, 0xb4, 0xff, 0xe2, 0x88, 0x9e, 0xff, 0xcf, 0x86, 0xe2, 0x88, 0x85, 0xff, 0xce, 0xb5,
+    0xff, 0xe2, 0x88, 0xa9, 0xff, 0xe2, 0x89, 0xa1, 0xff, 0xc2, 0xb1, 0xff, 0xe2, 0x89, 0xa5, 0xff,
+    0xe2, 0x89, 0xa4, 0xff, 0xe2, 0x8c, 0xa0, 0xff, 0xe2, 0x8c, 0xa1, 0xff, 0xc3, 0xb7, 0xff, 0xe2,
+    0x89, 0x88, 0xff, 0xc2, 0xb0, 0xe2, 0x88, 0x98, 0xff, 0xc2, 0xb7, 0xe2, 0x88, 0x99, 0xff, 0xc2,
+    0xb7, 0xcb, 0x99, 0xe2, 0x80, 0xa2, 0xff, 0xe2, 0x88, 0x9a, 0xff, 0xe2, 0x81, 0xbf, 0xff, 0xc2,
+    0xb2, 0xff, 0xe2, 0x96, 0xa0, 0xff, 0xc2, 0xa0, 0xff, 0xc3, 0xb8, 0xff, 0xc3, 0x98, 0xff, 0xc3,
+    0x97, 0xff, 0xc2, 0xae, 0xff, 0xc3, 0x81, 0xff, 0xc3, 0x82, 0xff, 0xc3, 0x80, 0xff, 0xc2, 0xa9,
+    0xff, 0xc3, 0xa3, 0xff, 0xc3, 0x83, 0xff, 0xc2, 0xa4, 0xc2, 0xbb, 0xff, 0xc3, 0xb0, 0xc4, 0x91,
+    0xff, 0xc3, 0x90, 0xc4, 0x90, 0xff, 0xc3, 0x8a, 0xff, 0xc3, 0x8b, 0xd0, 0x81, 0xff, 0xc3, 0x88,
+    0xff, 0xc4, 0xb1, 0xff, 0xc3, 0x8d, 0xff, 0xc3, 0x8e, 0xff, 0xc3, 0x8f, 0xd0, 0x87, 0xff, 0xc2,
+    0xa6, 0xff, 0xc3, 0x8c, 0xc3, 0x8e, 0xff, 0xc3, 0x92, 0xc3, 0x93, 0xff, 0xc3, 0x94, 0xff, 0xc3,
+    0x92, 0xc3, 0x93, 0xff, 0xc3, 0xb5, 0xff, 0xc3, 0x95, 0xff, 0xc3, 0xbe, 0xff, 0xc3, 0x9e, 0xff,
+    0xc3, 0x9a, 0xff, 0xc3, 0x9b, 0xff, 0xc3, 0x99, 0xff, 0xc3, 0xbd, 0xff, 0xc3, 0x9d, 0xff, 0xc2,
+    0xaf, 0xe2, 0x80, 0x94, 0xff, 0xc2, 0xb4, 0xff, 0xc2, 0xad, 0xc2, 0xaf, 0xff, 0xc3, 0xac, 0xe2,
+    0x80, 0x97, 0xff, 0xc2, 0xbe, 0xff, 0xc2, 0xb8, 0xcb, 0x9b, 0xff, 0xc2, 0xa8, 0xff, 0xc2, 0xb9,
+    0xff, 0xc2, 0xb3, 0xff, 0xd0, 0x91, 0xff, 0xd0, 0x93, 0xff, 0xd0, 0x94, 0xff, 0xd0, 0x96, 0xff,
+    0xd0, 0x97, 0xff, 0xd0, 0x98, 0xff, 0xd0, 0x99, 0xff, 0xd0, 0x9b, 0xff, 0xd0, 0x9f, 0xff, 0xd0,
+    0xa3, 0xff, 0xd0, 0xa4, 0xff, 0xd0, 0xa6, 0xff, 0xd0, 0xa7, 0xff, 0xd0, 0xa8, 0xff, 0xd0, 0xa9,
+    0xff, 0xd0, 0xaa, 0xff, 0xd0, 0xab, 0xff, 0xd0, 0xac, 0xff, 0xd0, 0xad, 0xff, 0xd0, 0xae, 0xff,
+    0xd0, 0xaf, 0xff, 0xd0, 0xb1, 0xff, 0xd0, 0xb2, 0xff, 0xd0, 0xb3, 0xff, 0xd0, 0xb4, 0xff, 0xd0,
+    0xb6, 0xff, 0xd0, 0xb7, 0xff, 0xd0, 0xb8, 0xff, 0xd0, 0xb9, 0xff, 0xd0, 0xba, 0xff, 0xd0, 0xbb,
+    0xff, 0xd0, 0xbc, 0xff, 0xd0, 0xbd, 0xff, 0xd0, 0xbf, 0xff, 0xd1, 0x82, 0xff, 0xd1, 0x83, 0xff,
+    0xd1, 0x84, 0xff, 0xd1, 0x86, 0xff, 0xd1, 0x87, 0xff, 0xd1, 0x88, 0xff, 0xd1, 0x89, 0xff, 0xd1,
+    0x8a, 0xff, 0xd1, 0x8b, 0xff, 0xff, 0xd1, 0x8d, 0xff, 0xd1, 0x8e, 0xff, 0xd1, 0x8f, 0xff, 0xd0,
+    0x84, 0xff, 0xd1, 0x94, 0xff, 0xd0, 0x8e, 0xff, 0xe2, 0x84, 0x96, 0xff, 0xd0, 0x90, 0xff, 0xd0,
+    0x92, 0xff, 0xd0, 0x95, 0xff, 0xd0, 0x9a, 0xff, 0xd0, 0x9c, 0xff, 0xd0, 0x9d, 0xff, 0xd0, 0x9e,
+    0xff, 0xd0, 0xa0, 0xff, 0xd0, 0xa2, 0xff, 0xd0, 0xa1, 0xff, 0xd0, 0xa5, 0xff, 0xd0, 0xb0, 0xff,
+    0xd0, 0xb5, 0xff, 0xd0, 0xbe, 0xff, 0xd1, 0x80, 0xff, 0xd1, 0x81, 0xff, 0xd1, 0x85, 0xff, 0xd1,
+    0x8c, 0xff, 0xd1, 0x9e, 0xff, 0xc2, 0xa4, 0xff, 0xc4, 0x89, 0xff, 0xc4, 0x88, 0xff, 0xc4, 0x8b,
+    0xff, 0xc4, 0x8a, 0xff, 0xc4, 0xb0, 0xff, 0xc4, 0x9d, 0xff, 0xc4, 0x9c, 0xff, 0xff, 0xc4, 0x9e,
+    0xff, 0xc4, 0x9f, 0xff, 0xc4, 0xa4, 0xff, 0xc4, 0xa5, 0xff, 0xc4, 0xb4, 0xff, 0xc4, 0xb5, 0xc5,
+    0x9f, 0xff, 0xc3, 0x97, 0xc5, 0x9e, 0xff, 0xc5, 0x9c, 0xff, 0xc5, 0x9d, 0xff, 0xc4, 0xa0, 0xff,
+    0xc4, 0xa1, 0xff, 0xc4, 0xa6, 0xff, 0xc4, 0xa7, 0xff, 0xc5, 0xac, 0xff, 0xc5, 0xad, 0xff, 0xe2,
+    0x84, 0x93, 0xff, 0xc5, 0x89, 0xff, 0xcb, 0x98, 0xff, 0xc3, 0xac, 0xc4, 0xb1, 0xff, 0xc5, 0xbc,
+    0xff, 0xc5, 0xbb, 0xff, 0xc5, 0xaf, 0xff, 0xc4, 0x87, 0xff, 0xc5, 0x82, 0xff, 0xc5, 0x90, 0xff,
+    0xc5, 0x91, 0xff, 0xc5, 0xb9, 0xff, 0xc4, 0x86, 0xff, 0xc4, 0xb9, 0xff, 0xc4, 0xba, 0xff, 0xc4,
+    0xbd, 0xff, 0xc4, 0xbe, 0xff, 0xc5, 0x9a, 0xff, 0xc5, 0x9b, 0xff, 0xc5, 0xa4, 0xff, 0xc5, 0xa5,
+    0xff, 0xc5, 0x81, 0xff, 0xc4, 0x8d, 0xff, 0xc4, 0x84, 0xff, 0xc4, 0x85, 0xff, 0xc5, 0xbd, 0xff,
+    0xc5, 0xbe, 0xff, 0xc4, 0x98, 0xff, 0xc4, 0x99, 0xff, 0xc5, 0xba, 0xff, 0xc4, 0x8c, 0xff, 0xc4,
+    0x9a, 0xff, 0xc4, 0x82, 0xff, 0xc4, 0x83, 0xff, 0xc4, 0x8e, 0xff, 0xc4, 0x8f, 0xff, 0xc5, 0x87,
+    0xff, 0xc4, 0x9b, 0xff, 0xc5, 0xa2, 0xff, 0xc5, 0xae, 0xff, 0xc5, 0x83, 0xff, 0xc5, 0x84, 0xff,
+    0xc5, 0x88, 0xff, 0xc5, 0xa0, 0xff, 0xc5, 0xa1, 0xff, 0xc5, 0x94, 0xff, 0xc5, 0x95, 0xff, 0xc5,
+    0xb0, 0xff, 0xc5, 0xa3, 0xff, 0xcb, 0x9d, 0xff, 0xcb, 0x9b, 0xff, 0xc5, 0xb1, 0xff, 0xc5, 0x98,
+    0xff, 0xc5, 0x99, 0xff, 0xcb, 0x87, 0xff
+};
+static constexpr unsigned int drdos8x8_psfu_len = 4983;
+
+#endif /* KERNEL_SRC_GRAPHICS_FONTS_DRDOS8X8_HPP_ */
diff --git a/kernel/src/graphics/geometry.hpp b/kernel/src/graphics/geometry.hpp
new file mode 100644
index 00000000..d547b152
--- /dev/null
+++ b/kernel/src/graphics/geometry.hpp
@@ -0,0 +1,38 @@
+#ifndef KERNEL_SRC_GRAPHICS_GEOMETRY_HPP_
+#define KERNEL_SRC_GRAPHICS_GEOMETRY_HPP_
+
+#include <string.hpp>
+#include <types.hpp>
+
+namespace Graphics
+{
+
+struct Point {
+    i32 x;
+    i32 y;
+};
+
+struct Rect {
+    i32 x;
+    i32 y;
+    i32 w;
+    i32 h;
+};
+
+struct TextCmd {
+    i32 x;
+    i32 y;
+    std::string_view text;
+    u8 scale = 1;
+};
+
+struct CharCmd {
+    i32 x;
+    i32 y;
+    char c;
+    u8 scale = 1;
+};
+
+}  // namespace Graphics
+
+#endif  // KERNEL_SRC_GRAPHICS_GEOMETRY_HPP_
diff --git a/kernel/src/graphics/painter.cpp b/kernel/src/graphics/painter.cpp
index 4017039e..61817dfc 100644
--- a/kernel/src/graphics/painter.cpp
+++ b/kernel/src/graphics/painter.cpp
@@ -24,8 +24,10 @@ u32 Painter::PackColor(Color c) const
            (static_cast<u32>(c.b & b_mask) << format_.blue_pos);
 }
 
-void Painter::DrawPixel(i32 x, i32 y)
+void Painter::DrawPixel(Point p)
 {
+    i32 x = p.x;
+    i32 y = p.y;
     if (x < 0 || y < 0 || static_cast<u32>(x) >= target_.GetWidth() ||
         static_cast<u32>(y) >= target_.GetHeight()) {
         return;
@@ -41,7 +43,6 @@ void Painter::FillScanline(u32 *dest, u32 count, u32 color)
         (color & 0xFF) == ((color >> 24) & 0xFF)) {
         memset(dest, color & 0xFF, count * sizeof(u32));
     } else {
-        // Compiler auto-vectorization usually handles this loop well
         for (u32 i = 0; i < count; ++i) {
             dest[i] = color;
         }
@@ -55,7 +56,7 @@ void Painter::Clear(Color color)
     u32 width  = target_.GetWidth();
     u32 pitch  = target_.GetPitch();
 
-    // Optimization: if buffer is contiguous (pitch == width * 4 for 32bpp)
+    // If buffer is contiguous (pitch == width * 4 for 32bpp)
     // we can clear it in one go.
     if (pitch == width * sizeof(u32)) {
         FillScanline(target_.GetScanline(0), width * height, raw);
@@ -66,8 +67,13 @@ void Painter::Clear(Color color)
     }
 }
 
-void Painter::FillRect(i32 x, i32 y, i32 w, i32 h)
+void Painter::FillRect(Rect r)
 {
+    i32 x = r.x;
+    i32 y = r.y;
+    i32 w = r.w;
+    i32 h = r.h;
+
     // Clipping Logic
     if (x < 0) {
         w += x;
@@ -103,16 +109,21 @@ void Painter::FillRect(i32 x, i32 y, i32 w, i32 h)
     }
 }
 
-void Painter::DrawRect(i32 x, i32 y, i32 w, i32 h)
+void Painter::DrawRect(Rect r)
 {
+    i32 x = r.x;
+    i32 y = r.y;
+    i32 w = r.w;
+    i32 h = r.h;
+
     // Top
-    FillRect(x, y, w, 1);
+    FillRect({x, y, w, 1});
     // Bottom
-    FillRect(x, y + h - 1, w, 1);
+    FillRect({x, y + h - 1, w, 1});
     // Left
-    FillRect(x, y, 1, h);
+    FillRect({x, y, 1, h});
     // Right
-    FillRect(x + w - 1, y, 1, h);
+    FillRect({x + w - 1, y, 1, h});
 }
 
 }  // namespace Graphics
diff --git a/kernel/src/graphics/painter.hpp b/kernel/src/graphics/painter.hpp
index 4265af7d..33e3ae76 100644
--- a/kernel/src/graphics/painter.hpp
+++ b/kernel/src/graphics/painter.hpp
@@ -1,12 +1,25 @@
 #ifndef KERNEL_SRC_GRAPHICS_PAINTER_HPP_
 #define KERNEL_SRC_GRAPHICS_PAINTER_HPP_
 
+#include <concepts.hpp>
+#include <string.hpp>
 #include "graphics/color.hpp"
+#include "graphics/font/glyph.hpp"
+#include "graphics/geometry.hpp"
 #include "graphics/surface.hpp"
 
 namespace Graphics
 {
 
+/**
+ * @brief Concept ensuring a type acts like a Font.
+ */
+template <typename T>
+concept FontType = requires(const T &t, char c) {
+    { t.GetGlyph(c) } -> std::same_as<Glyph>;
+    { t.GetHeight() } -> std::convertible_to<u32>;
+};
+
 class Painter
 {
     public:
@@ -20,10 +33,28 @@ class Painter
 
     void Clear(Color color);
 
-    // Safe drawing with clipping
-    void DrawPixel(i32 x, i32 y);
-    void DrawRect(i32 x, i32 y, i32 w, i32 h);
-    void FillRect(i32 x, i32 y, i32 w, i32 h);
+    void DrawPixel(Point p);
+    void DrawRect(Rect r);
+    void FillRect(Rect r);
+
+    // -------------------------------------------------------------------------
+    // Text Rendering
+    // -------------------------------------------------------------------------
+
+    /**
+     * @brief Draws a single character using the provided font.
+     * @tparam FontT A type satisfying the FontType concept (e.g., Psf2Font).
+     */
+    template <FontType FontT>
+    void DrawChar(const CharCmd &cmd, const FontT &font);
+
+    /**
+     * @brief Draws a null-terminated string.
+     * Handles newlines (\n) and carriage returns (\r).
+     * @tparam FontT A type satisfying the FontType concept.
+     */
+    template <FontType FontT>
+    void DrawString(const TextCmd &cmd, const FontT &font);
 
     private:
     void FillScanline(u32 *dest, u32 count, u32 color);
@@ -36,4 +67,6 @@ class Painter
 
 }  // namespace Graphics
 
+#include "graphics/painter.tpp"
+
 #endif  // KERNEL_SRC_GRAPHICS_PAINTER_HPP_
diff --git a/kernel/src/graphics/painter.tpp b/kernel/src/graphics/painter.tpp
new file mode 100644
index 00000000..8d470abc
--- /dev/null
+++ b/kernel/src/graphics/painter.tpp
@@ -0,0 +1,70 @@
+#ifndef KERNEL_SRC_GRAPHICS_PAINTER_TPP_
+#define KERNEL_SRC_GRAPHICS_PAINTER_TPP_
+
+#include "painter.hpp"
+
+namespace Graphics
+{
+
+template <FontType FontT>
+void Painter::DrawChar(const CharCmd &cmd, const FontT &font)
+{
+    Glyph glyph = font.GetGlyph(cmd.c);
+
+    i32 scaled_width  = static_cast<i32>(glyph.width) * cmd.scale;
+    i32 scaled_height = static_cast<i32>(glyph.height) * cmd.scale;
+
+    // Skip if character is off-screen
+    if (cmd.x >= static_cast<i32>(target_.GetWidth()) ||
+        cmd.y >= static_cast<i32>(target_.GetHeight()) || cmd.x + scaled_width <= 0 ||
+        cmd.y + scaled_height <= 0) {
+        return;
+    }
+
+    for (u32 row = 0; row < glyph.height; ++row) {
+        const byte *row_data = glyph.buffer + (static_cast<size_t>(row * glyph.stride));
+
+        for (u32 col = 0; col < glyph.width; ++col) {
+            // Bit testing for PSF (Big Endian / MSB first)
+            u32 byte_idx = col >> 3;
+            u32 bit_idx  = 7 - (col & 7);
+
+            bool is_set = (row_data[byte_idx] & (1 << bit_idx));
+
+            if (is_set) {
+                FillRect(
+                    {static_cast<i32>(cmd.x + (col * cmd.scale)),
+                     static_cast<i32>(cmd.y + (row * cmd.scale)), cmd.scale, cmd.scale}
+                );
+            }
+        }
+    }
+}
+
+template <FontType FontT>
+void Painter::DrawString(const TextCmd &cmd, const FontT &font)
+{
+    if (cmd.text.empty()) {
+        return;
+    }
+
+    i32 cursor_x          = cmd.x;
+    i32 cursor_y          = cmd.y;
+    const u32 line_height = font.GetHeight();
+
+    for (char c : cmd.text) {
+        if (c == '\n') {
+            cursor_x = cmd.x;
+            cursor_y += static_cast<i32>(line_height * cmd.scale);
+        } else if (c == '\r') {
+            cursor_x = cmd.x;
+        } else {
+            DrawChar({.x = cursor_x, .y = cursor_y, .c = c, .scale = cmd.scale}, font);
+            cursor_x += static_cast<i32>(font.GetGlyph(c).advance * cmd.scale);
+        }
+    }
+}
+
+}  // namespace Graphics
+
+#endif  // KERNEL_SRC_GRAPHICS_PAINTER_TPP_
diff --git a/kernel/src/io/register.hpp b/kernel/src/io/register.hpp
index 98a2f1d4..0ff3c89a 100644
--- a/kernel/src/io/register.hpp
+++ b/kernel/src/io/register.hpp
@@ -11,16 +11,8 @@ namespace IO
  * @brief Abstraction for a specific hardware I/O register or port.
  *
  * This class encapsulates the address of a hardware register (e.g., an I/O port number
- * on x86 or a physical memory address on MMIO architectures) and provides a type-safe
- * interface for data access.
+ * on x86 or a physical memory address on MMIO architectures)
  *
- * It acts as a wrapper around the Hardware Abstraction Layer (HAL), delegating
- * specific read/write instructions (like `inb`/`outb` or volatile pointer access)
- * to `hal::IoRead` and `hal::IoWrite`. This allows device drivers to remain
- * architecture-agnostic.
- *
- * @note Operations are restricted to valid I/O types (u8, u16, u32) via the
- *       `hal::IoT` concept.
  */
 class Register
 {
diff --git a/kernel/src/kernel.cpp b/kernel/src/kernel.cpp
index d5f2f473..ec2abf69 100644
--- a/kernel/src/kernel.cpp
+++ b/kernel/src/kernel.cpp
@@ -7,8 +7,11 @@
 /* internal includes */
 #include <hal/debug.hpp>
 
-#include "boot_args.hpp"
+#include "graphics/font/psf2_font.hpp"
+#include "graphics/fonts/drdos8x8.hpp"
 #include "graphics/painter.hpp"
+
+#include "boot_args.hpp"
 #include "hal/boot_args.hpp"
 #include "mem/heap.hpp"
 #include "modules/video.hpp"
@@ -35,17 +38,39 @@ static void KernelRun()
     auto fmt     = video.GetFormat();
 
     Graphics::Painter p(screen, fmt);
+    Graphics::Psf2Font system_font(drdos8x8_psfu);
+
+    if (!system_font.IsValid()) {
+        TRACE_WARN_VIDEO("System font magic invalid! Rendering might be corrupted.");
+    }
 
     // Animation Loop
     i32 x     = 0;
     i32 y     = 0;
     u16 speed = 1;
+
     while (true) {
         p.Clear(Graphics::Color::Black());
+
+        // Shape drawing
         p.SetColor(Graphics::Color::Green());
-        p.FillRect(x, 100, 50, 50);
+        p.FillRect({.x = x, .y = 100, .w = 50, .h = 50});
         p.SetColor(Graphics::Color::Blue());
-        p.FillRect(100, y, 70, 70);
+        p.FillRect({.x = 100, .y = y, .w = 70, .h = 70});
+
+        // Text drawing
+        p.SetColor(Graphics::Color::White());
+        p.DrawString({.x = 40, .y = 20, .text = "AlkOS Kernel", .scale = 3}, system_font);
+
+        p.SetColor(Graphics::Color::Red());
+        p.DrawString(
+            {.x = 40, .y = 50, .text = "Graphics Subsystem Online.", .scale = 3}, system_font
+        );
+
+        // Dynamic Text Position
+        p.SetColor(Graphics::Color::Green());
+        p.DrawString({.x = x, .y = y + 80, .text = "Moving Text!", .scale = 2}, system_font);
+
         video.Flush();
 
         x += (speed / 255) + 1;
@@ -55,7 +80,7 @@ static void KernelRun()
 
         // crude delay
         for (volatile int i = 0; i < 1000000; i++);
-        speed = speed + 80;
+        speed = speed + 10;
     }
 }
 
diff --git a/libs/libcontainers/include/data_structures/array_structures.hpp b/libs/libcontainers/include/data_structures/array_structures.hpp
index 4f38bef2..99ae1506 100644
--- a/libs/libcontainers/include/data_structures/array_structures.hpp
+++ b/libs/libcontainers/include/data_structures/array_structures.hpp
@@ -1,10 +1,11 @@
-#ifndef ALKOS_LIBC_INCLUDE_EXTENSIONS_DATA_STRUCTURES_ARRAY_STRUCTURES_HPP_
-#define ALKOS_LIBC_INCLUDE_EXTENSIONS_DATA_STRUCTURES_ARRAY_STRUCTURES_HPP_
+#ifndef LIBS_LIBCONTAINERS_INCLUDE_DATA_STRUCTURES_ARRAY_STRUCTURES_HPP_
+#define LIBS_LIBCONTAINERS_INCLUDE_DATA_STRUCTURES_ARRAY_STRUCTURES_HPP_
 
 #include <string.h>
 #include <array.hpp>
 #include <bits_ext.hpp>
 #include <concepts.hpp>
+#include <string.hpp>
 
 namespace data_structures
 {
@@ -342,6 +343,15 @@ struct StringArray : public std::array<char, kSize> {
     }
 
     NODISCARD FORCE_INLINE_F const char *GetCStr() const noexcept { return this->data(); }
+
+    NODISCARD constexpr operator std::string_view() const noexcept
+    {
+        size_t len = 0;
+        while (len < kSize && (*this)[len] != '\0') {
+            len++;
+        }
+        return std::string_view(this->data(), len);
+    }
 };
 
 template <size_t kSize>
@@ -377,4 +387,4 @@ NODISCARD FAST_CALL constexpr StringArray<sizeof(T)> IntegralToStringArray(const
 
 }  // namespace data_structures
 
-#endif  // ALKOS_LIBC_INCLUDE_EXTENSIONS_DATA_STRUCTURES_ARRAY_STRUCTURES_HPP_
+#endif  // LIBS_LIBCONTAINERS_INCLUDE_DATA_STRUCTURES_ARRAY_STRUCTURES_HPP_

From ba284c30cf610081da3754dab2e9b678b6af7d1e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C5=81ukasz=20Kryczka?=
 <60490378+kryczkal@users.noreply.github.com>
Date: Tue, 9 Dec 2025 23:42:51 +0100
Subject: [PATCH 04/56] Kryczkal/console 02 (#230)

![2025-12-0923-31-11-ezgif
com-video-to-gif-converter](https://github.com/user-attachments/assets/c74fddb2-e716-49f1-ada3-1715169bd0cd)

## Problem
There is no interface to communicate with the OS from a graphical
perspective

## Solution
Implemented a `graphics_console`
and a super basic shell that uses it.
---
 kernel/src/demos/donut.hpp               | 222 +++++++++++++++++++++++
 kernel/src/drivers/video/framebuffer.cpp |   8 +-
 kernel/src/drivers/video/framebuffer.hpp |   3 +-
 kernel/src/graphics/color.hpp            |  11 +-
 kernel/src/graphics/font/psf2_font.hpp   |  42 ++++-
 kernel/src/graphics/geometry.hpp         |   5 +
 kernel/src/graphics/native_pixel.hpp     |  47 +++++
 kernel/src/graphics/painter.cpp          |  65 +++----
 kernel/src/graphics/painter.hpp          |  23 ++-
 kernel/src/graphics/surface.hpp          |  32 ++--
 kernel/src/kernel.cpp                    |  70 ++-----
 kernel/src/modules/video.cpp             |   3 +-
 kernel/src/sys/graphics_console.cpp      | 130 +++++++++++++
 kernel/src/sys/graphics_console.hpp      |  68 +++++++
 kernel/src/sys/shell.cpp                 | 101 +++++++++++
 kernel/src/sys/shell.hpp                 |  57 ++++++
 16 files changed, 759 insertions(+), 128 deletions(-)
 create mode 100644 kernel/src/demos/donut.hpp
 create mode 100644 kernel/src/graphics/native_pixel.hpp
 create mode 100644 kernel/src/sys/graphics_console.cpp
 create mode 100644 kernel/src/sys/graphics_console.hpp
 create mode 100644 kernel/src/sys/shell.cpp
 create mode 100644 kernel/src/sys/shell.hpp

diff --git a/kernel/src/demos/donut.hpp b/kernel/src/demos/donut.hpp
new file mode 100644
index 00000000..e2c75be7
--- /dev/null
+++ b/kernel/src/demos/donut.hpp
@@ -0,0 +1,222 @@
+#ifndef KERNEL_SRC_DEMOS_DONUT_HPP_
+#define KERNEL_SRC_DEMOS_DONUT_HPP_
+
+#include <stdio.h>
+#include <algorithm.hpp>
+#include <memory.hpp>
+#include <span.hpp>
+#include <string.hpp>
+#include <types.hpp>
+
+#include "graphics/color.hpp"
+#include "graphics/font/psf2_font.hpp"
+#include "graphics/fonts/drdos8x8.hpp"
+#include "graphics/native_pixel.hpp"
+#include "graphics/painter.hpp"
+#include "graphics/surface.hpp"
+#include "mem/heap.hpp"
+#include "modules/video.hpp"
+#include "trace_framework.hpp"
+
+namespace Demos
+{
+
+// --------------------------------------------------------------------------------
+// Minimal Math for donut Implementation
+// --------------------------------------------------------------------------------
+
+namespace Math
+{
+// Simple Taylor series approximation for sin/cos to avoid libm dependency
+// or massive lookup tables. Precision is "good enough" for a donut.
+constexpr f32 PI = 3.14159265359f;
+
+f32 sin(f32 x)
+{
+    // Normalize to -PI to PI
+    while (x < -PI) {
+        x += 2 * PI;
+    }
+    while (x > PI) {
+        x -= 2 * PI;
+    }
+
+    f32 res  = 0;
+    f32 term = x;
+    f32 k    = 1;
+    for (i32 i = 0; i < 5; ++i) {  // 5 iterations is plenty for visual
+        res += term;
+        term *= -1 * x * x / ((k + 1) * (k + 2));
+        k += 2;
+    }
+    return res;
+}
+
+f32 cos(f32 x) { return sin(x + (PI / 2.0F)); }
+}  // namespace Math
+
+class SpinningDonut
+{
+    public:
+    void Init(u32 width, u32 height, const Graphics::PixelFormat &format)
+    {
+        width_  = width;
+        height_ = height;
+
+        size_t zbuf_size = width * height * sizeof(f32);
+        auto alloc       = Mem::KMalloc(zbuf_size);
+        if (alloc) {
+            z_buffer_ = static_cast<f32 *>(*alloc);
+        }
+
+        // Pre-calculate luminance palette to avoid color packing in the render loop.
+        for (i32 i = 0; i < 13; ++i) {
+            f32 intensity = i / 12.0f;
+            u8 r          = static_cast<u8>(255 * intensity);
+            u8 g          = static_cast<u8>(150 * intensity);
+            u8 b          = static_cast<u8>(50 * intensity);
+
+            luminance_palette_[i] = Graphics::NativePixel::FromColor({r, g, b}, format);
+        }
+    }
+
+    void Render(Graphics::Painter &painter)
+    {
+        if (z_buffer_ == nullptr) {
+            return;
+        }
+
+        // Reset Z-buffer.
+        memset(z_buffer_, 0, width_ * height_ * sizeof(f32));
+
+        painter.Clear(Graphics::Color::Black());
+
+        // Get unsafe pointers for direct access
+        Graphics::Surface &screen = painter.GetTarget();
+        u8 *raw_byte_buffer       = reinterpret_cast<u8 *>(screen.GetRawBuffer());
+        u32 pitch                 = screen.GetPitch();
+
+        // Precompute sines and cosines
+        f32 cA = Math::cos(A);
+        f32 sA = Math::sin(A);
+        f32 cB = Math::cos(B);
+        f32 sB = Math::sin(B);
+
+        // Theta (cross section of torus)
+        for (f32 theta = 0; theta < 2 * Math::PI; theta += 0.07F) {
+            f32 ct = Math::cos(theta);
+            f32 st = Math::sin(theta);
+
+            // Phi (center of revolution)
+            for (f32 phi = 0; phi < 2 * Math::PI; phi += 0.02F) {
+                f32 cp = Math::cos(phi);
+                f32 sp = Math::sin(phi);
+
+                // 3D coordinates calculation
+                f32 circleX = R2 + (R1 * ct);
+                f32 circleY = R1 * st;
+
+                f32 x = (circleX * (cp * cB + sp * sA * sB)) - (circleY * cA * sB);
+                f32 y = (circleX * (cp * sB - sp * sA * cB)) + (circleY * cA * cB);
+                f32 z = K2 + (circleX * sp * cA) + (circleY * sA);
+
+                // Inverse Z (Depth)
+                f32 ooz = 1.0F / z;
+
+                // Screen projection
+                i32 xp = (i32)((width_ / 2) + (K1 * ooz * x));
+                i32 yp = (i32)((height_ / 2) - (K1 * ooz * y));
+
+                // Luminance
+                f32 L =
+                    (cp * ct * sB) - (cA * ct * sp) - (sA * st) + (cB * (cA * st - ct * sA * sp));
+
+                if (L > 0 && xp >= 0 && xp < (i32)width_ && yp >= 0 && yp < (i32)height_) {
+                    i32 idx = xp + (yp * width_);
+
+                    if (ooz > z_buffer_[idx]) {
+                        z_buffer_[idx] = ooz;
+
+                        i32 luminance_idx = (i32)(L * 8.0F);
+                        if (luminance_idx > 12)
+                            luminance_idx = 12;
+                        else if (luminance_idx < 0)
+                            luminance_idx = 0;
+
+                        // Direct memory write: Base + (Y * Pitch) + (X * BytesPerPixel)
+                        u32 *pixel_addr =
+                            reinterpret_cast<u32 *>(raw_byte_buffer + (yp * pitch) + (xp * 4));
+                        *pixel_addr = luminance_palette_[luminance_idx].value;
+                    }
+                }
+            }
+        }
+
+        A += 0.04f;
+        B += 0.02f;
+    }
+
+    private:
+    f32 A        = 0;
+    f32 B        = 0;
+    const f32 R1 = 1.0f;    // Tube radius
+    const f32 R2 = 2.0f;    // Distance from center
+    const f32 K2 = 5.0f;    // Distance from camera
+    const f32 K1 = 350.0f;  // Zoom/Scale
+
+    u32 width_     = 0;
+    u32 height_    = 0;
+    f32 *z_buffer_ = nullptr;
+
+    Graphics::NativePixel luminance_palette_[13];
+};
+
+void RunDonutDemo()
+{
+    auto &video  = VideoModule::Get();
+    auto &screen = video.GetScreen();
+    auto fmt     = video.GetFormat();
+
+    Graphics::Painter p(screen, fmt);
+    Graphics::Psf2Font system_font(std::span<const u8>(drdos8x8_psfu, drdos8x8_psfu_len));
+
+    if (!system_font.IsValid()) {
+        TRACE_WARN_VIDEO("System font magic invalid! Rendering might be corrupted.");
+    }
+
+    SpinningDonut donut;
+    donut.Init(screen.GetWidth(), screen.GetHeight(), fmt);
+
+    u64 frame_count = 0;
+    char text_buffer[100];
+    while (true) {
+        donut.Render(p);
+
+        p.SetColor(Graphics::Color::White());
+        p.DrawString(
+            {.x = 10, .y = 10, .text = "AlkOS Kernel - Graphics Module ON", .scale = 2}, system_font
+        );
+        i32 ret = snprintf(text_buffer, 100, "Frame %lli", frame_count);
+        (void)ret;
+        p.DrawString(
+            {.x     = (static_cast<i32>(
+                 screen.GetWidth() - system_font.MeasureString(text_buffer).width * 2
+             )),
+             .y     = 10,
+             .text  = text_buffer,
+             .scale = 2},
+            system_font
+        );
+        video.Flush();
+
+        for (volatile i32 i = 0; i < 10000000; i++) {
+            ;
+        }
+
+        frame_count++;
+    }
+}
+
+}  // namespace Demos
+
+#endif  // KERNEL_SRC_DEMOS_DONUT_HPP_
diff --git a/kernel/src/drivers/video/framebuffer.cpp b/kernel/src/drivers/video/framebuffer.cpp
index cc116da9..ce9f8a95 100644
--- a/kernel/src/drivers/video/framebuffer.cpp
+++ b/kernel/src/drivers/video/framebuffer.cpp
@@ -1,5 +1,6 @@
 #include "drivers/video/framebuffer.hpp"
 #include "defines.hpp"
+#include "graphics/native_pixel.hpp"
 #include "mem/heap.hpp"
 #include "trace_framework.hpp"
 
@@ -13,7 +14,7 @@ void Framebuffer::Init(Graphics::Surface s, Graphics::PixelFormat pf, Mem::Heap
     // Backbuffer allocation
     size_t width       = front_surface_.GetWidth();
     size_t height      = front_surface_.GetHeight();
-    size_t buffer_size = width * height * sizeof(u32);
+    size_t buffer_size = width * height * sizeof(Graphics::NativePixel);
 
     auto alloc_res = hp.Malloc(buffer_size);
     if (!alloc_res) {
@@ -21,8 +22,9 @@ void Framebuffer::Init(Graphics::Surface s, Graphics::PixelFormat pf, Mem::Heap
         return;
     }
 
-    backbuffer_mem_ = static_cast<Mem::VPtr<u32>>(*alloc_res);
-    back_surface_   = Graphics::Surface(backbuffer_mem_, width, height, width * sizeof(u32));
+    backbuffer_mem_ = static_cast<Mem::VPtr<Graphics::NativePixel>>(*alloc_res);
+    back_surface_ =
+        Graphics::Surface(backbuffer_mem_, width, height, width * sizeof(Graphics::NativePixel));
 }
 
 void Framebuffer::Flush()
diff --git a/kernel/src/drivers/video/framebuffer.hpp b/kernel/src/drivers/video/framebuffer.hpp
index 184fffea..6456e650 100644
--- a/kernel/src/drivers/video/framebuffer.hpp
+++ b/kernel/src/drivers/video/framebuffer.hpp
@@ -3,6 +3,7 @@
 
 #include <expected.hpp>
 #include "graphics/color.hpp"
+#include "graphics/native_pixel.hpp"
 #include "graphics/surface.hpp"
 #include "mem/heap.hpp"
 
@@ -33,7 +34,7 @@ class Framebuffer
     Graphics::PixelFormat format_{};
 
     // We own the backbuffer memory
-    Mem::VPtr<u32> backbuffer_mem_{nullptr};
+    Mem::VPtr<Graphics::NativePixel> backbuffer_mem_{nullptr};
 };
 
 }  // namespace Drivers::Video
diff --git a/kernel/src/graphics/color.hpp b/kernel/src/graphics/color.hpp
index 1b728229..02189de8 100644
--- a/kernel/src/graphics/color.hpp
+++ b/kernel/src/graphics/color.hpp
@@ -8,13 +8,10 @@ namespace Graphics
 {
 
 struct PACK Color {
-    u8 r;
-    u8 g;
-    u8 b;
-    u8 a;
-
-    constexpr Color(u8 r, u8 g, u8 b, u8 a = 255) : r(r), g(g), b(b), a(a) {}
-    constexpr Color() : r(0), g(0), b(0), a(255) {}
+    u8 r = 0;
+    u8 g = 0;
+    u8 b = 0;
+    u8 a = 255;
 
     static constexpr Color Red() { return {255, 0, 0, 255}; }
     static constexpr Color Green() { return {0, 255, 0, 255}; }
diff --git a/kernel/src/graphics/font/psf2_font.hpp b/kernel/src/graphics/font/psf2_font.hpp
index 491ff543..13565fb9 100644
--- a/kernel/src/graphics/font/psf2_font.hpp
+++ b/kernel/src/graphics/font/psf2_font.hpp
@@ -4,8 +4,11 @@
 #include <assert.h>
 #include <defines.hpp>
 #include <span.hpp>
+#include <string.hpp>
 #include <types.hpp>
+
 #include "graphics/font/glyph.hpp"
+#include "graphics/geometry.hpp"
 
 namespace Graphics
 {
@@ -81,10 +84,47 @@ class Psf2Font
             .width   = hdr.width,
             .height  = hdr.height,
             .stride  = stride,
-            .advance = hdr.width  // PSF2 is fundamentally a fixed-width format
+            .advance = hdr.width
         };
     }
 
+    /**
+     * @brief Calculates the bounding box size of the text if it were drawn.
+     * @param text The string to measure.
+     * @param scale The scaling factor used for drawing.
+     * @return The width and height in pixels.
+     */
+    NODISCARD Size MeasureString(std::string_view text, u8 scale = 1) const
+    {
+        if (text.empty()) {
+            return {0, 0};
+        }
+
+        const auto &hdr = Header();
+        u32 cursor_x    = 0;
+        u32 cursor_y    = 0;
+        u32 max_width   = 0;
+
+        u32 total_height = hdr.height * scale;
+
+        for (char c : text) {
+            if (c == '\n') {
+                max_width = std::max(max_width, cursor_x);
+                cursor_x  = 0;
+                cursor_y += hdr.height * scale;
+                total_height = std::max(total_height, cursor_y + (hdr.height * scale));
+            } else if (c == '\r') {
+                cursor_x = 0;
+            } else {
+                cursor_x += hdr.width * scale;
+            }
+        }
+
+        max_width = std::max(max_width, cursor_x);
+
+        return {max_width, total_height};
+    }
+
     private:
     std::span<const u8> data_;
 };
diff --git a/kernel/src/graphics/geometry.hpp b/kernel/src/graphics/geometry.hpp
index d547b152..cd3ec15a 100644
--- a/kernel/src/graphics/geometry.hpp
+++ b/kernel/src/graphics/geometry.hpp
@@ -33,6 +33,11 @@ struct CharCmd {
     u8 scale = 1;
 };
 
+struct Size {
+    u32 width;
+    u32 height;
+};
+
 }  // namespace Graphics
 
 #endif  // KERNEL_SRC_GRAPHICS_GEOMETRY_HPP_
diff --git a/kernel/src/graphics/native_pixel.hpp b/kernel/src/graphics/native_pixel.hpp
new file mode 100644
index 00000000..20797f52
--- /dev/null
+++ b/kernel/src/graphics/native_pixel.hpp
@@ -0,0 +1,47 @@
+#ifndef KERNEL_SRC_GRAPHICS_NATIVE_PIXEL_HPP_
+#define KERNEL_SRC_GRAPHICS_NATIVE_PIXEL_HPP_
+
+#include <defines.hpp>
+#include <types.hpp>
+#include "graphics/color.hpp"
+
+namespace Graphics
+{
+
+/**
+ * @brief A wrapper around u32 that guarantees the value is formatted
+ * correctly for the hardware framebuffer.
+ */
+struct PACK NativePixel {
+    u32 value;
+
+    NativePixel() = default;
+
+    // Explicit constructor to prevent accidental integer assignment
+    explicit constexpr NativePixel(u32 v) : value(v) {}
+
+    bool operator==(const NativePixel &other) const = default;
+    explicit constexpr operator u32() const { return value; }
+
+    /**
+     * @brief Converts a logical RGBA color to a hardware-specific NativePixel.
+     */
+    NODISCARD static constexpr NativePixel FromColor(const Color &c, const PixelFormat &pf)
+    {
+        const u32 r_mask = (1 << pf.red_mask_size) - 1;
+        const u32 g_mask = (1 << pf.green_mask_size) - 1;
+        const u32 b_mask = (1 << pf.blue_mask_size) - 1;
+
+        u32 raw = (static_cast<u32>(c.r & r_mask) << pf.red_pos) |
+                  (static_cast<u32>(c.g & g_mask) << pf.green_pos) |
+                  (static_cast<u32>(c.b & b_mask) << pf.blue_pos);
+
+        return NativePixel(raw);
+    }
+};
+
+static_assert(sizeof(NativePixel) == sizeof(u32), "NativePixel must be 32-bit");
+
+}  // namespace Graphics
+
+#endif  // KERNEL_SRC_GRAPHICS_NATIVE_PIXEL_HPP_
diff --git a/kernel/src/graphics/painter.cpp b/kernel/src/graphics/painter.cpp
index 61817dfc..6b2ebb6b 100644
--- a/kernel/src/graphics/painter.cpp
+++ b/kernel/src/graphics/painter.cpp
@@ -11,18 +11,7 @@ Painter::Painter(Surface &target, const PixelFormat &format) : target_(target),
     SetColor(Color::White());
 }
 
-void Painter::SetColor(Color color) { packed_color_ = PackColor(color); }
-
-u32 Painter::PackColor(Color c) const
-{
-    const u32 r_mask = (1 << format_.red_mask_size) - 1;
-    const u32 g_mask = (1 << format_.green_mask_size) - 1;
-    const u32 b_mask = (1 << format_.blue_mask_size) - 1;
-
-    return (static_cast<u32>(c.r & r_mask) << format_.red_pos) |
-           (static_cast<u32>(c.g & g_mask) << format_.green_pos) |
-           (static_cast<u32>(c.b & b_mask) << format_.blue_pos);
-}
+void Painter::SetColor(Color color) { packed_color_ = NativePixel::FromColor(color, format_); }
 
 void Painter::DrawPixel(Point p)
 {
@@ -35,34 +24,35 @@ void Painter::DrawPixel(Point p)
     target_.Pixel(static_cast<u32>(x), static_cast<u32>(y)) = packed_color_;
 }
 
-void Painter::FillScanline(u32 *dest, u32 count, u32 color)
+void Painter::FillScanline(std::span<NativePixel> dest, NativePixel color)
 {
-    // Check for byte-repeating pattern for memset optimization
-    // e.g. 0x00000000, 0xFFFFFFFF, 0xABABABAB
-    if ((color & 0xFF) == ((color >> 8) & 0xFF) && (color & 0xFF) == ((color >> 16) & 0xFF) &&
-        (color & 0xFF) == ((color >> 24) & 0xFF)) {
-        memset(dest, color & 0xFF, count * sizeof(u32));
+    u32 raw = color.value;
+
+    // Optimization: If byte pattern is repeating, use memset
+    if ((raw & 0xFF) == ((raw >> 8) & 0xFF) && (raw & 0xFF) == ((raw >> 16) & 0xFF) &&
+        (raw & 0xFF) == ((raw >> 24) & 0xFF)) {
+        memset(dest.data(), raw & 0xFF, dest.size_bytes());
     } else {
-        for (u32 i = 0; i < count; ++i) {
-            dest[i] = color;
+        for (auto &px : dest) {
+            px = color;
         }
     }
 }
 
 void Painter::Clear(Color color)
 {
-    u32 raw    = PackColor(color);
-    u32 height = target_.GetHeight();
-    u32 width  = target_.GetWidth();
-    u32 pitch  = target_.GetPitch();
-
-    // If buffer is contiguous (pitch == width * 4 for 32bpp)
-    // we can clear it in one go.
-    if (pitch == width * sizeof(u32)) {
-        FillScanline(target_.GetScanline(0), width * height, raw);
+    NativePixel raw = NativePixel::FromColor(color, format_);
+    u32 height      = target_.GetHeight();
+    u32 width       = target_.GetWidth();
+    u32 pitch       = target_.GetPitch();
+
+    if (pitch == width * sizeof(NativePixel)) {
+        std::span<NativePixel> first_line = target_.GetScanline(0);
+        std::span<NativePixel> full_buffer(first_line.data(), width * height);
+        FillScanline(full_buffer, raw);
     } else {
         for (u32 y = 0; y < height; ++y) {
-            FillScanline(target_.GetScanline(y), width, raw);
+            FillScanline(target_.GetScanline(y), raw);
         }
     }
 }
@@ -74,7 +64,6 @@ void Painter::FillRect(Rect r)
     i32 w = r.w;
     i32 h = r.h;
 
-    // Clipping Logic
     if (x < 0) {
         w += x;
         x = 0;
@@ -84,14 +73,10 @@ void Painter::FillRect(Rect r)
         y = 0;
     }
 
-    if (static_cast<u32>(x) >= target_.GetWidth()) {
-        return;
-    }
-    if (static_cast<u32>(y) >= target_.GetHeight()) {
+    if (static_cast<u32>(x) >= target_.GetWidth() || static_cast<u32>(y) >= target_.GetHeight()) {
         return;
     }
 
-    // Clamp width/height to edges
     if (static_cast<u32>(x + w) > target_.GetWidth()) {
         w = target_.GetWidth() - x;
     }
@@ -104,8 +89,8 @@ void Painter::FillRect(Rect r)
     }
 
     for (i32 row = 0; row < h; ++row) {
-        u32 *line = target_.GetScanline(static_cast<u32>(y + row));
-        FillScanline(line + x, static_cast<u32>(w), packed_color_);
+        std::span<NativePixel> line = target_.GetScanline(static_cast<u32>(y + row));
+        FillScanline(line.subspan(static_cast<size_t>(x), static_cast<size_t>(w)), packed_color_);
     }
 }
 
@@ -116,13 +101,9 @@ void Painter::DrawRect(Rect r)
     i32 w = r.w;
     i32 h = r.h;
 
-    // Top
     FillRect({x, y, w, 1});
-    // Bottom
     FillRect({x, y + h - 1, w, 1});
-    // Left
     FillRect({x, y, 1, h});
-    // Right
     FillRect({x + w - 1, y, 1, h});
 }
 
diff --git a/kernel/src/graphics/painter.hpp b/kernel/src/graphics/painter.hpp
index 33e3ae76..22044062 100644
--- a/kernel/src/graphics/painter.hpp
+++ b/kernel/src/graphics/painter.hpp
@@ -2,10 +2,12 @@
 #define KERNEL_SRC_GRAPHICS_PAINTER_HPP_
 
 #include <concepts.hpp>
+#include <span.hpp>
 #include <string.hpp>
 #include "graphics/color.hpp"
 #include "graphics/font/glyph.hpp"
 #include "graphics/geometry.hpp"
+#include "graphics/native_pixel.hpp"
 #include "graphics/surface.hpp"
 
 namespace Graphics
@@ -41,28 +43,25 @@ class Painter
     // Text Rendering
     // -------------------------------------------------------------------------
 
-    /**
-     * @brief Draws a single character using the provided font.
-     * @tparam FontT A type satisfying the FontType concept (e.g., Psf2Font).
-     */
     template <FontType FontT>
     void DrawChar(const CharCmd &cmd, const FontT &font);
 
-    /**
-     * @brief Draws a null-terminated string.
-     * Handles newlines (\n) and carriage returns (\r).
-     * @tparam FontT A type satisfying the FontType concept.
-     */
     template <FontType FontT>
     void DrawString(const TextCmd &cmd, const FontT &font);
 
+    // -------------------------------------------------------------------------
+    // Accessors
+    // -------------------------------------------------------------------------
+
+    NODISCARD Surface &GetTarget() { return target_; }
+    NODISCARD const PixelFormat &GetFormat() const { return format_; }
+
     private:
-    void FillScanline(u32 *dest, u32 count, u32 color);
-    NODISCARD FORCE_INLINE_F u32 PackColor(Color c) const;
+    void FillScanline(std::span<NativePixel> dest, NativePixel color);
 
     Surface &target_;
     PixelFormat format_;
-    u32 packed_color_;
+    NativePixel packed_color_;
 };
 
 }  // namespace Graphics
diff --git a/kernel/src/graphics/surface.hpp b/kernel/src/graphics/surface.hpp
index 54b2dd4c..a07eaf65 100644
--- a/kernel/src/graphics/surface.hpp
+++ b/kernel/src/graphics/surface.hpp
@@ -3,7 +3,9 @@
 
 #include <assert.h>
 #include <mem/types.hpp>
+#include <span.hpp>
 #include <types.hpp>
+#include "graphics/native_pixel.hpp"
 
 namespace Graphics
 {
@@ -17,7 +19,7 @@ class Surface
     public:
     Surface() = default;
 
-    Surface(Mem::VPtr<u32> buffer, u32 width, u32 height, u32 pitch_bytes)
+    Surface(Mem::VPtr<NativePixel> buffer, u32 width, u32 height, u32 pitch_bytes)
         : buffer_(buffer), width_(width), height_(height), pitch_bytes_(pitch_bytes)
     {
         R_ASSERT_NOT_NULL(buffer_);
@@ -37,40 +39,48 @@ class Surface
         ASSERT_EQ(height_, src.height_);
 
         for (u32 y = 0; y < height_; ++y) {
-            u32 *dest_row      = GetScanline(y);
-            const u32 *src_row = src.GetScanline(y);
+            std::span<NativePixel> dest_row      = GetScanline(y);
+            std::span<const NativePixel> src_row = src.GetScanline(y);
 
             // We use the width for the copy size, not the pitch,
             // to handle stride differences correctly.
-            memcpy(dest_row, src_row, width_ * sizeof(u32));
+            memcpy(dest_row.data(), src_row.data(), width_ * sizeof(NativePixel));
         }
     }
 
     // -------------------------------------------------------------------------
-    // Fast Accessors
+    // Accessors
     // -------------------------------------------------------------------------
 
-    NODISCARD FORCE_INLINE_F Mem::VPtr<u32> GetScanline(u32 y)
+    NODISCARD FORCE_INLINE_F std::span<NativePixel> GetScanline(u32 y)
     {
         ASSERT_LT(y, height_);
         // Pointer arithmetic on byte level for pitch
         uptr addr = Mem::PtrToUptr(buffer_) + (static_cast<size_t>(y) * pitch_bytes_);
-        return Mem::UptrToPtr<u32>(addr);
+        Mem::VPtr<NativePixel> ptr = Mem::UptrToPtr<NativePixel>(addr);
+        return std::span<NativePixel>(ptr, width_);
     }
 
-    NODISCARD FORCE_INLINE_F const Mem::VPtr<u32> GetScanline(u32 y) const
+    NODISCARD FORCE_INLINE_F std::span<const NativePixel> GetScanline(u32 y) const
     {
         ASSERT_LT(y, height_);
         uptr addr = Mem::PtrToUptr(buffer_) + (static_cast<size_t>(y) * pitch_bytes_);
-        return Mem::UptrToPtr<u32>(addr);
+        Mem::VPtr<NativePixel> ptr = Mem::UptrToPtr<NativePixel>(addr);
+        return std::span<const NativePixel>(ptr, width_);
     }
 
-    FORCE_INLINE_F u32 &Pixel(u32 x, u32 y)
+    FORCE_INLINE_F NativePixel &Pixel(u32 x, u32 y)
     {
         ASSERT_LT(x, width_);
         return GetScanline(y)[x];
     }
 
+    /**
+     * @brief Gets the unsafe raw buffer pointer.
+     * @warning Use only for high-performance code where bounds are checked manually.
+     */
+    NODISCARD FORCE_INLINE_F Mem::VPtr<NativePixel> GetRawBuffer() { return buffer_; }
+
     // -------------------------------------------------------------------------
     // Properties
     // -------------------------------------------------------------------------
@@ -81,7 +91,7 @@ class Surface
     NODISCARD FORCE_INLINE_F bool IsValid() const { return buffer_ != nullptr; }
 
     private:
-    Mem::VPtr<u32> buffer_{nullptr};
+    Mem::VPtr<NativePixel> buffer_{nullptr};
     u32 width_{0};
     u32 height_{0};
     u32 pitch_bytes_{0};  // Stride in bytes
diff --git a/kernel/src/kernel.cpp b/kernel/src/kernel.cpp
index ec2abf69..1944bf18 100644
--- a/kernel/src/kernel.cpp
+++ b/kernel/src/kernel.cpp
@@ -1,6 +1,7 @@
 #include <assert.h>
 #include <autogen/feature_flags.h>
 #include <time.h>
+#include <string.hpp>
 #include <test_module/test_module.hpp>
 #include "trace_framework.hpp"
 
@@ -10,11 +11,13 @@
 #include "graphics/font/psf2_font.hpp"
 #include "graphics/fonts/drdos8x8.hpp"
 #include "graphics/painter.hpp"
+#include "hal/terminal.hpp"
+#include "modules/video.hpp"
+#include "sys/shell.hpp"
 
 #include "boot_args.hpp"
 #include "hal/boot_args.hpp"
 #include "mem/heap.hpp"
-#include "modules/video.hpp"
 #include "todo.hpp"
 
 extern void KernelInit(const hal::RawBootArguments &);
@@ -25,62 +28,29 @@ static void KernelRun()
     trace::DumpAllBuffersOnFailure();
     TODO_MMU_MINIMAL
 
-    // static constexpr size_t kBuffSize = 256;
-    // char buff[kBuffSize];
-    //
-    // const auto t = time(nullptr);
-    // strftime(buff, kBuffSize, "%Y-%m-%d %H:%M:%S", localtime(&t));
-    //
-    // KernelTraceSuccess("Hello from AlkOS! Today we have: %s", buff);
-
-    auto &video  = VideoModule::Get();
-    auto &screen = video.GetScreen();
-    auto fmt     = video.GetFormat();
+    auto &video = VideoModule::Get();
+    Graphics::Painter painter(video.GetScreen(), video.GetFormat());
+    Graphics::Psf2Font font(drdos8x8_psfu);
 
-    Graphics::Painter p(screen, fmt);
-    Graphics::Psf2Font system_font(drdos8x8_psfu);
-
-    if (!system_font.IsValid()) {
-        TRACE_WARN_VIDEO("System font magic invalid! Rendering might be corrupted.");
+    if (!font.IsValid()) {
+        TRACE_WARN_VIDEO("Invalid font");
     }
 
-    // Animation Loop
-    i32 x     = 0;
-    i32 y     = 0;
-    u16 speed = 1;
-
-    while (true) {
-        p.Clear(Graphics::Color::Black());
+    System::GraphicsConsole console(painter, font);
+    System::Shell shell(console);
 
-        // Shape drawing
-        p.SetColor(Graphics::Color::Green());
-        p.FillRect({.x = x, .y = 100, .w = 50, .h = 50});
-        p.SetColor(Graphics::Color::Blue());
-        p.FillRect({.x = 100, .y = y, .w = 70, .h = 70});
-
-        // Text drawing
-        p.SetColor(Graphics::Color::White());
-        p.DrawString({.x = 40, .y = 20, .text = "AlkOS Kernel", .scale = 3}, system_font);
-
-        p.SetColor(Graphics::Color::Red());
-        p.DrawString(
-            {.x = 40, .y = 50, .text = "Graphics Subsystem Online.", .scale = 3}, system_font
-        );
-
-        // Dynamic Text Position
-        p.SetColor(Graphics::Color::Green());
-        p.DrawString({.x = x, .y = y + 80, .text = "Moving Text!", .scale = 2}, system_font);
+    shell.Init();
+    video.Flush();
 
+    while (true) {
+        // Poll Serial Port for input (temporary until IRQ is hooked)
+        char c = hal::TerminalGetChar();
+        shell.OnInput(c);
         video.Flush();
 
-        x += (speed / 255) + 1;
-        y += (speed / 255) + 1;
-        x = x % screen.GetWidth();
-        y = y % screen.GetHeight();
-
-        // crude delay
-        for (volatile int i = 0; i < 1000000; i++);
-        speed = speed + 10;
+        // Don't burn CPU 100%
+        for (volatile i32 i = 0; i < 10000; ++i) {
+        }
     }
 }
 
diff --git a/kernel/src/modules/video.cpp b/kernel/src/modules/video.cpp
index 49782801..56d646b3 100644
--- a/kernel/src/modules/video.cpp
+++ b/kernel/src/modules/video.cpp
@@ -1,4 +1,5 @@
 #include "modules/video.hpp"
+#include "graphics/native_pixel.hpp"
 #include "graphics/painter.hpp"
 #include "mem/types.hpp"
 #include "trace_framework.hpp"
@@ -12,7 +13,7 @@ internal::VideoModule::VideoModule(const BootArguments &args, Heap &hp) noexcept
     DEBUG_INFO_GENERAL("VideoModule::VideoModule()");
 
     const auto &fb_args = args.fb_args;
-    auto *fb_pptr       = static_cast<PPtr<u32>>(fb_args.base_address);
+    auto *fb_pptr       = static_cast<PPtr<Graphics::NativePixel>>(fb_args.base_address);
 
     R_ASSERT_NOT_NULL(fb_pptr, "VideoModule: Framebuffer is null");
 
diff --git a/kernel/src/sys/graphics_console.cpp b/kernel/src/sys/graphics_console.cpp
new file mode 100644
index 00000000..9e44e021
--- /dev/null
+++ b/kernel/src/sys/graphics_console.cpp
@@ -0,0 +1,130 @@
+#include "sys/graphics_console.hpp"
+
+#include <string.h>
+#include <algorithm.hpp>
+
+namespace System
+{
+
+GraphicsConsole::GraphicsConsole(Graphics::Painter &painter, const Graphics::Psf2Font &font)
+    : painter_(painter), font_(font)
+{
+    // Auto-scale based on resolution
+    scale_ = static_cast<u8>(std::max(1u, painter_.GetTarget().GetWidth() / 400));
+
+    glyph_w_ = font_.GetWidth() * scale_;
+    glyph_h_ = font_.GetHeight() * scale_;
+
+    // Calculate grid size
+    max_cols_ = painter_.GetTarget().GetWidth() / glyph_w_;
+    max_rows_ = painter_.GetTarget().GetHeight() / glyph_h_;
+
+    Clear();
+}
+
+void GraphicsConsole::SetColors(Graphics::Color fg, Graphics::Color bg)
+{
+    fg_color_ = fg;
+    bg_color_ = bg;
+}
+
+void GraphicsConsole::Clear()
+{
+    painter_.Clear(bg_color_);
+    cursor_x_ = 0;
+    cursor_y_ = 0;
+}
+
+void GraphicsConsole::ScrollUp()
+{
+    // Scroll by one line height
+    auto &surface      = painter_.GetTarget();
+    u32 pitch          = surface.GetPitch();
+    u32 bytes_per_line = pitch * glyph_h_;
+    u32 total_height   = surface.GetHeight();
+
+    u8 *raw_buf = reinterpret_cast<u8 *>(surface.GetRawBuffer());
+
+    // Move memory up
+    // Dest: Start of buffer
+    // Src: Start of buffer + one line of pixels
+    // Size: Total size - one line of pixels
+    memmove(
+        raw_buf, raw_buf + bytes_per_line, static_cast<size_t>(pitch * (total_height - glyph_h_))
+    );
+
+    // Clear bottom area using the painter to ensure correct color format
+    painter_.SetColor(bg_color_);
+    painter_.FillRect(
+        {0, static_cast<i32>(total_height - glyph_h_), static_cast<i32>(surface.GetWidth()),
+         static_cast<i32>(glyph_h_)}
+    );
+}
+
+void GraphicsConsole::NewLine()
+{
+    cursor_x_ = 0;
+    cursor_y_++;
+
+    if (cursor_y_ >= max_rows_) {
+        cursor_y_ = max_rows_ - 1;
+        ScrollUp();
+    }
+}
+
+void GraphicsConsole::InternalPutChar(char c)
+{
+    if (c == '\n') {
+        NewLine();
+        return;
+    }
+
+    if (c == '\r') {
+        cursor_x_ = 0;
+        return;
+    }
+
+    if (c == '\b') {
+        if (cursor_x_ > 0) {
+            cursor_x_--;
+            // Erase char
+            painter_.SetColor(bg_color_);
+            painter_.FillRect(
+                {static_cast<i32>(cursor_x_ * glyph_w_), static_cast<i32>(cursor_y_ * glyph_h_),
+                 static_cast<i32>(glyph_w_), static_cast<i32>(glyph_h_)}
+            );
+        }
+        return;
+    }
+
+    // Draw the character
+    Graphics::CharCmd cmd{
+        .x     = static_cast<i32>(cursor_x_ * glyph_w_),
+        .y     = static_cast<i32>(cursor_y_ * glyph_h_),
+        .c     = c,
+        .scale = scale_
+    };
+
+    // Clear background for char
+    painter_.SetColor(bg_color_);
+    painter_.FillRect({cmd.x, cmd.y, static_cast<i32>(glyph_w_), static_cast<i32>(glyph_h_)});
+
+    // Draw foreground
+    painter_.SetColor(fg_color_);
+    painter_.DrawChar(cmd, font_);
+
+    cursor_x_++;
+    if (cursor_x_ >= max_cols_) {
+        NewLine();
+    }
+}
+
+IO::IoResult GraphicsConsole::Write(std::span<const byte> buffer)
+{
+    for (const auto &b : buffer) {
+        InternalPutChar(static_cast<char>(b));
+    }
+    return buffer.size();
+}
+
+}  // namespace System
diff --git a/kernel/src/sys/graphics_console.hpp b/kernel/src/sys/graphics_console.hpp
new file mode 100644
index 00000000..3a18a058
--- /dev/null
+++ b/kernel/src/sys/graphics_console.hpp
@@ -0,0 +1,68 @@
+#ifndef KERNEL_SRC_SYS_GRAPHICS_CONSOLE_HPP_
+#define KERNEL_SRC_SYS_GRAPHICS_CONSOLE_HPP_
+
+#include <graphics/color.hpp>
+#include <graphics/font/psf2_font.hpp>
+#include <graphics/painter.hpp>
+#include <io/stream.hpp>
+
+namespace System
+{
+
+// --------------------------------------------------------------------------------
+// GraphicsConsole
+// --------------------------------------------------------------------------------
+
+class GraphicsConsole : public IO::IWriter
+{
+    public:
+    GraphicsConsole(Graphics::Painter &painter, const Graphics::Psf2Font &font);
+
+    // -------------------------------------------------------------------------
+    // IWriter Interface
+    // -------------------------------------------------------------------------
+
+    IO::IoResult Write(std::span<const byte> buffer) override;
+
+    // -------------------------------------------------------------------------
+    // Console Operations
+    // -------------------------------------------------------------------------
+
+    void Clear();
+
+    // -------------------------------------------------------------------------
+    // Configuration
+    // -------------------------------------------------------------------------
+
+    void SetColors(Graphics::Color fg, Graphics::Color bg);
+
+    private:
+    // -------------------------------------------------------------------------
+    // Internal Helpers
+    // -------------------------------------------------------------------------
+
+    void InternalPutChar(char c);
+    void NewLine();
+    void ScrollUp();
+
+    Graphics::Painter &painter_;
+    const Graphics::Psf2Font &font_;
+
+    // Cursor State
+    u32 cursor_x_{0};
+    u32 cursor_y_{0};
+
+    // Cache dimensions
+    u32 max_cols_{0};
+    u32 max_rows_{0};
+    u32 glyph_w_{0};
+    u32 glyph_h_{0};
+    u8 scale_{1};
+
+    Graphics::Color fg_color_{Graphics::Color::White()};
+    Graphics::Color bg_color_{Graphics::Color::Black()};
+};
+
+}  // namespace System
+
+#endif  // KERNEL_SRC_SYS_GRAPHICS_CONSOLE_HPP_
diff --git a/kernel/src/sys/shell.cpp b/kernel/src/sys/shell.cpp
new file mode 100644
index 00000000..5db0ecb8
--- /dev/null
+++ b/kernel/src/sys/shell.cpp
@@ -0,0 +1,101 @@
+#include "sys/shell.hpp"
+#include <string.h>
+#include <modules/memory.hpp>
+#include <string.hpp>
+
+namespace System
+{
+
+Shell::Shell(GraphicsConsole &console) : console_(console) {}
+
+void Shell::Init()
+{
+    console_.Write(
+        std::span<const byte>(reinterpret_cast<const byte *>("Welcome to AlkOS Shell!\n"), 24)
+    );
+    PrintPrompt();
+}
+
+void Shell::PrintPrompt()
+{
+    console_.SetColors(Graphics::Color::Green(), Graphics::Color::Black());
+    const char *p = "AlkOS> ";
+    console_.Write(std::span<const byte>(reinterpret_cast<const byte *>(p), strlen(p)));
+    console_.SetColors(Graphics::Color::White(), Graphics::Color::Black());
+}
+
+void Shell::OnInput(char c)
+{
+    // Handle Special Keys
+    if (c == '\n' || c == '\r') {
+        console_.PutChar('\n');
+        ProcessCommand();
+        input_buffer_.Resize(0);  // Clear buffer
+        PrintPrompt();
+        return;
+    }
+
+    if (c == '\b' || c == 0x7F) {  // Backspace
+        if (input_buffer_.Size() > 0) {
+            input_buffer_.Pop();
+            console_.PutChar('\b');
+        }
+        return;
+    }
+
+    // Normal character
+    if (input_buffer_.Size() < kMaxInput) {
+        input_buffer_.Push(c);
+        console_.PutChar(c);
+    }
+}
+
+void Shell::ProcessCommand()
+{
+    if (input_buffer_.Size() == 0) {
+        return;
+    }
+
+    std::string_view line(static_cast<const char *>(input_buffer_.Data()), input_buffer_.Size());
+
+    // Split command and args
+    size_t space_pos     = line.find(' ');
+    std::string_view cmd = (space_pos == std::string_view::npos) ? line : line.substr(0, space_pos);
+    std::string_view args = (space_pos == std::string_view::npos) ? "" : line.substr(space_pos + 1);
+
+    if (cmd == "help") {
+        CmdHelp();
+    } else if (cmd == "clear") {
+        CmdClear();
+    } else if (cmd == "echo") {
+        CmdEcho(args);
+    } else {
+        console_.Write(
+            std::span<const byte>(reinterpret_cast<const byte *>("Unknown command: "), 17)
+        );
+        console_.Write(
+            std::span<const byte>(reinterpret_cast<const byte *>(cmd.data()), cmd.size())
+        );
+        console_.PutChar('\n');
+    }
+}
+
+void Shell::CmdHelp()
+{
+    const char *msg =
+        "Available commands:\n"
+        "  help   - Show this message\n"
+        "  clear  - Clear the screen\n"
+        "  echo   - Print arguments\n";
+    console_.Write(std::span<const byte>(reinterpret_cast<const byte *>(msg), strlen(msg)));
+}
+
+void Shell::CmdClear() { console_.Clear(); }
+
+void Shell::CmdEcho(std::string_view args)
+{
+    console_.Write(std::span<const byte>(reinterpret_cast<const byte *>(args.data()), args.size()));
+    console_.PutChar('\n');
+}
+
+}  // namespace System
diff --git a/kernel/src/sys/shell.hpp b/kernel/src/sys/shell.hpp
new file mode 100644
index 00000000..6b2d028a
--- /dev/null
+++ b/kernel/src/sys/shell.hpp
@@ -0,0 +1,57 @@
+#ifndef KERNEL_SRC_SYS_SHELL_HPP_
+#define KERNEL_SRC_SYS_SHELL_HPP_
+
+#include <data_structures/array_structures.hpp>
+#include <span.hpp>
+#include <string.hpp>
+
+#include "sys/graphics_console.hpp"
+
+namespace System
+{
+
+// --------------------------------------------------------------------------------
+// Shell
+// --------------------------------------------------------------------------------
+
+class Shell
+{
+    public:
+    explicit Shell(GraphicsConsole &console);
+
+    // -------------------------------------------------------------------------
+    // Public Interface
+    // -------------------------------------------------------------------------
+
+    void Init();
+
+    // Call this when hardware receives a keystroke
+    void OnInput(char c);
+
+    private:
+    // -------------------------------------------------------------------------
+    // Command Processing
+    // -------------------------------------------------------------------------
+
+    void ProcessCommand();
+    void PrintPrompt();
+
+    // -------------------------------------------------------------------------
+    // Command Handlers
+    // -------------------------------------------------------------------------
+
+    void CmdHelp();
+    void CmdClear();
+    void CmdEcho(std::string_view args);
+    void CmdMem();
+
+    // Data
+    GraphicsConsole &console_;
+
+    static constexpr size_t kMaxInput = 128;
+    data_structures::StaticVector<char, kMaxInput> input_buffer_;
+};
+
+}  // namespace System
+
+#endif  // KERNEL_SRC_SYS_SHELL_HPP_

From 426cf17f9740ab24052cbb09911ec48664626e8c Mon Sep 17 00:00:00 2001
From: Adam Ogieniewski <ogieniewski.dev@gmail.com>
Date: Thu, 11 Dec 2025 06:29:56 +0100
Subject: [PATCH 05/56] Add common data structures (#235)

Introduce several new data structures and allocator wrappers:
- CritBitTree: A binary crit-bit tree for NULL-terminated strings.
- LinkedList: Generic single and double linked lists with custom
allocators.
- LruCache: A fixed-capacity LRU cache.
- TaggedPointer: Stores type info in unused pointer bits.
- CustomAllocatorWrapper: Enables using custom allocators with
containers.
---
 kernel/src/interrupts/interrupt_types.hpp     |   4 +-
 kernel/test/critbit_tree_test.cpp             | 171 ++++++
 kernel/test/linked_list_test.cpp              | 333 ++++++++++++
 kernel/test/lru_cache_tests.cpp               |  78 +++
 kernel/test/tagged_pointer_test.cpp           |  73 +++
 .../allocators/custom_allocator_wrapper.hpp   |  62 +++
 .../include/data_structures/critbit_tree.hpp  | 370 +++++++++++++
 .../include/data_structures/linked_list.hpp   | 505 ++++++++++++++++++
 .../include/data_structures/lru_cache.hpp     | 115 ++++
 .../data_structures/tagged_pointer.hpp        | 214 ++++++++
 libs/libtemplate/include/template/utils.hpp   |  10 +-
 11 files changed, 1928 insertions(+), 7 deletions(-)
 create mode 100644 kernel/test/critbit_tree_test.cpp
 create mode 100644 kernel/test/linked_list_test.cpp
 create mode 100644 kernel/test/lru_cache_tests.cpp
 create mode 100644 kernel/test/tagged_pointer_test.cpp
 create mode 100644 libs/libcontainers/include/allocators/custom_allocator_wrapper.hpp
 create mode 100644 libs/libcontainers/include/data_structures/critbit_tree.hpp
 create mode 100644 libs/libcontainers/include/data_structures/linked_list.hpp
 create mode 100644 libs/libcontainers/include/data_structures/lru_cache.hpp
 create mode 100644 libs/libcontainers/include/data_structures/tagged_pointer.hpp

diff --git a/kernel/src/interrupts/interrupt_types.hpp b/kernel/src/interrupts/interrupt_types.hpp
index 22d21066..d738c891 100644
--- a/kernel/src/interrupts/interrupt_types.hpp
+++ b/kernel/src/interrupts/interrupt_types.hpp
@@ -40,9 +40,7 @@ struct InterruptHandlerEntry {
     HandlerData handler_data{};
     u16 logical_irq{};
     u64 hardware_irq{};
-    template_lib::OptionalField<
-        kInterruptType == InterruptType::kHardwareInterrupt, InterruptDriver *>
-        driver{};
+    OPTIONAL_FIELD(kInterruptType == InterruptType::kHardwareInterrupt, InterruptDriver *) driver{};
 };
 
 template <InterruptType kInterruptType>
diff --git a/kernel/test/critbit_tree_test.cpp b/kernel/test/critbit_tree_test.cpp
new file mode 100644
index 00000000..29530741
--- /dev/null
+++ b/kernel/test/critbit_tree_test.cpp
@@ -0,0 +1,171 @@
+#include <test_module/test.hpp>
+
+#include <data_structures/critbit_tree.hpp>
+#include <optional.hpp>
+#include <trace_framework.hpp>
+
+using namespace data_structures;
+
+class CritBitTreeTest : public TestGroupBase
+{
+};
+
+TEST_F(CritBitTreeTest, InsertAndContains)
+{
+    CritBitTree<int> tree;
+
+    R_ASSERT_FALSE(tree.Contains("key1"));
+    R_ASSERT_TRUE(tree.Insert("key1", 42));
+    R_ASSERT_TRUE(tree.Contains("key1"));
+
+    R_ASSERT_FALSE(tree.Contains("key2"));
+    R_ASSERT_TRUE(tree.Insert("key2", 67));
+    R_ASSERT_TRUE(tree.Contains("key2"));
+}
+
+TEST_F(CritBitTreeTest, InsertOverwrite)
+{
+    CritBitTree<int> tree;
+
+    R_ASSERT_TRUE(tree.Insert("key", 42));
+    R_ASSERT_TRUE(tree.Contains("key"));
+
+    R_ASSERT_FALSE(tree.Insert<false>("key", 67));
+    R_ASSERT_TRUE(tree.Contains("key"));
+
+    R_ASSERT_TRUE(tree.Insert<true>("key", 67));
+    R_ASSERT_TRUE(tree.Contains("key"));
+}
+
+TEST_F(CritBitTreeTest, Get)
+{
+    CritBitTree<int> tree;
+
+    R_ASSERT_TRUE(tree.Insert("key", 42));
+
+    auto retrieved = tree.Get("key");
+    R_ASSERT_TRUE(retrieved);
+    R_ASSERT_EQ(42, **retrieved);
+
+    retrieved = tree.Get("nonexistent");
+    R_ASSERT_FALSE(retrieved.has_value());
+}
+
+TEST_F(CritBitTreeTest, Remove)
+{
+    CritBitTree<int> tree;
+
+    R_ASSERT_TRUE(tree.Insert("key", 42));
+    R_ASSERT_TRUE(tree.Contains("key"));
+
+    R_ASSERT_TRUE(tree.Remove("key"));
+    R_ASSERT_FALSE(tree.Contains("key"));
+
+    R_ASSERT_FALSE(tree.Remove("key"));
+}
+
+TEST_F(CritBitTreeTest, ComplexOperations)
+{
+    CritBitTree<int> tree;
+
+    R_ASSERT_TRUE(tree.Insert("apple", 1));
+    R_ASSERT_TRUE(tree.Insert("banana", 2));
+    R_ASSERT_TRUE(tree.Insert("apricot", 3));
+    R_ASSERT_TRUE(tree.Insert("blueberry", 4));
+
+    R_ASSERT_TRUE(tree.Contains("apple"));
+    R_ASSERT_TRUE(tree.Contains("banana"));
+    R_ASSERT_TRUE(tree.Contains("apricot"));
+    R_ASSERT_TRUE(tree.Contains("blueberry"));
+
+    R_ASSERT_TRUE(tree.Remove("banana"));
+    R_ASSERT_FALSE(tree.Contains("banana"));
+
+    auto retrieved = tree.Get("apricot");
+    R_ASSERT_TRUE(retrieved);
+    R_ASSERT_EQ(3, **retrieved);
+}
+
+TEST_F(CritBitTreeTest, EmptyTreeOperations)
+{
+    CritBitTree<int> tree;
+
+    R_ASSERT_FALSE(tree.Contains("key"));
+    R_ASSERT_FALSE(tree.Remove("key"));
+
+    auto retrieved = tree.Get("key");
+    R_ASSERT_FALSE(retrieved.has_value());
+}
+
+TEST_F(CritBitTreeTest, InsertSimilarKeys)
+{
+    CritBitTree<int> tree;
+
+    R_ASSERT_TRUE(tree.Insert("test", 10));
+    R_ASSERT_TRUE(tree.Insert("testing", 20));
+    R_ASSERT_TRUE(tree.Insert("tester", 30));
+
+    R_ASSERT_TRUE(tree.Contains("test"));
+    R_ASSERT_TRUE(tree.Contains("testing"));
+    R_ASSERT_TRUE(tree.Contains("tester"));
+
+    auto retrieved = tree.Get("testing");
+    R_ASSERT_TRUE(retrieved);
+    R_ASSERT_EQ(20, **retrieved);
+}
+
+TEST_F(CritBitTreeTest, RemoveNonExistentKey)
+{
+    CritBitTree<int> tree;
+
+    R_ASSERT_FALSE(tree.Remove("nonexistent"));
+
+    R_ASSERT_TRUE(tree.Insert("existent", 100));
+    R_ASSERT_TRUE(tree.Remove("existent"));
+    R_ASSERT_FALSE(tree.Remove("existent"));
+}
+
+TEST_F(CritBitTreeTest, ConstGet)
+{
+    CritBitTree<int> tree;
+
+    R_ASSERT_TRUE(tree.Insert("constKey", 55));
+
+    const auto &const_tree = tree;
+    auto retrieved         = const_tree.Get("constKey");
+    R_ASSERT_TRUE(retrieved);
+    R_ASSERT_EQ(55, **retrieved);
+}
+
+TEST_F(CritBitTreeTest, IndexOperator)
+{
+    CritBitTree<int> tree;
+
+    R_ASSERT_TRUE(tree.Insert("indexKey", 77));
+
+    auto retrieved = tree["indexKey"];
+    R_ASSERT_TRUE(retrieved);
+    R_ASSERT_EQ(77, **retrieved);
+
+    retrieved = tree["nonexistentKey"];
+    R_ASSERT_FALSE(retrieved.has_value());
+}
+
+TEST_F(CritBitTreeTest, ComplexFilePaths)
+{
+    CritBitTree<int> tree;
+
+    R_ASSERT_TRUE(tree.Insert("/home/user/docs", 1));
+    R_ASSERT_TRUE(tree.Insert("/home/user/images", 2));
+    R_ASSERT_TRUE(tree.Insert("/var/log/syslog", 3));
+    R_ASSERT_TRUE(tree.Insert("/etc/config/settings", 4));
+
+    R_ASSERT_TRUE(tree.Contains("/home/user/docs"));
+    R_ASSERT_TRUE(tree.Contains("/home/user/images"));
+    R_ASSERT_TRUE(tree.Contains("/var/log/syslog"));
+    R_ASSERT_TRUE(tree.Contains("/etc/config/settings"));
+
+    auto retrieved = tree.Get("/var/log/syslog");
+    R_ASSERT_TRUE(retrieved);
+    R_ASSERT_EQ(3, **retrieved);
+}
diff --git a/kernel/test/linked_list_test.cpp b/kernel/test/linked_list_test.cpp
new file mode 100644
index 00000000..fd05815d
--- /dev/null
+++ b/kernel/test/linked_list_test.cpp
@@ -0,0 +1,333 @@
+#include <data_structures/linked_list.hpp>
+#include <mem/cyclic_allocator.hpp>
+#include <test_module/test.hpp>
+
+// ------------------------------
+// SingleLinkedList
+// ------------------------------
+
+using IntSingleList = data_structures::SingleLinkedList<int>;
+
+class SingleLinkedListTest : public TestGroupBase
+{
+    public:
+    IntSingleList list;
+};
+
+TEST_F(SingleLinkedListTest, EmptyList)
+{
+    EXPECT_TRUE(list.Empty());
+    EXPECT_EQ(0_size, list.Size());
+    EXPECT_EQ(nullptr, list.GetHead());
+}
+
+TEST_F(SingleLinkedListTest, PushFront)
+{
+    list.PushFront(1);
+    EXPECT_EQ(1_size, list.Size());
+    EXPECT_EQ(1, list.Front());
+
+    list.PushFront(2);
+    EXPECT_EQ(2_size, list.Size());
+    EXPECT_EQ(2, list.Front());
+
+    list.PushFront(0);
+    EXPECT_EQ(3_size, list.Size());
+    EXPECT_EQ(0, list.Front());
+}
+
+TEST_F(SingleLinkedListTest, PopFront)
+{
+    list.PushFront(3);
+    list.PushFront(2);
+    list.PushFront(1);
+
+    list.PopFront();
+    EXPECT_EQ(2_size, list.Size());
+    EXPECT_EQ(2, list.Front());
+
+    list.PopFront();
+    EXPECT_EQ(1_size, list.Size());
+    EXPECT_EQ(3, list.Front());
+
+    list.PopFront();
+    EXPECT_TRUE(list.Empty());
+}
+
+TEST_F(SingleLinkedListTest, Clear)
+{
+    list.PushFront(1);
+    list.PushFront(2);
+    list.PushFront(3);
+
+    EXPECT_EQ(3_size, list.Size());
+    list.Clear();
+    EXPECT_TRUE(list.Empty());
+    EXPECT_EQ(0_size, list.Size());
+}
+
+TEST_F(SingleLinkedListTest, Iterator)
+{
+    list.PushFront(3);
+    list.PushFront(2);
+    list.PushFront(1);
+
+    int expected = 1;
+    for (auto value : list) {
+        EXPECT_EQ(expected, value);
+        ++expected;
+    }
+}
+
+TEST_F(SingleLinkedListTest, MoveConstructor)
+{
+    list.PushFront(2);
+    list.PushFront(1);
+
+    IntSingleList otherList(std::move(list));
+    EXPECT_TRUE(list.Empty());
+    EXPECT_EQ(2_size, otherList.Size());
+    EXPECT_EQ(1, otherList.Front());
+}
+
+TEST_F(SingleLinkedListTest, MoveAssignment)
+{
+    list.PushFront(2);
+    list.PushFront(1);
+
+    IntSingleList otherList;
+    otherList.PushFront(99);
+
+    otherList = std::move(list);
+    EXPECT_TRUE(list.Empty());
+    EXPECT_EQ(2_size, otherList.Size());
+    EXPECT_EQ(1, otherList.Front());
+}
+
+TEST_F(SingleLinkedListTest, CustomAllocator)
+{
+    data_structures::StaticSingleLinkedList<int, 8> list;
+
+    list.PushFront(3);
+    list.PushFront(2);
+    list.PushFront(1);
+
+    EXPECT_EQ(3_size, list.Size());
+    EXPECT_EQ(1, list.Front());
+
+    list.Clear();
+    EXPECT_EQ(0_size, list.Size());
+}
+
+TEST_F(SingleLinkedListTest, InsertAfter)
+{
+    auto *node1 = list.PushFront(1);
+    auto *node2 = list.InsertAfter(node1, 2);
+    list.InsertAfter(node2, 3);
+
+    EXPECT_EQ(3_size, list.Size());
+
+    int expected = 1;
+    for (auto value : list) {
+        EXPECT_EQ(expected, value);
+        ++expected;
+    }
+}
+
+TEST_F(SingleLinkedListTest, StructureSizes)
+{
+    EXPECT_EQ(16_size, sizeof(IntSingleList::Node));
+    EXPECT_EQ(16_size, sizeof(IntSingleList));
+}
+
+// ------------------------------
+// DoubleLinkedList
+// ------------------------------
+
+using IntDoubleList = data_structures::DoubleLinkedList<int>;
+
+class DoubleLinkedListTest : public TestGroupBase
+{
+    public:
+    IntDoubleList list;
+};
+
+TEST_F(DoubleLinkedListTest, EmptyList)
+{
+    EXPECT_TRUE(list.Empty());
+    EXPECT_EQ(0_size, list.Size());
+    EXPECT_EQ(nullptr, list.GetHead());
+    EXPECT_EQ(nullptr, list.GetTail());
+}
+
+TEST_F(DoubleLinkedListTest, PushFrontAndBack)
+{
+    list.PushFront(1);
+    EXPECT_EQ(1_size, list.Size());
+    EXPECT_EQ(1, list.Front());
+    EXPECT_EQ(1, list.Back());
+
+    list.PushBack(2);
+    EXPECT_EQ(2_size, list.Size());
+    EXPECT_EQ(1, list.Front());
+    EXPECT_EQ(2, list.Back());
+
+    list.PushFront(0);
+    EXPECT_EQ(3_size, list.Size());
+    EXPECT_EQ(0, list.Front());
+    EXPECT_EQ(2, list.Back());
+}
+
+TEST_F(DoubleLinkedListTest, PopFrontAndBack)
+{
+    list.PushBack(1);
+    list.PushBack(2);
+    list.PushBack(3);
+
+    list.PopFront();
+    EXPECT_EQ(2_size, list.Size());
+    EXPECT_EQ(2, list.Front());
+
+    list.PopBack();
+    EXPECT_EQ(1_size, list.Size());
+    EXPECT_EQ(2, list.Back());
+
+    list.PopBack();
+    EXPECT_TRUE(list.Empty());
+}
+
+TEST_F(DoubleLinkedListTest, RemoveNode)
+{
+    auto *node1 = list.PushBack(1);
+    auto *node2 = list.PushBack(2);
+    auto *node3 = list.PushBack(3);
+
+    list.Remove(node2);
+    EXPECT_EQ(2_size, list.Size());
+    EXPECT_EQ(1, list.Front());
+    EXPECT_EQ(3, list.Back());
+
+    list.Remove(node1);
+    EXPECT_EQ(1_size, list.Size());
+    EXPECT_EQ(3, list.Front());
+
+    list.Remove(node3);
+    EXPECT_TRUE(list.Empty());
+}
+
+TEST_F(DoubleLinkedListTest, MoveToFront)
+{
+    auto *node1 = list.PushBack(1);
+    auto *node2 = list.PushBack(2);
+    auto *node3 = list.PushBack(3);
+
+    list.MoveToFront(node3);
+    EXPECT_EQ(3, list.Front());
+    EXPECT_EQ(2, list.Back());
+
+    list.MoveToFront(node1);
+    EXPECT_EQ(1, list.Front());
+}
+
+TEST_F(DoubleLinkedListTest, MoveToBack)
+{
+    auto *node1 = list.PushBack(1);
+    auto *node2 = list.PushBack(2);
+    auto *node3 = list.PushBack(3);
+
+    list.MoveToBack(node1);
+    EXPECT_EQ(2, list.Front());
+    EXPECT_EQ(1, list.Back());
+
+    list.MoveToBack(node3);
+    EXPECT_EQ(3, list.Back());
+}
+
+TEST_F(DoubleLinkedListTest, Clear)
+{
+    list.PushBack(1);
+    list.PushBack(2);
+    list.PushBack(3);
+
+    EXPECT_EQ(3_size, list.Size());
+    list.Clear();
+    EXPECT_TRUE(list.Empty());
+    EXPECT_EQ(0_size, list.Size());
+}
+
+TEST_F(DoubleLinkedListTest, Iterator)
+{
+    list.PushBack(1);
+    list.PushBack(2);
+    list.PushBack(3);
+
+    int expected = 1;
+    for (auto value : list) {
+        EXPECT_EQ(expected, value);
+        ++expected;
+    }
+}
+
+TEST_F(DoubleLinkedListTest, MoveConstructor)
+{
+    list.PushBack(1);
+    list.PushBack(2);
+
+    IntDoubleList otherList(std::move(list));
+    EXPECT_TRUE(list.Empty());
+    EXPECT_EQ(2_size, otherList.Size());
+    EXPECT_EQ(1, otherList.Front());
+    EXPECT_EQ(2, otherList.Back());
+}
+
+TEST_F(DoubleLinkedListTest, MoveAssignment)
+{
+    list.PushBack(1);
+    list.PushBack(2);
+
+    IntDoubleList otherList;
+    otherList.PushBack(99);
+
+    otherList = std::move(list);
+    EXPECT_TRUE(list.Empty());
+    EXPECT_EQ(2_size, otherList.Size());
+    EXPECT_EQ(1, otherList.Front());
+    EXPECT_EQ(2, otherList.Back());
+}
+
+TEST_F(DoubleLinkedListTest, CustomAllocator)
+{
+    data_structures::StaticDoubleLinkedList<int, 8> list;
+
+    list.PushBack(1);
+    list.PushBack(2);
+    list.PushBack(3);
+
+    EXPECT_EQ(3_size, list.Size());
+    EXPECT_EQ(1, list.Front());
+    EXPECT_EQ(3, list.Back());
+
+    list.Clear();
+    EXPECT_EQ(0_size, list.Size());
+}
+
+TEST_F(DoubleLinkedListTest, InsertAfter)
+{
+    auto *node1 = list.PushBack(1);
+    auto *node2 = list.InsertAfter(node1, 2);
+    list.InsertAfter(node2, 3);
+
+    EXPECT_EQ(3_size, list.Size());
+
+    int expected = 1;
+    for (auto value : list) {
+        EXPECT_EQ(expected, value);
+        ++expected;
+    }
+}
+
+TEST_F(DoubleLinkedListTest, StructureSizes)
+{
+    EXPECT_EQ(24_size, sizeof(IntDoubleList::Node));  // 20 + 4 bytes padding
+    EXPECT_EQ(24_size, sizeof(IntDoubleList));
+}
diff --git a/kernel/test/lru_cache_tests.cpp b/kernel/test/lru_cache_tests.cpp
new file mode 100644
index 00000000..a1b45aad
--- /dev/null
+++ b/kernel/test/lru_cache_tests.cpp
@@ -0,0 +1,78 @@
+#include <data_structures/lru_cache.hpp>
+#include <test_module/test.hpp>
+
+class LruCacheTest : public TestGroupBase
+{
+    public:
+    data_structures::LruCache<int, int, 3> cache;
+};
+
+TEST_F(LruCacheTest, InsertionAndLookup)
+{
+    cache.Put(1, 10);
+    cache.Put(2, 20);
+    cache.Put(3, 30);
+
+    EXPECT_EQ(3_size, cache.Size());
+    EXPECT_EQ(30, *cache.Get(3));
+    EXPECT_EQ(20, *cache.Get(2));
+    EXPECT_EQ(10, *cache.Get(1));
+    EXPECT_EQ(nullptr, cache.Get(42));
+}
+
+TEST_F(LruCacheTest, UpdateKeepsSizeAndMovesToFront)
+{
+    cache.Put(1, 10);
+    cache.Put(2, 20);
+    cache.Put(3, 30);
+
+    cache.Put(2, 200);
+    EXPECT_EQ(3_size, cache.Size());
+    EXPECT_EQ(200, *cache.Get(2));
+
+    cache.Put(4, 40);
+    EXPECT_EQ(nullptr, cache.Get(1));
+    EXPECT_NOT_NULL(cache.Get(4));
+    EXPECT_NOT_NULL(cache.Get(2));
+    EXPECT_NOT_NULL(cache.Get(3));
+}
+
+TEST_F(LruCacheTest, EvictionOfLruEntry)
+{
+    cache.Put(1, 10);
+    cache.Put(2, 20);
+    cache.Put(3, 30);
+    EXPECT_NOT_NULL(cache.Get(1));
+
+    cache.Put(4, 30);
+    EXPECT_EQ(nullptr, cache.Get(2));
+    EXPECT_NOT_NULL(cache.Get(1));
+    EXPECT_NOT_NULL(cache.Get(3));
+
+    cache.Get(1);
+    cache.Put(5, 40);
+    EXPECT_EQ(nullptr, cache.Get(4));
+    EXPECT_NOT_NULL(cache.Get(3));
+    EXPECT_NOT_NULL(cache.Get(1));
+    EXPECT_NOT_NULL(cache.Get(5));
+    EXPECT_EQ(3_size, cache.Size());
+}
+
+TEST_F(LruCacheTest, EraseAndClear)
+{
+    cache.Put(1, 10);
+    cache.Put(2, 20);
+    cache.Put(3, 30);
+
+    EXPECT_EQ(3_size, cache.Size());
+    EXPECT_TRUE(cache.Erase(2));
+    EXPECT_EQ(nullptr, cache.Get(2));
+    EXPECT_EQ(2_size, cache.Size());
+
+    EXPECT_FALSE(cache.Erase(42));
+
+    cache.Clear();
+    EXPECT_EQ(0_size, cache.Size());
+    EXPECT_TRUE(cache.Empty());
+    EXPECT_EQ(nullptr, cache.Get(1));
+}
diff --git a/kernel/test/tagged_pointer_test.cpp b/kernel/test/tagged_pointer_test.cpp
new file mode 100644
index 00000000..e9ff57cb
--- /dev/null
+++ b/kernel/test/tagged_pointer_test.cpp
@@ -0,0 +1,73 @@
+#include <test_module/test.hpp>
+
+#include <data_structures/tagged_pointer.hpp>
+
+using namespace data_structures;
+
+class TaggedPointerTest : public TestGroupBase
+{
+};
+
+struct AlignedStruct1 {
+    int value;
+    AlignedStruct1(int v) : value(v) {}
+};
+
+struct AlignedStruct2 {
+    long long a, b, c;
+
+    AlignedStruct2(long long x, long long y, long long z) : a(x), b(y), c(z) {}
+};
+
+using TagPtr = TaggedPointer<AlignedStruct1, AlignedStruct2>;
+
+TEST_F(TaggedPointerTest, BasicCreateAndIs)
+{
+    // Test Create with tag dispatch - uses universal reference binding
+    auto ptr1 = TagPtr::Construct<AlignedStruct1>(42);
+    R_ASSERT_TRUE(ptr1.IsValid());
+    R_ASSERT_TRUE(ptr1.Is<AlignedStruct1>());
+    R_ASSERT_FALSE(ptr1.Is<AlignedStruct2>());
+
+    auto ptr2 = TagPtr::Construct<AlignedStruct2>(1LL, 2LL, 3LL);
+    R_ASSERT_TRUE(ptr2.IsValid());
+    R_ASSERT_FALSE(ptr2.Is<AlignedStruct1>());
+    R_ASSERT_TRUE(ptr2.Is<AlignedStruct2>());
+}
+
+TEST_F(TaggedPointerTest, AsMethod)
+{
+    auto ptr1 = TagPtr::Construct<AlignedStruct1>(100);
+
+    auto &s1 = ptr1.As<AlignedStruct1>();
+    R_ASSERT_EQ(100, s1.value);
+
+    auto ptr2 = TagPtr::Construct<AlignedStruct2>(10LL, 20LL, 30LL);
+
+    auto &s2 = ptr2.As<AlignedStruct2>();
+    R_ASSERT_EQ(10LL, s2.a);
+    R_ASSERT_EQ(20LL, s2.b);
+    R_ASSERT_EQ(30LL, s2.c);
+}
+
+TEST_F(TaggedPointerTest, MoveSemantics)
+{
+    auto ptr1 = TagPtr::Construct<AlignedStruct1>(123);
+    R_ASSERT_TRUE(ptr1.IsValid());
+
+    // Move construction
+    auto ptr2 = std::move(ptr1);
+    R_ASSERT_FALSE(ptr1.IsValid());  // moved-from object is invalid
+    R_ASSERT_TRUE(ptr2.IsValid());
+    R_ASSERT_EQ(123, ptr2.As<AlignedStruct1>().value);
+
+    // Move assignment
+    auto ptr3 = TagPtr::Construct<AlignedStruct2>(5LL, 10LL, 15LL);
+    R_ASSERT_TRUE(ptr3.IsValid());
+
+    ptr3 = std::move(ptr2);
+    R_ASSERT_FALSE(ptr2.IsValid());  // moved-from object is invalid
+    R_ASSERT_TRUE(ptr3.IsValid());
+    R_ASSERT_TRUE(ptr3.Is<AlignedStruct1>());
+    R_ASSERT_EQ(123, ptr3.As<AlignedStruct1>().value);
+}
diff --git a/libs/libcontainers/include/allocators/custom_allocator_wrapper.hpp b/libs/libcontainers/include/allocators/custom_allocator_wrapper.hpp
new file mode 100644
index 00000000..020d60ae
--- /dev/null
+++ b/libs/libcontainers/include/allocators/custom_allocator_wrapper.hpp
@@ -0,0 +1,62 @@
+#ifndef LIBS_LIBCONTAINERS_INCLUDE_ALLOCATORS_CUSTOM_ALLOCATOR_WRAPPER_HPP_
+#define LIBS_LIBCONTAINERS_INCLUDE_ALLOCATORS_CUSTOM_ALLOCATOR_WRAPPER_HPP_
+
+#include <mem/cyclic_allocator.hpp>
+#include <mem/heap.hpp>
+#include <template_lib.hpp>
+#include <type_traits.hpp>
+
+namespace allocators
+{
+
+template <decltype(auto) AllocateFunc, decltype(auto) DeallocateFunc, typename AllocatorT = void>
+class CustomAllocatorWrapper : decltype(AllocateFunc), decltype(DeallocateFunc)
+{
+    static constexpr bool kCondition = !std::is_void_v<AllocatorT>;
+
+    public:
+    template <typename U, typename... Args>
+    FORCE_INLINE_F U *Allocate(Args &&...args)
+    {
+        return decltype(AllocateFunc)::operator()(std::forward<Args>(args)...);
+    }
+
+    template <typename U>
+    FORCE_INLINE_F void Deallocate(U *ptr)
+    {
+        decltype(DeallocateFunc)::operator()(ptr);
+    }
+
+    OPTIONAL_FIELD(kCondition, AllocatorT) Allocator {};
+};
+
+template <typename T>
+using KMallocAllocator = CustomAllocatorWrapper<
+    []<typename... Args>(this auto &, Args &&...args) FORCE_INLINE_L {
+        auto mem = Mem::KMalloc<T>();
+        if (!mem) {
+            return static_cast<T *>(nullptr);
+        }
+
+        return new (*mem) T(std::forward<Args>(args)...);
+    },
+    []<typename U>(this auto &, U *ptr) FORCE_INLINE_L {
+        if (ptr) {
+            ptr->~U();
+            Mem::KFree(ptr);
+        }
+    }>;
+
+template <typename T, size_t kPoolSize>
+using CyclicAllocatorWrapper = CustomAllocatorWrapper<
+    []<typename... Args>(this auto &self, Args &&...args) FORCE_INLINE_L {
+        return self.Allocator.Allocate(std::forward<Args>(args)...);
+    },
+    []<typename U>(this auto &self, U *ptr) FORCE_INLINE_L {
+        self.Allocator.Free(ptr);
+    },
+    CyclicAllocator<T, kPoolSize>>;
+
+}  // namespace allocators
+
+#endif  // LIBS_LIBCONTAINERS_INCLUDE_ALLOCATORS_CUSTOM_ALLOCATOR_WRAPPER_HPP_
diff --git a/libs/libcontainers/include/data_structures/critbit_tree.hpp b/libs/libcontainers/include/data_structures/critbit_tree.hpp
new file mode 100644
index 00000000..02beffe6
--- /dev/null
+++ b/libs/libcontainers/include/data_structures/critbit_tree.hpp
@@ -0,0 +1,370 @@
+#ifndef LIBS_LIBCONTAINERS_INCLUDE_DATA_STRUCTURES_CRITBIT_TREE_HPP_
+#define LIBS_LIBCONTAINERS_INCLUDE_DATA_STRUCTURES_CRITBIT_TREE_HPP_
+
+#include <string.h>
+#include <data_structures/bit_array.hpp>
+#include <data_structures/tagged_pointer.hpp>
+#include <mem/heap.hpp>
+#include <new.hpp>
+#include <optional.hpp>
+#include <string.hpp>
+
+namespace data_structures
+{
+
+// Crit-bit tree reference:
+// https://github.com/agl/critbit/blob/4bb69901a9813de05331bd3afc5085e00050f701/critbit.pdf
+
+/**
+ * @brief A binary crit-bit tree implementation for NUL-terminated strings.
+ *
+ * This implementation uses a `TaggedPointer` to distinguish between
+ * internal nodes and external nodes.
+ *
+ * @tparam T The type of value stored in the tree.
+ */
+template <typename T>
+class CritBitTree
+{
+    // Forward declarations
+    struct ExternalNode;
+    struct InternalNode;
+
+    // Tag 0: ExternalNode
+    // Tag 1: InternalNode
+    using NodePtr = TaggedPointer<ExternalNode, InternalNode>;
+
+    struct ExternalNode {
+        char *key;
+        T value;
+
+        template <typename... Args>
+        ExternalNode(const char *k, Args &&...args) : value(std::forward<Args>(args)...)
+        {
+            const size_t len = strlen(k);
+            key              = static_cast<char *>(Mem::KMalloc(len + 1).value_or(nullptr));
+            if (key) {
+                strncpy(key, k, len + 1);
+            }
+        }
+
+        ~ExternalNode()
+        {
+            if (key) {
+                Mem::KFree(key);
+            }
+        }
+    };
+
+    struct InternalNode {
+        NodePtr child[2];
+        u32 byte;
+        u8 mask;
+
+        InternalNode(u32 b, u8 o) : byte(b), mask(o) {}
+        ~InternalNode() = default;
+    };
+
+    public:
+    using value_type    = T;
+    using pointer       = value_type *;
+    using const_pointer = const value_type *;
+
+    // -----------------------------------------------------------------------------
+    // Construction / Destruction
+    // -----------------------------------------------------------------------------
+
+    CritBitTree() = default;
+
+    ~CritBitTree() { Clear(); }
+
+    CritBitTree(const CritBitTree &)            = delete;
+    CritBitTree &operator=(const CritBitTree &) = delete;
+
+    CritBitTree(CritBitTree &&other) noexcept : root_(std::move(other.root_)) {}
+
+    CritBitTree &operator=(CritBitTree &&other) noexcept
+    {
+        if (this != &other) {
+            root_ = std::move(other.root_);
+        }
+        return *this;
+    }
+
+    // -----------------------------------------------------------------------------
+    // Public API
+    // -----------------------------------------------------------------------------
+
+    void Clear() { root_ = {}; }
+
+    /**
+     * @brief Checks if a key exists in the tree.
+     */
+    NODISCARD FORCE_INLINE_F bool Contains(std::string_view key) const
+    {
+        const ExternalNode *match = GetBestMatch(key);
+        if (!match) {
+            return false;
+        }
+
+        return std::string_view(match->key) == key;
+    }
+
+    /**
+     * @brief Retrieves a pointer to the value associated with the key.
+     * @return An optional containing the pointer, or empty if not found.
+     */
+    NODISCARD FORCE_INLINE_F std::optional<pointer> Get(std::string_view key)
+    {
+        ExternalNode *match = GetBestMatch(key);
+        if (!match) {
+            return {};
+        }
+
+        if (std::string_view(match->key) != key) {
+            return {};
+        }
+
+        auto ret = std::optional<pointer>();
+        ret.emplace(&match->value);
+
+        return ret;
+    }
+
+    /**
+     * @brief Retrieves a const pointer to the value associated with the key.
+     */
+    NODISCARD FORCE_INLINE_F std::optional<const_pointer> Get(std::string_view key) const
+    {
+        const ExternalNode *match = GetBestMatch(key);
+        if (!match) {
+            return {};
+        }
+
+        if (std::string_view(match->key) != key) {
+            return {};
+        }
+
+        auto ret = std::optional<const_pointer>();
+        ret.emplace(&match->value);
+
+        return ret;
+    }
+
+    NODISCARD FORCE_INLINE_F std::optional<pointer> operator[](std::string_view key)
+    {
+        return Get(key);
+    }
+    NODISCARD FORCE_INLINE_F std::optional<const_pointer> operator[](std::string_view key) const
+    {
+        return Get(key);
+    }
+
+    /**
+     * @brief Get Longest Prefix Match for the given key.
+     * @param key The key to search for.
+     * @return An optional containing a pointer to the value, or empty if no match found.
+     */
+    NODISCARD FORCE_INLINE_F std::optional<pointer> GetLongestPrefixMatch(std::string_view key)
+    {
+        ExternalNode *match = GetBestMatch(key);
+        if (!match) {
+            return {};
+        }
+
+        auto ret = std::optional<pointer>();
+        ret.emplace(&match->value);
+        return ret;
+    }
+
+    /**
+     * @brief Inserts a key-value pair into the tree.
+     *
+     * @param key A NUL-terminated string.
+     * @param args Arguments to construct the value T.
+     *
+     * @tparam overwrite If true, overwrites the value if the key already exists.
+     * @return true if inserted (or overwritten), false if key exists (and overwrite is false) or
+     * allocation failed.
+     */
+    template <bool overwrite = false, typename... Args>
+    bool Insert(const char *key, Args &&...args)
+    {
+        // 1. Handle insertion into an empty tree
+        if (!root_.IsValid()) {
+            root_ = NodePtr::template Construct<ExternalNode>(key, std::forward<Args>(args)...);
+            if (!root_.IsValid()) {
+                return false;
+            }
+            return true;
+        }
+
+        // 2. Walk tree for best member
+        ExternalNode *best_match = GetBestMatch(key);
+
+        // 3. Check for successful membership (exact match)
+        // Find the first differing byte
+        const char *p = best_match->key;
+        size_t i      = 0;
+        while (p[i] != '\0' && key[i] == p[i]) {
+            i++;
+        }
+
+        // If we reached the end of both strings, it's a match
+        if (key[i] == '\0' && p[i] == '\0') {
+            if constexpr (overwrite) {
+                // Update value in place
+                best_match->value.~T();
+                new (&best_match->value) T(std::forward<Args>(args)...);
+                return true;
+            }
+            return false;
+        }
+
+        // 4. Find the critical bit
+        u32 newbyte = static_cast<u32>(i);
+        u32 newmask = 0;
+
+        // Get the differing bytes
+        u8 u_char = static_cast<u8>(key[newbyte]);
+        u8 p_char = static_cast<u8>(p[newbyte]);
+
+        newmask = u_char ^ p_char;
+
+        // Find the most significant differing bit.
+        newmask |= (newmask >> 1);
+        newmask |= (newmask >> 2);
+        newmask |= (newmask >> 4);
+        newmask = (newmask & ~(newmask >> 1)) ^ 255;
+
+        u8 mask = static_cast<u8>(newmask);
+
+        // 5. Allocate new internal node and external node
+        // Calculate direction for the new key at this critical bit
+        int dir = (1 + (mask | p_char)) >> 8;
+
+        NodePtr new_ext_node =
+            NodePtr::template Construct<ExternalNode>(key, std::forward<Args>(args)...);
+        if (!new_ext_node.IsValid()) {
+            return false;
+        }
+
+        NodePtr new_int_node = NodePtr::template Construct<InternalNode>(newbyte, mask);
+        if (!new_int_node.IsValid()) {
+            return false;
+        }
+
+        // Link the new external node
+        auto &internal_ref          = new_int_node.template As<InternalNode>();
+        internal_ref.child[1 - dir] = std::move(new_ext_node);
+
+        // 6. Insert new node into the tree
+        InsertInternalNode(new_int_node, newbyte, mask, dir, key);
+
+        return true;
+    }
+
+    /**
+     * @brief Removes a key from the tree.
+     */
+    bool Remove(std::string_view key)
+    {
+        if (!root_.IsValid()) {
+            return false;
+        }
+
+        NodePtr *current = &root_;
+        NodePtr *parent  = nullptr;
+        InternalNode *q  = nullptr;
+        int dir          = 0;
+
+        const char *u     = key.data();
+        const size_t ulen = key.size();
+
+        // Walk to find best match, keeping track of parent
+        while (current->template Is<InternalNode>()) {
+            parent = current;
+            q      = &current->template As<InternalNode>();
+
+            const u8 c = (q->byte < ulen) ? static_cast<u8>(u[q->byte]) : 0;
+            dir        = (1 + (q->mask | c)) >> 8;
+            current    = &q->child[dir];
+        }
+
+        ExternalNode &p = current->template As<ExternalNode>();
+        if (std::string_view(p.key) != key) {
+            return false;
+        }
+
+        // Found it. Remove p.
+        // If it's the root (and it's external), the tree becomes empty.
+        if (!parent) {
+            root_ = {};
+            return true;
+        }
+
+        *parent = NodePtr(q->child[1 - dir].Release());
+        return true;
+    }
+
+    // -----------------------------------------------------------------------------
+    // Private Helpers
+    // -----------------------------------------------------------------------------
+
+    private:
+    ExternalNode *GetBestMatch(std::string_view key) const
+    {
+        if (!root_.IsValid()) {
+            return nullptr;
+        }
+
+        const NodePtr *p  = &root_;
+        const char *u     = key.data();
+        const size_t ulen = key.size();
+
+        while (p->template Is<InternalNode>()) {
+            const InternalNode &q = p->template As<InternalNode>();
+            const u8 c            = (q.byte < ulen) ? static_cast<u8>(u[q.byte]) : 0;
+            int dir               = (1 + (q.mask | c)) >> 8;
+            p                     = &q.child[dir];
+        }
+
+        // p is now an ExternalNode
+        return &const_cast<NodePtr *>(p)->template As<ExternalNode>();
+    }
+
+    void InsertInternalNode(
+        NodePtr &new_node_ptr, u32 newbyte, u8 newmask, int newdir, const char *key
+    )
+    {
+        NodePtr *wherep      = &root_;
+        const size_t key_len = strlen(key);
+
+        // Walk the tree again to find the insertion point.
+        // We insert above the first node that checks a bit position *after* our new critical bit.
+        while (wherep->template Is<InternalNode>()) {
+            InternalNode &q = wherep->template As<InternalNode>();
+            if (q.byte > newbyte || (q.byte == newbyte && q.mask > newmask)) {
+                break;
+            }
+
+            // Move down
+            const u8 c    = (q.byte < key_len) ? static_cast<u8>(key[q.byte]) : 0;
+            const int dir = (1 + (q.mask | c)) >> 8;
+            wherep        = &q.child[dir];
+        }
+
+        // The other child of the new node adopts the subtree we are replacing
+        auto &new_node         = new_node_ptr.template As<InternalNode>();
+        new_node.child[newdir] = std::move(*wherep);
+
+        // The parent points to the new node
+        *wherep = std::move(new_node_ptr);
+    }
+
+    NodePtr root_;
+};
+
+}  // namespace data_structures
+
+#endif  // LIBS_LIBCONTAINERS_INCLUDE_DATA_STRUCTURES_CRITBIT_TREE_HPP_
diff --git a/libs/libcontainers/include/data_structures/linked_list.hpp b/libs/libcontainers/include/data_structures/linked_list.hpp
new file mode 100644
index 00000000..33633ece
--- /dev/null
+++ b/libs/libcontainers/include/data_structures/linked_list.hpp
@@ -0,0 +1,505 @@
+#ifndef LIBS_LIBCONTAINERS_INCLUDE_DATA_STRUCTURES_LINKED_LIST_HPP_
+#define LIBS_LIBCONTAINERS_INCLUDE_DATA_STRUCTURES_LINKED_LIST_HPP_
+
+#include <stddef.h>
+#include <allocators/custom_allocator_wrapper.hpp>
+#include <new.hpp>
+#include <template/utils.hpp>
+#include <type_traits.hpp>
+#include <utility.hpp>
+
+namespace data_structures
+{
+
+namespace internal
+{
+template <typename T, bool kIsDoubleLinked = true>
+struct LinkedListNode {
+    T data;
+    OPTIONAL_FIELD(kIsDoubleLinked, LinkedListNode *) prev;
+    LinkedListNode *next;
+
+    template <typename... Args>
+    explicit LinkedListNode(Args &&...args)
+        : data(std::forward<Args>(args)...), prev{}, next(nullptr)
+    {
+    }
+};
+}  // namespace internal
+
+/**
+ * @brief A linked list that can be either singly or doubly-linked
+ *
+ * @tparam T The type of elements stored in the list.
+ * @tparam AllocatorT The allocator type
+ * @tparam kIsDoubleLinked If true, creates a doubly-linked list; if false, singly-linked
+ */
+template <typename T, typename AllocatorT, bool kIsDoubleLinked = true>
+class LinkedList
+{
+    public:
+    using Node = internal::LinkedListNode<T, kIsDoubleLinked>;
+
+    class Iterator
+    {
+        public:
+        using value_type = T;
+        using reference  = T &;
+        using pointer    = T *;
+
+        explicit Iterator(Node *node) : node_(node) {}
+
+        reference operator*() const { return node_->data; }
+        pointer operator->() const { return &node_->data; }
+
+        Iterator &operator++()
+        {
+            node_ = node_->next;
+            return *this;
+        }
+
+        Iterator operator++(int)
+        {
+            Iterator tmp = *this;
+            ++(*this);
+            return tmp;
+        }
+
+        Iterator &operator--()
+            requires(kIsDoubleLinked)
+        {
+            node_ = node_->prev;
+            return *this;
+        }
+
+        Iterator operator--(int)
+            requires(kIsDoubleLinked)
+        {
+            Iterator tmp = *this;
+            --(*this);
+            return tmp;
+        }
+
+        bool operator==(const Iterator &other) const { return node_ == other.node_; }
+        bool operator!=(const Iterator &other) const { return node_ != other.node_; }
+
+        Node *GetNode() const { return node_; }
+
+        private:
+        Node *node_;
+    };
+
+    class ConstIterator
+    {
+        public:
+        using value_type = const T;
+        using reference  = const T &;
+        using pointer    = const T *;
+
+        explicit ConstIterator(const Node *node) : node_(node) {}
+
+        reference operator*() const { return node_->data; }
+        pointer operator->() const { return &node_->data; }
+
+        ConstIterator &operator++()
+        {
+            node_ = node_->next;
+            return *this;
+        }
+
+        ConstIterator operator++(int)
+        {
+            ConstIterator tmp = *this;
+            ++(*this);
+            return tmp;
+        }
+
+        ConstIterator &operator--()
+            requires(kIsDoubleLinked)
+        {
+            node_ = node_->prev;
+            return *this;
+        }
+
+        ConstIterator operator--(int)
+            requires(kIsDoubleLinked)
+        {
+            ConstIterator tmp = *this;
+            --(*this);
+            return tmp;
+        }
+
+        bool operator==(const ConstIterator &other) const { return node_ == other.node_; }
+        bool operator!=(const ConstIterator &other) const { return node_ != other.node_; }
+
+        const Node *GetNode() const { return node_; }
+
+        private:
+        const Node *node_;
+    };
+
+    // ------------------------------
+    // Class creation
+    // ------------------------------
+
+    public:
+    LinkedList() : head_(nullptr), tail_{}, size_(0) {}
+    ~LinkedList() { Clear(); }
+
+    LinkedList(const LinkedList &)            = delete;
+    LinkedList &operator=(const LinkedList &) = delete;
+
+    LinkedList(LinkedList &&other) noexcept
+        : head_(other.head_), tail_(other.tail_), size_(other.size_), allocator_(other.allocator_)
+    {
+        other.head_ = nullptr;
+        if constexpr (kIsDoubleLinked) {
+            other.tail_ = nullptr;
+        }
+        other.size_ = 0;
+    }
+
+    LinkedList &operator=(LinkedList &&other) noexcept
+    {
+        if (this != &other) {
+            Clear();
+            head_       = other.head_;
+            tail_       = other.tail_;
+            size_       = other.size_;
+            allocator_  = other.allocator_;
+            other.head_ = nullptr;
+            if constexpr (kIsDoubleLinked) {
+                other.tail_ = nullptr;
+            }
+            other.size_ = 0;
+        }
+        return *this;
+    }
+
+    // Capacity
+    size_t Size() const { return size_; }
+    bool Empty() const { return size_ == 0; }
+
+    // Element access
+    T &Front() { return head_->data; }
+    const T &Front() const { return head_->data; }
+
+    T &Back()
+        requires(kIsDoubleLinked)
+    {
+        return tail_->data;
+    }
+
+    const T &Back() const
+        requires(kIsDoubleLinked)
+    {
+        return tail_->data;
+    }
+
+    // Iterators
+    Iterator begin() { return Iterator(head_); }
+    Iterator end() { return Iterator(nullptr); }
+    ConstIterator begin() const { return ConstIterator(head_); }
+    ConstIterator end() const { return ConstIterator(nullptr); }
+
+    ConstIterator cbegin() const { return ConstIterator(head_); }
+    ConstIterator cend() const { return ConstIterator(nullptr); }
+
+    Node *PushFront(const T &value) { return EmplaceFront(value); }
+    Node *PushFront(T &&value) { return EmplaceFront(std::move(value)); }
+
+    template <typename... Args>
+    Node *EmplaceFront(Args &&...args)
+    {
+        Node *node = AllocateNode(std::forward<Args>(args)...);
+        if (!node) {
+            return nullptr;
+        }
+
+        if constexpr (kIsDoubleLinked) {
+            node->prev = nullptr;
+        }
+        node->next = head_;
+
+        if constexpr (kIsDoubleLinked) {
+            if (head_ != nullptr) {
+                head_->prev = node;
+            }
+        }
+
+        head_ = node;
+
+        if constexpr (kIsDoubleLinked) {
+            if (tail_ == nullptr) {
+                tail_ = node;
+            }
+        }
+
+        ++size_;
+        return node;
+    }
+
+    template <typename... Args>
+    Node *PushBack(Args &&...args)
+        requires(kIsDoubleLinked)
+    {
+        Node *node = AllocateNode(std::forward<Args>(args)...);
+        if (!node) {
+            return nullptr;
+        }
+
+        node->prev = tail_;
+        node->next = nullptr;
+
+        if (tail_ != nullptr) {
+            tail_->next = node;
+        }
+
+        tail_ = node;
+
+        if (head_ == nullptr) {
+            head_ = node;
+        }
+
+        ++size_;
+        return node;
+    }
+
+    Node *InsertAfter(Node *after, const T &value) { return EmplaceAfter(after, value); }
+    Node *InsertAfter(Node *after, T &&value) { return EmplaceAfter(after, std::move(value)); }
+
+    template <typename... Args>
+    Node *EmplaceAfter(Node *after, Args &&...args)
+    {
+        if (!after) {
+            return nullptr;
+        }
+
+        Node *node = AllocateNode(std::forward<Args>(args)...);
+        if (!node) {
+            return nullptr;
+        }
+
+        node->next = after->next;
+        if constexpr (kIsDoubleLinked) {
+            node->prev = after;
+
+            if (after->next != nullptr) {
+                after->next->prev = node;
+            } else {
+                tail_ = node;
+            }
+        }
+        after->next = node;
+
+        ++size_;
+        return node;
+    }
+
+    void PopFront()
+    {
+        if (head_ == nullptr) {
+            return;
+        }
+
+        Node *node = head_;
+        head_      = head_->next;
+
+        if constexpr (kIsDoubleLinked) {
+            if (head_ != nullptr) {
+                head_->prev = nullptr;
+            } else {
+                tail_ = nullptr;
+            }
+        }
+
+        DeallocateNode(node);
+        --size_;
+    }
+
+    void PopBack()
+        requires(kIsDoubleLinked)
+    {
+        if (tail_ == nullptr) {
+            return;
+        }
+
+        Node *node = tail_;
+        tail_      = tail_->prev;
+
+        if (tail_ != nullptr) {
+            tail_->next = nullptr;
+        } else {
+            head_ = nullptr;
+        }
+
+        DeallocateNode(node);
+        --size_;
+    }
+
+    void Remove(Node *node)
+        requires(kIsDoubleLinked)
+    {
+        if (!node) {
+            return;
+        }
+
+        if (node->prev != nullptr) {
+            node->prev->next = node->next;
+        } else {
+            head_ = node->next;
+        }
+
+        if (node->next != nullptr) {
+            node->next->prev = node->prev;
+        } else {
+            tail_ = node->prev;
+        }
+
+        node->prev = nullptr;
+        node->next = nullptr;
+
+        DeallocateNode(node);
+        --size_;
+    }
+
+    void MoveToFront(Node *node)
+        requires(kIsDoubleLinked)
+    {
+        if (!node || node == head_) {
+            return;
+        }
+
+        // Unlink from current position
+        if (node->prev != nullptr) {
+            node->prev->next = node->next;
+        }
+
+        if (node->next != nullptr) {
+            node->next->prev = node->prev;
+        } else {
+            tail_ = node->prev;
+        }
+
+        // Insert at front
+        node->prev = nullptr;
+        node->next = head_;
+
+        if (head_ != nullptr) {
+            head_->prev = node;
+        }
+
+        head_ = node;
+
+        if (tail_ == nullptr) {
+            tail_ = node;
+        }
+    }
+
+    void MoveToBack(Node *node)
+        requires(kIsDoubleLinked)
+    {
+        if (!node || node == tail_) {
+            return;
+        }
+
+        // Unlink from current position
+        if (node->prev != nullptr) {
+            node->prev->next = node->next;
+        } else {
+            head_ = node->next;
+        }
+
+        if (node->next != nullptr) {
+            node->next->prev = node->prev;
+        }
+
+        // Insert at back
+        node->prev = tail_;
+        node->next = nullptr;
+
+        if (tail_ != nullptr) {
+            tail_->next = node;
+        }
+
+        tail_ = node;
+
+        if (head_ == nullptr) {
+            head_ = node;
+        }
+    }
+
+    void Clear()
+    {
+        Node *node = head_;
+        while (node != nullptr) {
+            Node *next = node->next;
+            DeallocateNode(node);
+            node = next;
+        }
+
+        head_ = nullptr;
+        if constexpr (kIsDoubleLinked) {
+            tail_ = nullptr;
+        }
+        size_ = 0;
+    }
+
+    Node *GetHead() const { return head_; }
+
+    Node *GetTail() const
+        requires(kIsDoubleLinked)
+    {
+        return tail_;
+    }
+
+    // ------------------------------
+    // Helpers
+    // ------------------------------
+
+    private:
+    template <typename... Args>
+    Node *AllocateNode(Args &&...args)
+    {
+        return allocator_.template Allocate<Node>(std::forward<Args>(args)...);
+    }
+
+    void DeallocateNode(Node *node)
+    {
+        if (node) {
+            node->~Node();
+            allocator_.template Deallocate<Node>(node);
+        }
+    }
+
+    // ------------------------------
+    // Field members
+    // ------------------------------
+
+    private:
+    Node *head_;
+    OPTIONAL_FIELD(kIsDoubleLinked, Node *) tail_;
+    size_t size_;
+    NO_UNIQUE_ADDRESS AllocatorT allocator_{};
+};
+
+template <
+    typename T, typename AllocatorT = allocators::KMallocAllocator<internal::LinkedListNode<T>>>
+using DoubleLinkedList = LinkedList<T, AllocatorT>;
+
+template <typename T, size_t kSize>
+using StaticDoubleLinkedList =
+    DoubleLinkedList<T, allocators::CyclicAllocatorWrapper<internal::LinkedListNode<T>, kSize>>;
+
+template <
+    typename T,
+    typename AllocatorT = allocators::KMallocAllocator<internal::LinkedListNode<T, false>>>
+using SingleLinkedList = LinkedList<T, AllocatorT, false>;
+
+template <typename T, size_t kSize>
+using StaticSingleLinkedList = SingleLinkedList<
+    T, allocators::CyclicAllocatorWrapper<internal::LinkedListNode<T, false>, kSize>>;
+
+}  // namespace data_structures
+
+#endif  // LIBS_LIBCONTAINERS_INCLUDE_DATA_STRUCTURES_LINKED_LIST_HPP_
diff --git a/libs/libcontainers/include/data_structures/lru_cache.hpp b/libs/libcontainers/include/data_structures/lru_cache.hpp
new file mode 100644
index 00000000..0b5e3fbd
--- /dev/null
+++ b/libs/libcontainers/include/data_structures/lru_cache.hpp
@@ -0,0 +1,115 @@
+#ifndef LIBS_LIBCONTAINERS_INCLUDE_DATA_STRUCTURES_LRU_CACHE_HPP_
+#define LIBS_LIBCONTAINERS_INCLUDE_DATA_STRUCTURES_LRU_CACHE_HPP_
+
+#include <stddef.h>
+#include <type_traits.hpp>
+
+#include <data_structures/hash_maps.hpp>
+#include <data_structures/linked_list.hpp>
+#include <todo.hpp>
+
+TODO_WHEN_MULTITHREADING
+// TODO: Make thread-safe
+
+namespace data_structures
+{
+
+template <
+    typename KeyT, typename ValueT, size_t kCapacity,
+    class HashT = FastMinimalStaticHashmap<
+        KeyT, internal::LinkedListNode<std::tuple<const KeyT, ValueT>> *, kCapacity>>
+class LruCache
+{
+    static_assert(kCapacity > 0, "LRU cache capacity must be greater than zero");
+
+    public:
+    LruCache() = default;
+    ~LruCache() { Clear(); }
+
+    size_t Size() const { return list_.Size(); }
+    static constexpr size_t Capacity() { return kCapacity; }
+    bool Empty() const { return list_.Empty(); }
+
+    bool Contains(const KeyT &key) const { return hash_map_.HasKey(key); }
+
+    ValueT *Get(const KeyT &key)
+    {
+        auto node_ptr = hash_map_.Find(key);
+        if (!node_ptr) {
+            return nullptr;
+        }
+
+        ListNode *node = *node_ptr;
+        list_.MoveToFront(node);
+        return &std::get<1>(node->data);
+    }
+
+    const ValueT *Get(const KeyT &key) const
+    {
+        auto node_ptr = hash_map_.Find(key);
+        if (!node_ptr) {
+            return nullptr;
+        }
+
+        ListNode *node = *node_ptr;
+        return &std::get<1>(node->data);
+    }
+
+    void Put(const KeyT &key, ValueT value)
+    {
+        if (auto node_ptr = hash_map_.Find(key)) {
+            ListNode *node          = *node_ptr;
+            std::get<1>(node->data) = std::move(value);
+            list_.MoveToFront(node);
+            return;
+        }
+
+        if (list_.Size() == kCapacity) {
+            Evict();
+        }
+
+        if (ListNode *new_node = list_.EmplaceFront(key, std::move(value))) {
+            hash_map_.Insert(std::get<0>(new_node->data), new_node);
+        }
+    }
+
+    bool Erase(const KeyT &key)
+    {
+        auto node_ptr = hash_map_.Find(key);
+        if (!node_ptr) {
+            return false;
+        }
+
+        ListNode *node = *node_ptr;
+        hash_map_.Remove(key);
+        list_.Remove(node);
+        return true;
+    }
+
+    void Clear()
+    {
+        list_.Clear();
+        hash_map_ = HashT();
+    }
+
+    private:
+    void Evict()
+    {
+        ListNode *tail = list_.GetTail();
+        if (!tail) {
+            return;
+        }
+
+        hash_map_.Remove(std::get<0>(tail->data));
+        list_.PopBack();
+    }
+
+    DoubleLinkedList<std::tuple<const KeyT, ValueT>> list_{};
+    HashT hash_map_{};
+
+    using ListNode = decltype(list_)::Node;
+};
+
+}  // namespace data_structures
+
+#endif  // LIBS_LIBCONTAINERS_INCLUDE_DATA_STRUCTURES_LRU_CACHE_HPP_
diff --git a/libs/libcontainers/include/data_structures/tagged_pointer.hpp b/libs/libcontainers/include/data_structures/tagged_pointer.hpp
new file mode 100644
index 00000000..47832046
--- /dev/null
+++ b/libs/libcontainers/include/data_structures/tagged_pointer.hpp
@@ -0,0 +1,214 @@
+#ifndef LIBS_LIBCONTAINERS_INCLUDE_DATA_STRUCTURES_TAGGED_POINTER_HPP_
+#define LIBS_LIBCONTAINERS_INCLUDE_DATA_STRUCTURES_TAGGED_POINTER_HPP_
+
+#include <algorithm.hpp>
+#include <defines.hpp>
+#include <mem/heap.hpp>
+#include <new.hpp>
+#include <type_traits.hpp>
+#include <utility.hpp>
+
+namespace data_structures
+{
+/**
+ * @brief A tagged pointer that stores type information in unused pointer bits.
+ *
+ * The number of available tag bits is determined by the number of types provided.
+ *
+ * @tparam TaggedTypes Variadic list of types that can be stored with this tagged pointer
+ */
+template <typename... TaggedTypes>
+class TaggedPointer
+{
+    public:
+    using BaseT = uintptr_t;
+
+    static constexpr size_t kNumTypes = sizeof...(TaggedTypes);
+    static constexpr size_t kTagBits  = []() constexpr {
+        size_t bits = 0;
+        while ((1ULL << bits) < kNumTypes) {
+            bits++;
+        }
+        return bits;
+    }();
+
+    TaggedPointer() = default;
+
+    explicit TaggedPointer(BaseT tagged_ptr) : tagged_ptr_(tagged_ptr) {}
+
+    ~TaggedPointer() { Destroy(); }
+
+    TaggedPointer(const TaggedPointer &)            = delete;
+    TaggedPointer &operator=(const TaggedPointer &) = delete;
+
+    TaggedPointer(TaggedPointer &&other) noexcept : tagged_ptr_(other.tagged_ptr_)
+    {
+        other.tagged_ptr_ = 0;
+    }
+
+    TaggedPointer &operator=(TaggedPointer &&other) noexcept
+    {
+        if (this != &other) {
+            Destroy();
+            tagged_ptr_       = other.tagged_ptr_;
+            other.tagged_ptr_ = 0;
+        }
+        return *this;
+    }
+
+    NODISCARD FORCE_INLINE_F bool IsValid() const { return tagged_ptr_ != 0; }
+
+    NODISCARD FORCE_INLINE_F explicit operator bool() const { return IsValid(); }
+
+    template <typename T, typename... Args>
+    NODISCARD FAST_CALL TaggedPointer Construct(Args &&...args)
+    {
+        static_assert(
+            (std::is_same_v<T, TaggedTypes> || ...), "Type T must be one of the TaggedTypes"
+        );
+
+        auto mem = Mem::KMallocAligned(
+            {.size      = sizeof(T),
+             .alignment = alignof(T) > (1ULL << kTagBits) ? alignof(T) : (1ULL << kTagBits)}
+        );
+        if (!mem) {
+            return {};
+        }
+
+        T *ptr = new (*mem) T(std::forward<Args>(args)...);
+
+        return TaggedPointer(TagPtr(ptr, GetTypeIndex<T>()));
+    }
+
+    template <typename T>
+    NODISCARD FORCE_INLINE_F bool Is() const
+    {
+        static_assert(
+            (std::is_same_v<T, TaggedTypes> || ...), "Type T must be one of the TaggedTypes"
+        );
+        return IsValid() && GetTag() == GetTypeIndex<T>();
+    }
+
+    template <typename T>
+    NODISCARD FORCE_INLINE_F T &As()
+    {
+        ASSERT_TRUE(Is<T>());
+        return *static_cast<T *>(UntagPtr());
+    }
+
+    template <typename T>
+    NODISCARD FORCE_INLINE_F const T &As() const
+    {
+        ASSERT_TRUE(Is<T>());
+        return *static_cast<const T *>(UntagPtr());
+    }
+
+    // Visitor pattern to handle different types
+    template <typename Visitor>
+    FORCE_INLINE_F decltype(auto) Visit(Visitor &&visitor)
+    {
+        ASSERT_TRUE(IsValid());
+        size_t tag           = GetTag();
+        size_t current_index = 0;
+
+        // Dispatch to the correct type
+        return VisitImpl<Visitor, TaggedTypes...>(
+            std::forward<Visitor>(visitor), tag, current_index
+        );
+    }
+
+    template <typename Visitor>
+    FORCE_INLINE_F decltype(auto) Visit(Visitor &&visitor) const
+    {
+        ASSERT_TRUE(IsValid());
+        size_t tag           = GetTag();
+        size_t current_index = 0;
+
+        return VisitImpl<Visitor, TaggedTypes...>(
+            std::forward<Visitor>(visitor), tag, current_index
+        );
+    }
+
+    NODISCARD FORCE_INLINE_F uintptr_t GetRaw() const { return tagged_ptr_; }
+
+    NODISCARD FORCE_INLINE_F uintptr_t Release()
+    {
+        uintptr_t tmp = tagged_ptr_;
+        tagged_ptr_   = 0;
+        return tmp;
+    }
+
+    private:
+    FORCE_INLINE_F void Destroy()
+    {
+        if (IsValid()) {
+            size_t tag           = GetTag();
+            size_t current_index = 0;
+
+            (void)((current_index++ == tag ? (DestroyType<TaggedTypes>(), true) : false) || ...);
+        }
+    }
+
+    template <typename T>
+    static constexpr size_t GetTypeIndex()
+    {
+        size_t index = 0;
+        ((std::is_same_v<T, TaggedTypes> ? true : (++index, false)) || ...);
+        return index;
+    }
+
+    NODISCARD FORCE_INLINE_F static BaseT TagPtr(void *ptr, size_t type_index)
+    {
+        return reinterpret_cast<BaseT>(ptr) | type_index;
+    }
+
+    NODISCARD FORCE_INLINE_F void *UntagPtr() const
+    {
+        return reinterpret_cast<void *>(tagged_ptr_ & kPtrMask);
+    }
+
+    NODISCARD FORCE_INLINE_F size_t GetTag() const { return tagged_ptr_ & kTagMask; }
+
+    template <typename T>
+    void DestroyType()
+    {
+        T *ptr = static_cast<T *>(UntagPtr());
+        ptr->~T();
+        Mem::KFreeAligned(ptr);
+    }
+
+    template <typename Visitor, typename T, typename... Rest>
+    decltype(auto) VisitImpl(Visitor &&visitor, size_t tag, size_t &current_index)
+    {
+        if (current_index == tag) {
+            return visitor(As<T>());
+        }
+        current_index++;
+        if constexpr (sizeof...(Rest) > 0) {
+            return VisitImpl<Visitor, Rest...>(std::forward<Visitor>(visitor), tag, current_index);
+        }
+        R_FAIL_ALWAYS("Invalid tag in TaggedPointer::Visit");
+    }
+
+    template <typename Visitor, typename T, typename... Rest>
+    decltype(auto) VisitImpl(Visitor &&visitor, size_t tag, size_t &current_index) const
+    {
+        if (current_index == tag) {
+            return visitor(As<T>());
+        }
+        current_index++;
+        if constexpr (sizeof...(Rest) > 0) {
+            return VisitImpl<Visitor, Rest...>(std::forward<Visitor>(visitor), tag, current_index);
+        }
+        R_FAIL_ALWAYS("Invalid tag in TaggedPointer::Visit");
+    }
+
+    static constexpr BaseT kTagMask = (static_cast<BaseT>(1) << kTagBits) - 1;
+    static constexpr BaseT kPtrMask = ~kTagMask;
+
+    BaseT tagged_ptr_{};
+};
+
+}  // namespace data_structures
+
+#endif  // LIBS_LIBCONTAINERS_INCLUDE_DATA_STRUCTURES_TAGGED_POINTER_HPP_
diff --git a/libs/libtemplate/include/template/utils.hpp b/libs/libtemplate/include/template/utils.hpp
index 35530bbf..715aadce 100644
--- a/libs/libtemplate/include/template/utils.hpp
+++ b/libs/libtemplate/include/template/utils.hpp
@@ -1,15 +1,17 @@
 #ifndef LIBS_LIBTEMPLATE_INCLUDE_TEMPLATE_UTILS_HPP_
 #define LIBS_LIBTEMPLATE_INCLUDE_TEMPLATE_UTILS_HPP_
 
-#include <variant.hpp>
+#include <defines.hpp>
+#include <type_traits.hpp>
 
 namespace template_lib
 {
 // ------------------------------
-// OptionalField
+// OPTIONAL_FIELD
 // ------------------------------
 
-template <bool cond, class T>
-using OptionalField = std::conditional_t<cond, T, std::monostate>;
+// Apparently using OptionalField = std::conditional_t<...> does not work
+#define OPTIONAL_FIELD(cond, type) NO_UNIQUE_ADDRESS std::conditional_t<cond, type, UNIQUE_EMPTY>
+
 }  // namespace template_lib
 #endif  // LIBS_LIBTEMPLATE_INCLUDE_TEMPLATE_UTILS_HPP_

From 08823941392936712b52ed8d892584a293527fd7 Mon Sep 17 00:00:00 2001
From: Adam Ogieniewski <ogieniewski.dev@gmail.com>
Date: Thu, 11 Dec 2025 06:45:42 +0100
Subject: [PATCH 06/56] Add root filesystem generation system (#234)

Introduces a comprehensive system for building root filesystems,
supporting both initial RAM disks (INITRD) and standalone disk images.

This includes:
- New `cmake/BashConfigHelpers.cmake` for managing bash configurations.
- `register_filesystem` CMake function in `RuntimeHelpers.cmake`.
- `rootfs` subdirectory with its own CMake configuration.
- `scripts/actions/make_rootfs.bash` and `scripts/rootfs/make_fat.bash`
  for orchestrating and creating FAT filesystems.
- A `ramdisk` feature flag to control INITRD vs. image generation.
- New bash helper functions for size conversions.
- Fixes a bug in test filtering logic.
---
 CMakeLists.txt                              |   5 +
 cmake/BashConfigHelpers.cmake               |  64 +++++++++++
 cmake/RuntimeHelpers.cmake                  | 116 ++++++++++++++++----
 cmake/ValidationHelpers.cmake               |  64 +++++++++++
 generated/.gitignore                        |   1 +
 rootfs/CMakeLists.txt                       |  33 ++++++
 rootfs/overlay/file.txt                     |   1 +
 scripts/actions/make_rootfs.bash            |  67 +++++++++++
 scripts/config/feature_flags_schema.yaml    |   4 +
 scripts/rootfs/make_fat.bash                |  73 ++++++++++++
 scripts/tests/test_framework/test_parser.py |   8 +-
 scripts/utils/helpers.bash                  |  89 +++++++++++++++
 toolchains/x86_64-conf.cmake                |   4 +-
 13 files changed, 502 insertions(+), 27 deletions(-)
 create mode 100644 cmake/BashConfigHelpers.cmake
 create mode 100644 generated/.gitignore
 create mode 100644 rootfs/CMakeLists.txt
 create mode 100644 rootfs/overlay/file.txt
 create mode 100755 scripts/actions/make_rootfs.bash
 create mode 100755 scripts/rootfs/make_fat.bash

diff --git a/CMakeLists.txt b/CMakeLists.txt
index c7e3544f..eeba090a 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -21,6 +21,7 @@ list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
 include(ValidationHelpers)
 include(SourceHelpers)
 include(RuntimeHelpers)
+include(BashConfigHelpers)
 
 add_library(alkos.target.properties.interface INTERFACE) # Populated by the toolchain file
 
@@ -30,6 +31,9 @@ set(CMAKE_ROOT_DIR ${CMAKE_SOURCE_DIR})
 #                                   Conf file                                  #
 ################################################################################
 
+set(BASH_CONF_FILE "${CMAKE_ROOT_DIR}/config/conf.generated.bash")
+alkos_init_bash_config()
+
 set(CMAKE_CONF_FILE "${CMAKE_ROOT_DIR}/config/conf.generated.cmake")
 
 # Check if configuration was done
@@ -93,6 +97,7 @@ set(SYSTEM_LIB_TYPE k)
 add_subdirectory(libs)
 add_subdirectory(generated)
 add_subdirectory(kernel)
+add_subdirectory(rootfs)
 
 ################################################################################
 #                                   Aliases                                    #
diff --git a/cmake/BashConfigHelpers.cmake b/cmake/BashConfigHelpers.cmake
new file mode 100644
index 00000000..bff4f0f3
--- /dev/null
+++ b/cmake/BashConfigHelpers.cmake
@@ -0,0 +1,64 @@
+#
+# This module provides a function for working with bash config files
+#
+
+#============================================================================
+# alkos_init_bash_config
+#============================================================================
+function(alkos_init_bash_config)
+    file(WRITE "${BASH_CONF_FILE}" "#!/bin/bash\n")
+    file(APPEND "${BASH_CONF_FILE}" "# Autogenerated config for ${ARCH}\n")
+    file(APPEND "${BASH_CONF_FILE}" "# Do not try to edit this by hand!\n")
+    file(APPEND "${BASH_CONF_FILE}" "\n")
+endfunction()
+
+#===============================================================================
+# alkos_add_to_bash_config
+#===============================================================================
+function(alkos_add_to_bash_config VARIABLE_NAME VARIABLE_VALUE)
+    if(NOT EXISTS "${BASH_CONF_FILE}")
+        message(FATAL_ERROR "Bash config file ${BASH_CONF_FILE} does not exist. Please call alkos_init_bash_config first.")
+    endif()
+
+    # Update existing variable if it exists, otherwise append at the end
+    file(READ "${BASH_CONF_FILE}" BASH_CONF_CONTENTS)
+    if(BASH_CONF_CONTENTS MATCHES "export ${VARIABLE_NAME}=")
+        string(REGEX REPLACE "export ${VARIABLE_NAME}=\"[^\"]*\"" "export ${VARIABLE_NAME}=\"${VARIABLE_VALUE}\"" UPDATED_BASH_CONF_CONTENTS "${BASH_CONF_CONTENTS}")
+        file(WRITE "${BASH_CONF_FILE}" "${UPDATED_BASH_CONF_CONTENTS}\n")
+    else()
+        file(APPEND "${BASH_CONF_FILE}" "export ${VARIABLE_NAME}=\"${VARIABLE_VALUE}\"\n")
+    endif()
+endfunction()
+
+#===============================================================================
+# alkos_bash_config_append_to_list
+#===============================================================================
+function(alkos_bash_config_append_to_list VARIABLE_NAME VALUES_TO_APPEND)
+    if(NOT EXISTS "${BASH_CONF_FILE}")
+        message(FATAL_ERROR "Bash config file ${BASH_CONF_FILE} does not exist. Please call alkos_init_bash_config first.")
+    endif()
+
+    # This is how you pass list arguments to a bash script from CMake
+    string(REPLACE ";" " " VALUES_TO_APPEND "${VALUES_TO_APPEND}")
+
+    # Read the current value of the variable from the bash config
+    file(READ "${BASH_CONF_FILE}" BASH_CONF_CONTENTS)
+    if(BASH_CONF_CONTENTS MATCHES "export ${VARIABLE_NAME}=\"[^\"]*\"")
+        string(REGEX MATCH "export ${VARIABLE_NAME}=\"([^\"]*)\"" "\\1" _ "${BASH_CONF_CONTENTS}")
+
+        # Append the new value to the existing list
+        set(CURRENT_VALUE "${CMAKE_MATCH_1}")
+        if(CURRENT_VALUE STREQUAL "")
+            set(CURRENT_VALUE "${VALUES_TO_APPEND}")
+        else()
+            set(CURRENT_VALUE "${CURRENT_VALUE} ${VALUES_TO_APPEND}")
+        endif()
+
+        # Update the variable in the bash config
+        string(REGEX REPLACE "export ${VARIABLE_NAME}=\"[^\"]*\"" "export ${VARIABLE_NAME}=\"${CURRENT_VALUE}\"" UPDATED_BASH_CONF_CONTENTS "${BASH_CONF_CONTENTS}")
+        file(WRITE "${BASH_CONF_FILE}" "${UPDATED_BASH_CONF_CONTENTS}\n")
+    else()
+        # Variable does not exist, create it
+        alkos_add_to_bash_config("${VARIABLE_NAME}" "${VALUES_TO_APPEND}")
+    endif()
+endfunction()
diff --git a/cmake/RuntimeHelpers.cmake b/cmake/RuntimeHelpers.cmake
index b3bb7c45..bf670134 100644
--- a/cmake/RuntimeHelpers.cmake
+++ b/cmake/RuntimeHelpers.cmake
@@ -4,6 +4,7 @@
 #
 
 include(ValidationHelpers)
+include(BashConfigHelpers)
 
 #===============================================================================
 # alkos_register_runtime_environment
@@ -61,29 +62,19 @@ function(alkos_register_runtime_environment)
         PATHS ${MAKE_ISO_SCRIPT_PATH} ${RUN_ALKOS_SCRIPT_PATH} ${RUN_TESTS_SCRIPT_PATH}
     )
 
-    # This is how you pass list arguments to a bash script from CMake
-    string(REPLACE ";" " " KERNEL_MODULES_FORMATTED "${ARG_MODULES}")
-    string(REPLACE ";" " " KERNEL_COMMANDS_FORMATTED "${ARG_MODULE_COMMANDS}")
-
-    # Write a bash config file specific to this architecture
-    set(BASH_CONF_FILE "${CMAKE_ROOT_DIR}/config/conf.generated.bash")
-
-    file(WRITE "${BASH_CONF_FILE}" "#!/bin/bash\n")
-    file(APPEND "${BASH_CONF_FILE}" "# Autogenerated config for ${ARG_ARCH_NAME}\n")
-    file(APPEND "${BASH_CONF_FILE}" "# Do not try to edit this by hand!\n")
-    file(APPEND "${BASH_CONF_FILE}" "\n")
-    file(APPEND "${BASH_CONF_FILE}" "export CONF_ARCH=\"${ARG_ARCH_NAME}\"\n")
-    file(APPEND "${BASH_CONF_FILE}" "export CONF_BUILD_TYPE=\"${CMAKE_BUILD_TYPE}\"\n")
-    file(APPEND "${BASH_CONF_FILE}" "export CONF_SYSROOT=\"${CMAKE_SYSROOT}\"\n")
-    file(APPEND "${BASH_CONF_FILE}" "export CONF_BOOTABLE_KERNEL_EXEC=\"${ARG_BOOTABLE_EXECUTABLE}\"\n")
-    file(APPEND "${BASH_CONF_FILE}" "export CONF_ISO_PATH=\"${ALKOS_ISO_PATH}\"\n")
-    file(APPEND "${BASH_CONF_FILE}" "export CONF_KERNEL_MODULES=\"${KERNEL_MODULES_FORMATTED}\"\n")
-    file(APPEND "${BASH_CONF_FILE}" "export CONF_KERNEL_COMMANDS=\"${KERNEL_COMMANDS_FORMATTED}\"\n")
-    file(APPEND "${BASH_CONF_FILE}" "export CONF_BUILD_DIR=\"${CMAKE_BINARY_DIR}\"\n")
-    file(APPEND "${BASH_CONF_FILE}" "export CONF_TOOL_DIR=\"${TOOL_BINARIES_DIR}\"\n")
-    file(APPEND "${BASH_CONF_FILE}" "export CONF_QEMU_COMMAND=\"${ARG_QEMU_COMMAND}\"\n")
-    file(APPEND "${BASH_CONF_FILE}" "export CONF_QEMU_NORMAL_FLAGS=\"${ARG_QEMU_NORMAL_FLAGS}\"\n")
-    file(APPEND "${BASH_CONF_FILE}" "export CONF_QEMU_TEST_FLAGS=\"${ARG_QEMU_TEST_FLAGS}\"\n")
+    # Add architecture-specific variables to the bash config
+    alkos_add_to_bash_config("CONF_ARCH" "${ARG_ARCH_NAME}")
+    alkos_add_to_bash_config("CONF_BUILD_TYPE" "${CMAKE_BUILD_TYPE}")
+    alkos_add_to_bash_config("CONF_SYSROOT" "${CMAKE_SYSROOT}")
+    alkos_add_to_bash_config("CONF_BOOTABLE_KERNEL_EXEC" "${ARG_BOOTABLE_EXECUTABLE}")
+    alkos_add_to_bash_config("CONF_ISO_PATH" "${ALKOS_ISO_PATH}")
+    alkos_bash_config_append_to_list("CONF_KERNEL_MODULES" "${ARG_MODULES}")
+    alkos_bash_config_append_to_list("CONF_KERNEL_COMMANDS" "${ARG_MODULE_COMMANDS}")
+    alkos_add_to_bash_config("CONF_BUILD_DIR" "${CMAKE_BINARY_DIR}")
+    alkos_add_to_bash_config("CONF_TOOL_DIR" "${TOOL_BINARIES_DIR}")
+    alkos_add_to_bash_config("CONF_QEMU_COMMAND" "${ARG_QEMU_COMMAND}")
+    alkos_add_to_bash_config("CONF_QEMU_NORMAL_FLAGS" "${ARG_QEMU_NORMAL_FLAGS}")
+    alkos_add_to_bash_config("CONF_QEMU_TEST_FLAGS" "${ARG_QEMU_TEST_FLAGS}")
 
     add_custom_target(iso-${ARG_ARCH_NAME}
         COMMAND ${MAKE_ISO_SCRIPT_PATH} -v
@@ -123,3 +114,82 @@ function(alkos_register_runtime_environment)
       )
     endif()
 endfunction()
+#-------------------------------------------------------------------------------
+# register_filesystem
+#-------------------------------------------------------------------------------
+# A filesystem registration helper that configures the rootfs
+# generation. It can be used to create either an initrd within the sysroot
+# or a standalone filesystem image within the build binaries folder.
+#
+# Parameters (oneValueArgs):
+#   TYPE                  Either INITRD or IMAGE
+#   ROOTFS_TYPE           Type of rootfs to create (e.g., fat, ext4)
+#   ROOTFS_DIR            Staging directory for building rootfs contents
+#   ROOTFS_TARGET_PATH    Target image path to generate (optional; defaults based on TYPE)
+#   ROOTFS_OVERLAY_DIR    Overlay directory to copy into the rootfs
+#   MODULE                Optional module target name to include in the ISO
+#   MODULE_COMMAND        Optional bootloader command for the module
+#
+#-------------------------------------------------------------------------------
+function(register_filesystem)
+    set(options)
+    set(oneValueArgs
+        TYPE
+        ROOTFS_TYPE
+        ROOTFS_DIR
+        ROOTFS_TARGET_PATH
+        ROOTFS_OVERLAY_DIR
+        MODULE
+        MODULE_COMMAND
+    )
+    set(multiValueArgs)
+
+    cmake_parse_arguments(ARG "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+
+    alkos_ensure_called_once(NAME ${CMAKE_CURRENT_FUNCTION})
+
+    alkos_ensure_defined(
+        VARS ARG_TYPE ARG_ROOTFS_TYPE ARG_ROOTFS_DIR ARG_ROOTFS_TARGET_PATH ARG_ROOTFS_OVERLAY_DIR
+    )
+
+    # Resolve target defaults and feature flags
+    if(ARG_TYPE STREQUAL "INITRD")
+        alkos_ensure_feature_enabled(
+            FLAG CMAKE_FEATURE_FLAG_RAMDISK
+            MESSAGE "Initial RAM filesystem support is disabled."
+        )
+    elseif(ARG_TYPE NOT STREQUAL "IMAGE")
+        message(FATAL_ERROR "register_filesystem: Unknown TYPE='${ARG_TYPE}'. Expected INITRD or IMAGE.")
+    endif()
+
+    # Export variables for the rootfs maker
+    alkos_add_to_bash_config("CONF_ROOTFS_DIR" "${ARG_ROOTFS_DIR}")
+    alkos_add_to_bash_config("CONF_ROOTFS_TARGET_PATH" "${ARG_ROOTFS_TARGET_PATH}")
+    alkos_add_to_bash_config("CONF_ROOTFS_OVERLAY_DIR" "${ARG_ROOTFS_OVERLAY_DIR}")
+
+    if(ARG_TYPE STREQUAL "INITRD")
+        alkos_ensure_defined(VARS ARG_MODULE ARG_MODULE_COMMAND)
+
+        alkos_bash_config_append_to_list("CONF_KERNEL_MODULES" "${ARG_MODULE}")
+        alkos_bash_config_append_to_list("CONF_KERNEL_COMMANDS" "${ARG_MODULE_COMMAND}")
+    endif()
+
+    # Create the targets
+    set(MAKE_ROOTFS_SCRIPT_PATH ${CMAKE_SOURCE_DIR}/scripts/actions/make_rootfs.bash)
+    alkos_ensure_path_exists(PATHS ${MAKE_ROOTFS_SCRIPT_PATH})
+
+    add_custom_target(rootfs
+            COMMAND ${MAKE_ROOTFS_SCRIPT_PATH} -v -- ${ARG_ROOTFS_TYPE}
+            WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+            COMMENT "Building root filesystem"
+    )
+    add_dependencies(iso-${ARCH} rootfs)
+
+    add_custom_target(mountfs
+            DEPENDS rootfs
+            COMMAND sudo umount /mnt || true
+            COMMAND sudo mount -o loop ${ARG_ROOTFS_TARGET_PATH} /mnt
+            WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+            COMMENT "Mounting root filesystem"
+    )
+endfunction()
diff --git a/cmake/ValidationHelpers.cmake b/cmake/ValidationHelpers.cmake
index 2a2d5d58..93e17594 100644
--- a/cmake/ValidationHelpers.cmake
+++ b/cmake/ValidationHelpers.cmake
@@ -168,3 +168,67 @@ function(alkos_ensure_path_exists)
         message(FATAL_ERROR "${error_message}")
     endif()
 endfunction()
+
+#===============================================================================
+# alkos_ensure_feature_flag_enabled
+#===============================================================================
+#
+# Checks if a specified feature flag is enabled and halts with a
+# fatal error if it is not.
+#
+# Parameters:
+#   FLAG <flag>            The name of the feature flag variable to check.
+#   MESSAGE <message>      (Optional) A supplementary message to append to the
+#                          standard error output. This is useful for providing
+#                          additional context or instructions to the user.
+#
+# Example:
+#   # Assume CMAKE_FEATURE_FLAG_DEBUG_OUTPUT must be enabled.
+#   alkos_ensure_feature_flag_enabled(
+#       FLAG CMAKE_FEATURE_FLAG_DEBUG_OUTPUT
+#       MESSAGE "Debug output must be enabled for this build."
+#   )
+#
+function(alkos_ensure_feature_enabled)
+    set(options)
+    set(oneValueArgs FLAG MESSAGE)
+    set(multiValueArgs)
+
+    cmake_parse_arguments(ARG "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+
+    if(NOT ARG_FLAG)
+        message(FATAL_ERROR "alkos_ensure_feature_enabled() called without a feature to check.")
+    endif()
+
+    if(NOT DEFINED ${ARG_FLAG} OR NOT ${ARG_FLAG})
+        set(error_message "The feature flag '${ARG_FLAG}' must be enabled.")
+
+        if(ARG_MESSAGE)
+            string(APPEND error_message "\n${ARG_MESSAGE}")
+        endif()
+
+        message(FATAL_ERROR "${error_message}")
+    endif()
+endfunction()
+
+#===============================================================================
+# alkos_ensure_called_once
+#===============================================================================
+function(alkos_ensure_called_once)
+    set(options)
+    set(oneValueArgs NAME)
+    set(multiValueArgs)
+
+    cmake_parse_arguments(ARG "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+
+    if(NOT ARG_NAME)
+        message(FATAL_ERROR "alkos_ensure_called_once() called without a NAME to check.")
+    endif()
+
+    get_property(already_called GLOBAL PROPERTY ALKOS_CALLED_${ARG_NAME})
+    if(already_called)
+        message(FATAL_ERROR "The function '${ARG_NAME}' has already been called. It can only be called once.")
+    endif()
+
+    set_property(GLOBAL PROPERTY ALKOS_CALLED_${ARG_NAME} TRUE)
+endfunction()
diff --git a/generated/.gitignore b/generated/.gitignore
new file mode 100644
index 00000000..7841db52
--- /dev/null
+++ b/generated/.gitignore
@@ -0,0 +1 @@
+include/autogen/*
diff --git a/rootfs/CMakeLists.txt b/rootfs/CMakeLists.txt
new file mode 100644
index 00000000..94066710
--- /dev/null
+++ b/rootfs/CMakeLists.txt
@@ -0,0 +1,33 @@
+message(STATUS "Configuring Filesystem...")
+
+################################################################################
+#                                   Helpers                                    #
+################################################################################
+
+include(RuntimeHelpers)
+
+################################################################################
+#                                Configuration                                 #
+################################################################################
+
+set(ROOTFS_TYPE fat CACHE STRING "Type of root filesystem to create (e.g. fat)")
+
+if(CMAKE_FEATURE_FLAG_RAMDISK)
+    register_filesystem(
+            TYPE INITRD
+            ROOTFS_TYPE ${ROOTFS_TYPE}
+            ROOTFS_DIR ${CMAKE_CURRENT_BINARY_DIR}/target
+            ROOTFS_TARGET_PATH ${CMAKE_BINARY_DIR}/sysroot/boot/alkos.initrd
+            ROOTFS_OVERLAY_DIR ${CMAKE_CURRENT_SOURCE_DIR}/overlay
+            MODULE alkos.initrd
+            MODULE_COMMAND initrd
+    )
+else()
+    register_filesystem(
+            TYPE IMAGE
+            ROOTFS_TYPE ${ROOTFS_TYPE}
+            ROOTFS_DIR ${CMAKE_CURRENT_BINARY_DIR}/target
+            ROOTFS_TARGET_PATH ${CMAKE_BINARY_DIR}/alkos.rootfs.img
+            ROOTFS_OVERLAY_DIR ${CMAKE_CURRENT_SOURCE_DIR}/overlay
+    )
+endif()
diff --git a/rootfs/overlay/file.txt b/rootfs/overlay/file.txt
new file mode 100644
index 00000000..3bbe4864
--- /dev/null
+++ b/rootfs/overlay/file.txt
@@ -0,0 +1 @@
+Hello AlkOS from FAT32!
diff --git a/scripts/actions/make_rootfs.bash b/scripts/actions/make_rootfs.bash
new file mode 100755
index 00000000..9df143fe
--- /dev/null
+++ b/scripts/actions/make_rootfs.bash
@@ -0,0 +1,67 @@
+#!/usr/bin/env bash
+
+readonly MAKE_ROOTFS_SCRIPT_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" &>/dev/null && pwd)"
+readonly MAKE_ROOTFS_SCRIPT_PATH="${MAKE_ROOTFS_SCRIPT_DIR}/$(basename "$0")"
+readonly MAKE_ROOTFS_IMPL_DIR="${MAKE_ROOTFS_SCRIPT_DIR}/../rootfs"
+
+source "${MAKE_ROOTFS_SCRIPT_DIR}/../utils/helpers.bash"
+source "${MAKE_ROOTFS_SCRIPT_DIR}/../utils/conf_handlers.bash"
+source "${MAKE_ROOTFS_SCRIPT_DIR}/../utils/argparse.bash"
+
+source_conf_file
+verify_conf_var_exists CONF_ROOTFS_DIR
+verify_conf_var_exists CONF_ROOTFS_TARGET_PATH
+verify_conf_var_exists CONF_ROOTFS_OVERLAY_DIR
+
+# Filesystem types dictionary
+declare -A ALK_OS_SUPPORTED_FS=(
+    [fat]="FAT filesystem (fat12/fat16/fat32)"
+)
+
+help() {
+    echo "Examples:"
+    echo "    $0 fat --type fat32 --size 200M --label ALKOS"
+    echo
+}
+
+parse_args() {
+    argparse_init "${MAKE_ROOTFS_SCRIPT_PATH}" "Create a rootfs image for AlkOS" help
+    argparse_add_option "v|verbose" "Enable verbose output" false false "" "flag"
+
+    local fs_choices=$(echo "${!ALK_OS_SUPPORTED_FS[@]}" | tr ' ' '|')
+    argparse_add_positional "filesystem" "Filesystem type" true "$fs_choices"
+    argparse_add_variadic "extra_args" "Additional arguments for the chosen filesystem"
+
+    argparse_parse "$@"
+}
+
+copy_overlay_files() {
+    local overlay_dir="${CONF_ROOTFS_OVERLAY_DIR}"
+    local target_dir="${CONF_ROOTFS_DIR}"
+
+    if [[ -d "${overlay_dir}" ]]; then
+        cp -rT "${overlay_dir}" "${target_dir}"
+    fi
+}
+
+run_delegate() {
+    local fs_type="$(argparse_get "filesystem")"
+    local fs_script="${MAKE_ROOTFS_IMPL_DIR}/make_${fs_type}.bash"
+
+    # Check if filesystem script exists
+    if [[ ! -f "${fs_script}" ]]; then
+        dump_error "Filesystem script not found: ${fs_script}"
+    fi
+
+    # Execute filesystem-specific script
+    base_runner "Failed to make rootfs image for ${fs_type}" "$(argparse_get "v|verbose")" \
+    "${fs_script}" "${CONF_ROOTFS_DIR}" "${CONF_ROOTFS_TARGET_PATH}" "$(argparse_get "extra_args")"
+}
+
+main() {
+    parse_args "$@"
+    copy_overlay_files
+    run_delegate
+}
+
+main "$@"
diff --git a/scripts/config/feature_flags_schema.yaml b/scripts/config/feature_flags_schema.yaml
index 63e54781..c44d1fec 100644
--- a/scripts/config/feature_flags_schema.yaml
+++ b/scripts/config/feature_flags_schema.yaml
@@ -63,3 +63,7 @@ feature_flags:
     default: 2
     min: 0
     max: 3
+
+  - name: ramdisk
+    description: Load root filesystem from ramdisk instead of block device.
+    default: true
diff --git a/scripts/rootfs/make_fat.bash b/scripts/rootfs/make_fat.bash
new file mode 100755
index 00000000..49d784a3
--- /dev/null
+++ b/scripts/rootfs/make_fat.bash
@@ -0,0 +1,73 @@
+#!/usr/bin/env bash
+
+readonly MAKE_FAT_IMAGE_SCRIPT_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" &>/dev/null && pwd)"
+
+source "${MAKE_FAT_IMAGE_SCRIPT_DIR}/../utils/helpers.bash"
+source "${MAKE_FAT_IMAGE_SCRIPT_DIR}/../utils/argparse.bash"
+
+# FAT filesystem default configurations
+declare -A MAKE_FAT_DEFAULT_CONFIG=(
+    [type]="fat12"
+    [size]="1M"
+    [label]="ALKOS"
+    [sector_size]=512
+    [sectors_per_cluster]=2
+)
+
+parse_args() {
+    argparse_init "$(basename "$0")" "Create a FAT filesystem image"
+
+    argparse_add_option "type" "FAT type (fat12, fat16, fat32)" false "${MAKE_FAT_DEFAULT_CONFIG[type]}" "fat12|fat16|fat32"
+    argparse_add_option "size" "Size of the image" false "${MAKE_FAT_DEFAULT_CONFIG[size]}"
+    argparse_add_option "label" "Volume label" false "${MAKE_FAT_DEFAULT_CONFIG[label]}"
+    argparse_add_option "sector-size" "Sector size in bytes" false "${MAKE_FAT_DEFAULT_CONFIG[sector_size]}"
+    argparse_add_option "sectors-per-cluster" "Sectors per cluster" false "${MAKE_FAT_DEFAULT_CONFIG[sectors_per_cluster]}"
+
+    argparse_add_positional "source_dir" "Source directory to copy from" true
+    argparse_add_positional "target_dir" "Target image file path" true
+
+    argparse_parse "$@"
+}
+
+make_fat_image() {
+    local source_dir="$(argparse_get "source_dir")"
+    local target_dir="$(argparse_get "target_dir")"
+    local fat_type="$(argparse_get "type")"
+    local size="$(argparse_get "size")"
+    local label="$(argparse_get "label")"
+    local sector_size="$(argparse_get "sector-size")"
+    local sectors_per_cluster="$(argparse_get "sectors-per-cluster")"
+
+    # Get size in bytes and round up to the nearest 512-byte block
+    local size_bytes=$(convert_to_bytes "$size")
+    local block_count=$(ceil_division "$size_bytes" 512)
+    local target_size_bytes=$(("$block_count" * 512))
+
+    pretty_info "Creating FAT rootfs image with size $(from_bytes_to_human_readable "$target_size_bytes")..."
+
+    dd if=/dev/zero of="$target_dir" \
+       bs=512 count="$block_count" status=progress
+
+    mkfs.fat "${target_dir}" \
+             -F "${fat_type/fat/}" \
+             -n "${label}" \
+             -s "${sectors_per_cluster}" \
+             -S "${sector_size}"
+
+    pretty_info "FAT rootfs image created successfully."
+
+    if ! command -v mcopy &>/dev/null; then
+        dump_error "mtools is not installed. Please install it to use this script."
+        exit 1
+    fi
+
+    pretty_info "Copy the source directory to the image..."
+    mcopy -i "${target_dir}" -sv "${source_dir}"/* ::/
+}
+
+main() {
+    parse_args "$@"
+    make_fat_image
+}
+
+main "$@"
diff --git a/scripts/tests/test_framework/test_parser.py b/scripts/tests/test_framework/test_parser.py
index c35abd2e..3ef5bfc8 100644
--- a/scripts/tests/test_framework/test_parser.py
+++ b/scripts/tests/test_framework/test_parser.py
@@ -160,14 +160,18 @@ def _filter_tests(tests: list[TestInfo], filters: list[str], blocks: list[str])
         if is_blocked:
             continue
 
+        if not filters:
+            filtered_tests.append(test)
+            continue
+
         is_filtered = False
 
         for test_filter in filters:
-            if not fnmatch.fnmatch(test.test_name, test_filter):
+            if fnmatch.fnmatch(test.test_name, test_filter):
                 is_filtered = True
                 break
 
-        if is_filtered:
+        if not is_filtered:
             continue
 
         filtered_tests.append(test)
diff --git a/scripts/utils/helpers.bash b/scripts/utils/helpers.bash
index 4ef44223..bbdf65d8 100644
--- a/scripts/utils/helpers.bash
+++ b/scripts/utils/helpers.bash
@@ -130,6 +130,95 @@ strip_quotes() {
     echo "$input" | sed 's/^"\(.*\)"$/\1/' | sed "s/^'\(.*\)'$/\1/"
 }
 
+ceil_division() {
+    local numerator="$1"
+    local denominator="$2"
+    echo $(( (numerator + denominator - 1) / denominator ))
+}
+
+convert_to_bytes() {
+    assert_argument_provided "$1"
+
+    local size="$1"
+    local size_bytes
+
+    case ${size: -1} in
+        K|k) size_bytes=$((${size%?} * 1024)) ;;
+        M|m) size_bytes=$((${size%?} * 1024 * 1024)) ;;
+        G|g) size_bytes=$((${size%?} * 1024 * 1024 * 1024)) ;;
+        *) size_bytes="$size" ;;
+    esac
+
+    echo "${size_bytes}"
+}
+
+convert_to_kb() {
+    assert_argument_provided "$1"
+
+    local size="$1"
+    local size_kb
+
+    case ${size: -1} in
+        K|k) size_kb="${size%?}" ;;
+        M|m) size_kb=$((${size%?} * 1024)) ;;
+        G|g) size_kb=$((${size%?} * 1024 * 1024)) ;;
+        *) size_kb=$((size / 1024)) ;;
+    esac
+
+    echo "${size_kb}"
+}
+
+convert_to_mb() {
+    assert_argument_provided "$1"
+
+    local size="$1"
+    local size_mb
+
+    case ${size: -1} in
+        K|k) size_mb=$((${size%?} / 1024)) ;;
+        M|m) size_mb="${size%?}" ;;
+        G|g) size_mb=$((${size%?} * 1024)) ;;
+        *) size_mb=$((size / 1024 / 1024)) ;;
+    esac
+
+    echo "${size_mb}"
+}
+
+convert_to_gb() {
+    assert_argument_provided "$1"
+
+    local size="$1"
+    local size_gb
+
+    case ${size: -1} in
+        K|k) size_gb=$((${size%?} / 1024 / 1024)) ;;
+        M|m) size_gb=$((${size%?} / 1024)) ;;
+        G|g) size_gb="${size%?}" ;;
+        *) size_gb=$((size / 1024 / 1024 / 1024)) ;;
+    esac
+
+    echo "${size_gb}"
+}
+
+from_bytes_to_human_readable() {
+    assert_argument_provided "$1"
+
+    local size_bytes="$1"
+    local size_human_readable
+
+    if [ "$size_bytes" -lt 1024 ]; then
+        size_human_readable="${size_bytes}B"
+    elif [ "$size_bytes" -lt $((1024 * 1024)) ]; then
+        size_human_readable="$(convert_to_kb "$size_bytes")KiB"
+    elif [ "$size_bytes" -lt $((1024 * 1024 * 1024)) ]; then
+        size_human_readable="$(convert_to_mb "$size_bytes")MiB"
+    else
+        size_human_readable="$(convert_to_gb "$size_bytes")GiB"
+    fi
+
+    echo "${size_human_readable}"
+}
+
 require_root_privileges() {
     if [ "$EUID" -ne 0 ]; then
         dump_error "This operation requires root privileges. Please run as root or use sudo."
diff --git a/toolchains/x86_64-conf.cmake b/toolchains/x86_64-conf.cmake
index db167bd5..6903b780 100644
--- a/toolchains/x86_64-conf.cmake
+++ b/toolchains/x86_64-conf.cmake
@@ -2,8 +2,8 @@ set(CMAKE_C_FLAGS_RELEASE "" CACHE STRING "Release C flags" FORCE)
 set(CMAKE_CXX_FLAGS_RELEASE "" CACHE STRING "Release C++ flags" FORCE)
 
 # Architecture specific flags
-set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -ffreestanding -mstackrealign -ffile-prefix-map=${CMAKE_ROOT_DIR}/=")
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -ffreestanding -fno-exceptions -fno-rtti -mstackrealign -ffile-prefix-map=${CMAKE_ROOT_DIR}/=")
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -ffreestanding -mstackrealign -ffile-prefix-map=${CMAKE_ROOT_DIR}/=./")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -ffreestanding -fno-exceptions -fno-rtti -mstackrealign -ffile-prefix-map=${CMAKE_ROOT_DIR}/=./")
 
 # Debug or Release flags
 if (CMAKE_BUILD_TYPE STREQUAL "Debug" OR CMAKE_BUILD_TYPE STREQUAL "DEBUG")

From 94e8187be6cc0fa6c9674b07dd6275f3a0fed791 Mon Sep 17 00:00:00 2001
From: Adam Ogieniewski <ogieniewski.dev@gmail.com>
Date: Thu, 11 Dec 2025 07:43:50 +0100
Subject: [PATCH 07/56] Implements Virtual File System with FAT support (#233)

Adds a foundational Virtual File System (VFS) module, providing a
unified interface for file and directory operations across different
filesystems.

Key changes include:
- Introduces the core `VfsModule` for managing filesystem mount points
and routing file operations to appropriate drivers.
- Implements a robust `Path` class for handling absolute and relative
path parsing, manipulation, and normalization.
- Adds comprehensive support for FAT12, FAT16, and FAT32 filesystems
through a generic FAT driver architecture, including file and directory
management.
- Integrates an `InMemory` I/O driver, suitable for boot-time filesystem
interaction and testing.
- Incorporates new utility functions and macros across the codebase,
such as `DivRoundUp` for ceiling division, `OPTIONAL_FIELD` for
conditional struct members, and advanced array template utilities.
- Initializes the VFS during kernel startup, making file operations
available early in the boot process.
- Includes extensive unit tests for the `Path` class, VFS module, and
FAT12 driver to ensure correctness and reliability.
---
 kernel/arch/x86_64/boot/lib/mem/pmm.cpp       |    7 +-
 kernel/src/init.cpp                           |    3 +
 kernel/src/modules/vfs.cpp                    |  292 ++++
 kernel/src/modules/vfs.hpp                    |  201 +++
 kernel/src/trace_framework.hpp                |    7 +-
 kernel/src/vfs.hpp                            |  123 ++
 kernel/src/vfs/error.hpp                      |   33 +
 kernel/src/vfs/fat/fat.hpp                    | 1437 +++++++++++++++++
 kernel/src/vfs/fat/fat12.hpp                  |  181 +++
 kernel/src/vfs/fat/fat16.hpp                  |  135 ++
 kernel/src/vfs/fat/fat32.hpp                  |  162 ++
 kernel/src/vfs/interface.hpp                  |   59 +
 kernel/src/vfs/io/in_memory.hpp               |  105 ++
 kernel/src/vfs/path.hpp                       |  403 +++++
 kernel/src/vfs/types.hpp                      |  186 +++
 kernel/test/vfs/fat/fat12_test.cpp            |  496 ++++++
 kernel/test/vfs/path_test.cpp                 |  419 +++++
 kernel/test/vfs/vfs_module_test.cpp           |  559 +++++++
 libs/libc/include/defines.h                   |   18 +-
 libs/libc/internal/defines.cpp                |   14 +
 libs/libcpp/include/internal/math.hpp         |   27 +
 libs/libcpp/include/internal/span.hpp         |   28 +
 libs/libcpp/include/span.hpp                  |    8 +-
 .../include/template/array_utils.hpp          |   72 +
 libs/libtemplate/include/template_lib.hpp     |    1 +
 25 files changed, 4965 insertions(+), 11 deletions(-)
 create mode 100644 kernel/src/modules/vfs.cpp
 create mode 100644 kernel/src/modules/vfs.hpp
 create mode 100644 kernel/src/vfs.hpp
 create mode 100644 kernel/src/vfs/error.hpp
 create mode 100644 kernel/src/vfs/fat/fat.hpp
 create mode 100644 kernel/src/vfs/fat/fat12.hpp
 create mode 100644 kernel/src/vfs/fat/fat16.hpp
 create mode 100644 kernel/src/vfs/fat/fat32.hpp
 create mode 100644 kernel/src/vfs/interface.hpp
 create mode 100644 kernel/src/vfs/io/in_memory.hpp
 create mode 100644 kernel/src/vfs/path.hpp
 create mode 100644 kernel/src/vfs/types.hpp
 create mode 100644 kernel/test/vfs/fat/fat12_test.cpp
 create mode 100644 kernel/test/vfs/path_test.cpp
 create mode 100644 kernel/test/vfs/vfs_module_test.cpp
 create mode 100644 libs/libc/internal/defines.cpp
 create mode 100644 libs/libcpp/include/internal/math.hpp
 create mode 100644 libs/libcpp/include/internal/span.hpp
 create mode 100644 libs/libtemplate/include/template/array_utils.hpp

diff --git a/kernel/arch/x86_64/boot/lib/mem/pmm.cpp b/kernel/arch/x86_64/boot/lib/mem/pmm.cpp
index 0a45421f..80a2ed53 100644
--- a/kernel/arch/x86_64/boot/lib/mem/pmm.cpp
+++ b/kernel/arch/x86_64/boot/lib/mem/pmm.cpp
@@ -5,6 +5,7 @@
 #include <data_structures/bit_array.hpp>
 #include <expected.hpp>
 #include <internal/formats.hpp>
+#include <internal/math.hpp>
 #include <optional.hpp>
 
 #include "debug_trace.hpp"
@@ -274,6 +275,7 @@ std::expected<void, MemError> PhysicalMemoryManager::IterateToNextFreePage32()
 std::tuple<u64, u64> PhysicalMemoryManager::CalcBitmapSize(Multiboot::MemoryMap &mem_map)
 {
     using namespace Multiboot;
+    using namespace internal;
 
     u64 maximum_physical_address = 0;
     for (MmapEntry &entry : mem_map) {
@@ -283,9 +285,8 @@ std::tuple<u64, u64> PhysicalMemoryManager::CalcBitmapSize(Multiboot::MemoryMap
         maximum_physical_address = std::max(maximum_physical_address, entry.addr + entry.len);
     }
 
-    // Round up division TODO Add to libc
-    const u64 total_pages = static_cast<u64>(maximum_physical_address + kPageSize - 1) / kPageSize;
-    const u64 bitmap_size = (static_cast<u64>(total_pages) + 7) / 8;
+    const u64 total_pages = DivRoundUp(maximum_physical_address, kPageSize);
+    const u64 bitmap_size = DivRoundUp(total_pages, 8);
 
     TRACE_DEBUG(
         "Max avaliable physical address: %#018llx, total pages: %llu, bitmap size: %sB",
diff --git a/kernel/src/init.cpp b/kernel/src/init.cpp
index 5a43010f..bd0738a8 100644
--- a/kernel/src/init.cpp
+++ b/kernel/src/init.cpp
@@ -10,6 +10,7 @@
 #include "modules/hardware.hpp"
 #include "modules/memory.hpp"
 #include "modules/timing.hpp"
+#include "modules/vfs.hpp"
 #include "modules/video.hpp"
 #include "trace_framework.hpp"
 
@@ -55,5 +56,7 @@ void KernelInit(const hal::RawBootArguments &raw_args)
 
     MemoryModule::Get().RegisterPageFault(HardwareModule::Get());
 
+    VfsModule::Init();
+
     VideoModule::Init(args, MemoryModule::Get().GetHeap());
 }
diff --git a/kernel/src/modules/vfs.cpp b/kernel/src/modules/vfs.cpp
new file mode 100644
index 00000000..dcc01664
--- /dev/null
+++ b/kernel/src/modules/vfs.cpp
@@ -0,0 +1,292 @@
+#include "vfs.hpp"
+#include "../vfs.hpp"
+
+#include <mem/heap.hpp>
+#include <trace_framework.hpp>
+
+using namespace vfs;
+
+// ------------------------------
+// Construction
+// ------------------------------
+
+internal::VfsModule::VfsModule() noexcept { TRACE_INFO_VFS("VFS Module initialized"); }
+
+// ------------------------------
+// Mount Point Management
+// ------------------------------
+
+Result<> internal::VfsModule::Mount(
+    const Path &mount_path, MountOptions options, Filesystem &driver
+)
+{
+    if (mount_path.IsEmpty() || !mount_path.IsAbsolute()) {
+        return std::unexpected(VfsError::kInvalidPath);
+    }
+
+    if (GetMounts().Contains(mount_path.CString())) {
+        return std::unexpected(VfsError::kAlreadyMounted);
+    }
+
+    bool inserted = GetMounts().Insert(mount_path.CString(), mount_path, options, driver);
+    if (!inserted) {
+        return std::unexpected(VfsError::kUnknownError);
+    }
+
+    TRACE_INFO_VFS("Mounted %s filesystem at %s", driver.GetInfo().name, mount_path.CString());
+    return {};
+}
+
+Result<> internal::VfsModule::Unmount(const Path &mount_path)
+{
+    if (mount_path.IsEmpty() || !mount_path.IsAbsolute()) {
+        return std::unexpected(VfsError::kInvalidPath);
+    }
+
+    if (!GetMounts().Contains(mount_path.CString())) {
+        return std::unexpected(VfsError::kNotMounted);
+    }
+
+    bool removed = GetMounts().Remove(mount_path.CString());
+    if (!removed) {
+        return std::unexpected(VfsError::kUnknownError);
+    }
+
+    TRACE_INFO_VFS("Unmounted filesystem at %s", mount_path.CString());
+    return {};
+}
+
+Result<MountPoint *> internal::VfsModule::FindMountPoint(const Path &path)
+{
+    if (path.IsEmpty()) {
+        return std::unexpected(VfsError::kInvalidPath);
+    }
+
+    auto match = GetMounts().GetLongestPrefixMatch(path.CString());
+    if (match) {
+        return *match;
+    }
+
+    return std::unexpected(VfsError::kMountPointNotFound);
+}
+
+// ------------------------------
+// Path Utilities
+// ------------------------------
+
+Path internal::VfsModule::GetRelativePath_(const Path &absolute_path, const Path &mount_path)
+{
+    // If the mount point is root, the relative path is the same as absolute
+    if (mount_path.IsRoot()) {
+        return absolute_path;
+    }
+
+    // Build relative path by skipping mount_path components
+    size_t mount_components    = mount_path.ComponentCount();
+    size_t absolute_components = absolute_path.ComponentCount();
+
+    if (mount_components >= absolute_components) {
+        // The path is the mount point itself, return root
+        return Path("/");
+    }
+
+    // Build path from remaining components
+    Path result("/");
+    for (size_t i = mount_components; i < absolute_components; ++i) {
+        result /= absolute_path.GetComponent(i);
+    }
+
+    return result;
+}
+
+// ------------------------------
+// File Operations
+// ------------------------------
+
+Result<> internal::VfsModule::CreateFile(const Path &path)
+{
+    auto mount_result = FindMountPoint(path);
+    if (!mount_result.has_value()) {
+        return std::unexpected(mount_result.error());
+    }
+
+    MountPoint *mount = mount_result.value();
+
+    if (mount->options.read_only) {
+        return std::unexpected(VfsError::kReadOnly);
+    }
+
+    Path relative_path = GetRelativePath_(path, mount->path);
+    return mount->fs.CreateFile(relative_path);
+}
+
+Result<size_t> internal::VfsModule::ReadFile(
+    const Path &path, void *buffer, size_t size, size_t offset
+)
+{
+    auto mount_result = FindMountPoint(path);
+    if (!mount_result.has_value()) {
+        return std::unexpected(mount_result.error());
+    }
+
+    MountPoint *mount  = mount_result.value();
+    Path relative_path = GetRelativePath_(path, mount->path);
+    return mount->fs.ReadFile(relative_path, buffer, size, offset);
+}
+
+Result<size_t> internal::VfsModule::WriteFile(
+    const Path &path, const void *buffer, size_t size, size_t offset
+)
+{
+    auto mount_result = FindMountPoint(path);
+    if (!mount_result.has_value()) {
+        return std::unexpected(mount_result.error());
+    }
+
+    MountPoint *mount = mount_result.value();
+
+    if (mount->options.read_only) {
+        return std::unexpected(VfsError::kReadOnly);
+    }
+
+    Path relative_path = GetRelativePath_(path, mount->path);
+    return mount->fs.WriteFile(relative_path, buffer, size, offset);
+}
+
+Result<> internal::VfsModule::DeleteFile(const Path &path)
+{
+    auto mount_result = FindMountPoint(path);
+    if (!mount_result.has_value()) {
+        return std::unexpected(mount_result.error());
+    }
+
+    MountPoint *mount = mount_result.value();
+
+    if (mount->options.read_only) {
+        return std::unexpected(VfsError::kReadOnly);
+    }
+
+    Path relative_path = GetRelativePath_(path, mount->path);
+    return mount->fs.DeleteFile(relative_path);
+}
+
+Result<bool> internal::VfsModule::FileExists(const Path &path)
+{
+    auto mount_result = FindMountPoint(path);
+    if (!mount_result.has_value()) {
+        return std::unexpected(mount_result.error());
+    }
+
+    MountPoint *mount  = mount_result.value();
+    Path relative_path = GetRelativePath_(path, mount->path);
+    return mount->fs.FileExists(relative_path);
+}
+
+Result<size_t> internal::VfsModule::GetFileSize(const Path &path)
+{
+    auto mount_result = FindMountPoint(path);
+    if (!mount_result.has_value()) {
+        return std::unexpected(mount_result.error());
+    }
+
+    MountPoint *mount  = mount_result.value();
+    Path relative_path = GetRelativePath_(path, mount->path);
+    return mount->fs.GetFileSize(relative_path);
+}
+
+// ------------------------------
+// Directory Operations
+// ------------------------------
+
+Result<> internal::VfsModule::CreateDirectory(const Path &path)
+{
+    auto mount_result = FindMountPoint(path);
+    if (!mount_result.has_value()) {
+        return std::unexpected(mount_result.error());
+    }
+
+    MountPoint *mount = mount_result.value();
+
+    if (mount->options.read_only) {
+        return std::unexpected(VfsError::kReadOnly);
+    }
+
+    Path relative_path = GetRelativePath_(path, mount->path);
+    return mount->fs.CreateDirectory(relative_path);
+}
+
+Result<> internal::VfsModule::RemoveDirectory(const Path &path)
+{
+    auto mount_result = FindMountPoint(path);
+    if (!mount_result.has_value()) {
+        return std::unexpected(mount_result.error());
+    }
+
+    MountPoint *mount = mount_result.value();
+
+    if (mount->options.read_only) {
+        return std::unexpected(VfsError::kReadOnly);
+    }
+
+    Path relative_path = GetRelativePath_(path, mount->path);
+    return mount->fs.RemoveDirectory(relative_path);
+}
+
+Result<bool> internal::VfsModule::DirectoryExists(const Path &path)
+{
+    auto mount_result = FindMountPoint(path);
+    if (!mount_result.has_value()) {
+        return std::unexpected(mount_result.error());
+    }
+
+    MountPoint *mount  = mount_result.value();
+    Path relative_path = GetRelativePath_(path, mount->path);
+    return mount->fs.DirectoryExists(relative_path);
+}
+
+// ------------------------------
+// General Operations
+// ------------------------------
+
+Result<bool> internal::VfsModule::Exists(const Path &path)
+{
+    auto mount_result = FindMountPoint(path);
+    if (!mount_result.has_value()) {
+        return std::unexpected(mount_result.error());
+    }
+
+    MountPoint *mount  = mount_result.value();
+    Path relative_path = GetRelativePath_(path, mount->path);
+    return mount->fs.Exists(relative_path);
+}
+
+Result<> internal::VfsModule::Move(const Path &old_path, const Path &new_path)
+{
+    // Find mount points for both paths
+    auto old_mount_result = FindMountPoint(old_path);
+    if (!old_mount_result.has_value()) {
+        return std::unexpected(old_mount_result.error());
+    }
+
+    auto new_mount_result = FindMountPoint(new_path);
+    if (!new_mount_result.has_value()) {
+        return std::unexpected(new_mount_result.error());
+    }
+
+    MountPoint *old_mount = old_mount_result.value();
+    MountPoint *new_mount = new_mount_result.value();
+
+    // Cross-filesystem move is not supported
+    if (old_mount != new_mount) {
+        return std::unexpected(VfsError::kCrossFilesystemRename);
+    }
+
+    if (old_mount->options.read_only) {
+        return std::unexpected(VfsError::kReadOnly);
+    }
+
+    Path old_relative = GetRelativePath_(old_path, old_mount->path);
+    Path new_relative = GetRelativePath_(new_path, new_mount->path);
+
+    return old_mount->fs.Move(old_relative, new_relative);
+}
diff --git a/kernel/src/modules/vfs.hpp b/kernel/src/modules/vfs.hpp
new file mode 100644
index 00000000..73dbb546
--- /dev/null
+++ b/kernel/src/modules/vfs.hpp
@@ -0,0 +1,201 @@
+#ifndef KERNEL_SRC_MODULES_VFS_HPP_
+#define KERNEL_SRC_MODULES_VFS_HPP_
+
+#include <template_lib.hpp>
+#include <vfs/types.hpp>
+#include "modules/helpers.hpp"
+
+namespace internal
+{
+class VfsModule : template_lib::StaticSingletonHelper
+{
+    // -------------------------------------
+    // Protected singleton constructor
+    // -------------------------------------
+
+    protected:
+    VfsModule() noexcept;
+
+    // ------------------------------
+    // Module fields
+    // ------------------------------
+
+    DEFINE_MODULE_FIELD(vfs, Mounts);
+
+    // ------------------------------
+    // Mount Point Management
+    // ------------------------------
+
+    public:
+    /**
+     * @brief Mount a filesystem at the specified path.
+     *
+     * @param mount_path Absolute path where filesystem should be mounted
+     * @param options Mount options (e.g., read-only)
+     * @param driver Handle to the filesystem driver
+     * @return Result Success or error
+     */
+    vfs::Result<> Mount(
+        const vfs::Path &mount_path, vfs::MountOptions options, vfs::Filesystem &driver
+    );
+
+    /**
+     * @brief Unmount a filesystem at the specified path.
+     *
+     * @param mount_path Path of the mount point to unmount
+     * @return Result Success or error
+     */
+    vfs::Result<> Unmount(const vfs::Path &mount_path);
+
+    /**
+     * @brief Find the mountpoint for a given path using longest prefix matching.
+     *
+     * @param path Path to resolve
+     * @return Optional pointer to the MountPoint, or empty if no mount found
+     */
+    vfs::Result<vfs::MountPoint *> FindMountPoint(const vfs::Path &path);
+
+    // ------------------------------
+    // File Operations
+    // ------------------------------
+
+    /**
+     * @brief Create a new file at the specified path.
+     *
+     * @param path Absolute path of the file to create
+     * @return Result Success or error
+     */
+    vfs::Result<> CreateFile(const vfs::Path &path);
+
+    /**
+     * @brief Read data from a file.
+     *
+     * @param path Absolute path of the file
+     * @param buffer Buffer to read data into
+     * @param size Number of bytes to read
+     * @param offset Offset in the file to start reading from
+     * @return Result Number of bytes read or error
+     */
+    vfs::Result<size_t> ReadFile(const vfs::Path &path, void *buffer, size_t size, size_t offset);
+
+    /**
+     * @brief Write data to a file.
+     *
+     * @param path Absolute path of the file
+     * @param buffer Buffer containing data to write
+     * @param size Number of bytes to write
+     * @param offset Offset in the file to start writing at
+     * @return Result Number of bytes written or error
+     */
+    vfs::Result<size_t> WriteFile(
+        const vfs::Path &path, const void *buffer, size_t size, size_t offset
+    );
+
+    /**
+     * @brief Delete a file.
+     *
+     * @param path Absolute path of the file to delete
+     * @return Result Success or error
+     */
+    vfs::Result<> DeleteFile(const vfs::Path &path);
+
+    /**
+     * @brief Check if a file exists.
+     *
+     * @param path Absolute path to check
+     * @return Result True if file exists, false otherwise, or error
+     */
+    vfs::Result<bool> FileExists(const vfs::Path &path);
+
+    /**
+     * @brief Get the size of a file.
+     *
+     * @param path Absolute path of the file
+     * @return Result File size in bytes or error
+     */
+    vfs::Result<size_t> GetFileSize(const vfs::Path &path);
+
+    // ------------------------------
+    // Directory Operations
+    // ------------------------------
+
+    /**
+     * @brief Create a new directory.
+     *
+     * @param path Absolute path of the directory to create
+     * @return Result Success or error
+     */
+    vfs::Result<> CreateDirectory(const vfs::Path &path);
+
+    /**
+     * @brief Remove an empty directory.
+     *
+     * @param path Absolute path of the directory to remove
+     * @return Result Success or error
+     */
+    vfs::Result<> RemoveDirectory(const vfs::Path &path);
+
+    /**
+     * @brief List contents of a directory.
+     *
+     * @param path Absolute path of the directory
+     * @param callback Function called for each entry with (name, is_directory)
+     */
+    template <typename Callback>
+    void ListDirectory(const vfs::Path &path, Callback &&callback)
+    {
+        auto mount_result = FindMountPoint(path);
+        if (!mount_result.has_value()) {
+            return;
+        }
+
+        vfs::MountPoint *mount  = mount_result.value();
+        vfs::Path relative_path = GetRelativePath_(path, mount->path);
+        mount->fs.ListDirectory(relative_path, std::forward<Callback>(callback));
+    }
+
+    /**
+     * @brief Check if a directory exists.
+     *
+     * @param path Absolute path to check
+     * @return Result True if directory exists, false otherwise, or error
+     */
+    vfs::Result<bool> DirectoryExists(const vfs::Path &path);
+
+    // ------------------------------
+    // General Operations
+    // ------------------------------
+
+    /**
+     * @brief Check if a path exists (file or directory).
+     *
+     * @param path Absolute path to check
+     * @return Result True if exists, false otherwise, or error
+     */
+    vfs::Result<bool> Exists(const vfs::Path &path);
+
+    /**
+     * @brief Rename or move a file/directory.
+     *
+     * @param old_path Current absolute path
+     * @param new_path New absolute path
+     * @return Result Success or error
+     */
+    vfs::Result<> Move(const vfs::Path &old_path, const vfs::Path &new_path);
+
+    private:
+    /**
+     * @brief Convert an absolute path to a path relative to the mount point.
+     *
+     * @param absolute_path The full absolute path
+     * @param mount_path The mount point path
+     * @return Path relative to the mount point
+     */
+    static vfs::Path GetRelativePath_(const vfs::Path &absolute_path, const vfs::Path &mount_path);
+};
+
+}  // namespace internal
+
+using VfsModule = template_lib::StaticSingleton<internal::VfsModule>;
+
+#endif  // KERNEL_SRC_MODULES_VFS_HPP_
diff --git a/kernel/src/trace_framework.hpp b/kernel/src/trace_framework.hpp
index d49f37ac..5b2b8a00 100644
--- a/kernel/src/trace_framework.hpp
+++ b/kernel/src/trace_framework.hpp
@@ -32,7 +32,8 @@ enum class TraceType {
 };
 
 enum class TraceModule {
-    kMemory = 0,
+    kVfs = 0,
+    kMemory,
     kInterrupts,
     kBoot,
     kGeneral,
@@ -80,6 +81,10 @@ PREVENT_INLINE static void Write(const char *format, Args... args);
     CREATE_HELPER(kKernelLog, module, kInfo, TRACE_INFO_##module_name)       \
     CREATE_HELPER(kKernelLog, module, kFrequentInfo, TRACE_FREQ_INFO_##module_name)
 
+// VFS
+CREATE_DEBUG_HELPERS(kVfs, VFS)
+CREATE_TRACE_HELPERS(kVfs, VFS)
+
 // MEMORY
 CREATE_DEBUG_HELPERS(kMemory, MEMORY)
 CREATE_TRACE_HELPERS(kMemory, MEMORY)
diff --git a/kernel/src/vfs.hpp b/kernel/src/vfs.hpp
new file mode 100644
index 00000000..91e8081e
--- /dev/null
+++ b/kernel/src/vfs.hpp
@@ -0,0 +1,123 @@
+#ifndef KERNEL_SRC_VFS_HPP_
+#define KERNEL_SRC_VFS_HPP_
+
+#include <modules/vfs.hpp>
+
+namespace vfs
+{
+
+// ------------------------------
+// General VFS Operations
+// ------------------------------
+
+/**
+ * @brief Mount a filesystem at the specified path.
+ */
+FORCE_INLINE_F Result<> Mount(const Path &mount_path, MountOptions options, Filesystem &driver)
+{
+    return VfsModule::Get().Mount(mount_path, options, driver);
+}
+
+/**
+ * @brief Unmount a filesystem at the specified path.
+ */
+FORCE_INLINE_F Result<> Unmount(const Path &mount_path)
+{
+    return VfsModule::Get().Unmount(mount_path);
+}
+
+/**
+ * @brief Create a new file at the specified path.
+ */
+FORCE_INLINE_F Result<> CreateFile(const Path &path) { return VfsModule::Get().CreateFile(path); }
+
+/**
+ * @brief Read data from a file.
+ */
+FORCE_INLINE_F Result<size_t> ReadFile(
+    const Path &path, void *buffer, size_t size, size_t offset = 0
+)
+{
+    return VfsModule::Get().ReadFile(path, buffer, size, offset);
+}
+
+/**
+ * @brief Write data to a file.
+ */
+FORCE_INLINE_F Result<size_t> WriteFile(
+    const Path &path, const void *buffer, size_t size, size_t offset = 0
+)
+{
+    return VfsModule::Get().WriteFile(path, buffer, size, offset);
+}
+
+/**
+ * @brief Delete a file.
+ */
+FORCE_INLINE_F Result<> DeleteFile(const Path &path) { return VfsModule::Get().DeleteFile(path); }
+
+/**
+ * @brief Check if a file exists.
+ */
+FORCE_INLINE_F Result<bool> FileExists(const Path &path)
+{
+    return VfsModule::Get().FileExists(path);
+}
+
+/**
+ * @brief Get the size of a file.
+ */
+FORCE_INLINE_F Result<size_t> GetFileSize(const Path &path)
+{
+    return VfsModule::Get().GetFileSize(path);
+}
+
+/**
+ * @brief Create a new directory.
+ */
+FORCE_INLINE_F Result<> CreateDirectory(const Path &path)
+{
+    return VfsModule::Get().CreateDirectory(path);
+}
+
+/**
+ * @brief Remove an empty directory.
+ */
+FORCE_INLINE_F Result<> RemoveDirectory(const Path &path)
+{
+    return VfsModule::Get().RemoveDirectory(path);
+}
+
+/**
+ * @brief List contents of a directory.
+ */
+template <typename Callback>
+FORCE_INLINE_F void ListDirectory(const Path &path, Callback &&callback)
+{
+    VfsModule::Get().ListDirectory(path, std::forward<Callback>(callback));
+}
+
+/**
+ * @brief Check if a directory exists.
+ */
+FORCE_INLINE_F Result<bool> DirectoryExists(const Path &path)
+{
+    return VfsModule::Get().DirectoryExists(path);
+}
+
+/**
+ * @brief Check if a path exists (file or directory).
+ */
+FORCE_INLINE_F Result<bool> Exists(const Path &path) { return VfsModule::Get().Exists(path); }
+
+/**
+ * @brief Rename or move a file/directory.
+ */
+FORCE_INLINE_F Result<> Move(const Path &old_path, const Path &new_path)
+{
+    return VfsModule::Get().Move(old_path, new_path);
+}
+
+}  // namespace vfs
+
+#endif  // KERNEL_SRC_VFS_HPP_
diff --git a/kernel/src/vfs/error.hpp b/kernel/src/vfs/error.hpp
new file mode 100644
index 00000000..0b765b19
--- /dev/null
+++ b/kernel/src/vfs/error.hpp
@@ -0,0 +1,33 @@
+#ifndef KERNEL_SRC_VFS_ERROR_HPP_
+#define KERNEL_SRC_VFS_ERROR_HPP_
+
+#include <expected.hpp>
+
+namespace vfs
+{
+
+enum class VfsError {
+    kFileNotFound,
+    kDirectoryNotFound,
+    kInvalidPath,
+    kMountPointNotFound,
+    kAlreadyMounted,
+    kNotMounted,
+    kInvalidArgument,
+    kAlreadyExists,
+    kNotEmpty,
+    kNotADirectory,
+    kNotAFile,
+    kInvalidName,
+    kReadOnly,
+    kDiskFull,
+    kCrossFilesystemRename,
+    kUnknownError,
+};
+
+template <typename T = void>
+using Result = std::expected<T, VfsError>;
+
+}  // namespace vfs
+
+#endif  // KERNEL_SRC_VFS_ERROR_HPP_
diff --git a/kernel/src/vfs/fat/fat.hpp b/kernel/src/vfs/fat/fat.hpp
new file mode 100644
index 00000000..47d1c8db
--- /dev/null
+++ b/kernel/src/vfs/fat/fat.hpp
@@ -0,0 +1,1437 @@
+#ifndef KERNEL_SRC_VFS_FAT_FAT_HPP_
+#define KERNEL_SRC_VFS_FAT_FAT_HPP_
+
+#include <ctype.h>
+#include <string.h>
+#include <internal/span.hpp>
+#include <span.hpp>
+#include <string.hpp>
+#include <template_lib.hpp>
+#include <trace_framework.hpp>
+#include <vfs.hpp>
+#include <vfs/error.hpp>
+#include <vfs/interface.hpp>
+#include <vfs/path.hpp>
+
+namespace vfs
+{
+
+template <template <typename> typename T, typename IO>
+class Fat
+{
+    using ImplT  = T<IO>;
+    using Traits = FatTraits<T, IO>;
+
+    protected:
+    using ClusterNumT                      = typename Traits::ClusterNumT;
+    static constexpr bool kHasFixedRootDir = Traits::kHasFixedRootDir;
+
+    // ------------------------------
+    // Construction
+    // ------------------------------
+
+    Fat() = delete;
+
+    explicit Fat(IO &io) : io_(io)
+    {
+        if constexpr (requires { ImplT::kCleanShutdownMarker; }) {
+            if (!IsBitEnabled<ImplT::kCleanShutdownMarker>(GetFATEntry_(1))) {
+                TRACE_WARN_VFS(
+                    "Filesystem has not been shut down properly, some data may be lost!"
+                );
+            }
+        }
+    }
+
+    ~Fat() = default;
+
+    // ------------------------------
+    // FAT Structures
+    // ------------------------------
+
+    struct BootSector {
+        static constexpr u16 kSignature = 0xAA55;
+
+        // FAT12/FAT16/FAT32 common fields
+        byte jump_instruction[3];
+        char oem_name[8];
+        u16 bytes_per_sector;
+        u8 sectors_per_cluster;
+        u16 reserved_sectors;
+        u8 number_of_fats;
+        u16 root_dir_entries;
+        u16 total_sectors_word;  // 0 if FAT32 then total_sectors_dword is used
+        u8 media_descriptor;     // 0xF8 for fixed disk, 0xF0 for removable disk
+        u16 fat_size_word;       // 0 if FAT32
+        u16 sectors_per_track;
+        u16 number_of_heads;
+        u32 hidden_sectors;
+        u32 total_sectors_dword;
+    } PACK;
+    static_assert(sizeof(BootSector) == 36, "BootSector size mismatch");
+
+    struct LongDirectoryEntry {
+        static constexpr u8 kLastLongEntryMask = 0x40;
+
+        NODISCARD FORCE_INLINE_F bool IsLast() const { return (order & kLastLongEntryMask) != 0; }
+
+        u8 order;               // Order of the entry in the long name sequence
+        char name1[10];         // First 5 characters of the long name
+        u8 attributes;          // Must be LongName (0x0F)
+        u8 type;                // Must be 0x00
+        u8 checksum;            // Checksum for the short name
+        char name2[12];         // Next 6 characters of the long name
+        u16 first_cluster_low;  // Must be zero
+        char name3[4];          // Last 2 characters of the long name
+    } PACK;
+    static_assert(sizeof(LongDirectoryEntry) == 32, "LongDirectoryEntry size mismatch");
+
+    struct DirectoryEntry {
+        static constexpr u8 kLongNameMask = 0x3F;
+        static constexpr u8 kDeletedEntry = 0xE5;
+        static constexpr u8 kEOD          = 0x00;
+
+        enum class Attributes : u8 {
+            None        = 0x00,
+            ReadOnly    = 0x01,
+            Hidden      = 0x02,
+            System      = 0x04,
+            VolumeLabel = 0x08,
+            Directory   = 0x10,
+            Archive     = 0x20,
+            LongName    = 0x0F,  // ReadOnly | Hidden | System | VolumeLabel
+        };
+
+        friend constexpr Attributes operator|(Attributes a, Attributes b)
+        {
+            return static_cast<Attributes>(static_cast<u8>(a) | static_cast<u8>(b));
+        }
+
+        friend constexpr Attributes operator&(Attributes a, Attributes b)
+        {
+            return static_cast<Attributes>(static_cast<u8>(a) & static_cast<u8>(b));
+        }
+
+        friend constexpr Attributes operator&(Attributes a, u8 b)
+        {
+            return static_cast<Attributes>(static_cast<u8>(a) & b);
+        }
+
+        friend constexpr bool operator==(Attributes a, Attributes b)
+        {
+            return static_cast<u8>(a) == static_cast<u8>(b);
+        }
+
+        NODISCARD FORCE_INLINE_F bool IsLongNameSubComponent() const
+        {
+            return ((attributes & kLongNameMask) == Attributes::LongName) && !IsFree();
+        }
+
+        NODISCARD FORCE_INLINE_F LongDirectoryEntry *TryGetLongNameSubComponent()
+        {
+            return IsLongNameSubComponent() ? reinterpret_cast<LongDirectoryEntry *>(this)
+                                            : nullptr;
+        }
+
+        NODISCARD FORCE_INLINE_F u8 GetCheckSum() const
+        {
+            u8 sum   = 0;
+            auto ptr = reinterpret_cast<const unsigned char *>(filename);
+            for (size_t i = kMaxNameLength; i != 0; --i) {
+                sum = ((sum & 1) ? 0x80 : 0) + (sum >> 1) + *ptr++;
+            }
+            return sum;
+        }
+
+        NODISCARD FORCE_INLINE_F bool IsDirectory() const
+        {
+            return (attributes & (Attributes::Directory | Attributes::VolumeLabel)) ==
+                   Attributes::Directory;
+        }
+
+        NODISCARD FORCE_INLINE_F bool IsFile() const
+        {
+            return (attributes & (Attributes::Directory | Attributes::VolumeLabel)) ==
+                   Attributes::None;
+        }
+
+        NODISCARD FORCE_INLINE_F bool IsVolumeLabel() const
+        {
+            return (attributes & (Attributes::Directory | Attributes::VolumeLabel)) ==
+                   Attributes::VolumeLabel;
+        }
+
+        NODISCARD FORCE_INLINE_F bool IsValid() const
+        {
+            return IsFile() || IsDirectory() || IsVolumeLabel();
+        }
+
+        NODISCARD FORCE_INLINE_F bool IsRootDirectory() const
+        {
+            return IsDirectory() && first_cluster_low == 0 && first_cluster_high == 0;
+        }
+
+        NODISCARD FORCE_INLINE_F bool IsFree() const
+        {
+            return reinterpret_cast<const byte &>(*this) == kDeletedEntry;
+        }
+        NODISCARD FORCE_INLINE_F bool IsFurtherEntriesFree() const
+        {
+            return reinterpret_cast<const byte &>(*this) == kEOD;
+        }
+
+        char filename[11];  // Padded with spaces
+        Attributes attributes;
+        RESERVED(1);
+        u8 creation_time_tenth;  // Time in tenths of seconds, valid range 0-199
+        u16 creation_time;       // Time in 2-second intervals
+        u16 creation_date;       // Date relative to MS-DOS epoch of 01/01/1980.
+        u16 last_access_date;
+        u16 first_cluster_high;  // High 16 bits of the first cluster number
+        u16 last_write_time;     // Must be supported
+        u16 last_write_date;     // Must be supported
+        u16 first_cluster_low;   // Low 16 bits of the first cluster number
+        u32 file_size;           // Size of the file in bytes
+    } PACK;
+    static_assert(sizeof(DirectoryEntry) == 32, "DirectoryEntry size mismatch");
+
+    struct PathLookupResult {
+        DirectoryEntry entry;
+        ClusterNumT parent_cluster;
+        size_t entry_offset;  // Offset within the parent directory cluster
+        bool found;
+    };
+
+    // ------------------------------
+    // Constants
+    // ------------------------------
+
+    static constexpr u16 kMaxDirectoryEntries   = static_cast<u16>(-1);
+    static constexpr size_t kFirstClusterNumber = 2;
+    static constexpr size_t kMaxNameLength      = 11;
+    static constexpr size_t kMaxClusterSize     = 32768;
+    static constexpr auto kDot    = template_lib::fill_array_v<char, kMaxNameLength, ' ', '.'>;
+    static constexpr auto kDotDot = template_lib::fill_array_v<char, kMaxNameLength, ' ', '.', '.'>;
+
+    // ------------------------------
+    // Validation
+    // ------------------------------
+
+    NODISCARD static bool IsValid(IO &io)
+    {
+        auto sector_data = io.ReadSector(0);
+
+        if (!ValidateBootSignature_(sector_data)) {
+            return false;
+        }
+
+        auto boot_sector = internal::get<const BootSector>(sector_data);
+
+        if (!ValidateJumpInstruction_(boot_sector)) {
+            return false;
+        }
+
+        if (!ValidateSectorAndClusterSize_(boot_sector)) {
+            return false;
+        }
+
+        if (!ValidateReservedSectors_(boot_sector)) {
+            return false;
+        }
+
+        if (!ValidateFatCount_(boot_sector)) {
+            return false;
+        }
+
+        if (!ValidateMediaDescriptor_(boot_sector)) {
+            return false;
+        }
+
+        if (!ValidateFatMediaDescriptor_(io, boot_sector)) {
+            return false;
+        }
+
+        return true;
+    }
+
+    // ------------------------------
+    // VFS Filesystem Interface
+    // ------------------------------
+
+    NODISCARD Filesystem GetFilesystem()
+    {
+        return Filesystem(
+            this,
+            Filesystem::Operations{
+                .create_file      = &Fat::CreateFileCallback_,
+                .read_file        = &Fat::ReadFileCallback_,
+                .write_file       = &Fat::WriteFileCallback_,
+                .delete_file      = &Fat::DeleteFileCallback_,
+                .file_exists      = &Fat::FileExistsCallback_,
+                .get_file_size    = &Fat::GetFileSizeCallback_,
+                .create_directory = &Fat::CreateDirectoryCallback_,
+                .remove_directory = &Fat::RemoveDirectoryCallback_,
+                .list_directory   = &Fat::ListDirectoryCallback_,
+                .directory_exists = &Fat::DirectoryExistsCallback_,
+                .exists           = &Fat::ExistsCallback_,
+                .move             = &Fat::MoveCallback_,
+            },
+            Filesystem::Info{
+                .type = ImplT::kFsType,
+                .name = ImplT::kFsName,
+            }
+        );
+    }
+
+    // ------------------------------
+    // File Operations
+    // ------------------------------
+
+    NODISCARD Result<> CreateFile(const Path &path)
+    {
+        if (path.IsEmpty() || !path.HasComponents()) {
+            return std::unexpected(VfsError::kInvalidPath);
+        }
+
+        char formatted_name[kMaxNameLength];
+        if (!FormatFilename_(path.GetFilename(), formatted_name)) {
+            return std::unexpected(VfsError::kInvalidName);
+        }
+
+        if (LookupPath_(path).found) {
+            return std::unexpected(VfsError::kAlreadyExists);
+        }
+
+        auto parent_cluster = GetParentCluster_(path);
+        if (!parent_cluster.has_value()) {
+            return std::unexpected(VfsError::kDirectoryNotFound);
+        }
+
+        return CreateEntry_(
+            parent_cluster.value(), formatted_name, DirectoryEntry::Attributes::Archive, 0
+        );
+    }
+
+    NODISCARD Result<size_t> ReadFile(const Path &path, void *buffer, size_t size, size_t offset)
+    {
+        if (!buffer || size == 0) {
+            return std::unexpected(VfsError::kInvalidArgument);
+        }
+
+        auto lookup = LookupPath_(path);
+        if (!lookup.found) {
+            return std::unexpected(VfsError::kFileNotFound);
+        }
+
+        if (!lookup.entry.IsFile()) {
+            return std::unexpected(VfsError::kNotAFile);
+        }
+
+        if (offset >= lookup.entry.file_size) {
+            return 0;
+        }
+
+        return ReadFileData_(lookup.entry, buffer, size, offset);
+    }
+
+    NODISCARD Result<size_t> WriteFile(
+        const Path &path, const void *buffer, size_t size, size_t offset
+    )
+    {
+        if (!buffer || size == 0) {
+            return std::unexpected(VfsError::kInvalidArgument);
+        }
+
+        auto lookup = LookupPath_(path);
+        if (!lookup.found) {
+            return std::unexpected(VfsError::kFileNotFound);
+        }
+
+        if (!lookup.entry.IsFile()) {
+            return std::unexpected(VfsError::kNotAFile);
+        }
+
+        return WriteFileData_(lookup, buffer, size, offset);
+    }
+
+    NODISCARD Result<> DeleteFile(const Path &path)
+    {
+        auto lookup = LookupPath_(path);
+        if (!lookup.found) {
+            return std::unexpected(VfsError::kFileNotFound);
+        }
+
+        if (!lookup.entry.IsFile()) {
+            return std::unexpected(VfsError::kNotAFile);
+        }
+
+        return DeleteEntry_(lookup);
+    }
+
+    NODISCARD Result<bool> FileExists(const Path &path)
+    {
+        auto lookup = LookupPath_(path);
+        return lookup.found && lookup.entry.IsFile();
+    }
+
+    NODISCARD Result<size_t> GetFileSize(const Path &path)
+    {
+        auto lookup = LookupPath_(path);
+        if (!lookup.found) {
+            return std::unexpected(VfsError::kFileNotFound);
+        }
+        if (!lookup.entry.IsFile()) {
+            return std::unexpected(VfsError::kNotAFile);
+        }
+        return static_cast<size_t>(lookup.entry.file_size);
+    }
+
+    // ------------------------------
+    // Directory Operations
+    // ------------------------------
+
+    NODISCARD Result<> CreateDirectory(const Path &path)
+    {
+        if (path.IsEmpty() || !path.HasComponents()) {
+            return std::unexpected(VfsError::kInvalidPath);
+        }
+
+        char formatted_name[kMaxNameLength];
+        if (!FormatFilename_(path.GetFilename(), formatted_name)) {
+            return std::unexpected(VfsError::kInvalidName);
+        }
+
+        if (LookupPath_(path).found) {
+            return std::unexpected(VfsError::kAlreadyExists);
+        }
+
+        auto parent_cluster = GetParentCluster_(path);
+        if (!parent_cluster.has_value()) {
+            return std::unexpected(VfsError::kDirectoryNotFound);
+        }
+
+        return CreateDirectoryWithCluster_(parent_cluster.value(), formatted_name);
+    }
+
+    NODISCARD Result<> RemoveDirectory(const Path &path)
+    {
+        auto lookup = LookupPath_(path);
+        if (!lookup.found) {
+            return std::unexpected(VfsError::kDirectoryNotFound);
+        }
+
+        if (!lookup.entry.IsDirectory()) {
+            return std::unexpected(VfsError::kNotADirectory);
+        }
+
+        if (!IsDirectoryEmpty_(lookup.entry)) {
+            return std::unexpected(VfsError::kNotEmpty);
+        }
+
+        return DeleteEntry_(lookup);
+    }
+
+    void ListDirectory(const Path &path, ListDirCallback callback, void *user_ctx)
+    {
+        auto lookup = GetDirectoryLookup_(path);
+        if (!lookup.found || !lookup.entry.IsDirectory()) {
+            return;
+        }
+
+        ScanDirectoryTable_(lookup.entry, [callback, user_ctx](const DirectoryEntry &entry) {
+            if (entry.IsValid() && !entry.IsVolumeLabel()) {
+                char name[13];
+                FormatShortName_(entry.filename, name);
+                callback(user_ctx, name, entry.IsDirectory());
+            }
+        });
+    }
+
+    NODISCARD Result<bool> DirectoryExists(const Path &path)
+    {
+        if (path.IsRoot()) {
+            return true;
+        }
+        auto lookup = LookupPath_(path);
+        return lookup.found && lookup.entry.IsDirectory();
+    }
+
+    NODISCARD Result<bool> Exists(const Path &path)
+    {
+        if (path.IsRoot()) {
+            return true;
+        }
+        return LookupPath_(path).found;
+    }
+
+    // ------------------------------
+    // Move Operation
+    // ------------------------------
+
+    NODISCARD Result<> Move(const Path &old_path, const Path &new_path)
+    {
+        auto old_lookup = LookupPath_(old_path);
+        if (!old_lookup.found) {
+            return std::unexpected(VfsError::kFileNotFound);
+        }
+
+        if (LookupPath_(new_path).found) {
+            return std::unexpected(VfsError::kAlreadyExists);
+        }
+
+        char new_formatted[kMaxNameLength];
+        if (!FormatFilename_(new_path.GetFilename(), new_formatted)) {
+            return std::unexpected(VfsError::kInvalidName);
+        }
+
+        auto new_parent_cluster = GetParentCluster_(new_path);
+        if (!new_parent_cluster.has_value()) {
+            return std::unexpected(VfsError::kDirectoryNotFound);
+        }
+
+        return MoveEntry_(old_lookup, new_formatted, new_parent_cluster.value());
+    }
+
+    // ------------------------------
+    // Protected Cluster Operations
+    // ------------------------------
+
+    NODISCARD FAST_CALL u32 GetFirstCluster_(const DirectoryEntry &entry)
+    {
+        return (static_cast<u32>(entry.first_cluster_high) << 16) | entry.first_cluster_low;
+    }
+
+    NODISCARD FORCE_INLINE_F u32 GetClusterSector_(ClusterNumT cluster) const
+    {
+        return data_region_.start +
+               (cluster - kFirstClusterNumber) * GetBootSector_().sectors_per_cluster;
+    }
+
+    NODISCARD FORCE_INLINE_F ClusterNumT GetFATEntry_(ClusterNumT cluster)
+    {
+        auto boot_sector     = GetBootSector_();
+        size_t fat_offset    = cluster * sizeof(ClusterNumT);
+        size_t sector_number = fat_region_.start + (fat_offset / boot_sector.bytes_per_sector);
+        size_t sector_offset = fat_offset % boot_sector.bytes_per_sector;
+        return internal::get<ClusterNumT>(io_.ReadSector(sector_number), sector_offset) &
+               ImplT::kClusterMask;
+    }
+
+    FORCE_INLINE_F void SetFATEntry_(ClusterNumT cluster, ClusterNumT value)
+    {
+        auto boot_sector     = GetBootSector_();
+        size_t fat_offset    = cluster * sizeof(ClusterNumT);
+        size_t sector_number = fat_region_.start + (fat_offset / boot_sector.bytes_per_sector);
+        size_t sector_offset = fat_offset % boot_sector.bytes_per_sector;
+        auto sector          = io_.ReadSector(sector_number);
+        auto &entry          = internal::get<ClusterNumT>(sector, sector_offset);
+        entry                = (entry & ~ImplT::kClusterMask) | (value & ImplT::kClusterMask);
+        io_.WriteSector(sector_number, sector);
+    }
+
+    NODISCARD FORCE_INLINE_F size_t GetClusterSize_() const
+    {
+        auto &bs = GetBootSector_();
+        return bs.sectors_per_cluster * bs.bytes_per_sector;
+    }
+
+    // ------------------------------
+    // Protected Data Members
+    // ------------------------------
+
+    io::SectorRange fat_region_;
+    io::SectorRange root_dir_region_;
+    io::SectorRange data_region_;
+    size_t cluster_count_{};
+    IO &io_;
+
+    private:
+    // ------------------------------
+    // CRTP Helpers
+    // ------------------------------
+
+    NODISCARD FORCE_INLINE_F ImplT &GetImpl_() { return *static_cast<ImplT *>(this); }
+    NODISCARD FORCE_INLINE_F const ImplT &GetImpl_() const
+    {
+        return *static_cast<const ImplT *>(this);
+    }
+
+    NODISCARD FORCE_INLINE_F const BootSector &GetBootSector_() const
+    {
+        return static_cast<const BootSector &>(GetImpl_().boot_sector_.fat);
+    }
+
+    NODISCARD FORCE_INLINE_F ClusterNumT GetRootCluster_() const
+    {
+        return GetImpl_().GetRootCluster();
+    }
+
+    // ------------------------------
+    // Validation Helpers
+    // ------------------------------
+
+    NODISCARD static FORCE_INLINE_F bool ValidateBootSignature_(std::span<byte> sector_data)
+    {
+        return internal::get<u16>(sector_data, 510) == BootSector::kSignature;
+    }
+
+    NODISCARD static FORCE_INLINE_F bool ValidateJumpInstruction_(const BootSector &bs)
+    {
+        return (bs.jump_instruction[0] == 0xEB && bs.jump_instruction[2] == 0x90) ||
+               bs.jump_instruction[0] == 0xE9;
+    }
+
+    NODISCARD static FORCE_INLINE_F bool ValidateSectorAndClusterSize_(const BootSector &bs)
+    {
+        if (!IsPowerOfTwo(bs.bytes_per_sector) || bs.bytes_per_sector < 512 ||
+            bs.bytes_per_sector > 4096) {
+            return false;
+        }
+        if (!IsPowerOfTwo(bs.sectors_per_cluster) || bs.sectors_per_cluster < 1 ||
+            bs.sectors_per_cluster > 128) {
+            return false;
+        }
+        return bs.bytes_per_sector * bs.sectors_per_cluster <= kMaxClusterSize;
+    }
+
+    NODISCARD static FORCE_INLINE_F bool ValidateReservedSectors_(const BootSector &bs)
+    {
+        return bs.reserved_sectors != 0;
+    }
+
+    NODISCARD static FORCE_INLINE_F bool ValidateFatCount_(const BootSector &bs)
+    {
+        return bs.number_of_fats != 0;
+    }
+
+    NODISCARD static FORCE_INLINE_F bool ValidateMediaDescriptor_(const BootSector &bs)
+    {
+        constexpr u8 kValid[] = {0xF0, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF};
+        for (auto desc : kValid) {
+            if (bs.media_descriptor == desc)
+                return true;
+        }
+        return false;
+    }
+
+    NODISCARD static FORCE_INLINE_F bool ValidateFatMediaDescriptor_(IO &io, const BootSector &bs)
+    {
+        auto fat_region       = io.ReadSector(bs.reserved_sectors);
+        ClusterNumT fat_entry = internal::get<ClusterNumT>(fat_region);
+        return static_cast<u8>(fat_entry & 0xFF) == bs.media_descriptor;
+    }
+
+    // ------------------------------
+    // Cluster Management
+    // ------------------------------
+
+    NODISCARD FORCE_INLINE_F ClusterNumT AllocateCluster_(ClusterNumT value = ImplT::kEOC)
+    {
+        auto &impl = GetImpl_();
+        for (ClusterNumT cluster = kFirstClusterNumber;
+             cluster < cluster_count_ + kFirstClusterNumber; ++cluster) {
+            if (impl.GetFATEntry_(cluster) == 0) {
+                impl.SetFATEntry_(cluster, value);
+                return cluster;
+            }
+        }
+        return 0;
+    }
+
+    FORCE_INLINE_F void FreeClusterChain_(ClusterNumT cluster)
+    {
+        auto &impl = GetImpl_();
+        while (cluster != 0 && cluster < ImplT::kEOC) {
+            ClusterNumT next = impl.GetFATEntry_(cluster);
+            impl.SetFATEntry_(cluster, 0);
+            cluster = next;
+        }
+    }
+
+    NODISCARD FORCE_INLINE_F std::span<const byte> ReadCluster_(ClusterNumT cluster) const
+    {
+        return io_.ReadRange({GetClusterSector_(cluster), GetBootSector_().sectors_per_cluster});
+    }
+
+    FORCE_INLINE_F void WriteCluster_(ClusterNumT cluster, std::span<const byte> data)
+    {
+        io_.WriteRange({GetClusterSector_(cluster), GetBootSector_().sectors_per_cluster}, data);
+    }
+
+    // ------------------------------
+    // Directory Scanning
+    // ------------------------------
+
+    template <typename Callback>
+    FORCE_INLINE_F void ScanDirectoryTable_(
+        const DirectoryEntry &dir_entry, Callback &&callback
+    ) const
+    {
+        ClusterNumT cluster = GetFirstCluster_(dir_entry);
+
+        if constexpr (kHasFixedRootDir) {
+            if (cluster == 0) {
+                ScanFixedRootDirectory_(callback);
+                return;
+            }
+        }
+
+        ScanClusterChainDirectory_(cluster, callback);
+    }
+
+    template <typename Callback>
+    FORCE_INLINE_F void ScanFixedRootDirectory_(Callback &&callback) const
+    {
+        auto root_data     = io_.ReadRange(root_dir_region_);
+        size_t entry_count = root_data.size() / sizeof(DirectoryEntry);
+
+        for (size_t i = 0; i < entry_count; ++i) {
+            const auto &entry =
+                internal::get<DirectoryEntry>(root_data, i * sizeof(DirectoryEntry));
+            if (entry.IsFree())
+                continue;
+            if (entry.IsFurtherEntriesFree())
+                break;
+            callback(entry);
+        }
+    }
+
+    template <typename Callback>
+    FORCE_INLINE_F void ScanClusterChainDirectory_(ClusterNumT cluster, Callback &&callback) const
+    {
+        auto &impl = GetImpl_();
+
+        while (cluster < ImplT::kEOC) {
+            auto cluster_data  = ReadCluster_(cluster);
+            size_t entry_count = cluster_data.size() / sizeof(DirectoryEntry);
+
+            for (size_t i = 0; i < entry_count; ++i) {
+                const auto &entry =
+                    internal::get<DirectoryEntry>(cluster_data, i * sizeof(DirectoryEntry));
+                if (entry.IsFree())
+                    continue;
+                if (entry.IsFurtherEntriesFree())
+                    return;
+                callback(entry);
+            }
+            cluster = impl.GetFATEntry_(cluster);
+        }
+    }
+
+    template <typename Callback>
+    FORCE_INLINE_F void ScanDirectoryTableWithOffset_(
+        const DirectoryEntry &dir_entry, Callback &&callback
+    ) const
+    {
+        ClusterNumT cluster = GetFirstCluster_(dir_entry);
+
+        if constexpr (kHasFixedRootDir) {
+            if (cluster == 0) {
+                ScanFixedRootDirectoryWithOffset_(callback);
+                return;
+            }
+        }
+        ScanClusterChainDirectoryWithOffset_(cluster, callback);
+    }
+
+    template <typename Callback>
+    FORCE_INLINE_F void ScanFixedRootDirectoryWithOffset_(Callback &&callback) const
+    {
+        auto root_data     = io_.ReadRange(root_dir_region_);
+        size_t entry_count = root_data.size() / sizeof(DirectoryEntry);
+        size_t offset      = 0;
+
+        for (size_t i = 0; i < entry_count; ++i, offset += sizeof(DirectoryEntry)) {
+            const auto &entry =
+                internal::get<DirectoryEntry>(root_data, i * sizeof(DirectoryEntry));
+            if (entry.IsFree())
+                continue;
+            if (entry.IsFurtherEntriesFree())
+                break;
+            if (!callback(entry, offset))
+                break;
+        }
+    }
+
+    template <typename Callback>
+    FORCE_INLINE_F void ScanClusterChainDirectoryWithOffset_(
+        ClusterNumT cluster, Callback &&callback
+    ) const
+    {
+        auto &impl           = GetImpl_();
+        size_t global_offset = 0;
+
+        while (cluster < ImplT::kEOC) {
+            auto cluster_data  = ReadCluster_(cluster);
+            size_t entry_count = cluster_data.size() / sizeof(DirectoryEntry);
+
+            for (size_t i = 0; i < entry_count; ++i) {
+                const auto &entry =
+                    internal::get<DirectoryEntry>(cluster_data, i * sizeof(DirectoryEntry));
+
+                if (entry.IsFree()) {
+                    global_offset += sizeof(DirectoryEntry);
+                    continue;
+                }
+                if (entry.IsFurtherEntriesFree())
+                    return;
+                if (!callback(entry, global_offset))
+                    return;
+                global_offset += sizeof(DirectoryEntry);
+            }
+            cluster = impl.GetFATEntry_(cluster);
+        }
+    }
+
+    // ------------------------------
+    // Path Lookup
+    // ------------------------------
+
+    NODISCARD PathLookupResult LookupPath_(const Path &path)
+    {
+        PathLookupResult result{};
+        result.found = false;
+
+        if (path.IsEmpty() || path.IsRoot()) {
+            return result;
+        }
+
+        DirectoryEntry current_entry = MakeRootDirectoryEntry_();
+        ClusterNumT current_cluster  = GetRootCluster_();
+        ClusterNumT parent_cluster   = current_cluster;
+
+        for (size_t i = 0; i < path.ComponentCount(); ++i) {
+            auto component = path.GetComponent(i);
+
+            if (component == ".")
+                continue;
+            if (component == "..")
+                continue;
+
+            auto match = FindEntryInDirectory_(current_entry, component);
+            if (!match.found)
+                return result;
+
+            parent_cluster      = current_cluster;
+            current_entry       = match.entry;
+            current_cluster     = GetFirstCluster_(current_entry);
+            result.entry_offset = match.entry_offset;
+        }
+
+        result.entry          = current_entry;
+        result.parent_cluster = parent_cluster;
+        result.found          = true;
+        return result;
+    }
+
+    NODISCARD FORCE_INLINE_F DirectoryEntry MakeRootDirectoryEntry_() const
+    {
+        DirectoryEntry entry{};
+        ClusterNumT root         = GetRootCluster_();
+        entry.attributes         = DirectoryEntry::Attributes::Directory;
+        entry.first_cluster_low  = root & 0xFFFF;
+        entry.first_cluster_high = (root >> 16) & 0xFFFF;
+        return entry;
+    }
+
+    struct EntryMatch {
+        DirectoryEntry entry;
+        size_t entry_offset;
+        bool found;
+    };
+
+    NODISCARD EntryMatch
+    FindEntryInDirectory_(const DirectoryEntry &dir_entry, std::string_view component)
+    {
+        EntryMatch match{};
+        match.found = false;
+
+        char formatted[kMaxNameLength];
+        char component_buf[kMaxComponentSize];
+        size_t copy_len = std::min(component.size(), kMaxComponentSize - 1);
+        memcpy(component_buf, component.data(), copy_len);
+        component_buf[copy_len] = '\0';
+
+        if (!ToShortFormat_(component_buf, formatted)) {
+            return match;
+        }
+
+        ScanDirectoryTableWithOffset_(dir_entry, [&](const DirectoryEntry &entry, size_t offset) {
+            if (!entry.IsLongNameSubComponent() && !entry.IsFree()) {
+                if (memcmp(entry.filename, formatted, kMaxNameLength) == 0) {
+                    match.entry        = entry;
+                    match.entry_offset = offset;
+                    match.found        = true;
+                    return false;
+                }
+            }
+            return true;
+        });
+
+        return match;
+    }
+
+    NODISCARD PathLookupResult GetDirectoryLookup_(const Path &path)
+    {
+        PathLookupResult lookup;
+        if (path.IsRoot()) {
+            lookup.found = true;
+            lookup.entry = MakeRootDirectoryEntry_();
+        } else {
+            lookup = LookupPath_(path);
+        }
+        return lookup;
+    }
+
+    NODISCARD std::expected<ClusterNumT, VfsError> GetParentCluster_(const Path &path)
+    {
+        auto parent_path = path.GetParent();
+        if (parent_path.IsRoot()) {
+            return GetRootCluster_();
+        }
+        auto parent_lookup = LookupPath_(parent_path);
+        if (!parent_lookup.found) {
+            return std::unexpected(VfsError::kDirectoryNotFound);
+        }
+        return GetFirstCluster_(parent_lookup.entry);
+    }
+
+    // ------------------------------
+    // File Data Operations
+    // ------------------------------
+
+    NODISCARD size_t
+    ReadFileData_(const DirectoryEntry &entry, void *buffer, size_t size, size_t offset)
+    {
+        size_t bytes_to_read     = std::min(size, static_cast<size_t>(entry.file_size - offset));
+        size_t cluster_size      = GetClusterSize_();
+        ClusterNumT cluster      = SkipClusters_(GetFirstCluster_(entry), offset / cluster_size);
+        size_t offset_in_cluster = offset % cluster_size;
+
+        auto *dst         = static_cast<byte *>(buffer);
+        size_t bytes_read = 0;
+
+        while (bytes_read < bytes_to_read && cluster < ImplT::kEOC) {
+            auto cluster_data = ReadCluster_(cluster);
+            size_t copy_size =
+                std::min(cluster_size - offset_in_cluster, bytes_to_read - bytes_read);
+            memcpy(dst + bytes_read, cluster_data.data() + offset_in_cluster, copy_size);
+
+            bytes_read += copy_size;
+            offset_in_cluster = 0;
+            cluster           = GetImpl_().GetFATEntry_(cluster);
+        }
+
+        return bytes_read;
+    }
+
+    NODISCARD Result<size_t> WriteFileData_(
+        PathLookupResult &lookup, const void *buffer, size_t size, size_t offset
+    )
+    {
+        size_t cluster_size = GetClusterSize_();
+        ClusterNumT cluster = GetFirstCluster_(lookup.entry);
+
+        if (cluster == 0) {
+            cluster = AllocateCluster_();
+            if (cluster == 0)
+                return std::unexpected(VfsError::kDiskFull);
+            SetEntryFirstCluster_(lookup.entry, cluster);
+            UpdateDirectoryEntry_(lookup.parent_cluster, lookup.entry_offset, lookup.entry);
+        }
+
+        cluster = EnsureClusterChain_(cluster, offset / cluster_size);
+        if (cluster == 0)
+            return std::unexpected(VfsError::kDiskFull);
+
+        size_t bytes_written = WriteToClusterChain_(cluster, buffer, size, offset % cluster_size);
+
+        size_t new_size =
+            std::max(static_cast<size_t>(lookup.entry.file_size), offset + bytes_written);
+        if (new_size != lookup.entry.file_size) {
+            lookup.entry.file_size = static_cast<u32>(new_size);
+            UpdateDirectoryEntry_(lookup.parent_cluster, lookup.entry_offset, lookup.entry);
+        }
+
+        return bytes_written;
+    }
+
+    NODISCARD FORCE_INLINE_F ClusterNumT SkipClusters_(ClusterNumT cluster, size_t count)
+    {
+        for (size_t i = 0; i < count && cluster < ImplT::kEOC; ++i) {
+            cluster = GetImpl_().GetFATEntry_(cluster);
+        }
+        return cluster;
+    }
+
+    NODISCARD FORCE_INLINE_F ClusterNumT
+    EnsureClusterChain_(ClusterNumT cluster, size_t clusters_needed)
+    {
+        for (size_t i = 0; i < clusters_needed; ++i) {
+            ClusterNumT next = GetImpl_().GetFATEntry_(cluster);
+            if (next >= ImplT::kEOC) {
+                next = AllocateCluster_();
+                if (next == 0)
+                    return 0;
+                GetImpl_().SetFATEntry_(cluster, next);
+            }
+            cluster = next;
+        }
+        return cluster;
+    }
+
+    NODISCARD size_t WriteToClusterChain_(
+        ClusterNumT cluster, const void *buffer, size_t size, size_t offset_in_cluster
+    )
+    {
+        size_t cluster_size  = GetClusterSize_();
+        const auto *src      = static_cast<const byte *>(buffer);
+        size_t bytes_written = 0;
+
+        while (bytes_written < size) {
+            auto cluster_data = ReadCluster_(cluster);
+            byte temp_buffer[kMaxClusterSize];
+            memcpy(temp_buffer, cluster_data.data(), cluster_size);
+
+            size_t copy_size = std::min(cluster_size - offset_in_cluster, size - bytes_written);
+            memcpy(temp_buffer + offset_in_cluster, src + bytes_written, copy_size);
+            WriteCluster_(cluster, std::span<const byte>(temp_buffer, cluster_size));
+
+            bytes_written += copy_size;
+            offset_in_cluster = 0;
+
+            if (bytes_written < size) {
+                ClusterNumT next = GetImpl_().GetFATEntry_(cluster);
+                if (next >= ImplT::kEOC) {
+                    next = AllocateCluster_();
+                    if (next == 0)
+                        break;
+                    GetImpl_().SetFATEntry_(cluster, next);
+                }
+                cluster = next;
+            }
+        }
+
+        return bytes_written;
+    }
+
+    FAST_CALL void SetEntryFirstCluster_(DirectoryEntry &entry, ClusterNumT cluster)
+    {
+        entry.first_cluster_low  = cluster & 0xFFFF;
+        entry.first_cluster_high = (cluster >> 16) & 0xFFFF;
+    }
+
+    // ------------------------------
+    // Directory Entry Management
+    // ------------------------------
+
+    NODISCARD Result<> DeleteEntry_(PathLookupResult &lookup)
+    {
+        FreeClusterChain_(GetFirstCluster_(lookup.entry));
+        reinterpret_cast<byte &>(lookup.entry) = DirectoryEntry::kDeletedEntry;
+        UpdateDirectoryEntry_(lookup.parent_cluster, lookup.entry_offset, lookup.entry);
+        return {};
+    }
+
+    NODISCARD Result<> MoveEntry_(
+        PathLookupResult &old_lookup, const char (&new_name)[kMaxNameLength],
+        ClusterNumT new_parent_cluster
+    )
+    {
+        if (old_lookup.parent_cluster == new_parent_cluster) {
+            memcpy(old_lookup.entry.filename, new_name, kMaxNameLength);
+            UpdateDirectoryEntry_(
+                old_lookup.parent_cluster, old_lookup.entry_offset, old_lookup.entry
+            );
+            return {};
+        }
+
+        auto result = CreateEntry_(
+            new_parent_cluster, new_name, old_lookup.entry.attributes,
+            GetFirstCluster_(old_lookup.entry)
+        );
+        if (!result.has_value()) {
+            return std::unexpected(result.error());
+        }
+
+        old_lookup.entry.filename[0] = DirectoryEntry::kDeletedEntry;
+        UpdateDirectoryEntry_(old_lookup.parent_cluster, old_lookup.entry_offset, old_lookup.entry);
+        return {};
+    }
+
+    NODISCARD Result<> CreateEntry_(
+        ClusterNumT parent_cluster, const char (&name)[kMaxNameLength],
+        DirectoryEntry::Attributes attributes, ClusterNumT first_cluster
+    )
+    {
+        if constexpr (kHasFixedRootDir) {
+            if (parent_cluster == 0) {
+                return CreateEntryInFixedRootDir_(name, attributes, first_cluster);
+            }
+        }
+        return CreateEntryInClusterDir_(parent_cluster, name, attributes, first_cluster);
+    }
+
+    NODISCARD Result<> CreateEntryInFixedRootDir_(
+        const char (&name)[kMaxNameLength], DirectoryEntry::Attributes attributes,
+        ClusterNumT first_cluster
+    )
+    {
+        auto root_data     = io_.ReadRange(root_dir_region_);
+        size_t root_size   = root_dir_region_.count * GetBootSector_().bytes_per_sector;
+        size_t entry_count = root_size / sizeof(DirectoryEntry);
+
+        for (size_t i = 0; i < entry_count; ++i) {
+            const auto &entry =
+                internal::get<DirectoryEntry>(root_data, i * sizeof(DirectoryEntry));
+
+            if (entry.IsFree() || entry.IsFurtherEntriesFree()) {
+                byte temp_buffer[kMaxClusterSize];
+                memcpy(temp_buffer, root_data.data(), root_size);
+                WriteNewEntry_(
+                    temp_buffer, i, name, attributes, first_cluster, entry.IsFurtherEntriesFree(),
+                    i + 1 < entry_count
+                );
+                io_.WriteRange(root_dir_region_, std::span<const byte>(temp_buffer, root_size));
+                return {};
+            }
+        }
+        return std::unexpected(VfsError::kDiskFull);
+    }
+
+    NODISCARD Result<> CreateEntryInClusterDir_(
+        ClusterNumT parent_cluster, const char (&name)[kMaxNameLength],
+        DirectoryEntry::Attributes attributes, ClusterNumT first_cluster
+    )
+    {
+        size_t cluster_size = GetClusterSize_();
+        auto &impl          = GetImpl_();
+        ClusterNumT cluster = parent_cluster;
+
+        while (cluster < ImplT::kEOC) {
+            auto cluster_data  = ReadCluster_(cluster);
+            size_t entry_count = cluster_data.size() / sizeof(DirectoryEntry);
+
+            for (size_t i = 0; i < entry_count; ++i) {
+                const auto &entry =
+                    internal::get<DirectoryEntry>(cluster_data, i * sizeof(DirectoryEntry));
+
+                if (entry.IsFree() || entry.IsFurtherEntriesFree()) {
+                    byte temp_buffer[kMaxClusterSize];
+                    memcpy(temp_buffer, cluster_data.data(), cluster_size);
+                    WriteNewEntry_(
+                        temp_buffer, i, name, attributes, first_cluster,
+                        entry.IsFurtherEntriesFree(), i + 1 < entry_count
+                    );
+                    WriteCluster_(cluster, std::span<const byte>(temp_buffer, cluster_size));
+                    return {};
+                }
+            }
+
+            ClusterNumT next = impl.GetFATEntry_(cluster);
+            if (next >= ImplT::kEOC) {
+                next = AllocateCluster_();
+                if (next == 0)
+                    return std::unexpected(VfsError::kDiskFull);
+                impl.SetFATEntry_(cluster, next);
+                InitializeEmptyCluster_(next);
+            }
+            cluster = next;
+        }
+
+        return std::unexpected(VfsError::kDiskFull);
+    }
+
+    FORCE_INLINE_F void WriteNewEntry_(
+        byte *buffer, size_t index, const char (&name)[kMaxNameLength],
+        DirectoryEntry::Attributes attributes, ClusterNumT first_cluster, bool was_eod,
+        bool has_next_slot
+    )
+    {
+        auto *new_entry =
+            reinterpret_cast<DirectoryEntry *>(buffer + index * sizeof(DirectoryEntry));
+        memcpy(new_entry->filename, name, kMaxNameLength);
+        new_entry->attributes          = attributes;
+        new_entry->creation_time_tenth = 0;
+        new_entry->creation_time       = 0;
+        new_entry->creation_date       = 0;
+        new_entry->last_access_date    = 0;
+        new_entry->first_cluster_high  = (first_cluster >> 16) & 0xFFFF;
+        new_entry->last_write_time     = 0;
+        new_entry->last_write_date     = 0;
+        new_entry->first_cluster_low   = first_cluster & 0xFFFF;
+        new_entry->file_size           = 0;
+
+        if (was_eod && has_next_slot) {
+            *(buffer + (index + 1) * sizeof(DirectoryEntry)) = DirectoryEntry::kEOD;
+        }
+    }
+
+    FORCE_INLINE_F void InitializeEmptyCluster_(ClusterNumT cluster)
+    {
+        size_t cluster_size = GetClusterSize_();
+        byte data[kMaxClusterSize];
+        memset(data, 0, cluster_size);
+        data[0] = DirectoryEntry::kEOD;
+        WriteCluster_(cluster, std::span<const byte>(data, cluster_size));
+    }
+
+    void UpdateDirectoryEntry_(
+        ClusterNumT parent_cluster, size_t offset, const DirectoryEntry &entry
+    )
+    {
+        if constexpr (kHasFixedRootDir) {
+            if (parent_cluster == 0) {
+                UpdateEntryInFixedRootDir_(offset, entry);
+                return;
+            }
+        }
+        UpdateEntryInClusterDir_(parent_cluster, offset, entry);
+    }
+
+    FORCE_INLINE_F void UpdateEntryInFixedRootDir_(size_t offset, const DirectoryEntry &entry)
+    {
+        size_t root_size = root_dir_region_.count * GetBootSector_().bytes_per_sector;
+        if (offset >= root_size)
+            return;
+
+        auto root_data = io_.ReadRange(root_dir_region_);
+        byte temp_buffer[kMaxClusterSize];
+        memcpy(temp_buffer, root_data.data(), root_size);
+        memcpy(temp_buffer + offset, &entry, sizeof(DirectoryEntry));
+        io_.WriteRange(root_dir_region_, std::span<const byte>(temp_buffer, root_size));
+    }
+
+    FORCE_INLINE_F void UpdateEntryInClusterDir_(
+        ClusterNumT parent_cluster, size_t offset, const DirectoryEntry &entry
+    )
+    {
+        size_t cluster_size = GetClusterSize_();
+        auto &impl          = GetImpl_();
+        ClusterNumT cluster = parent_cluster;
+
+        while (offset >= cluster_size && cluster < ImplT::kEOC) {
+            offset -= cluster_size;
+            cluster = impl.GetFATEntry_(cluster);
+        }
+
+        if (cluster >= ImplT::kEOC)
+            return;
+
+        auto cluster_data = ReadCluster_(cluster);
+        byte temp_buffer[kMaxClusterSize];
+        memcpy(temp_buffer, cluster_data.data(), cluster_size);
+        memcpy(temp_buffer + offset, &entry, sizeof(DirectoryEntry));
+        WriteCluster_(cluster, std::span<const byte>(temp_buffer, cluster_size));
+    }
+
+    // ------------------------------
+    // Directory Creation Helpers
+    // ------------------------------
+
+    NODISCARD Result<> CreateDirectoryWithCluster_(
+        ClusterNumT parent_cluster, const char (&name)[kMaxNameLength]
+    )
+    {
+        ClusterNumT new_cluster = AllocateCluster_();
+        if (new_cluster == 0) {
+            return std::unexpected(VfsError::kDiskFull);
+        }
+
+        InitializeNewDirectory_(new_cluster, parent_cluster);
+        return CreateEntry_(
+            parent_cluster, name, DirectoryEntry::Attributes::Directory, new_cluster
+        );
+    }
+
+    FORCE_INLINE_F void InitializeNewDirectory_(ClusterNumT new_cluster, ClusterNumT parent_cluster)
+    {
+        size_t cluster_size = GetClusterSize_();
+        byte dir_data[kMaxClusterSize];
+        memset(dir_data, 0, cluster_size);
+
+        auto *dot_entry = reinterpret_cast<DirectoryEntry *>(dir_data);
+        memcpy(dot_entry->filename, kDot, kMaxNameLength);
+        dot_entry->attributes         = DirectoryEntry::Attributes::Directory;
+        dot_entry->first_cluster_low  = new_cluster & 0xFFFF;
+        dot_entry->first_cluster_high = (new_cluster >> 16) & 0xFFFF;
+
+        auto *dotdot_entry = reinterpret_cast<DirectoryEntry *>(dir_data + sizeof(DirectoryEntry));
+        memcpy(dotdot_entry->filename, kDotDot, kMaxNameLength);
+        dotdot_entry->attributes         = DirectoryEntry::Attributes::Directory;
+        dotdot_entry->first_cluster_low  = parent_cluster & 0xFFFF;
+        dotdot_entry->first_cluster_high = (parent_cluster >> 16) & 0xFFFF;
+
+        WriteCluster_(new_cluster, std::span<const byte>(dir_data, cluster_size));
+    }
+
+    NODISCARD FORCE_INLINE_F bool IsDirectoryEmpty_(const DirectoryEntry &entry) const
+    {
+        bool is_empty = true;
+        ScanDirectoryTable_(entry, [&is_empty](const DirectoryEntry &e) {
+            if (!e.IsFree() && !e.IsLongNameSubComponent() && !e.IsVolumeLabel()) {
+                if (memcmp(e.filename, kDot, kMaxNameLength) != 0 &&
+                    memcmp(e.filename, kDotDot, kMaxNameLength) != 0) {
+                    is_empty = false;
+                }
+            }
+        });
+        return is_empty;
+    }
+
+    // ------------------------------
+    // Name Formatting
+    // ------------------------------
+
+    NODISCARD FAST_CALL bool FormatFilename_(
+        std::string_view filename, char (&formatted)[kMaxNameLength]
+    )
+    {
+        char buf[kMaxComponentSize];
+        size_t len = std::min(filename.size(), kMaxComponentSize - 1);
+        memcpy(buf, filename.data(), len);
+        buf[len] = '\0';
+        return ToShortFormat_(buf, formatted);
+    }
+
+    NODISCARD FAST_CALL bool ToShortFormat_(const char *filename, char (&formatted)[kMaxNameLength])
+    {
+        if (!filename)
+            return false;
+
+        const size_t len = strlen(filename);
+        if (len > kMaxNameLength + 1)
+            return false;
+
+        const char *dot_pos   = strrchr(filename, '.');
+        const size_t name_len = dot_pos ? static_cast<size_t>(dot_pos - filename) : len;
+        const size_t ext_len  = dot_pos ? (len - name_len - 1) : 0;
+
+        if (ext_len > 3 || name_len == 0 || name_len > 8)
+            return false;
+
+        memset(formatted, ' ', kMaxNameLength);
+
+        if (!CopyAndValidateChars_(filename, formatted, name_len, 0))
+            return false;
+        if (dot_pos && !CopyAndValidateChars_(dot_pos + 1, formatted, ext_len, 8))
+            return false;
+
+        return true;
+    }
+
+    NODISCARD FAST_CALL bool CopyAndValidateChars_(
+        const char *src, char *dst, size_t len, size_t dst_offset
+    )
+    {
+        constexpr u8 kInvalidChars[] = {0x22, 0x2A, 0x2B, 0x2C, 0x2E, 0x2F, 0x3A, 0x3B,
+                                        0x3C, 0x3D, 0x3E, 0x3F, 0x5B, 0x5C, 0x5D, 0x7C};
+
+        for (size_t i = 0; i < len; ++i) {
+            char c = src[i];
+            if (c < 0x20 && c != 0x05)
+                return false;
+
+            for (auto invalid : kInvalidChars) {
+                if (static_cast<u8>(c) == invalid)
+                    return false;
+            }
+
+            dst[dst_offset + i] =
+                (c == 0x05) ? static_cast<char>(toupper(0xE5)) : static_cast<char>(toupper(c));
+        }
+        return true;
+    }
+
+    FAST_CALL void FormatShortName_(const char (&short_name)[11], char *output)
+    {
+        size_t out_idx = 0;
+
+        for (size_t i = 0; i < 8 && short_name[i] != ' '; ++i) {
+            output[out_idx++] = short_name[i];
+        }
+
+        if (short_name[8] != ' ') {
+            output[out_idx++] = '.';
+            for (size_t i = 8; i < 11 && short_name[i] != ' '; ++i) {
+                output[out_idx++] = short_name[i];
+            }
+        }
+
+        output[out_idx] = '\0';
+    }
+
+    // ------------------------------
+    // Static Callback Wrappers
+    // ------------------------------
+
+    FAST_CALL Result<> CreateFileCallback_(void *ctx, const Path &path)
+    {
+        return static_cast<Fat *>(ctx)->CreateFile(path);
+    }
+
+    WRAP_CALL Result<size_t> ReadFileCallback_(
+        void *ctx, const Path &path, void *buffer, size_t size, size_t offset
+    )
+    {
+        return static_cast<Fat *>(ctx)->ReadFile(path, buffer, size, offset);
+    }
+
+    WRAP_CALL Result<size_t> WriteFileCallback_(
+        void *ctx, const Path &path, const void *buffer, size_t size, size_t offset
+    )
+    {
+        return static_cast<Fat *>(ctx)->WriteFile(path, buffer, size, offset);
+    }
+
+    WRAP_CALL Result<> DeleteFileCallback_(void *ctx, const Path &path)
+    {
+        return static_cast<Fat *>(ctx)->DeleteFile(path);
+    }
+
+    WRAP_CALL Result<bool> FileExistsCallback_(void *ctx, const Path &path)
+    {
+        return static_cast<Fat *>(ctx)->FileExists(path);
+    }
+
+    WRAP_CALL Result<size_t> GetFileSizeCallback_(void *ctx, const Path &path)
+    {
+        return static_cast<Fat *>(ctx)->GetFileSize(path);
+    }
+
+    WRAP_CALL Result<> CreateDirectoryCallback_(void *ctx, const Path &path)
+    {
+        return static_cast<Fat *>(ctx)->CreateDirectory(path);
+    }
+
+    WRAP_CALL Result<> RemoveDirectoryCallback_(void *ctx, const Path &path)
+    {
+        return static_cast<Fat *>(ctx)->RemoveDirectory(path);
+    }
+
+    WRAP_CALL void ListDirectoryCallback_(
+        void *ctx, const Path &path, ListDirCallback callback, void *user_ctx
+    )
+    {
+        static_cast<Fat *>(ctx)->ListDirectory(path, callback, user_ctx);
+    }
+
+    WRAP_CALL Result<bool> DirectoryExistsCallback_(void *ctx, const Path &path)
+    {
+        return static_cast<Fat *>(ctx)->DirectoryExists(path);
+    }
+
+    WRAP_CALL Result<bool> ExistsCallback_(void *ctx, const Path &path)
+    {
+        return static_cast<Fat *>(ctx)->Exists(path);
+    }
+
+    WRAP_CALL Result<> MoveCallback_(void *ctx, const Path &old_path, const Path &new_path)
+    {
+        return static_cast<Fat *>(ctx)->Move(old_path, new_path);
+    }
+};
+
+}  // namespace vfs
+
+#endif  // KERNEL_SRC_VFS_FAT_FAT_HPP_
diff --git a/kernel/src/vfs/fat/fat12.hpp b/kernel/src/vfs/fat/fat12.hpp
new file mode 100644
index 00000000..eff314c9
--- /dev/null
+++ b/kernel/src/vfs/fat/fat12.hpp
@@ -0,0 +1,181 @@
+#ifndef KERNEL_SRC_VFS_FAT_FAT12_HPP_
+#define KERNEL_SRC_VFS_FAT_FAT12_HPP_
+
+#include <bit.hpp>
+#include <internal/math.hpp>
+#include <internal/span.hpp>
+#include <vfs/fat/fat.hpp>
+#include <vfs/interface.hpp>
+
+namespace vfs
+{
+
+/* FAT12 filesystem implementation of the VFS interface
+ * https://www.cs.fsu.edu/~cop4610t/assignments/project3/spec/fatspec.pdf
+ */
+template <VFSIO IO>
+class Fat12 : public Fat<Fat12, IO>
+{
+    using BaseT = Fat<Fat12, IO>;
+
+    public:
+    using ClusterNumT = typename BaseT::ClusterNumT;
+
+    // Filesystem identification
+    static constexpr Type kFsType        = Type::kFat12;
+    static constexpr const char *kFsName = "FAT12";
+
+    // ------------------------------
+    // Class creation
+    // ------------------------------
+
+    Fat12() = delete;
+
+    explicit Fat12(IO &io)
+        : BaseT(io), boot_sector_(internal::get<const BootSector>(io.ReadSector(0)))
+    {
+        BaseT::io_.SetSectorSize(boot_sector_.fat.bytes_per_sector);
+
+        const u32 fat_region_start_sector = boot_sector_.fat.reserved_sectors;
+        const u32 fat_region_sectors =
+            boot_sector_.fat.number_of_fats * boot_sector_.fat.fat_size_word;
+        BaseT::fat_region_ = {fat_region_start_sector, fat_region_sectors};
+
+        const u32 root_dir_start   = fat_region_start_sector + fat_region_sectors;
+        const u32 root_dir_sectors = internal::DivRoundUp(
+            boot_sector_.fat.root_dir_entries * sizeof(typename BaseT::DirectoryEntry),
+            boot_sector_.fat.bytes_per_sector
+        );
+        BaseT::root_dir_region_ = {root_dir_start, root_dir_sectors};
+
+        const u32 data_start_sector =
+            boot_sector_.fat.reserved_sectors + fat_region_sectors + root_dir_sectors;
+        const u32 data_sectors =
+            ((boot_sector_.fat.total_sectors_word != 0) ? boot_sector_.fat.total_sectors_word
+                                                        : boot_sector_.fat.total_sectors_dword) -
+            data_start_sector;
+        BaseT::data_region_ = {data_start_sector, data_sectors};
+
+        BaseT::cluster_count_ = data_sectors / boot_sector_.fat.sectors_per_cluster;
+    }
+
+    ~Fat12() = default;
+
+    friend class Fat<Fat12, IO>;
+
+    Filesystem GetFilesystem() { return BaseT::GetFilesystem(); }
+
+    static bool IsValid(IO &io)
+    {
+        if (!BaseT::IsValid(io)) {
+            return false;
+        }
+
+        auto boot_sector = internal::get<const BootSector>(io.ReadSector(0));
+
+        const u32 fat_region_sectors =
+            boot_sector.fat.number_of_fats * boot_sector.fat.fat_size_word;
+        const u32 root_dir_sectors = internal::DivRoundUp(
+            boot_sector.fat.root_dir_entries * sizeof(typename BaseT::DirectoryEntry),
+            boot_sector.fat.bytes_per_sector
+        );
+        const u32 data_start_sector =
+            boot_sector.fat.reserved_sectors + fat_region_sectors + root_dir_sectors;
+        const u32 data_sectors =
+            ((boot_sector.fat.total_sectors_word != 0) ? boot_sector.fat.total_sectors_word
+                                                       : boot_sector.fat.total_sectors_dword) -
+            data_start_sector;
+        const u32 cluster_count = data_sectors / boot_sector.fat.sectors_per_cluster;
+
+        constexpr u16 kMaxClusterCount = 4085;
+        return cluster_count < kMaxClusterCount;
+    }
+
+    private:
+    struct BootSector {
+        typename BaseT::BootSector fat;  // Inherit common fields from Fat
+
+        // FAT12 specific fields
+        u8 drive_number;
+        RESERVED(1);
+        u8 boot_signature;
+        u32 volume_id;
+        char volume_label[11];  // Padded with spaces
+        char filesystem_type[8];
+    } PACK;
+    static_assert(sizeof(BootSector) == 62, "BootSector size mismatch");
+
+    // FAT12 root directory is at a fixed location, not in a cluster
+    ClusterNumT GetRootCluster() const
+    {
+        // For FAT12, root directory starts at sector after FAT region
+        // We return 0 to indicate fixed root directory
+        return 0;
+    }
+
+    NODISCARD FORCE_INLINE_F ClusterNumT GetFATEntry_(ClusterNumT cluster) const
+    {
+        ASSERT_LT(
+            cluster, BaseT::cluster_count_ + BaseT::kFirstClusterNumber,
+            "Cluster number out of range"
+        );
+        const size_t fat_offset = cluster + (cluster / 2);
+        const size_t sector_number =
+            BaseT::fat_region_.start + (fat_offset / boot_sector_.fat.bytes_per_sector);
+        const size_t sector_offset = fat_offset % boot_sector_.fat.bytes_per_sector;
+
+        // Load 2 sectors if entry spans two sectors
+        size_t count =
+            (sector_offset == static_cast<size_t>(boot_sector_.fat.bytes_per_sector - 1)) ? 2 : 1;
+        auto range = BaseT::io_.ReadRange({sector_number, count});
+        if ((cluster % 2) == 0) {  // Even cluster
+            return internal::get<ClusterNumT>(range, sector_offset) & kClusterMask;
+        } else {
+            return internal::get<ClusterNumT>(range, sector_offset) >> 4;
+        }
+    }
+
+    FORCE_INLINE_F void SetFATEntry_(ClusterNumT cluster, ClusterNumT value)
+    {
+        ASSERT_LT(
+            cluster, BaseT::cluster_count_ + BaseT::kFirstClusterNumber,
+            "Cluster number out of range"
+        );
+
+        // FAT12 uses 12-bit entries, packed as: entry_n at offset (n * 3 / 2)
+        // Even clusters: low 12 bits, Odd clusters: high 12 bits (shifted by 4)
+        const size_t fat_offset = cluster + (cluster / 2);
+        const size_t sector_number =
+            BaseT::fat_region_.start + (fat_offset / boot_sector_.fat.bytes_per_sector);
+        const size_t sector_offset = fat_offset % boot_sector_.fat.bytes_per_sector;
+
+        // Load 2 sectors if entry spans two sectors
+        size_t count =
+            (sector_offset == static_cast<size_t>(boot_sector_.fat.bytes_per_sector - 1)) ? 2 : 1;
+        auto range = BaseT::io_.ReadRange({sector_number, count});
+
+        u16 &fat_entry = internal::get<u16>(range, sector_offset);
+        if ((cluster % 2) == 0) {  // Even cluster: set low 12 bits
+            fat_entry = (fat_entry & 0xF000) | (value & 0x0FFF);
+        } else {  // Odd cluster: set high 12 bits
+            fat_entry = (fat_entry & 0x000F) | ((value & 0x0FFF) << 4);
+        }
+
+        BaseT::io_.WriteRange({sector_number, count}, range);
+    }
+
+    static constexpr ClusterNumT kEOC         = 0x0FF8;  // End of cluster chain marker for FAT12
+    static constexpr ClusterNumT kClusterMask = kBitMaskRight<ClusterNumT, 12>;
+
+    const BootSector boot_sector_{};
+};
+
+template <typename IO>
+struct FatTraits<Fat12, IO> {
+    using ClusterNumT                      = u16;
+    static constexpr bool kHasFixedRootDir = true;
+};
+
+}  // namespace vfs
+
+#endif  // KERNEL_SRC_VFS_FAT_FAT12_HPP_
diff --git a/kernel/src/vfs/fat/fat16.hpp b/kernel/src/vfs/fat/fat16.hpp
new file mode 100644
index 00000000..efe4a235
--- /dev/null
+++ b/kernel/src/vfs/fat/fat16.hpp
@@ -0,0 +1,135 @@
+#ifndef KERNEL_SRC_VFS_FAT_FAT16_HPP_
+#define KERNEL_SRC_VFS_FAT_FAT16_HPP_
+
+#include <bit.hpp>
+#include <internal/math.hpp>
+#include <internal/span.hpp>
+#include <vfs/fat/fat.hpp>
+#include <vfs/interface.hpp>
+
+namespace vfs
+{
+
+/* FAT16 filesystem implementation of the VFS interface
+ * https://www.cs.fsu.edu/~cop4610t/assignments/project3/spec/fatspec.pdf
+ */
+template <VFSIO IO>
+class Fat16 : public Fat<Fat16, IO>
+{
+    using BaseT = Fat<Fat16, IO>;
+
+    public:
+    using ClusterNumT = typename BaseT::ClusterNumT;
+
+    // Filesystem identification
+    static constexpr Type kFsType        = Type::kFat16;
+    static constexpr const char *kFsName = "FAT16";
+
+    // ------------------------------
+    // Class creation
+    // ------------------------------
+
+    Fat16() = delete;
+
+    explicit Fat16(IO &io)
+        : BaseT(io), boot_sector_(internal::get<const BootSector>(io.ReadSector(0)))
+    {
+        BaseT::io_.SetSectorSize(boot_sector_.fat.bytes_per_sector);
+
+        const u32 fat_region_start_sector = boot_sector_.fat.reserved_sectors;
+        const u32 fat_region_sectors =
+            boot_sector_.fat.number_of_fats * boot_sector_.fat.fat_size_word;
+        BaseT::fat_region_ = {fat_region_start_sector, fat_region_sectors};
+
+        const u32 root_dir_start   = fat_region_start_sector + fat_region_sectors;
+        const u32 root_dir_sectors = internal::DivRoundUp(
+            boot_sector_.fat.root_dir_entries * sizeof(typename BaseT::DirectoryEntry),
+            boot_sector_.fat.bytes_per_sector
+        );
+        BaseT::root_dir_region_ = {root_dir_start, root_dir_sectors};
+
+        const u32 data_start_sector =
+            boot_sector_.fat.reserved_sectors + fat_region_sectors + root_dir_sectors;
+        const u32 data_sectors =
+            ((boot_sector_.fat.total_sectors_word != 0) ? boot_sector_.fat.total_sectors_word
+                                                        : boot_sector_.fat.total_sectors_dword) -
+            data_start_sector;
+        BaseT::data_region_ = {data_start_sector, data_sectors};
+
+        BaseT::cluster_count_ = data_sectors / boot_sector_.fat.sectors_per_cluster;
+    }
+
+    ~Fat16() = default;
+
+    friend class Fat<Fat16, IO>;
+
+    Filesystem GetFilesystem() { return BaseT::GetFilesystem(); }
+
+    static bool IsValid(IO &io)
+    {
+        if (!BaseT::IsValid(io)) {
+            return false;
+        }
+
+        auto boot_sector = internal::get<const BootSector>(io.ReadSector(0));
+
+        const u32 fat_region_sectors =
+            boot_sector.fat.number_of_fats * boot_sector.fat.fat_size_word;
+        const u32 root_dir_sectors = internal::DivRoundUp(
+            boot_sector.fat.root_dir_entries * sizeof(typename BaseT::DirectoryEntry),
+            boot_sector.fat.bytes_per_sector
+        );
+        const u32 data_start_sector =
+            boot_sector.fat.reserved_sectors + fat_region_sectors + root_dir_sectors;
+        const u32 data_sectors =
+            ((boot_sector.fat.total_sectors_word != 0) ? boot_sector.fat.total_sectors_word
+                                                       : boot_sector.fat.total_sectors_dword) -
+            data_start_sector;
+        const u32 cluster_count = data_sectors / boot_sector.fat.sectors_per_cluster;
+
+        constexpr u16 kMinClusterCount = 4085;
+        constexpr u16 kMaxClusterCount = 65525;
+        return cluster_count >= kMinClusterCount && cluster_count < kMaxClusterCount;
+    }
+
+    private:
+    struct BootSector {
+        typename BaseT::BootSector fat;  // Inherit common fields from Fat
+
+        // FAT16 specific fields
+        u8 drive_number;
+        RESERVED(1);
+        u8 boot_signature;
+        u32 volume_id;
+        char volume_label[11];  // Padded with spaces
+        char filesystem_type[8];
+    } PACK;
+    static_assert(sizeof(BootSector) == 62, "BootSector size mismatch");
+
+    // FAT16 root directory is at a fixed location, not in a cluster
+    ClusterNumT GetRootCluster() const
+    {
+        // For FAT16, root directory starts at sector after FAT region
+        // We return 0 to indicate fixed root directory
+        return 0;
+    }
+
+    static constexpr u16 kEOC                 = 0xFFF8;  // End of cluster chain marker for FAT16
+    static constexpr ClusterNumT kClusterMask = kFullMask<ClusterNumT>;
+    static constexpr ClusterNumT kCleanShutdownMarker =
+        kSingleBit<ClusterNumT, sizeof(ClusterNumT) * 8 - 1>;
+    static constexpr ClusterNumT kHardwareErrorMarker =
+        kSingleBit<ClusterNumT, sizeof(ClusterNumT) * 8 - 2>;
+
+    const BootSector boot_sector_{};
+};
+
+template <typename IO>
+struct FatTraits<Fat16, IO> {
+    using ClusterNumT                      = u16;
+    static constexpr bool kHasFixedRootDir = true;
+};
+
+}  // namespace vfs
+
+#endif  // KERNEL_SRC_VFS_FAT_FAT16_HPP_
diff --git a/kernel/src/vfs/fat/fat32.hpp b/kernel/src/vfs/fat/fat32.hpp
new file mode 100644
index 00000000..3043a649
--- /dev/null
+++ b/kernel/src/vfs/fat/fat32.hpp
@@ -0,0 +1,162 @@
+#ifndef KERNEL_SRC_VFS_FAT_FAT32_HPP_
+#define KERNEL_SRC_VFS_FAT_FAT32_HPP_
+
+#include <bit.hpp>
+#include <internal/math.hpp>
+#include <internal/span.hpp>
+#include <span.hpp>
+#include <vfs/fat/fat.hpp>
+#include <vfs/interface.hpp>
+#include <vfs/io/in_memory.hpp>
+
+namespace vfs
+{
+
+/* FAT32 filesystem implementation of the VFS interface
+ * https://www.cs.fsu.edu/~cop4610t/assignments/project3/spec/fatspec.pdf
+ */
+template <VFSIO IO>
+class Fat32 : public Fat<Fat32, IO>
+{
+    using BaseT = Fat<Fat32, IO>;
+
+    public:
+    using ClusterNumT = typename BaseT::ClusterNumT;
+
+    // Filesystem identification
+    static constexpr Type kFsType        = Type::kFat32;
+    static constexpr const char *kFsName = "FAT32";
+
+    // ------------------------------
+    // Class creation
+    // ------------------------------
+
+    Fat32() = delete;
+
+    explicit Fat32(IO &io)
+        : BaseT(io), boot_sector_(internal::get<const BootSector>(io.ReadSector(0)))
+    {
+        BaseT::io_.SetSectorSize(boot_sector_.fat.bytes_per_sector);
+
+        const u32 fat_region_start_sector = boot_sector_.fat.reserved_sectors;
+        const u32 fat_region_sectors =
+            boot_sector_.fat.number_of_fats * ((boot_sector_.fat.fat_size_word != 0)
+                                                   ? boot_sector_.fat.fat_size_word
+                                                   : boot_sector_.fat_size_dword);
+        BaseT::fat_region_ = {fat_region_start_sector, fat_region_sectors};
+
+        const u32 root_dir_start   = fat_region_start_sector + fat_region_sectors;
+        const u32 root_dir_sectors = internal::DivRoundUp(
+            boot_sector_.fat.root_dir_entries * sizeof(typename BaseT::DirectoryEntry),
+            boot_sector_.fat.bytes_per_sector
+        );
+        BaseT::root_dir_region_ = {root_dir_start, root_dir_sectors};
+
+        const u32 data_start_sector =
+            boot_sector_.fat.reserved_sectors + fat_region_sectors + root_dir_sectors;
+        const u32 data_sectors =
+            ((boot_sector_.fat.total_sectors_word != 0) ? boot_sector_.fat.total_sectors_word
+                                                        : boot_sector_.fat.total_sectors_dword) -
+            data_start_sector;
+        BaseT::data_region_ = {data_start_sector, data_sectors};
+
+        BaseT::cluster_count_ = data_sectors / boot_sector_.fat.sectors_per_cluster;
+    }
+
+    ~Fat32() = default;
+
+    friend class Fat<Fat32, IO>;
+
+    Filesystem GetFilesystem() { return BaseT::GetFilesystem(); }
+
+    static bool IsValid(IO &io)
+    {
+        if (!BaseT::IsValid(io)) {
+            return false;
+        }
+
+        auto boot_sector = internal::get<const BootSector>(io.ReadSector(0));
+
+        if (boot_sector.fat.fat_size_word != 0 || boot_sector.fat.total_sectors_word != 0) {
+            return false;
+        }
+
+        const u32 fat_region_sectors = boot_sector.fat.number_of_fats * boot_sector.fat_size_dword;
+        const u32 root_dir_sectors   = internal::DivRoundUp(
+            boot_sector.fat.root_dir_entries * sizeof(typename BaseT::DirectoryEntry),
+            boot_sector.fat.bytes_per_sector
+        );
+        const u32 data_start_sector =
+            boot_sector.fat.reserved_sectors + fat_region_sectors + root_dir_sectors;
+        const u32 data_sectors  = boot_sector.fat.total_sectors_dword - data_start_sector;
+        const u32 cluster_count = data_sectors / boot_sector.fat.sectors_per_cluster;
+
+        constexpr u16 kMinClusterCount = 65525;
+        return cluster_count >= kMinClusterCount;
+    }
+
+    private:
+    struct BootSector {
+        typename BaseT::BootSector fat;  // Inherit common fields from Fat
+
+        // FAT32 specific fields
+        u32 fat_size_dword;
+        u16 extended_flags;
+        u16 filesystem_version;
+        u32 root_cluster;
+        u16 filesystem_info_sector;
+        u16 backup_boot_sector;
+        RESERVED(12);
+        u8 drive_number;
+        RESERVED(1);
+        u8 boot_signature;
+        u32 volume_id;
+        char volume_label[11];  // Padded with spaces
+        char filesystem_type[8];
+    } PACK;
+    static_assert(sizeof(BootSector) == 90, "BootSector size mismatch");
+
+    struct FSInfo {
+        u32 lead_signature;  // 0x41615252
+        RESERVED(480);
+        u32 structure_signature;  // 0x61417272
+        u32 free_cluster_count;
+        u32 next_free_cluster;  // if 0xFFFFFFFF start searching from cluster 2
+        RESERVED(12);
+        u32 trail_signature;  // 0xAA550000
+    };
+    static_assert(sizeof(FSInfo) == 512, "FSInfo size mismatch");
+
+    ClusterNumT GetRootCluster() const { return boot_sector_.root_cluster; }
+
+    // FAT32 specific constants
+    static constexpr u32 kFSInfoLeadSig      = 0x41615252;
+    static constexpr u32 kFSInfoStructureSig = 0x61417272;
+    static constexpr u32 kFSInfoTrailSig     = 0xAA550000;
+
+    // FAT32 specific cluster markers
+    static constexpr ClusterNumT kEOC =
+        kBitMask<ClusterNumT, 3, 25>;  // End of cluster marker for FAT32
+    static constexpr ClusterNumT kClusterMask = kBitMaskRight<ClusterNumT, 28>;
+    static constexpr ClusterNumT kCleanShutdownMarker =
+        kSingleBit<ClusterNumT, sizeof(ClusterNumT) * 8 - 5>;
+    static constexpr ClusterNumT kHardwareErrorMarker =
+        kSingleBit<ClusterNumT, sizeof(ClusterNumT) * 8 - 6>;
+
+    // ------------------------------
+    // Data Members
+    // ------------------------------
+
+    const BootSector boot_sector_;
+    const FSInfo fs_info_;
+};
+
+template <typename IO>
+struct FatTraits<Fat32, IO> {
+    using ClusterNumT                      = u32;
+    static constexpr bool kHasFixedRootDir = false;
+};
+
+}  // namespace vfs
+
+#endif  // KERNEL_SRC_VFS_FAT_FAT32_HPP_
diff --git a/kernel/src/vfs/interface.hpp b/kernel/src/vfs/interface.hpp
new file mode 100644
index 00000000..def6379b
--- /dev/null
+++ b/kernel/src/vfs/interface.hpp
@@ -0,0 +1,59 @@
+#ifndef KERNEL_SRC_VFS_INTERFACE_HPP_
+#define KERNEL_SRC_VFS_INTERFACE_HPP_
+
+#include <concepts.hpp>
+#include <defines.hpp>
+#include <span.hpp>
+#include <types.hpp>
+
+namespace vfs
+{
+
+// Forward declarations
+class Path;
+
+namespace io
+{
+
+struct SectorRange {
+    size_t start;
+    size_t count;
+};
+
+}  // namespace io
+
+enum class Type { kUnknown, kFat12, kFat16, kFat32 };
+
+template <template <typename> typename T, typename IO>
+struct FatTraits {
+    static_assert(false, "Invalid FatTraits specialization");
+};
+
+template <typename IO>
+concept VFSIO =
+    requires(IO io, size_t offset, io::SectorRange range, std::span<const byte> data, size_t size) {
+        { io.ReadRange(range) } -> std::same_as<std::span<byte>>;
+        { io.ReadSector(offset) } -> std::same_as<std::span<byte>>;
+        { io.WriteRange(range, data) } -> std::same_as<void>;
+        { io.WriteSector(offset, data) } -> std::same_as<void>;
+        { io.GetSectorSize() } -> std::same_as<size_t>;
+    };
+
+// Forward declare Filesystem struct
+struct Filesystem;
+
+/* Should be derived by filesystem driver implementations.
+ * This interface defines the basic operations that a filesystem should support.
+ * Note: The actual implementation uses Path and Result types, but this concept
+ * only checks for the existence of GetFilesystem() as the main API entry point.
+ */
+template <template <typename> typename T, typename IO>
+concept VFSInterface = VFSIO<IO> and requires(T<IO> fs, IO io) {
+    T<IO>(io);
+    { T<IO>::IsValid(io) } -> std::same_as<bool>;
+    { fs.GetFilesystem() } -> std::same_as<Filesystem>;
+};
+
+}  // namespace vfs
+
+#endif  // KERNEL_SRC_VFS_INTERFACE_HPP_
diff --git a/kernel/src/vfs/io/in_memory.hpp b/kernel/src/vfs/io/in_memory.hpp
new file mode 100644
index 00000000..fd32c4d4
--- /dev/null
+++ b/kernel/src/vfs/io/in_memory.hpp
@@ -0,0 +1,105 @@
+#ifndef KERNEL_SRC_VFS_IO_IN_MEMORY_HPP_
+#define KERNEL_SRC_VFS_IO_IN_MEMORY_HPP_
+
+#include <string.h>
+#include <mem/heap.hpp>
+#include <span.hpp>
+#include <todo.hpp>
+#include <vfs/interface.hpp>
+
+namespace vfs::io
+{
+
+class InMemory
+{
+    static constexpr size_t kMaxTempBufSize = 64 * 1024;  // 64 KB
+
+    public:
+    // ------------------------------
+    // Class creation
+    // ------------------------------
+    InMemory() = delete;
+    explicit InMemory(void *address, size_t sector_size = 512)
+        : address_(static_cast<byte *>(address)), sector_size_(sector_size), buffer_(nullptr)
+    {
+        auto result = Mem::KMalloc(kMaxTempBufSize);
+        R_ASSERT_TRUE(result.has_value(), "Failed to allocate InMemory buffer");
+        buffer_ = static_cast<byte *>(result.value());
+    }
+
+    ~InMemory()
+    {
+        if (buffer_) {
+            Mem::KFree(buffer_);
+            buffer_ = nullptr;
+        }
+    }
+
+    InMemory(const InMemory &)            = delete;
+    InMemory &operator=(const InMemory &) = delete;
+
+    InMemory(InMemory &&other) noexcept
+        : address_(other.address_), sector_size_(other.sector_size_), buffer_(other.buffer_)
+    {
+        other.buffer_  = nullptr;
+        other.address_ = nullptr;
+    }
+
+    InMemory &operator=(InMemory &&other) noexcept
+    {
+        if (this != &other) {
+            if (buffer_) {
+                Mem::KFree(buffer_);
+            }
+            address_       = other.address_;
+            sector_size_   = other.sector_size_;
+            buffer_        = other.buffer_;
+            other.buffer_  = nullptr;
+            other.address_ = nullptr;
+        }
+        return *this;
+    }
+
+    std::span<byte> ReadRange(SectorRange range)
+    {
+        size_t total_size = range.count * sector_size_;
+        R_ASSERT_LE(
+            total_size, kMaxTempBufSize, "Requested range exceeds maximum temporary buffer size"
+        );
+
+        memcpy(buffer_, address_ + range.start * sector_size_, total_size);
+        return std::span<byte>(buffer_, total_size);
+    }
+
+    std::span<byte> ReadSector(size_t offset) { return ReadRange({offset, 1}); }
+
+    void WriteRange(SectorRange range, std::span<const byte> data)
+    {
+        ASSERT_EQ(
+            data.size(), range.count * sector_size_,
+            "Data size does not match the expected size for writing"
+        );
+
+        memcpy(address_ + range.start * sector_size_, data.data(), range.count * sector_size_);
+    }
+
+    FORCE_INLINE_F void WriteSector(size_t offset, std::span<const byte> data)
+    {
+        WriteRange({offset, 1}, data);
+    }
+
+    FORCE_INLINE_F size_t GetSectorSize() const { return sector_size_; }
+
+    FORCE_INLINE_F void SetSectorSize(size_t sector_size) { sector_size_ = sector_size; }
+
+    private:
+    byte *address_;
+    size_t sector_size_;
+    byte *buffer_;
+};
+
+static_assert(VFSIO<InMemory>, "InMemory does not implement VFSIO");
+
+}  // namespace vfs::io
+
+#endif  // KERNEL_SRC_VFS_IO_IN_MEMORY_HPP_
diff --git a/kernel/src/vfs/path.hpp b/kernel/src/vfs/path.hpp
new file mode 100644
index 00000000..425f499b
--- /dev/null
+++ b/kernel/src/vfs/path.hpp
@@ -0,0 +1,403 @@
+#ifndef KERNEL_SRC_VFS_PATH_HPP_
+#define KERNEL_SRC_VFS_PATH_HPP_
+
+#include <array.hpp>
+#include <concepts.hpp>
+#include <string.hpp>
+#include <type_traits.hpp>
+
+namespace vfs
+{
+
+// Constants
+inline constexpr size_t kMaxPathSize      = 4096;
+inline constexpr size_t kMaxComponents    = 64;
+inline constexpr size_t kMaxComponentSize = 256;
+inline constexpr char kPathSeparator      = '/';
+
+// Ccncepts
+template <typename T>
+concept PathStringLike = std::convertible_to<T, std::string_view>;
+
+template <typename Callback>
+concept PathComponentCallback = requires(Callback cb, std::string_view sv) {
+    { cb(sv) } -> std::same_as<void>;
+};
+
+// Path component const iterator
+class PathIterator
+{
+    public:
+    using value_type      = std::string_view;
+    using difference_type = std::ptrdiff_t;
+    using pointer         = const std::string_view *;
+    using reference       = const std::string_view &;
+
+    PathIterator() = delete;
+    PathIterator(const std::array<std::string_view, kMaxComponents> &components, size_t index)
+        : components_(components), index_(index)
+    {
+    }
+
+    reference operator*() const { return components_[index_]; }
+    pointer operator->() const { return &components_[index_]; }
+
+    PathIterator &operator++()
+    {
+        ++index_;
+        return *this;
+    }
+    PathIterator operator++(int)
+    {
+        auto tmp = *this;
+        ++(*this);
+        return tmp;
+    }
+
+    bool operator==(const PathIterator &other) const
+    {
+        return components_ == other.components_ && index_ == other.index_;
+    }
+
+    private:
+    const std::array<std::string_view, kMaxComponents> &components_;
+    size_t index_ = 0;
+};
+
+class Path
+{
+    public:
+    static const Path kCurrentDir;
+    static const Path kParentDir;
+    static const Path kRoot;
+
+    Path() = default;
+
+    template <PathStringLike T>
+    explicit Path(T &&path_str)
+    {
+        std::string_view sv(std::forward<T>(path_str));
+        path_len_ = std::min(sv.length(), kMaxPathSize - 1);
+        strncpy(raw_path_.data(), sv.data(), path_len_);
+        raw_path_[path_len_] = '\0';
+        Parse();
+    }
+
+    Path(const Path &other)                = default;
+    Path(Path &&other) noexcept            = default;
+    Path &operator=(const Path &other)     = default;
+    Path &operator=(Path &&other) noexcept = default;
+
+    // --- Basic properties ---
+    bool IsEmpty() const noexcept { return path_len_ == 0; }
+    bool IsAbsolute() const noexcept { return is_absolute_; }
+    bool IsRelative() const noexcept { return !is_absolute_; }
+    bool IsRoot() const noexcept { return is_absolute_ && num_components_ == 0; }
+
+    const char *CString() const noexcept { return raw_path_.data(); }
+    std::string_view StringView() const noexcept
+    {
+        return std::string_view(raw_path_.data(), path_len_);
+    }
+
+    // --- Component access ---
+    size_t ComponentCount() const noexcept { return num_components_; }
+    bool HasComponents() const noexcept { return num_components_ > 0; }
+
+    std::string_view operator[](size_t index) const noexcept
+    {
+        return index < num_components_ ? components_[index] : std::string_view{};
+    }
+
+    std::string_view GetComponent(size_t index) const noexcept { return (*this)[index]; }
+
+    std::string_view GetFilename() const noexcept
+    {
+        return num_components_ == 0 ? std::string_view{} : components_[num_components_ - 1];
+    }
+
+    std::string_view GetStem() const noexcept
+    {
+        auto filename = GetFilename();
+        if (filename.empty())
+            return {};
+        auto dot_pos = filename.find_last_of('.');
+        return (dot_pos == std::string_view::npos || dot_pos == 0) ? filename
+                                                                   : filename.substr(0, dot_pos);
+    }
+
+    std::string_view GetExtension() const noexcept
+    {
+        auto filename = GetFilename();
+        if (filename.empty())
+            return {};
+        auto dot_pos = filename.find_last_of('.');
+        return (dot_pos == std::string_view::npos || dot_pos == 0) ? std::string_view{}
+                                                                   : filename.substr(dot_pos);
+    }
+
+    Path GetParent() const
+    {
+        if (IsRoot() || num_components_ == 0) {
+            return IsAbsolute() ? kRoot : kCurrentDir;
+        }
+
+        // If this is a relative path with only one component, parent is current dir
+        if (IsRelative() && num_components_ == 1) {
+            return kCurrentDir;
+        }
+
+        Path parent;
+        parent.is_absolute_    = is_absolute_;
+        parent.num_components_ = num_components_ - 1;
+        strncpy(parent.raw_path_.data(), raw_path_.data(), std::min(path_len_, kMaxPathSize - 1));
+        for (size_t i = 0; i < parent.num_components_; ++i) {
+            parent.components_[i] = components_[i];
+        }
+        parent.RebuildPath();
+        return parent;
+    }
+
+    // --- Iterator interface ---
+    using iterator       = PathIterator;
+    using const_iterator = PathIterator;
+
+    iterator begin() { return PathIterator(components_, 0); }
+    iterator end() { return PathIterator(components_, num_components_); }
+    const_iterator begin() const { return PathIterator(components_, 0); }
+    const_iterator end() const { return PathIterator(components_, num_components_); }
+    const_iterator cbegin() const { return begin(); }
+    const_iterator cend() const { return end(); }
+
+    // --- Path manipulation ---
+    Path operator/(const Path &other) const
+    {
+        if (other.IsAbsolute())
+            return other;
+
+        Path result = *this;
+        // Check for component overflow before appending
+        if (result.num_components_ + other.num_components_ <= kMaxComponents) {
+            for (size_t i = 0; i < other.num_components_; ++i) {
+                result.components_[result.num_components_ + i] = other.components_[i];
+            }
+            result.num_components_ += other.num_components_;
+            result.RebuildPath();
+        }
+        return result;
+    }
+
+    template <PathStringLike T>
+    Path operator/(T &&component) const
+    {
+        return *this / Path(std::forward<T>(component));
+    }
+
+    Path &operator/=(const Path &other)
+    {
+        *this = *this / other;
+        return *this;
+    }
+
+    template <PathStringLike T>
+    Path &operator/=(T &&component)
+    {
+        return *this /= Path(std::forward<T>(component));
+    }
+
+    // --- Canonical path operations ---
+    Path GetWeaklyCanonical() const
+    {
+        Path canonical;
+        canonical.is_absolute_ = is_absolute_;
+
+        for (size_t i = 0; i < num_components_; ++i) {
+            const auto &component = components_[i];
+
+            if (component == kCurrentDir.StringView()) {
+                continue;  // Skip "."
+            }
+
+            if (component == kParentDir.StringView()) {
+                if (canonical.num_components_ > 0 &&
+                    canonical.components_[canonical.num_components_ - 1] !=
+                        kParentDir.StringView()) {
+                    canonical.num_components_--;  // Pop back
+                } else if (canonical.IsRelative()) {
+                    if (canonical.num_components_ < kMaxComponents) {
+                        canonical.components_[canonical.num_components_++] = component;
+                    }
+                }
+            } else {
+                if (canonical.num_components_ < kMaxComponents) {
+                    canonical.components_[canonical.num_components_++] = component;
+                }
+            }
+        }
+
+        canonical.RebuildPath();
+        return canonical;
+    }
+
+    Path GetNormalized() const { return GetWeaklyCanonical(); }
+
+    // --- Callback-based iteration ---
+    template <PathComponentCallback Callback>
+    void ForEachComponent(Callback &&callback) const
+    {
+        for (size_t i = 0; i < num_components_; ++i) {
+            if constexpr (std::same_as<std::invoke_result_t<Callback, std::string_view>, bool>) {
+                if (!callback(components_[i]))
+                    break;
+            } else {
+                callback(components_[i]);
+            }
+        }
+    }
+
+    template <PathComponentCallback Callback>
+    void ForEachComponentReverse(Callback &&callback) const
+    {
+        if (num_components_ == 0)
+            return;
+        for (size_t i = num_components_; i-- > 0;) {
+            if constexpr (std::same_as<std::invoke_result_t<Callback, std::string_view>, bool>) {
+                if (!callback(components_[i]))
+                    break;
+            } else {
+                callback(components_[i]);
+            }
+        }
+    }
+
+    // --- Comparison operators ---
+    bool operator==(const Path &other) const noexcept
+    {
+        if (is_absolute_ != other.is_absolute_ || num_components_ != other.num_components_) {
+            return false;
+        }
+
+        for (size_t i = 0; i < num_components_; ++i) {
+            if (components_[i] != other.components_[i]) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    bool operator!=(const Path &other) const noexcept { return !(*this == other); }
+
+    bool operator<(const Path &other) const noexcept
+    {
+        if (is_absolute_ != other.is_absolute_) {
+            return !is_absolute_;  // Relative paths are less than absolute
+        }
+
+        size_t min_components = std::min(num_components_, other.num_components_);
+        for (size_t i = 0; i < min_components; ++i) {
+            if (components_[i] < other.components_[i]) {
+                return true;
+            } else if (components_[i] > other.components_[i]) {
+                return false;
+            }
+        }
+        // If all common components are equal, shorter path is less
+        return num_components_ < other.num_components_;
+    }
+
+    // --- Static utility methods ---
+
+    template <PathStringLike... Args>
+    static Path Join(Args &&...args)
+    {
+        Path result;
+        ((result /= Path(std::forward<Args>(args))), ...);
+        return result;
+    }
+
+    private:
+    void Parse()
+    {
+        num_components_ = 0;
+        std::string_view full_path(raw_path_.data(), path_len_);
+
+        if (full_path.empty()) {
+            is_absolute_ = false;
+            return;
+        }
+
+        is_absolute_ = (full_path[0] == kPathSeparator);
+
+        size_t start = is_absolute_ ? 1 : 0;
+        size_t pos   = start;
+
+        while (pos < full_path.size() && num_components_ < kMaxComponents) {
+            size_t next_sep = full_path.find(kPathSeparator, pos);
+            if (next_sep == std::string_view::npos) {
+                next_sep = full_path.size();
+            }
+
+            if (next_sep > pos) {  // Non-empty component
+                components_[num_components_++] = full_path.substr(pos, next_sep - pos);
+            }
+
+            pos = next_sep + 1;
+        }
+    }
+
+    void RebuildPath()
+    {
+        char *current         = raw_path_.data();
+        const char *const end = raw_path_.data() + kMaxPathSize;
+
+        if (is_absolute_) {
+            if (current < end) {
+                *current++ = kPathSeparator;
+            }
+        }
+
+        for (size_t i = 0; i < num_components_; ++i) {
+            if (i > 0) {
+                if (current < end) {
+                    *current++ = kPathSeparator;
+                }
+            }
+            // Ensure we don't write past the end of the buffer
+            size_t copy_len = std::min(components_[i].length(), static_cast<size_t>(end - current));
+            strncpy(current, components_[i].data(), copy_len);
+            current += copy_len;
+        }
+
+        path_len_ = current - raw_path_.data();
+        if (path_len_ < kMaxPathSize) {
+            raw_path_[path_len_] = '\0';
+        }
+
+        // Re-point all string_views to our internal buffer
+        is_absolute_          = (path_len_ > 0 && raw_path_[0] == kPathSeparator);
+        size_t current_offset = is_absolute_ ? 1 : 0;
+        for (size_t i = 0; i < num_components_; ++i) {
+            size_t component_len = components_[i].length();
+            components_[i] = std::string_view(raw_path_.data() + current_offset, component_len);
+            current_offset += component_len + 1;  // +1 for the separator
+        }
+    }
+
+    // Member variables
+    std::array<char, kMaxPathSize> raw_path_{};
+    size_t path_len_ = 0;
+
+    std::array<std::string_view, kMaxComponents> components_{};
+    size_t num_components_ = 0;
+
+    bool is_absolute_ = false;
+};
+
+inline const Path Path::kCurrentDir = Path(".");
+inline const Path Path::kParentDir  = Path("..");
+inline const Path Path::kRoot       = Path(std::string_view(&kPathSeparator, 1));
+
+}  // namespace vfs
+
+#endif  // KERNEL_SRC_VFS_PATH_HPP_
diff --git a/kernel/src/vfs/types.hpp b/kernel/src/vfs/types.hpp
new file mode 100644
index 00000000..5c93b46c
--- /dev/null
+++ b/kernel/src/vfs/types.hpp
@@ -0,0 +1,186 @@
+#ifndef KERNEL_SRC_VFS_TYPES_HPP_
+#define KERNEL_SRC_VFS_TYPES_HPP_
+
+#include <data_structures/critbit_tree.hpp>
+#include <types.hpp>
+
+#include "vfs/error.hpp"
+#include "vfs/interface.hpp"
+#include "vfs/path.hpp"
+
+namespace vfs
+{
+
+/**
+ * @brief Filesystem callbacks struct for VFS operations.
+ *
+ * This struct contains function pointers that implement filesystem operations.
+ * Each filesystem driver should provide an instance of this struct with
+ * appropriate implementations for its operations.
+ */
+
+// Callback type for directory listing - receives user context, entry name, and is_dir flag
+using ListDirCallback = void (*)(void *user_ctx, const char *name, bool is_dir);
+
+struct Filesystem {
+    // ------------------------------
+    // Structures
+    // ------------------------------
+
+    struct Operations {
+        // File operations
+        Result<> (*create_file)(void *ctx, const Path &path);
+        Result<size_t> (*read_file)(
+            void *ctx, const Path &path, void *buffer, size_t size, size_t offset
+        );
+        Result<size_t> (*write_file)(
+            void *ctx, const Path &path, const void *buffer, size_t size, size_t offset
+        );
+        Result<> (*delete_file)(void *ctx, const Path &path);
+        Result<bool> (*file_exists)(void *ctx, const Path &path);
+        Result<size_t> (*get_file_size)(void *ctx, const Path &path);
+
+        // Directory operations
+        Result<> (*create_directory)(void *ctx, const Path &path);
+        Result<> (*remove_directory)(void *ctx, const Path &path);
+        void (*list_directory)(
+            void *ctx, const Path &path, ListDirCallback callback, void *user_ctx
+        );
+        Result<bool> (*directory_exists)(void *ctx, const Path &path);
+
+        // General operations
+        Result<bool> (*exists)(void *ctx, const Path &path);
+        Result<> (*move)(void *ctx, const Path &old_path, const Path &new_path);
+    };
+
+    struct Info {
+        Type type;
+        const char *name;  // Filesystem name (e.g., "FAT32", "FAT16")
+    };
+
+    // ------------------------------
+    // Creation and Destruction
+    // ------------------------------
+
+    Filesystem() = delete;
+    explicit Filesystem(void *context, const Operations &operations, const Info &info)
+        : context_(context), ops_(operations), info_(info)
+    {
+    }
+
+    // ------------------------------
+    // Filesystem Operations
+    // ------------------------------
+
+    // File operations
+    FORCE_INLINE_F Result<> CreateFile(const Path &path) const
+    {
+        return ops_.create_file(context_, path);
+    }
+
+    FORCE_INLINE_F Result<size_t> ReadFile(
+        const Path &path, void *buffer, size_t size, size_t offset
+    ) const
+    {
+        return ops_.read_file(context_, path, buffer, size, offset);
+    }
+
+    FORCE_INLINE_F Result<size_t> WriteFile(
+        const Path &path, const void *buffer, size_t size, size_t offset
+    ) const
+    {
+        return ops_.write_file(context_, path, buffer, size, offset);
+    }
+
+    FORCE_INLINE_F Result<> DeleteFile(const Path &path) const
+    {
+        return ops_.delete_file(context_, path);
+    }
+
+    FORCE_INLINE_F Result<bool> FileExists(const Path &path) const
+    {
+        return ops_.file_exists(context_, path);
+    }
+
+    FORCE_INLINE_F Result<size_t> GetFileSize(const Path &path) const
+    {
+        return ops_.get_file_size(context_, path);
+    }
+
+    // Directory operations
+    FORCE_INLINE_F Result<> CreateDirectory(const Path &path) const
+    {
+        return ops_.create_directory(context_, path);
+    }
+
+    FORCE_INLINE_F Result<> RemoveDirectory(const Path &path) const
+    {
+        return ops_.remove_directory(context_, path);
+    }
+
+    template <typename Callback>
+    void ListDirectory(const Path &path, Callback &&callback) const
+    {
+        ops_.list_directory(
+            context_, path,
+            [](void *user_ctx, const char *name, bool is_dir) {
+                (*static_cast<Callback *>(user_ctx))(name, is_dir);
+            },
+            &callback
+        );
+    }
+
+    FORCE_INLINE_F Result<bool> DirectoryExists(const Path &path) const
+    {
+        return ops_.directory_exists(context_, path);
+    }
+
+    // General operations
+    FORCE_INLINE_F Result<bool> Exists(const Path &path) const
+    {
+        return ops_.exists(context_, path);
+    }
+
+    FORCE_INLINE_F Result<> Move(const Path &old_path, const Path &new_path) const
+    {
+        return ops_.move(context_, old_path, new_path);
+    }
+
+    FORCE_INLINE_F const Info &GetInfo() const { return info_; }
+
+    private:
+    void *context_;  // Filesystem instance
+    Operations ops_;
+    Info info_;
+};
+
+struct MountOptions {
+    bool read_only : 1 = false;
+};
+
+enum class FileType : u8 {
+    File,
+    Directory,
+};
+
+struct MountPoint {
+    Path path;
+    MountOptions options;
+    Filesystem fs;
+
+    MountPoint() = delete;
+    explicit MountPoint(
+        const Path &mount_path, MountOptions mount_options, const Filesystem &filesystem
+    )
+        : path(mount_path), options(mount_options), fs(filesystem)
+    {
+    }
+
+    ~MountPoint() = default;
+};
+
+using Mounts = data_structures::CritBitTree<MountPoint>;
+
+}  // namespace vfs
+
+#endif  // KERNEL_SRC_VFS_TYPES_HPP_
diff --git a/kernel/test/vfs/fat/fat12_test.cpp b/kernel/test/vfs/fat/fat12_test.cpp
new file mode 100644
index 00000000..4132fcb3
--- /dev/null
+++ b/kernel/test/vfs/fat/fat12_test.cpp
@@ -0,0 +1,496 @@
+#include <test_module/test.hpp>
+
+#include <string.h>
+#include <vfs/fat/fat12.hpp>
+#include <vfs/io/in_memory.hpp>
+#include <vfs/path.hpp>
+
+// FAT12 disk image layout helper
+// A minimal FAT12 filesystem for testing
+class Fat12TestHelper
+{
+    public:
+    static constexpr size_t kSectorSize        = 512;
+    static constexpr size_t kSectorsPerCluster = 1;
+    static constexpr size_t kReservedSectors   = 1;
+    static constexpr size_t kNumberOfFats      = 2;
+    static constexpr size_t kRootDirEntries    = 16;
+    static constexpr size_t kFatSizeSectors    = 1;
+    static constexpr size_t kTotalSectors      = 64;  // Small test image
+
+    // Calculate regions
+    static constexpr size_t kFatRegionStart = kReservedSectors;
+    static constexpr size_t kRootDirStart   = kReservedSectors + kNumberOfFats * kFatSizeSectors;
+    static constexpr size_t kRootDirSectors =
+        (kRootDirEntries * 32 + kSectorSize - 1) / kSectorSize;
+    static constexpr size_t kDataRegionStart = kRootDirStart + kRootDirSectors;
+
+    static constexpr size_t kImageSize = kTotalSectors * kSectorSize;
+
+    static void CreateBootSector(byte *image)
+    {
+        memset(image, 0, kSectorSize);
+
+        // Jump instruction
+        image[0] = 0xEB;
+        image[1] = 0x3C;
+        image[2] = 0x90;
+
+        // OEM name
+        memcpy(image + 3, "MSDOS5.0", 8);
+
+        // Bytes per sector
+        *reinterpret_cast<u16 *>(image + 11) = kSectorSize;
+
+        // Sectors per cluster
+        image[13] = kSectorsPerCluster;
+
+        // Reserved sectors
+        *reinterpret_cast<u16 *>(image + 14) = kReservedSectors;
+
+        // Number of FATs
+        image[16] = kNumberOfFats;
+
+        // Root directory entries
+        *reinterpret_cast<u16 *>(image + 17) = kRootDirEntries;
+
+        // Total sectors (small volume)
+        *reinterpret_cast<u16 *>(image + 19) = kTotalSectors;
+
+        // Media descriptor (fixed disk)
+        image[21] = 0xF8;
+
+        // FAT size in sectors
+        *reinterpret_cast<u16 *>(image + 22) = kFatSizeSectors;
+
+        // Sectors per track
+        *reinterpret_cast<u16 *>(image + 24) = 18;
+
+        // Number of heads
+        *reinterpret_cast<u16 *>(image + 26) = 2;
+
+        // Hidden sectors
+        *reinterpret_cast<u32 *>(image + 28) = 0;
+
+        // Total sectors (dword, for large volumes)
+        *reinterpret_cast<u32 *>(image + 32) = 0;
+
+        // Drive number
+        image[36] = 0x80;
+
+        // Boot signature
+        image[38] = 0x29;
+
+        // Volume ID
+        *reinterpret_cast<u32 *>(image + 39) = 0x12345678;
+
+        // Volume label
+        memcpy(image + 43, "TEST VOLUME", 11);
+
+        // Filesystem type
+        memcpy(image + 54, "FAT12   ", 8);
+
+        // Boot signature at end
+        image[510] = 0x55;
+        image[511] = 0xAA;
+    }
+
+    static void CreateFatTables(byte *image)
+    {
+        // First FAT
+        byte *fat1 = image + kFatRegionStart * kSectorSize;
+        memset(fat1, 0, kFatSizeSectors * kSectorSize);
+
+        // FAT[0] = media descriptor | 0xF00
+        fat1[0] = 0xF8;  // Media descriptor
+        fat1[1] = 0xFF;
+        fat1[2] = 0xFF;
+
+        // Second FAT (copy)
+        byte *fat2 = image + (kFatRegionStart + kFatSizeSectors) * kSectorSize;
+        memcpy(fat2, fat1, kFatSizeSectors * kSectorSize);
+    }
+
+    static void CreateRootDirectory(byte *image)
+    {
+        byte *root_dir = image + kRootDirStart * kSectorSize;
+        memset(root_dir, 0, kRootDirSectors * kSectorSize);
+
+        // Create volume label entry
+        memcpy(root_dir, "TEST VOLUME", 11);
+        root_dir[11] = 0x08;  // Volume label attribute
+    }
+
+    static void CreateMinimalImage(byte *image)
+    {
+        memset(image, 0, kImageSize);
+        CreateBootSector(image);
+        CreateFatTables(image);
+        CreateRootDirectory(image);
+    }
+};
+
+class Fat12Test : public TestGroupBase
+{
+    protected:
+    alignas(16) byte disk_image[Fat12TestHelper::kImageSize];
+    vfs::io::InMemory *io{nullptr};
+    vfs::Fat12<vfs::io::InMemory> *fat12{nullptr};
+
+    void Setup_() override
+    {
+        Fat12TestHelper::CreateMinimalImage(disk_image);
+
+        io = Mem::KMalloc<vfs::io::InMemory>().value_or(nullptr);
+        EXPECT_NOT_NULL(io);
+        std::construct_at<vfs::io::InMemory>(io, disk_image, Fat12TestHelper::kSectorSize);
+
+        fat12 = Mem::KMalloc<vfs::Fat12<vfs::io::InMemory>>().value_or(nullptr);
+        EXPECT_NOT_NULL(fat12);
+        std::construct_at<vfs::Fat12<vfs::io::InMemory>>(fat12, *io);
+    }
+
+    void TearDown_() override
+    {
+        std::destroy_at(fat12);
+        Mem::KFree(fat12);
+
+        std::destroy_at(io);
+        Mem::KFree(io);
+    }
+};
+
+// Basic validation tests
+TEST_F(Fat12Test, IsValidReturnsTrueForValidImage)
+{
+    vfs::io::InMemory io(disk_image, Fat12TestHelper::kSectorSize);
+    EXPECT_TRUE(vfs::Fat12<vfs::io::InMemory>::IsValid(io));
+}
+
+TEST_F(Fat12Test, IsValidReturnsFalseForInvalidSignature)
+{
+    // Corrupt boot signature
+    disk_image[510] = 0x00;
+    disk_image[511] = 0x00;
+
+    vfs::io::InMemory io(disk_image, Fat12TestHelper::kSectorSize);
+    EXPECT_FALSE(vfs::Fat12<vfs::io::InMemory>::IsValid(io));
+}
+
+TEST_F(Fat12Test, IsValidReturnsFalseForInvalidJumpInstruction)
+{
+    // Corrupt jump instruction
+    disk_image[0] = 0x00;
+
+    vfs::io::InMemory io(disk_image, Fat12TestHelper::kSectorSize);
+    EXPECT_FALSE(vfs::Fat12<vfs::io::InMemory>::IsValid(io));
+}
+
+// Directory listing tests
+TEST_F(Fat12Test, ListDirectoryRootReturnsVolumeLabel)
+{
+    auto fs = fat12->GetFilesystem();
+
+    int entry_count = 0;
+    vfs::Path root("/");
+
+    fs.ListDirectory(root, [&](const char *, bool) {
+        ++entry_count;
+    });
+
+    // Volume label should be skipped, so expect 0 entries
+    EXPECT_EQ(0, entry_count);
+}
+
+// File existence tests
+TEST_F(Fat12Test, FileExistsReturnsFalseForNonExistentFile)
+{
+    auto fs = fat12->GetFilesystem();
+
+    vfs::Path path("/NOFILE.TXT");
+    auto result = fs.FileExists(path);
+
+    EXPECT_TRUE(result.has_value());
+    EXPECT_FALSE(result.value());
+}
+
+TEST_F(Fat12Test, DirectoryExistsReturnsTrueForRoot)
+{
+    auto fs = fat12->GetFilesystem();
+
+    vfs::Path path("/");
+    auto result = fs.DirectoryExists(path);
+
+    EXPECT_TRUE(result.has_value());
+    EXPECT_TRUE(result.value());
+}
+
+TEST_F(Fat12Test, DirectoryExistsReturnsFalseForNonExistentDir)
+{
+    auto fs = fat12->GetFilesystem();
+
+    vfs::Path path("/NODIR");
+    auto result = fs.DirectoryExists(path);
+
+    EXPECT_TRUE(result.has_value());
+    EXPECT_FALSE(result.value());
+}
+
+TEST_F(Fat12Test, ExistsReturnsTrueForRoot)
+{
+    auto fs = fat12->GetFilesystem();
+
+    vfs::Path path("/");
+    auto result = fs.Exists(path);
+
+    EXPECT_TRUE(result.has_value());
+    EXPECT_TRUE(result.value());
+}
+
+// File creation tests
+TEST_F(Fat12Test, CreateFileSucceeds)
+{
+    auto fs = fat12->GetFilesystem();
+
+    vfs::Path path("/TEST.TXT");
+    auto result = fs.CreateFile(path);
+
+    EXPECT_TRUE(result.has_value());
+}
+
+TEST_F(Fat12Test, CreateFileFailsForInvalidName)
+{
+    auto fs = fat12->GetFilesystem();
+
+    // Name too long for 8.3 format
+    vfs::Path path("/VERYLONGFILENAME.TXT");
+    auto result = fs.CreateFile(path);
+
+    EXPECT_FALSE(result.has_value());
+    EXPECT_EQ(result.error(), vfs::VfsError::kInvalidName);
+}
+
+TEST_F(Fat12Test, CreateFileThenFileExists)
+{
+    auto fs = fat12->GetFilesystem();
+
+    vfs::Path path("/NEWFILE.TXT");
+
+    // Create file
+    auto create_result = fs.CreateFile(path);
+    EXPECT_TRUE(create_result.has_value());
+
+    // Verify it exists
+    auto exists_result = fs.FileExists(path);
+    EXPECT_TRUE(exists_result.has_value());
+    EXPECT_TRUE(exists_result.value());
+}
+
+TEST_F(Fat12Test, CreateFileFailsIfAlreadyExists)
+{
+    auto fs = fat12->GetFilesystem();
+
+    vfs::Path path("/DUP.TXT");
+
+    // Create file first time
+    auto result1 = fs.CreateFile(path);
+    EXPECT_TRUE(result1.has_value());
+
+    // Try to create again
+    auto result2 = fs.CreateFile(path);
+    EXPECT_FALSE(result2.has_value());
+    EXPECT_EQ(result2.error(), vfs::VfsError::kAlreadyExists);
+}
+
+// Directory creation tests
+TEST_F(Fat12Test, CreateDirectorySucceeds)
+{
+    auto fs = fat12->GetFilesystem();
+
+    vfs::Path path("/TESTDIR");
+    auto result = fs.CreateDirectory(path);
+
+    EXPECT_TRUE(result.has_value());
+}
+
+TEST_F(Fat12Test, CreateDirectoryThenExists)
+{
+    auto fs = fat12->GetFilesystem();
+
+    vfs::Path path("/MYDIR");
+
+    // Create directory
+    auto create_result = fs.CreateDirectory(path);
+    EXPECT_TRUE(create_result.has_value());
+
+    // Verify it exists
+    auto exists_result = fs.DirectoryExists(path);
+    EXPECT_TRUE(exists_result.has_value());
+    EXPECT_TRUE(exists_result.value());
+}
+
+// File deletion tests
+TEST_F(Fat12Test, DeleteFileSucceeds)
+{
+    auto fs = fat12->GetFilesystem();
+
+    vfs::Path path("/TODEL.TXT");
+
+    // Create file first
+    auto create_result = fs.CreateFile(path);
+    EXPECT_TRUE(create_result.has_value());
+
+    // Delete it
+    auto delete_result = fs.DeleteFile(path);
+    EXPECT_TRUE(delete_result.has_value());
+
+    // Verify it's gone
+    auto exists_result = fs.FileExists(path);
+    EXPECT_TRUE(exists_result.has_value());
+    EXPECT_FALSE(exists_result.value());
+}
+
+TEST_F(Fat12Test, DeleteFileFailsForNonExistent)
+{
+    auto fs = fat12->GetFilesystem();
+
+    vfs::Path path("/NOFILE.TXT");
+    auto result = fs.DeleteFile(path);
+
+    EXPECT_FALSE(result.has_value());
+    EXPECT_EQ(result.error(), vfs::VfsError::kFileNotFound);
+}
+
+// File read/write tests
+TEST_F(Fat12Test, WriteAndReadFile)
+{
+    auto fs = fat12->GetFilesystem();
+
+    vfs::Path path("/DATA.TXT");
+
+    // Create file
+    auto create_result = fs.CreateFile(path);
+    EXPECT_TRUE(create_result.has_value());
+
+    // Write data
+    const char *test_data = "Hello, FAT12!";
+    size_t data_len       = strlen(test_data);
+
+    auto write_result = fs.WriteFile(path, test_data, data_len, 0);
+    EXPECT_TRUE(write_result.has_value());
+    EXPECT_EQ(write_result.value(), data_len);
+
+    // Read it back
+    char read_buffer[64] = {0};
+    auto read_result     = fs.ReadFile(path, read_buffer, data_len, 0);
+    EXPECT_TRUE(read_result.has_value());
+    EXPECT_EQ(read_result.value(), data_len);
+
+    // Verify content
+    EXPECT_EQ(memcmp(read_buffer, test_data, data_len), 0);
+}
+
+TEST_F(Fat12Test, GetFileSizeAfterWrite)
+{
+    auto fs = fat12->GetFilesystem();
+
+    vfs::Path path("/SIZE.TXT");
+
+    // Create and write
+    fs.CreateFile(path);
+    const char *data = "Test content";
+    size_t data_len  = strlen(data);
+    fs.WriteFile(path, data, data_len, 0);
+
+    // Check size
+    auto size_result = fs.GetFileSize(path);
+    EXPECT_TRUE(size_result.has_value());
+    EXPECT_EQ(size_result.value(), data_len);
+}
+
+TEST_F(Fat12Test, ReadFileFailsForNonExistent)
+{
+    auto fs = fat12->GetFilesystem();
+
+    vfs::Path path("/NOFILE.TXT");
+    char buffer[64];
+
+    auto result = fs.ReadFile(path, buffer, sizeof(buffer), 0);
+    EXPECT_FALSE(result.has_value());
+    EXPECT_EQ(result.error(), vfs::VfsError::kFileNotFound);
+}
+
+// Remove directory tests
+TEST_F(Fat12Test, RemoveEmptyDirectorySucceeds)
+{
+    auto fs = fat12->GetFilesystem();
+
+    vfs::Path path("/EMPTYDIR");
+
+    // Create directory
+    auto create_result = fs.CreateDirectory(path);
+    EXPECT_TRUE(create_result.has_value());
+
+    // Remove it
+    auto remove_result = fs.RemoveDirectory(path);
+    EXPECT_TRUE(remove_result.has_value());
+
+    // Verify it's gone
+    auto exists_result = fs.DirectoryExists(path);
+    EXPECT_TRUE(exists_result.has_value());
+    EXPECT_FALSE(exists_result.value());
+}
+
+TEST_F(Fat12Test, RemoveDirectoryFailsForNonExistent)
+{
+    auto fs = fat12->GetFilesystem();
+
+    vfs::Path path("/NODIR");
+    auto result = fs.RemoveDirectory(path);
+
+    EXPECT_FALSE(result.has_value());
+    EXPECT_EQ(result.error(), vfs::VfsError::kDirectoryNotFound);
+}
+
+// Move tests
+TEST_F(Fat12Test, MoveFileSucceeds)
+{
+    auto fs = fat12->GetFilesystem();
+
+    vfs::Path old_path("/OLD.TXT");
+    vfs::Path new_path("/NEW.TXT");
+
+    // Create file
+    fs.CreateFile(old_path);
+
+    // Move it
+    auto move_result = fs.Move(old_path, new_path);
+    EXPECT_TRUE(move_result.has_value());
+
+    // Verify old doesn't exist
+    auto old_exists = fs.FileExists(old_path);
+    EXPECT_TRUE(old_exists.has_value());
+    EXPECT_FALSE(old_exists.value());
+
+    // Verify new exists
+    auto new_exists = fs.FileExists(new_path);
+    EXPECT_TRUE(new_exists.has_value());
+    EXPECT_TRUE(new_exists.value());
+}
+
+TEST_F(Fat12Test, MoveFailsIfDestinationExists)
+{
+    auto fs = fat12->GetFilesystem();
+
+    vfs::Path path1("/FILE1.TXT");
+    vfs::Path path2("/FILE2.TXT");
+
+    // Create both files
+    fs.CreateFile(path1);
+    fs.CreateFile(path2);
+
+    // Try to move
+    auto result = fs.Move(path1, path2);
+    EXPECT_FALSE(result.has_value());
+    EXPECT_EQ(result.error(), vfs::VfsError::kAlreadyExists);
+}
diff --git a/kernel/test/vfs/path_test.cpp b/kernel/test/vfs/path_test.cpp
new file mode 100644
index 00000000..162417cd
--- /dev/null
+++ b/kernel/test/vfs/path_test.cpp
@@ -0,0 +1,419 @@
+#include <test_module/test.hpp>
+
+#include <vfs/path.hpp>
+
+class VFSPathTest : public TestGroupBase
+{
+};
+
+// =============================================================================
+// Construction and Basic Properties
+// =============================================================================
+
+TEST_F(VFSPathTest, DefaultAndEmptyPaths)
+{
+    // Default constructor
+    vfs::Path empty_default;
+    EXPECT_TRUE(empty_default.IsEmpty());
+    EXPECT_FALSE(empty_default.IsAbsolute());
+    EXPECT_TRUE(empty_default.IsRelative());
+    EXPECT_FALSE(empty_default.IsRoot());
+    EXPECT_EQ(0u, empty_default.ComponentCount());
+
+    // Empty string
+    vfs::Path empty_string("");
+    EXPECT_TRUE(empty_string.IsEmpty());
+    EXPECT_EQ(0u, empty_string.ComponentCount());
+
+    // Only slashes (should be treated as root)
+    vfs::Path only_slashes("///");
+    EXPECT_TRUE(only_slashes.IsAbsolute());
+    EXPECT_TRUE(only_slashes.IsRoot());
+    EXPECT_EQ(0u, only_slashes.ComponentCount());
+}
+
+TEST_F(VFSPathTest, RootPath)
+{
+    vfs::Path path("/");
+    EXPECT_FALSE(path.IsEmpty());
+    EXPECT_TRUE(path.IsAbsolute());
+    EXPECT_FALSE(path.IsRelative());
+    EXPECT_TRUE(path.IsRoot());
+    EXPECT_EQ(0u, path.ComponentCount());
+    EXPECT_TRUE(path.GetFilename().empty());
+}
+
+TEST_F(VFSPathTest, AbsolutePaths)
+{
+    // Single component
+    vfs::Path single("/home");
+    EXPECT_FALSE(single.IsEmpty());
+    EXPECT_TRUE(single.IsAbsolute());
+    EXPECT_FALSE(single.IsRoot());
+    EXPECT_EQ(1u, single.ComponentCount());
+    EXPECT_EQ("home", single.GetComponent(0));
+
+    // Multiple components
+    vfs::Path multi("/home/user/documents");
+    EXPECT_TRUE(multi.IsAbsolute());
+    EXPECT_EQ(3u, multi.ComponentCount());
+    EXPECT_EQ("home", multi.GetComponent(0));
+    EXPECT_EQ("user", multi.GetComponent(1));
+    EXPECT_EQ("documents", multi.GetComponent(2));
+
+    // Trailing slash (should be ignored)
+    vfs::Path trailing("/home/user/");
+    EXPECT_TRUE(trailing.IsAbsolute());
+    EXPECT_EQ(2u, trailing.ComponentCount());
+    EXPECT_EQ("home", trailing.GetComponent(0));
+    EXPECT_EQ("user", trailing.GetComponent(1));
+
+    // Multiple consecutive slashes (should be treated as single)
+    vfs::Path multi_slash("/home//user///documents");
+    EXPECT_TRUE(multi_slash.IsAbsolute());
+    EXPECT_EQ(3u, multi_slash.ComponentCount());
+    EXPECT_EQ("home", multi_slash.GetComponent(0));
+    EXPECT_EQ("user", multi_slash.GetComponent(1));
+    EXPECT_EQ("documents", multi_slash.GetComponent(2));
+}
+
+TEST_F(VFSPathTest, RelativePaths)
+{
+    // Single component
+    vfs::Path single("file.txt");
+    EXPECT_FALSE(single.IsEmpty());
+    EXPECT_FALSE(single.IsAbsolute());
+    EXPECT_TRUE(single.IsRelative());
+    EXPECT_EQ(1u, single.ComponentCount());
+    EXPECT_EQ("file.txt", single.GetComponent(0));
+
+    // Multiple components
+    vfs::Path multi("dir/subdir/file.txt");
+    EXPECT_TRUE(multi.IsRelative());
+    EXPECT_EQ(3u, multi.ComponentCount());
+    EXPECT_EQ("dir", multi.GetComponent(0));
+    EXPECT_EQ("subdir", multi.GetComponent(1));
+    EXPECT_EQ("file.txt", multi.GetComponent(2));
+}
+
+// =============================================================================
+// Filename, Stem, and Extension
+// =============================================================================
+
+TEST_F(VFSPathTest, FilenameExtraction)
+{
+    // Simple filename with extension
+    EXPECT_EQ("file.txt", vfs::Path("/home/user/file.txt").GetFilename());
+
+    // Filename without extension
+    EXPECT_EQ("README", vfs::Path("/home/user/README").GetFilename());
+
+    // Root has no filename
+    EXPECT_TRUE(vfs::Path("/").GetFilename().empty());
+
+    // Empty path has no filename
+    EXPECT_TRUE(vfs::Path().GetFilename().empty());
+}
+
+TEST_F(VFSPathTest, StemExtraction)
+{
+    // Simple case
+    EXPECT_EQ("file", vfs::Path("/home/user/file.txt").GetStem());
+
+    // Multiple dots - stem is everything before last dot
+    EXPECT_EQ("file.tar", vfs::Path("/home/user/file.tar.gz").GetStem());
+
+    // No extension
+    EXPECT_EQ("README", vfs::Path("/home/user/README").GetStem());
+
+    // Dot file (leading dot) - entire name is stem
+    EXPECT_EQ(".bashrc", vfs::Path("/home/user/.bashrc").GetStem());
+}
+
+TEST_F(VFSPathTest, ExtensionExtraction)
+{
+    // Simple extension
+    EXPECT_EQ(".txt", vfs::Path("/home/user/file.txt").GetExtension());
+
+    // Multiple dots - only last extension
+    EXPECT_EQ(".gz", vfs::Path("/home/user/file.tar.gz").GetExtension());
+
+    // No extension
+    EXPECT_TRUE(vfs::Path("/home/user/README").GetExtension().empty());
+
+    // Dot file has no extension
+    EXPECT_TRUE(vfs::Path("/home/user/.bashrc").GetExtension().empty());
+}
+
+// =============================================================================
+// Parent Path
+// =============================================================================
+
+TEST_F(VFSPathTest, ParentPathNavigation)
+{
+    // Absolute path parent
+    vfs::Path abs_path("/home/user/file.txt");
+    vfs::Path abs_parent = abs_path.GetParent();
+    EXPECT_TRUE(abs_parent.IsAbsolute());
+    EXPECT_EQ(2u, abs_parent.ComponentCount());
+    EXPECT_EQ("home", abs_parent.GetComponent(0));
+    EXPECT_EQ("user", abs_parent.GetComponent(1));
+
+    // Root's parent is still root
+    vfs::Path root("/");
+    EXPECT_TRUE(root.GetParent().IsRoot());
+
+    // Single component absolute path's parent is root
+    vfs::Path single_abs("/home");
+    EXPECT_TRUE(single_abs.GetParent().IsRoot());
+
+    // Relative path parent
+    vfs::Path rel_path("dir/file.txt");
+    vfs::Path rel_parent = rel_path.GetParent();
+    EXPECT_TRUE(rel_parent.IsRelative());
+    EXPECT_EQ(1u, rel_parent.ComponentCount());
+    EXPECT_EQ("dir", rel_parent.GetComponent(0));
+
+    // Single component relative path's parent is current dir
+    vfs::Path single_rel("file.txt");
+    EXPECT_EQ(single_rel.GetParent(), vfs::Path::kCurrentDir);
+}
+
+// =============================================================================
+// Path Concatenation
+// =============================================================================
+
+TEST_F(VFSPathTest, PathConcatenation)
+{
+    // Absolute + relative
+    vfs::Path base("/home");
+    vfs::Path rel("user");
+    vfs::Path result = base / rel;
+    EXPECT_TRUE(result.IsAbsolute());
+    EXPECT_EQ(2u, result.ComponentCount());
+    EXPECT_EQ("home", result.GetComponent(0));
+    EXPECT_EQ("user", result.GetComponent(1));
+
+    // Absolute + absolute (second replaces first)
+    vfs::Path abs("/etc");
+    vfs::Path replaced = base / abs;
+    EXPECT_TRUE(replaced.IsAbsolute());
+    EXPECT_EQ("etc", replaced.GetComponent(0));
+
+    // Chaining with strings
+    vfs::Path chained = vfs::Path("/home") / "user" / "documents";
+    EXPECT_TRUE(chained.IsAbsolute());
+    EXPECT_EQ(3u, chained.ComponentCount());
+    EXPECT_EQ("home", chained.GetComponent(0));
+    EXPECT_EQ("user", chained.GetComponent(1));
+    EXPECT_EQ("documents", chained.GetComponent(2));
+
+    // Assignment operator
+    vfs::Path assigned("/home");
+    assigned /= "user";
+    assigned /= "documents";
+    EXPECT_TRUE(assigned.IsAbsolute());
+    EXPECT_EQ(3u, assigned.ComponentCount());
+}
+
+// =============================================================================
+// Path Normalization
+// =============================================================================
+
+TEST_F(VFSPathTest, PathNormalization)
+{
+    // Remove single dots
+    vfs::Path dot_path("/home/./user");
+    vfs::Path dot_norm = dot_path.GetNormalized();
+    EXPECT_EQ(2u, dot_norm.ComponentCount());
+    EXPECT_EQ("home", dot_norm.GetComponent(0));
+    EXPECT_EQ("user", dot_norm.GetComponent(1));
+
+    // Resolve double dots
+    vfs::Path dotdot_path("/home/user/../documents");
+    vfs::Path dotdot_norm = dotdot_path.GetNormalized();
+    EXPECT_EQ(2u, dotdot_norm.ComponentCount());
+    EXPECT_EQ("home", dotdot_norm.GetComponent(0));
+    EXPECT_EQ("documents", dotdot_norm.GetComponent(1));
+
+    // Complex path with mixed . and ..
+    vfs::Path complex("/home/user/./documents/../downloads/./file.txt");
+    vfs::Path complex_norm = complex.GetNormalized();
+    EXPECT_EQ(4u, complex_norm.ComponentCount());
+    EXPECT_EQ("home", complex_norm.GetComponent(0));
+    EXPECT_EQ("user", complex_norm.GetComponent(1));
+    EXPECT_EQ("downloads", complex_norm.GetComponent(2));
+    EXPECT_EQ("file.txt", complex_norm.GetComponent(3));
+
+    // Double dot at root is ignored for absolute paths
+    vfs::Path dotdot_root("/../home");
+    vfs::Path dotdot_root_norm = dotdot_root.GetNormalized();
+    EXPECT_TRUE(dotdot_root_norm.IsAbsolute());
+    EXPECT_EQ(1u, dotdot_root_norm.ComponentCount());
+    EXPECT_EQ("home", dotdot_root_norm.GetComponent(0));
+
+    // Relative path with double dots
+    vfs::Path rel_dotdot("a/b/../c");
+    vfs::Path rel_dotdot_norm = rel_dotdot.GetNormalized();
+    EXPECT_TRUE(rel_dotdot_norm.IsRelative());
+    EXPECT_EQ(2u, rel_dotdot_norm.ComponentCount());
+    EXPECT_EQ("a", rel_dotdot_norm.GetComponent(0));
+    EXPECT_EQ("c", rel_dotdot_norm.GetComponent(1));
+
+    // Relative path going past root keeps the ..
+    vfs::Path past_root("a/../..");
+    vfs::Path past_root_norm = past_root.GetNormalized();
+    EXPECT_TRUE(past_root_norm.IsRelative());
+    EXPECT_EQ(1u, past_root_norm.ComponentCount());
+    EXPECT_EQ("..", past_root_norm.GetComponent(0));
+}
+
+// =============================================================================
+// Comparison Operators
+// =============================================================================
+
+TEST_F(VFSPathTest, PathComparison)
+{
+    // Equality
+    vfs::Path path1("/home/user");
+    vfs::Path path2("/home/user");
+    vfs::Path path3("/home/other");
+    EXPECT_TRUE(path1 == path2);
+    EXPECT_FALSE(path1 != path2);
+    EXPECT_FALSE(path1 == path3);
+    EXPECT_TRUE(path1 != path3);
+
+    // Absolute vs relative are not equal
+    vfs::Path abs("/home");
+    vfs::Path rel("home");
+    EXPECT_FALSE(abs == rel);
+
+    // Less than ordering
+    vfs::Path a("/a/b");
+    vfs::Path c("/a/c");
+    EXPECT_TRUE(a < c);
+
+    // Relative paths are "less than" absolute
+    EXPECT_TRUE(rel < abs);
+}
+
+// =============================================================================
+// Iteration
+// =============================================================================
+
+TEST_F(VFSPathTest, IteratorAndForEach)
+{
+    vfs::Path path("/home/user/documents");
+
+    // Range-based for loop
+    size_t count = 0;
+    for (const auto &p : path) {
+        (void)p;
+        ++count;
+    }
+    EXPECT_EQ(3u, count);
+
+    // Iterator values
+    auto it = path.begin();
+    EXPECT_EQ("home", *it);
+    ++it;
+    EXPECT_EQ("user", *it);
+    ++it;
+    EXPECT_EQ("documents", *it);
+    ++it;
+    EXPECT_TRUE(it == path.end());
+
+    // Empty path (root) has no components
+    vfs::Path root("/");
+    EXPECT_TRUE(root.begin() == root.end());
+
+    // ForEachComponent
+    size_t foreach_count = 0;
+    path.ForEachComponent([&](std::string_view) {
+        ++foreach_count;
+    });
+    EXPECT_EQ(3u, foreach_count);
+
+    // ForEachComponentReverse
+    vfs::Path abc("/a/b/c");
+    std::array<std::string_view, 3> expected = {"c", "b", "a"};
+    size_t idx                               = 0;
+    abc.ForEachComponentReverse([&](std::string_view component) {
+        EXPECT_EQ(expected[idx++], component);
+    });
+    EXPECT_EQ(3u, idx);
+}
+
+// =============================================================================
+// Static Methods and Constants
+// =============================================================================
+
+TEST_F(VFSPathTest, StaticMethodsAndConstants)
+{
+    // Path::Join
+    vfs::Path joined = vfs::Path::Join("/home", "user", "documents");
+    EXPECT_TRUE(joined.IsAbsolute());
+    EXPECT_EQ(3u, joined.ComponentCount());
+
+    // Static constants
+    EXPECT_EQ(1u, vfs::Path::kCurrentDir.ComponentCount());
+    EXPECT_EQ(".", vfs::Path::kCurrentDir.GetComponent(0));
+
+    EXPECT_EQ(1u, vfs::Path::kParentDir.ComponentCount());
+    EXPECT_EQ("..", vfs::Path::kParentDir.GetComponent(0));
+
+    EXPECT_TRUE(vfs::Path::kRoot.IsRoot());
+    EXPECT_TRUE(vfs::Path::kRoot.IsAbsolute());
+}
+
+// =============================================================================
+// Copy and Move Semantics
+// =============================================================================
+
+TEST_F(VFSPathTest, CopyAndMoveSemantics)
+{
+    vfs::Path original("/home/user/documents");
+
+    // Copy construction
+    vfs::Path copy_constructed(original);
+    EXPECT_EQ(original, copy_constructed);
+    EXPECT_EQ(3u, copy_constructed.ComponentCount());
+
+    // Copy assignment
+    vfs::Path copy_assigned;
+    copy_assigned = original;
+    EXPECT_EQ(original, copy_assigned);
+
+    // Move construction
+    vfs::Path to_move1("/home/user/documents");
+    vfs::Path move_constructed(std::move(to_move1));
+    EXPECT_EQ(3u, move_constructed.ComponentCount());
+    EXPECT_EQ("home", move_constructed.GetComponent(0));
+
+    // Move assignment
+    vfs::Path to_move2("/home/user/documents");
+    vfs::Path move_assigned;
+    move_assigned = std::move(to_move2);
+    EXPECT_EQ(3u, move_assigned.ComponentCount());
+}
+
+// =============================================================================
+// String Access and Edge Cases
+// =============================================================================
+
+TEST_F(VFSPathTest, StringAccessAndEdgeCases)
+{
+    vfs::Path path("/home/user");
+
+    // StringView access
+    std::string_view sv = path.StringView();
+    EXPECT_EQ("/home/user", sv);
+
+    // CString access
+    const char *cstr = path.CString();
+    EXPECT_STREQ("/home/user", cstr);
+
+    // Out of bounds component access returns empty
+    EXPECT_TRUE(path.GetComponent(100).empty());
+    EXPECT_TRUE(path[100].empty());
+}
diff --git a/kernel/test/vfs/vfs_module_test.cpp b/kernel/test/vfs/vfs_module_test.cpp
new file mode 100644
index 00000000..56ffd529
--- /dev/null
+++ b/kernel/test/vfs/vfs_module_test.cpp
@@ -0,0 +1,559 @@
+#include <test_module/test.hpp>
+
+#include <string.h>
+#include <mem/heap.hpp>
+#include <memory.hpp>
+#include <modules/vfs.hpp>
+#include <vfs/fat/fat12.hpp>
+#include <vfs/io/in_memory.hpp>
+#include <vfs/path.hpp>
+
+class VfsFat12ImageHelper
+{
+    public:
+    static constexpr size_t kSectorSize        = 512;
+    static constexpr size_t kSectorsPerCluster = 1;
+    static constexpr size_t kReservedSectors   = 1;
+    static constexpr size_t kNumberOfFats      = 2;
+    static constexpr size_t kRootDirEntries    = 16;
+    static constexpr size_t kFatSizeSectors    = 1;
+    static constexpr size_t kTotalSectors      = 64;
+
+    static constexpr size_t kFatRegionStart = kReservedSectors;
+    static constexpr size_t kRootDirStart   = kReservedSectors + kNumberOfFats * kFatSizeSectors;
+    static constexpr size_t kRootDirSectors =
+        (kRootDirEntries * 32 + kSectorSize - 1) / kSectorSize;
+    static constexpr size_t kDataRegionStart = kRootDirStart + kRootDirSectors;
+    static constexpr size_t kImageSize       = kTotalSectors * kSectorSize;
+
+    static void CreateMinimalImage(byte *image)
+    {
+        memset(image, 0, kImageSize);
+        CreateBootSector(image);
+        CreateFatTables(image);
+        CreateRootDirectory(image);
+    }
+
+    private:
+    static void CreateBootSector(byte *image)
+    {
+        image[0] = 0xEB;
+        image[1] = 0x3C;
+        image[2] = 0x90;
+        memcpy(image + 3, "MSDOS5.0", 8);
+        *reinterpret_cast<u16 *>(image + 11) = kSectorSize;
+        image[13]                            = kSectorsPerCluster;
+        *reinterpret_cast<u16 *>(image + 14) = kReservedSectors;
+        image[16]                            = kNumberOfFats;
+        *reinterpret_cast<u16 *>(image + 17) = kRootDirEntries;
+        *reinterpret_cast<u16 *>(image + 19) = kTotalSectors;
+        image[21]                            = 0xF8;
+        *reinterpret_cast<u16 *>(image + 22) = kFatSizeSectors;
+        *reinterpret_cast<u16 *>(image + 24) = 18;
+        *reinterpret_cast<u16 *>(image + 26) = 2;
+        *reinterpret_cast<u32 *>(image + 28) = 0;
+        *reinterpret_cast<u32 *>(image + 32) = 0;
+        image[36]                            = 0x80;
+        image[38]                            = 0x29;
+        *reinterpret_cast<u32 *>(image + 39) = 0x12345678;
+        memcpy(image + 43, "TEST VOLUME", 11);
+        memcpy(image + 54, "FAT12   ", 8);
+        image[510] = 0x55;
+        image[511] = 0xAA;
+    }
+
+    static void CreateFatTables(byte *image)
+    {
+        byte *fat1 = image + kFatRegionStart * kSectorSize;
+        memset(fat1, 0, kFatSizeSectors * kSectorSize);
+        fat1[0]    = 0xF8;
+        fat1[1]    = 0xFF;
+        fat1[2]    = 0xFF;
+        byte *fat2 = image + (kFatRegionStart + kFatSizeSectors) * kSectorSize;
+        memcpy(fat2, fat1, kFatSizeSectors * kSectorSize);
+    }
+
+    static void CreateRootDirectory(byte *image)
+    {
+        byte *root_dir = image + kRootDirStart * kSectorSize;
+        memset(root_dir, 0, kRootDirSectors * kSectorSize);
+        memcpy(root_dir, "TEST VOLUME", 11);
+        root_dir[11] = 0x08;
+    }
+};
+
+class VfsModuleTest : public TestGroupBase
+{
+    protected:
+    alignas(16) byte disk_image_[VfsFat12ImageHelper::kImageSize];
+    vfs::io::InMemory *io_{nullptr};
+    vfs::Fat12<vfs::io::InMemory> *fat12_{nullptr};
+
+    void Setup_() override
+    {
+        VfsFat12ImageHelper::CreateMinimalImage(disk_image_);
+
+        io_ = Mem::KMalloc<vfs::io::InMemory>().value_or(nullptr);
+        EXPECT_NOT_NULL(io_);
+        std::construct_at<vfs::io::InMemory>(io_, disk_image_, VfsFat12ImageHelper::kSectorSize);
+
+        fat12_ = Mem::KMalloc<vfs::Fat12<vfs::io::InMemory>>().value_or(nullptr);
+        EXPECT_NOT_NULL(fat12_);
+        std::construct_at<vfs::Fat12<vfs::io::InMemory>>(fat12_, *io_);
+    }
+
+    void TearDown_() override
+    {
+        vfs::Unmount(vfs::Path("/"));
+
+        std::destroy_at(fat12_);
+        Mem::KFree(fat12_);
+
+        std::destroy_at(io_);
+        Mem::KFree(io_);
+    }
+};
+
+// =============================================================================
+// Mount/Unmount Tests
+// =============================================================================
+
+TEST_F(VfsModuleTest, MountFilesystemAtRoot)
+{
+    auto fs     = fat12_->GetFilesystem();
+    auto result = vfs::Mount(vfs::Path("/"), {}, fs);
+    EXPECT_TRUE(result.has_value());
+}
+
+TEST_F(VfsModuleTest, MountFailsForEmptyPath)
+{
+    auto fs     = fat12_->GetFilesystem();
+    auto result = vfs::Mount(vfs::Path(""), {}, fs);
+    EXPECT_FALSE(result.has_value());
+    EXPECT_EQ(vfs::VfsError::kInvalidPath, result.error());
+}
+
+TEST_F(VfsModuleTest, MountFailsForRelativePath)
+{
+    auto fs     = fat12_->GetFilesystem();
+    auto result = vfs::Mount(vfs::Path("relative/path"), {}, fs);
+    EXPECT_FALSE(result.has_value());
+    EXPECT_EQ(vfs::VfsError::kInvalidPath, result.error());
+}
+
+TEST_F(VfsModuleTest, MountFailsIfAlreadyMounted)
+{
+    auto fs = fat12_->GetFilesystem();
+
+    auto result1 = vfs::Mount(vfs::Path("/"), {}, fs);
+    EXPECT_TRUE(result1.has_value());
+
+    auto result2 = vfs::Mount(vfs::Path("/"), {}, fs);
+    EXPECT_FALSE(result2.has_value());
+    EXPECT_EQ(vfs::VfsError::kAlreadyMounted, result2.error());
+}
+
+TEST_F(VfsModuleTest, UnmountSucceeds)
+{
+    auto fs = fat12_->GetFilesystem();
+    vfs::Mount(vfs::Path("/"), {}, fs);
+
+    auto result = vfs::Unmount(vfs::Path("/"));
+    EXPECT_TRUE(result.has_value());
+}
+
+TEST_F(VfsModuleTest, UnmountFailsIfNotMounted)
+{
+    auto result = vfs::Unmount(vfs::Path("/mnt/notmounted"));
+    EXPECT_FALSE(result.has_value());
+    EXPECT_EQ(vfs::VfsError::kNotMounted, result.error());
+}
+
+// =============================================================================
+// File Operations Through VFS
+// =============================================================================
+
+TEST_F(VfsModuleTest, CreateFileViaVfs)
+{
+    auto fs = fat12_->GetFilesystem();
+    vfs::Mount(vfs::Path("/"), {}, fs);
+
+    auto result = vfs::CreateFile(vfs::Path("/TEST.TXT"));
+    EXPECT_TRUE(result.has_value());
+}
+
+TEST_F(VfsModuleTest, FileExistsViaVfs)
+{
+    auto fs = fat12_->GetFilesystem();
+    vfs::Mount(vfs::Path("/"), {}, fs);
+
+    vfs::CreateFile(vfs::Path("/EXISTS.TXT"));
+
+    auto result = vfs::FileExists(vfs::Path("/EXISTS.TXT"));
+    EXPECT_TRUE(result.has_value());
+    EXPECT_TRUE(result.value());
+}
+
+TEST_F(VfsModuleTest, FileNotExistsViaVfs)
+{
+    auto fs = fat12_->GetFilesystem();
+    vfs::Mount(vfs::Path("/"), {}, fs);
+
+    auto result = vfs::FileExists(vfs::Path("/NOTHERE.TXT"));
+    EXPECT_TRUE(result.has_value());
+    EXPECT_FALSE(result.value());
+}
+
+TEST_F(VfsModuleTest, WriteAndReadFileViaVfs)
+{
+    auto fs = fat12_->GetFilesystem();
+    vfs::Mount(vfs::Path("/"), {}, fs);
+
+    vfs::Path path("/DATA.TXT");
+    vfs::CreateFile(path);
+
+    const char *test_data = "Hello VFS!";
+    size_t data_len       = strlen(test_data);
+
+    auto write_result = vfs::WriteFile(path, test_data, data_len);
+    EXPECT_TRUE(write_result.has_value());
+    EXPECT_EQ(data_len, write_result.value());
+
+    char buffer[64]  = {0};
+    auto read_result = vfs::ReadFile(path, buffer, sizeof(buffer));
+    EXPECT_TRUE(read_result.has_value());
+    EXPECT_EQ(data_len, read_result.value());
+    EXPECT_STREQ(test_data, buffer);
+}
+
+TEST_F(VfsModuleTest, DeleteFileViaVfs)
+{
+    auto fs = fat12_->GetFilesystem();
+    vfs::Mount(vfs::Path("/"), {}, fs);
+
+    vfs::Path path("/TODEL.TXT");
+    vfs::CreateFile(path);
+
+    auto delete_result = vfs::DeleteFile(path);
+    EXPECT_TRUE(delete_result.has_value());
+
+    auto exists_result = vfs::FileExists(path);
+    EXPECT_TRUE(exists_result.has_value());
+    EXPECT_FALSE(exists_result.value());
+}
+
+TEST_F(VfsModuleTest, GetFileSizeViaVfs)
+{
+    auto fs = fat12_->GetFilesystem();
+    vfs::Mount(vfs::Path("/"), {}, fs);
+
+    vfs::Path path("/SIZE.TXT");
+    vfs::CreateFile(path);
+
+    const char *data = "1234567890";
+    vfs::WriteFile(path, data, 10);
+
+    auto result = vfs::GetFileSize(path);
+    EXPECT_TRUE(result.has_value());
+    EXPECT_EQ(10u, result.value());
+}
+
+// =============================================================================
+// Directory Operations Through VFS
+// =============================================================================
+
+TEST_F(VfsModuleTest, CreateDirectoryViaVfs)
+{
+    auto fs = fat12_->GetFilesystem();
+    vfs::Mount(vfs::Path("/"), {}, fs);
+
+    auto result = vfs::CreateDirectory(vfs::Path("/TESTDIR"));
+    EXPECT_TRUE(result.has_value());
+}
+
+TEST_F(VfsModuleTest, DirectoryExistsViaVfs)
+{
+    auto fs = fat12_->GetFilesystem();
+    vfs::Mount(vfs::Path("/"), {}, fs);
+
+    vfs::CreateDirectory(vfs::Path("/MYDIR"));
+
+    auto result = vfs::DirectoryExists(vfs::Path("/MYDIR"));
+    EXPECT_TRUE(result.has_value());
+    EXPECT_TRUE(result.value());
+}
+
+TEST_F(VfsModuleTest, RootDirectoryExists)
+{
+    auto fs = fat12_->GetFilesystem();
+    vfs::Mount(vfs::Path("/"), {}, fs);
+
+    auto result = vfs::DirectoryExists(vfs::Path("/"));
+    EXPECT_TRUE(result.has_value());
+    EXPECT_TRUE(result.value());
+}
+
+TEST_F(VfsModuleTest, RemoveDirectoryViaVfs)
+{
+    auto fs = fat12_->GetFilesystem();
+    vfs::Mount(vfs::Path("/"), {}, fs);
+
+    vfs::Path path("/RMDIR");
+    vfs::CreateDirectory(path);
+
+    auto remove_result = vfs::RemoveDirectory(path);
+    EXPECT_TRUE(remove_result.has_value());
+
+    auto exists_result = vfs::DirectoryExists(path);
+    EXPECT_TRUE(exists_result.has_value());
+    EXPECT_FALSE(exists_result.value());
+}
+
+TEST_F(VfsModuleTest, ListDirectoryViaVfs)
+{
+    auto fs = fat12_->GetFilesystem();
+    vfs::Mount(vfs::Path("/"), {}, fs);
+
+    vfs::CreateFile(vfs::Path("/FILE1.TXT"));
+    vfs::CreateFile(vfs::Path("/FILE2.TXT"));
+    vfs::CreateDirectory(vfs::Path("/SUBDIR"));
+
+    int file_count = 0;
+    int dir_count  = 0;
+
+    vfs::ListDirectory(vfs::Path("/"), [&](const char *, bool is_dir) {
+        if (is_dir) {
+            ++dir_count;
+        } else {
+            ++file_count;
+        }
+    });
+
+    EXPECT_EQ(2, file_count);
+    EXPECT_EQ(1, dir_count);
+}
+
+// =============================================================================
+// General Operations Through VFS
+// =============================================================================
+
+TEST_F(VfsModuleTest, ExistsForFile)
+{
+    auto fs = fat12_->GetFilesystem();
+    vfs::Mount(vfs::Path("/"), {}, fs);
+
+    vfs::CreateFile(vfs::Path("/FILE.TXT"));
+
+    auto result = vfs::Exists(vfs::Path("/FILE.TXT"));
+    EXPECT_TRUE(result.has_value());
+    EXPECT_TRUE(result.value());
+}
+
+TEST_F(VfsModuleTest, ExistsForDirectory)
+{
+    auto fs = fat12_->GetFilesystem();
+    vfs::Mount(vfs::Path("/"), {}, fs);
+
+    vfs::CreateDirectory(vfs::Path("/DIR"));
+
+    auto result = vfs::Exists(vfs::Path("/DIR"));
+    EXPECT_TRUE(result.has_value());
+    EXPECT_TRUE(result.value());
+}
+
+TEST_F(VfsModuleTest, ExistsForNonExistent)
+{
+    auto fs = fat12_->GetFilesystem();
+    vfs::Mount(vfs::Path("/"), {}, fs);
+
+    auto result = vfs::Exists(vfs::Path("/NOTHERE"));
+    EXPECT_TRUE(result.has_value());
+    EXPECT_FALSE(result.value());
+}
+
+TEST_F(VfsModuleTest, MoveFileViaVfs)
+{
+    auto fs = fat12_->GetFilesystem();
+    vfs::Mount(vfs::Path("/"), {}, fs);
+
+    vfs::Path old_path("/OLD.TXT");
+    vfs::Path new_path("/NEW.TXT");
+
+    vfs::CreateFile(old_path);
+
+    auto move_result = vfs::Move(old_path, new_path);
+    EXPECT_TRUE(move_result.has_value());
+
+    auto old_exists = vfs::Exists(old_path);
+    EXPECT_TRUE(old_exists.has_value());
+    EXPECT_FALSE(old_exists.value());
+
+    auto new_exists = vfs::Exists(new_path);
+    EXPECT_TRUE(new_exists.has_value());
+    EXPECT_TRUE(new_exists.value());
+}
+
+// =============================================================================
+// Read-Only Mount Tests
+// =============================================================================
+
+TEST_F(VfsModuleTest, ReadOnlyMountBlocksWrite)
+{
+    auto fs = fat12_->GetFilesystem();
+    vfs::MountOptions opts{.read_only = true};
+    vfs::Mount(vfs::Path("/"), opts, fs);
+
+    auto result = vfs::CreateFile(vfs::Path("/TEST.TXT"));
+    EXPECT_FALSE(result.has_value());
+    EXPECT_EQ(vfs::VfsError::kReadOnly, result.error());
+}
+
+TEST_F(VfsModuleTest, ReadOnlyMountAllowsRead)
+{
+    // First mount as writable to create a file
+    auto fs = fat12_->GetFilesystem();
+    vfs::Mount(vfs::Path("/"), {}, fs);
+    vfs::CreateFile(vfs::Path("/READ.TXT"));
+    vfs::WriteFile(vfs::Path("/READ.TXT"), "data", 4);
+    vfs::Unmount(vfs::Path("/"));
+
+    // Now mount as read-only
+    vfs::MountOptions opts{.read_only = true};
+    vfs::Mount(vfs::Path("/"), opts, fs);
+
+    char buffer[10] = {0};
+    auto result     = vfs::ReadFile(vfs::Path("/READ.TXT"), buffer, 4);
+    EXPECT_TRUE(result.has_value());
+    EXPECT_EQ(4u, result.value());
+}
+
+// =============================================================================
+// Error Handling Tests
+// =============================================================================
+
+TEST_F(VfsModuleTest, OperationFailsWithoutMount)
+{
+    auto result = vfs::CreateFile(vfs::Path("/TEST.TXT"));
+    EXPECT_FALSE(result.has_value());
+    EXPECT_EQ(vfs::VfsError::kMountPointNotFound, result.error());
+}
+
+TEST_F(VfsModuleTest, ReadNonExistentFile)
+{
+    auto fs = fat12_->GetFilesystem();
+    vfs::Mount(vfs::Path("/"), {}, fs);
+
+    char buffer[10];
+    auto result = vfs::ReadFile(vfs::Path("/NOFILE.TXT"), buffer, 10);
+    EXPECT_FALSE(result.has_value());
+    EXPECT_EQ(vfs::VfsError::kFileNotFound, result.error());
+}
+
+// =============================================================================
+// Complex Scenario Tests
+// =============================================================================
+
+TEST_F(VfsModuleTest, CreateAndListMultipleFilesAndDirectories)
+{
+    auto fs = fat12_->GetFilesystem();
+    vfs::Mount(vfs::Path("/"), {}, fs);
+
+    vfs::CreateFile(vfs::Path("/FILE1.TXT"));
+    vfs::CreateFile(vfs::Path("/FILE2.TXT"));
+    vfs::CreateDirectory(vfs::Path("/DIR1"));
+    vfs::CreateDirectory(vfs::Path("/DIR2"));
+
+    int file_count = 0;
+    int dir_count  = 0;
+
+    vfs::ListDirectory(vfs::Path("/"), [&](const char *, bool is_dir) {
+        if (is_dir) {
+            ++dir_count;
+        } else {
+            ++file_count;
+        }
+    });
+
+    EXPECT_EQ(2, file_count);
+    EXPECT_EQ(2, dir_count);
+}
+
+TEST_F(VfsModuleTest, MoveDirectoryWithContents)
+{
+    auto fs = fat12_->GetFilesystem();
+    vfs::Mount(vfs::Path("/"), {}, fs);
+
+    vfs::CreateDirectory(vfs::Path("/OLDDIR"));
+    vfs::CreateFile(vfs::Path("/OLDDIR/FILE.TXT"));
+
+    // Write some data to the file
+    vfs::WriteFile(vfs::Path("/OLDDIR/FILE.TXT"), "Sample Data", 11);
+
+    auto move_result = vfs::Move(vfs::Path("/OLDDIR"), vfs::Path("/NEWDIR"));
+    EXPECT_TRUE(move_result.has_value());
+
+    auto old_exists = vfs::Exists(vfs::Path("/OLDDIR"));
+    EXPECT_TRUE(old_exists.has_value());
+    EXPECT_FALSE(old_exists.value());
+
+    auto new_exists = vfs::Exists(vfs::Path("/NEWDIR"));
+    EXPECT_TRUE(new_exists.has_value());
+    EXPECT_TRUE(new_exists.value());
+
+    auto file_exists = vfs::Exists(vfs::Path("/NEWDIR/FILE.TXT"));
+    EXPECT_TRUE(file_exists.has_value());
+    EXPECT_TRUE(file_exists.value());
+
+    char buffer[20]  = {0};
+    auto read_result = vfs::ReadFile(vfs::Path("/NEWDIR/FILE.TXT"), buffer, sizeof(buffer));
+    EXPECT_TRUE(read_result.has_value());
+    EXPECT_EQ(11u, read_result.value());
+    EXPECT_STREQ("Sample Data", buffer);
+}
+
+TEST_F(VfsModuleTest, DeleteFileThenDirectory)
+{
+    auto fs = fat12_->GetFilesystem();
+    vfs::Mount(vfs::Path("/"), {}, fs);
+
+    vfs::CreateDirectory(vfs::Path("/DIR"));
+    vfs::CreateFile(vfs::Path("/DIR/FILE.TXT"));
+
+    auto delete_file_result = vfs::DeleteFile(vfs::Path("/DIR/FILE.TXT"));
+    EXPECT_TRUE(delete_file_result.has_value());
+
+    auto delete_dir_result = vfs::RemoveDirectory(vfs::Path("/DIR"));
+    EXPECT_TRUE(delete_dir_result.has_value());
+
+    auto dir_exists = vfs::DirectoryExists(vfs::Path("/DIR"));
+    EXPECT_TRUE(dir_exists.has_value());
+    EXPECT_FALSE(dir_exists.value());
+}
+
+TEST_F(VfsModuleTest, MountMultipleFilesystemsAtDifferentPaths)
+{
+    auto fs1 = fat12_->GetFilesystem();
+    vfs::Mount(vfs::Path("/mnt/fs1"), {}, fs1);
+
+    auto fs2 = fat12_->GetFilesystem();
+    vfs::Mount(vfs::Path("/mnt/fs2"), {}, fs2);
+
+    vfs::CreateFile(vfs::Path("/mnt/fs1/FILE1.TXT"));
+    vfs::CreateFile(vfs::Path("/mnt/fs2/FILE2.TXT"));
+
+    auto exists1 = vfs::Exists(vfs::Path("/mnt/fs1/FILE1.TXT"));
+    EXPECT_TRUE(exists1.has_value());
+    EXPECT_TRUE(exists1.value());
+
+    auto exists2 = vfs::Exists(vfs::Path("/mnt/fs1/FILE2.TXT"));
+    EXPECT_TRUE(exists2.has_value());
+    EXPECT_TRUE(exists2.value());
+
+    auto exists3 = vfs::Exists(vfs::Path("/mnt/fs2/FILE1.TXT"));
+    EXPECT_TRUE(exists3.has_value());
+    EXPECT_TRUE(exists3.value());
+
+    auto exists4 = vfs::Exists(vfs::Path("/mnt/fs2/FILE2.TXT"));
+    EXPECT_TRUE(exists4.has_value());
+    EXPECT_TRUE(exists4.value());
+}
diff --git a/libs/libc/include/defines.h b/libs/libc/include/defines.h
index b524c638..de6fa2c3 100644
--- a/libs/libc/include/defines.h
+++ b/libs/libc/include/defines.h
@@ -1,5 +1,5 @@
-#ifndef ALKOS_LIBC_INCLUDE_DEFINES_H_
-#define ALKOS_LIBC_INCLUDE_DEFINES_H_
+#ifndef LIBS_LIBC_INCLUDE_DEFINES_H_
+#define LIBS_LIBC_INCLUDE_DEFINES_H_
 
 // ------------------------------
 // C++ defines
@@ -42,6 +42,9 @@ static constexpr bool kIsKernel = false;
 /* Marks a function for a compiler to prevent any optimizations */
 #define NO_OPT __attribute__((optimize("O0")))
 
+/* Marks a function or variable as unused */
+#define UNUSED __attribute__((unused))
+
 // ------------------------------
 // Useful macros
 // ------------------------------
@@ -52,9 +55,18 @@ static constexpr bool kIsKernel = false;
 /* Apply STRINGIFY to expand macros before conversion */
 #define TOSTRING(x) STRINGIFY(x)
 
+/* Concatenate two tokens */
+#define CONCAT_IMPL(a, b) a##b
+
+/* Apply CONCAT_IMPL to expand macros before concatenation */
+#define CONCAT(a, b) CONCAT_IMPL(a, b)
+
 /* Creates a COMPILER LEVEL memory barrier forcing optimizer to not re-order memory accesses */
 #define BARRIER() __asm__ volatile("" : : : "memory")
 
+/* Create reserved structure member */
+#define RESERVED(size) byte CONCAT(__reserved_, __COUNTER__)[size] UNUSED
+
 // ------------------------------
 // Lang specific defines
 // ------------------------------
@@ -75,4 +87,4 @@ static constexpr bool kIsKernel = false;
 #define CONSTEXPR static inline
 #endif  // __cplusplus
 
-#endif  // ALKOS_LIBC_INCLUDE_DEFINES_H_
+#endif  // LIBS_LIBC_INCLUDE_DEFINES_H_
diff --git a/libs/libc/internal/defines.cpp b/libs/libc/internal/defines.cpp
new file mode 100644
index 00000000..06021804
--- /dev/null
+++ b/libs/libc/internal/defines.cpp
@@ -0,0 +1,14 @@
+#include <compare.hpp>
+#include <defines.hpp>
+
+template <size_t ID, size_t OtherID>
+constexpr bool operator==(empty_t<ID>, empty_t<OtherID>) noexcept
+{
+    return true;
+}
+
+template <size_t ID, size_t OtherID>
+constexpr std::strong_ordering operator<=>(empty_t<ID>, empty_t<OtherID>) noexcept
+{
+    return std::strong_ordering::equal;
+}
diff --git a/libs/libcpp/include/internal/math.hpp b/libs/libcpp/include/internal/math.hpp
new file mode 100644
index 00000000..fa272560
--- /dev/null
+++ b/libs/libcpp/include/internal/math.hpp
@@ -0,0 +1,27 @@
+#ifndef LIBS_LIBCPP_INCLUDE_INTERNAL_MATH_HPP_
+#define LIBS_LIBCPP_INCLUDE_INTERNAL_MATH_HPP_
+
+#include <defines.hpp>
+#include <type_traits.hpp>
+
+namespace internal
+{
+template <typename Dividend, typename Divisor>
+NODISCARD FORCE_INLINE_F constexpr auto DivRoundUp(Dividend x, Divisor y)
+{
+    if constexpr (std::is_unsigned_v<Dividend> && std::is_unsigned_v<Divisor>) {
+        return (x + y - 1) / y;  // uint / uint
+    } else if constexpr (std::is_signed_v<Dividend> && std::is_unsigned_v<Divisor>) {
+        auto sy = static_cast<std::make_signed_t<Divisor>>(y);
+        return x / sy + (x % sy != 0 && x >= 0);  // int / uint
+    } else if constexpr (std::is_unsigned_v<Dividend> && std::is_signed_v<Divisor>) {
+        auto sx = static_cast<std::make_signed_t<Dividend>>(x);
+        return sx / y + (sx % y != 0 && y >= 0);  // uint / int
+    } else {
+        return x / y + (x % y != 0 && (y >= 0) == (x >= 0));  // int / int
+    }
+}
+
+}  // namespace internal
+
+#endif  // LIBS_LIBCPP_INCLUDE_INTERNAL_MATH_HPP_
diff --git a/libs/libcpp/include/internal/span.hpp b/libs/libcpp/include/internal/span.hpp
new file mode 100644
index 00000000..86d45d65
--- /dev/null
+++ b/libs/libcpp/include/internal/span.hpp
@@ -0,0 +1,28 @@
+#ifndef LIBS_LIBCPP_INCLUDE_INTERNAL_SPAN_HPP_
+#define LIBS_LIBCPP_INCLUDE_INTERNAL_SPAN_HPP_
+
+#include <assert.h>
+#include <span.hpp>
+
+namespace internal
+{
+
+template <class T, class U, std::size_t N>
+    requires std::is_trivial_v<T> && std::is_standard_layout_v<T> && (!std::is_const_v<U>)
+auto &get(std::span<U, N> s, size_t offset = 0)
+{
+    ASSERT_LE(offset + sizeof(T), s.size_bytes(), "Offset out of bounds");
+    return *reinterpret_cast<T *>(std::as_writable_bytes(s).data() + offset);
+}
+
+template <class T, class U, std::size_t N>
+    requires std::is_trivial_v<T> && std::is_standard_layout_v<T> && std::is_const_v<U>
+const T &get(std::span<U, N> s, size_t offset = 0)
+{
+    ASSERT_LE(offset + sizeof(T), s.size_bytes(), "Offset out of bounds");
+    return *reinterpret_cast<const T *>(std::as_bytes(s).data() + offset);
+}
+
+}  // namespace internal
+
+#endif  // LIBS_LIBCPP_INCLUDE_INTERNAL_SPAN_HPP_
diff --git a/libs/libcpp/include/span.hpp b/libs/libcpp/include/span.hpp
index 2aa0533a..fd012228 100644
--- a/libs/libcpp/include/span.hpp
+++ b/libs/libcpp/include/span.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_LIBC_INCLUDE_EXTENSIONS_SPAN_HPP_
-#define ALKOS_LIBC_INCLUDE_EXTENSIONS_SPAN_HPP_
+#ifndef LIBS_LIBCPP_INCLUDE_SPAN_HPP_
+#define LIBS_LIBCPP_INCLUDE_SPAN_HPP_
 
 #include <assert.h>
 #include <stdint.h>
@@ -363,7 +363,7 @@ class span
     // ------------------------------
     // Data members
     // ------------------------------
-    NO_UNIQUE_ADDRESS pointer data_;
+    pointer data_;
     NO_UNIQUE_ADDRESS std::conditional_t<is_dynamic_extent_, size_type, UNIQUE_EMPTY> size_;
 };
 
@@ -392,4 +392,4 @@ FORCE_INLINE_F constexpr auto as_writable_bytes(std::span<T, N> s) noexcept
 
 }  // namespace std
 
-#endif  // ALKOS_LIBC_INCLUDE_EXTENSIONS_SPAN_HPP_
+#endif  // LIBS_LIBCPP_INCLUDE_SPAN_HPP_
diff --git a/libs/libtemplate/include/template/array_utils.hpp b/libs/libtemplate/include/template/array_utils.hpp
new file mode 100644
index 00000000..c206fafe
--- /dev/null
+++ b/libs/libtemplate/include/template/array_utils.hpp
@@ -0,0 +1,72 @@
+#ifndef LIBS_LIBTEMPLATE_INCLUDE_TEMPLATE_ARRAY_UTILS_HPP_
+#define LIBS_LIBTEMPLATE_INCLUDE_TEMPLATE_ARRAY_UTILS_HPP_
+
+#include <cstddef.hpp>
+
+namespace template_lib
+{
+// ------------------------------
+// ArrayHolder
+// ------------------------------
+
+template <typename T, T... args>
+struct ArrayHolder {
+    static constexpr T data[sizeof...(args)] = {args...};
+};
+
+template <typename T, T... args>
+constexpr T ArrayHolder<T, args...>::data[sizeof...(args)];
+
+template <typename T, typename Pack1, typename Pack2>
+struct ConcatenateArrays;
+
+template <typename T, T... pack1_args, T... pack2_args>
+struct ConcatenateArrays<T, ArrayHolder<T, pack1_args...>, ArrayHolder<T, pack2_args...>> {
+    using type = ArrayHolder<T, pack1_args..., pack2_args...>;
+};
+
+// ------------------------------
+// MakeUniformArray
+// ------------------------------
+
+template <typename T, T value, size_t N, T... args>
+struct MakeUniformArray {
+    using type = typename MakeUniformArray<T, value, N - 1, args..., value>::type;
+};
+
+template <typename T, T value, T... args>
+struct MakeUniformArray<T, value, 0, args...> {
+    using type = ArrayHolder<T, args...>;
+};
+
+template <typename T, T fill, size_t N>
+using uniform_array_t = typename MakeUniformArray<T, fill, N>::type;
+
+template <typename T, T fill, size_t N>
+constexpr auto uniform_array_v = uniform_array_t<T, fill, N>::data;
+
+// ------------------------------
+// MakeFilledArray
+// ------------------------------
+
+template <typename T, size_t N, T fill, T... args>
+struct MakeFilledArray {
+    static_assert(sizeof...(args) <= N, "Too many initial arguments for array size");
+
+    private:
+    using initial_array = ArrayHolder<T, args...>;
+    using uniform_array = typename MakeUniformArray<T, fill, N - sizeof...(args)>::type;
+
+    public:
+    using type = typename ConcatenateArrays<T, initial_array, uniform_array>::type;
+};
+
+template <typename T, size_t N, T fill, T... args>
+using fill_array_t = typename MakeFilledArray<T, N, fill, args...>::type;
+
+template <typename T, size_t N, T fill, T... args>
+constexpr auto fill_array_v = fill_array_t<T, N, fill, args...>::data;
+
+}  // namespace template_lib
+
+#endif  // LIBS_LIBTEMPLATE_INCLUDE_TEMPLATE_ARRAY_UTILS_HPP_
diff --git a/libs/libtemplate/include/template_lib.hpp b/libs/libtemplate/include/template_lib.hpp
index da3f2a13..2a892b22 100644
--- a/libs/libtemplate/include/template_lib.hpp
+++ b/libs/libtemplate/include/template_lib.hpp
@@ -1,6 +1,7 @@
 #ifndef LIBS_LIBTEMPLATE_INCLUDE_TEMPLATE_LIB_HPP_
 #define LIBS_LIBTEMPLATE_INCLUDE_TEMPLATE_LIB_HPP_
 
+#include <template/array_utils.hpp>
 #include <template/rolled_switch.hpp>
 #include <template/special_members.hpp>
 #include <template/static_singleton.hpp>

From 8d612f19d82ab56a369404b75f88b8012959ce8a Mon Sep 17 00:00:00 2001
From: Adam Ogieniewski <ogieniewski.dev@gmail.com>
Date: Thu, 11 Dec 2025 07:59:57 +0100
Subject: [PATCH 08/56] Add ramdisk support and shell commands (#232)

Bootloader now locates and passes ramdisk information to the kernel.
The VFS module mounts the FAT12 ramdisk at the root filesystem.
Introduces 'cd', 'ls', 'cat', and 'pwd' commands to the kernel shell for
basic filesystem interaction.
---
 .../x86_64/boot/lib/abi/transition_data.hpp   |   6 +-
 kernel/arch/x86_64/boot/lib/elf/elf_64.cpp    |   2 +-
 .../arch/x86_64/boot/loader_64/src/main.cpp   |  33 +++
 kernel/arch/x86_64/boot/settings/settings.hpp |   1 +
 kernel/src/boot_args.cpp                      |   9 +
 kernel/src/boot_args.hpp                      |   6 +
 kernel/src/hal/api/boot_args.hpp              |   4 +
 kernel/src/init.cpp                           |   2 +-
 kernel/src/modules/vfs.cpp                    |  41 +++-
 kernel/src/modules/vfs.hpp                    |   3 +-
 kernel/src/sys/shell.cpp                      | 203 +++++++++++++++++-
 kernel/src/sys/shell.hpp                      |  12 ++
 kernel/src/trace.cpp                          |   2 +
 kernel/src/trace_framework.hpp                |   6 +-
 kernel/test/vfs/vfs_module_test.cpp           |   2 +
 rootfs/overlay/docs/greet.txt                 |   1 +
 rootfs/overlay/file.txt                       |   1 -
 rootfs/overlay/lorem.txt                      |   1 +
 18 files changed, 322 insertions(+), 13 deletions(-)
 create mode 100644 rootfs/overlay/docs/greet.txt
 delete mode 100644 rootfs/overlay/file.txt
 create mode 100644 rootfs/overlay/lorem.txt

diff --git a/kernel/arch/x86_64/boot/lib/abi/transition_data.hpp b/kernel/arch/x86_64/boot/lib/abi/transition_data.hpp
index 8944153e..10972d28 100644
--- a/kernel/arch/x86_64/boot/lib/abi/transition_data.hpp
+++ b/kernel/arch/x86_64/boot/lib/abi/transition_data.hpp
@@ -17,7 +17,7 @@ struct alignas(64) TransitionData {
     alignas(64) VirtualMemoryManager::VmmState vmm_state;
 };
 
-struct PACK alignas(64) KernelArguments {
+struct alignas(64) KernelArguments {
     /// Kernel Mem Layout
     u64 kernel_start_addr;
     u64 kernel_end_addr;
@@ -44,6 +44,10 @@ struct PACK alignas(64) KernelArguments {
     u8 fb_blue_pos;
     u8 fb_blue_mask;
 
+    /// Ramdisk
+    u64 ramdisk_start;
+    u64 ramdisk_end;
+
     /// Multiboot
     u64 multiboot_info_addr;
     u64 multiboot_header_start_addr;
diff --git a/kernel/arch/x86_64/boot/lib/elf/elf_64.cpp b/kernel/arch/x86_64/boot/lib/elf/elf_64.cpp
index 75e80390..2711da0e 100644
--- a/kernel/arch/x86_64/boot/lib/elf/elf_64.cpp
+++ b/kernel/arch/x86_64/boot/lib/elf/elf_64.cpp
@@ -51,7 +51,7 @@ std::expected<u64, Error> Load(const byte *elf_ptr, u64 destination_addr)
             const u64 segment_source_size = program_header_entry->size_in_file_bytes;
 
             TRACE_INFO(
-                "Segment %d: dest=0x%llX, dest_size=0x%sB, source=0x%llX, source_size=0x%sB", i + 1,
+                "Segment %d: dest=0x%llX, dest_size=%sB, source=0x%llX, source_size=%sB", i + 1,
                 segment_dest, FormatMetricUint(segment_dest_size), segment_source,
                 FormatMetricUint(segment_source_size)
             );
diff --git a/kernel/arch/x86_64/boot/loader_64/src/main.cpp b/kernel/arch/x86_64/boot/loader_64/src/main.cpp
index 68d7b9a1..7a0e06d5 100644
--- a/kernel/arch/x86_64/boot/loader_64/src/main.cpp
+++ b/kernel/arch/x86_64/boot/loader_64/src/main.cpp
@@ -160,6 +160,27 @@ static u64 LoadKernelIntoMemory(
     return entry_point_res.value();
 }
 
+void FindRamdiskInMemory(MultibootInfo &multiboot_info, MemoryManagers &mms)
+{
+    auto &pmm = mms.pmm;
+
+    auto ramdisk_module_res = multiboot_info.FindTag<TagModule>([](TagModule *tag) {
+        return strcmp(tag->cmdline, kInitrdModuleCmdline) == 0;
+    });
+    ASSERT_TRUE(ramdisk_module_res, "Failed to find the ramdisk module");
+    const TagModule *ramdisk_tag = ramdisk_module_res.value();
+
+    const size_t ramdisk_size = ramdisk_tag->mod_end - ramdisk_tag->mod_start;
+    TRACE_DEBUG(
+        "Ramdisk located at 0x%llX - 0x%llX (size: %sB)", ramdisk_tag->mod_start,
+        ramdisk_tag->mod_end, FormatMetricUint(ramdisk_size)
+    );
+    pmm.Reserve(PhysicalPtr<void>(ramdisk_tag->mod_start), ramdisk_size);
+
+    gKernelInitialParams.ramdisk_start = ramdisk_tag->mod_start;
+    gKernelInitialParams.ramdisk_end   = ramdisk_tag->mod_end;
+}
+
 static void EstablishDirectMemMapping(MemoryManagers &mms)
 {
     auto &vmm = mms.vmm;
@@ -243,6 +264,15 @@ static void PrepareKernelArgs(
         gKernelInitialParams.fb_pitch  = 0;
         gKernelInitialParams.fb_bpp    = 0;
     }
+
+    // Ramdisk
+    if constexpr (FeatureEnabled<FeatureFlag::kRamdisk>) {
+        FindRamdiskInMemory(multiboot_info, mem_managers);
+    } else {
+        TRACE_INFO("Ramdisk feature disabled, skipping ramdisk setup");
+        gKernelInitialParams.ramdisk_start = 0;
+        gKernelInitialParams.ramdisk_end   = 0;
+    }
 }
 
 NO_RET static void TransitionToKernel(
@@ -265,6 +295,8 @@ NO_RET static void TransitionToKernel(
         "  Kernel Arguments:\n"
         "    kernel_start_addr:           0x%llX\n"
         "    kernel_end_addr:             0x%llX\n"
+        "    ramdisk_start_addr           0x%llX\n"
+        "    ramdisk_end_addr:            0x%llX\n"
         "    pml_4_table_phys_addr:       0x%llX\n"
         "    mem_info_bitmap_addr:        0x%llX\n"
         "    mem_info_total_pages:        %llu\n"
@@ -284,6 +316,7 @@ NO_RET static void TransitionToKernel(
         "    fb_blue_pos:                 %hhu\n"
         "    fb_blue_mask:                %hhu\n",
         gKernelInitialParams.kernel_start_addr, gKernelInitialParams.kernel_end_addr,
+        gKernelInitialParams.ramdisk_start, gKernelInitialParams.ramdisk_end,
         gKernelInitialParams.pml_4_table_phys_addr, gKernelInitialParams.mem_info_bitmap_addr,
         gKernelInitialParams.mem_info_total_pages, gKernelInitialParams.multiboot_info_addr,
         gKernelInitialParams.multiboot_header_start_addr,
diff --git a/kernel/arch/x86_64/boot/settings/settings.hpp b/kernel/arch/x86_64/boot/settings/settings.hpp
index 2011bc54..d9443451 100644
--- a/kernel/arch/x86_64/boot/settings/settings.hpp
+++ b/kernel/arch/x86_64/boot/settings/settings.hpp
@@ -10,5 +10,6 @@ static constexpr u64 kDirectMemMapSizeGb        = 512;
 
 static constexpr const char *kKernelModuleCmdline   = "kernel";
 static constexpr const char *kLoader64ModuleCmdline = "loader64";
+static constexpr const char *kInitrdModuleCmdline   = "initrd";
 
 #endif  // KERNEL_ARCH_X86_64_BOOT_SETTINGS_SETTINGS_HPP_
diff --git a/kernel/src/boot_args.cpp b/kernel/src/boot_args.cpp
index 44fc65a5..7bf33854 100644
--- a/kernel/src/boot_args.cpp
+++ b/kernel/src/boot_args.cpp
@@ -34,6 +34,11 @@ BootArguments SanitizeBootArgs(const hal::RawBootArguments &raw_args)
         .blue_mask_size  = raw_args.fb_blue_mask,
     };
 
+    RamdiskArgs ramdisk_args{
+        .start = UptrToPtr<void>(raw_args.ramdisk_start),
+        .end   = UptrToPtr<void>(raw_args.ramdisk_end),
+    };
+
     BootArguments sanitized_k_args{
         .kernel_start      = UptrToPtr<void>(raw_args.kernel_start_addr),
         .kernel_end        = UptrToPtr<void>(raw_args.kernel_end_addr),
@@ -42,6 +47,7 @@ BootArguments SanitizeBootArgs(const hal::RawBootArguments &raw_args)
         .total_page_frames = static_cast<size_t>(raw_args.mem_info_total_pages),
         .multiboot_info    = UptrToPtr<void>(raw_args.multiboot_info_phys_addr),
         .fb_args           = fb_args,
+        .ramdisk_args      = ramdisk_args,
     };
 
     DEBUG_INFO_BOOT("Sanitized boot arguments:");
@@ -49,6 +55,8 @@ BootArguments SanitizeBootArgs(const hal::RawBootArguments &raw_args)
         "  Boot Arguments:\n"
         "    kernel_start:       %p\n"
         "    kernel_end:         %p\n"
+        "    ramdisk_start:      %p\n"
+        "    ramdisk_end:        %p\n"
         "    root_page_table:    %p\n"
         "    mem_bitmap:         %p\n"
         "    total_page_frames:  %zu\n"
@@ -66,6 +74,7 @@ BootArguments SanitizeBootArgs(const hal::RawBootArguments &raw_args)
         "    blue_pos:           %hhu\n"
         "    blue_mask_size:     %hhu\n",
         sanitized_k_args.kernel_start, sanitized_k_args.kernel_end,
+        sanitized_k_args.ramdisk_args.start, sanitized_k_args.ramdisk_args.end,
         sanitized_k_args.root_page_table, sanitized_k_args.mem_bitmap,
         sanitized_k_args.total_page_frames, sanitized_k_args.multiboot_info,
         sanitized_k_args.fb_args.base_address, sanitized_k_args.fb_args.width,
diff --git a/kernel/src/boot_args.hpp b/kernel/src/boot_args.hpp
index 6830646a..7fc6f225 100644
--- a/kernel/src/boot_args.hpp
+++ b/kernel/src/boot_args.hpp
@@ -18,6 +18,11 @@ struct FramebufferArgs {
     u8 blue_mask_size;
 };
 
+struct RamdiskArgs {
+    Mem::PPtr<void> start;
+    Mem::PPtr<void> end;
+};
+
 struct BootArguments {
     Mem::VPtr<void> kernel_start;
     Mem::VPtr<void> kernel_end;
@@ -26,6 +31,7 @@ struct BootArguments {
     size_t total_page_frames;
     Mem::PPtr<void> multiboot_info;
     FramebufferArgs fb_args;
+    RamdiskArgs ramdisk_args;
 };
 
 BootArguments SanitizeBootArgs(const hal::RawBootArguments &raw_args);
diff --git a/kernel/src/hal/api/boot_args.hpp b/kernel/src/hal/api/boot_args.hpp
index 314a3d5f..faf18292 100644
--- a/kernel/src/hal/api/boot_args.hpp
+++ b/kernel/src/hal/api/boot_args.hpp
@@ -32,6 +32,10 @@ struct RawBootArgumentsAPI {
     u8 fb_green_mask;
     u8 fb_blue_pos;
     u8 fb_blue_mask;
+
+    // Ramdisk
+    u64 ramdisk_start;
+    u64 ramdisk_end;
 };
 }  // namespace arch
 
diff --git a/kernel/src/init.cpp b/kernel/src/init.cpp
index bd0738a8..4cf73bb7 100644
--- a/kernel/src/init.cpp
+++ b/kernel/src/init.cpp
@@ -56,7 +56,7 @@ void KernelInit(const hal::RawBootArguments &raw_args)
 
     MemoryModule::Get().RegisterPageFault(HardwareModule::Get());
 
-    VfsModule::Init();
+    VfsModule::Init(args);
 
     VideoModule::Init(args, MemoryModule::Get().GetHeap());
 }
diff --git a/kernel/src/modules/vfs.cpp b/kernel/src/modules/vfs.cpp
index dcc01664..cb07626f 100644
--- a/kernel/src/modules/vfs.cpp
+++ b/kernel/src/modules/vfs.cpp
@@ -1,16 +1,55 @@
 #include "vfs.hpp"
 #include "../vfs.hpp"
 
+#include <autogen/feature_flags.h>
 #include <mem/heap.hpp>
+#include <mem/types.hpp>
 #include <trace_framework.hpp>
+#include <vfs/fat/fat12.hpp>
+#include <vfs/io/in_memory.hpp>
+#include "boot_args.hpp"
 
 using namespace vfs;
 
+// ------------------------------
+// Global ramdisk storage (must persist for the lifetime of the VFS)
+// ------------------------------
+
+static byte gRamdiskIoStorage[sizeof(io::InMemory)];
+static byte gRamdiskFsStorage[sizeof(Fat12<io::InMemory>)];
+
 // ------------------------------
 // Construction
 // ------------------------------
 
-internal::VfsModule::VfsModule() noexcept { TRACE_INFO_VFS("VFS Module initialized"); }
+internal::VfsModule::VfsModule(const BootArguments &args) noexcept
+{
+    DEBUG_INFO_VFS("VfsModule::VfsModule()");
+
+    // Mount ramdisk if available
+    if constexpr (FeatureEnabled<FeatureFlag::kRamdisk>) {
+        if (args.ramdisk_args.start != nullptr && args.ramdisk_args.end > args.ramdisk_args.start) {
+            auto *ramdisk_virt = Mem::PhysToVirt(args.ramdisk_args.start);
+            auto *io_ptr       = new (gRamdiskIoStorage) io::InMemory(ramdisk_virt);
+
+            // Validate and create Fat12 filesystem
+            if (Fat12<io::InMemory>::IsValid(*io_ptr)) {
+                auto *fat12_ptr = new (gRamdiskFsStorage) Fat12(*io_ptr);
+                auto fs         = fat12_ptr->GetFilesystem();
+
+                // Mount at root
+                auto mount_result = Mount(Path("/"), MountOptions{.read_only = false}, fs);
+                if (!mount_result.has_value()) {
+                    TRACE_FATAL_VFS("Failed to mount ramdisk");
+                }
+            } else {
+                TRACE_FATAL_VFS("Ramdisk is not a valid FAT12 filesystem");
+            }
+        } else {
+            TRACE_FATAL_VFS("No ramdisk available");
+        }
+    }
+}
 
 // ------------------------------
 // Mount Point Management
diff --git a/kernel/src/modules/vfs.hpp b/kernel/src/modules/vfs.hpp
index 73dbb546..3c476d7a 100644
--- a/kernel/src/modules/vfs.hpp
+++ b/kernel/src/modules/vfs.hpp
@@ -3,6 +3,7 @@
 
 #include <template_lib.hpp>
 #include <vfs/types.hpp>
+#include "boot_args.hpp"
 #include "modules/helpers.hpp"
 
 namespace internal
@@ -14,7 +15,7 @@ class VfsModule : template_lib::StaticSingletonHelper
     // -------------------------------------
 
     protected:
-    VfsModule() noexcept;
+    explicit VfsModule(const BootArguments &args) noexcept;
 
     // ------------------------------
     // Module fields
diff --git a/kernel/src/sys/shell.cpp b/kernel/src/sys/shell.cpp
index 5db0ecb8..f5ec39d8 100644
--- a/kernel/src/sys/shell.cpp
+++ b/kernel/src/sys/shell.cpp
@@ -1,12 +1,14 @@
 #include "sys/shell.hpp"
 #include <string.h>
 #include <modules/memory.hpp>
+#include <modules/vfs.hpp>
 #include <string.hpp>
+#include <vfs/path.hpp>
 
 namespace System
 {
 
-Shell::Shell(GraphicsConsole &console) : console_(console) {}
+Shell::Shell(GraphicsConsole &console) : console_(console), current_dir_(vfs::Path::kRoot) {}
 
 void Shell::Init()
 {
@@ -69,6 +71,14 @@ void Shell::ProcessCommand()
         CmdClear();
     } else if (cmd == "echo") {
         CmdEcho(args);
+    } else if (cmd == "cd") {
+        CmdCd(args);
+    } else if (cmd == "ls") {
+        CmdLs(args);
+    } else if (cmd == "cat") {
+        CmdCat(args);
+    } else if (cmd == "pwd") {
+        CmdPwd();
     } else {
         console_.Write(
             std::span<const byte>(reinterpret_cast<const byte *>("Unknown command: "), 17)
@@ -84,9 +94,13 @@ void Shell::CmdHelp()
 {
     const char *msg =
         "Available commands:\n"
-        "  help   - Show this message\n"
-        "  clear  - Clear the screen\n"
-        "  echo   - Print arguments\n";
+        "  help        - Show this message\n"
+        "  clear       - Clear the screen\n"
+        "  echo <text> - Print arguments\n"
+        "  pwd         - Print working directory\n"
+        "  cd <path>   - Change directory\n"
+        "  ls [path]   - List directory contents\n"
+        "  cat <file>  - Display file contents\n";
     console_.Write(std::span<const byte>(reinterpret_cast<const byte *>(msg), strlen(msg)));
 }
 
@@ -98,4 +112,185 @@ void Shell::CmdEcho(std::string_view args)
     console_.PutChar('\n');
 }
 
+vfs::Path Shell::ResolvePath(std::string_view path_str)
+{
+    if (path_str.empty()) {
+        return current_dir_;
+    }
+
+    vfs::Path path(path_str);
+    if (path.IsAbsolute()) {
+        return path.GetNormalized();
+    }
+
+    // Relative path - combine with current directory
+    return (current_dir_ / path).GetNormalized();
+}
+
+void Shell::CmdPwd()
+{
+    const char *path = current_dir_.CString();
+    console_.Write(std::span<const byte>(reinterpret_cast<const byte *>(path), strlen(path)));
+    console_.PutChar('\n');
+}
+
+void Shell::CmdCd(std::string_view args)
+{
+    // Trim leading/trailing spaces
+    while (!args.empty() && args.front() == ' ') {
+        args.remove_prefix(1);
+    }
+    while (!args.empty() && args.back() == ' ') {
+        args.remove_suffix(1);
+    }
+
+    if (args.empty()) {
+        // cd with no args goes to root
+        current_dir_ = vfs::Path::kRoot;
+        return;
+    }
+
+    vfs::Path new_path = ResolvePath(args);
+
+    // Check if path exists and is a directory
+    auto &vfs         = VfsModule::Get();
+    auto exists_check = vfs.DirectoryExists(new_path);
+
+    if (!exists_check.has_value()) {
+        const char *err = "cd: path not found: ";
+        console_.Write(std::span<const byte>(reinterpret_cast<const byte *>(err), strlen(err)));
+        console_.Write(
+            std::span<const byte>(reinterpret_cast<const byte *>(args.data()), args.size())
+        );
+        console_.PutChar('\n');
+        return;
+    }
+
+    if (!exists_check.value()) {
+        const char *err = "cd: not a directory: ";
+        console_.Write(std::span<const byte>(reinterpret_cast<const byte *>(err), strlen(err)));
+        console_.Write(
+            std::span<const byte>(reinterpret_cast<const byte *>(args.data()), args.size())
+        );
+        console_.PutChar('\n');
+        return;
+    }
+
+    current_dir_ = new_path;
+}
+
+void Shell::CmdLs(std::string_view args)
+{
+    // Trim leading/trailing spaces
+    while (!args.empty() && args.front() == ' ') {
+        args.remove_prefix(1);
+    }
+    while (!args.empty() && args.back() == ' ') {
+        args.remove_suffix(1);
+    }
+
+    vfs::Path path = args.empty() ? current_dir_ : ResolvePath(args);
+
+    auto &vfs = VfsModule::Get();
+
+    // Check if the path exists
+    auto exists_check = vfs.DirectoryExists(path);
+    if (!exists_check.has_value() || !exists_check.value()) {
+        const char *err = "ls: cannot access '";
+        console_.Write(std::span<const byte>(reinterpret_cast<const byte *>(err), strlen(err)));
+        const char *p = path.CString();
+        console_.Write(std::span<const byte>(reinterpret_cast<const byte *>(p), strlen(p)));
+        const char *err2 = "': No such directory\n";
+        console_.Write(std::span<const byte>(reinterpret_cast<const byte *>(err2), strlen(err2)));
+        return;
+    }
+
+    // List directory contents
+    vfs.ListDirectory(path, [this](const char *name, bool is_dir) {
+        if (is_dir) {
+            console_.SetColors(Graphics::Color::Blue(), Graphics::Color::Black());
+        }
+        console_.Write(std::span<const byte>(reinterpret_cast<const byte *>(name), strlen(name)));
+        if (is_dir) {
+            console_.PutChar('/');
+            console_.SetColors(Graphics::Color::White(), Graphics::Color::Black());
+        }
+        console_.PutChar('\n');
+    });
+}
+
+void Shell::CmdCat(std::string_view args)
+{
+    // Trim leading/trailing spaces
+    while (!args.empty() && args.front() == ' ') {
+        args.remove_prefix(1);
+    }
+    while (!args.empty() && args.back() == ' ') {
+        args.remove_suffix(1);
+    }
+
+    if (args.empty()) {
+        const char *err = "cat: missing file operand\n";
+        console_.Write(std::span<const byte>(reinterpret_cast<const byte *>(err), strlen(err)));
+        return;
+    }
+
+    vfs::Path path = ResolvePath(args);
+
+    auto &vfs = VfsModule::Get();
+
+    // Check if file exists
+    auto exists_check = vfs.FileExists(path);
+    if (!exists_check.has_value() || !exists_check.value()) {
+        const char *err = "cat: ";
+        console_.Write(std::span<const byte>(reinterpret_cast<const byte *>(err), strlen(err)));
+        console_.Write(
+            std::span<const byte>(reinterpret_cast<const byte *>(args.data()), args.size())
+        );
+        const char *err2 = ": No such file\n";
+        console_.Write(std::span<const byte>(reinterpret_cast<const byte *>(err2), strlen(err2)));
+        return;
+    }
+
+    // Get file size
+    auto size_result = vfs.GetFileSize(path);
+    if (!size_result.has_value()) {
+        const char *err = "cat: cannot read file size\n";
+        console_.Write(std::span<const byte>(reinterpret_cast<const byte *>(err), strlen(err)));
+        return;
+    }
+
+    size_t file_size = size_result.value();
+    if (file_size == 0) {
+        return;  // Empty file, nothing to print
+    }
+
+    // Read and display file contents in chunks
+    static constexpr size_t kBufferSize = 512;
+    char buffer[kBufferSize];
+    size_t offset = 0;
+
+    while (offset < file_size) {
+        size_t to_read   = (file_size - offset) < kBufferSize ? (file_size - offset) : kBufferSize;
+        auto read_result = vfs.ReadFile(path, buffer, to_read, offset);
+
+        if (!read_result.has_value()) {
+            const char *err = "\ncat: error reading file\n";
+            console_.Write(std::span<const byte>(reinterpret_cast<const byte *>(err), strlen(err)));
+            return;
+        }
+
+        size_t bytes_read = read_result.value();
+        if (bytes_read == 0) {
+            break;
+        }
+
+        console_.Write(std::span<const byte>(reinterpret_cast<const byte *>(buffer), bytes_read));
+        offset += bytes_read;
+    }
+
+    // Ensure we end with a newline
+    console_.PutChar('\n');
+}
+
 }  // namespace System
diff --git a/kernel/src/sys/shell.hpp b/kernel/src/sys/shell.hpp
index 6b2d028a..26643ee9 100644
--- a/kernel/src/sys/shell.hpp
+++ b/kernel/src/sys/shell.hpp
@@ -4,6 +4,7 @@
 #include <data_structures/array_structures.hpp>
 #include <span.hpp>
 #include <string.hpp>
+#include <vfs/path.hpp>
 
 #include "sys/graphics_console.hpp"
 
@@ -44,9 +45,20 @@ class Shell
     void CmdClear();
     void CmdEcho(std::string_view args);
     void CmdMem();
+    void CmdCd(std::string_view args);
+    void CmdLs(std::string_view args);
+    void CmdCat(std::string_view args);
+    void CmdPwd();
+
+    // -------------------------------------------------------------------------
+    // Path utilities
+    // -------------------------------------------------------------------------
+
+    vfs::Path ResolvePath(std::string_view path_str);
 
     // Data
     GraphicsConsole &console_;
+    vfs::Path current_dir_;
 
     static constexpr size_t kMaxInput = 128;
     data_structures::StaticVector<char, kMaxInput> input_buffer_;
diff --git a/kernel/src/trace.cpp b/kernel/src/trace.cpp
index 7f465725..495ae752 100644
--- a/kernel/src/trace.cpp
+++ b/kernel/src/trace.cpp
@@ -43,6 +43,8 @@ static struct TraceFramework {
             rv[static_cast<size_t>(TraceModule::kMemory)]     = "MemoryModule";
             rv[static_cast<size_t>(TraceModule::kInterrupts)] = "InterruptsModule";
             rv[static_cast<size_t>(TraceModule::kTime)]       = "TimeModule";
+            rv[static_cast<size_t>(TraceModule::kVfs)]        = "VFSModule";
+            rv[static_cast<size_t>(TraceModule::kVideo)]      = "VideoModule";
 
             return rv;
         }();
diff --git a/kernel/src/trace_framework.hpp b/kernel/src/trace_framework.hpp
index 5b2b8a00..75af928c 100644
--- a/kernel/src/trace_framework.hpp
+++ b/kernel/src/trace_framework.hpp
@@ -32,14 +32,14 @@ enum class TraceType {
 };
 
 enum class TraceModule {
-    kVfs = 0,
+    kBoot = 0,
     kMemory,
     kInterrupts,
-    kBoot,
     kGeneral,
     kTime,
-    kLast,
+    kVfs,
     kVideo,
+    kLast,
 };
 
 // ------------------------------
diff --git a/kernel/test/vfs/vfs_module_test.cpp b/kernel/test/vfs/vfs_module_test.cpp
index 56ffd529..5a7383fa 100644
--- a/kernel/test/vfs/vfs_module_test.cpp
+++ b/kernel/test/vfs/vfs_module_test.cpp
@@ -100,6 +100,8 @@ class VfsModuleTest : public TestGroupBase
         fat12_ = Mem::KMalloc<vfs::Fat12<vfs::io::InMemory>>().value_or(nullptr);
         EXPECT_NOT_NULL(fat12_);
         std::construct_at<vfs::Fat12<vfs::io::InMemory>>(fat12_, *io_);
+
+        vfs::Unmount(vfs::Path("/"));
     }
 
     void TearDown_() override
diff --git a/rootfs/overlay/docs/greet.txt b/rootfs/overlay/docs/greet.txt
new file mode 100644
index 00000000..d9bb60c3
--- /dev/null
+++ b/rootfs/overlay/docs/greet.txt
@@ -0,0 +1 @@
+Hello AlkOS from FAT12!
diff --git a/rootfs/overlay/file.txt b/rootfs/overlay/file.txt
deleted file mode 100644
index 3bbe4864..00000000
--- a/rootfs/overlay/file.txt
+++ /dev/null
@@ -1 +0,0 @@
-Hello AlkOS from FAT32!
diff --git a/rootfs/overlay/lorem.txt b/rootfs/overlay/lorem.txt
new file mode 100644
index 00000000..dad629c6
--- /dev/null
+++ b/rootfs/overlay/lorem.txt
@@ -0,0 +1 @@
+Lorem ipsum dolor sit amet, consectetur adipiscing elit. Fusce et massa interdum, laoreet purus eu, pretium sem. Praesent lacinia metus ultricies consequat porta.

From ce05d38bfc948da044b021e4bda8aa78c6fd3f83 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C5=81ukasz=20Kryczka?=
 <60490378+kryczkal@users.noreply.github.com>
Date: Fri, 12 Dec 2025 16:03:05 +0100
Subject: [PATCH 09/56] Kryczkal/ucapi 01 (#236)

## Problem
Bug in irq error wrapper callback, having offset to error struct wrong
by 8-bytes
also bug in timing module which doesnt initialize numerator and
denumerator

Also multiboot related code (`x86_64` specific) present in generic
kernel. Moved the related logic to bootloader

## Solution
Fixed those bugs and uncommented uacpi & timing related code
---
 .../x86_64/boot/lib/abi/transition_data.hpp   |  3 ++
 .../arch/x86_64/boot/loader_64/src/main.cpp   | 18 ++++++++++
 kernel/arch/x86_64/src/drivers/hpet/hpet.cpp  |  4 +++
 kernel/arch/x86_64/src/interrupts/idt.nasm    |  4 +--
 kernel/src/acpi/acpi.cpp                      | 36 +++----------------
 kernel/src/acpi/acpi.hpp                      |  4 +--
 kernel/src/acpi/osl.cpp                       |  8 ++---
 kernel/src/boot_args.cpp                      |  4 ++-
 kernel/src/boot_args.hpp                      |  1 +
 kernel/src/hal/api/boot_args.hpp              |  3 ++
 kernel/src/init.cpp                           |  8 ++---
 11 files changed, 48 insertions(+), 45 deletions(-)

diff --git a/kernel/arch/x86_64/boot/lib/abi/transition_data.hpp b/kernel/arch/x86_64/boot/lib/abi/transition_data.hpp
index 10972d28..eeb18417 100644
--- a/kernel/arch/x86_64/boot/lib/abi/transition_data.hpp
+++ b/kernel/arch/x86_64/boot/lib/abi/transition_data.hpp
@@ -48,6 +48,9 @@ struct alignas(64) KernelArguments {
     u64 ramdisk_start;
     u64 ramdisk_end;
 
+    /// ACPI
+    u64 acpi_rsdp_phys_addr;
+
     /// Multiboot
     u64 multiboot_info_addr;
     u64 multiboot_header_start_addr;
diff --git a/kernel/arch/x86_64/boot/loader_64/src/main.cpp b/kernel/arch/x86_64/boot/loader_64/src/main.cpp
index 7a0e06d5..3ecb475a 100644
--- a/kernel/arch/x86_64/boot/loader_64/src/main.cpp
+++ b/kernel/arch/x86_64/boot/loader_64/src/main.cpp
@@ -273,6 +273,24 @@ static void PrepareKernelArgs(
         gKernelInitialParams.ramdisk_start = 0;
         gKernelInitialParams.ramdisk_end   = 0;
     }
+
+    // ACPI
+    auto acpi_new_tag_res = multiboot_info.FindTag<TagNewAcpi>();
+    if (acpi_new_tag_res) {
+        const auto *tag                          = acpi_new_tag_res.value();
+        gKernelInitialParams.acpi_rsdp_phys_addr = reinterpret_cast<u64>(tag->rsdp);
+        TRACE_INFO("ACPI RSDP (v2) found at: 0x%llX", gKernelInitialParams.acpi_rsdp_phys_addr);
+    } else {
+        auto acpi_old_tag_res = multiboot_info.FindTag<TagOldAcpi>();
+        if (acpi_old_tag_res) {
+            const auto *tag                          = acpi_old_tag_res.value();
+            gKernelInitialParams.acpi_rsdp_phys_addr = reinterpret_cast<u64>(tag->rsdp);
+            TRACE_INFO("ACPI RSDP (v1) found at: 0x%llX", gKernelInitialParams.acpi_rsdp_phys_addr);
+        } else {
+            TRACE_WARNING("No ACPI RSDP tag found!");
+            gKernelInitialParams.acpi_rsdp_phys_addr = 0;
+        }
+    }
 }
 
 NO_RET static void TransitionToKernel(
diff --git a/kernel/arch/x86_64/src/drivers/hpet/hpet.cpp b/kernel/arch/x86_64/src/drivers/hpet/hpet.cpp
index 5a3e6092..7560459b 100644
--- a/kernel/arch/x86_64/src/drivers/hpet/hpet.cpp
+++ b/kernel/arch/x86_64/src/drivers/hpet/hpet.cpp
@@ -128,6 +128,10 @@ Hpet::Hpet(acpi_hpet *table)
     hpet_entry.stop_counter   = StopCounterCb;
     hpet_entry.resume_counter = ResumeCounterCb;
 
+    hpet_entry.clock_numerator = clock_period_;
+    hpet_entry.clock_denominator =
+        1'000'000;  // Convert femtoseconds (10^-15) to nanoseconds (10^-9)
+
     /* Own data */
     hpet_entry.own_data = this;
 
diff --git a/kernel/arch/x86_64/src/interrupts/idt.nasm b/kernel/arch/x86_64/src/interrupts/idt.nasm
index d7480b2a..ffd0bf95 100644
--- a/kernel/arch/x86_64/src/interrupts/idt.nasm
+++ b/kernel/arch/x86_64/src/interrupts/idt.nasm
@@ -59,7 +59,7 @@ isr_wrapper_%+%1:
     sub rsp, _shadow_space      ; Allocate shadow space.
     cld                         ; Clear direction flag.
     mov rdi, %1                 ; Arg1: interrupt number.
-    lea rsi, [rsp + _shadow_space + _reg_size + 8] ; Arg2: pointer to stack frame.
+    lea rsi, [rsp + _shadow_space + _reg_size] ; Arg2: pointer to stack frame.
     call HandleException
     add rsp, _shadow_space      ; Deallocate shadow space.
     pop_regs                    ; Restore registers.
@@ -77,7 +77,7 @@ isr_wrapper_%+%1:
     sub rsp, _shadow_space      ; Allocate shadow space.
     cld                         ; Clear direction flag.
     mov rdi, %1                 ; Arg1: interrupt number.
-    lea rsi, [rsp + _shadow_space + _reg_size + 8] ; Arg2: pointer to stack frame.
+    lea rsi, [rsp + _shadow_space + _reg_size] ; Arg2: pointer to stack frame.
     call HandleException
     add rsp, _shadow_space      ; Deallocate shadow space.
     pop_regs                    ; Restore registers.
diff --git a/kernel/src/acpi/acpi.cpp b/kernel/src/acpi/acpi.cpp
index a14cf05b..401c6131 100644
--- a/kernel/src/acpi/acpi.cpp
+++ b/kernel/src/acpi/acpi.cpp
@@ -3,50 +3,22 @@
 #include <internal/formats.hpp>
 #include "trace_framework.hpp"
 
-// TODO
-#include <include/multiboot2/multiboot2.h>
-#include <include/multiboot2/multiboot_info.hpp>
-
 /* External includes */
 #include <uacpi/event.h>
 #include <uacpi/uacpi.h>
 
-static Multiboot::TagNewAcpi *FindAcpiTag(u64 multiboot_info_addr)
-{
-    // TODO: 1. Multiboot Tags should be in both the arch and the kernel, so maybe move to libk?
-    // TODO: 2. This should probably recieve a MultibootInfo object instead of an address.
-    DEBUG_INFO_GENERAL("Finding ACPI tag in multiboot tags...");
-    Multiboot::MultibootInfo multiboot_info(multiboot_info_addr);
-
-    auto *new_acpi_tag = multiboot_info.FindTag<Multiboot::TagNewAcpi>();
-
-    if (new_acpi_tag == nullptr) {
-        TRACE_WARN_GENERAL("ACPI2.0 tag not found in multiboot tags, trying ACPI1.0 tag...");
-        auto *old_acpi_tag = multiboot_info.FindTag<Multiboot::TagOldAcpi>();
-
-        new_acpi_tag = reinterpret_cast<Multiboot::TagNewAcpi *>(old_acpi_tag);
-    }
-
-    return new_acpi_tag;
-}
-
 int ACPI::ACPIController::Init(const BootArguments &args)
 {
     TODO_WHEN_VMEM_WORKS
     DEBUG_INFO_GENERAL("ACPI initialization...");
 
-    DEBUG_INFO_GENERAL("Finding RSDP...");
-    auto *acpi_tag = FindAcpiTag(Mem::PtrToUptr(args.multiboot_info));
+    DEBUG_INFO_GENERAL("Getting RSDP from boot arguments...");
     R_ASSERT_NOT_NULL(
-        acpi_tag, "ACPI tag not found in multiboot tags, only platforms with ACPI supported..."
-    );
-
-    DEBUG_INFO_GENERAL(
-        "ACPI tag found at 0x%016llX, size: %sB", reinterpret_cast<u64>(acpi_tag),
-        FormatMetricUint(acpi_tag->size)
+        args.rsdp,
+        "RSDP address not provided in boot arguments, only platforms with ACPI supported..."
     );
 
-    RsdpAddress_ = reinterpret_cast<void *>(acpi_tag->rsdp);
+    RsdpAddress_ = args.rsdp;
     DEBUG_INFO_GENERAL("RSDP address: 0x%016p", RsdpAddress_);
 
     /* Load all tables, bring the event subsystem online, and enter ACPI mode */
diff --git a/kernel/src/acpi/acpi.hpp b/kernel/src/acpi/acpi.hpp
index c420d29a..c3615e12 100644
--- a/kernel/src/acpi/acpi.hpp
+++ b/kernel/src/acpi/acpi.hpp
@@ -57,14 +57,14 @@ class ACPIController final : public hal::AcpiController
     // Getters
     // ------------------------------
 
-    FORCE_INLINE_F void *GetRsdpAddress() const { return RsdpAddress_; }
+    FORCE_INLINE_F Mem::PPtr<void> GetRsdpAddress() const { return RsdpAddress_; }
 
     // ------------------------------
     // Class fields
     // ------------------------------
 
     private:
-    void *RsdpAddress_{};
+    Mem::PPtr<void> RsdpAddress_{};
 };
 
 //////////////////////////////
diff --git a/kernel/src/acpi/osl.cpp b/kernel/src/acpi/osl.cpp
index 442e1e00..5f45afe8 100644
--- a/kernel/src/acpi/osl.cpp
+++ b/kernel/src/acpi/osl.cpp
@@ -223,7 +223,7 @@ uacpi_cpu_flags uacpi_kernel_lock_spinlock(uacpi_handle handle)
 {
     ASSERT_NOT_NULL(handle);
 
-    const auto spinlock = static_cast<Spinlock *>(handle);
+    auto *const spinlock = static_cast<Spinlock *>(handle);
     spinlock->Lock();
 
     return 0;
@@ -233,7 +233,7 @@ void uacpi_kernel_unlock_spinlock(uacpi_handle handle, uacpi_cpu_flags)
 {
     ASSERT_NOT_NULL(handle);
 
-    const auto spinlock = static_cast<Spinlock *>(handle);
+    auto *const spinlock = static_cast<Spinlock *>(handle);
     spinlock->Unlock();
 }
 
@@ -242,7 +242,7 @@ TODO_WHEN_MUTEX_IMPLEMENTED
 uacpi_status uacpi_kernel_acquire_mutex(uacpi_handle handle, uacpi_u16)
 {
     ASSERT_NOT_NULL(handle);
-    const auto spinlock = static_cast<Spinlock *>(handle);
+    auto *const spinlock = static_cast<Spinlock *>(handle);
     spinlock->Lock();
 
     return UACPI_STATUS_OK;
@@ -251,7 +251,7 @@ uacpi_status uacpi_kernel_acquire_mutex(uacpi_handle handle, uacpi_u16)
 void uacpi_kernel_release_mutex(uacpi_handle handle)
 {
     ASSERT_NOT_NULL(handle);
-    const auto spinlock = static_cast<Spinlock *>(handle);
+    auto *const spinlock = static_cast<Spinlock *>(handle);
     spinlock->Unlock();
 }
 
diff --git a/kernel/src/boot_args.cpp b/kernel/src/boot_args.cpp
index 7bf33854..710ac14a 100644
--- a/kernel/src/boot_args.cpp
+++ b/kernel/src/boot_args.cpp
@@ -48,6 +48,7 @@ BootArguments SanitizeBootArgs(const hal::RawBootArguments &raw_args)
         .multiboot_info    = UptrToPtr<void>(raw_args.multiboot_info_phys_addr),
         .fb_args           = fb_args,
         .ramdisk_args      = ramdisk_args,
+        .rsdp              = UptrToPtr<void>(raw_args.acpi_rsdp_phys_addr),
     };
 
     DEBUG_INFO_BOOT("Sanitized boot arguments:");
@@ -61,6 +62,7 @@ BootArguments SanitizeBootArgs(const hal::RawBootArguments &raw_args)
         "    mem_bitmap:         %p\n"
         "    total_page_frames:  %zu\n"
         "    multiboot_info:     %p\n"
+        "    rsdp:               %p\n"
         "  Framebuffer Arguments:\n"
         "    base_address:       %p\n"
         "    width:              %u\n"
@@ -76,7 +78,7 @@ BootArguments SanitizeBootArgs(const hal::RawBootArguments &raw_args)
         sanitized_k_args.kernel_start, sanitized_k_args.kernel_end,
         sanitized_k_args.ramdisk_args.start, sanitized_k_args.ramdisk_args.end,
         sanitized_k_args.root_page_table, sanitized_k_args.mem_bitmap,
-        sanitized_k_args.total_page_frames, sanitized_k_args.multiboot_info,
+        sanitized_k_args.total_page_frames, sanitized_k_args.multiboot_info, sanitized_k_args.rsdp,
         sanitized_k_args.fb_args.base_address, sanitized_k_args.fb_args.width,
         sanitized_k_args.fb_args.height, sanitized_k_args.fb_args.pitch,
         sanitized_k_args.fb_args.bpp, sanitized_k_args.fb_args.red_pos,
diff --git a/kernel/src/boot_args.hpp b/kernel/src/boot_args.hpp
index 7fc6f225..aec66982 100644
--- a/kernel/src/boot_args.hpp
+++ b/kernel/src/boot_args.hpp
@@ -32,6 +32,7 @@ struct BootArguments {
     Mem::PPtr<void> multiboot_info;
     FramebufferArgs fb_args;
     RamdiskArgs ramdisk_args;
+    Mem::PPtr<void> rsdp;
 };
 
 BootArguments SanitizeBootArgs(const hal::RawBootArguments &raw_args);
diff --git a/kernel/src/hal/api/boot_args.hpp b/kernel/src/hal/api/boot_args.hpp
index faf18292..fef87863 100644
--- a/kernel/src/hal/api/boot_args.hpp
+++ b/kernel/src/hal/api/boot_args.hpp
@@ -36,6 +36,9 @@ struct RawBootArgumentsAPI {
     // Ramdisk
     u64 ramdisk_start;
     u64 ramdisk_end;
+
+    // ACPI
+    u64 acpi_rsdp_phys_addr;
 };
 }  // namespace arch
 
diff --git a/kernel/src/init.cpp b/kernel/src/init.cpp
index 4cf73bb7..b3dfdbb7 100644
--- a/kernel/src/init.cpp
+++ b/kernel/src/init.cpp
@@ -41,18 +41,18 @@ void KernelInit(const hal::RawBootArguments &raw_args)
     GlobalStateModule::Init();
 
     /* Initialize ACPI */
-    // HardwareModule::Get().GetACPIController().Init(args);
+    HardwareModule::Get().GetACPIController().Init(args);
 
     /* Extract all necessary data from ACPI tables */
-    // HardwareModule::Get().GetACPIController().ParseTables();
+    HardwareModule::Get().GetACPIController().ParseTables();
 
     /* Allow hardware to fully initialise interrupt system */
-    // HardwareModule::Get().GetInterrupts().Init();
+    HardwareModule::Get().GetInterrupts().Init();
 
     /* Setup core local data */
 
     /* Initialize the timing system */
-    // TimingModule::Init();
+    TimingModule::Init();
 
     MemoryModule::Get().RegisterPageFault(HardwareModule::Get());
 

From 6fd1037248fcc45137de2feb4f45d927936119ee Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C5=81ukasz=20Kryczka?=
 <60490378+kryczkal@users.noreply.github.com>
Date: Fri, 12 Dec 2025 18:48:35 +0100
Subject: [PATCH 10/56] Kryczkal/keyboard (#237)

## Problem
Handling keyboard input was done solely through legacy QemuTerminal
functions with a blocking read.

## Solution
Implemented a driver for a ps2 keyboard and connected it to a interrupt
handler. Shell now reads from an abstract Keyboard IReader (a pipe to
which keyboard drivers write)
---
 kernel/arch/x86_64/CMakeLists.txt             |   2 +-
 .../arch/x86_64/src/drivers/apic/io_apic.cpp  |  20 +-
 .../arch/x86_64/src/drivers/apic/io_apic.hpp  |   7 +
 .../x86_64/src/drivers/apic/local_apic.cpp    |   1 +
 .../x86_64/src/hal/impl/acpi_controller.cpp   |   8 +-
 .../arch/x86_64/src/hal/impl/interrupts.cpp   |   7 +-
 kernel/src/drivers/input/keyboard.hpp         |  61 +++++++
 kernel/src/drivers/input/ps2_keyboard.cpp     | 171 ++++++++++++++++++
 kernel/src/drivers/input/ps2_keyboard.hpp     |  90 +++++++++
 kernel/src/hardware.cpp                       |   8 -
 kernel/src/init.cpp                           |   6 +-
 kernel/src/kernel.cpp                         |  19 +-
 kernel/src/modules/hardware.cpp               |  23 +++
 kernel/src/modules/hardware.hpp               |   5 +
 kernel/src/sys/shell.cpp                      |  13 +-
 kernel/src/sys/shell.hpp                      |  19 +-
 kernel/src/trace.cpp                          |   4 +-
 kernel/src/trace_framework.hpp                |   6 +
 18 files changed, 433 insertions(+), 37 deletions(-)
 create mode 100644 kernel/src/drivers/input/keyboard.hpp
 create mode 100644 kernel/src/drivers/input/ps2_keyboard.cpp
 create mode 100644 kernel/src/drivers/input/ps2_keyboard.hpp
 delete mode 100644 kernel/src/hardware.cpp
 create mode 100644 kernel/src/modules/hardware.cpp

diff --git a/kernel/arch/x86_64/CMakeLists.txt b/kernel/arch/x86_64/CMakeLists.txt
index 9a9917cd..20b366ca 100644
--- a/kernel/arch/x86_64/CMakeLists.txt
+++ b/kernel/arch/x86_64/CMakeLists.txt
@@ -58,7 +58,7 @@ alkos_register_runtime_environment(
     QEMU_COMMAND
         "qemu-system-x86_64"
     QEMU_NORMAL_FLAGS
-        "-serial stdio -enable-kvm -cpu max -display default,show-cursor=on -m 4G -smp sockets=1,cores=4,threads=1"
+    "-serial stdio -enable-kvm -cpu max -display default,show-cursor=on -k en-us -m 4G -smp sockets=1,cores=4,threads=1"
     QEMU_TEST_FLAGS
         "-serial stdio -enable-kvm -cpu max -display none -m 4G -smp sockets=1,cores=4,threads=1"
     MODULES
diff --git a/kernel/arch/x86_64/src/drivers/apic/io_apic.cpp b/kernel/arch/x86_64/src/drivers/apic/io_apic.cpp
index 1becf663..8ce05053 100644
--- a/kernel/arch/x86_64/src/drivers/apic/io_apic.cpp
+++ b/kernel/arch/x86_64/src/drivers/apic/io_apic.cpp
@@ -3,6 +3,7 @@
 
 #include <bit.hpp>
 #include <todo.hpp>
+
 #include "interrupts/idt.hpp"
 #include "trace_framework.hpp"
 
@@ -54,15 +55,30 @@ IoApic::IoApic(const u8 id, const u32 address, const u32 gsi_base)
 
 void IoApic::PrepareDefaultConfig() const
 {
+    // Get the APIC ID of the running processor (BSP) to route interrupts to it
+    const u32 bsp_apic_id = LocalApic::GetCoreId();
+
     for (u32 idx = 0; idx < num_entries_; ++idx) {
         auto reg_low = ReadLowerTableRegister(idx);
+        // Prepare the Destination Register
+        HigherTableRegister reg_high{};
+        reg_high.destination = bsp_apic_id;
 
-        /* Note: vector not initialized */
+        /* Set defaults */
         reg_low.delivery_mode    = LowerTableRegister::DeliveryMode::kFixed;
         reg_low.destination_mode = LowerTableRegister::DestinationMode::kPhysical;
         reg_low.pin_polarity     = LowerTableRegister::PinPolarity::kActiveHigh;
         reg_low.trigger_mode     = LowerTableRegister::TriggerMode::kEdge;
-        reg_low.mask             = LowerTableRegister::EnabledFlag::kEnabled;
+
+        /* Map ISA interrupts (GSI 0-15) to IDT vectors */
+        const u32 current_gsi = gsi_base_ + idx;
+        if (current_gsi < 16) {
+            reg_low.vector = kIrq1Offset + current_gsi;
+            reg_low.mask   = LowerTableRegister::EnabledFlag::kEnabled;
+        } else {
+            reg_low.vector = 0;
+            reg_low.mask   = LowerTableRegister::EnabledFlag::kDisabled;
+        }
 
         WriteLowerTableRegister(idx, reg_low);
     }
diff --git a/kernel/arch/x86_64/src/drivers/apic/io_apic.hpp b/kernel/arch/x86_64/src/drivers/apic/io_apic.hpp
index fe60d29f..3f54f5de 100644
--- a/kernel/arch/x86_64/src/drivers/apic/io_apic.hpp
+++ b/kernel/arch/x86_64/src/drivers/apic/io_apic.hpp
@@ -178,6 +178,13 @@ class IoApic final
         WriteRegister(IoApicTableReg(reg_idx), ToRawRegister(reg_low));
     }
 
+    FORCE_INLINE_F void WriteHigherTableRegister(
+        const u32 reg_idx, const HigherTableRegister &reg_high
+    ) const
+    {
+        WriteRegister(IoApicTableReg(reg_idx) + 1, ToRawRegister(reg_high));
+    }
+
     // ------------------------------
     // Status and Configuration Methods
     // ------------------------------
diff --git a/kernel/arch/x86_64/src/drivers/apic/local_apic.cpp b/kernel/arch/x86_64/src/drivers/apic/local_apic.cpp
index b345d742..10dc681b 100644
--- a/kernel/arch/x86_64/src/drivers/apic/local_apic.cpp
+++ b/kernel/arch/x86_64/src/drivers/apic/local_apic.cpp
@@ -90,6 +90,7 @@ void LocalApic::Enable()
     reg.vector  = kSpuriousVector;
 
     WriteRegister(kSpuriousInterruptRegRW, reg);
+    WriteRegister(kTaskPriorityRegRW, 0);
 
     DEBUG_INFO_INTERRUPTS("Local APIC enabled...");
 }
diff --git a/kernel/arch/x86_64/src/hal/impl/acpi_controller.cpp b/kernel/arch/x86_64/src/hal/impl/acpi_controller.cpp
index f7cd7c93..cab0ad21 100644
--- a/kernel/arch/x86_64/src/hal/impl/acpi_controller.cpp
+++ b/kernel/arch/x86_64/src/hal/impl/acpi_controller.cpp
@@ -96,16 +96,20 @@ static void PrepareIoApic_(MadtTable &table)
     DEBUG_INFO_INTERRUPTS("Detected %lu I/O APIC devices...", num_apic);
 
     table.ForEachTableEntry([](const acpi_entry_hdr *entry) {
-        const auto table_ptr = ACPI::TryToAccessTheTable<acpi_madt_ioapic>(entry);
+        const auto *const table_ptr = ACPI::TryToAccessTheTable<acpi_madt_ioapic>(entry);
 
         if (!table_ptr) {
             return;
         }
 
-        HardwareModule::Get().GetInterrupts().GetIoApicTable().PushEmplace(
+        auto &io_apic_table = HardwareModule::Get().GetInterrupts().GetIoApicTable();
+        io_apic_table.PushEmplace(
             static_cast<u8>(table_ptr->id), static_cast<u32>(table_ptr->address),
             static_cast<u32>(table_ptr->gsi_base)
         );
+
+        // Initialize default configuration immediately so overrides can apply on top later
+        io_apic_table[io_apic_table.Size() - 1].PrepareDefaultConfig();
     });
 }
 
diff --git a/kernel/arch/x86_64/src/hal/impl/interrupts.cpp b/kernel/arch/x86_64/src/hal/impl/interrupts.cpp
index 26c01ed8..88a6fb65 100644
--- a/kernel/arch/x86_64/src/hal/impl/interrupts.cpp
+++ b/kernel/arch/x86_64/src/hal/impl/interrupts.cpp
@@ -21,14 +21,11 @@ void Interrupts::Init()
     /* Disable PIC unit */
     Pic8259Disable();
 
-    /* Enable IO apics */
-    for (IoApic &io_apic : GetIoApicTable()) {
-        io_apic.PrepareDefaultConfig();
-    }
-
     /* Replace first stage PIC with new APIC chip on startup Core */
     local_apic_.Enable();
 
+    ReplacePicDriverWithLapic_();
+
     tsc::Initialize();
 
     EnableHardwareInterrupts();
diff --git a/kernel/src/drivers/input/keyboard.hpp b/kernel/src/drivers/input/keyboard.hpp
new file mode 100644
index 00000000..96b96ce5
--- /dev/null
+++ b/kernel/src/drivers/input/keyboard.hpp
@@ -0,0 +1,61 @@
+#ifndef KERNEL_SRC_DRIVERS_INPUT_KEYBOARD_HPP_
+#define KERNEL_SRC_DRIVERS_INPUT_KEYBOARD_HPP_
+
+#include "io/pipe.hpp"
+#include "io/stream.hpp"
+
+namespace Drivers::Input
+{
+
+/**
+ * @brief Abstract Keyboard Driver Base Class.
+ *
+ * This class decouples the mechanism of receiving keystrokes (Hardware Interrupts)
+ * from the mechanism of consuming them (Shell/User-space).
+ *
+ */
+class Keyboard : public IO::IReader
+{
+    public:
+    static constexpr size_t kKeyBufferSize = 128;
+
+    virtual ~Keyboard() = default;
+
+    // ------------------------------
+    // IO::IReader Implementation
+    // ------------------------------
+
+    /**
+     * @brief Reads buffered characters from the keyboard.
+     * @param buffer Destination buffer.
+     * @return Number of bytes read or Error::Retry if empty.
+     */
+    IO::IoResult Read(std::span<byte> buffer) override { return pipe_.Read(buffer); }
+
+    // ------------------------------
+    // Protected Interface for Drivers
+    // ------------------------------
+
+    protected:
+    /**
+     * @brief Pushes a decoded character into the internal buffer.
+     * This method is intended to be called by derived classes (Drivers)
+     * typically from an Interrupt Service Routine context.
+     *
+     * @param c The decoded ASCII character.
+     */
+    void PushKey(char c)
+    {
+        byte b = static_cast<byte>(c);
+        // If full drop the keystroke
+        (void)pipe_.Write(std::span<const byte>(&b, 1));
+    }
+
+    private:
+    // Lock-free pipe enables IRQ-Main communication
+    IO::Pipe<kKeyBufferSize> pipe_;
+};
+
+}  // namespace Drivers::Input
+
+#endif  // KERNEL_SRC_DRIVERS_INPUT_KEYBOARD_HPP_
diff --git a/kernel/src/drivers/input/ps2_keyboard.cpp b/kernel/src/drivers/input/ps2_keyboard.cpp
new file mode 100644
index 00000000..cd97d42f
--- /dev/null
+++ b/kernel/src/drivers/input/ps2_keyboard.cpp
@@ -0,0 +1,171 @@
+#include "drivers/input/ps2_keyboard.hpp"
+#include "trace_framework.hpp"
+
+namespace Drivers::Input
+{
+
+// ----------------------------------------------------------------------------
+// Scancode Maps (Set 1)
+// ----------------------------------------------------------------------------
+
+static constexpr char kScancodeMap[128] = {
+    0,   27,  '1', '2', '3', '4', '5',  '6', '7', '8',  '9', '0',  '-', '=', '\b', '\t', 'q',
+    'w', 'e', 'r', 't', 'y', 'u', 'i',  'o', 'p', '[',  ']', '\n', 0,   'a', 's',  'd',  'f',
+    'g', 'h', 'j', 'k', 'l', ';', '\'', '`', 0,   '\\', 'z', 'x',  'c', 'v', 'b',  'n',  'm',
+    ',', '.', '/', 0,   '*', 0,   ' ',  0,   0,   0,    0,   0,    0,   0,   0,    0,    0,
+    0,   0,   0,   0,   0,   0,   0,    0,   0,   0,    0,   0,    0,   0,   0,    0,    0,
+    0,   0,   0,   0,   0,   0,   0,    0,   0,   0,    0,   0,    0,   0,   0,    0,    0,
+    // F11, F12 (mapped to 0 here)
+};
+
+static constexpr char kScancodeMapShift[128] = {
+    0,   27,  '!', '@', '#', '$', '%', '^', '&', '*', '(', ')',  '_', '+', '\b', '\t', 'Q',
+    'W', 'E', 'R', 'T', 'Y', 'U', 'I', 'O', 'P', '{', '}', '\n', 0,   'A', 'S',  'D',  'F',
+    'G', 'H', 'J', 'K', 'L', ':', '"', '~', 0,   '|', 'Z', 'X',  'C', 'V', 'B',  'N',  'M',
+    '<', '>', '?', 0,   '*', 0,   ' ', 0,   0,   0,   0,   0,    0,   0,   0,    0,    0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,    0,   0,   0,    0,    0,
+    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,    0,   0,   0,    0,    0,
+};
+
+// ----------------------------------------------------------------------------
+// Implementation
+// ----------------------------------------------------------------------------
+
+Ps2Keyboard::Ps2Keyboard(size_t data_addr, size_t status_addr)
+    : data_reg_(data_addr), status_reg_(status_addr)
+{
+}
+
+void Ps2Keyboard::Init()
+{
+    TRACE_INFO_GENERAL("Initializing PS/2 Keyboard...");
+
+    // prevent IRQs while we configure
+    status_reg_.Write<u8>(kCmdDisableKeyboard);
+    status_reg_.Write<u8>(kCmdDisableMouse);
+
+    // Flush Output Buffer
+    while ((status_reg_.Read<u8>() & kStatusOutputBufferFull) != 0) {
+        (void)data_reg_.Read<u8>();
+    }
+
+    // Set Controller Configuration
+    status_reg_.Write<u8>(kCmdReadConfig);
+    while ((status_reg_.Read<u8>() & kStatusOutputBufferFull) == 0);
+    u8 config = data_reg_.Read<u8>();
+
+    config |= kConfigIrq1Enable;
+    config |= kConfigTranslation;
+    config &= ~kConfigDisableKeyboard;
+
+    status_reg_.Write<u8>(kCmdWriteConfig);
+    while ((status_reg_.Read<u8>() & kStatusInputBufferFull) != 0);
+    data_reg_.Write<u8>(config);
+
+    status_reg_.Write<u8>(kCmdEnableKeyboard);
+
+    while ((status_reg_.Read<u8>() & kStatusInputBufferFull) != 0);
+    data_reg_.Write<u8>(kCmdResetDevice);
+
+    // Wait for Reset Response (ACK 0xFA + Success 0xAA)
+    // We must consume these bytes so they don't stick the IRQ line as High
+    int bytes_expected = 2;
+    int timeout        = kResetTimeout;
+    while (bytes_expected > 0 && timeout > 0) {
+        u8 status = status_reg_.Read<u8>();
+        if ((status & kStatusOutputBufferFull) != 0) {
+            u8 byte = data_reg_.Read<u8>();
+            TRACE_INFO_GENERAL("PS/2 Init: Consumed byte 0x%02x", byte);
+            bytes_expected--;
+        }
+        timeout--;
+    }
+
+    if (timeout == 0) {
+        TRACE_WARN_GENERAL("PS/2 Reset Timed Out - Keyboard might be unresponsive");
+    }
+
+    while ((status_reg_.Read<u8>() & kStatusInputBufferFull) != 0);
+    data_reg_.Write<u8>(kCmdEnableScanning);
+
+    timeout = kResetTimeout;
+    while (timeout > 0) {
+        if ((status_reg_.Read<u8>() & kStatusOutputBufferFull) != 0) {
+            u8 byte = data_reg_.Read<u8>();
+            if (byte == kResponseAck) {
+                break;
+            }
+        }
+        timeout--;
+    }
+
+    TRACE_INFO_GENERAL("PS/2 Keyboard Initialized & Drained");
+    trace::Flush();
+}
+
+void Ps2Keyboard::OnInterrupt()
+{
+    TRACE_INFO_HARDWARE("PS/2 Interrupt fired");
+    const u8 status = status_reg_.Read<u8>();
+
+    if ((status & kStatusOutputBufferFull) != 0) {
+        const u8 scancode = data_reg_.Read<u8>();
+
+        // This indicates the next byte is part of an extended sequence (e.g., arrow keys)
+        if (scancode == kScancodeExtendedPrefix) {
+            is_e0_prefix_ = true;
+            return;
+        }
+
+        if ((scancode & kScancodeBreakMask) != 0) {
+            const u8 released_code = scancode & ~kScancodeBreakMask;
+
+            if (released_code == kScancodeLeftShift || released_code == kScancodeRightShift) {
+                shift_pressed_ = false;
+            }
+
+            // Reset prefix on key release as well
+            is_e0_prefix_ = false;
+            return;
+        }
+
+        // Handle Make Code (Key Press)
+        if (scancode == kScancodeLeftShift || scancode == kScancodeRightShift) {
+            shift_pressed_ = true;
+        } else if (scancode == kScancodeCapsLock) {  // Caps Lock
+            caps_lock_ = !caps_lock_;
+        } else {
+            // Translate and push regular characters
+            const char c = TranslateScancode(scancode);
+            if (c != 0) {
+                PushKey(c);
+            }
+        }
+
+        is_e0_prefix_ = false;
+    }
+}
+
+char Ps2Keyboard::TranslateScancode(u8 scancode)
+{
+    if (scancode > 127) {
+        return 0;
+    }
+
+    char c = kScancodeMap[scancode];
+    if (shift_pressed_) {
+        c = kScancodeMapShift[scancode];
+    }
+
+    if (caps_lock_) {
+        if (c >= 'a' && c <= 'z') {
+            c -= 32;
+        } else if (c >= 'A' && c <= 'Z') {
+            c += 32;
+        }
+    }
+
+    return c;
+}
+
+}  // namespace Drivers::Input
diff --git a/kernel/src/drivers/input/ps2_keyboard.hpp b/kernel/src/drivers/input/ps2_keyboard.hpp
new file mode 100644
index 00000000..bf9dc6fc
--- /dev/null
+++ b/kernel/src/drivers/input/ps2_keyboard.hpp
@@ -0,0 +1,90 @@
+#ifndef KERNEL_SRC_DRIVERS_INPUT_PS2_KEYBOARD_HPP_
+#define KERNEL_SRC_DRIVERS_INPUT_PS2_KEYBOARD_HPP_
+
+#include <drivers/input/keyboard.hpp>
+#include <io/register.hpp>
+#include <types.hpp>
+
+namespace Drivers::Input
+{
+
+/**
+ * @brief Driver for a Generic PS/2 Keyboard connected via an 8042 Controller.
+ */
+class Ps2Keyboard final : public Keyboard
+{
+    public:
+    // Standard 8042 Controller Ports
+    static constexpr size_t kDefaultDataPort   = 0x60;
+    static constexpr size_t kDefaultStatusPort = 0x64;
+
+    // PS/2 Controller Commands
+    static constexpr u8 kCmdDisableKeyboard = 0xAD;
+    static constexpr u8 kCmdDisableMouse    = 0xA7;
+    static constexpr u8 kCmdEnableKeyboard  = 0xAE;
+    static constexpr u8 kCmdReadConfig      = 0x20;
+    static constexpr u8 kCmdWriteConfig     = 0x60;
+
+    // PS/2 Keyboard Device Commands
+    static constexpr u8 kCmdResetDevice    = 0xFF;
+    static constexpr u8 kCmdEnableScanning = 0xF4;
+
+    // Status Register Bits
+    static constexpr u8 kStatusOutputBufferFull = 1 << 0;
+    static constexpr u8 kStatusInputBufferFull  = 1 << 1;
+
+    // Configuration Byte Bits
+    static constexpr u8 kConfigIrq1Enable      = 1 << 0;
+    static constexpr u8 kConfigDisableKeyboard = 1 << 4;
+    static constexpr u8 kConfigTranslation     = 1 << 6;
+
+    // Device Responses
+    static constexpr u8 kResponseAck          = 0xFA;
+    static constexpr u8 kResponseResetSuccess = 0xAA;
+
+    // Scancodes (Set 1)
+    static constexpr u8 kScancodeExtendedPrefix = 0xE0;
+    static constexpr u8 kScancodeBreakMask      = 0x80;
+    static constexpr u8 kScancodeLeftShift      = 0x2A;
+    static constexpr u8 kScancodeRightShift     = 0x36;
+    static constexpr u8 kScancodeCapsLock       = 0x3A;
+
+    static constexpr int kResetTimeout = 1000000;
+
+    /**
+     * @brief Construct a new Ps2 Keyboard driver.
+     * @param data_addr I/O address of the data register.
+     * @param status_addr I/O address of the status/command register.
+     */
+    explicit Ps2Keyboard(
+        size_t data_addr = kDefaultDataPort, size_t status_addr = kDefaultStatusPort
+    );
+
+    /**
+     * @brief Initializes the driver and drains any pending garbage in the buffer.
+     */
+    void Init();
+
+    /**
+     * @brief Handle the interrupt request.
+     * Should be called by the architecture-specific ISR wrapper.
+     */
+    void OnInterrupt();
+
+    private:
+    // I/O Abstractions
+    IO::Register data_reg_;
+    IO::Register status_reg_;
+
+    // Translation State Machine
+    bool is_e0_prefix_{false};  // Processing an extended scancode?
+    bool shift_pressed_{false};
+    bool caps_lock_{false};
+
+    // Helpers
+    NODISCARD char TranslateScancode(u8 scancode);
+};
+
+}  // namespace Drivers::Input
+
+#endif  // KERNEL_SRC_DRIVERS_INPUT_PS2_KEYBOARD_HPP_
diff --git a/kernel/src/hardware.cpp b/kernel/src/hardware.cpp
deleted file mode 100644
index 13ac0272..00000000
--- a/kernel/src/hardware.cpp
+++ /dev/null
@@ -1,8 +0,0 @@
-#include "modules/hardware.hpp"
-
-#include "trace_framework.hpp"
-
-internal::HardwareModule::HardwareModule() noexcept
-{
-    DEBUG_INFO_GENERAL("HardwareModule::HardwareModule()");
-}
diff --git a/kernel/src/init.cpp b/kernel/src/init.cpp
index b3dfdbb7..287dc951 100644
--- a/kernel/src/init.cpp
+++ b/kernel/src/init.cpp
@@ -54,9 +54,11 @@ void KernelInit(const hal::RawBootArguments &raw_args)
     /* Initialize the timing system */
     TimingModule::Init();
 
-    MemoryModule::Get().RegisterPageFault(HardwareModule::Get());
-
     VfsModule::Init(args);
 
     VideoModule::Init(args, MemoryModule::Get().GetHeap());
+
+    // Register Interrupts
+    MemoryModule::Get().RegisterPageFault(HardwareModule::Get());
+    HardwareModule::Get().RegisterInterruptHandlers();
 }
diff --git a/kernel/src/kernel.cpp b/kernel/src/kernel.cpp
index 1944bf18..457cb3ad 100644
--- a/kernel/src/kernel.cpp
+++ b/kernel/src/kernel.cpp
@@ -1,6 +1,5 @@
 #include <assert.h>
 #include <autogen/feature_flags.h>
-#include <time.h>
 #include <string.hpp>
 #include <test_module/test_module.hpp>
 #include "trace_framework.hpp"
@@ -11,13 +10,13 @@
 #include "graphics/font/psf2_font.hpp"
 #include "graphics/fonts/drdos8x8.hpp"
 #include "graphics/painter.hpp"
-#include "hal/terminal.hpp"
+#include "modules/hardware.hpp"
 #include "modules/video.hpp"
 #include "sys/shell.hpp"
 
-#include "boot_args.hpp"
+#include "drivers/apic/local_apic.hpp"
 #include "hal/boot_args.hpp"
-#include "mem/heap.hpp"
+#include "modules/hardware.hpp"
 #include "todo.hpp"
 
 extern void KernelInit(const hal::RawBootArguments &);
@@ -25,8 +24,7 @@ extern void KernelInit(const hal::RawBootArguments &);
 static void KernelRun()
 {
     TRACE_INFO_GENERAL("Hello from AlkOS!");
-    trace::DumpAllBuffersOnFailure();
-    TODO_MMU_MINIMAL
+    trace::Flush();
 
     auto &video = VideoModule::Get();
     Graphics::Painter painter(video.GetScreen(), video.GetFormat());
@@ -37,20 +35,19 @@ static void KernelRun()
     }
 
     System::GraphicsConsole console(painter, font);
-    System::Shell shell(console);
+    System::Shell shell(console, HardwareModule::Get().GetPs2Keyboard());
 
     shell.Init();
     video.Flush();
 
     while (true) {
-        // Poll Serial Port for input (temporary until IRQ is hooked)
-        char c = hal::TerminalGetChar();
-        shell.OnInput(c);
+        shell.Update();
         video.Flush();
 
-        // Don't burn CPU 100%
+        // TODO: Replace with CpuHalt or smth like scheduler sleep.
         for (volatile i32 i = 0; i < 10000; ++i) {
         }
+        trace::Flush();
     }
 }
 
diff --git a/kernel/src/modules/hardware.cpp b/kernel/src/modules/hardware.cpp
new file mode 100644
index 00000000..831977db
--- /dev/null
+++ b/kernel/src/modules/hardware.cpp
@@ -0,0 +1,23 @@
+#include "modules/hardware.hpp"
+
+#include "trace_framework.hpp"
+
+static void Ps2KeyboardHandler(intr::LitHwEntry &)
+{
+    HardwareModule::Get().GetPs2Keyboard().OnInterrupt();
+}
+
+internal::HardwareModule::HardwareModule() noexcept
+{
+    DEBUG_INFO_GENERAL("HardwareModule::HardwareModule()");
+
+    Ps2Keyboard_.Init();
+}
+
+void internal::HardwareModule::RegisterInterruptHandlers()
+{
+    DEBUG_INFO_HARDWARE("Registering Ps2 Keyboard Handler");
+    GetInterrupts().GetLit().InstallInterruptHandler<intr::InterruptType::kHardwareInterrupt>(
+        1, intr::HwHandler{.handler = Ps2KeyboardHandler}
+    );
+}
diff --git a/kernel/src/modules/hardware.hpp b/kernel/src/modules/hardware.hpp
index 86fbe292..bb4c456b 100644
--- a/kernel/src/modules/hardware.hpp
+++ b/kernel/src/modules/hardware.hpp
@@ -4,6 +4,7 @@
 #include <template_lib.hpp>
 
 #include "acpi/acpi.hpp"
+#include "drivers/input/ps2_keyboard.hpp"
 #include "hardware/clock_infra.hpp"
 #include "hardware/core_controller.hpp"
 #include "hardware/cores.hpp"
@@ -31,6 +32,10 @@ class HardwareModule : template_lib::StaticSingletonHelper
     DEFINE_MODULE_FIELD(hardware, CoresController)
     DEFINE_MODULE_FIELD(hardware, ClockRegistry)
     DEFINE_MODULE_FIELD(hardware, EventClockRegistry)
+    DEFINE_MODULE_FIELD(Drivers::Input, Ps2Keyboard)
+
+    public:
+    void RegisterInterruptHandlers();
 };
 }  // namespace internal
 
diff --git a/kernel/src/sys/shell.cpp b/kernel/src/sys/shell.cpp
index f5ec39d8..63b925bc 100644
--- a/kernel/src/sys/shell.cpp
+++ b/kernel/src/sys/shell.cpp
@@ -8,7 +8,10 @@
 namespace System
 {
 
-Shell::Shell(GraphicsConsole &console) : console_(console), current_dir_(vfs::Path::kRoot) {}
+Shell::Shell(GraphicsConsole &console, IO::IReader &input_reader)
+    : console_(console), input_reader_(input_reader), current_dir_(vfs::Path::kRoot)
+{
+}
 
 void Shell::Init()
 {
@@ -26,6 +29,14 @@ void Shell::PrintPrompt()
     console_.SetColors(Graphics::Color::White(), Graphics::Color::Black());
 }
 
+void Shell::Update()
+{
+    auto result = input_reader_.GetChar();
+    if (result.has_value()) {
+        OnInput(result.value());
+    }
+}
+
 void Shell::OnInput(char c)
 {
     // Handle Special Keys
diff --git a/kernel/src/sys/shell.hpp b/kernel/src/sys/shell.hpp
index 26643ee9..1b5e9715 100644
--- a/kernel/src/sys/shell.hpp
+++ b/kernel/src/sys/shell.hpp
@@ -4,9 +4,10 @@
 #include <data_structures/array_structures.hpp>
 #include <span.hpp>
 #include <string.hpp>
-#include <vfs/path.hpp>
 
+#include "io/stream.hpp"
 #include "sys/graphics_console.hpp"
+#include "vfs/path.hpp"
 
 namespace System
 {
@@ -18,7 +19,7 @@ namespace System
 class Shell
 {
     public:
-    explicit Shell(GraphicsConsole &console);
+    explicit Shell(GraphicsConsole &console, IO::IReader &input_reader);
 
     // -------------------------------------------------------------------------
     // Public Interface
@@ -26,8 +27,11 @@ class Shell
 
     void Init();
 
-    // Call this when hardware receives a keystroke
-    void OnInput(char c);
+    /**
+     * @brief Polling function to check for new input and process it.
+     * Should be called inside the main kernel loop.
+     */
+    void Update();
 
     private:
     // -------------------------------------------------------------------------
@@ -56,8 +60,15 @@ class Shell
 
     vfs::Path ResolvePath(std::string_view path_str);
 
+    // -------------------------------------------------------------------------
+    // Internal Helpers
+    // -------------------------------------------------------------------------
+
+    void OnInput(char c);
+
     // Data
     GraphicsConsole &console_;
+    IO::IReader &input_reader_;
     vfs::Path current_dir_;
 
     static constexpr size_t kMaxInput = 128;
diff --git a/kernel/src/trace.cpp b/kernel/src/trace.cpp
index 495ae752..e5bf5365 100644
--- a/kernel/src/trace.cpp
+++ b/kernel/src/trace.cpp
@@ -45,6 +45,7 @@ static struct TraceFramework {
             rv[static_cast<size_t>(TraceModule::kTime)]       = "TimeModule";
             rv[static_cast<size_t>(TraceModule::kVfs)]        = "VFSModule";
             rv[static_cast<size_t>(TraceModule::kVideo)]      = "VideoModule";
+            rv[static_cast<size_t>(TraceModule::kHardware)]   = "HardwareModule";
 
             return rv;
         }();
@@ -420,5 +421,6 @@ NODISCARD TraceLevel GetTraceLevel(TraceModule module)
     return g_TraceFramework.trace_levels[static_cast<size_t>(module)];
 }
 
-void DumpAllBuffersOnFailure() { (g_TraceFramework.*g_TraceFramework.stage_callbacks.dump_all)(); }
+void Flush() { (g_TraceFramework.*g_TraceFramework.stage_callbacks.dump_all)(); }
+void DumpAllBuffersOnFailure() { Flush(); }
 }  // namespace trace
diff --git a/kernel/src/trace_framework.hpp b/kernel/src/trace_framework.hpp
index 75af928c..684776b0 100644
--- a/kernel/src/trace_framework.hpp
+++ b/kernel/src/trace_framework.hpp
@@ -39,6 +39,7 @@ enum class TraceModule {
     kTime,
     kVfs,
     kVideo,
+    kHardware,
     kLast,
 };
 
@@ -49,6 +50,7 @@ enum class TraceModule {
 void AdvanceTracingStage();
 NODISCARD TraceLevel GetTraceLevel(TraceModule module);
 void DumpAllBuffersOnFailure();
+void Flush();
 
 /* MODULE TIME CORE PROC FILE LINE MSG */
 template <TraceType type, TraceModule module, TraceLevel level, class... Args>
@@ -109,6 +111,10 @@ CREATE_TRACE_HELPERS(kTime, TIME)
 CREATE_DEBUG_HELPERS(kVideo, VIDEO)
 CREATE_TRACE_HELPERS(kVideo, VIDEO)
 
+// HARDWARE
+CREATE_DEBUG_HELPERS(kHardware, HARDWARE)
+CREATE_TRACE_HELPERS(kHardware, HARDWARE)
+
 #include "trace_framework.tpp"
 
 #endif  // KERNEL_SRC_TRACE_FRAMEWORK_HPP_

From fbdef5ba6b61bf39fc28be4ec749845054c57662 Mon Sep 17 00:00:00 2001
From: Jakub Lisowski <115403674+Jlisowskyy@users.noreply.github.com>
Date: Sun, 14 Dec 2025 14:41:58 +0100
Subject: [PATCH 11/56] Jlisowskyy/sync fix (#229)

Things done in this PR:
- fixed minor issues
- Improved interrupts
- improved exceptions
---
 .gitignore                                    |   2 +
 kernel/arch/x86_64/CMakeLists.txt             |   4 +-
 .../x86_64/boot/lib/abi/transition_data.hpp   |   2 +-
 kernel/arch/x86_64/src/cpu/utils.cpp          |  78 ++-------
 kernel/arch/x86_64/src/cpu/utils.hpp          | 155 ++++++++++++++----
 kernel/arch/x86_64/src/drivers/hpet/hpet.cpp  |   2 -
 kernel/arch/x86_64/src/hal/impl/debug.cpp     |   1 +
 kernel/arch/x86_64/src/hal/impl/debug.hpp     |   9 +-
 .../x86_64/src/hal/impl/interrupt_params.hpp  |  21 ++-
 .../arch/x86_64/src/hal/impl/interrupts.cpp   |   7 -
 kernel/arch/x86_64/src/hal/impl/io.hpp        |   2 +-
 kernel/arch/x86_64/src/hal/impl/panic.cpp     |   1 -
 kernel/arch/x86_64/src/interrupts/idt.cpp     |  76 +++++----
 kernel/arch/x86_64/src/interrupts/idt.nasm    |  85 +++++++---
 kernel/arch/x86_64/src/kernel/init.cpp        |   1 -
 .../arch/x86_64/src/startup/alkos_entry.nasm  |   3 -
 .../x86_64/src/tests/interrupts_tests.cpp     | 121 ++++++++++++--
 kernel/arch/x86_64/src/tests/manual_tests.cpp |   6 +-
 kernel/src/acpi/osl.cpp                       |  68 +++++++-
 kernel/src/hal/api/boot_args.hpp              |   2 +-
 kernel/src/hal/debug.hpp                      |   7 +-
 kernel/src/init.cpp                           |   7 -
 .../interrupts/logical_interrupt_table.hpp    |  43 ++++-
 .../interrupts/logical_interrupt_table.tpp    |   4 +-
 kernel/src/kernel.cpp                         |   2 +-
 kernel/src/libc_backend.cpp                   |   9 +-
 kernel/src/timing.cpp                         |   3 +
 kernel/src/trace.cpp                          |   3 +-
 kernel/src/trace_framework.hpp                |   2 +-
 kernel/src/trace_framework.tpp                |   6 +-
 kernel/test/interrupt_test.cpp                |  11 ++
 kernel/test/tests.cpp                         |  29 ----
 libs/libc/CMakeLists.txt                      |   1 +
 libs/libc/internal/debug.hpp                  |  60 +++++++
 libs/libc/memory/memory.cpp                   |   1 -
 .../include/data_structures/bit_array.hpp     |  36 +++-
 libs/libcpp/CMakeLists.txt                    |   1 +
 libs/libcpp/include/internal/debug.hpp        |  59 +++++++
 scripts/actions/find_failing_line.bash        |  24 +++
 tests/libcpp_mocks/algorithm.hpp              |   6 +-
 tests/libcpp_mocks/array.hpp                  |   6 +-
 tests/libcpp_mocks/atomic.hpp                 |   6 +-
 tests/libcpp_mocks/defines.hpp                |   6 +-
 tests/libcpp_mocks/hal/constants.hpp          |   6 +-
 tests/libcpp_mocks/span.hpp                   |   6 +-
 tests/libcpp_mocks/types.hpp                  |   6 +-
 46 files changed, 716 insertions(+), 280 deletions(-)
 create mode 100644 kernel/test/interrupt_test.cpp
 create mode 100644 libs/libc/internal/debug.hpp
 create mode 100644 libs/libcpp/include/internal/debug.hpp
 create mode 100755 scripts/actions/find_failing_line.bash

diff --git a/.gitignore b/.gitignore
index 04d0bb49..0f8f9ba9 100644
--- a/.gitignore
+++ b/.gitignore
@@ -54,3 +54,5 @@ tools
 __pycache__
 logs
 test_framework_logs
+
+generated
diff --git a/kernel/arch/x86_64/CMakeLists.txt b/kernel/arch/x86_64/CMakeLists.txt
index 20b366ca..6daf8839 100644
--- a/kernel/arch/x86_64/CMakeLists.txt
+++ b/kernel/arch/x86_64/CMakeLists.txt
@@ -58,9 +58,9 @@ alkos_register_runtime_environment(
     QEMU_COMMAND
         "qemu-system-x86_64"
     QEMU_NORMAL_FLAGS
-    "-serial stdio -enable-kvm -cpu max -display default,show-cursor=on -k en-us -m 4G -smp sockets=1,cores=4,threads=1"
+    "-serial stdio -enable-kvm -cpu max -display default,show-cursor=on -k en-us -m 4G -smp sockets=1,cores=4,threads=1 -no-reboot"
     QEMU_TEST_FLAGS
-        "-serial stdio -enable-kvm -cpu max -display none -m 4G -smp sockets=1,cores=4,threads=1"
+        "-serial stdio -enable-kvm -cpu max -display none -m 4G -smp sockets=1,cores=4,threads=1 -no-reboot"
     MODULES
         alkos.boot.loader.64
         alkos.kernel
diff --git a/kernel/arch/x86_64/boot/lib/abi/transition_data.hpp b/kernel/arch/x86_64/boot/lib/abi/transition_data.hpp
index eeb18417..8d9775fe 100644
--- a/kernel/arch/x86_64/boot/lib/abi/transition_data.hpp
+++ b/kernel/arch/x86_64/boot/lib/abi/transition_data.hpp
@@ -17,7 +17,7 @@ struct alignas(64) TransitionData {
     alignas(64) VirtualMemoryManager::VmmState vmm_state;
 };
 
-struct alignas(64) KernelArguments {
+struct PACK alignas(64) KernelArguments {
     /// Kernel Mem Layout
     u64 kernel_start_addr;
     u64 kernel_end_addr;
diff --git a/kernel/arch/x86_64/src/cpu/utils.cpp b/kernel/arch/x86_64/src/cpu/utils.cpp
index df0eed6f..ba744baa 100644
--- a/kernel/arch/x86_64/src/cpu/utils.cpp
+++ b/kernel/arch/x86_64/src/cpu/utils.cpp
@@ -1,74 +1,26 @@
 #include "cpu/utils.hpp"
+#include "trace_framework.hpp"
 
-#include <assert.h>
-#include <stdio.h>
-#include <hal/terminal.hpp>
-
-/**
- * @brief Capture current CPU register state
- *
- * @return CpuState structure containing current register values
- */
-CpuState DumpCpuState()
-{
-    CpuState cpu_state{};
-
-    __asm__ volatile("movq %%rax, %0" : "=m"(cpu_state.general_purpose_registers[CpuState::kRax]));
-    __asm__ volatile("movq %%rbx, %0" : "=m"(cpu_state.general_purpose_registers[CpuState::kRbx]));
-    __asm__ volatile("movq %%rcx, %0" : "=m"(cpu_state.general_purpose_registers[CpuState::kRcx]));
-    __asm__ volatile("movq %%rdx, %0" : "=m"(cpu_state.general_purpose_registers[CpuState::kRdx]));
-    __asm__ volatile("movq %%rsi, %0" : "=m"(cpu_state.general_purpose_registers[CpuState::kRsi]));
-    __asm__ volatile("movq %%rdi, %0" : "=m"(cpu_state.general_purpose_registers[CpuState::kRdi]));
-    __asm__ volatile("movq %%rbp, %0" : "=m"(cpu_state.general_purpose_registers[CpuState::kRbp]));
-    __asm__ volatile("movq %%rsp, %0" : "=m"(cpu_state.general_purpose_registers[CpuState::kRsp]));
-    __asm__ volatile("movq %%r8, %0" : "=m"(cpu_state.general_purpose_registers[CpuState::kR8]));
-    __asm__ volatile("movq %%r9, %0" : "=m"(cpu_state.general_purpose_registers[CpuState::kR9]));
-    __asm__ volatile("movq %%r10, %0" : "=m"(cpu_state.general_purpose_registers[CpuState::kR10]));
-    __asm__ volatile("movq %%r11, %0" : "=m"(cpu_state.general_purpose_registers[CpuState::kR11]));
-    __asm__ volatile("movq %%r12, %0" : "=m"(cpu_state.general_purpose_registers[CpuState::kR12]));
-    __asm__ volatile("movq %%r13, %0" : "=m"(cpu_state.general_purpose_registers[CpuState::kR13]));
-    __asm__ volatile("movq %%r14, %0" : "=m"(cpu_state.general_purpose_registers[CpuState::kR14]));
-    __asm__ volatile("movq %%r15, %0" : "=m"(cpu_state.general_purpose_registers[CpuState::kR15]));
-
-    return cpu_state;
-}
-
-/**
- * Simply formats the CPU state into a human-readable string.
- *
- * @param buff - buffer to write to
- * @param buff_size - size of buffer
- */
-void CpuState::GetStateDesc(char *buff, const size_t buff_size) const
+void TraceDumpedRegisters(const DumpedRegisters *regs)
 {
-    static constexpr const char *kRegNames[]{"rax", "rbx", "rcx", "rdx", "rsi", "rdi",
-                                             "rbp", "rsp", "r8",  "r9",  "r10", "r11",
-                                             "r12", "r13", "r14", "r15"};
+    static constexpr const char *kRegNames[] = {"rax", "rbx", "rcx", "rdx", "rsi", "rdi",
+                                                "rbp", "rsp", "r8",  "r9",  "r10", "r11",
+                                                "r12", "r13", "r14", "r15", "rip", "rflags",
+                                                "cr0", "cr2", "cr3", "cr4"};
 
+    static constexpr size_t kBuffSize = 1024;
+    char buff[kBuffSize];
     size_t offset = 0;
 
-    for (int i = 0; i < kGprLast && offset < buff_size; ++i) {
-        const int written = snprintf(
-            buff + offset, buff_size - offset, "%s: 0x%016llx\n", kRegNames[i],
-            general_purpose_registers[i]
+    for (size_t i = 0; i < regs->flat.size() && offset < kBuffSize; ++i) {
+        int written = snprintf(
+            buff + offset, kBuffSize - offset, "%s: 0x%016llx\n", kRegNames[i],
+            static_cast<unsigned long long>(regs->flat[i])
         );
-
+        ASSERT_GT(written, 0);
+        ASSERT_LT(written + offset, kBuffSize);
         offset += written;
-        ASSERT_NEQ(offset, buff_size);
     }
-}
-
-/**
- * @brief Print formatted dump of CPU register state
- *
- * Outputs current values of all general-purpose registers
- * to the terminal in a human-readable format.
- */
-void CpuState::DumpStateDesc() const
-{
-    static constexpr size_t kSizeBuff = 2048;
-    char buff[kSizeBuff];
 
-    GetStateDesc(buff, kSizeBuff);
-    hal::TerminalWriteString(buff);
+    TRACE_INFO_GENERAL("Dumped registers:\n%s", buff);
 }
diff --git a/kernel/arch/x86_64/src/cpu/utils.hpp b/kernel/arch/x86_64/src/cpu/utils.hpp
index 85f48ef1..6fc01238 100644
--- a/kernel/arch/x86_64/src/cpu/utils.hpp
+++ b/kernel/arch/x86_64/src/cpu/utils.hpp
@@ -2,7 +2,10 @@
 #define KERNEL_ARCH_X86_64_SRC_CPU_UTILS_HPP_
 
 #include <defines.hpp>
+#include <template/rolled_switch.hpp>
 #include <types.hpp>
+
+#include "array.hpp"
 #include "include/io.hpp"
 
 /**
@@ -69,41 +72,133 @@ FAST_CALL void OsHangNoInterrupts()
  *
  * Executes INT instruction with specified vector number.
  */
-FAST_CALL void InvokeInterrupt(const u8 idx) { __asm__ volatile("int %0" : : "N"(idx)); }
+template <const u8 idx>
+FAST_CALL void InvokeInterrupt()
+{
+    __asm__ volatile("int %0" : : "N"(idx));
+}
 
-/**
- * @brief CPU state container structure
- *
- * Holds values of all general-purpose registers for x86_64 CPU.
- */
-struct PACK CpuState final {
-    enum GeneralPurposeRegisters {
-        kRax,
-        kRbx,
-        kRcx,
-        kRdx,
-        kRsi,
-        kRdi,
-        kRbp,
-        kRsp,
-        kR8,
-        kR9,
-        kR10,
-        kR11,
-        kR12,
-        kR13,
-        kR14,
-        kR15,
-        kGprLast,
-    };
+FAST_CALL void InvokeInterruptDynamic(const u8 idx)
+{
+    template_lib::RolledSwitch<u8, 64, 1>(
+        []<const u64 idx> {
+            return InvokeInterrupt<idx>();
+        },
+        idx
+    );
+}
 
-    u64 general_purpose_registers[kGprLast];
+enum RegisterIdx : size_t {
+    kRegRax = 0,
+    kRegRbx,
+    kRegRcx,
+    kRegRdx,
+    kRegRsi,
+    kRegRdi,
+    kRegRbp,
+    kRegRsp,
+    kRegR8,
+    kRegR9,
+    kRegR10,
+    kRegR11,
+    kRegR12,
+    kRegR13,
+    kRegR14,
+    kRegR15,
+    kRegRip,
+    kRegRflags,
+    kRegCr0,
+    kRegCr2,
+    kRegCr3,
+    kRegCr4,
+    kRegCount
+};
 
-    void GetStateDesc(char *buff, size_t buff_size) const;
+union DumpedRegisters {
+    struct {
+        u64 rax, rbx, rcx, rdx, rsi, rdi, rbp, rsp;
+        u64 r8, r9, r10, r11, r12, r13, r14, r15;
+        u64 rip;
+        u64 rflags;
+        u64 cr0, cr2, cr3, cr4;
+    };
 
-    void DumpStateDesc() const;
+    std::array<u64, 22> flat;
 };
 
-[[nodiscard]] CpuState DumpCpuState();
+FAST_CALL void DumpRegisters(DumpedRegisters *regs)
+{
+    __asm__ volatile(
+        "movq %%rax, 0x00(%0) \n"
+        "movq %%rbx, 0x08(%0) \n"
+        "movq %%rcx, 0x10(%0) \n"
+        "movq %%rdx, 0x18(%0) \n"
+        "movq %%rsi, 0x20(%0) \n"
+        "movq %%rdi, 0x28(%0) \n"
+        "movq %%rbp, 0x30(%0) \n"
+        "movq %%rsp, 0x38(%0) \n"
+
+        "movq %%r8,  0x40(%0) \n"
+        "movq %%r9,  0x48(%0) \n"
+        "movq %%r10, 0x50(%0) \n"
+        "movq %%r11, 0x58(%0) \n"
+        "movq %%r12, 0x60(%0) \n"
+        "movq %%r13, 0x68(%0) \n"
+        "movq %%r14, 0x70(%0) \n"
+        "movq %%r15, 0x78(%0) \n"
+
+        "lea (%%rip), %%rax   \n"
+        "movq %%rax, 0x80(%0) \n"
+
+        "pushfq               \n"
+        "popq %%rax           \n"
+        "movq %%rax, 0x88(%0) \n"
+
+        "movq %%cr0, %%rax    \n"
+        "movq %%rax, 0x90(%0) \n"
+
+        "movq %%cr2, %%rax    \n"
+        "movq %%rax, 0x98(%0) \n"
+
+        "movq %%cr3, %%rax    \n"
+        "movq %%rax, 0xA0(%0) \n"
+
+        "movq %%cr4, %%rax    \n"
+        "movq %%rax, 0xA8(%0) \n"
+
+        :
+        : "r"(regs)
+        : "rax", "memory"
+    );
+}
+
+FAST_CALL void DumpGeneralRegisters(DumpedRegisters *regs)
+{
+    __asm__ volatile(
+        "movq %%rax, 0x00(%0) \n"
+        "movq %%rbx, 0x08(%0) \n"
+        "movq %%rcx, 0x10(%0) \n"
+        "movq %%rdx, 0x18(%0) \n"
+        "movq %%rsi, 0x20(%0) \n"
+        "movq %%rdi, 0x28(%0) \n"
+        "movq %%rbp, 0x30(%0) \n"
+        "movq %%rsp, 0x38(%0) \n"
+
+        "movq %%r8,  0x40(%0) \n"
+        "movq %%r9,  0x48(%0) \n"
+        "movq %%r10, 0x50(%0) \n"
+        "movq %%r11, 0x58(%0) \n"
+        "movq %%r12, 0x60(%0) \n"
+        "movq %%r13, 0x68(%0) \n"
+        "movq %%r14, 0x70(%0) \n"
+        "movq %%r15, 0x78(%0) \n"
+
+        :
+        : "r"(regs)
+        : "rax", "memory"
+    );
+}
+
+void TraceDumpedRegisters(const DumpedRegisters *regs);
 
 #endif  // KERNEL_ARCH_X86_64_SRC_CPU_UTILS_HPP_
diff --git a/kernel/arch/x86_64/src/drivers/hpet/hpet.cpp b/kernel/arch/x86_64/src/drivers/hpet/hpet.cpp
index 7560459b..a51e27d2 100644
--- a/kernel/arch/x86_64/src/drivers/hpet/hpet.cpp
+++ b/kernel/arch/x86_64/src/drivers/hpet/hpet.cpp
@@ -119,8 +119,6 @@ Hpet::Hpet(acpi_hpet *table)
     hpet_entry.id            = static_cast<u64>(arch::HardwareClockId::kHpet);
     hpet_entry.frequency_kHz = (kFemtoSecondsPerSecond / clock_period_) / 1000;
 
-    BlockHardwareInterrupts();
-
     /* Callbacks */
     hpet_entry.read           = ReadCb;
     hpet_entry.enable_device  = EnableDeviceCb;
diff --git a/kernel/arch/x86_64/src/hal/impl/debug.cpp b/kernel/arch/x86_64/src/hal/impl/debug.cpp
index 21ad8763..4c745bae 100644
--- a/kernel/arch/x86_64/src/hal/impl/debug.cpp
+++ b/kernel/arch/x86_64/src/hal/impl/debug.cpp
@@ -8,6 +8,7 @@ extern char stack_bottom;
 
 namespace arch
 {
+void Noop() { asm volatile("nop"); }
 
 void DebugStack()
 {
diff --git a/kernel/arch/x86_64/src/hal/impl/debug.hpp b/kernel/arch/x86_64/src/hal/impl/debug.hpp
index d5a3afa9..85864364 100644
--- a/kernel/arch/x86_64/src/hal/impl/debug.hpp
+++ b/kernel/arch/x86_64/src/hal/impl/debug.hpp
@@ -1,9 +1,10 @@
-#ifndef ALKOS_KERNEL_ARCH_X86_64_SRC_HAL_IMPL_DEBUG_HPP_
-#define ALKOS_KERNEL_ARCH_X86_64_SRC_HAL_IMPL_DEBUG_HPP_
+#ifndef KERNEL_ARCH_X86_64_SRC_HAL_IMPL_DEBUG_HPP_
+#define KERNEL_ARCH_X86_64_SRC_HAL_IMPL_DEBUG_HPP_
 
 namespace arch
 {
 void DebugStack();
-}
+void Noop();
+}  // namespace arch
 
-#endif  // ALKOS_KERNEL_ARCH_X86_64_SRC_HAL_IMPL_DEBUG_HPP_
+#endif  // KERNEL_ARCH_X86_64_SRC_HAL_IMPL_DEBUG_HPP_
diff --git a/kernel/arch/x86_64/src/hal/impl/interrupt_params.hpp b/kernel/arch/x86_64/src/hal/impl/interrupt_params.hpp
index d2b145b8..53735e60 100644
--- a/kernel/arch/x86_64/src/hal/impl/interrupt_params.hpp
+++ b/kernel/arch/x86_64/src/hal/impl/interrupt_params.hpp
@@ -5,6 +5,24 @@
 #include <hal/api/interrupts_params.hpp>
 #include <types.hpp>
 
+struct PACK IsrRegisters {
+    uint64_t rax;
+    uint64_t rcx;
+    uint64_t rdx;
+    uint64_t rsi;
+    uint64_t rdi;
+    uint64_t r8;
+    uint64_t r9;
+    uint64_t r10;
+    uint64_t r11;
+    uint64_t rbp;
+    uint64_t rbx;
+    uint64_t r12;
+    uint64_t r13;
+    uint64_t r14;
+    uint64_t r15;
+};
+
 struct PACK IsrStackFrame {
     u64 rip;
     u64 cs;
@@ -13,6 +31,7 @@ struct PACK IsrStackFrame {
 };
 
 struct PACK IsrErrorStackFrame {
+    IsrRegisters registers;
     u64 error_code;
     IsrStackFrame isr_stack_frame;
 };
@@ -25,7 +44,7 @@ static constexpr size_t kNumSoftwareInterrupts  = 32;
 static constexpr size_t kNumX86_64CpuExceptions = 32;
 static constexpr size_t kNumX86_64Irqs          = 16;
 
-struct ExceptionData : public IsrErrorStackFrame {
+struct ExceptionData : IsrErrorStackFrame {
 };
 
 /* Mapping params */
diff --git a/kernel/arch/x86_64/src/hal/impl/interrupts.cpp b/kernel/arch/x86_64/src/hal/impl/interrupts.cpp
index 88a6fb65..bc011ba0 100644
--- a/kernel/arch/x86_64/src/hal/impl/interrupts.cpp
+++ b/kernel/arch/x86_64/src/hal/impl/interrupts.cpp
@@ -134,13 +134,6 @@ void Interrupts::MapToLogicalInterrupts_()
         .GetInterrupts()
         .GetLit()
         .MapLogicalInterruptToHw<intr::InterruptType::kSoftwareInterrupt>(0, 48);
-
-    HardwareModule::Get()
-        .GetInterrupts()
-        .GetLit()
-        .InstallInterruptHandler<intr::InterruptType::kSoftwareInterrupt>(
-            0, intr::SwHandler{.handler = TestIsr}
-        );
 }
 
 void Interrupts::SetupPicAsDefaultDriver_()
diff --git a/kernel/arch/x86_64/src/hal/impl/io.hpp b/kernel/arch/x86_64/src/hal/impl/io.hpp
index 0e4e2c5a..4c013bfe 100644
--- a/kernel/arch/x86_64/src/hal/impl/io.hpp
+++ b/kernel/arch/x86_64/src/hal/impl/io.hpp
@@ -26,4 +26,4 @@ T IoRead(size_t addr)
 
 }  // namespace arch
 
-#endif /* KERNEL_ARCH_X86_64_SRC_HAL_IMPL_IO_HPP_ */
+#endif  // KERNEL_ARCH_X86_64_SRC_HAL_IMPL_IO_HPP_
diff --git a/kernel/arch/x86_64/src/hal/impl/panic.cpp b/kernel/arch/x86_64/src/hal/impl/panic.cpp
index 9f77795d..d2e8e517 100644
--- a/kernel/arch/x86_64/src/hal/impl/panic.cpp
+++ b/kernel/arch/x86_64/src/hal/impl/panic.cpp
@@ -1,7 +1,6 @@
 #include <autogen/feature_flags.h>
 #include <test_module/test_module.hpp>
 
-#include <hal/impl/terminal.hpp>
 #include "hal/impl/panic.hpp"
 
 #include "cpu/utils.hpp"
diff --git a/kernel/arch/x86_64/src/interrupts/idt.cpp b/kernel/arch/x86_64/src/interrupts/idt.cpp
index a0c78ea8..1f89eeac 100644
--- a/kernel/arch/x86_64/src/interrupts/idt.cpp
+++ b/kernel/arch/x86_64/src/interrupts/idt.cpp
@@ -11,6 +11,8 @@
 
 #include <assert.h>
 #include <bit.hpp>
+#include <hal/terminal.hpp>
+
 #include "trace_framework.hpp"
 
 static constexpr u32 kStubTableSize = 64;
@@ -47,21 +49,47 @@ NO_RET void DefaultInterruptHandler(const u8 idt_idx)
     hal::KernelPanicFormat("Received unsupported interrupt with code: %hhu\n", idt_idx);
 }
 
-NO_RET FAST_CALL void DefaultExceptionHandler(IsrErrorStackFrame *stack_frame, const u8 idt_idx)
+static void FormatIsrRegisters(
+    const IsrErrorStackFrame *stack_frame, char *buff, const size_t buff_size
+)
 {
-    static constexpr size_t kStateMsgSize = 1024;
-
-    CpuState cpu_state = DumpCpuState();
+    static constexpr const char *kRegNames[] = {"rip", "rflags", "rsp", "rax", "rbx", "rcx",
+                                                "rdx", "rsi",    "rdi", "rbp", "r8",  "r9",
+                                                "r10", "r11",    "r12", "r13", "r14", "r15"};
+
+    const uint64_t reg_values[] = {
+        stack_frame->isr_stack_frame.rip, stack_frame->isr_stack_frame.rflags,
+        stack_frame->isr_stack_frame.rsp, stack_frame->registers.rax,
+        stack_frame->registers.rbx,       stack_frame->registers.rcx,
+        stack_frame->registers.rdx,       stack_frame->registers.rsi,
+        stack_frame->registers.rdi,       stack_frame->registers.rbp,
+        stack_frame->registers.r8,        stack_frame->registers.r9,
+        stack_frame->registers.r10,       stack_frame->registers.r11,
+        stack_frame->registers.r12,       stack_frame->registers.r13,
+        stack_frame->registers.r14,       stack_frame->registers.r15
+    };
+
+    size_t offset             = 0;
+    constexpr size_t num_regs = sizeof(reg_values) / sizeof(reg_values[0]);
+    for (size_t i = 0; i < num_regs && offset < buff_size; ++i) {
+        int written = snprintf(
+            buff + offset, buff_size - offset, "%s: 0x%016llx\n", kRegNames[i],
+            static_cast<unsigned long long>(reg_values[i])
+        );
+        ASSERT_GT(written, 0);
+        ASSERT_LT(offset + written, buff_size);
+        offset += written;
+    }
+}
 
-    /* restore relevant registers to the state before printing msg */
-    cpu_state.general_purpose_registers[CpuState::kRdi] =
-        *(reinterpret_cast<u64 *>(stack_frame) - 1);
-    cpu_state.general_purpose_registers[CpuState::kRsi] =
-        *(reinterpret_cast<u64 *>(stack_frame) - 2);
-    cpu_state.general_purpose_registers[CpuState::kRsp] = stack_frame->isr_stack_frame.rsp;
+NO_RET FAST_CALL void DefaultExceptionHandler(
+    const IsrErrorStackFrame *stack_frame, const u8 idt_idx
+)
+{
+    static constexpr size_t kStateMsgSize = 1024;
 
     char state_buffer[kStateMsgSize];
-    cpu_state.GetStateDesc(state_buffer, kStateMsgSize);
+    FormatIsrRegisters(stack_frame, state_buffer, kStateMsgSize);
 
     const char *exception_msg = GetExceptionMsg(idt_idx);
     R_ASSERT_NOT_NULL(exception_msg);
@@ -92,34 +120,10 @@ void SimpleIrqHandler(intr::LitHwEntry &entry)
     LogIrqReceived(entry.hardware_irq, entry.logical_irq);
 }
 
-void TestIsr(intr::LitSwEntry &entry)
+void TimerIsr(intr::LitHwEntry &)
 {
-    LogIrqReceived(entry.hardware_irq, entry.logical_irq);
-
-    /* pollute all registers possible */
-    __asm__ volatile("movq $-1, %%rax" : : : "rax");
-    __asm__ volatile("movq $-1, %%rbx" : : : "rbx");
-    __asm__ volatile("movq $-1, %%rcx" : : : "rcx");
-    __asm__ volatile("movq $-1, %%rdx" : : : "rdx");
-    __asm__ volatile("movq $-1, %%rsi" : : : "rsi");
-    __asm__ volatile("movq $-1, %%rdi" : : : "rdi");
-    __asm__ volatile("movq $-1, %%r8" : : : "r8");
-    __asm__ volatile("movq $-1, %%r9" : : : "r9");
-    __asm__ volatile("movq $-1, %%r10" : : : "r10");
-    __asm__ volatile("movq $-1, %%r11" : : : "r11");
-    __asm__ volatile("movq $-1, %%r12" : : : "r12");
-    __asm__ volatile("movq $-1, %%r13" : : : "r13");
-    __asm__ volatile("movq $-1, %%r14" : : : "r14");
-    __asm__ volatile("movq $-1, %%r15" : : : "r15");
-}
-
-void TimerIsr(intr::LitHwEntry &entry)
-{
-    (void)entry;  // Unused parameter
     // LogIrqReceived(entry.hardware_irq, entry.logical_irq);
 
-    hal::DebugStack();
-
     // TODO: Temporary code
     static u64 counter = 0;
     if (!FeatureEnabled<FeatureFlag::kRunTestMode> && counter++ % 33 == 0) {
diff --git a/kernel/arch/x86_64/src/interrupts/idt.nasm b/kernel/arch/x86_64/src/interrupts/idt.nasm
index ffd0bf95..fc61e7d4 100644
--- a/kernel/arch/x86_64/src/interrupts/idt.nasm
+++ b/kernel/arch/x86_64/src/interrupts/idt.nasm
@@ -13,15 +13,20 @@ _r9  equ 48
 _r10 equ 56
 _r11 equ 64
 _rbp equ 72
+_rbx equ 80
+_r12 equ 88
+_r13 equ 96
+_r14 equ 104
+_r15 equ 112
 
-; Size needed to save the registers on the stack
-_reg_size equ 8*10
+; Size needed to save the sysv registers on the stack
+_sysv_reg_size equ 8*10
 
 ; Shadow space required for C++ function calls
 _shadow_space equ 8*4
 
 ; Macro to save all volatile registers (SysV ABI) onto the stack.
-%macro push_regs 0
+%macro push_sysv_regs 0
     mov qword [rsp + _rax], rax
     mov qword [rsp + _rcx], rcx
     mov qword [rsp + _rdx], rdx
@@ -35,7 +40,45 @@ _shadow_space equ 8*4
 %endmacro
 
 ; Macro to restore all volatile registers (SysV ABI) from the stack.
-%macro pop_regs 0
+%macro pop_sysv_regs 0
+    mov rax, qword [rsp + _rax]
+    mov rcx, qword [rsp + _rcx]
+    mov rdx, qword [rsp + _rdx]
+    mov rsi, qword [rsp + _rsi]
+    mov rdi, qword [rsp + _rdi]
+    mov r8, qword [rsp + _r8]
+    mov r9, qword [rsp + _r9]
+    mov r10, qword [rsp + _r10]
+    mov r11, qword [rsp + _r11]
+    mov rbp, qword [rsp + _rbp]
+%endmacro
+
+; Size needed to save the registers on the stack
+_all_reg_size equ 8*15
+
+; Macro to save ALL general purpose registers onto the stack.
+; Useful for Interrupt Service Routines (ISRs) or kernel panic dumps.
+%macro push_all_regs 0
+    mov qword [rsp + _rax], rax
+    mov qword [rsp + _rcx], rcx
+    mov qword [rsp + _rdx], rdx
+    mov qword [rsp + _rsi], rsi
+    mov qword [rsp + _rdi], rdi
+    mov qword [rsp + _r8], r8
+    mov qword [rsp + _r9], r9
+    mov qword [rsp + _r10], r10
+    mov qword [rsp + _r11], r11
+    mov qword [rsp + _rbp], rbp
+    mov qword [rsp + _rbx], rbx
+    mov qword [rsp + _r12], r12
+    mov qword [rsp + _r13], r13
+    mov qword [rsp + _r14], r14
+    mov qword [rsp + _r15], r15
+%endmacro
+
+; Macro to restore ALL general purpose registers from the stack.
+; Must be called in the reverse order of push_all_regs.
+%macro pop_all_regs 0
     mov rax, qword [rsp + _rax]
     mov rcx, qword [rsp + _rcx]
     mov rdx, qword [rsp + _rdx]
@@ -46,6 +89,11 @@ _shadow_space equ 8*4
     mov r10, qword [rsp + _r10]
     mov r11, qword [rsp + _r11]
     mov rbp, qword [rsp + _rbp]
+    mov rbx, qword [rsp + _rbx]
+    mov r12, qword [rsp + _r12]
+    mov r13, qword [rsp + _r13]
+    mov r14, qword [rsp + _r14]
+    mov r15, qword [rsp + _r15]
 %endmacro
 
 ; Macro for CPU exceptions that DO NOT push an error code.
@@ -54,16 +102,16 @@ _shadow_space equ 8*4
 %macro exception_wrapper 1
 isr_wrapper_%+%1:
     push 0                      ; Push a dummy error code for alignment.
-    sub rsp, _reg_size          ; Allocate space for saving registers.
-    push_regs                   ; Save registers.
+    sub rsp, _all_reg_size          ; Allocate space for saving registers.
+    push_all_regs                   ; Save registers.
     sub rsp, _shadow_space      ; Allocate shadow space.
     cld                         ; Clear direction flag.
     mov rdi, %1                 ; Arg1: interrupt number.
-    lea rsi, [rsp + _shadow_space + _reg_size] ; Arg2: pointer to stack frame.
+    lea rsi, [rsp + _shadow_space] ; Arg2: pointer to stack frame.
     call HandleException
     add rsp, _shadow_space      ; Deallocate shadow space.
-    pop_regs                    ; Restore registers.
-    add rsp, _reg_size          ; Deallocate register save space.
+    pop_all_regs                    ; Restore registers.
+    add rsp, _all_reg_size          ; Deallocate register save space.
     add rsp, 8                  ; Pop dummy error code.
     iretq
 %endmacro
@@ -72,17 +120,16 @@ isr_wrapper_%+%1:
 ; Calls 'HandleException(u16 lirq, ExceptionData* data)'.
 %macro exception_error_wrapper 1
 isr_wrapper_%+%1:
-    sub rsp, _reg_size          ; Allocate space for saving registers.
-    push_regs                   ; Save registers.
+    sub rsp, _all_reg_size          ; Allocate space for saving registers.
+    push_all_regs                   ; Save registers.
     sub rsp, _shadow_space      ; Allocate shadow space.
     cld                         ; Clear direction flag.
     mov rdi, %1                 ; Arg1: interrupt number.
-    lea rsi, [rsp + _shadow_space + _reg_size] ; Arg2: pointer to stack frame.
+    lea rsi, [rsp + _shadow_space] ; Arg2: pointer to stack frame.
     call HandleException
     add rsp, _shadow_space      ; Deallocate shadow space.
-    pop_regs                    ; Restore registers.
-    add rsp, _reg_size          ; Deallocate register save space.
-    add rsp, 8                  ; Pop real error code.
+    pop_all_regs                    ; Restore registers.
+    add rsp, _all_reg_size          ; Deallocate register save space.
     iretq
 %endmacro
 
@@ -90,15 +137,15 @@ isr_wrapper_%+%1:
 ; Calls a handler with the signature 'void handler(u16 lirq)'.
 %macro interrupt_wrapper 3 ; %1: Logical IRQ, %2: idt idx %3: C handler function
 isr_wrapper_%+%2:
-    sub rsp, _reg_size          ; Allocate space for saving registers.
-    push_regs                   ; Save registers.
+    sub rsp, _sysv_reg_size          ; Allocate space for saving registers.
+    push_sysv_regs                   ; Save registers.
     sub rsp, _shadow_space      ; Allocate shadow space for function calls.
     cld                         ; Clear direction flag for string operations.
     mov rdi, %1                 ; Pass the mapped IRQ number as the first argument.
     call %3                     ; Call the specific ISR handler.
     add rsp, _shadow_space      ; Deallocate shadow space.
-    pop_regs                    ; Restore registers.
-    add rsp, _reg_size          ; Deallocate register save space.
+    pop_sysv_regs                    ; Restore registers.
+    add rsp, _sysv_reg_size          ; Deallocate register save space.
     iretq                       ; Return from interrupt.
 %endmacro
 
diff --git a/kernel/arch/x86_64/src/kernel/init.cpp b/kernel/arch/x86_64/src/kernel/init.cpp
index b4a60f89..8ece59b7 100644
--- a/kernel/arch/x86_64/src/kernel/init.cpp
+++ b/kernel/arch/x86_64/src/kernel/init.cpp
@@ -64,7 +64,6 @@ void ArchInit(const RawBootArguments &)
     EnableSSE();
     EnableAVX();
 
-    hal::DebugStack();
     HardwareModule::Init();
     HardwareModule::Get().GetInterrupts().FirstStageInit();
 
diff --git a/kernel/arch/x86_64/src/startup/alkos_entry.nasm b/kernel/arch/x86_64/src/startup/alkos_entry.nasm
index c2eaddef..33f8ec8d 100644
--- a/kernel/arch/x86_64/src/startup/alkos_entry.nasm
+++ b/kernel/arch/x86_64/src/startup/alkos_entry.nasm
@@ -9,9 +9,6 @@
           ; GCC compiler global destructor support
           extern _fini
 
-          ; Pre-Kernel Initialization that couldn't be in loaders
-          extern PreKernelInit
-
           ; Kernel Entry Point
           extern KernelMain
 
diff --git a/kernel/arch/x86_64/src/tests/interrupts_tests.cpp b/kernel/arch/x86_64/src/tests/interrupts_tests.cpp
index 4bb6f2c0..6d2d0fb0 100644
--- a/kernel/arch/x86_64/src/tests/interrupts_tests.cpp
+++ b/kernel/arch/x86_64/src/tests/interrupts_tests.cpp
@@ -1,29 +1,122 @@
 /* internal includes */
-#include <assert.h>
-#include <bit.hpp>
-#include "cpu/utils.hpp"
+#include "interrupts/interrupt_types.hpp"
+#include "modules/hardware.hpp"
 
 // ------------------------------
 // Preserve cpu state test
 // ------------------------------
 
-// TODO - Use test_module/test.hpp
-extern "C" void PreserveCpuStateTest()
+static void PolluteAllRegistersSw(intr::LitSwEntry &)
 {
-    /* current interrupt idx picked for testing */
-    static constexpr u8 kTestInterrupt = 48;
+    /* pollute all registers possible */
+    __asm__ volatile("movq $-1, %%rax" : : : "rax");
+    __asm__ volatile("movq $-1, %%rbx" : : : "rbx");
+    __asm__ volatile("movq $-1, %%rcx" : : : "rcx");
+    __asm__ volatile("movq $-1, %%rdx" : : : "rdx");
+    __asm__ volatile("movq $-1, %%rsi" : : : "rsi");
+    __asm__ volatile("movq $-1, %%rdi" : : : "rdi");
+    __asm__ volatile("movq $-1, %%r8" : : : "r8");
+    __asm__ volatile("movq $-1, %%r9" : : : "r9");
+    __asm__ volatile("movq $-1, %%r10" : : : "r10");
+    __asm__ volatile("movq $-1, %%r11" : : : "r11");
+    __asm__ volatile("movq $-1, %%r12" : : : "r12");
+    __asm__ volatile("movq $-1, %%r13" : : : "r13");
+    __asm__ volatile("movq $-1, %%r14" : : : "r14");
+    __asm__ volatile("movq $-1, %%r15" : : : "r15");
+}
+
+static DumpedRegisters g_DumpedRegisters{};
+
+static void DivZeroExceptionHandler(intr::LitExcEntry &entry, hal::ExceptionData *data)
+{
+    g_DumpedRegisters.rax = data->registers.rax;
+    g_DumpedRegisters.rbx = data->registers.rbx;
+    g_DumpedRegisters.rcx = data->registers.rcx;
+    g_DumpedRegisters.rdx = data->registers.rdx;
+
+    g_DumpedRegisters.rsi = data->registers.rsi;
+    g_DumpedRegisters.rdi = data->registers.rdi;
+    g_DumpedRegisters.rbp = data->registers.rbp;
+    g_DumpedRegisters.rsp = data->isr_stack_frame.rsp;
+
+    g_DumpedRegisters.r8  = data->registers.r8;
+    g_DumpedRegisters.r9  = data->registers.r9;
+    g_DumpedRegisters.r10 = data->registers.r10;
+    g_DumpedRegisters.r11 = data->registers.r11;
+    g_DumpedRegisters.r12 = data->registers.r12;
+    g_DumpedRegisters.r13 = data->registers.r13;
+    g_DumpedRegisters.r14 = data->registers.r14;
+    g_DumpedRegisters.r15 = data->registers.r15;
+
+    TraceDumpedRegisters(&g_DumpedRegisters);
+}
+
+void ExceptionTestSavesAllRegisters()
+{
+    DumpedRegisters registers{};
+
+    /* Ensure all register state is preserved */
+    const u16 sw_lirq = HardwareModule::Get().GetInterrupts().GetLit().InstallSwIntrFirstFree(
+        {.handler = PolluteAllRegistersSw}
+    );
+    R_ASSERT_NEQ(sw_lirq, std::numeric_limits<u16>::max());
+    const u8 hw_intr = HardwareModule::Get()
+                           .GetInterrupts()
+                           .GetLit()
+                           .GetEntry<intr::InterruptType::kSoftwareInterrupt>(sw_lirq)
+                           .hardware_irq;
 
     BlockHardwareInterrupts();
+    InvokeInterruptDynamic(hw_intr);
+    DumpRegisters(&registers);
 
-    const auto initial_cpu_state = DumpCpuState();
-    initial_cpu_state.DumpStateDesc();
+    for (size_t idx = 0; idx <= RegisterIdx::kRegR15; ++idx) {
+        const u64 content = registers.flat[idx];
+        R_ASSERT_NEQ(kBitMask64, content);
+    }
 
-    InvokeInterrupt(kTestInterrupt);
+    /* Ensure exceptions has proper data */
+    HardwareModule::Get()
+        .GetInterrupts()
+        .GetLit()
+        .InstallInterruptHandler<intr::InterruptType::kException>(
+            0, {.handler = DivZeroExceptionHandler}
+        );
 
-    const auto final_cpu_state = DumpCpuState();
-    final_cpu_state.DumpStateDesc();
+    __asm__ volatile("movq $-1, %%rax" : : : "rax");
+    __asm__ volatile("movq $-1, %%rbx" : : : "rbx");
+    __asm__ volatile("movq $-1, %%rcx" : : : "rcx");
+    __asm__ volatile("movq $-1, %%rdx" : : : "rdx");
+    __asm__ volatile("movq $-1, %%r8" : : : "r8");
+    __asm__ volatile("movq $-1, %%r9" : : : "r9");
+    __asm__ volatile("movq $-1, %%r10" : : : "r10");
+    __asm__ volatile("movq $-1, %%r11" : : : "r11");
+    __asm__ volatile("movq $-1, %%r12" : : : "r12");
+    __asm__ volatile("movq $-1, %%r13" : : : "r13");
+    __asm__ volatile("movq $-1, %%r14" : : : "r14");
+    __asm__ volatile("movq $-1, %%r15" : : : "r15");
+    DumpedRegisters exc_registers{};
+    DumpGeneralRegisters(&exc_registers);
+    InvokeInterrupt<0>();
+    TraceDumpedRegisters(&exc_registers);
+    trace::Flush();
 
-    for (const u64 &cpu_state : final_cpu_state.general_purpose_registers) {
-        R_ASSERT_NEQ(kBitMask64, cpu_state);
+    for (size_t idx = 0; idx <= RegisterIdx::kRegR15; ++idx) {
+        R_ASSERT_EQ(
+            exc_registers.flat[idx], g_DumpedRegisters.flat[idx], "Failed on idx: %zu", idx
+        );
     }
+
+    EnableHardwareInterrupts();
+}
+
+/**
+ *  @brief Test should simply drop 0 division exception
+ */
+void ExceptionFailsKernelTest()
+{
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdiv-by-zero"
+    [[maybe_unused]] volatile int a = 9 / 0;
+#pragma GCC diagnostic pop
 }
diff --git a/kernel/arch/x86_64/src/tests/manual_tests.cpp b/kernel/arch/x86_64/src/tests/manual_tests.cpp
index 23db5495..2f134dc2 100644
--- a/kernel/arch/x86_64/src/tests/manual_tests.cpp
+++ b/kernel/arch/x86_64/src/tests/manual_tests.cpp
@@ -6,6 +6,8 @@
  */
 MTEST(VerifyDefaultExceptionMsg)
 {
-    const auto ptr = reinterpret_cast<u64 *>(~static_cast<u64>(0));
-    ++(*ptr);
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdiv-by-zero"
+    [[maybe_unused]] volatile int a = 9 / 0;
+#pragma GCC diagnostic pop
 }
diff --git a/kernel/src/acpi/osl.cpp b/kernel/src/acpi/osl.cpp
index 5f45afe8..3ae035d2 100644
--- a/kernel/src/acpi/osl.cpp
+++ b/kernel/src/acpi/osl.cpp
@@ -8,7 +8,6 @@
 #include <modules/hardware.hpp>
 #include <modules/timing.hpp>
 #include <todo.hpp>
-#include "todo.hpp"
 #include "trace_framework.hpp"
 
 uacpi_status uacpi_kernel_get_rsdp(uacpi_phys_addr *out_rsdp_address)
@@ -176,22 +175,73 @@ uacpi_status uacpi_kernel_handle_firmware_request(uacpi_firmware_request *)
     return UACPI_STATUS_UNIMPLEMENTED;
 }
 
+struct UacpiInterrupt {
+    uacpi_interrupt_handler uacpi_handler;
+    uacpi_handle ctx;
+};
+
+static void UacpiHander(intr::LitHwEntry &handler)
+{
+    auto *uacpi_interrupt = static_cast<UacpiInterrupt *>(handler.handler_data.data);
+    uacpi_interrupt->uacpi_handler(uacpi_interrupt->ctx);
+}
+
 uacpi_status uacpi_kernel_install_interrupt_handler(
-    uacpi_u32 irq, uacpi_interrupt_handler, uacpi_handle ctx, uacpi_handle *out_irq_handle
+    uacpi_u32 irq, uacpi_interrupt_handler uacpi_handler, uacpi_handle ctx,
+    uacpi_handle *out_irq_handle
 )
 {
-    (void)irq;
-    (void)ctx;
-    (void)out_irq_handle;
-    return UACPI_STATUS_UNIMPLEMENTED;
+    DEBUG_INFO_BOOT(
+        "Installing uacpi irq: %u with handler: %p", irq, reinterpret_cast<void *>(uacpi_handler)
+    );
+
+    auto ptr_or_error = Mem::KMalloc(sizeof(UacpiInterrupt));
+    ASSERT_TRUE(static_cast<bool>(ptr_or_error));
+    auto *intr_ptr          = static_cast<UacpiInterrupt *>(ptr_or_error.value());
+    intr_ptr->ctx           = ctx;
+    intr_ptr->uacpi_handler = uacpi_handler;
+
+    const intr::HwHandler handler{
+        .handler = UacpiHander,
+        .data    = intr_ptr,
+    };
+
+    /* Note: on x86_64 irq == lirq for hardware requests */
+    HardwareModule::Get()
+        .GetInterrupts()
+        .GetLit()
+        .InstallInterruptHandler<intr::InterruptType::kHardwareInterrupt>(irq, handler);
+
+    auto &entry = HardwareModule::Get()
+                      .GetInterrupts()
+                      .GetLit()
+                      .GetEntry<intr::InterruptType::kHardwareInterrupt>(irq);
+    *out_irq_handle = reinterpret_cast<void *>(&entry);
+    return UACPI_STATUS_OK;
 }
 
 uacpi_status uacpi_kernel_uninstall_interrupt_handler(
-    uacpi_interrupt_handler, uacpi_handle irq_handle
+    uacpi_interrupt_handler handler, uacpi_handle irq_handle
 )
 {
-    (void)irq_handle;
-    return UACPI_STATUS_UNIMPLEMENTED;
+    DEBUG_INFO_BOOT("Uninstalling uacpi irq: %p", handler);
+
+    auto entry = static_cast<intr::LitHwEntry *>(irq_handle);
+    ASSERT_NOT_NULL(irq_handle);
+    ASSERT_EQ(
+        reinterpret_cast<void *>(handler),
+        reinterpret_cast<void *>(
+            static_cast<UacpiInterrupt *>(entry->handler_data.data)->uacpi_handler
+        )
+    );
+
+    Mem::KFree(entry->handler_data.data);
+    HardwareModule::Get()
+        .GetInterrupts()
+        .GetLit()
+        .UninstallEntry<intr::InterruptType::kHardwareInterrupt>(entry->logical_irq);
+
+    return UACPI_STATUS_OK;
 }
 
 uacpi_status uacpi_kernel_schedule_work(uacpi_work_type, uacpi_work_handler, uacpi_handle ctx)
diff --git a/kernel/src/hal/api/boot_args.hpp b/kernel/src/hal/api/boot_args.hpp
index fef87863..33132db1 100644
--- a/kernel/src/hal/api/boot_args.hpp
+++ b/kernel/src/hal/api/boot_args.hpp
@@ -7,7 +7,7 @@
 namespace arch
 {
 struct RawBootArguments;
-struct RawBootArgumentsAPI {
+struct PACK RawBootArgumentsAPI {
     /// Mem Layout
     u64 kernel_start_addr;
     u64 kernel_end_addr;
diff --git a/kernel/src/hal/debug.hpp b/kernel/src/hal/debug.hpp
index 708100ab..f55953e8 100644
--- a/kernel/src/hal/debug.hpp
+++ b/kernel/src/hal/debug.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_KERNEL_INCLUDE_HAL_DEBUG_HPP_
-#define ALKOS_KERNEL_INCLUDE_HAL_DEBUG_HPP_
+#ifndef KERNEL_SRC_HAL_DEBUG_HPP_
+#define KERNEL_SRC_HAL_DEBUG_HPP_
 
 #include <hal/impl/debug.hpp>
 
@@ -9,6 +9,7 @@ namespace hal
  * @brief Display some debug info for stack
  */
 WRAP_CALL void DebugStack() { arch::DebugStack(); }
+WRAP_CALL void Noop() { arch::Noop(); }
 }  // namespace hal
 
-#endif  // ALKOS_KERNEL_INCLUDE_HAL_DEBUG_HPP_
+#endif  // KERNEL_SRC_HAL_DEBUG_HPP_
diff --git a/kernel/src/init.cpp b/kernel/src/init.cpp
index 287dc951..62eb4a7b 100644
--- a/kernel/src/init.cpp
+++ b/kernel/src/init.cpp
@@ -17,13 +17,8 @@
 /* GCC CXX provided function initializing global constructors */
 extern "C" void _init();
 
-static void test() { hal::DebugStack(); }
-
 void KernelInit(const hal::RawBootArguments &raw_args)
 {
-    hal::DebugStack();
-    test();
-
     hal::TerminalInit();
     hal::ArchInit(raw_args);
 
@@ -49,8 +44,6 @@ void KernelInit(const hal::RawBootArguments &raw_args)
     /* Allow hardware to fully initialise interrupt system */
     HardwareModule::Get().GetInterrupts().Init();
 
-    /* Setup core local data */
-
     /* Initialize the timing system */
     TimingModule::Init();
 
diff --git a/kernel/src/interrupts/logical_interrupt_table.hpp b/kernel/src/interrupts/logical_interrupt_table.hpp
index 17d84cfc..93bb33ff 100644
--- a/kernel/src/interrupts/logical_interrupt_table.hpp
+++ b/kernel/src/interrupts/logical_interrupt_table.hpp
@@ -87,6 +87,22 @@ class LogicalInterruptTable
     {
         ASSERT_LT(lirq, GetTableSize_<kInterruptType>());
         GetTable_<kInterruptType>()[lirq].handler_data = handler;
+
+        if constexpr (kInterruptType == InterruptType::kSoftwareInterrupt) {
+            software_interrupt_occupied_map_.SetTrue(lirq);
+        }
+    }
+
+    // std::numeric_limits<u16>::max() on fail
+    FORCE_INLINE_F u16 InstallSwIntrFirstFree(const SwHandler &handler)
+    {
+        const size_t lirq = software_interrupt_occupied_map_.FindFirst();
+        if (lirq == std::numeric_limits<size_t>::max()) {
+            return std::numeric_limits<u16>::max();
+        }
+
+        InstallInterruptHandler<InterruptType::kSoftwareInterrupt>(static_cast<u16>(lirq), handler);
+        return static_cast<u16>(lirq);
     }
 
     template <InterruptType kInterruptType>
@@ -102,6 +118,24 @@ class LogicalInterruptTable
         GetTable_<InterruptType::kHardwareInterrupt>()[lirq].driver = driver;
     }
 
+    template <InterruptType kInterruptType>
+    FORCE_INLINE_F InterruptHandlerEntry<kInterruptType> &GetEntry(const u16 lirq)
+    {
+        ASSERT_LT(lirq, GetTableSize_<kInterruptType>());
+        return GetTable_<kInterruptType>()[lirq];
+    }
+
+    template <InterruptType kInterruptType>
+    FORCE_INLINE_F void UninstallEntry(const u16 lirq)
+    {
+        ASSERT_LT(lirq, GetTableSize_<kInterruptType>());
+        GetTable_<kInterruptType>()[lirq].handler_data.handler = nullptr;
+
+        if constexpr (kInterruptType == InterruptType::kSoftwareInterrupt) {
+            software_interrupt_occupied_map_.SetFalse(lirq);
+        }
+    }
+
     // ------------------------------
     // Implementation
     // ------------------------------
@@ -113,9 +147,9 @@ class LogicalInterruptTable
         if constexpr (kInterruptType == InterruptType::kException) {
             return exception_table_;
         } else if constexpr (kInterruptType == InterruptType::kHardwareInterrupt) {
-            return hardware_exception_table_;
+            return hardware_interrupt_table_;
         } else if constexpr (kInterruptType == InterruptType::kSoftwareInterrupt) {
-            return software_exception_table_;
+            return software_interrupt_table_;
         } else {
             R_FAIL_ALWAYS("Invalid type provided");
         }
@@ -148,9 +182,10 @@ class LogicalInterruptTable
 
     InterruptHandlerEntry<InterruptType::kException> exception_table_[kNumExceptions];
     InterruptHandlerEntry<InterruptType::kHardwareInterrupt>
-        hardware_exception_table_[kNumHardwareExceptions];
+        hardware_interrupt_table_[kNumHardwareExceptions];
     InterruptHandlerEntry<InterruptType::kSoftwareInterrupt>
-        software_exception_table_[kNumSoftwareExceptions];
+        software_interrupt_table_[kNumSoftwareExceptions];
+    data_structures::BitArray<kNumSoftwareExceptions> software_interrupt_occupied_map_;
 };
 
 using LitType = LogicalInterruptTable<
diff --git a/kernel/src/interrupts/logical_interrupt_table.tpp b/kernel/src/interrupts/logical_interrupt_table.tpp
index d4d67a59..135656dc 100644
--- a/kernel/src/interrupts/logical_interrupt_table.tpp
+++ b/kernel/src/interrupts/logical_interrupt_table.tpp
@@ -18,12 +18,12 @@ LogicalInterruptTable<
     }
 
     for (u16 irq = 0; irq < kNumHardwareExceptions; irq++) {
-        hardware_exception_table_[irq].logical_irq = irq;
+        hardware_interrupt_table_[irq].logical_irq = irq;
         exception_table_[irq].hardware_irq         = kUnmappedIrq;
     }
 
     for (u16 irq = 0; irq < kNumSoftwareExceptions; irq++) {
-        software_exception_table_[irq].logical_irq = irq;
+        software_interrupt_table_[irq].logical_irq = irq;
         exception_table_[irq].hardware_irq         = kUnmappedIrq;
     }
 }
diff --git a/kernel/src/kernel.cpp b/kernel/src/kernel.cpp
index 457cb3ad..50ef88c5 100644
--- a/kernel/src/kernel.cpp
+++ b/kernel/src/kernel.cpp
@@ -6,6 +6,7 @@
 
 /* internal includes */
 #include <hal/debug.hpp>
+#include <hal/terminal.hpp>
 
 #include "graphics/font/psf2_font.hpp"
 #include "graphics/fonts/drdos8x8.hpp"
@@ -56,7 +57,6 @@ extern "C" void KernelMain(const hal::RawBootArguments *raw_args)
     ASSERT_NOT_NULL(raw_args, "Raw boot arguments are null");
     TRACE_INFO_GENERAL("Running kernel initialization...");
 
-    hal::DebugStack();
     KernelInit(*raw_args);
 
     if constexpr (FeatureEnabled<FeatureFlag::kRunTestMode>) {
diff --git a/kernel/src/libc_backend.cpp b/kernel/src/libc_backend.cpp
index 0aa6da7b..a9d1cf0b 100644
--- a/kernel/src/libc_backend.cpp
+++ b/kernel/src/libc_backend.cpp
@@ -68,14 +68,7 @@ void __platform_get_timezone(Timezone *time_zone)
     *time_zone = TimingModule::Get().GetSystemTime().GetTimezone();
 }
 
-void __platform_debug_write(const char *buffer)
-{
-    if constexpr (!FeatureEnabled<FeatureFlag::kDebugOutput>) {
-        return;
-    }
-
-    hal::DebugTerminalWrite(buffer);
-}
+void __platform_debug_write(const char *buffer) { DEBUG_INFO_GENERAL(buffer); }
 
 size_t __platform_debug_read_line(char *buffer, const size_t buffer_size)
 {
diff --git a/kernel/src/timing.cpp b/kernel/src/timing.cpp
index 61b147a6..56094558 100644
--- a/kernel/src/timing.cpp
+++ b/kernel/src/timing.cpp
@@ -6,6 +6,7 @@
 
 internal::TimingModule::TimingModule() noexcept
 {
+    BlockHardwareInterrupts();
     arch::PickSystemClockSource();
     auto &clock_source = ::HardwareModule::Get().GetClockRegistry().GetSelected();
 
@@ -18,5 +19,7 @@ internal::TimingModule::TimingModule() noexcept
     }
 
     GetSystemTime().SyncWithHardware();
+    EnableHardwareInterrupts();
+
     DEBUG_INFO_TIME("TimingModule::TimingModule()");
 }
diff --git a/kernel/src/trace.cpp b/kernel/src/trace.cpp
index e5bf5365..dd39df7f 100644
--- a/kernel/src/trace.cpp
+++ b/kernel/src/trace.cpp
@@ -56,7 +56,7 @@ static struct TraceFramework {
 
     struct SmallTraceCyclicBuffer {
         static constexpr size_t kSize           = 65536;
-        static constexpr size_t kDumpSize       = kSize - kSize / 16;
+        static constexpr size_t kDumpSize       = kSize - kSize / 32;
         static constexpr size_t kBatchSize      = 256;
         static constexpr size_t kBufferDumpDone = kSize - kSize / 8;
 
@@ -113,6 +113,7 @@ static struct TraceFramework {
 
     FORCE_INLINE_F void AdvanceToSingleThreadInterruptsStage()
     {
+        DEBUG_INFO_GENERAL("Updating tracing stage to stage 1 (Single thread with interrupts)");
         stage_callbacks.get_workspace_cb = &TraceFramework::GetWorkspaceSingleThreadInterrupts;
         stage_callbacks.commit_to_log_cb = &TraceFramework::CommitToLogSingleThreadInterrupts;
         stage_callbacks.commit_to_debug_log_cb =
diff --git a/kernel/src/trace_framework.hpp b/kernel/src/trace_framework.hpp
index 684776b0..0f7af5e0 100644
--- a/kernel/src/trace_framework.hpp
+++ b/kernel/src/trace_framework.hpp
@@ -52,7 +52,7 @@ NODISCARD TraceLevel GetTraceLevel(TraceModule module);
 void DumpAllBuffersOnFailure();
 void Flush();
 
-/* MODULE TIME CORE PROC FILE LINE MSG */
+/* MODULE TIME CORE PROC MSG */
 template <TraceType type, TraceModule module, TraceLevel level, class... Args>
 PREVENT_INLINE static void Write(const char *format, Args... args);
 }  // namespace trace
diff --git a/kernel/src/trace_framework.tpp b/kernel/src/trace_framework.tpp
index ad0da703..67f5a182 100644
--- a/kernel/src/trace_framework.tpp
+++ b/kernel/src/trace_framework.tpp
@@ -45,8 +45,10 @@ PREVENT_INLINE static void Write(const char *format, Args... args)
     bool extended = false;
     if (bytesWritten + trace_info_size == kWorkspaceSize - 1) {
         /* write to last char */
-        workspace[kWorkspaceSize - 2] = '\n';
-    } else {
+        if (workspace[kWorkspaceSize - 2] != '\n') {
+            workspace[kWorkspaceSize - 2] = '\n';
+        }
+    } else if (workspace[bytesWritten + trace_info_size - 1] != '\n') {
         workspace[bytesWritten + trace_info_size]     = '\n';
         workspace[bytesWritten + trace_info_size + 1] = '\0';
         extended                                      = true;
diff --git a/kernel/test/interrupt_test.cpp b/kernel/test/interrupt_test.cpp
new file mode 100644
index 00000000..9947387f
--- /dev/null
+++ b/kernel/test/interrupt_test.cpp
@@ -0,0 +1,11 @@
+#include <test_module/test.hpp>
+
+class InterruptTest : public TestGroupBase
+{
+};
+
+void ExceptionFailsKernelTest();
+FAIL_TEST_F(InterruptTest, ExceptionFailsKernelTest) { ExceptionFailsKernelTest(); }
+
+void ExceptionTestSavesAllRegisters();
+TEST_F(InterruptTest, ExceptionTestSavesAllRegisters) { ExceptionTestSavesAllRegisters(); }
diff --git a/kernel/test/tests.cpp b/kernel/test/tests.cpp
index 4ede1eea..a440da7a 100644
--- a/kernel/test/tests.cpp
+++ b/kernel/test/tests.cpp
@@ -90,32 +90,3 @@ extern void FloatExtensionTest();
  * @note This test is architecture dependent, simply invokes floating point instructions
  */
 TEST(FloatOperationsTest) { FloatExtensionTest(); }
-
-// ------------------------------
-// Simple Exception test
-// ------------------------------
-
-/**
- *  @brief Test should simply drop 0 division exception
- */
-FAIL_TEST(SimpleExceptionTest)
-{
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdiv-by-zero"
-    [[maybe_unused]] volatile int a = 9 / 0;
-#pragma GCC diagnostic pop
-}
-
-// ------------------------------
-// Preserve CPU test
-// ------------------------------
-
-/**
- * @brief Special test interrupt writes ones to all registers. Expected behavior is to not see
- * any ones in the registers after returning from interrupt.
- */
-extern "C" void PreserveCpuStateTest();
-
-TEST(PreserveCpuStateTest) { PreserveCpuStateTest(); }
-
-MTEST(TraceFramework) {}
diff --git a/libs/libc/CMakeLists.txt b/libs/libc/CMakeLists.txt
index d58d7078..4b9eb92b 100644
--- a/libs/libc/CMakeLists.txt
+++ b/libs/libc/CMakeLists.txt
@@ -32,4 +32,5 @@ target_include_directories(alkos.libc.interface INTERFACE
 
 target_link_libraries(alkos.libc.interface INTERFACE
     alkos.libcpp.interface
+    alkos.autogen.interface
 )
diff --git a/libs/libc/internal/debug.hpp b/libs/libc/internal/debug.hpp
new file mode 100644
index 00000000..66354601
--- /dev/null
+++ b/libs/libc/internal/debug.hpp
@@ -0,0 +1,60 @@
+#ifndef LIBS_LIBC_INTERNAL_DEBUG_HPP_
+#define LIBS_LIBC_INTERNAL_DEBUG_HPP_
+
+#include <autogen/feature_flags.h>
+#include <todo.hpp>
+
+#include "platform.h"
+
+#if FEATURE_FLAG_DEBUG_TRACES
+
+#include <assert.h>
+#include <stdio.h>
+
+// ------------------------------
+// Traces
+// ------------------------------
+
+static constexpr size_t kTraceBufferSize = 4096;
+template <typename... Args>
+void FormatTrace(const char *format, Args... args)
+{
+    char buffer[kTraceBufferSize];
+    [[maybe_unused]] const u64 bytesWritten = snprintf(buffer, kTraceBufferSize, format, args...);
+    ASSERT(bytesWritten < kTraceBufferSize);
+    __platform_debug_write(buffer);
+}
+
+#define TRACE(message, ...) FormatTrace(message __VA_OPT__(, ) __VA_ARGS__)
+
+#else
+
+#define TRACE(message, ...)
+
+#endif  // __USE_DEBUG_TRACES__
+
+#define ERROR_TAG   "[ERROR]     "
+#define WARNING_TAG "[WARNING]   "
+#define INFO_TAG    "[INFO]      "
+#define SUCCESS_TAG "[SUCCESS]   "
+#define DEBUG_TAG   "[DEBUG]     "
+#define TRACE_TAG   "[TRACE]     "
+
+#define TRACE_FORMAT_LOCATION(message) __FILE__ " " TOSTRING(__LINE__) " " message "\n"
+#define TRACE_FORMAT_ERROR(message)    ERROR_TAG " %zu " TRACE_FORMAT_LOCATION(message)
+#define TRACE_FORMAT_WARNING(message)  WARNING_TAG " %zu " TRACE_FORMAT_LOCATION(message)
+#define TRACE_FORMAT_INFO(message)     INFO_TAG " %zu " TRACE_FORMAT_LOCATION(message)
+#define TRACE_FORMAT_DEBUG(message)    DEBUG_TAG " %zu " TRACE_FORMAT_LOCATION(message)
+#define TRACE_FORMAT_SUCCESS(message)  SUCCESS_TAG " %zu " TRACE_FORMAT_LOCATION(message)
+
+#define TRACE_ERROR(message, ...) \
+    TRACE(TRACE_FORMAT_ERROR(message), 0ull __VA_OPT__(, ) __VA_ARGS__)
+#define TRACE_WARNING(message, ...) \
+    TRACE(TRACE_FORMAT_WARNING(message), 0ull __VA_OPT__(, ) __VA_ARGS__)
+#define TRACE_INFO(message, ...) TRACE(TRACE_FORMAT_INFO(message), 0ull __VA_OPT__(, ) __VA_ARGS__)
+#define TRACE_DEBUG(message, ...) \
+    TRACE(TRACE_FORMAT_DEBUG(message), 0ull __VA_OPT__(, ) __VA_ARGS__)
+#define TRACE_SUCCESS(message, ...) \
+    TRACE(TRACE_FORMAT_SUCCESS(message), 0ull __VA_OPT__(, ) __VA_ARGS__)
+
+#endif  // LIBS_LIBC_INTERNAL_DEBUG_HPP_
diff --git a/libs/libc/memory/memory.cpp b/libs/libc/memory/memory.cpp
index 2fbceaf4..e65f2f5a 100644
--- a/libs/libc/memory/memory.cpp
+++ b/libs/libc/memory/memory.cpp
@@ -1,5 +1,4 @@
 #include <stddef.h>
-
 #include "string.h"
 
 void *memcpy(void *dest, const void *src, const size_t n)
diff --git a/libs/libcontainers/include/data_structures/bit_array.hpp b/libs/libcontainers/include/data_structures/bit_array.hpp
index e668b5fe..500f8330 100644
--- a/libs/libcontainers/include/data_structures/bit_array.hpp
+++ b/libs/libcontainers/include/data_structures/bit_array.hpp
@@ -1,7 +1,8 @@
-#ifndef LIBS_LIBCPP_INCLUDE_DATA_STRUCTURES_BIT_ARRAY_HPP_
-#define LIBS_LIBCPP_INCLUDE_DATA_STRUCTURES_BIT_ARRAY_HPP_
+#ifndef LIBS_LIBCONTAINERS_INCLUDE_DATA_STRUCTURES_BIT_ARRAY_HPP_
+#define LIBS_LIBCONTAINERS_INCLUDE_DATA_STRUCTURES_BIT_ARRAY_HPP_
 
 #include <stddef.h>
+#include <optional.hpp>
 #include "assert.h"
 #include "bit.hpp"
 #include "string.h"
@@ -144,6 +145,35 @@ class PACK BitArray final
         return *reinterpret_cast<const u32 *>(storage_);
     }
 
+    // std::numeric_limits<size_t>::max() for failure
+    template <bool value = false>
+    NODISCARD FORCE_INLINE_F size_t FindFirst()
+    {
+        const StorageT empty_unit =
+            value ? std::numeric_limits<StorageT>::min() : std::numeric_limits<StorageT>::max();
+
+        for (size_t i = 0; i < kNumStorageT; ++i) {
+            if (storage_[i] == empty_unit) {
+                continue;
+            }
+
+            const size_t start = i * kStorageTBits;
+            const size_t local_offset =
+                value ? std::countr_zero(storage_[i]) : std::countr_one(storage_[i]);
+            return start + local_offset;
+        }
+
+        return std::numeric_limits<size_t>::max();
+    }
+
+    NODISCARD FORCE_INLINE_F size_t FindFirst(const bool value = false)
+    {
+        if (value) {
+            return FindFirst<true>();
+        }
+        return FindFirst<false>();
+    }
+
     // ------------------------------
     // Class fields
     // ------------------------------
@@ -154,4 +184,4 @@ class PACK BitArray final
 
 }  // namespace data_structures
 
-#endif  // LIBS_LIBCPP_INCLUDE_DATA_STRUCTURES_BIT_ARRAY_HPP_
+#endif  // LIBS_LIBCONTAINERS_INCLUDE_DATA_STRUCTURES_BIT_ARRAY_HPP_
diff --git a/libs/libcpp/CMakeLists.txt b/libs/libcpp/CMakeLists.txt
index 0ecfd05c..ca5ddf4c 100644
--- a/libs/libcpp/CMakeLists.txt
+++ b/libs/libcpp/CMakeLists.txt
@@ -28,4 +28,5 @@ target_include_directories(alkos.libcpp.interface INTERFACE
 
 target_link_libraries(alkos.libcpp.interface INTERFACE
     alkos.libtemplate.interface
+    alkos.autogen.interface
 )
diff --git a/libs/libcpp/include/internal/debug.hpp b/libs/libcpp/include/internal/debug.hpp
new file mode 100644
index 00000000..49defb8b
--- /dev/null
+++ b/libs/libcpp/include/internal/debug.hpp
@@ -0,0 +1,59 @@
+#ifndef LIBS_LIBCPP_INCLUDE_INTERNAL_DEBUG_HPP_
+#define LIBS_LIBCPP_INCLUDE_INTERNAL_DEBUG_HPP_
+
+#include <autogen/feature_flags.h>
+
+#include "platform.h"
+
+#if FEATURE_FLAG_DEBUG_TRACES
+
+#include <assert.h>
+#include <stdio.h>
+
+// ------------------------------
+// Traces
+// ------------------------------
+
+static constexpr size_t kTraceBufferSize = 4096;
+template <typename... Args>
+void FormatTrace(const char *format, Args... args)
+{
+    char buffer[kTraceBufferSize];
+    [[maybe_unused]] const u64 bytesWritten = snprintf(buffer, kTraceBufferSize, format, args...);
+    ASSERT(bytesWritten < kTraceBufferSize);
+    __platform_debug_write(buffer);
+}
+
+#define TRACE(message, ...) FormatTrace(message __VA_OPT__(, ) __VA_ARGS__)
+
+#else
+
+#define TRACE(message, ...)
+
+#endif  // __USE_DEBUG_TRACES__
+
+#define ERROR_TAG   "[LIBC] [ERROR]     "
+#define WARNING_TAG "[LIBC] [WARNING]   "
+#define INFO_TAG    "[LIBC] [INFO]      "
+#define SUCCESS_TAG "[LIBC] [SUCCESS]   "
+#define DEBUG_TAG   "[LIBC] [DEBUG]     "
+#define TRACE_TAG   "[LIBC] [TRACE]     "
+
+#define TRACE_FORMAT_LOCATION(message) __FILE__ " " TOSTRING(__LINE__) " " message "\n"
+#define TRACE_FORMAT_ERROR(message)    ERROR_TAG " %zu " TRACE_FORMAT_LOCATION(message)
+#define TRACE_FORMAT_WARNING(message)  WARNING_TAG " %zu " TRACE_FORMAT_LOCATION(message)
+#define TRACE_FORMAT_INFO(message)     INFO_TAG " %zu " TRACE_FORMAT_LOCATION(message)
+#define TRACE_FORMAT_DEBUG(message)    DEBUG_TAG " %zu " TRACE_FORMAT_LOCATION(message)
+#define TRACE_FORMAT_SUCCESS(message)  SUCCESS_TAG " %zu " TRACE_FORMAT_LOCATION(message)
+
+#define TRACE_ERROR(message, ...) \
+    TRACE(TRACE_FORMAT_ERROR(message), 0ull __VA_OPT__(, ) __VA_ARGS__)
+#define TRACE_WARNING(message, ...) \
+    TRACE(TRACE_FORMAT_WARNING(message), 0ull __VA_OPT__(, ) __VA_ARGS__)
+#define TRACE_INFO(message, ...) TRACE(TRACE_FORMAT_INFO(message), 0ull __VA_OPT__(, ) __VA_ARGS__)
+#define TRACE_DEBUG(message, ...) \
+    TRACE(TRACE_FORMAT_DEBUG(message), 0ull __VA_OPT__(, ) __VA_ARGS__)
+#define TRACE_SUCCESS(message, ...) \
+    TRACE(TRACE_FORMAT_SUCCESS(message), 0ull __VA_OPT__(, ) __VA_ARGS__)
+
+#endif  // LIBS_LIBCPP_INCLUDE_INTERNAL_DEBUG_HPP_
diff --git a/scripts/actions/find_failing_line.bash b/scripts/actions/find_failing_line.bash
new file mode 100755
index 00000000..3b86b222
--- /dev/null
+++ b/scripts/actions/find_failing_line.bash
@@ -0,0 +1,24 @@
+#!/bin/bash
+
+FIND_FAILING_LINE_ACTION_DIR="$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )"
+source "${FIND_FAILING_LINE_ACTION_DIR}/../utils/conf_handlers.bash"
+
+source_conf_file
+verify_conf_var_exists CONF_SYSROOT
+
+FIND_FAILING_LINE_KERNEL_ELF="${CONF_SYSROOT}/boot/alkos.kernel"
+
+if [ $# -ne 1 ]; then
+    echo "Usage: $0 <RIP_HEX_ADDRESS>"
+    echo "For example: $0 0xFFFFFFFF80012345"
+    exit 1
+fi
+
+RIP_ADDR="$1"
+STOP_ADDR=$((${RIP_ADDR} + 0x10))
+STOP_ADDR_HEX=$(printf "0x%x" $STOP_ADDR)
+
+addr2line -e "${FIND_FAILING_LINE_KERNEL_ELF}" -C "${RIP_ADDR}"
+objdump -d -M intel "${FIND_FAILING_LINE_KERNEL_ELF}" \
+    --start-address="${RIP_ADDR}" \
+    --stop-address="${STOP_ADDR_HEX}"
diff --git a/tests/libcpp_mocks/algorithm.hpp b/tests/libcpp_mocks/algorithm.hpp
index e867b9ca..4e2f04a1 100644
--- a/tests/libcpp_mocks/algorithm.hpp
+++ b/tests/libcpp_mocks/algorithm.hpp
@@ -1,6 +1,6 @@
-#ifndef TESTS_HOST_MOCKS_ALGORITHM_HPP_
-#define TESTS_HOST_MOCKS_ALGORITHM_HPP_
+#ifndef TESTS_LIBCPP_MOCKS_ALGORITHM_HPP_
+#define TESTS_LIBCPP_MOCKS_ALGORITHM_HPP_
 
 #include <algorithm>
 
-#endif  // TESTS_HOST_MOCKS_ALGORITHM_HPP_
+#endif  // TESTS_LIBCPP_MOCKS_ALGORITHM_HPP_
diff --git a/tests/libcpp_mocks/array.hpp b/tests/libcpp_mocks/array.hpp
index 178476fb..85003e68 100644
--- a/tests/libcpp_mocks/array.hpp
+++ b/tests/libcpp_mocks/array.hpp
@@ -1,6 +1,6 @@
-#ifndef TESTS_HOST_MOCKS_ARRAY_HPP_
-#define TESTS_HOST_MOCKS_ARRAY_HPP_
+#ifndef TESTS_LIBCPP_MOCKS_ARRAY_HPP_
+#define TESTS_LIBCPP_MOCKS_ARRAY_HPP_
 
 #include <array>
 
-#endif  // TESTS_HOST_MOCKS_ARRAY_HPP_
+#endif  // TESTS_LIBCPP_MOCKS_ARRAY_HPP_
diff --git a/tests/libcpp_mocks/atomic.hpp b/tests/libcpp_mocks/atomic.hpp
index 1e85d666..c056b9f8 100644
--- a/tests/libcpp_mocks/atomic.hpp
+++ b/tests/libcpp_mocks/atomic.hpp
@@ -1,6 +1,6 @@
-#ifndef TESTS_HOST_MOCKS_ATOMIC_HPP_
-#define TESTS_HOST_MOCKS_ATOMIC_HPP_
+#ifndef TESTS_LIBCPP_MOCKS_ATOMIC_HPP_
+#define TESTS_LIBCPP_MOCKS_ATOMIC_HPP_
 
 #include <atomic>
 
-#endif  // TESTS_HOST_MOCKS_ATOMIC_HPP_
+#endif  // TESTS_LIBCPP_MOCKS_ATOMIC_HPP_
diff --git a/tests/libcpp_mocks/defines.hpp b/tests/libcpp_mocks/defines.hpp
index 80cca710..5b7648d4 100644
--- a/tests/libcpp_mocks/defines.hpp
+++ b/tests/libcpp_mocks/defines.hpp
@@ -1,5 +1,5 @@
-#ifndef TESTS_HOST_MOCKS_DEFINES_HPP_
-#define TESTS_HOST_MOCKS_DEFINES_HPP_
+#ifndef TESTS_LIBCPP_MOCKS_DEFINES_HPP_
+#define TESTS_LIBCPP_MOCKS_DEFINES_HPP_
 
 #include <cassert>
 #include <cstddef>
@@ -139,4 +139,4 @@ struct empty_t {
 };
 #define UNIQUE_EMPTY empty_t<__COUNTER__>
 
-#endif  // TESTS_HOST_MOCKS_DEFINES_HPP_
+#endif  // TESTS_LIBCPP_MOCKS_DEFINES_HPP_
diff --git a/tests/libcpp_mocks/hal/constants.hpp b/tests/libcpp_mocks/hal/constants.hpp
index 8e772e6b..258e79be 100644
--- a/tests/libcpp_mocks/hal/constants.hpp
+++ b/tests/libcpp_mocks/hal/constants.hpp
@@ -1,5 +1,5 @@
-#ifndef TESTS_HOST_MOCKS_HAL_CONSTANTS_HPP_
-#define TESTS_HOST_MOCKS_HAL_CONSTANTS_HPP_
+#ifndef TESTS_LIBCPP_MOCKS_HAL_CONSTANTS_HPP_
+#define TESTS_LIBCPP_MOCKS_HAL_CONSTANTS_HPP_
 
 #include <cstddef>
 
@@ -13,4 +13,4 @@ namespace arch
 static constexpr std::size_t kCacheLineSizeBytes = 64;
 }
 
-#endif  // TESTS_HOST_MOCKS_HAL_CONSTANTS_HPP_
+#endif  // TESTS_LIBCPP_MOCKS_HAL_CONSTANTS_HPP_
diff --git a/tests/libcpp_mocks/span.hpp b/tests/libcpp_mocks/span.hpp
index 7eb28fbc..5aed38a2 100644
--- a/tests/libcpp_mocks/span.hpp
+++ b/tests/libcpp_mocks/span.hpp
@@ -1,6 +1,6 @@
-#ifndef TESTS_HOST_MOCKS_SPAN_HPP_
-#define TESTS_HOST_MOCKS_SPAN_HPP_
+#ifndef TESTS_LIBCPP_MOCKS_SPAN_HPP_
+#define TESTS_LIBCPP_MOCKS_SPAN_HPP_
 
 #include <span>
 
-#endif  // TESTS_HOST_MOCKS_SPAN_HPP_
+#endif  // TESTS_LIBCPP_MOCKS_SPAN_HPP_
diff --git a/tests/libcpp_mocks/types.hpp b/tests/libcpp_mocks/types.hpp
index a17f76f9..1c82796b 100644
--- a/tests/libcpp_mocks/types.hpp
+++ b/tests/libcpp_mocks/types.hpp
@@ -1,5 +1,5 @@
-#ifndef TESTS_HOST_MOCKS_TYPES_HPP_
-#define TESTS_HOST_MOCKS_TYPES_HPP_
+#ifndef TESTS_LIBCPP_MOCKS_TYPES_HPP_
+#define TESTS_LIBCPP_MOCKS_TYPES_HPP_
 
 #include <cstddef>
 #include <cstdint>
@@ -21,4 +21,4 @@ using iptr = intptr_t;
 using f32 = float;
 using f64 = double;
 
-#endif  // TESTS_HOST_MOCKS_TYPES_HPP_
+#endif  // TESTS_LIBCPP_MOCKS_TYPES_HPP_

From 83f1a6b2af2cf6396be9d48ae5db2461d1ea7f48 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C5=81ukasz=20Kryczka?= <lukasz.kryczka000@gmail.com>
Date: Mon, 15 Dec 2025 23:09:51 +0100
Subject: [PATCH 12/56] feat: Add video module support and set graphics payload
 for ISO bootloader

---
 kernel/arch/x86_64/boot/loader_32/build/multiboot_header.nasm | 4 ++--
 scripts/install/make_iso.bash                                 | 2 ++
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/kernel/arch/x86_64/boot/loader_32/build/multiboot_header.nasm b/kernel/arch/x86_64/boot/loader_32/build/multiboot_header.nasm
index fb43a08f..3f5d4375 100644
--- a/kernel/arch/x86_64/boot/loader_32/build/multiboot_header.nasm
+++ b/kernel/arch/x86_64/boot/loader_32/build/multiboot_header.nasm
@@ -80,8 +80,8 @@ multiboot_start:
           dw MULTIBOOT_HEADER_TAG_FRAMEBUFFER
           dw MULTIBOOT_HEADER_TAG_OPTIONAL
           dd (.framebuffer_tag_end - .framebuffer_tag_start)
-          dd 0 ; width  - no preference
-          dd 0 ; height - no preference
+          dd 800 ; width  - no preference
+          dd 600 ; height - no preference
           dd FRAMEBUFFER_REQUIRED_DEPTH ; depth
 .framebuffer_tag_end:
 
diff --git a/scripts/install/make_iso.bash b/scripts/install/make_iso.bash
index 0bbd0ec4..0ea8bd35 100755
--- a/scripts/install/make_iso.bash
+++ b/scripts/install/make_iso.bash
@@ -15,6 +15,8 @@ menuentry \"AlkOS\" {
   ${MAKE_ISO_SCRIPT_MODULES_TOKEN}
   boot
 }
+insmod all_video
+set gfxpayload=1024x768x32,1024x768,800x600x32,800x600,keep
 "
 MAKE_ISO_SCRIPT_GRUB_PATH_IN_ISO="boot/grub/grub.cfg"
 

From 4cf26fbb4e22c45628d77a683ac605e2bbff0efc Mon Sep 17 00:00:00 2001
From: Adam Ogieniewski <ogieniewski.dev@gmail.com>
Date: Tue, 16 Dec 2025 02:25:17 +0100
Subject: [PATCH 13/56] Add bitfield and bit array range ops (#238)

Introduces a new `BitField` utility for defining and accessing bitfields
with named, type-safe fields.
Enhances `BitArray` with `GetRange` and `SetRange` methods to
efficiently manipulate bit ranges, including boundary-crossing
scenarios. These methods are fundamental for `BitField`'s internal
storage.
Adds `std::bit_cast` for safe reinterpretation of object
representations, enabling `BitField` to convert to/from raw integer
types.
Includes new internal macros to support the `CREATE_BITFIELD` macro.
Adds comprehensive tests for both `BitArray` range operations and the
new `BitField` utility.
---
 kernel/test/bit_array_test.cpp                |  23 ++
 kernel/test/bitfield_test.cpp                 |  77 +++++++
 .../include/data_structures/bit_array.hpp     | 111 ++++++++-
 .../include/data_structures/bitfield.hpp      | 216 ++++++++++++++++++
 libs/libcpp/include/bit.hpp                   |  18 +-
 libs/libcpp/include/bits_ext.hpp              |  12 +-
 libs/libcpp/include/internal/macro.hpp        |  37 +++
 7 files changed, 477 insertions(+), 17 deletions(-)
 create mode 100644 kernel/test/bitfield_test.cpp
 create mode 100644 libs/libcontainers/include/data_structures/bitfield.hpp
 create mode 100644 libs/libcpp/include/internal/macro.hpp

diff --git a/kernel/test/bit_array_test.cpp b/kernel/test/bit_array_test.cpp
index cf518bbc..76ef6689 100644
--- a/kernel/test/bit_array_test.cpp
+++ b/kernel/test/bit_array_test.cpp
@@ -37,6 +37,29 @@ TEST_F(BitArrayTest, CrossBoundary)
     EXPECT_FALSE(bits.Get(33));
 }
 
+TEST_F(BitArrayTest, GetSetRange_BoundariesCrossing)
+{
+    data_structures::BitArray<192> bits;
+
+    // No boundary crossing - 48 bits at offset 2
+    bits.SetRange<2, 48>(0x15);
+    EXPECT_EQ(0x15, (bits.GetRange<2, 48>()));
+
+    // Verify unaffected bits
+    EXPECT_EQ(0, (bits.GetRange<0, 2>()));
+    EXPECT_EQ(0, (bits.GetRange<50, 64>()));
+
+    bits.SetAll(false);
+
+    // Boundary crossing - 32 bits at offset 48
+    bits.SetRange<48, 32>(0xABC);
+    EXPECT_EQ(0xABC, (bits.GetRange<48, 32>()));
+
+    // Verify unaffected bits
+    EXPECT_EQ(0, (bits.GetRange<0, 48>()));
+    EXPECT_EQ(0, (bits.GetRange<80, 64>()));
+}
+
 TEST_F(BitArrayTest, Size)
 {
     data_structures::BitArray<100> bits;
diff --git a/kernel/test/bitfield_test.cpp b/kernel/test/bitfield_test.cpp
new file mode 100644
index 00000000..b3c21509
--- /dev/null
+++ b/kernel/test/bitfield_test.cpp
@@ -0,0 +1,77 @@
+#include <data_structures/bitfield.hpp>
+#include <test_module/test.hpp>
+#include <types.hpp>
+
+class BitFieldTest : public TestGroupBase
+{
+};
+
+CREATE_BITFIELD(TestBitField1, FieldA, 3, FieldB, 5, FieldC, 8);
+
+CREATE_BITFIELD(TestBitField2, FlagX, 1, FlagY, 1, Counter, 6);
+
+CREATE_BITFIELD(StatusReg, Ready, 1, Error, 1, ErrorCode, 6, Reserved, 24);
+
+static_assert(sizeof(StatusReg) == sizeof(u32));
+static_assert(StatusReg::kTotalBits == 32);
+static_assert(sizeof(TestBitField1) == sizeof(u16));
+static_assert(sizeof(TestBitField2) == sizeof(u8));
+
+struct RawStatus {
+    u32 flags;
+};
+
+TEST_F(BitFieldTest, BitFieldConstruction)
+{
+    TestBitField1 bf1{static_cast<u16>(0x1FF8)};
+    EXPECT_EQ(0, bf1.get<TestBitField1::FieldA>());
+    EXPECT_EQ(31, bf1.get<TestBitField1::FieldB>());
+    EXPECT_EQ(31, bf1.get<TestBitField1::FieldC>());
+
+    TestBitField2 bf2;
+    EXPECT_EQ(0, bf2.get<TestBitField2::FlagX>());
+    EXPECT_EQ(0, bf2.get<TestBitField2::FlagY>());
+    EXPECT_EQ(0, bf2.get<TestBitField2::Counter>());
+}
+
+TEST_F(BitFieldTest, BitFieldIntegerConstruction)
+{
+    u32 val1 = 0x01000003;  // Binary ...00011 (Ready=1, Error=1)
+    StatusReg reg(val1);
+
+    EXPECT_EQ(1, reg.get<StatusReg::Ready>());
+    EXPECT_EQ(1, reg.get<StatusReg::Error>());
+
+    RawStatus raw{0xFFFFFFFF};
+    reg = raw;
+
+    EXPECT_EQ(63, reg.get<StatusReg::ErrorCode>());
+    EXPECT_EQ(16777215, reg.get<StatusReg::Reserved>());
+
+    reg.set<StatusReg::Ready>(0);
+    reg.set<StatusReg::Error>(0);
+
+    u32 val = static_cast<u32>(reg);
+    EXPECT_EQ(0xFFFFFFFC, val);
+}
+
+TEST_F(BitFieldTest, BitFieldSetGet)
+{
+    TestBitField1 bf1;
+    bf1.set<TestBitField1::FieldA>(5);
+    bf1.set<TestBitField1::FieldB>(17);
+    bf1.set<TestBitField1::FieldC>(255);
+
+    EXPECT_EQ(5, bf1.get<TestBitField1::FieldA>());
+    EXPECT_EQ(17, bf1.get<TestBitField1::FieldB>());
+    EXPECT_EQ(255, bf1.get<TestBitField1::FieldC>());
+
+    TestBitField2 bf2;
+    bf2.set<TestBitField2::FlagX>(1);
+    bf2.set<TestBitField2::FlagY>(0);
+    bf2.set<TestBitField2::Counter>(42);
+
+    EXPECT_EQ(1, bf2.get<TestBitField2::FlagX>());
+    EXPECT_EQ(0, bf2.get<TestBitField2::FlagY>());
+    EXPECT_EQ(42, bf2.get<TestBitField2::Counter>());
+}
diff --git a/libs/libcontainers/include/data_structures/bit_array.hpp b/libs/libcontainers/include/data_structures/bit_array.hpp
index 500f8330..245a3b5e 100644
--- a/libs/libcontainers/include/data_structures/bit_array.hpp
+++ b/libs/libcontainers/include/data_structures/bit_array.hpp
@@ -82,9 +82,8 @@ class BitMapView final
 template <size_t kNumBits>
 class PACK BitArray final
 {
-    using StorageT                        = u8;
-    static constexpr size_t kStorageTBits = sizeof(StorageT) * 8;
-    static constexpr size_t kNumStorageT  = (kNumBits + kStorageTBits - 1) / kStorageTBits;
+    using StorageT                       = u8;
+    static constexpr size_t kStorageBits = sizeof(StorageT) * 8;
 
     public:
     // ------------------------------
@@ -102,14 +101,14 @@ class PACK BitArray final
     {
         ASSERT_LT(index, kNumBits, "Index out of bounds in BitArray");
 
-        storage_[index / kStorageTBits] |= (kLsb<StorageT> << (index % kStorageTBits));
+        storage_[index / kStorageBits] |= (kLsb<StorageT> << (index % kStorageBits));
     }
 
     FORCE_INLINE_F void SetFalse(const size_t index)
     {
         ASSERT_LT(index, kNumBits, "Index out of bounds in BitArray");
 
-        storage_[index / kStorageTBits] &= ~(kLsb<StorageT> << (index % kStorageTBits));
+        storage_[index / kStorageBits] &= ~(kLsb<StorageT> << (index % kStorageBits));
     }
 
     FORCE_INLINE_F void Set(const size_t index, const bool value)
@@ -117,20 +116,108 @@ class PACK BitArray final
         ASSERT_LT(index, kNumBits, "Index out of bounds in BitArray");
 
         SetFalse(index);
-        storage_[index / kStorageTBits] |= (static_cast<u32>(value) << (index % kStorageTBits));
+        storage_[index / kStorageBits] |= (static_cast<u32>(value) << (index % kStorageBits));
     }
 
     NODISCARD FORCE_INLINE_F bool Get(const size_t index) const
     {
         ASSERT_LT(index, kNumBits, "Index out of bounds in BitArray");
-        return (storage_[index / kStorageTBits] >> (index % kStorageTBits)) & kLsb<StorageT>;
+        return (storage_[index / kStorageBits] >> (index % kStorageBits)) & kLsb<StorageT>;
+    }
+
+    template <size_t kOffset, size_t kWidth>
+    NODISCARD FORCE_INLINE_F size_t GetRange() const
+    {
+        constexpr size_t kSizeTBits = sizeof(size_t) * 8;
+        static_assert(kOffset + kWidth <= kNumBits, "Range exceeds BitArray size");
+        static_assert(kWidth <= kSizeTBits, "Width exceeds size_t size");
+
+        constexpr size_t kByteOffset = kOffset / 8;
+        constexpr size_t kBitOffset  = kOffset % 8;
+
+        if constexpr (kBitOffset + kWidth <= kSizeTBits) {
+            size_t raw = *reinterpret_cast<const size_t *>(storage_ + kByteOffset);
+
+            // Shift right to align, then mask
+            constexpr size_t kMask = kBitMaskRight<size_t, kWidth>;
+            return (raw >> kBitOffset) & kMask;
+        } else {
+            // Spans two register-sized words
+            constexpr size_t kFirstWidth  = kSizeTBits - kBitOffset;
+            constexpr size_t kSecondWidth = kWidth - kFirstWidth;
+
+            // Read first word
+            size_t raw1             = *reinterpret_cast<const size_t *>(storage_ + kByteOffset);
+            constexpr size_t kMask1 = kBitMaskRight<size_t, kFirstWidth>;
+            size_t result           = (raw1 >> kBitOffset) & kMask1;
+
+            // Read second word
+            size_t raw2 =
+                *reinterpret_cast<const size_t *>(storage_ + kByteOffset + sizeof(size_t));
+            constexpr size_t kMask2 = kBitMaskRight<size_t, kSecondWidth>;
+            result |= (raw2 & kMask2) << kFirstWidth;
+
+            return result;
+        }
+    }
+
+    template <size_t kOffset, size_t kWidth>
+    FORCE_INLINE_F void SetRange(size_t value)
+    {
+        constexpr size_t kSizeTBits = sizeof(size_t) * 8;
+        static_assert(kOffset + kWidth <= kNumBits, "Range exceeds BitArray size");
+        static_assert(kWidth <= kSizeTBits, "Width exceeds size_t size");
+
+        // Mask value to width
+        constexpr size_t kValueMask = kBitMaskRight<size_t, kWidth>;
+        value &= kValueMask;
+
+        constexpr size_t kByteOffset = kOffset / 8;
+        constexpr size_t kBitOffset  = kOffset % 8;
+
+        if constexpr (kBitOffset + kWidth <= kSizeTBits) {
+            auto *raw_ptr = reinterpret_cast<size_t *>(storage_ + kByteOffset);
+            size_t raw    = *raw_ptr;
+
+            // Create clear mask at the correct position
+            constexpr size_t kClearMask = kBitMaskRight<size_t, kWidth> << kBitOffset;
+
+            // Clear bits: use ~mask & raw
+            raw &= ~kClearMask;
+
+            // Set new bits: shift value and OR
+            raw |= (value << kBitOffset);
+
+            // Write back
+            *raw_ptr = raw;
+        } else {
+            // Spans two register-sized words - split the operation
+            constexpr size_t kFirstWidth  = kSizeTBits - kBitOffset;
+            constexpr size_t kSecondWidth = kWidth - kFirstWidth;
+
+            // First word: clear and set lower bits
+            auto *raw_ptr1               = reinterpret_cast<size_t *>(storage_ + kByteOffset);
+            size_t raw1                  = *raw_ptr1;
+            constexpr size_t kClearMask1 = kBitMaskRight<size_t, kFirstWidth> << kBitOffset;
+            raw1 &= ~kClearMask1;
+            raw1 |= (value << kBitOffset);
+            *raw_ptr1 = raw1;
+
+            // Second word: clear and set upper bits
+            auto *raw_ptr2 = reinterpret_cast<size_t *>(storage_ + kByteOffset + sizeof(size_t));
+            size_t raw2    = *raw_ptr2;
+            constexpr size_t kClearMask2 = kBitMaskRight<size_t, kSecondWidth>;
+            raw2 &= ~kClearMask2;
+            raw2 |= (value >> kFirstWidth);
+            *raw_ptr2 = raw2;
+        }
     }
 
     NODISCARD FORCE_INLINE_F size_t Size() const { return kNumBits; }
 
     FORCE_INLINE_F void SetAll(const bool value)
     {
-        memset(storage_, value ? UINT8_MAX : 0, kNumStorageT * sizeof(StorageT));
+        memset(storage_, value ? UINT8_MAX : 0, kNumStorage * sizeof(StorageT));
     }
 
     FORCE_INLINE_F u64 ToU64() const
@@ -152,12 +239,12 @@ class PACK BitArray final
         const StorageT empty_unit =
             value ? std::numeric_limits<StorageT>::min() : std::numeric_limits<StorageT>::max();
 
-        for (size_t i = 0; i < kNumStorageT; ++i) {
+        for (size_t i = 0; i < kNumStorage; ++i) {
             if (storage_[i] == empty_unit) {
                 continue;
             }
 
-            const size_t start = i * kStorageTBits;
+            const size_t start = i * kStorageBits;
             const size_t local_offset =
                 value ? std::countr_zero(storage_[i]) : std::countr_one(storage_[i]);
             return start + local_offset;
@@ -178,8 +265,10 @@ class PACK BitArray final
     // Class fields
     // ------------------------------
 
+    static constexpr size_t kNumStorage = (kNumBits + kStorageBits - 1) / kStorageBits;
+
     private:
-    StorageT storage_[kNumStorageT]{};
+    StorageT storage_[kNumStorage]{};
 };
 
 }  // namespace data_structures
diff --git a/libs/libcontainers/include/data_structures/bitfield.hpp b/libs/libcontainers/include/data_structures/bitfield.hpp
new file mode 100644
index 00000000..8d095b67
--- /dev/null
+++ b/libs/libcontainers/include/data_structures/bitfield.hpp
@@ -0,0 +1,216 @@
+#ifndef LIBS_LIBCONTAINERS_INCLUDE_DATA_STRUCTURES_BITFIELD_HPP_
+#define LIBS_LIBCONTAINERS_INCLUDE_DATA_STRUCTURES_BITFIELD_HPP_
+
+#include <stddef.h>
+#include <bit.hpp>
+#include <data_structures/bit_array.hpp>
+#include <internal/macro.hpp>
+#include <tuple.hpp>
+#include <type_traits.hpp>
+
+namespace data_structures::internal
+{
+
+// Type-safe field tag
+template <typename Owner, size_t Index, size_t Width>
+struct BitFieldTag {
+    using owner_type              = Owner;
+    static constexpr size_t index = Index;
+    static constexpr size_t width = Width;
+};
+
+// BitField specification
+template <typename Tag>
+struct BitFieldSpec {
+    using tag_type                = Tag;
+    static constexpr size_t width = Tag::width;
+    static constexpr size_t index = Tag::index;
+};
+
+// Calculate offset for a field at Index
+template <size_t Index, typename... Specs>
+struct OffsetCalculator;
+
+template <size_t Index, typename First, typename... Rest>
+struct OffsetCalculator<Index, First, Rest...> {
+    static constexpr size_t value =
+        (Index == First::index) ? 0 : First::width + OffsetCalculator<Index, Rest...>::value;
+};
+
+template <size_t Index, typename First>
+struct OffsetCalculator<Index, First> {
+    static constexpr size_t value = (Index == First::index) ? 0 : First::width;
+};
+
+// Calculate total size in bits
+template <typename... Specs>
+struct TotalSize;
+
+template <typename First, typename... Rest>
+struct TotalSize<First, Rest...> {
+    static constexpr size_t value = First::width + TotalSize<Rest...>::value;
+};
+
+template <>
+struct TotalSize<> {
+    static constexpr size_t value = 0;
+};
+
+// Find spec by tag index
+template <size_t Index, typename... Specs>
+struct FindSpecByIndex;
+
+template <size_t Index, typename First, typename... Rest>
+struct FindSpecByIndex<Index, First, Rest...> {
+    static constexpr bool found = (First::index == Index);
+    using type = std::conditional_t<found, First, typename FindSpecByIndex<Index, Rest...>::type>;
+};
+
+template <size_t Index>
+struct FindSpecByIndex<Index> {
+    static constexpr bool found = false;
+    using type                  = void;
+};
+
+template <typename T>
+struct IsBitField : std::false_type {
+};
+
+template <typename Derived, typename... FieldSpecs>
+class EnumBitFieldsBase;
+
+template <typename Derived, typename... FieldSpecs>
+struct IsBitField<EnumBitFieldsBase<Derived, FieldSpecs...>> : std::true_type {
+};
+
+template <typename T>
+concept NotBitField = !IsBitField<std::remove_cvref_t<T>>::value;
+
+template <typename Derived, typename... FieldSpecs>
+class EnumBitFieldsBase
+{
+    public:
+    constexpr EnumBitFieldsBase()                          = default;
+    constexpr EnumBitFieldsBase(const EnumBitFieldsBase &) = default;
+
+    template <typename OtherDerived, typename... OtherSpecs>
+    constexpr EnumBitFieldsBase(const EnumBitFieldsBase<OtherDerived, OtherSpecs...> &other)
+        : data_(other.storage())
+    {
+        static_assert(
+            kTotalBits == EnumBitFieldsBase<OtherDerived, OtherSpecs...>::kTotalBits,
+            "Source and Destination must have the same total size in bits."
+        );
+    }
+
+    template <NotBitField T>
+    constexpr explicit EnumBitFieldsBase(const T &value)
+    {
+        static_assert(
+            sizeof(T) == data_.kNumStorage, "Size of input type must match BitField storage size."
+        );
+
+        data_ = std::bit_cast<BitArray<kTotalBits>>(value);
+    }
+
+    template <NotBitField T>
+    constexpr EnumBitFieldsBase &operator=(const T &value)
+    {
+        static_assert(
+            sizeof(T) == data_.kNumStorage, "Size of input type must match BitField storage size."
+        );
+
+        data_ = std::bit_cast<BitArray<kTotalBits>>(value);
+        return *this;
+    }
+
+    template <NotBitField T>
+    constexpr explicit operator T() const
+    {
+        static_assert(
+            sizeof(T) == data_.kNumStorage,
+            "Size of destination type must match BitField storage size."
+        );
+
+        return std::bit_cast<T>(data_);
+    }
+
+    template <typename OtherDerived, typename... OtherSpecs>
+    constexpr EnumBitFieldsBase &operator=(
+        const EnumBitFieldsBase<OtherDerived, OtherSpecs...> &other
+    )
+    {
+        static_assert(
+            kTotalBits == EnumBitFieldsBase<OtherDerived, OtherSpecs...>::kTotalBits,
+            "Source and Destination bitfields must have the same total size in bits."
+        );
+
+        this->data_ = other.data_;
+        return *this;
+    }
+
+    template <typename Tag>
+    constexpr size_t get() const
+    {
+        static_assert(std::is_same_v<typename Tag::owner_type, Derived>, "Invalid Tag used");
+        using Spec = typename FindSpecByIndex<Tag::index, FieldSpecs...>::type;
+        return data_.template GetRange<OffsetFor<Tag::index>, Spec::width>();
+    }
+
+    template <typename Tag>
+    constexpr void set(size_t value)
+    {
+        static_assert(std::is_same_v<typename Tag::owner_type, Derived>, "Invalid Tag used");
+        using Spec = typename FindSpecByIndex<Tag::index, FieldSpecs...>::type;
+        data_.template SetRange<OffsetFor<Tag::index>, Spec::width>(value);
+    }
+
+    static constexpr size_t kTotalBits = TotalSize<FieldSpecs...>::value;
+
+    private:
+    template <size_t Index>
+    static constexpr size_t OffsetFor = OffsetCalculator<Index, FieldSpecs...>::value;
+
+    protected:
+    BitArray<kTotalBits> data_;
+};
+
+}  // namespace data_structures::internal
+
+#define BF_ENUM_ENTRY(name, width) k##name
+
+#define BF_FIELD_TAG(ctx, name, width)                   \
+    using name = data_structures::internal::BitFieldTag< \
+        ctx::Owner, static_cast<size_t>(ctx::Index::k##name), width>
+
+#define BF_FIELD_SPEC(ctx, name, width)                                             \
+    data_structures::internal::BitFieldSpec<data_structures::internal::BitFieldTag< \
+        ctx::Owner, static_cast<size_t>(ctx::Index::k##name), width>>
+
+#define CREATE_BITFIELD(ClassName, ...)                                                     \
+    class ClassName;                                                                        \
+                                                                                            \
+    namespace ClassName##Details                                                            \
+    {                                                                                       \
+        using Owner = ClassName;                                                            \
+        enum class Index : size_t { FOR_EACH_PAIR(BF_ENUM_ENTRY, __VA_ARGS__), kLast };     \
+    }                                                                                       \
+                                                                                            \
+    class ClassName                                                                         \
+        : public data_structures::internal::EnumBitFieldsBase<                              \
+              ClassName, FOR_EACH_PAIR_CTX(BF_FIELD_SPEC, ClassName##Details, __VA_ARGS__)> \
+    {                                                                                       \
+        private:                                                                            \
+        using Base = data_structures::internal::EnumBitFieldsBase<                          \
+            ClassName, FOR_EACH_PAIR_CTX(BF_FIELD_SPEC, ClassName##Details, __VA_ARGS__)>;  \
+                                                                                            \
+        public:                                                                             \
+        using Base::Base;                                                                   \
+        using Base::operator=;                                                              \
+        using Base::get;                                                                    \
+        using Base::set;                                                                    \
+                                                                                            \
+        FOR_EACH_PAIR_CTX_SEP(SEMICOLON, BF_FIELD_TAG, ClassName##Details, __VA_ARGS__);    \
+    }
+
+#endif  // LIBS_LIBCONTAINERS_INCLUDE_DATA_STRUCTURES_BITFIELD_HPP_
diff --git a/libs/libcpp/include/bit.hpp b/libs/libcpp/include/bit.hpp
index 01a692dc..276828e3 100644
--- a/libs/libcpp/include/bit.hpp
+++ b/libs/libcpp/include/bit.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_LIBC_INCLUDE_EXTENSIONS_BIT_HPP_
-#define ALKOS_LIBC_INCLUDE_EXTENSIONS_BIT_HPP_
+#ifndef LIBS_LIBCPP_INCLUDE_BIT_HPP_
+#define LIBS_LIBCPP_INCLUDE_BIT_HPP_
 
 #include <bits_ext.hpp>
 #include <concepts.hpp>
@@ -168,9 +168,21 @@ constexpr FAST_CALL T bit_ceil(T x) noexcept
     return kLsb<T> << std::bit_width(T(x - static_cast<T>(1)));
 }
 
+// ------------------------------
+// std::bit_cast
+// ------------------------------
+
+template <class To, class From>
+constexpr To bit_cast(const From &from) noexcept
+    requires(sizeof(To) == sizeof(From)) && std::is_trivially_copyable_v<To> &&
+            std::is_trivially_copyable_v<From>
+{
+    return __builtin_bit_cast(To, from);
+}
+
 TODO_LIBCPP_COMPLIANCE
 // TODO: Implement other functions from standard
 
 }  // namespace std
 
-#endif  // ALKOS_LIBC_INCLUDE_EXTENSIONS_BIT_HPP_
+#endif  // LIBS_LIBCPP_INCLUDE_BIT_HPP_
diff --git a/libs/libcpp/include/bits_ext.hpp b/libs/libcpp/include/bits_ext.hpp
index 0a7149ce..bdb3451f 100644
--- a/libs/libcpp/include/bits_ext.hpp
+++ b/libs/libcpp/include/bits_ext.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_LIBC_INCLUDE_EXTENSIONS_BITS_EXT_HPP_
-#define ALKOS_LIBC_INCLUDE_EXTENSIONS_BITS_EXT_HPP_
+#ifndef LIBS_LIBCPP_INCLUDE_BITS_EXT_HPP_
+#define LIBS_LIBCPP_INCLUDE_BITS_EXT_HPP_
 
 #include <stdint.h>
 #include "assert.h"
@@ -98,6 +98,12 @@ FAST_CALL NumT &SetBit(NumT &num, const u16 bit)
     return num |= kLsb<NumT> << bit;
 }
 
+template <u16 kBit, std::unsigned_integral NumT>
+FAST_CALL constexpr bool GetBit(const NumT num)
+{
+    return num & kSingleBit<NumT, kBit>;
+}
+
 template <std::unsigned_integral NumT>
 FAST_CALL NumT &ClearBit(NumT &num, const u16 bit)
 {
@@ -214,4 +220,4 @@ FAST_CALL constexpr bool IsPowerOfTwo(const NumT n)
     return n > 0 && (n & (n - 1)) == 0;
 }
 
-#endif  // ALKOS_LIBC_INCLUDE_EXTENSIONS_BITS_EXT_HPP_
+#endif  // LIBS_LIBCPP_INCLUDE_BITS_EXT_HPP_
diff --git a/libs/libcpp/include/internal/macro.hpp b/libs/libcpp/include/internal/macro.hpp
new file mode 100644
index 00000000..b82385cd
--- /dev/null
+++ b/libs/libcpp/include/internal/macro.hpp
@@ -0,0 +1,37 @@
+#ifndef LIBS_LIBCPP_INCLUDE_INTERNAL_MACRO_HPP_
+#define LIBS_LIBCPP_INCLUDE_INTERNAL_MACRO_HPP_
+
+// https://www.scs.stanford.edu/~dm/blog/va-opt.html
+#define PARENS      ()
+#define SEMICOLON() ;
+#define COMMA()     ,
+
+#define EXPAND(...)  EXPAND4(EXPAND4(EXPAND4(EXPAND4(__VA_ARGS__))))
+#define EXPAND4(...) EXPAND3(EXPAND3(EXPAND3(EXPAND3(__VA_ARGS__))))
+#define EXPAND3(...) EXPAND2(EXPAND2(EXPAND2(EXPAND2(__VA_ARGS__))))
+#define EXPAND2(...) EXPAND1(EXPAND1(EXPAND1(EXPAND1(__VA_ARGS__))))
+#define EXPAND1(...) __VA_ARGS__
+
+#define FOR_EACH(macro, ...) __VA_OPT__(EXPAND(FOR_EACH_HELPER(macro, __VA_ARGS__)))
+#define FOR_EACH_HELPER(macro, a1, ...) \
+    macro(a1) __VA_OPT__(, FOR_EACH_AGAIN PARENS(macro, __VA_ARGS__))
+#define FOR_EACH_AGAIN() FOR_EACH_HELPER
+
+#define FOR_EACH_PAIR_SEP(sep, macro, ...) \
+    __VA_OPT__(EXPAND(FOR_EACH_PAIR_SEP_HELPER(sep, macro, __VA_ARGS__)))
+#define FOR_EACH_PAIR_SEP_HELPER(sep, macro, a1, a2, ...) \
+    macro(a1, a2) __VA_OPT__(sep PARENS FOR_EACH_PAIR_SEP_AGAIN PARENS(sep, macro, __VA_ARGS__))
+#define FOR_EACH_PAIR_SEP_AGAIN() FOR_EACH_PAIR_SEP_HELPER
+
+#define FOR_EACH_PAIR(macro, ...) FOR_EACH_PAIR_SEP(COMMA, macro, __VA_ARGS__)
+
+#define FOR_EACH_PAIR_CTX_SEP(sep, macro, ctx, ...) \
+    __VA_OPT__(EXPAND(FOR_EACH_PAIR_CTX_SEP_HELPER(sep, macro, ctx, __VA_ARGS__)))
+#define FOR_EACH_PAIR_CTX_SEP_HELPER(sep, macro, ctx, a1, a2, ...) \
+    macro(ctx, a1, a2)                                             \
+        __VA_OPT__(sep PARENS FOR_EACH_PAIR_CTX_SEP_AGAIN PARENS(sep, macro, ctx, __VA_ARGS__))
+#define FOR_EACH_PAIR_CTX_SEP_AGAIN() FOR_EACH_PAIR_CTX_SEP_HELPER
+
+#define FOR_EACH_PAIR_CTX(macro, ctx, ...) FOR_EACH_PAIR_CTX_SEP(COMMA, macro, ctx, __VA_ARGS__)
+
+#endif  // LIBS_LIBCPP_INCLUDE_INTERNAL_MACRO_HPP_

From e6e0972a072adae46aebadd27c0668b2ba03976b Mon Sep 17 00:00:00 2001
From: Adam Ogieniewski <ogieniewski.dev@gmail.com>
Date: Tue, 16 Dec 2025 02:26:28 +0100
Subject: [PATCH 14/56] Header gaurds cleanup (#239)

---
 .gitignore                                                  | 2 --
 kernel/arch/x86_64/boot/lib/debug_trace.hpp                 | 6 +++---
 kernel/arch/x86_64/boot/lib/elf/error.hpp                   | 6 +++---
 kernel/arch/x86_64/boot/lib/mem/error.hpp                   | 6 +++---
 kernel/arch/x86_64/boot/lib/multiboot2/error.hpp            | 6 +++---
 kernel/arch/x86_64/boot/lib/sys/panic.hpp                   | 6 +++---
 kernel/arch/x86_64/boot/lib/todo.hpp                        | 6 +++---
 kernel/arch/x86_64/boot/loader_32/src/error.hpp             | 6 +++---
 kernel/arch/x86_64/boot/loader_64/src/error.hpp             | 6 +++---
 kernel/arch/x86_64/src/hal/impl/acpi_controller.hpp         | 6 +++---
 kernel/arch/x86_64/src/hal/impl/core.hpp                    | 6 +++---
 kernel/arch/x86_64/src/hal/impl/intr_parser.hpp             | 6 +++---
 kernel/arch/x86_64/src/hal/impl/panic.hpp                   | 6 +++---
 kernel/arch/x86_64/src/hal/impl/tlb.hpp                     | 6 +++---
 kernel/src/graphics/fonts/drdos8x8.hpp                      | 2 +-
 kernel/src/hal/acpi_controller.hpp                          | 6 +++---
 kernel/src/hal/api/acpi_controller.hpp                      | 6 +++---
 kernel/src/hal/api/interrupts.hpp                           | 6 +++---
 kernel/src/hal/api/interrupts_params.hpp                    | 6 +++---
 kernel/src/hal/api/intr_parser.hpp                          | 6 +++---
 kernel/src/hal/api/spinlock.hpp                             | 6 +++---
 kernel/src/hal/boot_args.hpp                                | 6 +++---
 kernel/src/hal/core.hpp                                     | 6 +++---
 kernel/src/hal/debug_terminal.hpp                           | 6 +++---
 kernel/src/hal/interrupt_params.hpp                         | 6 +++---
 kernel/src/hal/interrupts.hpp                               | 6 +++---
 kernel/src/hal/intr_parser.hpp                              | 6 +++---
 kernel/src/hal/panic.hpp                                    | 6 +++---
 kernel/src/hal/qemu.hpp                                     | 6 +++---
 kernel/src/hal/spinlock.hpp                                 | 6 +++---
 kernel/src/hal/sync.hpp                                     | 6 +++---
 kernel/src/hal/terminal.hpp                                 | 6 +++---
 kernel/src/hal/timers.hpp                                   | 6 +++---
 kernel/src/hardware/core_controller.hpp                     | 6 +++---
 kernel/src/hardware/core_local.hpp                          | 6 +++---
 kernel/src/hardware/interupts.hpp                           | 6 +++---
 kernel/src/interrupts/interupts.hpp                         | 6 +++---
 kernel/src/mem/error.hpp                                    | 6 +++---
 kernel/src/mem/virt/page_fault.hpp                          | 6 +++---
 kernel/src/mem/virt/page_fault_data.hpp                     | 6 +++---
 kernel/src/modules/helpers.hpp                              | 6 +++---
 kernel/src/modules/timing_constants.hpp                     | 6 +++---
 kernel/src/sync/kernel/spinlock.hpp                         | 6 +++---
 kernel/src/todo.hpp                                         | 6 +++---
 kernel/test/test_module/expect.hpp                          | 6 +++---
 kernel/test/test_module/test.hpp                            | 6 +++---
 kernel/test/test_module/test_group_base.hpp                 | 6 +++---
 kernel/test/test_structs.hpp                                | 6 +++---
 kernel/thirdparty/uacpi/uacpi_libc.h                        | 6 +++---
 libs/libc/include/errno.h                                   | 6 +++---
 libs/libc/include/libssp.h                                  | 6 +++---
 libs/libc/include/math/checks.h                             | 6 +++---
 libs/libc/include/math/operations.hpp                       | 6 +++---
 libs/libc/include/stdio.h                                   | 6 +++---
 libs/libc/include/stdlib.h                                  | 6 +++---
 libs/libc/include/string.h                                  | 6 +++---
 libs/libc/include/sys/calls.h                               | 6 +++---
 libs/libc/include/time.h                                    | 6 +++---
 libs/libc/include/todo.h                                    | 6 +++---
 libs/libc/include/types.h                                   | 6 +++---
 libs/libc/internal/time_internal.hpp                        | 6 +++---
 .../include/data_structures/data_structures.hpp             | 6 +++---
 libs/libcontainers/include/data_structures/events.hpp       | 6 +++---
 libs/libcontainers/include/data_structures/hash_maps.hpp    | 6 +++---
 libs/libcpp/include/algorithm.hpp                           | 6 +++---
 libs/libcpp/include/array.hpp                               | 6 +++---
 libs/libcpp/include/char_traits.hpp                         | 6 +++---
 libs/libcpp/include/compare.hpp                             | 6 +++---
 libs/libcpp/include/concepts.hpp                            | 6 +++---
 libs/libcpp/include/concepts_ext.hpp                        | 6 +++---
 libs/libcpp/include/cstddef.hpp                             | 6 +++---
 libs/libcpp/include/defines.hpp                             | 6 +++---
 libs/libcpp/include/expected.hpp                            | 6 +++---
 libs/libcpp/include/formats.hpp                             | 6 +++---
 libs/libcpp/include/functional.hpp                          | 6 +++---
 libs/libcpp/include/initializer_list.hpp                    | 6 +++---
 libs/libcpp/include/internal/formats.hpp                    | 6 +++---
 libs/libcpp/include/internal/intervals.hpp                  | 6 +++---
 libs/libcpp/include/internal/invoke.hpp                     | 6 +++---
 libs/libcpp/include/internal/tuple_base.hpp                 | 6 +++---
 libs/libcpp/include/internal/utility.hpp                    | 6 +++---
 libs/libcpp/include/limits.hpp                              | 6 +++---
 libs/libcpp/include/literals.hpp                            | 6 +++---
 libs/libcpp/include/mutex.hpp                               | 6 +++---
 libs/libcpp/include/new.hpp                                 | 6 +++---
 libs/libcpp/include/optional.hpp                            | 6 +++---
 libs/libcpp/include/string.hpp                              | 6 +++---
 libs/libcpp/include/time.hpp                                | 6 +++---
 libs/libcpp/include/tuple.hpp                               | 6 +++---
 libs/libcpp/include/type_traits.hpp                         | 6 +++---
 libs/libcpp/include/type_traits_ext.hpp                     | 6 +++---
 libs/libcpp/include/types.hpp                               | 6 +++---
 libs/libcpp/include/variant.hpp                             | 6 +++---
 93 files changed, 274 insertions(+), 276 deletions(-)

diff --git a/.gitignore b/.gitignore
index 0f8f9ba9..04d0bb49 100644
--- a/.gitignore
+++ b/.gitignore
@@ -54,5 +54,3 @@ tools
 __pycache__
 logs
 test_framework_logs
-
-generated
diff --git a/kernel/arch/x86_64/boot/lib/debug_trace.hpp b/kernel/arch/x86_64/boot/lib/debug_trace.hpp
index 732fba4d..de2a1fc6 100644
--- a/kernel/arch/x86_64/boot/lib/debug_trace.hpp
+++ b/kernel/arch/x86_64/boot/lib/debug_trace.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_LIBC_INCLUDE_EXTENSIONS_DEBUG_HPP_
-#define ALKOS_LIBC_INCLUDE_EXTENSIONS_DEBUG_HPP_
+#ifndef KERNEL_ARCH_X86_64_BOOT_LIB_DEBUG_TRACE_HPP_
+#define KERNEL_ARCH_X86_64_BOOT_LIB_DEBUG_TRACE_HPP_
 
 #include <autogen/feature_flags.h>
 #include <todo.hpp>
@@ -57,4 +57,4 @@ void FormatTrace(const char *format, Args... args)
 #define TRACE_SUCCESS(message, ...) \
     TRACE(TRACE_FORMAT_SUCCESS(message), 0ull __VA_OPT__(, ) __VA_ARGS__)
 
-#endif  // ALKOS_LIBC_INCLUDE_EXTENSIONS_DEBUG_HPP_
+#endif  // KERNEL_ARCH_X86_64_BOOT_LIB_DEBUG_TRACE_HPP_
diff --git a/kernel/arch/x86_64/boot/lib/elf/error.hpp b/kernel/arch/x86_64/boot/lib/elf/error.hpp
index a4ec0299..f0377da2 100644
--- a/kernel/arch/x86_64/boot/lib/elf/error.hpp
+++ b/kernel/arch/x86_64/boot/lib/elf/error.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_KERNEL_ARCH_X86_64_BOOT_LIB_ELF_ERROR_HPP_
-#define ALKOS_KERNEL_ARCH_X86_64_BOOT_LIB_ELF_ERROR_HPP_
+#ifndef KERNEL_ARCH_X86_64_BOOT_LIB_ELF_ERROR_HPP_
+#define KERNEL_ARCH_X86_64_BOOT_LIB_ELF_ERROR_HPP_
 
 namespace Elf64
 {
@@ -14,4 +14,4 @@ enum class Error {
 
 }  // namespace Elf64
 
-#endif  // ALKOS_KERNEL_ARCH_X86_64_BOOT_LIB_ELF_ERROR_HPP_
+#endif  // KERNEL_ARCH_X86_64_BOOT_LIB_ELF_ERROR_HPP_
diff --git a/kernel/arch/x86_64/boot/lib/mem/error.hpp b/kernel/arch/x86_64/boot/lib/mem/error.hpp
index 1db77ab6..7ea6b3ae 100644
--- a/kernel/arch/x86_64/boot/lib/mem/error.hpp
+++ b/kernel/arch/x86_64/boot/lib/mem/error.hpp
@@ -1,9 +1,9 @@
-#ifndef ALKOS_KERNEL_ARCH_X86_64_BOOT_LIB_MEM_ERROR_HPP_
-#define ALKOS_KERNEL_ARCH_X86_64_BOOT_LIB_MEM_ERROR_HPP_
+#ifndef KERNEL_ARCH_X86_64_BOOT_LIB_MEM_ERROR_HPP_
+#define KERNEL_ARCH_X86_64_BOOT_LIB_MEM_ERROR_HPP_
 
 enum class MemError {
     OutOfMemory,
     InvalidArgument,
 };
 
-#endif  // ALKOS_KERNEL_ARCH_X86_64_BOOT_LIB_MEM_ERROR_HPP_
+#endif  // KERNEL_ARCH_X86_64_BOOT_LIB_MEM_ERROR_HPP_
diff --git a/kernel/arch/x86_64/boot/lib/multiboot2/error.hpp b/kernel/arch/x86_64/boot/lib/multiboot2/error.hpp
index 3b4bff5e..bed81f6a 100644
--- a/kernel/arch/x86_64/boot/lib/multiboot2/error.hpp
+++ b/kernel/arch/x86_64/boot/lib/multiboot2/error.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_KERNEL_ARCH_X86_64_BOOT_LIB_MULTIBOOT2_ERROR_HPP_
-#define ALKOS_KERNEL_ARCH_X86_64_BOOT_LIB_MULTIBOOT2_ERROR_HPP_
+#ifndef KERNEL_ARCH_X86_64_BOOT_LIB_MULTIBOOT2_ERROR_HPP_
+#define KERNEL_ARCH_X86_64_BOOT_LIB_MULTIBOOT2_ERROR_HPP_
 
 namespace Multiboot
 {
@@ -10,4 +10,4 @@ enum class Error {
 
 }  // namespace Multiboot
 
-#endif  // ALKOS_KERNEL_ARCH_X86_64_BOOT_LIB_MULTIBOOT2_ERROR_HPP_
+#endif  // KERNEL_ARCH_X86_64_BOOT_LIB_MULTIBOOT2_ERROR_HPP_
diff --git a/kernel/arch/x86_64/boot/lib/sys/panic.hpp b/kernel/arch/x86_64/boot/lib/sys/panic.hpp
index e7a1e267..45f6aba1 100644
--- a/kernel/arch/x86_64/boot/lib/sys/panic.hpp
+++ b/kernel/arch/x86_64/boot/lib/sys/panic.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_KERNEL_ARCH_X86_64_BOOT_LIB_SYS_PANIC_HPP_
-#define ALKOS_KERNEL_ARCH_X86_64_BOOT_LIB_SYS_PANIC_HPP_
+#ifndef KERNEL_ARCH_X86_64_BOOT_LIB_SYS_PANIC_HPP_
+#define KERNEL_ARCH_X86_64_BOOT_LIB_SYS_PANIC_HPP_
 
 #include <stdio.h>
 
@@ -22,4 +22,4 @@ FAST_CALL NO_RET void KernelPanicFormat(const char *fmt, Args... args)
     KernelPanic(buffer);
 }
 
-#endif  // ALKOS_KERNEL_ARCH_X86_64_BOOT_LIB_SYS_PANIC_HPP_
+#endif  // KERNEL_ARCH_X86_64_BOOT_LIB_SYS_PANIC_HPP_
diff --git a/kernel/arch/x86_64/boot/lib/todo.hpp b/kernel/arch/x86_64/boot/lib/todo.hpp
index 7890490f..fb4e07e1 100644
--- a/kernel/arch/x86_64/boot/lib/todo.hpp
+++ b/kernel/arch/x86_64/boot/lib/todo.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_KERNEL_ARCH_X86_64_BOOT_LIB_TODO_HPP_
-#define ALKOS_KERNEL_ARCH_X86_64_BOOT_LIB_TODO_HPP_
+#ifndef KERNEL_ARCH_X86_64_BOOT_LIB_TODO_HPP_
+#define KERNEL_ARCH_X86_64_BOOT_LIB_TODO_HPP_
 
 /**
  * @brief This file's purpose is to define a set of macros used as placeholders
@@ -16,4 +16,4 @@
 #define TODO_BY_THE_END_OF_MILESTONE0
 #define TODO_WHEN_DEBUGGING_FRAMEWORK
 
-#endif  // ALKOS_KERNEL_ARCH_X86_64_BOOT_LIB_TODO_HPP_
+#endif  // KERNEL_ARCH_X86_64_BOOT_LIB_TODO_HPP_
diff --git a/kernel/arch/x86_64/boot/loader_32/src/error.hpp b/kernel/arch/x86_64/boot/loader_32/src/error.hpp
index 252d3701..0910dd3b 100644
--- a/kernel/arch/x86_64/boot/loader_32/src/error.hpp
+++ b/kernel/arch/x86_64/boot/loader_32/src/error.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_KERNEL_ARCH_X86_64_BOOT_LOADER_32_SRC_ERROR_HPP_
-#define ALKOS_KERNEL_ARCH_X86_64_BOOT_LOADER_32_SRC_ERROR_HPP_
+#ifndef KERNEL_ARCH_X86_64_BOOT_LOADER_32_SRC_ERROR_HPP_
+#define KERNEL_ARCH_X86_64_BOOT_LOADER_32_SRC_ERROR_HPP_
 
 namespace loader32
 {
@@ -15,4 +15,4 @@ enum class Error {
 
 }  // namespace loader32
 
-#endif  // ALKOS_KERNEL_ARCH_X86_64_BOOT_LOADER_32_SRC_ERROR_HPP_
+#endif  // KERNEL_ARCH_X86_64_BOOT_LOADER_32_SRC_ERROR_HPP_
diff --git a/kernel/arch/x86_64/boot/loader_64/src/error.hpp b/kernel/arch/x86_64/boot/loader_64/src/error.hpp
index 418ec3b6..d4af71b7 100644
--- a/kernel/arch/x86_64/boot/loader_64/src/error.hpp
+++ b/kernel/arch/x86_64/boot/loader_64/src/error.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_KERNEL_ARCH_X86_64_BOOT_LOADER_64_SRC_ERROR_HPP_
-#define ALKOS_KERNEL_ARCH_X86_64_BOOT_LOADER_64_SRC_ERROR_HPP_
+#ifndef KERNEL_ARCH_X86_64_BOOT_LOADER_64_SRC_ERROR_HPP_
+#define KERNEL_ARCH_X86_64_BOOT_LOADER_64_SRC_ERROR_HPP_
 
 namespace loader64
 {
@@ -13,4 +13,4 @@ enum class Error {
 
 }  // namespace loader64
 
-#endif  // ALKOS_KERNEL_ARCH_X86_64_BOOT_LOADER_64_SRC_ERROR_HPP_
+#endif  // KERNEL_ARCH_X86_64_BOOT_LOADER_64_SRC_ERROR_HPP_
diff --git a/kernel/arch/x86_64/src/hal/impl/acpi_controller.hpp b/kernel/arch/x86_64/src/hal/impl/acpi_controller.hpp
index 65df347e..847dc931 100644
--- a/kernel/arch/x86_64/src/hal/impl/acpi_controller.hpp
+++ b/kernel/arch/x86_64/src/hal/impl/acpi_controller.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_KERNEL_ARCH_X86_64_SRC_HAL_IMPL_ACPI_CONTROLLER_HPP_
-#define ALKOS_KERNEL_ARCH_X86_64_SRC_HAL_IMPL_ACPI_CONTROLLER_HPP_
+#ifndef KERNEL_ARCH_X86_64_SRC_HAL_IMPL_ACPI_CONTROLLER_HPP_
+#define KERNEL_ARCH_X86_64_SRC_HAL_IMPL_ACPI_CONTROLLER_HPP_
 
 #include <hal/api/acpi_controller.hpp>
 
@@ -32,4 +32,4 @@ class AcpiController : public AcpiAPI
 };
 }  // namespace arch
 
-#endif  // ALKOS_KERNEL_ARCH_X86_64_SRC_HAL_IMPL_ACPI_CONTROLLER_HPP_
+#endif  // KERNEL_ARCH_X86_64_SRC_HAL_IMPL_ACPI_CONTROLLER_HPP_
diff --git a/kernel/arch/x86_64/src/hal/impl/core.hpp b/kernel/arch/x86_64/src/hal/impl/core.hpp
index c4bd2ff5..76ce91d3 100644
--- a/kernel/arch/x86_64/src/hal/impl/core.hpp
+++ b/kernel/arch/x86_64/src/hal/impl/core.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_KERNEL_ARCH_X86_64_SRC_HAL_IMPL_CORE_HPP_
-#define ALKOS_KERNEL_ARCH_X86_64_SRC_HAL_IMPL_CORE_HPP_
+#ifndef KERNEL_ARCH_X86_64_SRC_HAL_IMPL_CORE_HPP_
+#define KERNEL_ARCH_X86_64_SRC_HAL_IMPL_CORE_HPP_
 
 #include <hal/api/core.hpp>
 #include "cpu/msrs.hpp"
@@ -51,4 +51,4 @@ FAST_CALL void *GetCoreLocalData() { return reinterpret_cast<void *>(cpu::GetMSR
 
 }  // namespace arch
 
-#endif  // ALKOS_KERNEL_ARCH_X86_64_SRC_HAL_IMPL_CORE_HPP_
+#endif  // KERNEL_ARCH_X86_64_SRC_HAL_IMPL_CORE_HPP_
diff --git a/kernel/arch/x86_64/src/hal/impl/intr_parser.hpp b/kernel/arch/x86_64/src/hal/impl/intr_parser.hpp
index 2da9eec7..09d6d10c 100644
--- a/kernel/arch/x86_64/src/hal/impl/intr_parser.hpp
+++ b/kernel/arch/x86_64/src/hal/impl/intr_parser.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_KERNEL_ARCH_X86_64_SRC_HAL_IMPL_INTR_PARSER_HPP_
-#define ALKOS_KERNEL_ARCH_X86_64_SRC_HAL_IMPL_INTR_PARSER_HPP_
+#ifndef KERNEL_ARCH_X86_64_SRC_HAL_IMPL_INTR_PARSER_HPP_
+#define KERNEL_ARCH_X86_64_SRC_HAL_IMPL_INTR_PARSER_HPP_
 
 #include <hal/api/intr_parser.hpp>
 #include <mem/virt/page_fault_data.hpp>
@@ -13,4 +13,4 @@ Mem::PageFaultData ParsePageFaultData(const ExceptionData &ed);
 
 }
 
-#endif  // ALKOS_KERNEL_ARCH_X86_64_SRC_HAL_IMPL_INTR_PARSER_HPP_
+#endif  // KERNEL_ARCH_X86_64_SRC_HAL_IMPL_INTR_PARSER_HPP_
diff --git a/kernel/arch/x86_64/src/hal/impl/panic.hpp b/kernel/arch/x86_64/src/hal/impl/panic.hpp
index 6153ee30..3dcdf297 100644
--- a/kernel/arch/x86_64/src/hal/impl/panic.hpp
+++ b/kernel/arch/x86_64/src/hal/impl/panic.hpp
@@ -1,9 +1,9 @@
-#ifndef ALKOS_KERNEL_ARCH_X86_64_SRC_HAL_IMPL_PANIC_HPP_
-#define ALKOS_KERNEL_ARCH_X86_64_SRC_HAL_IMPL_PANIC_HPP_
+#ifndef KERNEL_ARCH_X86_64_SRC_HAL_IMPL_PANIC_HPP_
+#define KERNEL_ARCH_X86_64_SRC_HAL_IMPL_PANIC_HPP_
 
 namespace arch
 {
 extern "C" NO_RET void KernelPanic();
 }  // namespace arch
 
-#endif  // ALKOS_KERNEL_ARCH_X86_64_SRC_HAL_IMPL_PANIC_HPP_
+#endif  // KERNEL_ARCH_X86_64_SRC_HAL_IMPL_PANIC_HPP_
diff --git a/kernel/arch/x86_64/src/hal/impl/tlb.hpp b/kernel/arch/x86_64/src/hal/impl/tlb.hpp
index 2760149c..80ef07d4 100644
--- a/kernel/arch/x86_64/src/hal/impl/tlb.hpp
+++ b/kernel/arch/x86_64/src/hal/impl/tlb.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_KERNEL_ARCH_X86_64_SRC_HAL_IMPL_TLB_HPP_
-#define ALKOS_KERNEL_ARCH_X86_64_SRC_HAL_IMPL_TLB_HPP_
+#ifndef KERNEL_ARCH_X86_64_SRC_HAL_IMPL_TLB_HPP_
+#define KERNEL_ARCH_X86_64_SRC_HAL_IMPL_TLB_HPP_
 
 #include <hal/api/tlb.hpp>
 
@@ -28,4 +28,4 @@ class Tlb : public TlbAPI
 
 }  // namespace arch
 
-#endif  // ALKOS_KERNEL_ARCH_X86_64_SRC_HAL_IMPL_TLB_HPP_
+#endif  // KERNEL_ARCH_X86_64_SRC_HAL_IMPL_TLB_HPP_
diff --git a/kernel/src/graphics/fonts/drdos8x8.hpp b/kernel/src/graphics/fonts/drdos8x8.hpp
index 59e49902..ebd73fed 100644
--- a/kernel/src/graphics/fonts/drdos8x8.hpp
+++ b/kernel/src/graphics/fonts/drdos8x8.hpp
@@ -318,4 +318,4 @@ static constexpr unsigned char drdos8x8_psfu[] = {
 };
 static constexpr unsigned int drdos8x8_psfu_len = 4983;
 
-#endif /* KERNEL_SRC_GRAPHICS_FONTS_DRDOS8X8_HPP_ */
+#endif  // KERNEL_SRC_GRAPHICS_FONTS_DRDOS8X8_HPP_
diff --git a/kernel/src/hal/acpi_controller.hpp b/kernel/src/hal/acpi_controller.hpp
index f6285f67..3a36c327 100644
--- a/kernel/src/hal/acpi_controller.hpp
+++ b/kernel/src/hal/acpi_controller.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_KERNEL_INCLUDE_HAL_ACPI_CONTROLLER_HPP_
-#define ALKOS_KERNEL_INCLUDE_HAL_ACPI_CONTROLLER_HPP_
+#ifndef KERNEL_SRC_HAL_ACPI_CONTROLLER_HPP_
+#define KERNEL_SRC_HAL_ACPI_CONTROLLER_HPP_
 
 #include <hal/impl/acpi_controller.hpp>
 
@@ -8,4 +8,4 @@ namespace hal
 using arch::AcpiController;
 }  // namespace hal
 
-#endif  // ALKOS_KERNEL_INCLUDE_HAL_ACPI_CONTROLLER_HPP_
+#endif  // KERNEL_SRC_HAL_ACPI_CONTROLLER_HPP_
diff --git a/kernel/src/hal/api/acpi_controller.hpp b/kernel/src/hal/api/acpi_controller.hpp
index a5490300..7a5ae710 100644
--- a/kernel/src/hal/api/acpi_controller.hpp
+++ b/kernel/src/hal/api/acpi_controller.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_KERNEL_INCLUDE_HAL_API_ACPI_CONTROLLER_HPP_
-#define ALKOS_KERNEL_INCLUDE_HAL_API_ACPI_CONTROLLER_HPP_
+#ifndef KERNEL_SRC_HAL_API_ACPI_CONTROLLER_HPP_
+#define KERNEL_SRC_HAL_API_ACPI_CONTROLLER_HPP_
 
 namespace arch
 {
@@ -12,4 +12,4 @@ struct AcpiAPI {
 
 }  // namespace arch
 
-#endif  // ALKOS_KERNEL_INCLUDE_HAL_API_ACPI_CONTROLLER_HPP_
+#endif  // KERNEL_SRC_HAL_API_ACPI_CONTROLLER_HPP_
diff --git a/kernel/src/hal/api/interrupts.hpp b/kernel/src/hal/api/interrupts.hpp
index 0afb3e62..bfac21c1 100644
--- a/kernel/src/hal/api/interrupts.hpp
+++ b/kernel/src/hal/api/interrupts.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_KERNEL_INCLUDE_HAL_API_INTERRUPTS_HPP_
-#define ALKOS_KERNEL_INCLUDE_HAL_API_INTERRUPTS_HPP_
+#ifndef KERNEL_SRC_HAL_API_INTERRUPTS_HPP_
+#define KERNEL_SRC_HAL_API_INTERRUPTS_HPP_
 
 #include "stddef.h"
 
@@ -14,4 +14,4 @@ struct InterruptsAPI {
 
 }  // namespace arch
 
-#endif  // ALKOS_KERNEL_INCLUDE_HAL_API_INTERRUPTS_HPP_
+#endif  // KERNEL_SRC_HAL_API_INTERRUPTS_HPP_
diff --git a/kernel/src/hal/api/interrupts_params.hpp b/kernel/src/hal/api/interrupts_params.hpp
index 48172009..19b6edd1 100644
--- a/kernel/src/hal/api/interrupts_params.hpp
+++ b/kernel/src/hal/api/interrupts_params.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_KERNEL_INCLUDE_HAL_API_INTERRUPTS_PARAMS_HPP_
-#define ALKOS_KERNEL_INCLUDE_HAL_API_INTERRUPTS_PARAMS_HPP_
+#ifndef KERNEL_SRC_HAL_API_INTERRUPTS_PARAMS_HPP_
+#define KERNEL_SRC_HAL_API_INTERRUPTS_PARAMS_HPP_
 
 namespace arch
 {
@@ -9,4 +9,4 @@ struct ExceptionData;
 
 }  // namespace arch
 
-#endif  // ALKOS_KERNEL_INCLUDE_HAL_API_INTERRUPTS_PARAMS_HPP_
+#endif  // KERNEL_SRC_HAL_API_INTERRUPTS_PARAMS_HPP_
diff --git a/kernel/src/hal/api/intr_parser.hpp b/kernel/src/hal/api/intr_parser.hpp
index 2b061799..a89ab27a 100644
--- a/kernel/src/hal/api/intr_parser.hpp
+++ b/kernel/src/hal/api/intr_parser.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_KERNEL_INCLUDE_HAL_API_INTR_PARSER_HPP_
-#define ALKOS_KERNEL_INCLUDE_HAL_API_INTR_PARSER_HPP_
+#ifndef KERNEL_SRC_HAL_API_INTR_PARSER_HPP_
+#define KERNEL_SRC_HAL_API_INTR_PARSER_HPP_
 
 /*
  * This file contains functions that parse/translate data given
@@ -26,4 +26,4 @@ Mem::PageFaultData ParsePageFaultData(const ExceptionData &ed);
 
 }  // namespace arch
 
-#endif  // ALKOS_KERNEL_INCLUDE_HAL_API_INTR_PARSER_HPP_
+#endif  // KERNEL_SRC_HAL_API_INTR_PARSER_HPP_
diff --git a/kernel/src/hal/api/spinlock.hpp b/kernel/src/hal/api/spinlock.hpp
index 1ebdf8f1..397f8bf7 100644
--- a/kernel/src/hal/api/spinlock.hpp
+++ b/kernel/src/hal/api/spinlock.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_KERNEL_INCLUDE_HAL_API_SPINLOCK_HPP_
-#define ALKOS_KERNEL_INCLUDE_HAL_API_SPINLOCK_HPP_
+#ifndef KERNEL_SRC_HAL_API_SPINLOCK_HPP_
+#define KERNEL_SRC_HAL_API_SPINLOCK_HPP_
 
 namespace arch
 {
@@ -14,4 +14,4 @@ struct SpinlockAPI {
 
 }  // namespace arch
 
-#endif  // ALKOS_KERNEL_INCLUDE_HAL_API_SPINLOCK_HPP_
+#endif  // KERNEL_SRC_HAL_API_SPINLOCK_HPP_
diff --git a/kernel/src/hal/boot_args.hpp b/kernel/src/hal/boot_args.hpp
index bd9e1fdb..dd586092 100644
--- a/kernel/src/hal/boot_args.hpp
+++ b/kernel/src/hal/boot_args.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_KERNEL_INCLUDE_HAL_BOOT_ARGS_HPP_
-#define ALKOS_KERNEL_INCLUDE_HAL_BOOT_ARGS_HPP_
+#ifndef KERNEL_SRC_HAL_BOOT_ARGS_HPP_
+#define KERNEL_SRC_HAL_BOOT_ARGS_HPP_
 
 #include <hal/impl/kernel.hpp>
 
@@ -10,4 +10,4 @@ using arch::RawBootArguments;
 WRAP_CALL void ArchInit(const RawBootArguments &args) { arch::ArchInit(args); }
 }  // namespace hal
 
-#endif  // ALKOS_KERNEL_INCLUDE_HAL_BOOT_ARGS_HPP_
+#endif  // KERNEL_SRC_HAL_BOOT_ARGS_HPP_
diff --git a/kernel/src/hal/core.hpp b/kernel/src/hal/core.hpp
index c0b9cd6f..12b608d7 100644
--- a/kernel/src/hal/core.hpp
+++ b/kernel/src/hal/core.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_KERNEL_INCLUDE_HAL_CORE_HPP_
-#define ALKOS_KERNEL_INCLUDE_HAL_CORE_HPP_
+#ifndef KERNEL_SRC_HAL_CORE_HPP_
+#define KERNEL_SRC_HAL_CORE_HPP_
 
 #include <hal/impl/core.hpp>
 
@@ -13,4 +13,4 @@ WRAP_CALL void SetCoreLocalData(void *data) { arch::SetCoreLocalData(data); }
 NODISCARD WRAP_CALL void *GetCoreLocalData() { return arch::GetCoreLocalData(); }
 }  // namespace hal
 
-#endif  // ALKOS_KERNEL_INCLUDE_HAL_CORE_HPP_
+#endif  // KERNEL_SRC_HAL_CORE_HPP_
diff --git a/kernel/src/hal/debug_terminal.hpp b/kernel/src/hal/debug_terminal.hpp
index b76cc83b..faaf6494 100644
--- a/kernel/src/hal/debug_terminal.hpp
+++ b/kernel/src/hal/debug_terminal.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_KERNEL_INCLUDE_HAL_DEBUG_TERMINAL_HPP_
-#define ALKOS_KERNEL_INCLUDE_HAL_DEBUG_TERMINAL_HPP_
+#ifndef KERNEL_SRC_HAL_DEBUG_TERMINAL_HPP_
+#define KERNEL_SRC_HAL_DEBUG_TERMINAL_HPP_
 
 #include <hal/impl/debug_terminal.hpp>
 
@@ -31,4 +31,4 @@ WRAP_CALL size_t DebugTerminalReadLine(char *const buffer, const size_t buffer_s
 
 }  // namespace hal
 
-#endif  // ALKOS_KERNEL_INCLUDE_HAL_DEBUG_TERMINAL_HPP_
+#endif  // KERNEL_SRC_HAL_DEBUG_TERMINAL_HPP_
diff --git a/kernel/src/hal/interrupt_params.hpp b/kernel/src/hal/interrupt_params.hpp
index 52408db1..48b020ca 100644
--- a/kernel/src/hal/interrupt_params.hpp
+++ b/kernel/src/hal/interrupt_params.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_KERNEL_INCLUDE_HAL_INTERRUPT_PARAMS_HPP_
-#define ALKOS_KERNEL_INCLUDE_HAL_INTERRUPT_PARAMS_HPP_
+#ifndef KERNEL_SRC_HAL_INTERRUPT_PARAMS_HPP_
+#define KERNEL_SRC_HAL_INTERRUPT_PARAMS_HPP_
 
 #include <hal/impl/interrupt_params.hpp>
 
@@ -17,4 +17,4 @@ static constexpr u16 kPageFaultExcLirq = arch::kPageFaultExcLirq;
 
 }  // namespace hal
 
-#endif  // ALKOS_KERNEL_INCLUDE_HAL_INTERRUPT_PARAMS_HPP_
+#endif  // KERNEL_SRC_HAL_INTERRUPT_PARAMS_HPP_
diff --git a/kernel/src/hal/interrupts.hpp b/kernel/src/hal/interrupts.hpp
index 3b0af198..b49445e2 100644
--- a/kernel/src/hal/interrupts.hpp
+++ b/kernel/src/hal/interrupts.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_KERNEL_INCLUDE_HAL_INTERRUPTS_HPP_
-#define ALKOS_KERNEL_INCLUDE_HAL_INTERRUPTS_HPP_
+#ifndef KERNEL_SRC_HAL_INTERRUPTS_HPP_
+#define KERNEL_SRC_HAL_INTERRUPTS_HPP_
 
 #include <hal/impl/interrupts.hpp>
 
@@ -9,4 +9,4 @@ using arch::Interrupts;
 static constexpr size_t kMaxInterruptsSupported = arch::kMaxInterruptsSupported;
 }  // namespace hal
 
-#endif  // ALKOS_KERNEL_INCLUDE_HAL_INTERRUPTS_HPP_
+#endif  // KERNEL_SRC_HAL_INTERRUPTS_HPP_
diff --git a/kernel/src/hal/intr_parser.hpp b/kernel/src/hal/intr_parser.hpp
index 2c8bfe5c..292181f3 100644
--- a/kernel/src/hal/intr_parser.hpp
+++ b/kernel/src/hal/intr_parser.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_KERNEL_INCLUDE_HAL_INTR_PARSER_HPP_
-#define ALKOS_KERNEL_INCLUDE_HAL_INTR_PARSER_HPP_
+#ifndef KERNEL_SRC_HAL_INTR_PARSER_HPP_
+#define KERNEL_SRC_HAL_INTR_PARSER_HPP_
 
 #include "hal/impl/intr_parser.hpp"
 
@@ -10,4 +10,4 @@ using arch::ParsePageFaultData;
 
 }  // namespace hal
 
-#endif  // ALKOS_KERNEL_INCLUDE_HAL_INTR_PARSER_HPP_
+#endif  // KERNEL_SRC_HAL_INTR_PARSER_HPP_
diff --git a/kernel/src/hal/panic.hpp b/kernel/src/hal/panic.hpp
index 2a0352a3..5d052de1 100644
--- a/kernel/src/hal/panic.hpp
+++ b/kernel/src/hal/panic.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_KERNEL_INCLUDE_HAL_PANIC_HPP_
-#define ALKOS_KERNEL_INCLUDE_HAL_PANIC_HPP_
+#ifndef KERNEL_SRC_HAL_PANIC_HPP_
+#define KERNEL_SRC_HAL_PANIC_HPP_
 
 #include <hal/impl/panic.hpp>
 #include "trace_framework.hpp"
@@ -35,4 +35,4 @@ FAST_CALL NO_RET void KernelPanicFormat(const char *fmt, Args... args)
 
 }  // namespace hal
 
-#endif  // ALKOS_KERNEL_INCLUDE_HAL_PANIC_HPP_
+#endif  // KERNEL_SRC_HAL_PANIC_HPP_
diff --git a/kernel/src/hal/qemu.hpp b/kernel/src/hal/qemu.hpp
index 6ea6449d..a7872544 100644
--- a/kernel/src/hal/qemu.hpp
+++ b/kernel/src/hal/qemu.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_KERNEL_INCLUDE_HAL_QEMU_HPP_
-#define ALKOS_KERNEL_INCLUDE_HAL_QEMU_HPP_
+#ifndef KERNEL_SRC_HAL_QEMU_HPP_
+#define KERNEL_SRC_HAL_QEMU_HPP_
 
 #include <hal/impl/qemu.hpp>
 
@@ -10,4 +10,4 @@ namespace hal
 WRAP_CALL void QemuShutdown() { arch::QemuShutdown(); }
 }  // namespace hal
 
-#endif  // ALKOS_KERNEL_INCLUDE_HAL_QEMU_HPP_
+#endif  // KERNEL_SRC_HAL_QEMU_HPP_
diff --git a/kernel/src/hal/spinlock.hpp b/kernel/src/hal/spinlock.hpp
index 2867a2ea..bc600b9a 100644
--- a/kernel/src/hal/spinlock.hpp
+++ b/kernel/src/hal/spinlock.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_KERNEL_INCLUDE_HAL_SPINLOCK_HPP_
-#define ALKOS_KERNEL_INCLUDE_HAL_SPINLOCK_HPP_
+#ifndef KERNEL_SRC_HAL_SPINLOCK_HPP_
+#define KERNEL_SRC_HAL_SPINLOCK_HPP_
 
 #include <hal/impl/spinlock.hpp>
 
@@ -8,4 +8,4 @@ namespace hal
 using arch::Spinlock;
 }
 
-#endif  // ALKOS_KERNEL_INCLUDE_HAL_SPINLOCK_HPP_
+#endif  // KERNEL_SRC_HAL_SPINLOCK_HPP_
diff --git a/kernel/src/hal/sync.hpp b/kernel/src/hal/sync.hpp
index e6392b2f..6e7f5e82 100644
--- a/kernel/src/hal/sync.hpp
+++ b/kernel/src/hal/sync.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_KERNEL_INCLUDE_HAL_SYNC_HPP_
-#define ALKOS_KERNEL_INCLUDE_HAL_SYNC_HPP_
+#ifndef KERNEL_SRC_HAL_SYNC_HPP_
+#define KERNEL_SRC_HAL_SYNC_HPP_
 
 #include <hal/impl/sync.hpp>
 
@@ -62,4 +62,4 @@ WRAP_CALL typename T::BaseT AtomicDecrement(volatile T *ptr)
 
 }  // namespace hal
 
-#endif  // ALKOS_KERNEL_INCLUDE_HAL_SYNC_HPP_
+#endif  // KERNEL_SRC_HAL_SYNC_HPP_
diff --git a/kernel/src/hal/terminal.hpp b/kernel/src/hal/terminal.hpp
index d58d12a3..63f6e2ce 100644
--- a/kernel/src/hal/terminal.hpp
+++ b/kernel/src/hal/terminal.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_KERNEL_INCLUDE_HAL_TERMINAL_HPP_
-#define ALKOS_KERNEL_INCLUDE_HAL_TERMINAL_HPP_
+#ifndef KERNEL_SRC_HAL_TERMINAL_HPP_
+#define KERNEL_SRC_HAL_TERMINAL_HPP_
 
 #include <hal/impl/terminal.hpp>
 
@@ -52,4 +52,4 @@ WRAP_CALL size_t TerminalReadLine(char *buffer, size_t size)
 }
 }  // namespace hal
 
-#endif  // ALKOS_KERNEL_INCLUDE_HAL_TERMINAL_HPP_
+#endif  // KERNEL_SRC_HAL_TERMINAL_HPP_
diff --git a/kernel/src/hal/timers.hpp b/kernel/src/hal/timers.hpp
index 34fd3052..aff45980 100644
--- a/kernel/src/hal/timers.hpp
+++ b/kernel/src/hal/timers.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_KERNEL_INCLUDE_HAL_TIMERS_HPP_
-#define ALKOS_KERNEL_INCLUDE_HAL_TIMERS_HPP_
+#ifndef KERNEL_SRC_HAL_TIMERS_HPP_
+#define KERNEL_SRC_HAL_TIMERS_HPP_
 
 #include <hal/impl/timers.hpp>
 
@@ -21,4 +21,4 @@ WRAP_CALL time_t QuerySystemTime(const timezone &tz) { return arch::QuerySystemT
 WRAP_CALL void PickSystemClockSource() { return arch::PickSystemClockSource(); }
 }  // namespace hal
 
-#endif  // ALKOS_KERNEL_INCLUDE_HAL_TIMERS_HPP_
+#endif  // KERNEL_SRC_HAL_TIMERS_HPP_
diff --git a/kernel/src/hardware/core_controller.hpp b/kernel/src/hardware/core_controller.hpp
index e4906c93..ac9b1ab7 100644
--- a/kernel/src/hardware/core_controller.hpp
+++ b/kernel/src/hardware/core_controller.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_KERNEL_INCLUDE_HARDWARE_CORE_CONTROLLER_HPP_
-#define ALKOS_KERNEL_INCLUDE_HARDWARE_CORE_CONTROLLER_HPP_
+#ifndef KERNEL_SRC_HARDWARE_CORE_CONTROLLER_HPP_
+#define KERNEL_SRC_HARDWARE_CORE_CONTROLLER_HPP_
 
 #include "hardware/core_local.hpp"
 #include "hardware/cores.hpp"
@@ -71,4 +71,4 @@ class CoresController final
 
 }  // namespace hardware
 
-#endif  // ALKOS_KERNEL_INCLUDE_HARDWARE_CORE_CONTROLLER_HPP_
+#endif  // KERNEL_SRC_HARDWARE_CORE_CONTROLLER_HPP_
diff --git a/kernel/src/hardware/core_local.hpp b/kernel/src/hardware/core_local.hpp
index f09d8171..7e8f7368 100644
--- a/kernel/src/hardware/core_local.hpp
+++ b/kernel/src/hardware/core_local.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_KERNEL_INCLUDE_HARDWARE_CORE_LOCAL_HPP_
-#define ALKOS_KERNEL_INCLUDE_HARDWARE_CORE_LOCAL_HPP_
+#ifndef KERNEL_SRC_HARDWARE_CORE_LOCAL_HPP_
+#define KERNEL_SRC_HARDWARE_CORE_LOCAL_HPP_
 
 #include "hal/constants.hpp"
 #include "hal/core.hpp"
@@ -17,4 +17,4 @@ FAST_CALL CoreLocal &GetCoreLocalData()
 }
 }  // namespace hardware
 
-#endif  // ALKOS_KERNEL_INCLUDE_HARDWARE_CORE_LOCAL_HPP_
+#endif  // KERNEL_SRC_HARDWARE_CORE_LOCAL_HPP_
diff --git a/kernel/src/hardware/interupts.hpp b/kernel/src/hardware/interupts.hpp
index 5372aea5..c062be8b 100644
--- a/kernel/src/hardware/interupts.hpp
+++ b/kernel/src/hardware/interupts.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_KERNEL_INCLUDE_HARDWARE_INTERUPTS_HPP_
-#define ALKOS_KERNEL_INCLUDE_HARDWARE_INTERUPTS_HPP_
+#ifndef KERNEL_SRC_HARDWARE_INTERUPTS_HPP_
+#define KERNEL_SRC_HARDWARE_INTERUPTS_HPP_
 
 #include <hal/interrupts.hpp>
 #include <hal/spinlock.hpp>
@@ -80,4 +80,4 @@ class Interrupts final : public arch::Interrupts
 };
 }  // namespace intr
 
-#endif  // ALKOS_KERNEL_INCLUDE_HARDWARE_INTERUPTS_HPP_
+#endif  // KERNEL_SRC_HARDWARE_INTERUPTS_HPP_
diff --git a/kernel/src/interrupts/interupts.hpp b/kernel/src/interrupts/interupts.hpp
index 4868efea..8e3ae61b 100644
--- a/kernel/src/interrupts/interupts.hpp
+++ b/kernel/src/interrupts/interupts.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_KERNEL_INCLUDE_INTERRUPTS_INTERUPTS_HPP_
-#define ALKOS_KERNEL_INCLUDE_INTERRUPTS_INTERUPTS_HPP_
+#ifndef KERNEL_SRC_INTERRUPTS_INTERUPTS_HPP_
+#define KERNEL_SRC_INTERRUPTS_INTERUPTS_HPP_
 
 #include "hal/interrupts.hpp"
 #include "interrupts/logical_interrupt_table.hpp"
@@ -31,4 +31,4 @@ class Interrupts final : public arch::Interrupts
 };
 }  // namespace intr
 
-#endif  // ALKOS_KERNEL_INCLUDE_INTERRUPTS_INTERUPTS_HPP_
+#endif  // KERNEL_SRC_INTERRUPTS_INTERUPTS_HPP_
diff --git a/kernel/src/mem/error.hpp b/kernel/src/mem/error.hpp
index 6e612f5e..746774ef 100644
--- a/kernel/src/mem/error.hpp
+++ b/kernel/src/mem/error.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_KERNEL_INCLUDE_MEM_ERROR_HPP_
-#define ALKOS_KERNEL_INCLUDE_MEM_ERROR_HPP_
+#ifndef KERNEL_SRC_MEM_ERROR_HPP_
+#define KERNEL_SRC_MEM_ERROR_HPP_
 
 namespace Mem
 {
@@ -12,4 +12,4 @@ enum class MemError {
 
 }  // namespace Mem
 
-#endif  // ALKOS_KERNEL_INCLUDE_MEM_ERROR_HPP_
+#endif  // KERNEL_SRC_MEM_ERROR_HPP_
diff --git a/kernel/src/mem/virt/page_fault.hpp b/kernel/src/mem/virt/page_fault.hpp
index 985e9d08..d97c9795 100644
--- a/kernel/src/mem/virt/page_fault.hpp
+++ b/kernel/src/mem/virt/page_fault.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_KERNEL_INCLUDE_MEM_VIRT_PAGE_FAULT_HPP_
-#define ALKOS_KERNEL_INCLUDE_MEM_VIRT_PAGE_FAULT_HPP_
+#ifndef KERNEL_SRC_MEM_VIRT_PAGE_FAULT_HPP_
+#define KERNEL_SRC_MEM_VIRT_PAGE_FAULT_HPP_
 
 #include "hal/interrupt_params.hpp"
 #include "interrupts/interrupt_types.hpp"
@@ -11,4 +11,4 @@ void PageFaultHandler(intr::LitExcEntry &entry, hal::ExceptionData *data);
 
 }  // namespace Mem
 
-#endif  // ALKOS_KERNEL_INCLUDE_MEM_VIRT_PAGE_FAULT_HPP_
+#endif  // KERNEL_SRC_MEM_VIRT_PAGE_FAULT_HPP_
diff --git a/kernel/src/mem/virt/page_fault_data.hpp b/kernel/src/mem/virt/page_fault_data.hpp
index a870da81..8b047b0b 100644
--- a/kernel/src/mem/virt/page_fault_data.hpp
+++ b/kernel/src/mem/virt/page_fault_data.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_KERNEL_INCLUDE_MEM_VIRT_PAGE_FAULT_DATA_HPP_
-#define ALKOS_KERNEL_INCLUDE_MEM_VIRT_PAGE_FAULT_DATA_HPP_
+#ifndef KERNEL_SRC_MEM_VIRT_PAGE_FAULT_DATA_HPP_
+#define KERNEL_SRC_MEM_VIRT_PAGE_FAULT_DATA_HPP_
 
 #include "mem/types.hpp"
 
@@ -32,4 +32,4 @@ struct PageFaultData {
 
 }  // namespace Mem
 
-#endif  // ALKOS_KERNEL_INCLUDE_MEM_VIRT_PAGE_FAULT_DATA_HPP_
+#endif  // KERNEL_SRC_MEM_VIRT_PAGE_FAULT_DATA_HPP_
diff --git a/kernel/src/modules/helpers.hpp b/kernel/src/modules/helpers.hpp
index f08fc746..ac51b851 100644
--- a/kernel/src/modules/helpers.hpp
+++ b/kernel/src/modules/helpers.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_KERNEL_INCLUDE_MODULES_HELPERS_HPP_
-#define ALKOS_KERNEL_INCLUDE_MODULES_HELPERS_HPP_
+#ifndef KERNEL_SRC_MODULES_HELPERS_HPP_
+#define KERNEL_SRC_MODULES_HELPERS_HPP_
 
 #define DEFINE_MODULE_FIELD(name_space, type) \
                                               \
@@ -9,4 +9,4 @@
     public:                                   \
     NODISCARD FORCE_INLINE_F auto &Get##type() noexcept { return type##_; }
 
-#endif  // ALKOS_KERNEL_INCLUDE_MODULES_HELPERS_HPP_
+#endif  // KERNEL_SRC_MODULES_HELPERS_HPP_
diff --git a/kernel/src/modules/timing_constants.hpp b/kernel/src/modules/timing_constants.hpp
index 573e2d47..a3c75fc4 100644
--- a/kernel/src/modules/timing_constants.hpp
+++ b/kernel/src/modules/timing_constants.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_KERNEL_INCLUDE_MODULES_TIMING_CONSTANTS_HPP_
-#define ALKOS_KERNEL_INCLUDE_MODULES_TIMING_CONSTANTS_HPP_
+#ifndef KERNEL_SRC_MODULES_TIMING_CONSTANTS_HPP_
+#define KERNEL_SRC_MODULES_TIMING_CONSTANTS_HPP_
 
 #include <sys/time.h>
 
@@ -16,4 +16,4 @@ static_assert(kClockTicksInSecondSize == static_cast<size_t>(ClockType::kLastClo
 
 }  // namespace timing_constants
 
-#endif  // ALKOS_KERNEL_INCLUDE_MODULES_TIMING_CONSTANTS_HPP_
+#endif  // KERNEL_SRC_MODULES_TIMING_CONSTANTS_HPP_
diff --git a/kernel/src/sync/kernel/spinlock.hpp b/kernel/src/sync/kernel/spinlock.hpp
index 2961d8c3..45018259 100644
--- a/kernel/src/sync/kernel/spinlock.hpp
+++ b/kernel/src/sync/kernel/spinlock.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_KERNEL_INCLUDE_SYNC_KERNEL_SPINLOCK_HPP_
-#define ALKOS_KERNEL_INCLUDE_SYNC_KERNEL_SPINLOCK_HPP_
+#ifndef KERNEL_SRC_SYNC_KERNEL_SPINLOCK_HPP_
+#define KERNEL_SRC_SYNC_KERNEL_SPINLOCK_HPP_
 
 #include <hal/spinlock.hpp>
 
@@ -12,4 +12,4 @@ struct Spinlock : arch::Spinlock {
     FORCE_INLINE_F void unlock() { hal::Spinlock::Unlock(); }
 };
 
-#endif  // ALKOS_KERNEL_INCLUDE_SYNC_KERNEL_SPINLOCK_HPP_
+#endif  // KERNEL_SRC_SYNC_KERNEL_SPINLOCK_HPP_
diff --git a/kernel/src/todo.hpp b/kernel/src/todo.hpp
index 4b2b6800..522c7449 100644
--- a/kernel/src/todo.hpp
+++ b/kernel/src/todo.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_KERNEL_INCLUDE_TODO_HPP_
-#define ALKOS_KERNEL_INCLUDE_TODO_HPP_
+#ifndef KERNEL_SRC_TODO_HPP_
+#define KERNEL_SRC_TODO_HPP_
 
 /**
  * @brief This file's purpose is to define a set of macros used as placeholders
@@ -32,4 +32,4 @@
 
 #define TODO_WHEN_CPP_REFLECTION
 
-#endif  // ALKOS_KERNEL_INCLUDE_TODO_HPP_
+#endif  // KERNEL_SRC_TODO_HPP_
diff --git a/kernel/test/test_module/expect.hpp b/kernel/test/test_module/expect.hpp
index 55e90348..74684a41 100644
--- a/kernel/test/test_module/expect.hpp
+++ b/kernel/test/test_module/expect.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_KERNEL_TEST_TEST_MODULE_EXPECT_HPP_
-#define ALKOS_KERNEL_TEST_TEST_MODULE_EXPECT_HPP_
+#ifndef KERNEL_TEST_TEST_MODULE_EXPECT_HPP_
+#define KERNEL_TEST_TEST_MODULE_EXPECT_HPP_
 
 #include <assert.h>
 #include <hal/terminal.hpp>
@@ -44,4 +44,4 @@ inline void ExpectHandler(const char *msg)
 #define EXPECT_STRNEQ(val1, val2, ...) \
     BASE_ASSERT_STRNEQ(true, val1, val2, ExpectHandler __VA_OPT__(, ) __VA_ARGS__)
 
-#endif  // ALKOS_KERNEL_TEST_TEST_MODULE_EXPECT_HPP_
+#endif  // KERNEL_TEST_TEST_MODULE_EXPECT_HPP_
diff --git a/kernel/test/test_module/test.hpp b/kernel/test/test_module/test.hpp
index 849810db..b65b48bb 100644
--- a/kernel/test/test_module/test.hpp
+++ b/kernel/test/test_module/test.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_KERNEL_TEST_TEST_MODULE_TEST_HPP_
-#define ALKOS_KERNEL_TEST_TEST_MODULE_TEST_HPP_
+#ifndef KERNEL_TEST_TEST_MODULE_TEST_HPP_
+#define KERNEL_TEST_TEST_MODULE_TEST_HPP_
 
 #include <assert.h>
 #include <hal/debug_terminal.hpp>
@@ -8,4 +8,4 @@
 #include <test_module/test_group_base.hpp>
 #include "trace_framework.hpp"
 
-#endif  // ALKOS_KERNEL_TEST_TEST_MODULE_TEST_HPP_
+#endif  // KERNEL_TEST_TEST_MODULE_TEST_HPP_
diff --git a/kernel/test/test_module/test_group_base.hpp b/kernel/test/test_module/test_group_base.hpp
index 10003b40..b6876111 100644
--- a/kernel/test/test_module/test_group_base.hpp
+++ b/kernel/test/test_module/test_group_base.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_KERNEL_TEST_TEST_MODULE_TEST_GROUP_BASE_HPP_
-#define ALKOS_KERNEL_TEST_TEST_MODULE_TEST_GROUP_BASE_HPP_
+#ifndef KERNEL_TEST_TEST_MODULE_TEST_GROUP_BASE_HPP_
+#define KERNEL_TEST_TEST_MODULE_TEST_GROUP_BASE_HPP_
 
 namespace test
 {
@@ -42,4 +42,4 @@ class TestGroupBase
 
 }  // namespace test
 
-#endif  // ALKOS_KERNEL_TEST_TEST_MODULE_TEST_GROUP_BASE_HPP_
+#endif  // KERNEL_TEST_TEST_MODULE_TEST_GROUP_BASE_HPP_
diff --git a/kernel/test/test_structs.hpp b/kernel/test/test_structs.hpp
index 9662e570..c7e8d4c2 100644
--- a/kernel/test/test_structs.hpp
+++ b/kernel/test/test_structs.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_KERNEL_TEST_TEST_STRUCTS_HPP_
-#define ALKOS_KERNEL_TEST_TEST_STRUCTS_HPP_
+#ifndef KERNEL_TEST_TEST_STRUCTS_HPP_
+#define KERNEL_TEST_TEST_STRUCTS_HPP_
 
 class MoveOnlyInt
 {
@@ -87,4 +87,4 @@ struct ComplexType {
     }
 };
 
-#endif  // ALKOS_KERNEL_TEST_TEST_STRUCTS_HPP_
+#endif  // KERNEL_TEST_TEST_STRUCTS_HPP_
diff --git a/kernel/thirdparty/uacpi/uacpi_libc.h b/kernel/thirdparty/uacpi/uacpi_libc.h
index ca6181b2..3c6ae287 100644
--- a/kernel/thirdparty/uacpi/uacpi_libc.h
+++ b/kernel/thirdparty/uacpi/uacpi_libc.h
@@ -1,5 +1,5 @@
-#ifndef ALKOS_KERNEL_THIRDPARTY_UACPI_UACPI_LIBC_H_
-#define ALKOS_KERNEL_THIRDPARTY_UACPI_UACPI_LIBC_H_
+#ifndef KERNEL_THIRDPARTY_UACPI_UACPI_LIBC_H_
+#define KERNEL_THIRDPARTY_UACPI_UACPI_LIBC_H_
 
 #include <stdio.h>
 #include <string.h>
@@ -14,4 +14,4 @@
 #define uacpi_snprintf  snprintf
 #define uacpi_vsnprintf vsnprintf
 
-#endif  // ALKOS_KERNEL_THIRDPARTY_UACPI_UACPI_LIBC_H_
+#endif  // KERNEL_THIRDPARTY_UACPI_UACPI_LIBC_H_
diff --git a/libs/libc/include/errno.h b/libs/libc/include/errno.h
index 07778470..eb2a7e03 100644
--- a/libs/libc/include/errno.h
+++ b/libs/libc/include/errno.h
@@ -1,5 +1,5 @@
-#ifndef ALKOS_LIBC_INCLUDE_ERRNO_H_
-#define ALKOS_LIBC_INCLUDE_ERRNO_H_
+#ifndef LIBS_LIBC_INCLUDE_ERRNO_H_
+#define LIBS_LIBC_INCLUDE_ERRNO_H_
 
 #include <defines.h>
 #include <todo.h>
@@ -120,4 +120,4 @@ END_DECL_C
 #define EWOULDBLOCK     EAGAIN        /* Operation would block */
 #define EXDEV           __cast_er(79) /* Cross-device link */
 
-#endif  // ALKOS_LIBC_INCLUDE_ERRNO_H_
+#endif  // LIBS_LIBC_INCLUDE_ERRNO_H_
diff --git a/libs/libc/include/libssp.h b/libs/libc/include/libssp.h
index 6b341e61..85d77c49 100644
--- a/libs/libc/include/libssp.h
+++ b/libs/libc/include/libssp.h
@@ -1,5 +1,5 @@
-#ifndef ALKOS_LIBC_INCLUDE_LIBSSP_H_
-#define ALKOS_LIBC_INCLUDE_LIBSSP_H_
+#ifndef LIBS_LIBC_INCLUDE_LIBSSP_H_
+#define LIBS_LIBC_INCLUDE_LIBSSP_H_
 
 #include <defines.h>
 
@@ -7,4 +7,4 @@ BEGIN_DECL_C
 void __stack_chk_init();
 END_DECL_C
 
-#endif  // ALKOS_LIBC_INCLUDE_LIBSSP_H_
+#endif  // LIBS_LIBC_INCLUDE_LIBSSP_H_
diff --git a/libs/libc/include/math/checks.h b/libs/libc/include/math/checks.h
index 97bdaadd..061c8840 100644
--- a/libs/libc/include/math/checks.h
+++ b/libs/libc/include/math/checks.h
@@ -1,5 +1,5 @@
-#ifndef ALKOS_LIBC_INCLUDE_MATH_CHECKS_H_
-#define ALKOS_LIBC_INCLUDE_MATH_CHECKS_H_
+#ifndef LIBS_LIBC_INCLUDE_MATH_CHECKS_H_
+#define LIBS_LIBC_INCLUDE_MATH_CHECKS_H_
 
 #include <defines.h>
 #include <stdint.h>
@@ -20,4 +20,4 @@ CONSTEXPR int isinf(const double num)
 
 END_DECL_C
 
-#endif  // ALKOS_LIBC_INCLUDE_MATH_CHECKS_H_
+#endif  // LIBS_LIBC_INCLUDE_MATH_CHECKS_H_
diff --git a/libs/libc/include/math/operations.hpp b/libs/libc/include/math/operations.hpp
index c718f6ad..41172b80 100644
--- a/libs/libc/include/math/operations.hpp
+++ b/libs/libc/include/math/operations.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_LIBC_INCLUDE_MATH_OPERATIONS_HPP_
-#define ALKOS_LIBC_INCLUDE_MATH_OPERATIONS_HPP_
+#ifndef LIBS_LIBC_INCLUDE_MATH_OPERATIONS_HPP_
+#define LIBS_LIBC_INCLUDE_MATH_OPERATIONS_HPP_
 
 #include <defines.h>
 #include <stdint.h>
@@ -16,4 +16,4 @@ CONSTEXPR double fabs(const double num)
 
 END_DECL_C
 
-#endif  // ALKOS_LIBC_INCLUDE_MATH_OPERATIONS_HPP_
+#endif  // LIBS_LIBC_INCLUDE_MATH_OPERATIONS_HPP_
diff --git a/libs/libc/include/stdio.h b/libs/libc/include/stdio.h
index 1f2e94a3..c4d8c953 100644
--- a/libs/libc/include/stdio.h
+++ b/libs/libc/include/stdio.h
@@ -1,5 +1,5 @@
-#ifndef ALKOS_LIBC_INCLUDE_STDIO_H_
-#define ALKOS_LIBC_INCLUDE_STDIO_H_
+#ifndef LIBS_LIBC_INCLUDE_STDIO_H_
+#define LIBS_LIBC_INCLUDE_STDIO_H_
 
 #include <defines.h>
 #include <stdarg.h>
@@ -18,4 +18,4 @@ int vsnprintf(char *str, size_t size, const char *format, va_list va);
 
 END_DECL_C
 
-#endif  // ALKOS_LIBC_INCLUDE_STDIO_H_
+#endif  // LIBS_LIBC_INCLUDE_STDIO_H_
diff --git a/libs/libc/include/stdlib.h b/libs/libc/include/stdlib.h
index a2e6fbf8..484675fb 100644
--- a/libs/libc/include/stdlib.h
+++ b/libs/libc/include/stdlib.h
@@ -1,5 +1,5 @@
-#ifndef ALKOS_LIBC_INCLUDE_STDLIB_H_
-#define ALKOS_LIBC_INCLUDE_STDLIB_H_
+#ifndef LIBS_LIBC_INCLUDE_STDLIB_H_
+#define LIBS_LIBC_INCLUDE_STDLIB_H_
 
 #include <defines.h>
 #include <stddef.h>
@@ -16,4 +16,4 @@ CONSTEXPR intmax_t imaxabs(const intmax_t n) { return n < 0 ? -n : n; }
 
 END_DECL_C
 
-#endif  // ALKOS_LIBC_INCLUDE_STDLIB_H_
+#endif  // LIBS_LIBC_INCLUDE_STDLIB_H_
diff --git a/libs/libc/include/string.h b/libs/libc/include/string.h
index 190cb314..07ff09b9 100644
--- a/libs/libc/include/string.h
+++ b/libs/libc/include/string.h
@@ -1,5 +1,5 @@
-#ifndef ALKOS_LIBC_INCLUDE_STRING_H_
-#define ALKOS_LIBC_INCLUDE_STRING_H_
+#ifndef LIBS_LIBC_INCLUDE_STRING_H_
+#define LIBS_LIBC_INCLUDE_STRING_H_
 
 #include <defines.h>
 #include <stddef.h>
@@ -110,4 +110,4 @@ int memcmp(const void *s1, const void *s2, size_t n);
 
 END_DECL_C
 
-#endif  // ALKOS_LIBC_INCLUDE_STRING_H_
+#endif  // LIBS_LIBC_INCLUDE_STRING_H_
diff --git a/libs/libc/include/sys/calls.h b/libs/libc/include/sys/calls.h
index 6d45a3c9..1c4285ff 100644
--- a/libs/libc/include/sys/calls.h
+++ b/libs/libc/include/sys/calls.h
@@ -1,5 +1,5 @@
-#ifndef ALKOS_LIBC_INCLUDE_SYS_CALLS_H_
-#define ALKOS_LIBC_INCLUDE_SYS_CALLS_H_
+#ifndef LIBS_LIBC_INCLUDE_SYS_CALLS_H_
+#define LIBS_LIBC_INCLUDE_SYS_CALLS_H_
 
 /**
  * @brief This file collects all the system calls that are used by the libc.
@@ -9,4 +9,4 @@
 
 #include <sys/calls/time.h>
 
-#endif  // ALKOS_LIBC_INCLUDE_SYS_CALLS_H_
+#endif  // LIBS_LIBC_INCLUDE_SYS_CALLS_H_
diff --git a/libs/libc/include/time.h b/libs/libc/include/time.h
index 51aa0fcb..342603a0 100644
--- a/libs/libc/include/time.h
+++ b/libs/libc/include/time.h
@@ -1,5 +1,5 @@
-#ifndef ALKOS_LIBC_INCLUDE_TIME_H_
-#define ALKOS_LIBC_INCLUDE_TIME_H_
+#ifndef LIBS_LIBC_INCLUDE_TIME_H_
+#define LIBS_LIBC_INCLUDE_TIME_H_
 
 /* external includes */
 #include <errno.h>
@@ -94,4 +94,4 @@ time_t mktime(struct tm *time_ptr);
 
 END_DECL_C
 
-#endif  // ALKOS_LIBC_INCLUDE_TIME_H_
+#endif  // LIBS_LIBC_INCLUDE_TIME_H_
diff --git a/libs/libc/include/todo.h b/libs/libc/include/todo.h
index c21662da..4a1bd829 100644
--- a/libs/libc/include/todo.h
+++ b/libs/libc/include/todo.h
@@ -1,5 +1,5 @@
-#ifndef ALKOS_LIBC_INCLUDE_TODO_H_
-#define ALKOS_LIBC_INCLUDE_TODO_H_
+#ifndef LIBS_LIBC_INCLUDE_TODO_H_
+#define LIBS_LIBC_INCLUDE_TODO_H_
 
 /* Should be adjusted when userspace version of libc is implemented */
 #define TODO_USERSPACE
@@ -33,4 +33,4 @@
 
 #define TODO_RANDOM
 
-#endif  // ALKOS_LIBC_INCLUDE_TODO_H_
+#endif  // LIBS_LIBC_INCLUDE_TODO_H_
diff --git a/libs/libc/include/types.h b/libs/libc/include/types.h
index 03e88b0a..9fe5b43d 100644
--- a/libs/libc/include/types.h
+++ b/libs/libc/include/types.h
@@ -1,5 +1,5 @@
-#ifndef ALKOS_LIBC_INCLUDE_TYPES_H_
-#define ALKOS_LIBC_INCLUDE_TYPES_H_
+#ifndef LIBS_LIBC_INCLUDE_TYPES_H_
+#define LIBS_LIBC_INCLUDE_TYPES_H_
 
 #include <limits.h>
 #include <stdint.h>
@@ -38,4 +38,4 @@ typedef unsigned char uptrdiff_t;
 
 typedef size_t rsize_t;
 
-#endif  // ALKOS_LIBC_INCLUDE_TYPES_H_
+#endif  // LIBS_LIBC_INCLUDE_TYPES_H_
diff --git a/libs/libc/internal/time_internal.hpp b/libs/libc/internal/time_internal.hpp
index d7f5e6aa..9d4d9d70 100644
--- a/libs/libc/internal/time_internal.hpp
+++ b/libs/libc/internal/time_internal.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_LIBC_INTERNAL_TIME_INTERNAL_HPP_
-#define ALKOS_LIBC_INTERNAL_TIME_INTERNAL_HPP_
+#ifndef LIBS_LIBC_INTERNAL_TIME_INTERNAL_HPP_
+#define LIBS_LIBC_INTERNAL_TIME_INTERNAL_HPP_
 
 #include <stdint.h>
 
@@ -7,4 +7,4 @@
 
 [[nodiscard]] uint64_t __GetDstTimezoneOffsetNs();
 
-#endif  // ALKOS_LIBC_INTERNAL_TIME_INTERNAL_HPP_
+#endif  // LIBS_LIBC_INTERNAL_TIME_INTERNAL_HPP_
diff --git a/libs/libcontainers/include/data_structures/data_structures.hpp b/libs/libcontainers/include/data_structures/data_structures.hpp
index b1a04171..0c031306 100644
--- a/libs/libcontainers/include/data_structures/data_structures.hpp
+++ b/libs/libcontainers/include/data_structures/data_structures.hpp
@@ -1,9 +1,9 @@
-#ifndef ALKOS_LIBC_INCLUDE_EXTENSIONS_DATA_STRUCTURES_DATA_STRUCTURES_HPP_
-#define ALKOS_LIBC_INCLUDE_EXTENSIONS_DATA_STRUCTURES_DATA_STRUCTURES_HPP_
+#ifndef LIBS_LIBCONTAINERS_INCLUDE_DATA_STRUCTURES_DATA_STRUCTURES_HPP_
+#define LIBS_LIBCONTAINERS_INCLUDE_DATA_STRUCTURES_DATA_STRUCTURES_HPP_
 
 #include <data_structures/array_structures.hpp>
 #include <data_structures/bit_array.hpp>
 #include <data_structures/events.hpp>
 #include <data_structures/hash_maps.hpp>
 
-#endif  // ALKOS_LIBC_INCLUDE_EXTENSIONS_DATA_STRUCTURES_DATA_STRUCTURES_HPP_
+#endif  // LIBS_LIBCONTAINERS_INCLUDE_DATA_STRUCTURES_DATA_STRUCTURES_HPP_
diff --git a/libs/libcontainers/include/data_structures/events.hpp b/libs/libcontainers/include/data_structures/events.hpp
index 78407c9f..f1085769 100644
--- a/libs/libcontainers/include/data_structures/events.hpp
+++ b/libs/libcontainers/include/data_structures/events.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_LIBC_INCLUDE_EXTENSIONS_DATA_STRUCTURES_EVENTS_HPP_
-#define ALKOS_LIBC_INCLUDE_EXTENSIONS_DATA_STRUCTURES_EVENTS_HPP_
+#ifndef LIBS_LIBCONTAINERS_INCLUDE_DATA_STRUCTURES_EVENTS_HPP_
+#define LIBS_LIBCONTAINERS_INCLUDE_DATA_STRUCTURES_EVENTS_HPP_
 
 #include <template_lib.hpp>
 
@@ -165,4 +165,4 @@ class Settings : public template_lib::NoCopy
 
 }  // namespace data_structures
 
-#endif  // ALKOS_LIBC_INCLUDE_EXTENSIONS_DATA_STRUCTURES_EVENTS_HPP_
+#endif  // LIBS_LIBCONTAINERS_INCLUDE_DATA_STRUCTURES_EVENTS_HPP_
diff --git a/libs/libcontainers/include/data_structures/hash_maps.hpp b/libs/libcontainers/include/data_structures/hash_maps.hpp
index 263a2bcb..abb1db61 100644
--- a/libs/libcontainers/include/data_structures/hash_maps.hpp
+++ b/libs/libcontainers/include/data_structures/hash_maps.hpp
@@ -1,5 +1,5 @@
-#ifndef LIBS_LIBCPP_INCLUDE_DATA_STRUCTURES_HASH_MAPS_HPP_
-#define LIBS_LIBCPP_INCLUDE_DATA_STRUCTURES_HASH_MAPS_HPP_
+#ifndef LIBS_LIBCONTAINERS_INCLUDE_DATA_STRUCTURES_HASH_MAPS_HPP_
+#define LIBS_LIBCONTAINERS_INCLUDE_DATA_STRUCTURES_HASH_MAPS_HPP_
 
 #include <bit.hpp>
 #include <hal/constants.hpp>  // < TODO: This should not be here. Make kCacheLineSizeBytes a template param
@@ -341,4 +341,4 @@ class Registry
 
 }  // namespace data_structures
 
-#endif  // LIBS_LIBCPP_INCLUDE_DATA_STRUCTURES_HASH_MAPS_HPP_
+#endif  // LIBS_LIBCONTAINERS_INCLUDE_DATA_STRUCTURES_HASH_MAPS_HPP_
diff --git a/libs/libcpp/include/algorithm.hpp b/libs/libcpp/include/algorithm.hpp
index 0bbfdf5a..07d1d2d7 100644
--- a/libs/libcpp/include/algorithm.hpp
+++ b/libs/libcpp/include/algorithm.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_LIBC_INCLUDE_EXTENSIONS_ALGORITHM_HPP_
-#define ALKOS_LIBC_INCLUDE_EXTENSIONS_ALGORITHM_HPP_
+#ifndef LIBS_LIBCPP_INCLUDE_ALGORITHM_HPP_
+#define LIBS_LIBCPP_INCLUDE_ALGORITHM_HPP_
 
 #include <todo.h>
 
@@ -43,4 +43,4 @@ TODO_LIBCPP_COMPLIANCE
 
 };  // namespace std
 
-#endif  // ALKOS_LIBC_INCLUDE_EXTENSIONS_ALGORITHM_HPP_
+#endif  // LIBS_LIBCPP_INCLUDE_ALGORITHM_HPP_
diff --git a/libs/libcpp/include/array.hpp b/libs/libcpp/include/array.hpp
index 6777896a..409e5b0f 100644
--- a/libs/libcpp/include/array.hpp
+++ b/libs/libcpp/include/array.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_LIBC_INCLUDE_EXTENSIONS_ARRAY_HPP_
-#define ALKOS_LIBC_INCLUDE_EXTENSIONS_ARRAY_HPP_
+#ifndef LIBS_LIBCPP_INCLUDE_ARRAY_HPP_
+#define LIBS_LIBCPP_INCLUDE_ARRAY_HPP_
 
 #include <assert.h>
 #include <string.h>
@@ -252,4 +252,4 @@ NODISCARD FORCE_INLINE_F constexpr const T &&get(const array<T, N> &&arr) noexce
 
 TODO_LIBCPP_COMPLIANCE
 
-#endif  // ALKOS_LIBC_INCLUDE_EXTENSIONS_ARRAY_HPP_
+#endif  // LIBS_LIBCPP_INCLUDE_ARRAY_HPP_
diff --git a/libs/libcpp/include/char_traits.hpp b/libs/libcpp/include/char_traits.hpp
index 5a1f76ae..212edb36 100644
--- a/libs/libcpp/include/char_traits.hpp
+++ b/libs/libcpp/include/char_traits.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_LIBC_INCLUDE_EXTENSIONS_CHAR_TRAITS_HPP_
-#define ALKOS_LIBC_INCLUDE_EXTENSIONS_CHAR_TRAITS_HPP_
+#ifndef LIBS_LIBCPP_INCLUDE_CHAR_TRAITS_HPP_
+#define LIBS_LIBCPP_INCLUDE_CHAR_TRAITS_HPP_
 
 #include <string.h>
 #include <compare.hpp>
@@ -202,4 +202,4 @@ class char_traits
 
 }  // namespace std
 
-#endif  // ALKOS_LIBC_INCLUDE_EXTENSIONS_CHAR_TRAITS_HPP_
+#endif  // LIBS_LIBCPP_INCLUDE_CHAR_TRAITS_HPP_
diff --git a/libs/libcpp/include/compare.hpp b/libs/libcpp/include/compare.hpp
index ec375dda..1ac7b6d0 100644
--- a/libs/libcpp/include/compare.hpp
+++ b/libs/libcpp/include/compare.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_LIBC_INCLUDE_EXTENSIONS_COMPARE_HPP_
-#define ALKOS_LIBC_INCLUDE_EXTENSIONS_COMPARE_HPP_
+#ifndef LIBS_LIBCPP_INCLUDE_COMPARE_HPP_
+#define LIBS_LIBCPP_INCLUDE_COMPARE_HPP_
 
 #include <defines.hpp>
 #include <types.hpp>
@@ -387,4 +387,4 @@ NODISCARD constexpr bool is_gteq(partial_ordering order) noexcept { return order
 
 }  // namespace std
 
-#endif  // ALKOS_LIBC_INCLUDE_EXTENSIONS_COMPARE_HPP_
+#endif  // LIBS_LIBCPP_INCLUDE_COMPARE_HPP_
diff --git a/libs/libcpp/include/concepts.hpp b/libs/libcpp/include/concepts.hpp
index 57dc9cf9..3999ca09 100644
--- a/libs/libcpp/include/concepts.hpp
+++ b/libs/libcpp/include/concepts.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_LIBC_INCLUDE_EXTENSIONS_CONCEPTS_HPP_
-#define ALKOS_LIBC_INCLUDE_EXTENSIONS_CONCEPTS_HPP_
+#ifndef LIBS_LIBCPP_INCLUDE_CONCEPTS_HPP_
+#define LIBS_LIBCPP_INCLUDE_CONCEPTS_HPP_
 
 #include <type_traits.hpp>
 #include "utility.hpp"
@@ -28,4 +28,4 @@ concept floating_point = is_floating_point_v<T>;
 
 }  // namespace std
 
-#endif  // ALKOS_LIBC_INCLUDE_EXTENSIONS_CONCEPTS_HPP_
+#endif  // LIBS_LIBCPP_INCLUDE_CONCEPTS_HPP_
diff --git a/libs/libcpp/include/concepts_ext.hpp b/libs/libcpp/include/concepts_ext.hpp
index f3871138..3e5974b7 100644
--- a/libs/libcpp/include/concepts_ext.hpp
+++ b/libs/libcpp/include/concepts_ext.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_LIBC_INCLUDE_EXTENSIONS_CONCEPTS_EXT_HPP_
-#define ALKOS_LIBC_INCLUDE_EXTENSIONS_CONCEPTS_EXT_HPP_
+#ifndef LIBS_LIBCPP_INCLUDE_CONCEPTS_EXT_HPP_
+#define LIBS_LIBCPP_INCLUDE_CONCEPTS_EXT_HPP_
 
 #include <concepts.hpp>
 
@@ -33,4 +33,4 @@ concept LibCxxCompatibleMutex = requires(T m) {
 };
 }  // namespace concepts_ext
 
-#endif  // ALKOS_LIBC_INCLUDE_EXTENSIONS_CONCEPTS_EXT_HPP_
+#endif  // LIBS_LIBCPP_INCLUDE_CONCEPTS_EXT_HPP_
diff --git a/libs/libcpp/include/cstddef.hpp b/libs/libcpp/include/cstddef.hpp
index d15d82e9..9d4f5407 100644
--- a/libs/libcpp/include/cstddef.hpp
+++ b/libs/libcpp/include/cstddef.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_LIBC_INCLUDE_EXTENSIONS_CSTDDEF_HPP_
-#define ALKOS_LIBC_INCLUDE_EXTENSIONS_CSTDDEF_HPP_
+#ifndef LIBS_LIBCPP_INCLUDE_CSTDDEF_HPP_
+#define LIBS_LIBCPP_INCLUDE_CSTDDEF_HPP_
 
 #include <stddef.h>
 
@@ -11,4 +11,4 @@ using ptrdiff_t   = ::ptrdiff_t;
 using max_align_t = ::max_align_t;
 }  // namespace std
 
-#endif  // ALKOS_LIBC_INCLUDE_EXTENSIONS_CSTDDEF_HPP_
+#endif  // LIBS_LIBCPP_INCLUDE_CSTDDEF_HPP_
diff --git a/libs/libcpp/include/defines.hpp b/libs/libcpp/include/defines.hpp
index 69ad21c5..a853bfc8 100644
--- a/libs/libcpp/include/defines.hpp
+++ b/libs/libcpp/include/defines.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_LIBC_INCLUDE_EXTENSIONS_DEFINES_HPP_
-#define ALKOS_LIBC_INCLUDE_EXTENSIONS_DEFINES_HPP_
+#ifndef LIBS_LIBCPP_INCLUDE_DEFINES_HPP_
+#define LIBS_LIBCPP_INCLUDE_DEFINES_HPP_
 
 #include <defines.h>
 #include <stddef.h>
@@ -136,4 +136,4 @@ struct empty_t {
 
 #define UNIQUE_EMPTY empty_t<__COUNTER__>
 
-#endif  // ALKOS_LIBC_INCLUDE_EXTENSIONS_DEFINES_HPP_
+#endif  // LIBS_LIBCPP_INCLUDE_DEFINES_HPP_
diff --git a/libs/libcpp/include/expected.hpp b/libs/libcpp/include/expected.hpp
index 00ffd8d3..5cd4e07b 100644
--- a/libs/libcpp/include/expected.hpp
+++ b/libs/libcpp/include/expected.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_LIBC_INCLUDE_EXTENSIONS_EXPECTED_HPP_
-#define ALKOS_LIBC_INCLUDE_EXTENSIONS_EXPECTED_HPP_
+#ifndef LIBS_LIBCPP_INCLUDE_EXPECTED_HPP_
+#define LIBS_LIBCPP_INCLUDE_EXPECTED_HPP_
 
 #include "assert.h"
 #include "concepts.hpp"
@@ -1358,4 +1358,4 @@ class expected<void, E>
 
 }  // namespace std
 
-#endif  // ALKOS_LIBC_INCLUDE_EXTENSIONS_EXPECTED_HPP_
+#endif  // LIBS_LIBCPP_INCLUDE_EXPECTED_HPP_
diff --git a/libs/libcpp/include/formats.hpp b/libs/libcpp/include/formats.hpp
index 6f6c157d..d42f0865 100644
--- a/libs/libcpp/include/formats.hpp
+++ b/libs/libcpp/include/formats.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_LIBC_INCLUDE_EXTENSIONS_FORMATS_HPP_
-#define ALKOS_LIBC_INCLUDE_EXTENSIONS_FORMATS_HPP_
+#ifndef LIBS_LIBCPP_INCLUDE_FORMATS_HPP_
+#define LIBS_LIBCPP_INCLUDE_FORMATS_HPP_
 
 template <typename ObjT>
 char *DumpObjToBufferHex(const ObjT &obj, char *buffer, size_t buffer_size)
@@ -71,4 +71,4 @@ void DumpObjHexWithSep(FuncT func, const ObjT &obj)
     func(buffer);
 }
 
-#endif  // ALKOS_LIBC_INCLUDE_EXTENSIONS_FORMATS_HPP_
+#endif  // LIBS_LIBCPP_INCLUDE_FORMATS_HPP_
diff --git a/libs/libcpp/include/functional.hpp b/libs/libcpp/include/functional.hpp
index 9fd8ae53..24f05802 100644
--- a/libs/libcpp/include/functional.hpp
+++ b/libs/libcpp/include/functional.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_LIBC_INCLUDE_EXTENSIONS_FUNCTIONAL_HPP_
-#define ALKOS_LIBC_INCLUDE_EXTENSIONS_FUNCTIONAL_HPP_
+#ifndef LIBS_LIBCPP_INCLUDE_FUNCTIONAL_HPP_
+#define LIBS_LIBCPP_INCLUDE_FUNCTIONAL_HPP_
 
 #include <internal/invoke.hpp>
 #include "utility.hpp"
@@ -91,4 +91,4 @@ constexpr R invoke_r(F &&f, Args &&...args) noexcept(std::is_nothrow_invocable_r
 
 }  // namespace std
 
-#endif  // ALKOS_LIBC_INCLUDE_EXTENSIONS_FUNCTIONAL_HPP_
+#endif  // LIBS_LIBCPP_INCLUDE_FUNCTIONAL_HPP_
diff --git a/libs/libcpp/include/initializer_list.hpp b/libs/libcpp/include/initializer_list.hpp
index fc6dd3ce..8499d9df 100644
--- a/libs/libcpp/include/initializer_list.hpp
+++ b/libs/libcpp/include/initializer_list.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_LIBC_INCLUDE_EXTENSIONS_INITIALIZER_LIST_HPP_
-#define ALKOS_LIBC_INCLUDE_EXTENSIONS_INITIALIZER_LIST_HPP_
+#ifndef LIBS_LIBCPP_INCLUDE_INITIALIZER_LIST_HPP_
+#define LIBS_LIBCPP_INCLUDE_INITIALIZER_LIST_HPP_
 
 #include <cstddef.hpp>
 #include <defines.hpp>
@@ -66,4 +66,4 @@ constexpr const T *end(initializer_list<T> list) noexcept
 
 }  // namespace std
 
-#endif  // ALKOS_LIBC_INCLUDE_EXTENSIONS_INITIALIZER_LIST_HPP_
+#endif  // LIBS_LIBCPP_INCLUDE_INITIALIZER_LIST_HPP_
diff --git a/libs/libcpp/include/internal/formats.hpp b/libs/libcpp/include/internal/formats.hpp
index 0ff2a6ef..bced0245 100644
--- a/libs/libcpp/include/internal/formats.hpp
+++ b/libs/libcpp/include/internal/formats.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_LIBC_INCLUDE_EXTENSIONS_INTERNAL_FORMATS_HPP_
-#define ALKOS_LIBC_INCLUDE_EXTENSIONS_INTERNAL_FORMATS_HPP_
+#ifndef LIBS_LIBCPP_INCLUDE_INTERNAL_FORMATS_HPP_
+#define LIBS_LIBCPP_INCLUDE_INTERNAL_FORMATS_HPP_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -78,4 +78,4 @@ inline const char *FormatMetricUint(uintmax_t num)
     return buffer;
 }
 
-#endif  // ALKOS_LIBC_INCLUDE_EXTENSIONS_INTERNAL_FORMATS_HPP_
+#endif  // LIBS_LIBCPP_INCLUDE_INTERNAL_FORMATS_HPP_
diff --git a/libs/libcpp/include/internal/intervals.hpp b/libs/libcpp/include/internal/intervals.hpp
index aad53193..47eee783 100644
--- a/libs/libcpp/include/internal/intervals.hpp
+++ b/libs/libcpp/include/internal/intervals.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_LIBC_INCLUDE_EXTENSIONS_INTERNAL_INTERVALS_HPP_
-#define ALKOS_LIBC_INCLUDE_EXTENSIONS_INTERNAL_INTERVALS_HPP_
+#ifndef LIBS_LIBCPP_INCLUDE_INTERNAL_INTERVALS_HPP_
+#define LIBS_LIBCPP_INCLUDE_INTERNAL_INTERVALS_HPP_
 
 #include "type_traits.hpp"
 #include "types.hpp"
@@ -23,4 +23,4 @@ bool DoOpenIntervalsOverlap(NumT start1, NumT end1, NumT start2, NumT end2)
 
 }  // namespace internal
 
-#endif  // ALKOS_LIBC_INCLUDE_EXTENSIONS_INTERNAL_INTERVALS_HPP_
+#endif  // LIBS_LIBCPP_INCLUDE_INTERNAL_INTERVALS_HPP_
diff --git a/libs/libcpp/include/internal/invoke.hpp b/libs/libcpp/include/internal/invoke.hpp
index 5fcb7317..4d045db0 100644
--- a/libs/libcpp/include/internal/invoke.hpp
+++ b/libs/libcpp/include/internal/invoke.hpp
@@ -1,6 +1,6 @@
-#ifndef ALKOS_LIBC_INCLUDE_EXTENSIONS_INTERNAL_INVOKE_HPP_
-#define ALKOS_LIBC_INCLUDE_EXTENSIONS_INTERNAL_INVOKE_HPP_
+#ifndef LIBS_LIBCPP_INCLUDE_INTERNAL_INVOKE_HPP_
+#define LIBS_LIBCPP_INCLUDE_INTERNAL_INVOKE_HPP_
 
 #include <type_traits.hpp>
 
-#endif  // ALKOS_LIBC_INCLUDE_EXTENSIONS_INTERNAL_INVOKE_HPP_
+#endif  // LIBS_LIBCPP_INCLUDE_INTERNAL_INVOKE_HPP_
diff --git a/libs/libcpp/include/internal/tuple_base.hpp b/libs/libcpp/include/internal/tuple_base.hpp
index 9430f298..edbab0ab 100644
--- a/libs/libcpp/include/internal/tuple_base.hpp
+++ b/libs/libcpp/include/internal/tuple_base.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_LIBC_INCLUDE_EXTENSIONS_INTERNAL_TUPLE_BASE_HPP_
-#define ALKOS_LIBC_INCLUDE_EXTENSIONS_INTERNAL_TUPLE_BASE_HPP_
+#ifndef LIBS_LIBCPP_INCLUDE_INTERNAL_TUPLE_BASE_HPP_
+#define LIBS_LIBCPP_INCLUDE_INTERNAL_TUPLE_BASE_HPP_
 
 #include <stdlib.h>
 
@@ -349,4 +349,4 @@ class tuple : public __BaseTuple<Args...>
 };
 }  // namespace std
 
-#endif  // ALKOS_LIBC_INCLUDE_EXTENSIONS_INTERNAL_TUPLE_BASE_HPP_
+#endif  // LIBS_LIBCPP_INCLUDE_INTERNAL_TUPLE_BASE_HPP_
diff --git a/libs/libcpp/include/internal/utility.hpp b/libs/libcpp/include/internal/utility.hpp
index 39de7e05..63a883ec 100644
--- a/libs/libcpp/include/internal/utility.hpp
+++ b/libs/libcpp/include/internal/utility.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_LIBC_INCLUDE_EXTENSIONS_INTERNAL_UTILITY_HPP_
-#define ALKOS_LIBC_INCLUDE_EXTENSIONS_INTERNAL_UTILITY_HPP_
+#ifndef LIBS_LIBCPP_INCLUDE_INTERNAL_UTILITY_HPP_
+#define LIBS_LIBCPP_INCLUDE_INTERNAL_UTILITY_HPP_
 
 #include <initializer_list.hpp>
 
@@ -35,4 +35,4 @@ constexpr const E *data(std::initializer_list<E> il) noexcept
 
 }  // namespace std
 
-#endif  // ALKOS_LIBC_INCLUDE_EXTENSIONS_INTERNAL_UTILITY_HPP_
+#endif  // LIBS_LIBCPP_INCLUDE_INTERNAL_UTILITY_HPP_
diff --git a/libs/libcpp/include/limits.hpp b/libs/libcpp/include/limits.hpp
index 84ffedf3..23c7dadc 100644
--- a/libs/libcpp/include/limits.hpp
+++ b/libs/libcpp/include/limits.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_LIBC_INCLUDE_EXTENSIONS_LIMITS_HPP_
-#define ALKOS_LIBC_INCLUDE_EXTENSIONS_LIMITS_HPP_
+#ifndef LIBS_LIBCPP_INCLUDE_LIMITS_HPP_
+#define LIBS_LIBCPP_INCLUDE_LIMITS_HPP_
 
 #include <bits_ext.hpp>
 #include <type_traits.hpp>
@@ -281,4 +281,4 @@ TODO_LIBCPP_COMPLIANCE
 
 }  // namespace std
 
-#endif  // ALKOS_LIBC_INCLUDE_EXTENSIONS_LIMITS_HPP_
+#endif  // LIBS_LIBCPP_INCLUDE_LIMITS_HPP_
diff --git a/libs/libcpp/include/literals.hpp b/libs/libcpp/include/literals.hpp
index fd72b452..b8050344 100644
--- a/libs/libcpp/include/literals.hpp
+++ b/libs/libcpp/include/literals.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_LIBC_INCLUDE_EXTENSIONS_LITERALS_HPP_
-#define ALKOS_LIBC_INCLUDE_EXTENSIONS_LITERALS_HPP_
+#ifndef LIBS_LIBCPP_INCLUDE_LITERALS_HPP_
+#define LIBS_LIBCPP_INCLUDE_LITERALS_HPP_
 
 #include <string.hpp>
 
@@ -44,4 +44,4 @@ NODISCARD constexpr wstring_view operator""sv(const wchar_t *str, size_t len) no
 
 }  // namespace std::literals
 
-#endif  // ALKOS_LIBC_INCLUDE_EXTENSIONS_LITERALS_HPP_
+#endif  // LIBS_LIBCPP_INCLUDE_LITERALS_HPP_
diff --git a/libs/libcpp/include/mutex.hpp b/libs/libcpp/include/mutex.hpp
index ac31aff4..0219385f 100644
--- a/libs/libcpp/include/mutex.hpp
+++ b/libs/libcpp/include/mutex.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_LIBC_INCLUDE_EXTENSIONS_MUTEX_HPP_
-#define ALKOS_LIBC_INCLUDE_EXTENSIONS_MUTEX_HPP_
+#ifndef LIBS_LIBCPP_INCLUDE_MUTEX_HPP_
+#define LIBS_LIBCPP_INCLUDE_MUTEX_HPP_
 
 #include "concepts_ext.hpp"
 #include "template_lib.hpp"
@@ -38,4 +38,4 @@ class lock_guard final : template_lib::NoCopy
 };
 }  // namespace std
 
-#endif  // ALKOS_LIBC_INCLUDE_EXTENSIONS_MUTEX_HPP_
+#endif  // LIBS_LIBCPP_INCLUDE_MUTEX_HPP_
diff --git a/libs/libcpp/include/new.hpp b/libs/libcpp/include/new.hpp
index 371c57ea..e382c00e 100644
--- a/libs/libcpp/include/new.hpp
+++ b/libs/libcpp/include/new.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_LIBC_INCLUDE_EXTENSIONS_NEW_HPP_
-#define ALKOS_LIBC_INCLUDE_EXTENSIONS_NEW_HPP_
+#ifndef LIBS_LIBCPP_INCLUDE_NEW_HPP_
+#define LIBS_LIBCPP_INCLUDE_NEW_HPP_
 
 #include <assert.h>
 #include <stddef.h>
@@ -42,4 +42,4 @@ inline void *operator new[](size_t, std::align_val_t al, void *ptr)
     return ptr;
 }
 
-#endif  // ALKOS_LIBC_INCLUDE_EXTENSIONS_NEW_HPP_
+#endif  // LIBS_LIBCPP_INCLUDE_NEW_HPP_
diff --git a/libs/libcpp/include/optional.hpp b/libs/libcpp/include/optional.hpp
index 7e8617ea..4ad98323 100644
--- a/libs/libcpp/include/optional.hpp
+++ b/libs/libcpp/include/optional.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_LIBC_INCLUDE_EXTENSIONS_OPTIONAL_HPP_
-#define ALKOS_LIBC_INCLUDE_EXTENSIONS_OPTIONAL_HPP_
+#ifndef LIBS_LIBCPP_INCLUDE_OPTIONAL_HPP_
+#define LIBS_LIBCPP_INCLUDE_OPTIONAL_HPP_
 
 #include <assert.h>
 #include <todo.h>
@@ -88,4 +88,4 @@ class optional
 
 }  // namespace std
 
-#endif  // ALKOS_LIBC_INCLUDE_EXTENSIONS_OPTIONAL_HPP_
+#endif  // LIBS_LIBCPP_INCLUDE_OPTIONAL_HPP_
diff --git a/libs/libcpp/include/string.hpp b/libs/libcpp/include/string.hpp
index d667f874..1123b124 100644
--- a/libs/libcpp/include/string.hpp
+++ b/libs/libcpp/include/string.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_LIBC_INCLUDE_EXTENSIONS_STRING_HPP_
-#define ALKOS_LIBC_INCLUDE_EXTENSIONS_STRING_HPP_
+#ifndef LIBS_LIBCPP_INCLUDE_STRING_HPP_
+#define LIBS_LIBCPP_INCLUDE_STRING_HPP_
 
 // #include <basic_string.hpp>
 #include <basic_string_view.hpp>
@@ -21,4 +21,4 @@ using u32string_view = basic_string_view<char32_t>;
 
 }  // namespace std
 
-#endif  // ALKOS_LIBC_INCLUDE_EXTENSIONS_STRING_HPP_
+#endif  // LIBS_LIBCPP_INCLUDE_STRING_HPP_
diff --git a/libs/libcpp/include/time.hpp b/libs/libcpp/include/time.hpp
index 0a17053f..13643777 100644
--- a/libs/libcpp/include/time.hpp
+++ b/libs/libcpp/include/time.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_LIBC_INCLUDE_EXTENSIONS_TIME_HPP_
-#define ALKOS_LIBC_INCLUDE_EXTENSIONS_TIME_HPP_
+#ifndef LIBS_LIBCPP_INCLUDE_TIME_HPP_
+#define LIBS_LIBCPP_INCLUDE_TIME_HPP_
 
 #include <assert.h>
 #include <stdint.h>
@@ -179,4 +179,4 @@ NODISCARD FAST_CALL time_t MkTimeFromTimeZone(tm &time_ptr, const timezone &time
     return t;
 }
 
-#endif  // ALKOS_LIBC_INCLUDE_EXTENSIONS_TIME_HPP_
+#endif  // LIBS_LIBCPP_INCLUDE_TIME_HPP_
diff --git a/libs/libcpp/include/tuple.hpp b/libs/libcpp/include/tuple.hpp
index b78b9de2..5acd58f3 100644
--- a/libs/libcpp/include/tuple.hpp
+++ b/libs/libcpp/include/tuple.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_LIBC_INCLUDE_EXTENSIONS_TUPLE_HPP_
-#define ALKOS_LIBC_INCLUDE_EXTENSIONS_TUPLE_HPP_
+#ifndef LIBS_LIBCPP_INCLUDE_TUPLE_HPP_
+#define LIBS_LIBCPP_INCLUDE_TUPLE_HPP_
 
 #include <stdlib.h>
 
@@ -110,4 +110,4 @@ NODISCARD FORCE_INLINE_F constexpr const T &&get(const tuple<Args...> &&tuple) n
 }
 }  // namespace std
 
-#endif  // ALKOS_LIBC_INCLUDE_EXTENSIONS_TUPLE_HPP_
+#endif  // LIBS_LIBCPP_INCLUDE_TUPLE_HPP_
diff --git a/libs/libcpp/include/type_traits.hpp b/libs/libcpp/include/type_traits.hpp
index 6bc29a7f..efbff0a0 100644
--- a/libs/libcpp/include/type_traits.hpp
+++ b/libs/libcpp/include/type_traits.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_LIBC_INCLUDE_EXTENSIONS_TYPE_TRAITS_HPP_
-#define ALKOS_LIBC_INCLUDE_EXTENSIONS_TYPE_TRAITS_HPP_
+#ifndef LIBS_LIBCPP_INCLUDE_TYPE_TRAITS_HPP_
+#define LIBS_LIBCPP_INCLUDE_TYPE_TRAITS_HPP_
 
 #include <todo.h>
 #include <cstddef.hpp>
@@ -2073,4 +2073,4 @@ constexpr bool is_nothrow_destructible_v = is_nothrow_destructible<T>::value;
 
 }  // namespace std
 
-#endif  // ALKOS_LIBC_INCLUDE_EXTENSIONS_TYPE_TRAITS_HPP_
+#endif  // LIBS_LIBCPP_INCLUDE_TYPE_TRAITS_HPP_
diff --git a/libs/libcpp/include/type_traits_ext.hpp b/libs/libcpp/include/type_traits_ext.hpp
index 1299ab39..98da8fc7 100644
--- a/libs/libcpp/include/type_traits_ext.hpp
+++ b/libs/libcpp/include/type_traits_ext.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_LIBC_INCLUDE_EXTENSIONS_TYPE_TRAITS_EXT_HPP_
-#define ALKOS_LIBC_INCLUDE_EXTENSIONS_TYPE_TRAITS_EXT_HPP_
+#ifndef LIBS_LIBCPP_INCLUDE_TYPE_TRAITS_EXT_HPP_
+#define LIBS_LIBCPP_INCLUDE_TYPE_TRAITS_EXT_HPP_
 
 #include <type_traits.hpp>
 
@@ -15,4 +15,4 @@ using conditional_const_t = typename conditional_const<B, T>::type;
 
 }  // namespace type_traits_ext
 
-#endif  // ALKOS_LIBC_INCLUDE_EXTENSIONS_TYPE_TRAITS_EXT_HPP_
+#endif  // LIBS_LIBCPP_INCLUDE_TYPE_TRAITS_EXT_HPP_
diff --git a/libs/libcpp/include/types.hpp b/libs/libcpp/include/types.hpp
index f626aa58..f741c072 100644
--- a/libs/libcpp/include/types.hpp
+++ b/libs/libcpp/include/types.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_LIBC_INCLUDE_EXTENSIONS_TYPES_HPP_
-#define ALKOS_LIBC_INCLUDE_EXTENSIONS_TYPES_HPP_
+#ifndef LIBS_LIBCPP_INCLUDE_TYPES_HPP_
+#define LIBS_LIBCPP_INCLUDE_TYPES_HPP_
 
 #include <stdbool.h>
 #include <stddef.h>
@@ -25,4 +25,4 @@ typedef double f64;
 typedef uintptr_t uptr;
 typedef intptr_t iptr;
 
-#endif  // ALKOS_LIBC_INCLUDE_EXTENSIONS_TYPES_HPP_
+#endif  // LIBS_LIBCPP_INCLUDE_TYPES_HPP_
diff --git a/libs/libcpp/include/variant.hpp b/libs/libcpp/include/variant.hpp
index 73184e99..36f849ab 100644
--- a/libs/libcpp/include/variant.hpp
+++ b/libs/libcpp/include/variant.hpp
@@ -1,5 +1,5 @@
-#ifndef ALKOS_LIBC_INCLUDE_EXTENSIONS_VARIANT_HPP_
-#define ALKOS_LIBC_INCLUDE_EXTENSIONS_VARIANT_HPP_
+#ifndef LIBS_LIBCPP_INCLUDE_VARIANT_HPP_
+#define LIBS_LIBCPP_INCLUDE_VARIANT_HPP_
 
 namespace std
 {
@@ -16,4 +16,4 @@ constexpr strong_ordering operator<=>(monostate, monostate) noexcept
 }
 }  // namespace std
 
-#endif  // ALKOS_LIBC_INCLUDE_EXTENSIONS_VARIANT_HPP_
+#endif  // LIBS_LIBCPP_INCLUDE_VARIANT_HPP_

From c8033797fee1138c10b8f5d6840fec3dc7efc4b3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C5=81ukasz=20Kryczka?=
 <60490378+kryczkal@users.noreply.github.com>
Date: Fri, 19 Dec 2025 23:22:49 +0100
Subject: [PATCH 15/56] Kryczkal/pagefault handler (#240)

- Made PageFaultHandler actually work for anonymous memory.
- Added tests for MMU abstraction
- Implemented kernel new/delete equivalents (KNew, KDelete)
- Enabled tests that should work now (time tests, and pagefaulthandler
test related to anonymous mem)

**Note**: Direct Memory mapping doesn't work and is still in progress
---
 kernel/arch/x86_64/src/hal/impl/mmu.tpp |  30 ++-
 kernel/src/mem/heap.hpp                 |  28 +++
 kernel/src/mem/virt/page_fault.cpp      |   6 +-
 kernel/test/mmu_test.cpp                | 235 ++++++++++++++++++++++++
 kernel/test/test_module.cpp             |   3 +
 scripts/tests/runner.py                 |   6 +-
 6 files changed, 293 insertions(+), 15 deletions(-)
 create mode 100644 kernel/test/mmu_test.cpp

diff --git a/kernel/arch/x86_64/src/hal/impl/mmu.tpp b/kernel/arch/x86_64/src/hal/impl/mmu.tpp
index bcdecb8d..d3d43aa6 100644
--- a/kernel/arch/x86_64/src/hal/impl/mmu.tpp
+++ b/kernel/arch/x86_64/src/hal/impl/mmu.tpp
@@ -44,10 +44,10 @@ expected<Mem::VPtr<PageMapEntry<kLevel>>, Mem::MemError> Mmu::WalkToEntry(
 
     static constexpr u64 kDefFlags = kPresentBit | kWriteBit | kUserAccessibleBit;
 
-    auto pmt_l4 =
-        reinterpret_cast<Mem::VPtr<PageMapTable<4>>>(Mem::PhysToVirt(as->PageTableRoot()));
+    // PML4
+    auto *pmt_l4 = reinterpret_cast<PageMapEntry<4> *>(Mem::PhysToVirt(as->PageTableRoot()));
+    auto *pme_l4 = &pmt_l4[PmeIdx<4>(vaddr)];
 
-    auto pme_l4 = Mem::PhysToVirt(pmt_l4[PmeIdx<4>(vaddr)]);
     if (!pme_l4->IsPresent()) {
         if (!create_if_missing) {
             return unexpected(Mem::MemError::NotFound);
@@ -58,13 +58,17 @@ expected<Mem::VPtr<PageMapEntry<kLevel>>, Mem::MemError> Mmu::WalkToEntry(
             return unexpected(res.error());
         }
 
+        memset(*res, 0, sizeof(PageMapTable<3>));
         pme_l4->SetNextLevelTable(Mem::VirtToPhys(*res), kDefFlags);
     }
     if constexpr (kLevel == 4)
         return pme_l4;
 
-    auto pmt_l3 = Mem::PhysToVirt(pme_l4->GetNextLevelTable());
-    auto pme_l3 = Mem::PhysToVirt(pmt_l3[PmeIdx<3>(vaddr)]);
+    // PDP (L3)
+    auto *pmt_l3 =
+        reinterpret_cast<PageMapEntry<3> *>(Mem::PhysToVirt(pme_l4->GetNextLevelTable()));
+    auto *pme_l3 = &pmt_l3[PmeIdx<3>(vaddr)];
+
     if (!pme_l3->IsPresent()) {
         if (!create_if_missing) {
             return unexpected(Mem::MemError::NotFound);
@@ -75,13 +79,17 @@ expected<Mem::VPtr<PageMapEntry<kLevel>>, Mem::MemError> Mmu::WalkToEntry(
             return unexpected(res.error());
         }
 
+        memset(*res, 0, sizeof(PageMapTable<2>));
         pme_l3->SetNextLevelTable(Mem::VirtToPhys(*res), kDefFlags);
     }
     if constexpr (kLevel == 3)
         return pme_l3;
 
-    auto pmt_l2 = Mem::PhysToVirt(pme_l3->GetNextLevelTable());
-    auto pme_l2 = Mem::PhysToVirt(pmt_l2[PmeIdx<2>(vaddr)]);
+    // PD (L2)
+    auto *pmt_l2 =
+        reinterpret_cast<PageMapEntry<2> *>(Mem::PhysToVirt(pme_l3->GetNextLevelTable()));
+    auto *pme_l2 = &pmt_l2[PmeIdx<2>(vaddr)];
+
     if (!pme_l2->IsPresent()) {
         if (!create_if_missing) {
             return unexpected(Mem::MemError::NotFound);
@@ -92,13 +100,17 @@ expected<Mem::VPtr<PageMapEntry<kLevel>>, Mem::MemError> Mmu::WalkToEntry(
             return unexpected(res.error());
         }
 
+        memset(*res, 0, sizeof(PageMapTable<1>));
         pme_l2->SetNextLevelTable(Mem::VirtToPhys(*res), kDefFlags);
     }
     if constexpr (kLevel == 2)
         return pme_l2;
 
-    auto pmt_l1 = Mem::PhysToVirt(pme_l2->GetNextLevelTable());
-    auto pme_l1 = Mem::PhysToVirt(pmt_l1[PmeIdx<1>(vaddr)]);
+    // PT (L1)
+    auto *pmt_l1 =
+        reinterpret_cast<PageMapEntry<1> *>(Mem::PhysToVirt(pme_l2->GetNextLevelTable()));
+    auto *pme_l1 = &pmt_l1[PmeIdx<1>(vaddr)];
+
     if constexpr (kLevel == 1)
         return pme_l1;
 
diff --git a/kernel/src/mem/heap.hpp b/kernel/src/mem/heap.hpp
index e725c9fd..4cb76043 100644
--- a/kernel/src/mem/heap.hpp
+++ b/kernel/src/mem/heap.hpp
@@ -2,6 +2,9 @@
 #define KERNEL_SRC_MEM_HEAP_HPP_
 
 #include <expected.hpp>
+#include <new.hpp>
+#include <utility.hpp>
+
 #include "mem/error.hpp"
 #include "mem/types.hpp"
 
@@ -97,6 +100,31 @@ void KFreeAligned(VPtr<T> ptr)
 template <>
 void KFreeAligned(VPtr<void> ptr);
 
+// ---------------------------------------------------------------------------
+// Object Lifecycle API (new/delete equivalents)
+// ---------------------------------------------------------------------------
+
+/// KNew: Allocates memory and constructs the object T
+template <typename T, typename... Args>
+expected<VPtr<T>, MemError> KNew(Args &&...args)
+{
+    return KMalloc(sizeof(T)).transform([&](VPtr<void> ptr) {
+        new (reinterpret_cast<void *>(ptr)) T(std::forward<Args>(args)...);
+        return reinterpret_cast<VPtr<T>>(ptr);
+    });
+}
+
+/// KDelete: Destructs the object T and frees memory
+template <typename T>
+void KDelete(VPtr<T> ptr)
+{
+    if (!ptr) {
+        return;
+    }
+    reinterpret_cast<T *>(ptr)->~T();
+    KFree(reinterpret_cast<VPtr<void>>(ptr));
+}
+
 }  // namespace Mem
 
 #endif  // KERNEL_SRC_MEM_HEAP_HPP_
diff --git a/kernel/src/mem/virt/page_fault.cpp b/kernel/src/mem/virt/page_fault.cpp
index 50c5439a..1981387a 100644
--- a/kernel/src/mem/virt/page_fault.cpp
+++ b/kernel/src/mem/virt/page_fault.cpp
@@ -12,6 +12,8 @@ namespace Mem
 
 void PageFaultHandler(intr::LitExcEntry &, hal::ExceptionData *data)
 {
+    TRACE_INFO_GENERAL("PageFaultHandler: Handling Anonymous VMA");
+    trace::Flush();
     using namespace hal;
     ASSERT_NOT_NULL(data);
 
@@ -39,6 +41,7 @@ void PageFaultHandler(intr::LitExcEntry &, hal::ExceptionData *data)
 
         PPtr<void> map_to = nullptr;
         if (vma.type == VirtualMemAreaT::Anonymous) {
+            TRACE_INFO_GENERAL("PageFaultHandler: Handling Anonymous VMA");
             auto new_page_or_error = pmm.Alloc();
             if (!new_page_or_error) {
                 hal::KernelPanic("Out of memory during page fault handling");
@@ -50,6 +53,7 @@ void PageFaultHandler(intr::LitExcEntry &, hal::ExceptionData *data)
 
             map_to = new_page_phys;
         } else if (vma.type == VirtualMemAreaT::DirectMapping) {
+            TRACE_INFO_GENERAL("PageFaultHandler: Handling DirectMapping VMA");
             const auto offset = PtrToUptr(f_ptr) - PtrToUptr(vma.start);
             map_to            = UptrToPtr<void>(
                 AlignDown(PtrToUptr(vma.direct_mapping_start) + offset, kPageSizeBytes)
@@ -77,7 +81,7 @@ void PageFaultHandler(intr::LitExcEntry &, hal::ExceptionData *data)
             hal::KernelPanicFormat("Failed to map page for address 0x%p", f_ptr);
         }
 
-        DEBUG_FREQ_INFO_MEMORY(
+        TRACE_INFO_GENERAL(
             "Handled page fault at 0x%p by mapping to physical page at 0x%p", f_ptr, map_to
         );
         return;
diff --git a/kernel/test/mmu_test.cpp b/kernel/test/mmu_test.cpp
new file mode 100644
index 00000000..4686c24d
--- /dev/null
+++ b/kernel/test/mmu_test.cpp
@@ -0,0 +1,235 @@
+#include <string.h>
+#include "test_module/test.hpp"
+
+#include "hal/mmu.hpp"
+#include "mem/page.hpp"
+#include "mem/virt/addr_space.hpp"
+#include "modules/memory.hpp"
+
+using namespace Mem;
+using namespace hal;
+
+class MmuTest : public TestGroupBase
+{
+    protected:
+    void Setup_() override
+    {
+        // Allocate a physical page for the root page table (PML4)
+        auto &pmm     = MemoryModule::Get().GetBitmapPmm();
+        auto page_res = pmm.Alloc();
+        R_ASSERT_TRUE(page_res.has_value());
+
+        pml4_phys_ = *page_res;
+        pml4_virt_ = Mem::PhysToVirt(reinterpret_cast<Mem::PPtr<void>>(pml4_phys_));
+
+        // Zero out the PML4 to ensure it's clean and valid
+        memset(pml4_virt_, 0, hal::kPageSizeBytes);
+
+        // Initialize AddressSpace with this root
+        auto test_as_or_err = KNew<AddressSpace>(pml4_phys_);
+        R_ASSERT_TRUE(test_as_or_err);
+        test_as_ = test_as_or_err.value();
+    }
+
+    void TearDown_() override
+    {
+        if (test_as_ != nullptr) {
+            KDelete(test_as_);
+            test_as_ = nullptr;
+        }
+
+        // NOTE: There is no cleanup of the PML pages here. But since each test runs
+        // in a separate AlkOS instace, this is ok
+
+        auto &pmm = MemoryModule::Get().GetBitmapPmm();
+        pmm.Free(pml4_phys_);
+    }
+
+    Mem::PPtr<Mem::Page> pml4_phys_;
+    Mem::VPtr<void> pml4_virt_;
+    Mem::VPtr<Mem::AddressSpace> test_as_{nullptr};
+    hal::Mmu mmu_{};
+
+    // Default flags for testing
+    PageFlags kDefaultFlags{
+        .Present        = true,
+        .Writable       = true,
+        .UserAccessible = false,
+        .WriteThrough   = false,
+        .CacheDisable   = false,
+        .Global         = true,
+        .NoExecute      = false,
+    };
+};
+
+// ------------------------------
+// Map Tests
+// ------------------------------
+
+TEST_F(MmuTest, Map_GivenValidUnmappedPage_SucceedsAndTranslateReturnsPhys)
+{
+    // Given
+    VPtr<void> vaddr = reinterpret_cast<VPtr<void>>(0x100000);
+    PPtr<void> paddr = reinterpret_cast<PPtr<void>>(0x200000);
+
+    // When
+    auto result = mmu_.Map(test_as_, vaddr, paddr, kDefaultFlags);
+
+    // Then
+    EXPECT_TRUE(result.has_value());
+
+    auto trans_res = mmu_.Translate(test_as_, vaddr);
+    EXPECT_TRUE(trans_res.has_value());
+    EXPECT_EQ(paddr, trans_res.value());
+}
+
+TEST_F(MmuTest, Map_GivenAlreadyMappedPage_ReturnsError)
+{
+    // Given
+    VPtr<void> vaddr  = reinterpret_cast<VPtr<void>>(0x100000);
+    PPtr<void> paddr1 = reinterpret_cast<PPtr<void>>(0x200000);
+    PPtr<void> paddr2 = reinterpret_cast<PPtr<void>>(0x300000);
+
+    EXPECT_TRUE(mmu_.Map(test_as_, vaddr, paddr1, kDefaultFlags).has_value());
+
+    // When
+    auto result = mmu_.Map(test_as_, vaddr, paddr2, kDefaultFlags);
+
+    // Then
+    EXPECT_FALSE(result.has_value());
+    EXPECT_EQ(Mem::MemError::InvalidArgument, result.error());
+
+    // Verify mapping hasn't changed
+    auto trans_res = mmu_.Translate(test_as_, vaddr);
+    EXPECT_TRUE(trans_res.has_value());
+    EXPECT_EQ(paddr1, trans_res.value());
+}
+
+TEST_F(MmuTest, Map_GivenUnalignedAddress_BehavesConsistency)
+{
+    // Given
+    VPtr<void> vaddr_aligned   = reinterpret_cast<VPtr<void>>(0x100000);
+    VPtr<void> vaddr_unaligned = reinterpret_cast<VPtr<void>>(0x100055);
+    PPtr<void> paddr           = reinterpret_cast<PPtr<void>>(0x200000);
+
+    // When: Mapping with unaligned address
+    auto result = mmu_.Map(test_as_, vaddr_unaligned, paddr, kDefaultFlags);
+
+    // Then
+    EXPECT_TRUE(result.has_value());
+
+    // Check that the aligned address is now mapped
+    auto trans_res = mmu_.Translate(test_as_, vaddr_aligned);
+    EXPECT_TRUE(trans_res.has_value());
+    EXPECT_EQ(paddr, trans_res.value());
+}
+
+TEST_F(MmuTest, Map_GivenZeroAddress_Succeeds)
+{
+    // Given
+    VPtr<void> vaddr = nullptr;
+    PPtr<void> paddr = reinterpret_cast<PPtr<void>>(0x5000);
+
+    // When
+    auto result = mmu_.Map(test_as_, vaddr, paddr, kDefaultFlags);
+
+    // Then
+    EXPECT_TRUE(result.has_value());
+    auto trans_res = mmu_.Translate(test_as_, vaddr);
+    EXPECT_TRUE(trans_res.has_value());
+    EXPECT_EQ(paddr, trans_res.value());
+}
+
+// ------------------------------
+// UnMap Tests
+// ------------------------------
+
+TEST_F(MmuTest, UnMap_GivenMappedPage_Succeeds)
+{
+    // Given
+    VPtr<void> vaddr = reinterpret_cast<VPtr<void>>(0x400000);
+    PPtr<void> paddr = reinterpret_cast<PPtr<void>>(0x800000);
+    mmu_.Map(test_as_, vaddr, paddr, kDefaultFlags);
+
+    // When
+    auto result = mmu_.UnMap(test_as_, vaddr);
+
+    // Then
+    EXPECT_TRUE(result.has_value());
+
+    // Verify it is no longer translated
+    auto trans_res = mmu_.Translate(test_as_, vaddr);
+    EXPECT_FALSE(trans_res.has_value());
+}
+
+TEST_F(MmuTest, UnMap_GivenUnmappedPage_ReturnsError)
+{
+    // Given
+    VPtr<void> vaddr = reinterpret_cast<VPtr<void>>(0x500000);  // Never mapped
+
+    // When
+    auto result = mmu_.UnMap(test_as_, vaddr);
+
+    // Then: Should have memory error
+    EXPECT_TRUE(result.error());
+}
+
+// ------------------------------
+// Translate Tests
+// ------------------------------
+
+TEST_F(MmuTest, Translate_GivenMappedPage_ReturnsPhysicalAddress)
+{
+    // Given
+    VPtr<void> vaddr = reinterpret_cast<VPtr<void>>(0x1000);
+    PPtr<void> paddr = reinterpret_cast<PPtr<void>>(0x2000);
+    mmu_.Map(test_as_, vaddr, paddr, kDefaultFlags);
+
+    // When
+    auto result = mmu_.Translate(test_as_, vaddr);
+
+    // Then
+    EXPECT_TRUE(result.has_value());
+    EXPECT_EQ(paddr, result.value());
+}
+
+TEST_F(MmuTest, Translate_GivenUnmappedPage_ReturnsError)
+{
+    // Given
+    VPtr<void> vaddr = reinterpret_cast<VPtr<void>>(0xDEADBEEF);
+
+    // When
+    auto result = mmu_.Translate(test_as_, vaddr);
+
+    // Then
+    EXPECT_FALSE(result.has_value());
+}
+
+// ------------------------------
+// Control Register Tests
+// ------------------------------
+
+TEST_F(MmuTest, SwitchRootPageMapTable_GivenCurrentRoot_DoesNotCrash)
+{
+    // Given: The current kernel address space root
+    auto &kernel_as              = MemoryModule::Get().GetKernelAddressSpace();
+    Mem::PPtr<void> current_root = kernel_as.PageTableRoot();
+
+    // When: We switch to the SAME root (safe to do)
+    mmu_.SwitchRootPageMapTable(current_root);
+
+    // Then: Execution continues
+    EXPECT_TRUE(true);
+}
+
+TEST_F(MmuTest, DestroyRootPageMapTable_GivenAnyPtr_NoOp)
+{
+    // Given
+    Mem::PPtr<void> dummy_root = reinterpret_cast<Mem::PPtr<void>>(0x1000);
+
+    // When
+    mmu_.DestroyRootPageMapTable(dummy_root);
+
+    // Then: Nothing happens (no crash)
+    EXPECT_TRUE(true);
+}
diff --git a/kernel/test/test_module.cpp b/kernel/test/test_module.cpp
index 57ade77c..4fa1d50d 100644
--- a/kernel/test/test_module.cpp
+++ b/kernel/test/test_module.cpp
@@ -137,15 +137,18 @@ void TestModule::RunTest_(const TestSpec *test)
         arch::TerminalWriteError(
             "[TEST] [FAIL] Test was supposed to fail but all checks passed correctly...\n"
         );
+        trace::Flush();
         return;
     }
 
     if (g_testCheckFailed) {
         arch::TerminalWriteError("[TEST] [FAIL] Test failed on some EXPECT_* checks...\n");
+        trace::Flush();
         return;
     }
 
     arch::TerminalWriteString("[TEST] [SUCCESS] Test passed...\n");
+    trace::Flush();
 }
 
 void AddTest(const char *name, const test_factory_t factory)
diff --git a/scripts/tests/runner.py b/scripts/tests/runner.py
index 7bf035c5..9cfe1d75 100755
--- a/scripts/tests/runner.py
+++ b/scripts/tests/runner.py
@@ -42,11 +42,7 @@ def __init__(self, name: str, test_filters: list[str], test_blockers: list[str])
         [
             "SnprintfTest_BufferSizeHandling",  # Fails <- issue added on low prio
             "SnprintfTest_EdgeCases",  # Fails <- issue added on low prio
-            # Time related tests fail since timing module is disabled for now
-            "MkTimeTest_*",
-            "TimeTConversionTest_*",
-            "TimeTests_TestTime",
-            "PageFaultHandlerTest_*",
+            "PageFaultHandlerTest*DirectMappedMemory*",
         ]
     )
 ]

From 9b814d303c2ad32b81a9518b8d1c974fecbb2329 Mon Sep 17 00:00:00 2001
From: Jakub Lisowski <115403674+Jlisowskyy@users.noreply.github.com>
Date: Sun, 21 Dec 2025 00:15:38 +0100
Subject: [PATCH 16/56] Jlisowski/trace framework 1 (#241)

---
 .../arch/x86_64/src/hal/impl/interrupts.hpp   |   5 +
 .../x86_64/src/tests/interrupts_tests.cpp     |   1 -
 kernel/src/drivers/input/ps2_keyboard.cpp     |   1 -
 kernel/src/hal/api/interrupts.hpp             |   4 +
 kernel/src/hardware/clock_infra.hpp           |  10 +-
 kernel/src/mem/virt/page_fault.cpp            |   1 -
 kernel/src/trace.cpp                          | 125 ++++++++++++------
 kernel/src/trace_framework.hpp                |   7 +-
 8 files changed, 100 insertions(+), 54 deletions(-)

diff --git a/kernel/arch/x86_64/src/hal/impl/interrupts.hpp b/kernel/arch/x86_64/src/hal/impl/interrupts.hpp
index 92401f24..cb168f45 100644
--- a/kernel/arch/x86_64/src/hal/impl/interrupts.hpp
+++ b/kernel/arch/x86_64/src/hal/impl/interrupts.hpp
@@ -6,6 +6,7 @@
 #include <data_structures/array_structures.hpp>
 #include <optional.hpp>
 
+#include <cpu/utils.hpp>
 #include <todo.hpp>
 
 #include "drivers/apic/io_apic.hpp"
@@ -35,6 +36,10 @@ class Interrupts : public InterruptsAPI
 
     void Init();
 
+    FORCE_INLINE_F void BlockHardwareInterrupts() { ::BlockHardwareInterrupts(); }
+
+    FORCE_INLINE_F void EnableHardwareInterrupts() { ::EnableHardwareInterrupts(); }
+
     // ------------------------------
     // Class methods
     // ------------------------------
diff --git a/kernel/arch/x86_64/src/tests/interrupts_tests.cpp b/kernel/arch/x86_64/src/tests/interrupts_tests.cpp
index 6d2d0fb0..2c4fdaf3 100644
--- a/kernel/arch/x86_64/src/tests/interrupts_tests.cpp
+++ b/kernel/arch/x86_64/src/tests/interrupts_tests.cpp
@@ -99,7 +99,6 @@ void ExceptionTestSavesAllRegisters()
     DumpGeneralRegisters(&exc_registers);
     InvokeInterrupt<0>();
     TraceDumpedRegisters(&exc_registers);
-    trace::Flush();
 
     for (size_t idx = 0; idx <= RegisterIdx::kRegR15; ++idx) {
         R_ASSERT_EQ(
diff --git a/kernel/src/drivers/input/ps2_keyboard.cpp b/kernel/src/drivers/input/ps2_keyboard.cpp
index cd97d42f..0ad891da 100644
--- a/kernel/src/drivers/input/ps2_keyboard.cpp
+++ b/kernel/src/drivers/input/ps2_keyboard.cpp
@@ -100,7 +100,6 @@ void Ps2Keyboard::Init()
     }
 
     TRACE_INFO_GENERAL("PS/2 Keyboard Initialized & Drained");
-    trace::Flush();
 }
 
 void Ps2Keyboard::OnInterrupt()
diff --git a/kernel/src/hal/api/interrupts.hpp b/kernel/src/hal/api/interrupts.hpp
index bfac21c1..bc61ee04 100644
--- a/kernel/src/hal/api/interrupts.hpp
+++ b/kernel/src/hal/api/interrupts.hpp
@@ -10,6 +10,10 @@ class Interrupts;
 struct InterruptsAPI {
     /* Should perform full initialisation of interrupt system */
     void Init();
+
+    /* Safety methods */
+    void BlockHardwareInterrupts();
+    void EnableHardwareInterrupts();
 };
 
 }  // namespace arch
diff --git a/kernel/src/hardware/clock_infra.hpp b/kernel/src/hardware/clock_infra.hpp
index 966fc4c4..199df248 100644
--- a/kernel/src/hardware/clock_infra.hpp
+++ b/kernel/src/hardware/clock_infra.hpp
@@ -3,6 +3,8 @@
 
 #include <data_structures/data_structures.hpp>
 #include <hal/constants.hpp>
+#include <hal/terminal.hpp>
+
 #include "trace_framework.hpp"
 
 namespace hardware
@@ -33,13 +35,9 @@ class ClockRegistry : public data_structures::Registry<ClockRegistryEntry, kMaxC
     /* Not safe for concurrent access */
     NODISCARD FORCE_INLINE_F u64 ReadTimeNsUnsafe()
     {
-        const u64 timer_val = GetSelected().read(&GetSelected());
-        DEBUG_FREQ_INFO_TIME("Timer value read: %llu", timer_val);
-        DEBUG_FREQ_INFO_TIME(
-            "Numerator: %llu, Denominator: %llu", GetSelected().clock_numerator,
-            GetSelected().clock_denominator
-        );
+        /* Note: cannot trace here!! */
 
+        const u64 timer_val = GetSelected().read(&GetSelected());
         const __uint128_t intermediate_value =
             static_cast<__uint128_t>(timer_val) * GetSelected().clock_numerator;
         const u64 time_ns = static_cast<u64>(intermediate_value / GetSelected().clock_denominator);
diff --git a/kernel/src/mem/virt/page_fault.cpp b/kernel/src/mem/virt/page_fault.cpp
index 1981387a..d80406f1 100644
--- a/kernel/src/mem/virt/page_fault.cpp
+++ b/kernel/src/mem/virt/page_fault.cpp
@@ -13,7 +13,6 @@ namespace Mem
 void PageFaultHandler(intr::LitExcEntry &, hal::ExceptionData *data)
 {
     TRACE_INFO_GENERAL("PageFaultHandler: Handling Anonymous VMA");
-    trace::Flush();
     using namespace hal;
     ASSERT_NOT_NULL(data);
 
diff --git a/kernel/src/trace.cpp b/kernel/src/trace.cpp
index dd39df7f..a8fe7495 100644
--- a/kernel/src/trace.cpp
+++ b/kernel/src/trace.cpp
@@ -55,10 +55,9 @@ static struct TraceFramework {
     // ------------------------------
 
     struct SmallTraceCyclicBuffer {
-        static constexpr size_t kSize           = 65536;
-        static constexpr size_t kDumpSize       = kSize - kSize / 32;
-        static constexpr size_t kBatchSize      = 256;
-        static constexpr size_t kBufferDumpDone = kSize - kSize / 8;
+        static constexpr size_t kSize      = 65536;
+        static constexpr size_t kDumpSize  = kSize - (kSize / 16);
+        static constexpr size_t kBatchSize = 256;
 
         hal::Atomic32 bytes_left{.value = kSize};
         hal::Atomic32 head{};
@@ -67,9 +66,12 @@ static struct TraceFramework {
     };
 
     struct MultithreadTraceCyclicBuffer {
-        u32 head;
-        u32 tail;
-        char *buffer;
+        static constexpr size_t kSize = FeatureValue<FeatureFlag::kTraceBufferSize>;
+
+        hal::Atomic32 bytes_left{.value = kSize};
+        hal::Atomic32 head{};
+        hal::Atomic32 tail{};
+        char buffer[kSize]{};
     };
 
     struct CoreTraceData {
@@ -113,6 +115,8 @@ static struct TraceFramework {
 
     FORCE_INLINE_F void AdvanceToSingleThreadInterruptsStage()
     {
+        /* Should be executed before interrupts are enabled */
+
         DEBUG_INFO_GENERAL("Updating tracing stage to stage 1 (Single thread with interrupts)");
         stage_callbacks.get_workspace_cb = &TraceFramework::GetWorkspaceSingleThreadInterrupts;
         stage_callbacks.commit_to_log_cb = &TraceFramework::CommitToLogSingleThreadInterrupts;
@@ -121,7 +125,20 @@ static struct TraceFramework {
         stage_callbacks.dump_all = &TraceFramework::DumpAllSingleThreadInterrupts;
     }
 
-    FORCE_INLINE_F void AdvanceToMultiThreadStage() { R_FAIL_ALWAYS("Not implemented"); }
+    FORCE_INLINE_F void AdvanceToMultiThreadStage()
+    {
+        /* Should be executed before another cores are enabled!!! */
+
+        DEBUG_INFO_GENERAL("Updating tracing stage to stage 2 (Multithreaded environment)");
+        HardwareModule::Get().GetInterrupts().BlockHardwareInterrupts();
+
+        stage_callbacks.get_workspace_cb       = &TraceFramework::GetWorkspaceMultithreaded;
+        stage_callbacks.commit_to_log_cb       = &TraceFramework::CommitToLogMultithreaded;
+        stage_callbacks.commit_to_debug_log_cb = &TraceFramework::CommitToDebugLogMultithreaded;
+        stage_callbacks.dump_all               = &TraceFramework::DumpAllMultithreaded;
+
+        HardwareModule::Get().GetInterrupts().EnableHardwareInterrupts();
+    }
 
     // --------------------------------------
     // Single thread env implementation
@@ -168,19 +185,31 @@ static struct TraceFramework {
     template <bool kIsDebug>
     FORCE_INLINE_F void DumpBufferSingleThread(SmallTraceCyclicBuffer &buffer)
     {
+        // Assumptions:
+        // 1) bytes_left (1 thread, only main execution writes out) -> bytes_left may only decrement
+        // by interrupts, so
+        //    in worst case we will not write the most recent message from interrupts incoming
+        //    during dumping the buffer
+        // 2) tail is only moved by this function and only main execution can write out so we are
+        // safe to modify
+        //    it without atomics and any constraints
+        //
+        // Based on those two assumptions this function operates
+
         // 1. Save exact amount of bytes to write at entry level (IMPORTANT: to not write infinite)
         const i32 bytes_left = hal::AtomicLoad(&buffer.bytes_left);
         i32 bytes_to_write   = static_cast<i32>(SmallTraceCyclicBuffer::kSize) - bytes_left;
 
+        // 1. Write out the content
         while (bytes_to_write > 0) {
-            // 1. Write out the content
+            // 1. Prepare old tail and write_size
             const i32 tail = buffer.tail.value;
             const i32 batch_write_size =
                 std::min(bytes_to_write, static_cast<i32>(SmallTraceCyclicBuffer::kBatchSize));
 
             if (tail + batch_write_size > static_cast<i32>(SmallTraceCyclicBuffer::kSize)) {
                 // We cross the boundary
-                const size_t first_write  = SmallTraceCyclicBuffer::kSize - buffer.tail.value;
+                const size_t first_write  = SmallTraceCyclicBuffer::kSize - tail;
                 const size_t second_write = batch_write_size - first_write;
                 HardenSingleThread<kIsDebug>(
                     buffer.buffer + tail, static_cast<size_t>(first_write)
@@ -193,8 +222,10 @@ static struct TraceFramework {
             }
 
             // 2. Push the tail
-            buffer.tail.value = (buffer.tail.value + batch_write_size) %
-                                static_cast<i32>(SmallTraceCyclicBuffer::kSize);
+            hal::AtomicStore(
+                &buffer.tail,
+                (tail + batch_write_size) % static_cast<i32>(SmallTraceCyclicBuffer::kSize)
+            );
 
             // 3. Release space
             hal::AtomicAdd(&buffer.bytes_left, batch_write_size);
@@ -209,62 +240,60 @@ static struct TraceFramework {
         SmallTraceCyclicBuffer &buffer, const size_t trace_size
     )
     {
+        // Assumptions:
+        // 1) Interrupt message will be dropped when there is no space left in the buffer
+        // 2) Main execution will try to immediately dump the buffers if there is no space
+        // 3) Only main execution may write the buffer out -> (interrupt writes -> no buffer dumps),
+        // (main exec writes ->
+        //    no buffer dumps) -> no buffer dumps during writing traces (it is safe to operate on
+        //    bytes_left)
+        // 4) Only full traces can be written out
+
         const u8 nested_intrs = hardware::GetCoreLocalData().nested_interrupts;
-        i32 available_bytes;
-        i32 bytes_left;
-        i32 new_value;
 
-        // 1. Allocate space for the trait
-        do {
-            do {
-                /* For main execution just empty the space and retry */
-                bytes_left = hal::AtomicLoad(&buffer.bytes_left);
+        // 1. Allocate space for the trace
+        while (true) {
+            if (hal::AtomicSub(&buffer.bytes_left, static_cast<i32>(trace_size)) < 0) {
+                hal::AtomicAdd(&buffer.bytes_left, static_cast<i32>(trace_size));
 
-                if (bytes_left < static_cast<i32>(trace_size)) {
+                if (nested_intrs == 0) {
                     DumpBufferSingleThread<kIsDebug>(buffer);
+                } else {
+                    /* No space for trace coming from this interrupt, we are dropping it */
+                    return;
                 }
-            } while (nested_intrs == 0 && bytes_left < static_cast<i32>(trace_size));
-
-            /* For interrupt traces, some information may be lost */
-
-            available_bytes = std::min(bytes_left, static_cast<i32>(trace_size));
-            new_value       = bytes_left - available_bytes;
-        } while (hal::AtomicCompareExchange(&buffer.bytes_left, bytes_left, new_value) !=
-                 bytes_left);
+            } else {
+                break;
+            }
+        }
 
         char *src = nested_intrs == 0 ? single_thread_env.main_execution_workspace
                                       : single_thread_env.interrupt_workspace[nested_intrs - 1];
-        if (nested_intrs != 0) {
-            if (available_bytes == 0) {
-                return;
-            }
-
-            /* Ensure EOS for interrupt traces */
-            src[FeatureValue<FeatureFlag::kSingleTraceMaxSize> - 1] = '\0';
-        }
 
         // 2. Adjust head ptr
         i32 old_head;
         i32 new_head;
         do {
             old_head = hal::AtomicLoad(&buffer.head);
-            new_head =
-                (old_head + available_bytes) % static_cast<i32>(SmallTraceCyclicBuffer::kSize);
+            new_head = (old_head + static_cast<i32>(trace_size)) %
+                       static_cast<i32>(SmallTraceCyclicBuffer::kSize);
         } while (hal::AtomicCompareExchange(&buffer.head, old_head, new_head) != old_head);
 
         // 3. Write the message
         if (new_head < old_head) {
-            const i32 first_part  = SmallTraceCyclicBuffer::kSize - old_head;
-            const i32 second_part = available_bytes - first_part;
+            // We cross the boundary
+
+            const i32 first_part  = static_cast<i32>(SmallTraceCyclicBuffer::kSize) - old_head;
+            const i32 second_part = static_cast<i32>(trace_size) - first_part;
             memcpy(buffer.buffer + old_head, src, first_part);
             memcpy(buffer.buffer, src + first_part, second_part);
         } else {
-            memcpy(buffer.buffer + old_head, src, available_bytes);
+            memcpy(buffer.buffer + old_head, src, static_cast<i32>(trace_size));
         }
 
         if (nested_intrs == 0 &&
             buffer.bytes_left.value < static_cast<i32>(SmallTraceCyclicBuffer::kDumpSize)) {
-            // Dump the content
+            // Dump the content on main execution if we used enough space
             DumpBufferSingleThread<kIsDebug>(buffer);
         }
     }
@@ -302,6 +331,14 @@ static struct TraceFramework {
     // Multithread env implementation
     // ------------------------------------
 
+    char *GetWorkspaceMultithreaded() { return nullptr; }
+
+    void CommitToLogMultithreaded(const size_t trace_size) {}
+
+    void CommitToDebugLogMultithreaded(const size_t trace_size) {}
+
+    void DumpAllMultithreaded() {}
+
     // ------------------------------
     // Global fields
     // ------------------------------
@@ -380,7 +417,7 @@ void CommitToDebugLog(const size_t trace_size)
     return (g_TraceFramework.*g_TraceFramework.stage_callbacks.commit_to_debug_log_cb)(trace_size);
 }
 
-int WriteTraceData(char *dst, TraceModule module, TraceType type)
+int WriteTraceData(char *dst, TraceModule module, const TraceType type)
 {
     ASSERT_NOT_NULL(dst);
     ASSERT_NEQ(type, TraceType::kShell);
diff --git a/kernel/src/trace_framework.hpp b/kernel/src/trace_framework.hpp
index 0f7af5e0..35b873bb 100644
--- a/kernel/src/trace_framework.hpp
+++ b/kernel/src/trace_framework.hpp
@@ -3,6 +3,11 @@
 
 #include <defines.hpp>
 
+/* FUTURE PLANS:
+ * - get rid of dumping -> introduce user space program dumping traces
+ * - remove flush() function
+ */
+
 namespace trace
 {
 // ------------------------------
@@ -50,7 +55,7 @@ enum class TraceModule {
 void AdvanceTracingStage();
 NODISCARD TraceLevel GetTraceLevel(TraceModule module);
 void DumpAllBuffersOnFailure();
-void Flush();
+void Flush(); /* May only be used on main execution, no interrupts allowed */
 
 /* MODULE TIME CORE PROC MSG */
 template <TraceType type, TraceModule module, TraceLevel level, class... Args>

From e7587107c8b122582ea904656ddada28415bac66 Mon Sep 17 00:00:00 2001
From: Jakub Lisowski <115403674+Jlisowskyy@users.noreply.github.com>
Date: Fri, 26 Dec 2025 16:04:21 +0100
Subject: [PATCH 17/56] Jlisowskyy/scheduler 0 (#242)

Things done in this PR:
- added GDT code in c++
- added TSS code in c++
- added gdt and TSS per core (stored in core local)
- initialized and flushed gdt for initial core
- cleaned up interrupt assembly
- started switch_task implementation
- added to_string for error enums
- added scheduling module
- added containers for threads and processes
- created thread and process structs
- created task_mgr class managing life time of threads and processes
- tested new containers and templates
- added `AtomicArrayStaticStack` structure
- added `PooledHashMap` structure
- added type `MinimalUnsignedStorage_t`
- added `ScopeGuard` and `BatchedScopeGuard` helpers
---
 .../generated/include/autogen/feature_flags.h | 115 +++++++
 kernel/arch/x86_64/src/cpu/gdt.cpp            |  84 +++++
 kernel/arch/x86_64/src/cpu/gdt.hpp            | 175 ++++++++++
 kernel/arch/x86_64/src/cpu/gdt_flush.nasm     |  32 ++
 kernel/arch/x86_64/src/cpu/tss.hpp            |  25 ++
 kernel/arch/x86_64/src/hal/impl/core.cpp      |  22 +-
 kernel/arch/x86_64/src/hal/impl/core.hpp      |  53 ++-
 .../arch/x86_64/src/hal/impl/scheduling.hpp   |  13 +
 kernel/arch/x86_64/src/include/regs.nasm      |  97 ++++++
 kernel/arch/x86_64/src/include/thread.nasm    |  11 +
 kernel/arch/x86_64/src/interrupts/idt.nasm    |  94 +-----
 kernel/arch/x86_64/src/kernel/init.cpp        |   4 +-
 .../x86_64/src/scheduling/scheduling.nasm     |  52 +++
 .../x86_64/src/tests/interrupts_tests.cpp     |   2 +-
 kernel/src/constants.hpp                      |  12 +
 kernel/src/cores.cpp                          |   7 +
 kernel/src/hal/api/core.hpp                   |   3 +
 kernel/src/hal/core.hpp                       |   2 +
 kernel/src/hal/scheduling.hpp                 |  14 +
 kernel/src/hardware/core_controller.hpp       |   2 +-
 kernel/src/hardware/core_local.cpp            |   4 +
 kernel/src/hardware/core_local.hpp            |  17 +-
 kernel/src/init.cpp                           |  14 +-
 kernel/src/mem/error.hpp                      |  14 +
 kernel/src/mem/phys/mngr/buddy.hpp            |   3 +-
 kernel/src/modules/hardware.cpp               |   3 +
 kernel/src/modules/scheduling.hpp             |  36 +++
 kernel/src/scheduling/error.hpp               |  34 ++
 kernel/src/scheduling/process.hpp             |  25 ++
 kernel/src/scheduling/processes.cpp           |  26 ++
 kernel/src/scheduling/processes.hpp           |  80 +++++
 kernel/src/scheduling/task_mgr.cpp            | 147 +++++++++
 kernel/src/scheduling/task_mgr.hpp            |  42 +++
 kernel/src/scheduling/thread.hpp              |  31 ++
 kernel/src/scheduling/threads.cpp             |  28 ++
 kernel/src/scheduling/threads.hpp             |  81 +++++
 kernel/src/todo.hpp                           |   2 +
 kernel/src/trace.cpp                          |   5 +-
 kernel/src/trace_framework.hpp                |   5 +
 kernel/test/atomic_stack_test.cpp             | 306 ++++++++++++++++++
 kernel/test/hash_maps_test.cpp                | 230 +++++++++++++
 kernel/test/integral_storage_test.cpp         |  58 ++++
 kernel/test/manual_tests.cpp                  |   2 +-
 kernel/test/test_module.cpp                   |   2 +
 .../include/data_structures/atomic_stack.hpp  | 139 ++++++++
 .../include/data_structures/hash_maps.hpp     |  85 +++++
 libs/libcpp/include/bits_ext.hpp              |   5 +-
 .../include/template/integral_storage.hpp     |  13 +
 .../include/template/scope_guard.hpp          |  87 +++++
 49 files changed, 2231 insertions(+), 112 deletions(-)
 create mode 100644 alkos/generated/include/autogen/feature_flags.h
 create mode 100644 kernel/arch/x86_64/src/cpu/gdt.cpp
 create mode 100644 kernel/arch/x86_64/src/cpu/gdt.hpp
 create mode 100644 kernel/arch/x86_64/src/cpu/gdt_flush.nasm
 create mode 100644 kernel/arch/x86_64/src/cpu/tss.hpp
 create mode 100644 kernel/arch/x86_64/src/hal/impl/scheduling.hpp
 create mode 100644 kernel/arch/x86_64/src/include/regs.nasm
 create mode 100644 kernel/arch/x86_64/src/include/thread.nasm
 create mode 100644 kernel/arch/x86_64/src/scheduling/scheduling.nasm
 create mode 100644 kernel/src/constants.hpp
 create mode 100644 kernel/src/hal/scheduling.hpp
 create mode 100644 kernel/src/hardware/core_local.cpp
 create mode 100644 kernel/src/modules/scheduling.hpp
 create mode 100644 kernel/src/scheduling/error.hpp
 create mode 100644 kernel/src/scheduling/process.hpp
 create mode 100644 kernel/src/scheduling/processes.cpp
 create mode 100644 kernel/src/scheduling/processes.hpp
 create mode 100644 kernel/src/scheduling/task_mgr.cpp
 create mode 100644 kernel/src/scheduling/task_mgr.hpp
 create mode 100644 kernel/src/scheduling/thread.hpp
 create mode 100644 kernel/src/scheduling/threads.cpp
 create mode 100644 kernel/src/scheduling/threads.hpp
 create mode 100644 kernel/test/atomic_stack_test.cpp
 create mode 100644 kernel/test/integral_storage_test.cpp
 create mode 100644 libs/libcontainers/include/data_structures/atomic_stack.hpp
 create mode 100644 libs/libtemplate/include/template/integral_storage.hpp
 create mode 100644 libs/libtemplate/include/template/scope_guard.hpp

diff --git a/alkos/generated/include/autogen/feature_flags.h b/alkos/generated/include/autogen/feature_flags.h
new file mode 100644
index 00000000..6bbe2809
--- /dev/null
+++ b/alkos/generated/include/autogen/feature_flags.h
@@ -0,0 +1,115 @@
+// This file is generated by configure script. Do not edit manually.
+
+#ifndef ALKOS_GENERATED_INCLUDE_AUTOGEN_FEATURE_FLAGS_H_
+#define ALKOS_GENERATED_INCLUDE_AUTOGEN_FEATURE_FLAGS_H_
+
+// Macros for feature flags in C code
+
+// "run_test_mode" - "Instead of proceeding to usual kernel boot enter the test mode, which allows
+// to run single test on the kernel."
+#define FEATURE_FLAG_RUN_TEST_MODE 0
+
+// "debug_spinlock" - "Enables additional debug information for spinlocks, which can help to
+// identify deadlocks and other synchronization issues."
+#define FEATURE_FLAG_DEBUG_SPINLOCK 1
+
+// "debug_output" - "Enables additional terminal output directed to serial port, mostly used for
+// qemu builds and debugging."
+#define FEATURE_FLAG_DEBUG_OUTPUT 1
+
+// "debug_traces" - "Enables additional debug traces in the kernel, which can help to identify
+// issues during execution."
+#define FEATURE_FLAG_DEBUG_TRACES 1
+
+// "single_trace_max_size" - "Maximum size of a single debug trace entry in bytes."
+#define FEATURE_FLAG_SINGLE_TRACE_MAX_SIZE 2048
+
+// "trace_buffer_size" - "Size of the trace buffer in bytes."
+#define FEATURE_FLAG_TRACE_BUFFER_SIZE 65536
+
+// "memory_trace_level" - "Level of Memory module tracing"
+#define FEATURE_FLAG_MEMORY_TRACE_LEVEL 2
+
+// "interrupts_trace_level" - "Level of Interrupts module tracing"
+#define FEATURE_FLAG_INTERRUPTS_TRACE_LEVEL 2
+
+// "boot_trace_level" - "Level of Boot module tracing"
+#define FEATURE_FLAG_BOOT_TRACE_LEVEL 2
+
+// "general_trace_level" - "Level of General module tracing"
+#define FEATURE_FLAG_GENERAL_TRACE_LEVEL 2
+
+// =========================================================================================
+
+#ifdef __cplusplus
+// Code for feature flags in C++ code
+
+enum class FeatureFlag {
+    kRunTestMode,
+    kDebugSpinlock,
+    kDebugOutput,
+    kDebugTraces,
+    kSingleTraceMaxSize,
+    kTraceBufferSize,
+    kMemoryTraceLevel,
+    kInterruptsTraceLevel,
+    kBootTraceLevel,
+    kGeneralTraceLevel,
+    kLast,
+};
+
+// Boolean feature flags
+template <FeatureFlag Flag>
+inline constexpr bool FeatureEnabled = false;
+
+// run_test_mode - "Instead of proceeding to usual kernel boot enter the test mode, which allows to
+// run single test on the kernel."
+template <>
+inline constexpr bool FeatureEnabled<FeatureFlag::kRunTestMode> = false;
+
+// debug_spinlock - "Enables additional debug information for spinlocks, which can help to identify
+// deadlocks and other synchronization issues."
+template <>
+inline constexpr bool FeatureEnabled<FeatureFlag::kDebugSpinlock> = true;
+
+// debug_output - "Enables additional terminal output directed to serial port, mostly used for qemu
+// builds and debugging."
+template <>
+inline constexpr bool FeatureEnabled<FeatureFlag::kDebugOutput> = true;
+
+// debug_traces - "Enables additional debug traces in the kernel, which can help to identify issues
+// during execution."
+template <>
+inline constexpr bool FeatureEnabled<FeatureFlag::kDebugTraces> = true;
+
+// Integer feature flags
+template <FeatureFlag Flag>
+inline constexpr int FeatureValue = 0;
+
+// single_trace_max_size - "Maximum size of a single debug trace entry in bytes."
+template <>
+inline constexpr int FeatureValue<FeatureFlag::kSingleTraceMaxSize> = 2048;
+
+// trace_buffer_size - "Size of the trace buffer in bytes."
+template <>
+inline constexpr int FeatureValue<FeatureFlag::kTraceBufferSize> = 65536;
+
+// memory_trace_level - "Level of Memory module tracing"
+template <>
+inline constexpr int FeatureValue<FeatureFlag::kMemoryTraceLevel> = 2;
+
+// interrupts_trace_level - "Level of Interrupts module tracing"
+template <>
+inline constexpr int FeatureValue<FeatureFlag::kInterruptsTraceLevel> = 2;
+
+// boot_trace_level - "Level of Boot module tracing"
+template <>
+inline constexpr int FeatureValue<FeatureFlag::kBootTraceLevel> = 2;
+
+// general_trace_level - "Level of General module tracing"
+template <>
+inline constexpr int FeatureValue<FeatureFlag::kGeneralTraceLevel> = 2;
+
+#endif  // __cplusplus
+
+#endif  // ALKOS_GENERATED_INCLUDE_AUTOGEN_FEATURE_FLAGS_H_
diff --git a/kernel/arch/x86_64/src/cpu/gdt.cpp b/kernel/arch/x86_64/src/cpu/gdt.cpp
new file mode 100644
index 00000000..3a83045b
--- /dev/null
+++ b/kernel/arch/x86_64/src/cpu/gdt.cpp
@@ -0,0 +1,84 @@
+#include "gdt.hpp"
+
+#include <bits_ext.hpp>
+
+void cpu::DefaultEntryInit(
+    GdtEntry<> &entry, const AccessByte access, const GdtEntry<>::Flags flags
+)
+{
+    entry.limit      = 0xFFFF;
+    entry.base       = 0;
+    entry.base_mid   = 0;
+    entry.access     = access;
+    entry.limit_high = 0xF;
+    entry.base_high  = 0;
+
+    // Flags
+    entry.reserved         = 0;
+    entry.long_mode_flag   = flags.long_mode_flag;
+    entry.granularity_flag = flags.granularity_flag;
+    entry.size_flag        = flags.size_flag;
+}
+
+void cpu::DefaultTssEntryInit(GdtSystemSegmentDescriptor &entry, const u64 tss_address)
+{
+    static constexpr u32 kLimit = sizeof(TSS) - 1;
+
+    // encode limit
+    entry.low.limit      = kLimit & kBitMask16;
+    entry.low.limit_high = (kLimit >> 16) & kBitMask4;
+
+    // encode base
+    entry.low.base      = tss_address & kBitMask16;
+    entry.low.base_mid  = (tss_address >> 16) & kBitMask8;
+    entry.low.base_high = (tss_address >> 24) & kBitMask8;
+    entry.base_upper32  = (tss_address >> 32) & kBitMask32;
+
+    // setup access
+    entry.low.access.present_bit = SystemSegmentAccessByte::PresentBit::kPresent;
+    entry.low.access.type_bit    = SystemSegmentAccessByte::DescriptorTypeBit::kSystemSegment;
+    entry.low.access.dpl_bits    = SystemSegmentAccessByte::DescriptorPrivilegeLevel::kKernel;
+    entry.low.access.type        = static_cast<u8>(SystemSegmentAccessByte::LongModeTypes::kTSS);
+
+    entry.low.reserved = 0;
+    entry.reserved     = 0;
+}
+
+void cpu::DefaultGdtInit(GDT &gdt, const u64 tss_address)
+{
+    AccessByte access_kernel_code{};
+    access_kernel_code.present_bit    = AccessByte::PresentBit::kPresent;
+    access_kernel_code.executable_bit = AccessByte::ExecutableBit::kExecutable;
+    access_kernel_code.type_bit       = AccessByte::DescriptorTypeBit::kUsualSegment;
+    access_kernel_code.dpl_bit        = AccessByte::DescriptorPrivilegeLevel::kKernel;
+    GdtEntry<>::Flags flags{};
+    flags.long_mode_flag = GdtEntry<>::LongModeFlag::kLongModeEnabled;
+
+    DefaultEntryInit(gdt.kernel_code, access_kernel_code, flags);
+
+    AccessByte access_kernel_data{};
+    access_kernel_data.present_bit = AccessByte::PresentBit::kPresent;
+    access_kernel_data.type_bit    = AccessByte::DescriptorTypeBit::kUsualSegment;
+    access_kernel_data.rw_bit      = AccessByte::RWBit::kAllowed;
+    access_kernel_data.dpl_bit     = AccessByte::DescriptorPrivilegeLevel::kKernel;
+
+    DefaultEntryInit(gdt.kernel_data, access_kernel_data, {});
+
+    AccessByte access_user_code{};
+    access_user_code.present_bit    = AccessByte::PresentBit::kPresent;
+    access_user_code.executable_bit = AccessByte::ExecutableBit::kExecutable;
+    access_user_code.type_bit       = AccessByte::DescriptorTypeBit::kUsualSegment;
+    access_user_code.dpl_bit        = AccessByte::DescriptorPrivilegeLevel::kUser;
+
+    DefaultEntryInit(gdt.user_code, access_user_code, flags);
+
+    AccessByte access_user_data{};
+    access_user_data.present_bit = AccessByte::PresentBit::kPresent;
+    access_user_data.type_bit    = AccessByte::DescriptorTypeBit::kUsualSegment;
+    access_user_data.rw_bit      = AccessByte::RWBit::kAllowed;
+    access_user_data.dpl_bit     = AccessByte::DescriptorPrivilegeLevel::kUser;
+
+    DefaultEntryInit(gdt.user_data, access_user_data, {});
+
+    DefaultTssEntryInit(gdt.tss_descriptor, tss_address);
+}
diff --git a/kernel/arch/x86_64/src/cpu/gdt.hpp b/kernel/arch/x86_64/src/cpu/gdt.hpp
new file mode 100644
index 00000000..04de3730
--- /dev/null
+++ b/kernel/arch/x86_64/src/cpu/gdt.hpp
@@ -0,0 +1,175 @@
+#ifndef KERNEL_ARCH_X86_64_SRC_CPU_GDT_HPP_
+#define KERNEL_ARCH_X86_64_SRC_CPU_GDT_HPP_
+
+#include <defines.hpp>
+#include <type_traits.hpp>
+#include <types.hpp>
+
+#include "tss.hpp"
+
+namespace cpu
+{
+struct PACK AccessByte {
+    enum class AccessedBit : u8 {
+        kNotAccessed = 0,
+        kAccessed    = 1,
+    };
+
+    enum class RWBit : u8 {
+        kUnallowed = 0,
+        kAllowed   = 1,
+    };
+
+    enum class DirectionBit : u8 {
+        kUp   = 0,
+        kDown = 1,
+    };
+
+    enum class ConformingBit : u8 {
+        kExecutionOnlyByDPL      = 0,
+        kExecutionByLowerThanDPL = 1,
+    };
+
+    enum class ExecutableBit : u8 {
+        kNonExecutable = 0,
+        kExecutable    = 1,
+    };
+
+    enum class DescriptorTypeBit : u8 {
+        kSystemSegment = 0,
+        kUsualSegment  = 1,
+    };
+
+    enum class DescriptorPrivilegeLevel : u8 {
+        kKernel = 0,
+        kRing1  = 1,
+        kRing2  = 2,
+        kUser   = 3,
+    };
+
+    enum class PresentBit : u8 {
+        kPresent    = 1,
+        kNotPresent = 0,
+    };
+
+    AccessedBit accessed_bit : 1;
+    RWBit rw_bit : 1;
+    u8 dc_bit : 1;
+    ExecutableBit executable_bit : 1;
+    DescriptorTypeBit type_bit : 1;
+    DescriptorPrivilegeLevel dpl_bit : 2;
+    PresentBit present_bit : 1;
+};
+static_assert(sizeof(AccessByte) == 1);
+
+struct PACK SystemSegmentAccessByte {
+    enum class DescriptorTypeBit : u8 {
+        kSystemSegment = 0,
+        kUsualSegment  = 1,
+    };
+
+    enum class DescriptorPrivilegeLevel : u8 {
+        kKernel = 0,
+        kRing1  = 1,
+        kRing2  = 2,
+        kUser   = 3,
+    };
+
+    enum class PresentBit : u8 {
+        kPresent    = 1,
+        kNotPresent = 0,
+    };
+
+    enum class ProtectedModeTypes : u8 {
+        kTSS16Bit     = 1,
+        kLDT          = 2,
+        kTSS16BitBusy = 3,
+        kTSS32Bit     = 9,
+        kTSS32BitBusy = 11,
+    };
+
+    enum class LongModeTypes : u8 {
+        kLDT     = 2,
+        kTSS     = 9,
+        kTSSBusy = 11,
+    };
+
+    u8 type : 4;
+    DescriptorTypeBit type_bit : 1;
+    DescriptorPrivilegeLevel dpl_bits : 2;
+    PresentBit present_bit : 1;
+};
+static_assert(sizeof(AccessByte) == 1);
+
+template <class AccessByteT = AccessByte>
+struct PACK GdtEntry {
+    enum class LongModeFlag : u8 {
+        kLongModeDisabled = 0,
+        kLongModeEnabled  = 1,
+    };
+
+    enum class SizeFlag : u8 {
+        k16BitMode = 0,
+        k32BitMode = 1,
+    };
+
+    enum class GranularityFlag : u8 {
+        kByteGranularity = 0,
+        kPageGranularity = 1,
+    };
+
+    struct PACK Flags {
+        u8 reserved : 1;
+        LongModeFlag long_mode_flag : 1;
+        SizeFlag size_flag : 1;
+        GranularityFlag granularity_flag : 1;
+    };
+
+    u16 limit;
+    u16 base;
+    u8 base_mid;
+    AccessByteT access;
+    u8 limit_high : 4;
+    u8 reserved : 1;
+    LongModeFlag long_mode_flag : 1;
+    SizeFlag size_flag : 1;
+    GranularityFlag granularity_flag : 1;
+    u8 base_high;
+};
+static_assert(sizeof(GdtEntry<>) == 8);
+static_assert(sizeof(GdtEntry<SystemSegmentAccessByte>) == 8);
+
+struct PACK GdtSystemSegmentDescriptor {
+    GdtEntry<SystemSegmentAccessByte> low;
+    u32 base_upper32;
+    u32 reserved;
+};
+static_assert(sizeof(GdtSystemSegmentDescriptor) == 16);
+
+struct PACK Gdtr {
+    u16 limit;
+    u64 base;
+};
+
+struct alignas(16) PACK GDT {
+    static constexpr u16 kKernelCodeSelector = 0x08;
+    static constexpr u16 kKernelDataSelector = 0x10;
+    static constexpr u16 kUserCodeSelector   = 0x18;
+    static constexpr u16 kUserDataSelector   = 0x20;
+    static constexpr u16 kTssSelector        = 0x28;
+
+    GdtEntry<> null_entry;
+    GdtEntry<> kernel_code;
+    GdtEntry<> kernel_data;
+    GdtEntry<> user_code;
+    GdtEntry<> user_data;
+    GdtSystemSegmentDescriptor tss_descriptor;
+};
+
+void DefaultEntryInit(GdtEntry<> &entry, AccessByte access, GdtEntry<>::Flags flags);
+void DefaultTssEntryInit(GdtSystemSegmentDescriptor &entry, u64 tss_address);
+void DefaultGdtInit(GDT &gdt, u64 tss_address);
+
+}  // namespace cpu
+
+#endif  // KERNEL_ARCH_X86_64_SRC_CPU_GDT_HPP_
diff --git a/kernel/arch/x86_64/src/cpu/gdt_flush.nasm b/kernel/arch/x86_64/src/cpu/gdt_flush.nasm
new file mode 100644
index 00000000..24de553f
--- /dev/null
+++ b/kernel/arch/x86_64/src/cpu/gdt_flush.nasm
@@ -0,0 +1,32 @@
+bits 64
+
+global GdtFlush
+
+section .text
+
+GdtFlush:
+    ; void GdtFlush(cpu::Gdtr* gdtr, u64 kernel_code_offset, u64 kernel_data_offset);
+    ; Layout:
+    ;  rdi = gdtr pointer
+    ;  rsi = kernel code selector
+    ;  rdx = kernel data selector
+    ;  rax = return address
+
+    lgdt [rdi] ; load new gdt
+
+    ; load data segments
+    mov ds, dx
+    mov es, dx
+    mov fs, dx
+    mov gs, dx
+    mov ss, dx
+
+    ; load code segments
+    push rsi
+    lea rax, [rel .next] ; push next label address on the stack to return nicely after far jump
+    push rax
+
+    retfq
+
+.next:
+    ret
diff --git a/kernel/arch/x86_64/src/cpu/tss.hpp b/kernel/arch/x86_64/src/cpu/tss.hpp
new file mode 100644
index 00000000..7386a81b
--- /dev/null
+++ b/kernel/arch/x86_64/src/cpu/tss.hpp
@@ -0,0 +1,25 @@
+#ifndef KERNEL_ARCH_X86_64_SRC_CPU_TSS_HPP_
+#define KERNEL_ARCH_X86_64_SRC_CPU_TSS_HPP_
+
+#include <defines.hpp>
+#include <types.hpp>
+
+namespace cpu
+{
+struct PACK TSS {
+    u32 reserved0;
+    u64 rsp0;
+    u64 rsp1;
+    u64 rsp2;
+    u64 reserved1;
+    u64 ist[7];
+    u64 reserved2;
+    u16 reserved3;
+    u16 iopb_offset;
+};
+
+FAST_CALL void LoadTss(u16 selector) { __asm__ volatile("ltr %0" : : "r"(selector) : "memory"); }
+
+}  // namespace cpu
+
+#endif  // KERNEL_ARCH_X86_64_SRC_CPU_TSS_HPP_
diff --git a/kernel/arch/x86_64/src/hal/impl/core.cpp b/kernel/arch/x86_64/src/hal/impl/core.cpp
index 730e02d0..485bc7f9 100644
--- a/kernel/arch/x86_64/src/hal/impl/core.cpp
+++ b/kernel/arch/x86_64/src/hal/impl/core.cpp
@@ -1,10 +1,30 @@
-#include <hal/impl/core.hpp>
+#include <hal/core.hpp>
 
+#include "cpu/gdt.hpp"
+#include "hardware/core_local.hpp"
 #include "trace_framework.hpp"
 
+extern "C" void GdtFlush(cpu::Gdtr *gdtr, u64 kernel_code_offset, u64 kernel_data_offset);
+
 using namespace arch;
 
 void Core::EnableCore()
 {
     // TODO:
 }
+
+void arch::InitializeCoreLocal()
+{
+    auto core_local = static_cast<hardware::CoreLocal *>(GetCoreLocalData());
+
+    cpu::DefaultGdtInit(core_local->gdt, reinterpret_cast<u64>(&core_local->tss));
+    core_local->gdtr.limit = sizeof(cpu::GDT) - 1;
+    core_local->gdtr.base  = reinterpret_cast<u64>(&core_local->gdt);
+
+    GdtFlush(&core_local->gdtr, cpu::GDT::kKernelCodeSelector, cpu::GDT::kKernelDataSelector);
+    cpu::LoadTss(cpu::GDT::kTssSelector);
+
+    DEBUG_INFO_HARDWARE(
+        "Successfully initialized GDT and TSS for core with id %hu", core_local->lid
+    );
+}
diff --git a/kernel/arch/x86_64/src/hal/impl/core.hpp b/kernel/arch/x86_64/src/hal/impl/core.hpp
index 76ce91d3..da10466b 100644
--- a/kernel/arch/x86_64/src/hal/impl/core.hpp
+++ b/kernel/arch/x86_64/src/hal/impl/core.hpp
@@ -2,6 +2,7 @@
 #define KERNEL_ARCH_X86_64_SRC_HAL_IMPL_CORE_HPP_
 
 #include <hal/api/core.hpp>
+#include "cpu/gdt.hpp"
 #include "cpu/msrs.hpp"
 #include "cpu/utils.hpp"
 #include "drivers/apic/local_apic.hpp"
@@ -9,12 +10,20 @@
 namespace arch
 {
 
+// ------------------------------
+// defines
+// ------------------------------
+
 static constexpr u32 kIa32GsBase = 0xC0000101;
 
 struct CoreConfig {
     u16 acpi_id;
 };
 
+// ------------------------------
+// arch::Core
+// ------------------------------
+
 class Core : public CoreAPI
 {
     public:
@@ -38,17 +47,57 @@ class Core : public CoreAPI
     protected:
 };
 
+// ------------------------------
+// arch::CoreController
+// ------------------------------
+
+class CoreController : public CoreControllerAPI
+{
+    public:
+    // ------------------------------
+    // Class creation
+    // ------------------------------
+
+    CoreController()  = default;
+    ~CoreController() = default;
+
+    // ------------------------------
+    // Class interaction
+    // ------------------------------
+
+    // ------------------------------
+    // Class fields
+    // ------------------------------
+
+    protected:
+};
+
+// ------------------------------
+// arch::CoreLocal
+// ------------------------------
+
+struct CoreLocal {
+    cpu::GDT gdt;
+    cpu::Gdtr gdtr;
+    cpu::TSS tss;
+};
+
+// ------------------------------
+// Helpers
+// ------------------------------
+
 NODISCARD WRAP_CALL u32 GetCurrentCoreId() { return LocalApic::GetCoreId(); }
 
 FAST_CALL void SetCoreLocalData(void *data)
+// note: Caller is responsible for disabling irqs during this function
 {
-    BlockHardwareInterrupts();
     cpu::SetMSR(kIa32GsBase, reinterpret_cast<u64>(data));
-    EnableHardwareInterrupts();
 }
 
 FAST_CALL void *GetCoreLocalData() { return reinterpret_cast<void *>(cpu::GetMSR(kIa32GsBase)); }
 
+void InitializeCoreLocal();
+
 }  // namespace arch
 
 #endif  // KERNEL_ARCH_X86_64_SRC_HAL_IMPL_CORE_HPP_
diff --git a/kernel/arch/x86_64/src/hal/impl/scheduling.hpp b/kernel/arch/x86_64/src/hal/impl/scheduling.hpp
new file mode 100644
index 00000000..a9e17a49
--- /dev/null
+++ b/kernel/arch/x86_64/src/hal/impl/scheduling.hpp
@@ -0,0 +1,13 @@
+#ifndef KERNEL_ARCH_X86_64_SRC_HAL_IMPL_SCHEDULING_HPP_
+#define KERNEL_ARCH_X86_64_SRC_HAL_IMPL_SCHEDULING_HPP_
+
+#include "scheduling/thread.hpp"
+
+extern "C" void SwitchToTask(Sched::Thread *thread);
+
+namespace arch
+{
+using ::SwitchToTask;
+}  // namespace arch
+
+#endif  // KERNEL_ARCH_X86_64_SRC_HAL_IMPL_SCHEDULING_HPP_
diff --git a/kernel/arch/x86_64/src/include/regs.nasm b/kernel/arch/x86_64/src/include/regs.nasm
new file mode 100644
index 00000000..b4878045
--- /dev/null
+++ b/kernel/arch/x86_64/src/include/regs.nasm
@@ -0,0 +1,97 @@
+; ------------------------------------------------------------
+; Register macros
+; ------------------------------------------------------------
+
+; Register offsets on the stack when saving the state
+_rax equ 0
+_rcx equ 8
+_rdx equ 16
+_rsi equ 24
+_rdi equ 32
+_r8  equ 40
+_r9  equ 48
+_r10 equ 56
+_r11 equ 64
+_rbp equ 72
+_rbx equ 80
+_r12 equ 88
+_r13 equ 96
+_r14 equ 104
+_r15 equ 112
+
+; Size needed to save the sysv registers on the stack
+_sysv_reg_size equ 8*10
+
+; Shadow space required for C++ function calls
+_shadow_space equ 8*4
+
+; Macro to save all volatile registers (SysV ABI) onto the stack.
+%macro push_sysv_regs 0
+    mov qword [rsp + _rax], rax
+    mov qword [rsp + _rcx], rcx
+    mov qword [rsp + _rdx], rdx
+    mov qword [rsp + _rsi], rsi
+    mov qword [rsp + _rdi], rdi
+    mov qword [rsp + _r8], r8
+    mov qword [rsp + _r9], r9
+    mov qword [rsp + _r10], r10
+    mov qword [rsp + _r11], r11
+    mov qword [rsp + _rbp], rbp
+%endmacro
+
+; Macro to restore all volatile registers (SysV ABI) from the stack.
+%macro pop_sysv_regs 0
+    mov rax, qword [rsp + _rax]
+    mov rcx, qword [rsp + _rcx]
+    mov rdx, qword [rsp + _rdx]
+    mov rsi, qword [rsp + _rsi]
+    mov rdi, qword [rsp + _rdi]
+    mov r8, qword [rsp + _r8]
+    mov r9, qword [rsp + _r9]
+    mov r10, qword [rsp + _r10]
+    mov r11, qword [rsp + _r11]
+    mov rbp, qword [rsp + _rbp]
+%endmacro
+
+; Size needed to save the registers on the stack
+_all_reg_size equ 8*15
+
+; Macro to save ALL general purpose registers onto the stack.
+; Useful for Interrupt Service Routines (ISRs) or kernel panic dumps.
+%macro push_all_regs 0
+    mov qword [rsp + _rax], rax
+    mov qword [rsp + _rcx], rcx
+    mov qword [rsp + _rdx], rdx
+    mov qword [rsp + _rsi], rsi
+    mov qword [rsp + _rdi], rdi
+    mov qword [rsp + _r8], r8
+    mov qword [rsp + _r9], r9
+    mov qword [rsp + _r10], r10
+    mov qword [rsp + _r11], r11
+    mov qword [rsp + _rbp], rbp
+    mov qword [rsp + _rbx], rbx
+    mov qword [rsp + _r12], r12
+    mov qword [rsp + _r13], r13
+    mov qword [rsp + _r14], r14
+    mov qword [rsp + _r15], r15
+%endmacro
+
+; Macro to restore ALL general purpose registers from the stack.
+; Must be called in the reverse order of push_all_regs.
+%macro pop_all_regs 0
+    mov rax, qword [rsp + _rax]
+    mov rcx, qword [rsp + _rcx]
+    mov rdx, qword [rsp + _rdx]
+    mov rsi, qword [rsp + _rsi]
+    mov rdi, qword [rsp + _rdi]
+    mov r8, qword [rsp + _r8]
+    mov r9, qword [rsp + _r9]
+    mov r10, qword [rsp + _r10]
+    mov r11, qword [rsp + _r11]
+    mov rbp, qword [rsp + _rbp]
+    mov rbx, qword [rsp + _rbx]
+    mov r12, qword [rsp + _r12]
+    mov r13, qword [rsp + _r13]
+    mov r14, qword [rsp + _r14]
+    mov r15, qword [rsp + _r15]
+%endmacro
diff --git a/kernel/arch/x86_64/src/include/thread.nasm b/kernel/arch/x86_64/src/include/thread.nasm
new file mode 100644
index 00000000..220ed410
--- /dev/null
+++ b/kernel/arch/x86_64/src/include/thread.nasm
@@ -0,0 +1,11 @@
+; ------------------------------------------------------------
+; Thread structure definition
+; ------------------------------------------------------------
+
+struc Thread
+    .tid:          resq 1
+    .owner:        resq 1
+    .next:         resq 1
+    .kernel_stack: resq 1
+    .user_stack:   resq 1
+endstruc
diff --git a/kernel/arch/x86_64/src/interrupts/idt.nasm b/kernel/arch/x86_64/src/interrupts/idt.nasm
index fc61e7d4..239beff3 100644
--- a/kernel/arch/x86_64/src/interrupts/idt.nasm
+++ b/kernel/arch/x86_64/src/interrupts/idt.nasm
@@ -2,99 +2,7 @@
 ; ISR with full GPR save/restore
 ; ------------------------------------
 
-; Register offsets on the stack when saving the state
-_rax equ 0
-_rcx equ 8
-_rdx equ 16
-_rsi equ 24
-_rdi equ 32
-_r8  equ 40
-_r9  equ 48
-_r10 equ 56
-_r11 equ 64
-_rbp equ 72
-_rbx equ 80
-_r12 equ 88
-_r13 equ 96
-_r14 equ 104
-_r15 equ 112
-
-; Size needed to save the sysv registers on the stack
-_sysv_reg_size equ 8*10
-
-; Shadow space required for C++ function calls
-_shadow_space equ 8*4
-
-; Macro to save all volatile registers (SysV ABI) onto the stack.
-%macro push_sysv_regs 0
-    mov qword [rsp + _rax], rax
-    mov qword [rsp + _rcx], rcx
-    mov qword [rsp + _rdx], rdx
-    mov qword [rsp + _rsi], rsi
-    mov qword [rsp + _rdi], rdi
-    mov qword [rsp + _r8], r8
-    mov qword [rsp + _r9], r9
-    mov qword [rsp + _r10], r10
-    mov qword [rsp + _r11], r11
-    mov qword [rsp + _rbp], rbp
-%endmacro
-
-; Macro to restore all volatile registers (SysV ABI) from the stack.
-%macro pop_sysv_regs 0
-    mov rax, qword [rsp + _rax]
-    mov rcx, qword [rsp + _rcx]
-    mov rdx, qword [rsp + _rdx]
-    mov rsi, qword [rsp + _rsi]
-    mov rdi, qword [rsp + _rdi]
-    mov r8, qword [rsp + _r8]
-    mov r9, qword [rsp + _r9]
-    mov r10, qword [rsp + _r10]
-    mov r11, qword [rsp + _r11]
-    mov rbp, qword [rsp + _rbp]
-%endmacro
-
-; Size needed to save the registers on the stack
-_all_reg_size equ 8*15
-
-; Macro to save ALL general purpose registers onto the stack.
-; Useful for Interrupt Service Routines (ISRs) or kernel panic dumps.
-%macro push_all_regs 0
-    mov qword [rsp + _rax], rax
-    mov qword [rsp + _rcx], rcx
-    mov qword [rsp + _rdx], rdx
-    mov qword [rsp + _rsi], rsi
-    mov qword [rsp + _rdi], rdi
-    mov qword [rsp + _r8], r8
-    mov qword [rsp + _r9], r9
-    mov qword [rsp + _r10], r10
-    mov qword [rsp + _r11], r11
-    mov qword [rsp + _rbp], rbp
-    mov qword [rsp + _rbx], rbx
-    mov qword [rsp + _r12], r12
-    mov qword [rsp + _r13], r13
-    mov qword [rsp + _r14], r14
-    mov qword [rsp + _r15], r15
-%endmacro
-
-; Macro to restore ALL general purpose registers from the stack.
-; Must be called in the reverse order of push_all_regs.
-%macro pop_all_regs 0
-    mov rax, qword [rsp + _rax]
-    mov rcx, qword [rsp + _rcx]
-    mov rdx, qword [rsp + _rdx]
-    mov rsi, qword [rsp + _rsi]
-    mov rdi, qword [rsp + _rdi]
-    mov r8, qword [rsp + _r8]
-    mov r9, qword [rsp + _r9]
-    mov r10, qword [rsp + _r10]
-    mov r11, qword [rsp + _r11]
-    mov rbp, qword [rsp + _rbp]
-    mov rbx, qword [rsp + _rbx]
-    mov r12, qword [rsp + _r12]
-    mov r13, qword [rsp + _r13]
-    mov r14, qword [rsp + _r14]
-    mov r15, qword [rsp + _r15]
-%endmacro
+%include "include/regs.nasm"
 
 ; Macro for CPU exceptions that DO NOT push an error code.
 ; A dummy error code is pushed to create a consistent stack frame.
diff --git a/kernel/arch/x86_64/src/kernel/init.cpp b/kernel/arch/x86_64/src/kernel/init.cpp
index 8ece59b7..847b175f 100644
--- a/kernel/arch/x86_64/src/kernel/init.cpp
+++ b/kernel/arch/x86_64/src/kernel/init.cpp
@@ -67,7 +67,9 @@ void ArchInit(const RawBootArguments &)
     HardwareModule::Init();
     HardwareModule::Get().GetInterrupts().FirstStageInit();
 
-    cpu::SetMSR(kIa32GsBase, reinterpret_cast<u64>(&g_CoreLocal));
+    hal::SetCoreLocalData(&g_CoreLocal);
+    InitializeCoreLocal();
+
     EnableHardwareInterrupts();
 
     DEBUG_INFO_BOOT("Leaving ArchInit");
diff --git a/kernel/arch/x86_64/src/scheduling/scheduling.nasm b/kernel/arch/x86_64/src/scheduling/scheduling.nasm
new file mode 100644
index 00000000..c2c52717
--- /dev/null
+++ b/kernel/arch/x86_64/src/scheduling/scheduling.nasm
@@ -0,0 +1,52 @@
+; ------------------------------------------------------------
+; Scheduling utilities and crucial functionality
+; ------------------------------------------------------------
+
+%include "include/regs.nasm"
+%include "include/thread.nasm"
+
+bits 64
+
+extern cdecl_GetCurrentTCB
+extern cdecl_SetCurrentTCB
+extern cdecl_GetThreadsPageTable
+
+section .text
+global SwitchToTask
+
+; c_decl
+; void SwitchToTask(Thread* thread)q
+;   RDI = thread
+; Note: Caller is responsible for ensuring proper environment before calling (disabling IRQs)
+; Layout:
+;   RAX = current TCB
+;   RDI = next TCB
+;   R10 = next cr3
+;   R11 = next kernel stack | current cr3
+SwitchToTask:
+    ; ------------------------
+    ; Save current task state
+
+    sub rsp, _sysv_reg_size          ; Allocate space for saving registers.
+    push_sysv_regs                   ; Save registers of calling TCB on ITS stack
+
+    call cdecl_GetCurrentTCB         ; RAX = pointer to TCB
+    mov [rax+Thread.user_stack], esp ; Save ESP for previous task's kernel stack in the thread's TCB
+
+    ; ------------------------
+    ; Setup next task state
+
+    call cdecl_SetCurrentTCB           ; Next task TCB already in RDI
+    mov esp, [rdi+Thread.user_stack]   ; Change the stack
+    mov r11, [rdi+Thread.kernel_stack] ; Load next task's kernel stack
+;    mov [TSS.ESP0]
+
+;    call cdecl_GetThreadsPageTable   ; RAX = next cr3
+
+
+.done:
+
+    pop_sysv_regs                    ; Restore registers of NEW thread's stack
+    add rsp, _sysv_reg_size          ; Deallocate register save space.
+
+    ret ; Load next thread's EIP from its kernel stack
diff --git a/kernel/arch/x86_64/src/tests/interrupts_tests.cpp b/kernel/arch/x86_64/src/tests/interrupts_tests.cpp
index 2c4fdaf3..4d6d61a6 100644
--- a/kernel/arch/x86_64/src/tests/interrupts_tests.cpp
+++ b/kernel/arch/x86_64/src/tests/interrupts_tests.cpp
@@ -27,7 +27,7 @@ static void PolluteAllRegistersSw(intr::LitSwEntry &)
 
 static DumpedRegisters g_DumpedRegisters{};
 
-static void DivZeroExceptionHandler(intr::LitExcEntry &entry, hal::ExceptionData *data)
+static void DivZeroExceptionHandler(intr::LitExcEntry &, hal::ExceptionData *data)
 {
     g_DumpedRegisters.rax = data->registers.rax;
     g_DumpedRegisters.rbx = data->registers.rbx;
diff --git a/kernel/src/constants.hpp b/kernel/src/constants.hpp
new file mode 100644
index 00000000..f4c8ad7e
--- /dev/null
+++ b/kernel/src/constants.hpp
@@ -0,0 +1,12 @@
+#ifndef KERNEL_SRC_CONSTANTS_HPP_
+#define KERNEL_SRC_CONSTANTS_HPP_
+
+#include "types.hpp"
+
+static constexpr u16 kMaxProcesses    = 4096;
+static constexpr u32 kMaxThreads      = kMaxProcesses * 2;
+static constexpr u32 kStackSize       = 64 * 1024;  // TODO 8 meg
+static constexpr u32 kKernelStackSize = 64 * 1024;  // TODO 1 meg
+static constexpr u32 kStackAlignment  = 64;
+
+#endif  // KERNEL_SRC_CONSTANTS_HPP_
diff --git a/kernel/src/cores.cpp b/kernel/src/cores.cpp
index f80402c7..7cc34765 100644
--- a/kernel/src/cores.cpp
+++ b/kernel/src/cores.cpp
@@ -50,6 +50,13 @@ void hardware::CoresController::BootUpAllCores()
     DEBUG_INFO_INTERRUPTS("Booting up all cores...");
 
     for (auto &core : core_arr_) {
+        if (core.IsEnabled()) {
+            DEBUG_INFO_BOOT(
+                "Core with id: %hu is alreday enabled. Skipping init...", core.GetLId()
+            );
+            continue;
+        }
+
         core.EnableCore();
     }
 
diff --git a/kernel/src/hal/api/core.hpp b/kernel/src/hal/api/core.hpp
index 83bf68ed..033c2141 100644
--- a/kernel/src/hal/api/core.hpp
+++ b/kernel/src/hal/api/core.hpp
@@ -13,6 +13,9 @@ struct CoreAPI {
     void EnableCore();
 };
 
+struct CoreControllerAPI {
+};
+
 NODISCARD WRAP_CALL u32 GetCurrentCoreId();
 
 }  // namespace arch
diff --git a/kernel/src/hal/core.hpp b/kernel/src/hal/core.hpp
index 12b608d7..c9b9c4d8 100644
--- a/kernel/src/hal/core.hpp
+++ b/kernel/src/hal/core.hpp
@@ -7,6 +7,8 @@ namespace hal
 {
 using arch::Core;
 using arch::CoreConfig;
+using arch::CoreController;
+using arch::CoreLocal;
 
 NODISCARD WRAP_CALL u32 GetCurrentCoreId() { return arch::GetCurrentCoreId(); }
 WRAP_CALL void SetCoreLocalData(void *data) { arch::SetCoreLocalData(data); }
diff --git a/kernel/src/hal/scheduling.hpp b/kernel/src/hal/scheduling.hpp
new file mode 100644
index 00000000..6f0030ee
--- /dev/null
+++ b/kernel/src/hal/scheduling.hpp
@@ -0,0 +1,14 @@
+#ifndef KERNEL_SRC_HAL_SCHEDULING_HPP_
+#define KERNEL_SRC_HAL_SCHEDULING_HPP_
+
+#include "defines.hpp"
+#include "scheduling/thread.hpp"
+
+#include "hal/impl/scheduling.hpp"
+
+namespace hal
+{
+WRAP_CALL void SwitchToTask(Sched::Thread *thread) { arch::SwitchToTask(thread); }
+}  // namespace hal
+
+#endif  // KERNEL_SRC_HAL_SCHEDULING_HPP_
diff --git a/kernel/src/hardware/core_controller.hpp b/kernel/src/hardware/core_controller.hpp
index ac9b1ab7..c4b42748 100644
--- a/kernel/src/hardware/core_controller.hpp
+++ b/kernel/src/hardware/core_controller.hpp
@@ -8,7 +8,7 @@
 namespace hardware
 {
 
-class CoresController final
+class CoresController final : public hal::CoreController
 {
     public:
     using CoreTable      = alloca::DynArray<Core>;
diff --git a/kernel/src/hardware/core_local.cpp b/kernel/src/hardware/core_local.cpp
new file mode 100644
index 00000000..96186344
--- /dev/null
+++ b/kernel/src/hardware/core_local.cpp
@@ -0,0 +1,4 @@
+#include "core_local.hpp"
+
+Sched::Thread *cdecl_GetCurrentTCB() { return hardware::GetCurrentTCB(); }
+void cdecl_SetCurrentTCB(Sched::Thread *tcb) { hardware::SetCurrentTCB(tcb); }
diff --git a/kernel/src/hardware/core_local.hpp b/kernel/src/hardware/core_local.hpp
index 7e8f7368..cf33a4b0 100644
--- a/kernel/src/hardware/core_local.hpp
+++ b/kernel/src/hardware/core_local.hpp
@@ -3,18 +3,29 @@
 
 #include "hal/constants.hpp"
 #include "hal/core.hpp"
+#include "scheduling/thread.hpp"
 
 namespace hardware
 {
-struct alignas(hal::kCacheLineSizeBytes) CoreLocal {
-    u8 nested_interrupts{};
-    u16 lid{};
+struct alignas(hal::kCacheLineSizeBytes) CoreLocal : hal::CoreLocal {
+    u8 nested_interrupts;
+    u16 lid;
+
+    Sched::Thread *thread_control_block;
 };
 
 FAST_CALL CoreLocal &GetCoreLocalData()
 {
     return *static_cast<CoreLocal *>(hal::GetCoreLocalData());
 }
+
+FAST_CALL Sched::Thread *GetCurrentTCB() { return GetCoreLocalData().thread_control_block; }
+
+FAST_CALL void SetCurrentTCB(Sched::Thread *tcb) { GetCoreLocalData().thread_control_block = tcb; }
+
 }  // namespace hardware
 
+extern "C" Sched::Thread *cdecl_GetCurrentTCB();
+extern "C" void cdecl_SetCurrentTCB(Sched::Thread *tcb);
+
 #endif  // KERNEL_SRC_HARDWARE_CORE_LOCAL_HPP_
diff --git a/kernel/src/init.cpp b/kernel/src/init.cpp
index 62eb4a7b..6007fc42 100644
--- a/kernel/src/init.cpp
+++ b/kernel/src/init.cpp
@@ -9,6 +9,7 @@
 #include "modules/global_state.hpp"
 #include "modules/hardware.hpp"
 #include "modules/memory.hpp"
+#include "modules/scheduling.hpp"
 #include "modules/timing.hpp"
 #include "modules/vfs.hpp"
 #include "modules/video.hpp"
@@ -47,11 +48,14 @@ void KernelInit(const hal::RawBootArguments &raw_args)
     /* Initialize the timing system */
     TimingModule::Init();
 
-    VfsModule::Init(args);
-
-    VideoModule::Init(args, MemoryModule::Get().GetHeap());
-
     // Register Interrupts
-    MemoryModule::Get().RegisterPageFault(HardwareModule::Get());
     HardwareModule::Get().RegisterInterruptHandlers();
+
+    SchedulingModule::Init();
+    SchedulingModule::Get().GetTaskMgr().InitializeMultitasking();
+
+    HardwareModule::Get().GetCoresController().BootUpAllCores();
+
+    VfsModule::Init(args);
+    VideoModule::Init(args, MemoryModule::Get().GetHeap());
 }
diff --git a/kernel/src/mem/error.hpp b/kernel/src/mem/error.hpp
index 746774ef..bbc61280 100644
--- a/kernel/src/mem/error.hpp
+++ b/kernel/src/mem/error.hpp
@@ -12,4 +12,18 @@ enum class MemError {
 
 }  // namespace Mem
 
+static constexpr const char *to_string(const Mem::MemError &error)
+{
+    switch (error) {
+        case Mem::MemError::OutOfMemory:
+            return "OutOfMemory";
+        case Mem::MemError::NotFound:
+            return "NotFound";
+        case Mem::MemError::InvalidArgument:
+            return "InvalidArgument";
+    }
+
+    return "unknown error";
+}
+
 #endif  // KERNEL_SRC_MEM_ERROR_HPP_
diff --git a/kernel/src/mem/phys/mngr/buddy.hpp b/kernel/src/mem/phys/mngr/buddy.hpp
index ab67bf03..18b9ff47 100644
--- a/kernel/src/mem/phys/mngr/buddy.hpp
+++ b/kernel/src/mem/phys/mngr/buddy.hpp
@@ -1,6 +1,7 @@
 #ifndef KERNEL_SRC_MEM_PHYS_MNGR_BUDDY_HPP_
 #define KERNEL_SRC_MEM_PHYS_MNGR_BUDDY_HPP_
 
+#include <bit.hpp>
 #include <expected.hpp>
 #include <types.hpp>
 
@@ -50,7 +51,7 @@ class BuddyPmm
         // __builtin_clzll returns the number of zero bits before the first '1'.
         // sizeof(long long) * 8 is the total width (usually 64).
         size_t pages_needed = (size_bytes - 1) >> hal::kPageShift;
-        return static_cast<u8>((sizeof(long long) * 8) - __builtin_clzll(pages_needed));
+        return static_cast<u8>((sizeof(size_t) * 8) - std::countl_zero(pages_needed));
     }
 
     static constexpr size_t BuddyAreaSize(u8 order)
diff --git a/kernel/src/modules/hardware.cpp b/kernel/src/modules/hardware.cpp
index 831977db..1cbc11eb 100644
--- a/kernel/src/modules/hardware.cpp
+++ b/kernel/src/modules/hardware.cpp
@@ -1,4 +1,5 @@
 #include "modules/hardware.hpp"
+#include "modules/memory.hpp"
 
 #include "trace_framework.hpp"
 
@@ -20,4 +21,6 @@ void internal::HardwareModule::RegisterInterruptHandlers()
     GetInterrupts().GetLit().InstallInterruptHandler<intr::InterruptType::kHardwareInterrupt>(
         1, intr::HwHandler{.handler = Ps2KeyboardHandler}
     );
+
+    ::MemoryModule::Get().RegisterPageFault(::HardwareModule::Get());
 }
diff --git a/kernel/src/modules/scheduling.hpp b/kernel/src/modules/scheduling.hpp
new file mode 100644
index 00000000..7aeda93a
--- /dev/null
+++ b/kernel/src/modules/scheduling.hpp
@@ -0,0 +1,36 @@
+#ifndef KERNEL_SRC_MODULES_SCHEDULING_HPP_
+#define KERNEL_SRC_MODULES_SCHEDULING_HPP_
+
+#include <template_lib.hpp>
+
+#include "modules/helpers.hpp"
+#include "scheduling/processes.hpp"
+#include "scheduling/task_mgr.hpp"
+#include "scheduling/threads.hpp"
+
+namespace internal
+{
+class SchedulingModule : template_lib::StaticSingletonHelper
+{
+    // -------------------------------------
+    // Protected singleton constructor
+    // -------------------------------------
+
+    protected:
+    SchedulingModule() noexcept = default;
+
+    // ------------------------------
+    // Module fields
+    // ------------------------------
+
+    DEFINE_MODULE_FIELD(Sched, Processes)
+    DEFINE_MODULE_FIELD(Sched, Threads)
+    DEFINE_MODULE_FIELD(Sched, TaskMgr)
+
+    public:
+};
+}  // namespace internal
+
+using SchedulingModule = template_lib::StaticSingleton<internal::SchedulingModule>;
+
+#endif  // KERNEL_SRC_MODULES_SCHEDULING_HPP_
diff --git a/kernel/src/scheduling/error.hpp b/kernel/src/scheduling/error.hpp
new file mode 100644
index 00000000..3293c847
--- /dev/null
+++ b/kernel/src/scheduling/error.hpp
@@ -0,0 +1,34 @@
+#ifndef KERNEL_SRC_SCHEDULING_ERROR_HPP_
+#define KERNEL_SRC_SCHEDULING_ERROR_HPP_
+
+#include <assert.h>
+
+namespace Sched
+{
+
+enum class Error {
+    OutOfMemory,
+    ExceededMaxAllowedInstances,
+    ProcessNotFound,
+    ThreadNotFound,
+};
+
+}  // namespace Sched
+
+static constexpr const char *to_string(const Sched::Error &error)
+{
+    switch (error) {
+        case Sched::Error::OutOfMemory:
+            return "OutOfMemory";
+        case Sched::Error::ExceededMaxAllowedInstances:
+            return "ExceededMaxAllowedInstances";
+        case Sched::Error::ProcessNotFound:
+            return "ProcessNotFound";
+        case Sched::Error::ThreadNotFound:
+            return "ThreadNotFound";
+    }
+
+    return "unknown error";
+}
+
+#endif  // KERNEL_SRC_SCHEDULING_ERROR_HPP_
diff --git a/kernel/src/scheduling/process.hpp b/kernel/src/scheduling/process.hpp
new file mode 100644
index 00000000..a568a46d
--- /dev/null
+++ b/kernel/src/scheduling/process.hpp
@@ -0,0 +1,25 @@
+#ifndef KERNEL_SRC_SCHEDULING_PROCESS_HPP_
+#define KERNEL_SRC_SCHEDULING_PROCESS_HPP_
+
+#include <defines.hpp>
+#include <types.hpp>
+
+#include "mem/virt/addr_space.hpp"
+
+namespace Sched
+{
+struct PACK Pid {
+    u16 id;
+    u64 count : 48;
+};
+
+struct Process {
+    /* Management */
+    Pid pid;
+
+    /* Process resources */
+    Mem::VirtualPtr<Mem::AddressSpace> address_space;
+};
+}  // namespace Sched
+
+#endif  // KERNEL_SRC_SCHEDULING_PROCESS_HPP_
diff --git a/kernel/src/scheduling/processes.cpp b/kernel/src/scheduling/processes.cpp
new file mode 100644
index 00000000..5b3b53c1
--- /dev/null
+++ b/kernel/src/scheduling/processes.cpp
@@ -0,0 +1,26 @@
+#include "processes.hpp"
+#include "error.hpp"
+
+// ------------------------------
+// statics
+// ------------------------------
+
+// ------------------------------
+// Implementations
+// ------------------------------
+
+std::expected<Sched::Process *, Sched::Error> Sched::Processes::PrepareProcess()
+{
+    const size_t idx = processes_.Allocate();
+
+    if (idx == std::numeric_limits<size_t>::max()) {
+        return std::unexpected(Error::ExceededMaxAllowedInstances);
+    }
+
+    Process *process = processes_.Get(idx);
+
+    ASSERT_LE(idx, std::numeric_limits<u16>::max());
+    process->pid = AssignNewPid(static_cast<u16>(idx));
+
+    return process;
+}
diff --git a/kernel/src/scheduling/processes.hpp b/kernel/src/scheduling/processes.hpp
new file mode 100644
index 00000000..d62f4322
--- /dev/null
+++ b/kernel/src/scheduling/processes.hpp
@@ -0,0 +1,80 @@
+#ifndef KERNEL_SRC_SCHEDULING_PROCESSES_HPP_
+#define KERNEL_SRC_SCHEDULING_PROCESSES_HPP_
+
+#include <data_structures/hash_maps.hpp>
+#include <expected.hpp>
+#include <todo.hpp>
+
+#include "constants.hpp"
+#include "hal/sync.hpp"
+#include "scheduling/error.hpp"
+#include "scheduling/process.hpp"
+
+#include <trace_framework.hpp>
+
+namespace Sched
+{
+class Processes
+{
+    public:
+    // ------------------------------
+    // Class creation
+    // ------------------------------
+
+    Processes()  = default;
+    ~Processes() = default;
+
+    // ------------------------------
+    // Class interaction
+    // ------------------------------
+
+    NODISCARD std::expected<Process *, Error> PrepareProcess();
+
+    NODISCARD FORCE_INLINE_F std::expected<Process *, Error> GetProcess(const Pid pid)
+    {
+        const u16 id = pid.id;
+        auto ptr     = processes_.Get(id);
+
+        if (ptr == nullptr) {
+            return std::unexpected(Error::ProcessNotFound);
+        }
+
+        return ptr;
+    }
+
+    FORCE_INLINE_F std::expected<void, Error> Free(const Pid pid)
+    {
+        const u16 id = pid.id;
+
+        if (processes_.Get(id) == nullptr) {
+            return std::unexpected(Error::ProcessNotFound);
+        }
+
+        processes_.Free(id);
+        return {};
+    }
+
+    // ------------------------------
+    // Private methods
+    // ------------------------------
+
+    protected:
+    NODISCARD FORCE_INLINE_F Pid AssignNewPid(const u16 id)
+    {
+        Pid pid{};
+        pid.id    = id;
+        pid.count = hal::AtomicIncrement(&process_counter_) - 1;
+
+        return pid;
+    }
+
+    // ------------------------------
+    // Class fields
+    // ------------------------------
+
+    data_structures::PooledHashMap<Process, kMaxProcesses> processes_{};
+    hal::Atomic64 process_counter_{};
+};
+}  // namespace Sched
+
+#endif  // KERNEL_SRC_SCHEDULING_PROCESSES_HPP_
diff --git a/kernel/src/scheduling/task_mgr.cpp b/kernel/src/scheduling/task_mgr.cpp
new file mode 100644
index 00000000..4b6b19ff
--- /dev/null
+++ b/kernel/src/scheduling/task_mgr.cpp
@@ -0,0 +1,147 @@
+#include <template/scope_guard.hpp>
+
+#include "modules/memory.hpp"
+#include "modules/scheduling.hpp"
+#include "task_mgr.hpp"
+#include "trace_framework.hpp"
+
+#include "hal/scheduling.hpp"
+
+// ------------------------------
+// statics
+// ------------------------------
+
+// ------------------------------
+// Implementations
+// ------------------------------
+
+namespace Sched
+{
+void TaskMgr::InitializeMultitasking()
+{
+    // Spawn 3 Kernel Workers
+    static constexpr size_t kNumKWorkers = 3;
+    for (size_t i = 0; i < kNumKWorkers; ++i) {
+        auto result = SpawnProcess();
+        R_ASSERT_TRUE(
+            static_cast<bool>(result),
+            "Failed to spawn kernel workers. Not enough resources for the system"
+        );
+
+        TRACE_INFO_SCHEDULING(
+            "Created initial Kernel Worker process with Pid: %llu", result.value()
+        );
+    }
+}
+
+std::expected<Pid, Error> TaskMgr::SpawnProcess()
+{
+    bool dismiss = false;
+
+    // 1. Prepare internal structure for the process
+    auto process = SchedulingModule::Get().GetProcesses().PrepareProcess();
+    if (!process) {
+        DEBUG_WARN_SCHEDULING(
+            "Failed to create process. Failed on struct allocation: %s", to_string(process.error())
+        );
+        return std::unexpected(process.error());
+    }
+    template_lib::BatchedScopeGuard process_guard(dismiss, [&]() {
+        [[maybe_unused]] const auto result =
+            SchedulingModule::Get().GetProcesses().Free(process.value()->pid);
+        ASSERT_TRUE(static_cast<bool>(result));
+    });
+
+    // 2. Fill process data and resources - TODO: replace with proper one
+    TODO_WHEN_VMEM_WORKS
+    process.value()->address_space = &MemoryModule::Get().GetKernelAddressSpace();
+    // auto addr_space = MemoryModule::Get().GetVmm().CreateAddrSpace();
+    // if (!addr_space) {
+    //     DEBUG_WARN_SCHEDULING(
+    //         "Failed to create process. Failed on AddressSpace creation: %s",
+    //         template_lib::to_string(addr_space.error()).data()
+    //     );
+    //     return std::unexpected(Error::OutOfMemory);
+    // }
+    // process.value()->address_space = addr_space.value();
+    // template_lib::BatchedScopeGuard addr_space_guard(dismiss, [&]() {
+    //     [[maybe_unused]] const auto result =
+    //         MemoryModule::Get().GetVmm().DestroyAddrSpace(addr_space.value());
+    //     ASSERT_TRUE(static_cast<bool>(result));
+    // });
+
+    // 3. Spawn first thread
+    const auto tid = SpawnThread(process.value()->pid);
+    if (!tid) {
+        DEBUG_WARN_SCHEDULING(
+            "Failed to create process. Failed on initial thread creation: %s",
+            to_string(tid.error())
+        );
+        return std::unexpected(tid.error());
+    }
+
+    // 4. Add to scheduler - TODO
+
+    DEBUG_INFO_SCHEDULING(
+        "Created process with pid: %llu, and initial thread with tid: %llu", process.value()->pid,
+        tid.value()
+    );
+
+    dismiss = true;
+    return process.value()->pid;
+}
+
+std::expected<Tid, Error> TaskMgr::SpawnThread(const Pid pid)
+{
+    bool dismiss = false;
+
+    // 1. Prepare internal structure for execution unit - thread:
+    auto thread = SchedulingModule::Get().GetThreads().PrepareThread();
+    if (!thread) {
+        DEBUG_WARN_SCHEDULING(
+            "Failed to create thread for %llu. Failed on struct allocation: %s", pid,
+            to_string(thread.error())
+        );
+
+        return std::unexpected(thread.error());
+    }
+    template_lib::BatchedScopeGuard thread_guard(dismiss, [&]() {
+        [[maybe_unused]] const auto result =
+            SchedulingModule::Get().GetThreads().Free(thread.value()->tid);
+        ASSERT_TRUE(static_cast<bool>(result));
+    });
+
+    // 2. Allocate process resources and prepare the struct
+    thread.value()->owner = pid;
+
+    // 2.1 Kernel Stack
+    const auto kernel_stack = Mem::KMallocAligned({kKernelStackSize, kStackAlignment});
+    if (!kernel_stack) {
+        DEBUG_WARN_SCHEDULING(
+            "Failed to create thread for %llu. Failed on kernel stack allocation: %s", pid,
+            to_string(kernel_stack.error())
+        );
+
+        return std::unexpected(Error::OutOfMemory);
+    }
+    template_lib::BatchedScopeGuard esp0_guard(dismiss, [&]() {
+        Mem::KFreeAligned(kernel_stack.value());
+    });
+    thread.value()->kernel_stack = kernel_stack.value();
+
+    // 2.2 Thread Stack
+    const auto thread_stack = Mem::KMallocAligned({kStackSize, kStackAlignment});
+    if (!thread_stack) {
+        DEBUG_WARN_SCHEDULING(
+            "Failed to create thread for %llu. Failed on thread stack allocation: %s", pid,
+            to_string(thread_stack.error())
+        );
+
+        return std::unexpected(Error::OutOfMemory);
+    }
+    thread.value()->user_stack = thread_stack.value();
+
+    dismiss = true;
+    return thread.value()->tid;
+}
+}  // namespace Sched
diff --git a/kernel/src/scheduling/task_mgr.hpp b/kernel/src/scheduling/task_mgr.hpp
new file mode 100644
index 00000000..c6eb8621
--- /dev/null
+++ b/kernel/src/scheduling/task_mgr.hpp
@@ -0,0 +1,42 @@
+#ifndef KERNEL_SRC_SCHEDULING_TASK_MGR_HPP_
+#define KERNEL_SRC_SCHEDULING_TASK_MGR_HPP_
+
+#include <expected.hpp>
+#include "error.hpp"
+#include "process.hpp"
+#include "thread.hpp"
+
+namespace Sched
+{
+class TaskMgr
+{
+    public:
+    // ------------------------------
+    // Class creation
+    // ------------------------------
+
+    TaskMgr()  = default;
+    ~TaskMgr() = default;
+
+    // ------------------------------
+    // Class interaction
+    // ------------------------------
+
+    void InitializeMultitasking();
+
+    NODISCARD std::expected<Pid, Error> SpawnProcess();
+
+    NODISCARD std::expected<Tid, Error> SpawnThread(Pid pid);
+
+    // ------------------------------
+    // Private methods
+    // ------------------------------
+
+    protected:
+    // ------------------------------
+    // Class fields
+    // ------------------------------
+};
+}  // namespace Sched
+
+#endif  // KERNEL_SRC_SCHEDULING_TASK_MGR_HPP_
diff --git a/kernel/src/scheduling/thread.hpp b/kernel/src/scheduling/thread.hpp
new file mode 100644
index 00000000..6b5a67ca
--- /dev/null
+++ b/kernel/src/scheduling/thread.hpp
@@ -0,0 +1,31 @@
+#ifndef KERNEL_SRC_SCHEDULING_THREAD_HPP_
+#define KERNEL_SRC_SCHEDULING_THREAD_HPP_
+
+#include <defines.hpp>
+#include <types.hpp>
+
+#include "process.hpp"
+
+namespace Sched
+{
+
+struct PACK Tid {
+    u16 id;
+    u64 count : 48;
+};
+
+struct PACK Thread {
+    /* Management */
+    Tid tid;
+    Pid owner;
+
+    /* Scheduler data */
+    Thread *next;
+
+    /* Thread resources */
+    void *kernel_stack;
+    void *user_stack;
+};
+}  // namespace Sched
+
+#endif  // KERNEL_SRC_SCHEDULING_THREAD_HPP_
diff --git a/kernel/src/scheduling/threads.cpp b/kernel/src/scheduling/threads.cpp
new file mode 100644
index 00000000..7678615e
--- /dev/null
+++ b/kernel/src/scheduling/threads.cpp
@@ -0,0 +1,28 @@
+#include "threads.hpp"
+#include "modules/scheduling.hpp"
+
+std::expected<Sched::Thread *, Sched::Error> Sched::Threads::PrepareThread()
+{
+    const size_t idx = threads_.Allocate();
+
+    if (idx == std::numeric_limits<size_t>::max()) {
+        return std::unexpected(Error::ExceededMaxAllowedInstances);
+    }
+
+    Thread *thread = threads_.Get(idx);
+
+    ASSERT_LE(idx, std::numeric_limits<u16>::max());
+    thread->tid = AssignNewTid(static_cast<u16>(idx));
+
+    return thread;
+}
+
+void *cdecl_GetThreadsPageTable(Sched::Thread *thread)
+{
+    ASSERT_NOT_NULL(thread);
+
+    const auto proc = SchedulingModule::Get().GetProcesses().GetProcess(thread->owner);
+    ASSERT_TRUE(static_cast<bool>(proc), "Threads exists -> owner MUST exist");
+
+    return proc.value()->address_space->PageTableRoot();
+}
diff --git a/kernel/src/scheduling/threads.hpp b/kernel/src/scheduling/threads.hpp
new file mode 100644
index 00000000..62004d99
--- /dev/null
+++ b/kernel/src/scheduling/threads.hpp
@@ -0,0 +1,81 @@
+#ifndef KERNEL_SRC_SCHEDULING_THREADS_HPP_
+#define KERNEL_SRC_SCHEDULING_THREADS_HPP_
+
+#include <data_structures/hash_maps.hpp>
+#include <defines.hpp>
+#include <expected.hpp>
+#include <hal/sync.hpp>
+
+#include "constants.hpp"
+#include "error.hpp"
+#include "scheduling/thread.hpp"
+
+namespace Sched
+{
+class Threads
+{
+    public:
+    // ------------------------------
+    // Class creation
+    // ------------------------------
+
+    Threads()  = default;
+    ~Threads() = default;
+
+    // ------------------------------
+    // Class interaction
+    // ------------------------------
+
+    std::expected<Thread *, Error> PrepareThread();
+
+    NODISCARD FORCE_INLINE_F std::expected<Thread *, Error> GetThread(const Tid tid)
+    {
+        const u16 id = tid.id;
+        auto ptr     = threads_.Get(id);
+
+        if (ptr == nullptr) {
+            return std::unexpected(Error::ThreadNotFound);
+        }
+
+        return ptr;
+    }
+
+    FORCE_INLINE_F std::expected<void, Error> Free(const Tid tid)
+    {
+        const u16 id = tid.id;
+
+        if (threads_.Get(id) == nullptr) {
+            return std::unexpected(Error::ThreadNotFound);
+        }
+
+        threads_.Free(id);
+        return {};
+    }
+
+    // ------------------------------
+    // Private methods
+    // ------------------------------
+
+    protected:
+    NODISCARD FORCE_INLINE_F Tid AssignNewTid(const u16 id)
+    {
+        Tid tid{};
+        tid.id    = id;
+        tid.count = hal::AtomicIncrement(&thread_counter_) - 1;
+
+        return tid;
+    }
+
+    // ------------------------------
+    // Class fields
+    // ------------------------------
+
+    data_structures::PooledHashMap<Thread, kMaxThreads> threads_{};
+    hal::Atomic64 thread_counter_{};
+};
+
+extern "C" void *cdecl_GetThreadsPageTable(Thread *thread);
+
+}  // namespace Sched
+
+#endif  // KERNEL_SRC_SCHEDULING_THREADS_HPP_
diff --git a/kernel/src/todo.hpp b/kernel/src/todo.hpp
index 522c7449..c2bdc155 100644
--- a/kernel/src/todo.hpp
+++ b/kernel/src/todo.hpp
@@ -32,4 +32,6 @@
 
 #define TODO_WHEN_CPP_REFLECTION
 
+#define TODO_WHEN_MULTICORE
+
 #endif  // KERNEL_SRC_TODO_HPP_
diff --git a/kernel/src/trace.cpp b/kernel/src/trace.cpp
index a8fe7495..e21d24cf 100644
--- a/kernel/src/trace.cpp
+++ b/kernel/src/trace.cpp
@@ -46,6 +46,7 @@ static struct TraceFramework {
             rv[static_cast<size_t>(TraceModule::kVfs)]        = "VFSModule";
             rv[static_cast<size_t>(TraceModule::kVideo)]      = "VideoModule";
             rv[static_cast<size_t>(TraceModule::kHardware)]   = "HardwareModule";
+            rv[static_cast<size_t>(TraceModule::kScheduling)] = "SchedulingModule";
 
             return rv;
         }();
@@ -333,9 +334,9 @@ static struct TraceFramework {
 
     char *GetWorkspaceMultithreaded() { return nullptr; }
 
-    void CommitToLogMultithreaded(const size_t trace_size) {}
+    void CommitToLogMultithreaded(const size_t) {}
 
-    void CommitToDebugLogMultithreaded(const size_t trace_size) {}
+    void CommitToDebugLogMultithreaded(const size_t) {}
 
     void DumpAllMultithreaded() {}
 
diff --git a/kernel/src/trace_framework.hpp b/kernel/src/trace_framework.hpp
index 35b873bb..5dfaabad 100644
--- a/kernel/src/trace_framework.hpp
+++ b/kernel/src/trace_framework.hpp
@@ -45,6 +45,7 @@ enum class TraceModule {
     kVfs,
     kVideo,
     kHardware,
+    kScheduling,
     kLast,
 };
 
@@ -120,6 +121,10 @@ CREATE_TRACE_HELPERS(kVideo, VIDEO)
 CREATE_DEBUG_HELPERS(kHardware, HARDWARE)
 CREATE_TRACE_HELPERS(kHardware, HARDWARE)
 
+// SCHEDULING
+CREATE_DEBUG_HELPERS(kScheduling, SCHEDULING)
+CREATE_TRACE_HELPERS(kScheduling, SCHEDULING)
+
 #include "trace_framework.tpp"
 
 #endif  // KERNEL_SRC_TRACE_FRAMEWORK_HPP_
diff --git a/kernel/test/atomic_stack_test.cpp b/kernel/test/atomic_stack_test.cpp
new file mode 100644
index 00000000..bd61cb83
--- /dev/null
+++ b/kernel/test/atomic_stack_test.cpp
@@ -0,0 +1,306 @@
+#include <data_structures/atomic_stack.hpp>
+#include <test_module/test.hpp>
+
+class AtomicArrayStaticStackTest : public TestGroupBase
+{
+    protected:
+    static constexpr size_t kStackSize = 256;
+    AtomicArrayStaticStack<kStackSize> stack_;
+};
+
+class AtomicArraySingleTypeStaticStackTest : public TestGroupBase
+{
+    protected:
+    static constexpr size_t kNumObjects = 16;
+    AtomicArraySingleTypeStaticStack<int, kNumObjects> stack_;
+};
+
+// --------------------------------------------------------------------------------
+// AtomicArrayStaticStack - Constructor & Basic State Tests
+// --------------------------------------------------------------------------------
+
+TEST_F(AtomicArrayStaticStackTest, Constructor_GivenDefault_InitializesEmptyState)
+{
+    EXPECT_EQ(0_size, stack_.Size());
+    EXPECT_NOT_NULL(stack_.Data());
+}
+
+TEST_F(AtomicArrayStaticStackTest, Size_GivenEmptyStack_ReturnsZero)
+{
+    EXPECT_EQ(0_size, stack_.Size());
+}
+
+TEST_F(AtomicArrayStaticStackTest, PushCopy_GivenInt_PushesSuccessfully)
+{
+    int value   = 42;
+    int &pushed = stack_.Push(value);
+
+    EXPECT_EQ(42, pushed);
+    EXPECT_EQ(sizeof(int), stack_.Size());
+}
+
+TEST_F(AtomicArrayStaticStackTest, PushCopy_GivenMultipleInts_PushesInOrder)
+{
+    int val1 = 10;
+    int val2 = 20;
+    int val3 = 30;
+
+    stack_.Push(val1);
+    stack_.Push(val2);
+    stack_.Push(val3);
+
+    EXPECT_EQ(sizeof(int) * 3, stack_.Size());
+}
+
+TEST_F(AtomicArrayStaticStackTest, PushCopy_GivenDifferentTypes_PushesCorrectly)
+{
+    int int_val     = 42;
+    char char_val   = 'A';
+    float float_val = 3.14f;
+
+    stack_.Push(int_val);
+    stack_.Push(char_val);
+    stack_.Push(float_val);
+
+    EXPECT_EQ(sizeof(int) + sizeof(char) + sizeof(float), stack_.Size());
+}
+
+struct MoveOnlyType {
+    int value;
+
+    MoveOnlyType() = default;
+    explicit MoveOnlyType(int v) : value(v) {}
+
+    MoveOnlyType(const MoveOnlyType &)            = delete;
+    MoveOnlyType &operator=(const MoveOnlyType &) = delete;
+
+    MoveOnlyType(MoveOnlyType &&other) noexcept : value(other.value) { other.value = -1; }
+
+    MoveOnlyType &operator=(MoveOnlyType &&other) noexcept
+    {
+        if (this != &other) {
+            value       = other.value;
+            other.value = -1;
+        }
+        return *this;
+    }
+};
+
+TEST_F(AtomicArrayStaticStackTest, PushMove_GivenMoveOnlyType_MovesIntoStack)
+{
+    MoveOnlyType obj(100);
+    MoveOnlyType &pushed = stack_.Push(std::move(obj));
+
+    EXPECT_EQ(100, pushed.value);
+    EXPECT_EQ(-1, obj.value);
+    EXPECT_EQ(sizeof(MoveOnlyType), stack_.Size());
+}
+
+struct EmplaceTestType {
+    int a;
+    int b;
+    int c;
+
+    EmplaceTestType(int x, int y, int z) : a(x), b(y), c(z) {}
+};
+
+TEST_F(AtomicArrayStaticStackTest, PushEmplace_GivenArgs_ConstructsInPlace)
+{
+    EmplaceTestType &pushed = stack_.PushEmplace<EmplaceTestType>(1, 2, 3);
+
+    EXPECT_EQ(1, pushed.a);
+    EXPECT_EQ(2, pushed.b);
+    EXPECT_EQ(3, pushed.c);
+    EXPECT_EQ(sizeof(EmplaceTestType), stack_.Size());
+}
+
+TEST_F(AtomicArrayStaticStackTest, Pop_GivenPushedInt_ReturnsCorrectValue)
+{
+    int original = 42;
+    stack_.Push(original);
+
+    int popped = stack_.Pop<int>();
+
+    EXPECT_EQ(42, popped);
+    EXPECT_EQ(0_size, stack_.Size());
+}
+
+TEST_F(AtomicArrayStaticStackTest, Pop_GivenMultiplePushes_PopsInReverseOrder)
+{
+    stack_.Push(10);
+    stack_.Push(20);
+    stack_.Push(30);
+
+    EXPECT_EQ(30, stack_.Pop<int>());
+    EXPECT_EQ(20, stack_.Pop<int>());
+    EXPECT_EQ(10, stack_.Pop<int>());
+    EXPECT_EQ(0_size, stack_.Size());
+}
+
+TEST_F(AtomicArrayStaticStackTest, Pop_GivenDifferentTypes_PopsCorrectly)
+{
+    int int_val     = 42;
+    char char_val   = 'A';
+    float float_val = 3.14f;
+
+    stack_.Push(int_val);
+    stack_.Push(char_val);
+    stack_.Push(float_val);
+
+    EXPECT_EQ(float_val, stack_.Pop<float>());
+    EXPECT_EQ(char_val, stack_.Pop<char>());
+    EXPECT_EQ(int_val, stack_.Pop<int>());
+}
+
+TEST_F(AtomicArrayStaticStackTest, Size_GivenPushAndPop_UpdatesCorrectly)
+{
+    EXPECT_EQ(0_size, stack_.Size());
+
+    stack_.Push(1);
+    EXPECT_EQ(sizeof(int), stack_.Size());
+
+    stack_.Push(2);
+    EXPECT_EQ(sizeof(int) * 2, stack_.Size());
+
+    stack_.Pop<int>();
+    EXPECT_EQ(sizeof(int), stack_.Size());
+
+    stack_.Pop<int>();
+    EXPECT_EQ(0_size, stack_.Size());
+}
+
+TEST_F(AtomicArraySingleTypeStaticStackTest, Constructor_GivenDefault_InitializesEmptyState)
+{
+    EXPECT_EQ(0_size, stack_.Size());
+    EXPECT_EQ(0_size, stack_.SizeBytes());
+    EXPECT_NOT_NULL(stack_.Data());
+}
+
+TEST_F(AtomicArraySingleTypeStaticStackTest, Size_GivenEmptyStack_ReturnsZero)
+{
+    EXPECT_EQ(0_size, stack_.Size());
+    EXPECT_EQ(0_size, stack_.SizeBytes());
+}
+
+TEST_F(AtomicArraySingleTypeStaticStackTest, PushCopy_GivenInt_PushesSuccessfully)
+{
+    int value   = 42;
+    int &pushed = stack_.Push(value);
+
+    EXPECT_EQ(42, pushed);
+    EXPECT_EQ(1_size, stack_.Size());
+    EXPECT_EQ(sizeof(int), stack_.SizeBytes());
+}
+
+TEST_F(AtomicArraySingleTypeStaticStackTest, PushCopy_GivenMultipleInts_PushesInOrder)
+{
+    stack_.Push(10);
+    stack_.Push(20);
+    stack_.Push(30);
+
+    EXPECT_EQ(3_size, stack_.Size());
+    EXPECT_EQ(sizeof(int) * 3, stack_.SizeBytes());
+}
+
+TEST_F(AtomicArraySingleTypeStaticStackTest, PushMove_GivenInt_MovesIntoStack)
+{
+    int value   = 100;
+    int &pushed = stack_.Push(std::move(value));
+
+    EXPECT_EQ(100, pushed);
+    EXPECT_EQ(1_size, stack_.Size());
+}
+
+struct EmplaceIntType {
+    int value;
+
+    explicit EmplaceIntType(int v) : value(v) {}
+};
+
+TEST_F(AtomicArraySingleTypeStaticStackTest, PushEmplace_GivenArgs_ConstructsInPlace)
+{
+    AtomicArraySingleTypeStaticStack<EmplaceIntType, 8> emplace_stack;
+    EmplaceIntType &pushed = emplace_stack.PushEmplace(42);
+
+    EXPECT_EQ(42, pushed.value);
+    EXPECT_EQ(1_size, emplace_stack.Size());
+}
+
+TEST_F(AtomicArraySingleTypeStaticStackTest, Pop_GivenPushedInt_ReturnsCorrectValue)
+{
+    int original = 42;
+    stack_.Push(original);
+
+    int popped = stack_.Pop();
+
+    EXPECT_EQ(42, popped);
+    EXPECT_EQ(0_size, stack_.Size());
+}
+
+TEST_F(AtomicArraySingleTypeStaticStackTest, Pop_GivenMultiplePushes_PopsInReverseOrder)
+{
+    stack_.Push(10);
+    stack_.Push(20);
+    stack_.Push(30);
+
+    EXPECT_EQ(30, stack_.Pop());
+    EXPECT_EQ(20, stack_.Pop());
+    EXPECT_EQ(10, stack_.Pop());
+    EXPECT_EQ(0_size, stack_.Size());
+}
+
+TEST_F(AtomicArraySingleTypeStaticStackTest, Pop_GivenFullStack_PopsAllElements)
+{
+    for (int i = 0; i < static_cast<int>(kNumObjects); ++i) {
+        stack_.Push(i);
+    }
+
+    EXPECT_EQ(kNumObjects, stack_.Size());
+
+    for (int i = static_cast<int>(kNumObjects) - 1; i >= 0; --i) {
+        EXPECT_EQ(i, stack_.Pop());
+    }
+
+    EXPECT_EQ(0_size, stack_.Size());
+}
+
+TEST_F(AtomicArraySingleTypeStaticStackTest, Size_GivenPushAndPop_UpdatesCorrectly)
+{
+    EXPECT_EQ(0_size, stack_.Size());
+
+    stack_.Push(1);
+    EXPECT_EQ(1_size, stack_.Size());
+    EXPECT_EQ(sizeof(int), stack_.SizeBytes());
+
+    stack_.Push(2);
+    EXPECT_EQ(2_size, stack_.Size());
+    EXPECT_EQ(sizeof(int) * 2, stack_.SizeBytes());
+
+    stack_.Pop();
+    EXPECT_EQ(1_size, stack_.Size());
+    EXPECT_EQ(sizeof(int), stack_.SizeBytes());
+
+    stack_.Pop();
+    EXPECT_EQ(0_size, stack_.Size());
+    EXPECT_EQ(0_size, stack_.SizeBytes());
+}
+
+TEST_F(
+    AtomicArraySingleTypeStaticStackTest,
+    PushPopSequence_GivenRepeatedOperations_MaintainsCorrectness
+)
+{
+    for (int round = 0; round < 5; ++round) {
+        for (int i = 0; i < 5; ++i) {
+            stack_.Push(i + round * 10);
+        }
+
+        EXPECT_EQ(5_size, stack_.Size());
+
+        for (int i = 4; i >= 0; --i) {
+            EXPECT_EQ(i + round * 10, stack_.Pop());
+        }
+
+        EXPECT_EQ(0_size, stack_.Size());
+    }
+}
diff --git a/kernel/test/hash_maps_test.cpp b/kernel/test/hash_maps_test.cpp
index a20b896b..71aeaf2e 100644
--- a/kernel/test/hash_maps_test.cpp
+++ b/kernel/test/hash_maps_test.cpp
@@ -15,6 +15,12 @@ class RegistryTest : public TestGroupBase
 {
 };
 
+class PooledHashMapTest : public TestGroupBase
+{
+    protected:
+    static constexpr size_t kPoolSize = 8;
+};
+
 // ------------------------------
 // Hashmap Insert Tests
 // ------------------------------
@@ -388,3 +394,227 @@ TEST_F(RegistryTest, IteratorAccess)
 
     EXPECT_EQ(3_size, count);
 }
+
+struct PooledTestType {
+    int value;
+    char data[16];
+
+    PooledTestType() : value(0) { data[0] = '\0'; }
+    explicit PooledTestType(int v) : value(v)
+    {
+        for (size_t i = 0; i < 16; ++i) {
+            data[i] = static_cast<char>(v + i);
+        }
+    }
+};
+
+TEST_F(PooledHashMapTest, Constructor_GivenDefault_InitializesEmptyPool)
+{
+    PooledHashMap<PooledTestType, kPoolSize> pool;
+
+    EXPECT_EQ(0_size, pool.Size());
+    EXPECT_EQ(kPoolSize, pool.SlotsLeft());
+}
+
+TEST_F(PooledHashMapTest, Allocate_GivenEmptyPool_ReturnsValidIndex)
+{
+    PooledHashMap<PooledTestType, kPoolSize> pool;
+
+    size_t idx = pool.Allocate();
+
+    EXPECT_LT(idx, kPoolSize);
+    EXPECT_NOT_NULL(pool.Get(idx));
+    EXPECT_EQ(1_size, pool.Size());
+    EXPECT_EQ(kPoolSize - 1, pool.SlotsLeft());
+}
+
+TEST_F(PooledHashMapTest, Allocate_GivenMultipleAllocations_ReturnsDifferentIndices)
+{
+    PooledHashMap<PooledTestType, kPoolSize> pool;
+
+    size_t idx1 = pool.Allocate();
+    size_t idx2 = pool.Allocate();
+    size_t idx3 = pool.Allocate();
+
+    EXPECT_NEQ(idx1, idx2);
+    EXPECT_NEQ(idx2, idx3);
+    EXPECT_NEQ(idx1, idx3);
+
+    EXPECT_NOT_NULL(pool.Get(idx1));
+    EXPECT_NOT_NULL(pool.Get(idx2));
+    EXPECT_NOT_NULL(pool.Get(idx3));
+
+    EXPECT_EQ(3_size, pool.Size());
+    EXPECT_EQ(kPoolSize - 3, pool.SlotsLeft());
+}
+
+TEST_F(PooledHashMapTest, Allocate_GivenFullPool_AllocatesAllSlots)
+{
+    PooledHashMap<PooledTestType, kPoolSize> pool;
+
+    size_t indices[kPoolSize];
+    for (size_t i = 0; i < kPoolSize; ++i) {
+        indices[i] = pool.Allocate();
+        EXPECT_NOT_NULL(pool.Get(indices[i]));
+    }
+
+    EXPECT_EQ(kPoolSize, pool.Size());
+    EXPECT_EQ(0_size, pool.SlotsLeft());
+
+    for (size_t i = 0; i < kPoolSize; ++i) {
+        for (size_t j = i + 1; j < kPoolSize; ++j) {
+            EXPECT_NEQ(indices[i], indices[j]);
+        }
+    }
+}
+
+TEST_F(PooledHashMapTest, Get_GivenAllocatedIndex_ReturnsValidPointer)
+{
+    PooledHashMap<PooledTestType, kPoolSize> pool;
+
+    size_t idx          = pool.Allocate();
+    PooledTestType *ptr = pool.Get(idx);
+
+    EXPECT_NOT_NULL(ptr);
+    ptr->value = 42;
+    EXPECT_EQ(42, ptr->value);
+}
+
+TEST_F(PooledHashMapTest, Get_GivenConstPool_ReturnsConstPointer)
+{
+    PooledHashMap<PooledTestType, kPoolSize> pool;
+    size_t idx = pool.Allocate();
+
+    const PooledHashMap<PooledTestType, kPoolSize> &const_pool = pool;
+    const PooledTestType *ptr                                  = const_pool.Get(idx);
+
+    EXPECT_NOT_NULL(ptr);
+}
+
+TEST_F(PooledHashMapTest, Free_GivenAllocatedIndex_FreesSlotAndReturnsToPool)
+{
+    PooledHashMap<PooledTestType, kPoolSize> pool;
+
+    size_t idx = pool.Allocate();
+    EXPECT_EQ(1_size, pool.Size());
+    EXPECT_EQ(kPoolSize - 1, pool.SlotsLeft());
+
+    pool.Free(idx);
+
+    EXPECT_EQ(0_size, pool.Size());
+    EXPECT_EQ(kPoolSize, pool.SlotsLeft());
+    EXPECT_NULL(pool.Get(idx));
+}
+
+TEST_F(PooledHashMapTest, Free_GivenMultipleAllocations_FreesCorrectly)
+{
+    PooledHashMap<PooledTestType, kPoolSize> pool;
+
+    size_t idx1 = pool.Allocate();
+    size_t idx2 = pool.Allocate();
+    size_t idx3 = pool.Allocate();
+
+    EXPECT_EQ(3_size, pool.Size());
+
+    pool.Free(idx2);
+
+    EXPECT_EQ(2_size, pool.Size());
+    EXPECT_EQ(kPoolSize - 2, pool.SlotsLeft());
+    EXPECT_NULL(pool.Get(idx2));
+    EXPECT_NOT_NULL(pool.Get(idx1));
+    EXPECT_NOT_NULL(pool.Get(idx3));
+}
+
+TEST_F(PooledHashMapTest, FreeAndReallocate_GivenFreedSlot_ReusesIndex)
+{
+    PooledHashMap<PooledTestType, kPoolSize> pool;
+
+    [[maybe_unused]] size_t idx1 = pool.Allocate();
+    size_t idx2                  = pool.Allocate();
+    [[maybe_unused]] size_t idx3 = pool.Allocate();
+
+    pool.Free(idx2);
+
+    size_t idx4 = pool.Allocate();
+
+    EXPECT_EQ(idx2, idx4);
+    EXPECT_EQ(3_size, pool.Size());
+    EXPECT_NOT_NULL(pool.Get(idx4));
+}
+
+TEST_F(PooledHashMapTest, AllocateFreeSequence_GivenRepeatedOperations_MaintainsCorrectness)
+{
+    PooledHashMap<PooledTestType, kPoolSize> pool;
+
+    size_t indices[kPoolSize];
+    for (size_t i = 0; i < kPoolSize; ++i) {
+        indices[i] = pool.Allocate();
+    }
+
+    EXPECT_EQ(kPoolSize, pool.Size());
+    EXPECT_EQ(0_size, pool.SlotsLeft());
+
+    for (size_t i = 0; i < kPoolSize / 2; ++i) {
+        pool.Free(indices[i]);
+    }
+
+    EXPECT_EQ(kPoolSize / 2, pool.Size());
+    EXPECT_EQ(kPoolSize / 2, pool.SlotsLeft());
+
+    for (size_t i = 0; i < kPoolSize / 2; ++i) {
+        size_t new_idx = pool.Allocate();
+        EXPECT_NOT_NULL(pool.Get(new_idx));
+    }
+
+    EXPECT_EQ(kPoolSize, pool.Size());
+    EXPECT_EQ(0_size, pool.SlotsLeft());
+}
+
+TEST_F(PooledHashMapTest, Size_GivenAllocateAndFree_UpdatesCorrectly)
+{
+    PooledHashMap<PooledTestType, kPoolSize> pool;
+
+    EXPECT_EQ(0_size, pool.Size());
+
+    size_t idx1 = pool.Allocate();
+    EXPECT_EQ(1_size, pool.Size());
+
+    size_t idx2 = pool.Allocate();
+    EXPECT_EQ(2_size, pool.Size());
+
+    pool.Free(idx1);
+    EXPECT_EQ(1_size, pool.Size());
+
+    pool.Free(idx2);
+    EXPECT_EQ(0_size, pool.Size());
+}
+
+TEST_F(PooledHashMapTest, SlotsLeft_GivenAllocateAndFree_UpdatesCorrectly)
+{
+    PooledHashMap<PooledTestType, kPoolSize> pool;
+
+    EXPECT_EQ(kPoolSize, pool.SlotsLeft());
+
+    size_t idx1 = pool.Allocate();
+    EXPECT_EQ(kPoolSize - 1, pool.SlotsLeft());
+
+    size_t idx2 = pool.Allocate();
+    EXPECT_EQ(kPoolSize - 2, pool.SlotsLeft());
+
+    pool.Free(idx1);
+    EXPECT_EQ(kPoolSize - 1, pool.SlotsLeft());
+
+    pool.Free(idx2);
+    EXPECT_EQ(kPoolSize, pool.SlotsLeft());
+}
+
+TEST_F(PooledHashMapTest, Get_GivenFreedIndex_ReturnsNull)
+{
+    PooledHashMap<PooledTestType, kPoolSize> pool;
+
+    size_t idx = pool.Allocate();
+    EXPECT_NOT_NULL(pool.Get(idx));
+
+    pool.Free(idx);
+    EXPECT_NULL(pool.Get(idx));
+}
diff --git a/kernel/test/integral_storage_test.cpp b/kernel/test/integral_storage_test.cpp
new file mode 100644
index 00000000..3de3d271
--- /dev/null
+++ b/kernel/test/integral_storage_test.cpp
@@ -0,0 +1,58 @@
+#include <bit.hpp>
+#include <bits_ext.hpp>
+#include <template/integral_storage.hpp>
+#include <test_module/test.hpp>
+
+using namespace template_lib;
+
+class MinimalUnsignedStorageTest : public TestGroupBase
+{
+};
+
+TEST_F(MinimalUnsignedStorageTest, MinimalUnsignedStorage_AllBoundariesAndEdgeCases)
+{
+    constexpr size_t val_lsb         = kLsb<size_t>;
+    constexpr size_t val_bit1        = kSingleBit<size_t, 1>;
+    constexpr size_t val_bit4        = kBitMask<size_t, 0, 4>;
+    constexpr size_t val_bit7        = kBitMask<size_t, 0, 7>;
+    constexpr size_t val_8bits       = static_cast<size_t>(kBitMask8);
+    constexpr size_t val_8bits_plus1 = static_cast<size_t>(kBitMask8) + 1;
+    constexpr size_t val_bit9        = kSingleBit<size_t, 9>;
+    constexpr size_t val_bit15       = kBitMask<size_t, 0, 15>;
+    constexpr size_t val_16bits      = static_cast<size_t>(kBitMask16);
+    constexpr size_t val_bit25       = kSingleBit<size_t, 25>;
+    constexpr size_t val_bit31       = kBitMask<size_t, 0, 31>;
+    constexpr size_t val_32bits      = static_cast<size_t>(kBitMask32);
+    constexpr size_t val_bit63       = kBitMask<size_t, 0, 63>;
+    constexpr size_t val_64bits      = static_cast<size_t>(kBitMask64);
+
+    using t_lsb         = MinimalUnsignedStorage_t<val_lsb>;
+    using t_bit1        = MinimalUnsignedStorage_t<val_bit1>;
+    using t_bit4        = MinimalUnsignedStorage_t<val_bit4>;
+    using t_bit7        = MinimalUnsignedStorage_t<val_bit7>;
+    using t_8bits       = MinimalUnsignedStorage_t<val_8bits>;
+    using t_8bits_plus1 = MinimalUnsignedStorage_t<val_8bits_plus1>;
+    using t_bit9        = MinimalUnsignedStorage_t<val_bit9>;
+    using t_bit15       = MinimalUnsignedStorage_t<val_bit15>;
+    using t_16bits      = MinimalUnsignedStorage_t<val_16bits>;
+    using t_bit25       = MinimalUnsignedStorage_t<val_bit25>;
+    using t_bit31       = MinimalUnsignedStorage_t<val_bit31>;
+    using t_32bits      = MinimalUnsignedStorage_t<val_32bits>;
+    using t_bit63       = MinimalUnsignedStorage_t<val_bit63>;
+    using t_64bits      = MinimalUnsignedStorage_t<val_64bits>;
+
+    EXPECT_TRUE((std::is_same_v<t_lsb, u8>));
+    EXPECT_TRUE((std::is_same_v<t_bit1, u8>));
+    EXPECT_TRUE((std::is_same_v<t_bit4, u8>));
+    EXPECT_TRUE((std::is_same_v<t_bit7, u8>));
+    EXPECT_TRUE((std::is_same_v<t_8bits, u8>));
+    EXPECT_TRUE((std::is_same_v<t_8bits_plus1, u16>));
+    EXPECT_TRUE((std::is_same_v<t_bit9, u16>));
+    EXPECT_TRUE((std::is_same_v<t_bit15, u16>));
+    EXPECT_TRUE((std::is_same_v<t_16bits, u16>));
+    EXPECT_TRUE((std::is_same_v<t_bit25, u32>));
+    EXPECT_TRUE((std::is_same_v<t_bit31, u32>));
+    EXPECT_TRUE((std::is_same_v<t_32bits, u32>));
+    EXPECT_TRUE((std::is_same_v<t_bit63, u64>));
+    EXPECT_TRUE((std::is_same_v<t_64bits, u64>));
+}
diff --git a/kernel/test/manual_tests.cpp b/kernel/test/manual_tests.cpp
index 40bb1a6e..c04e2e6b 100644
--- a/kernel/test/manual_tests.cpp
+++ b/kernel/test/manual_tests.cpp
@@ -1,4 +1,4 @@
 #include <assert.h>
 #include <test_module/test.hpp>
 
-MTEST(AssertSnprintfTest) { ASSERT_EQ(2, 3, "Values used in the test: %d, %d", 2, 3); }
+MTEST(AssertSnprintfTest) { ASSERT_EQ(2 + 2, 3 + 3, "Values used in the test: %d, %d", 2, 3); }
diff --git a/kernel/test/test_module.cpp b/kernel/test/test_module.cpp
index 4fa1d50d..a0d1281a 100644
--- a/kernel/test/test_module.cpp
+++ b/kernel/test/test_module.cpp
@@ -174,12 +174,14 @@ NO_RET void OnKernelPanic()
     if (!g_testStarted) {
         /* test not started yet, but we received failure -> some critical bug -> abort execution */
         arch::TerminalWriteError("[TEST] [FAIL] Kernel panic received before test started...\n");
+        trace::DumpAllBuffersOnFailure();
         hal::QemuShutdown();
     }
 
     if (g_expectFail) {
         /* fail was expected we are good */
         arch::TerminalWriteString("[TEST] [SUCCESS] Test failed successfully...\n");
+        trace::DumpAllBuffersOnFailure();
         hal::QemuShutdown();
     }
 
diff --git a/libs/libcontainers/include/data_structures/atomic_stack.hpp b/libs/libcontainers/include/data_structures/atomic_stack.hpp
new file mode 100644
index 00000000..4ffc4ab4
--- /dev/null
+++ b/libs/libcontainers/include/data_structures/atomic_stack.hpp
@@ -0,0 +1,139 @@
+#ifndef LIBS_LIBCONTAINERS_INCLUDE_DATA_STRUCTURES_ATOMIC_STACK_HPP_
+#define LIBS_LIBCONTAINERS_INCLUDE_DATA_STRUCTURES_ATOMIC_STACK_HPP_
+
+#include <assert.h>
+#include <defines.hpp>
+#include <type_traits.hpp>
+#include <utility.hpp>
+
+#include "hal/sync.hpp"
+
+template <size_t kSizeBytes, size_t kAlignment = 8>
+class AtomicArrayStaticStack
+{
+    // ------------------------------
+    // Class creation
+    // ------------------------------
+
+    template <class T>
+    using clean_type = std::remove_reference_t<std::remove_const_t<T>>;
+
+    public:
+    AtomicArrayStaticStack()  = default;
+    ~AtomicArrayStaticStack() = default;
+
+    AtomicArrayStaticStack(const AtomicArrayStaticStack &) = default;
+    AtomicArrayStaticStack(AtomicArrayStaticStack &&)      = default;
+
+    AtomicArrayStaticStack &operator=(const AtomicArrayStaticStack &) = default;
+    AtomicArrayStaticStack &operator=(AtomicArrayStaticStack &&)      = default;
+
+    // ------------------------------
+    // Class interaction
+    // ------------------------------
+
+    template <class T>
+    FORCE_INLINE_F T &Push(const T &item)
+    {
+        auto ptr = PushMem_<T>();
+        new (ptr) clean_type<T>(item); /* Checks alignment on debug */
+        return *ptr;
+    }
+
+    template <class T>
+    FORCE_INLINE_F T &Push(T &&item)
+    {
+        auto ptr = PushMem_<T>();
+        new (ptr) clean_type<T>(std::move(item)); /* Checks alignment on debug */
+        return *ptr;
+    }
+
+    template <class T, class... Args>
+    FORCE_INLINE_F T &PushEmplace(Args &&...args)
+    {
+        auto ptr = PushMem_<T>();
+        new (ptr) clean_type<T>(std::forward<Args>(args)...); /* Checks alignment on debug */
+        return *ptr;
+    }
+
+    template <class T>
+    FORCE_INLINE_F clean_type<T> Pop()
+    {
+        ASSERT_LE(sizeof(T), static_cast<size_t>(hal::AtomicLoad(&top_)), "Stack underflow!!");
+        const auto top = hal::AtomicSub(&top_, sizeof(T));
+
+        auto ptr = reinterpret_cast<clean_type<T> *>(stack_.data + top);
+        return std::move(*ptr);
+    }
+
+    NODISCARD FORCE_INLINE_F size_t Size() const { return hal::AtomicLoad(&top_); }
+
+    NODISCARD FORCE_INLINE_F const void *Data() const { return stack_.data; }
+
+    // ------------------------------
+    // Private methods
+    // ------------------------------
+
+    private:
+    template <class T>
+    clean_type<T> *PushMem_() noexcept
+    {
+        const size_t start = hal::AtomicLoad(&top_);
+        hal::AtomicAdd(&top_, sizeof(T));
+
+        ASSERT_LE(static_cast<size_t>(hal::AtomicLoad(&top_)), kSizeBytes, "Stack overflow!");
+        return reinterpret_cast<clean_type<T> *>(stack_.data + start);
+    }
+
+    // ------------------------------
+    // Class fields
+    // ------------------------------
+
+    protected:
+    hal::Atomic64 top_{};
+    std::aligned_storage_t<kSizeBytes, kAlignment> stack_{};
+};
+
+template <class T, size_t kNumObjects>
+class AtomicArraySingleTypeStaticStack
+    : public AtomicArrayStaticStack<sizeof(T) * kNumObjects, alignof(T)>
+{
+    using base_t = AtomicArrayStaticStack<sizeof(T) * kNumObjects, alignof(T)>;
+    // ------------------------------
+    // Class creation
+    // ------------------------------
+
+    public:
+    AtomicArraySingleTypeStaticStack()  = default;
+    ~AtomicArraySingleTypeStaticStack() = default;
+
+    AtomicArraySingleTypeStaticStack(const AtomicArraySingleTypeStaticStack &) = default;
+    AtomicArraySingleTypeStaticStack(AtomicArraySingleTypeStaticStack &&)      = default;
+
+    AtomicArraySingleTypeStaticStack &operator=(const AtomicArraySingleTypeStaticStack &) = default;
+    AtomicArraySingleTypeStaticStack &operator=(AtomicArraySingleTypeStaticStack &&)      = default;
+
+    // ------------------------------
+    // Class interaction
+    // ------------------------------
+
+    FORCE_INLINE_F T &Push(const T &item) { return base_t::Push(item); }
+
+    FORCE_INLINE_F T &Push(T &&item) { return base_t::Push(std::move(item)); }
+
+    template <class... Args>
+    FORCE_INLINE_F T &PushEmplace(Args &&...args)
+    {
+        return base_t::template PushEmplace<T>(std::forward<Args>(args)...);
+    }
+
+    FORCE_INLINE_F T Pop() { return base_t::template Pop<T>(); }
+
+    FORCE_INLINE_F size_t Size() const { return base_t::Size() / sizeof(T); }
+
+    FORCE_INLINE_F size_t SizeBytes() const { return base_t::Size(); }
+
+    using base_t::Data;
+};
+
+#endif  // LIBS_LIBCONTAINERS_INCLUDE_DATA_STRUCTURES_ATOMIC_STACK_HPP_
diff --git a/libs/libcontainers/include/data_structures/hash_maps.hpp b/libs/libcontainers/include/data_structures/hash_maps.hpp
index abb1db61..81dabfb9 100644
--- a/libs/libcontainers/include/data_structures/hash_maps.hpp
+++ b/libs/libcontainers/include/data_structures/hash_maps.hpp
@@ -4,7 +4,14 @@
 #include <bit.hpp>
 #include <hal/constants.hpp>  // < TODO: This should not be here. Make kCacheLineSizeBytes a template param
 #include <string.hpp>
+#include <template/integral_storage.hpp>
 #include <tuple.hpp>
+#include "array_structures.hpp"
+#include "atomic_stack.hpp"
+#include "bit_array.hpp"
+#include "mem/heap.hpp"
+
+#include <trace_framework.hpp>
 
 namespace data_structures
 {
@@ -339,6 +346,84 @@ class Registry
     bool is_active_{false};
 };
 
+// ------------------------------
+// PooledHashMap
+// ------------------------------
+
+template <class T, size_t kSize>
+class PooledHashMap
+{
+    using Idx_t = template_lib::MinimalUnsignedStorage_t<kSize>;
+
+    public:
+    // ------------------------------
+    // Class creation
+    // ------------------------------
+
+    PooledHashMap()
+    {
+        for (Idx_t i = 0; i < static_cast<Idx_t>(kSize); ++i) {
+            pool_.Push(static_cast<Idx_t>(kSize) - i - 1);
+        }
+        ASSERT_EQ(pool_.Size(), kSize);
+    }
+
+    // ------------------------------
+    // Class interaction
+    // ------------------------------
+
+    NODISCARD FORCE_INLINE_F size_t Size() const { return kSize - pool_.Size(); }
+
+    NODISCARD FORCE_INLINE_F size_t SlotsLeft() const { return pool_.Size(); }
+
+    NODISCARD FORCE_INLINE_F T *Get(const size_t idx)
+    {
+        ASSERT_LT(idx, kSize);
+        return map_[idx];
+    }
+
+    NODISCARD FORCE_INLINE_F T *Get(const size_t idx) const
+    {
+        ASSERT_LT(idx, kSize);
+        return map_[idx];
+    }
+
+    /* Does not initialize the memory!! */
+    NODISCARD FORCE_INLINE_F size_t Allocate()
+    {
+        if (SlotsLeft() == 0) {
+            return std::numeric_limits<size_t>::max();
+        }
+
+        const size_t idx = pool_.Pop();
+
+        auto mem = Mem::KMalloc(sizeof(T));
+        R_ASSERT_TRUE(static_cast<bool>(mem));
+        map_[idx] = static_cast<T *>(mem.value());
+
+        return idx;
+    }
+
+    FORCE_INLINE_F void Free(const size_t idx)
+    {
+        ASSERT_LT(idx, kSize);
+        ASSERT_NOT_NULL(Get(idx));
+
+        Mem::KFree(Get(idx));
+        map_[idx] = nullptr;
+
+        pool_.Push(static_cast<Idx_t>(idx));
+    }
+
+    // ------------------------------
+    // Class fields
+    // ------------------------------
+
+    protected:
+    T *map_[kSize]{};
+    AtomicArraySingleTypeStaticStack<Idx_t, kSize> pool_{};
+};
+
 }  // namespace data_structures
 
 #endif  // LIBS_LIBCONTAINERS_INCLUDE_DATA_STRUCTURES_HASH_MAPS_HPP_
diff --git a/libs/libcpp/include/bits_ext.hpp b/libs/libcpp/include/bits_ext.hpp
index bdb3451f..1ab5d0bd 100644
--- a/libs/libcpp/include/bits_ext.hpp
+++ b/libs/libcpp/include/bits_ext.hpp
@@ -13,7 +13,7 @@
 //==============================================================================
 
 template <std::unsigned_integral NumT>
-FAST_CALL constexpr bool IsPowerOfTwo(const NumT n);
+FAST_CALL constexpr bool IsPowerOfTwo(NumT n);
 
 // ------------------------------
 // Various defines
@@ -88,6 +88,9 @@ struct UnsignedIntegral<8> {
     using type = u64;
 };
 
+template <size_t kSize>
+using UnsignedIntegral_t = typename UnsignedIntegral<kSize>::type;
+
 // ------------------------------
 // Functions
 // ------------------------------
diff --git a/libs/libtemplate/include/template/integral_storage.hpp b/libs/libtemplate/include/template/integral_storage.hpp
new file mode 100644
index 00000000..95619507
--- /dev/null
+++ b/libs/libtemplate/include/template/integral_storage.hpp
@@ -0,0 +1,13 @@
+#ifndef LIBS_LIBTEMPLATE_INCLUDE_TEMPLATE_INTEGRAL_STORAGE_HPP_
+#define LIBS_LIBTEMPLATE_INCLUDE_TEMPLATE_INTEGRAL_STORAGE_HPP_
+
+#include "bits_ext.hpp"
+
+namespace template_lib
+{
+template <size_t kNum>
+using MinimalUnsignedStorage_t = UnsignedIntegral_t<(std::bit_width(kNum) + 7) / 8>;
+
+}  // namespace template_lib
+
+#endif  // LIBS_LIBTEMPLATE_INCLUDE_TEMPLATE_INTEGRAL_STORAGE_HPP_
diff --git a/libs/libtemplate/include/template/scope_guard.hpp b/libs/libtemplate/include/template/scope_guard.hpp
new file mode 100644
index 00000000..2c4012dc
--- /dev/null
+++ b/libs/libtemplate/include/template/scope_guard.hpp
@@ -0,0 +1,87 @@
+#ifndef LIBS_LIBTEMPLATE_INCLUDE_TEMPLATE_SCOPE_GUARD_HPP_
+#define LIBS_LIBTEMPLATE_INCLUDE_TEMPLATE_SCOPE_GUARD_HPP_
+
+#include <assert.h>
+#include <utility.hpp>
+
+namespace template_lib
+{
+
+template <class F>
+class ScopeGuard
+{
+    public:
+    // ------------------------------
+    // Class construction
+    // ------------------------------
+
+    explicit ScopeGuard(F &&f) : f_(std::forward<F>(f)) {}
+
+    ScopeGuard(ScopeGuard &&other) noexcept : f_(std::move(other.f_)), dismissed_(other.dismissed_)
+    {
+        other.dismissed_ = true;
+    }
+
+    ScopeGuard(ScopeGuard &)            = delete;
+    ScopeGuard &operator=(ScopeGuard &) = delete;
+
+    ~ScopeGuard()
+    {
+        if (!dismissed_) {
+            f_();
+        }
+    }
+
+    // ------------------------------
+    // Class interaction
+    // ------------------------------
+
+    void dismiss() { dismissed_ = true; }
+
+    // ------------------------------
+    // Class Fields
+    // ------------------------------
+
+    private:
+    F f_{};
+    bool dismissed_{};
+};
+
+template <class F>
+class BatchedScopeGuard
+{
+    public:
+    // ------------------------------
+    // Class construction
+    // ------------------------------
+
+    explicit BatchedScopeGuard(bool &dismissed, F &&f)
+        : f_(std::forward<F>(f)), dismissed_(dismissed)
+    {
+    }
+
+    BatchedScopeGuard(BatchedScopeGuard &&)            = delete;
+    BatchedScopeGuard &operator=(BatchedScopeGuard &&) = delete;
+
+    BatchedScopeGuard(BatchedScopeGuard &)            = delete;
+    BatchedScopeGuard &operator=(BatchedScopeGuard &) = delete;
+
+    ~BatchedScopeGuard()
+    {
+        if (!dismissed_) {
+            f_();
+        }
+    }
+
+    // ------------------------------
+    // Class Fields
+    // ------------------------------
+
+    private:
+    F f_;
+    bool &dismissed_;
+};
+
+}  // namespace template_lib
+
+#endif  // LIBS_LIBTEMPLATE_INCLUDE_TEMPLATE_SCOPE_GUARD_HPP_

From 53007651b79f82809ab5ce2683e76ba67bd83c83 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C5=81ukasz=20Kryczka?=
 <60490378+kryczkal@users.noreply.github.com>
Date: Sat, 27 Dec 2025 18:47:28 +0100
Subject: [PATCH 18/56] Kryczkal/elf loading (#243)

## Problem
Programs need to run in userspace in the future
Programs (elfs) need to be loaded from rootfs
in order to be in rootfs, they need to be compiled, and copied there

<img width="773" height="354" alt="image"
src="https://github.com/user-attachments/assets/ae53dfe3-92fb-431d-b8ae-cb5778438250"
/>


## Solution
This PR introduced:
- the `userspace` folder, that handles creating userspaces programs.
- elf loader that creates proper virtual memory regions (in kernel
address space) and jumps to the loaded program

## Bugfixes
Fixed a bug in VFS Path where non-owning view type (that viewed volatile
mem) objects were copied, without copying the underlying thing they
viewed at, causing errors.

## Note
**TDLR**: Hardcoded for x86_64 and only a single program can be executed
per run of alkos

**Long Version**: This this is severly limited, and more of a Proof of
Concept.
1. There is no cleanup that "unloads" a program (and most likely will
not be needed since each program is a process in its own address space,
so destroying an address space is the cleanup itself). This means a
program can only be run once, then its loaded into memory, and cant be
loaded again (since the vmem areas are already used).
3. Since there is no libc and syscalls yet, this PR added a workaround
where userspace programs are compiled in such a way that address of a
desired print function is passed into them.
This allowed of testing that indeed the elf loading functionality works
out, without waiting for syscalls and libc to be fully implemented. This
needs to be cleaned up later.
This is temporarily hardcoded for `x86_64`
---
 CMakeLists.txt                                |   1 +
 .../generated/include/autogen/feature_flags.h | 115 --------------
 kernel/arch/x86_64/src/hal/impl/constants.hpp |   1 +
 kernel/src/hal/constants.hpp                  |   2 +
 kernel/src/sys/elf/elf.hpp                    |  50 ++++++
 kernel/src/sys/loader.cpp                     | 142 ++++++++++++++++++
 kernel/src/sys/loader.hpp                     |  29 ++++
 kernel/src/sys/shell.cpp                      |  83 +++++++++-
 kernel/src/sys/shell.hpp                      |   1 +
 kernel/src/vfs/path.hpp                       |  53 +++++--
 rootfs/CMakeLists.txt                         |   7 +
 scripts/actions/make_rootfs.bash              |  11 ++
 userspace/.gitignore                          |   1 +
 userspace/CMakeLists.txt                      |  49 ++++++
 userspace/build/linker.ld                     |  24 +++
 userspace/crt0.nasm                           |  22 +++
 userspace/programs/hello_world/main.cpp       |  15 ++
 17 files changed, 475 insertions(+), 131 deletions(-)
 delete mode 100644 alkos/generated/include/autogen/feature_flags.h
 create mode 100644 kernel/src/sys/elf/elf.hpp
 create mode 100644 kernel/src/sys/loader.cpp
 create mode 100644 kernel/src/sys/loader.hpp
 create mode 100644 userspace/.gitignore
 create mode 100644 userspace/CMakeLists.txt
 create mode 100644 userspace/build/linker.ld
 create mode 100644 userspace/crt0.nasm
 create mode 100644 userspace/programs/hello_world/main.cpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index eeba090a..26a6a4db 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -97,6 +97,7 @@ set(SYSTEM_LIB_TYPE k)
 add_subdirectory(libs)
 add_subdirectory(generated)
 add_subdirectory(kernel)
+add_subdirectory(userspace)
 add_subdirectory(rootfs)
 
 ################################################################################
diff --git a/alkos/generated/include/autogen/feature_flags.h b/alkos/generated/include/autogen/feature_flags.h
deleted file mode 100644
index 6bbe2809..00000000
--- a/alkos/generated/include/autogen/feature_flags.h
+++ /dev/null
@@ -1,115 +0,0 @@
-// This file is generated by configure script. Do not edit manually.
-
-#ifndef ALKOS_GENERATED_INCLUDE_AUTOGEN_FEATURE_FLAGS_H_
-#define ALKOS_GENERATED_INCLUDE_AUTOGEN_FEATURE_FLAGS_H_
-
-// Macros for feature flags in C code
-
-// "run_test_mode" - "Instead of proceeding to usual kernel boot enter the test mode, which allows
-// to run single test on the kernel."
-#define FEATURE_FLAG_RUN_TEST_MODE 0
-
-// "debug_spinlock" - "Enables additional debug information for spinlocks, which can help to
-// identify deadlocks and other synchronization issues."
-#define FEATURE_FLAG_DEBUG_SPINLOCK 1
-
-// "debug_output" - "Enables additional terminal output directed to serial port, mostly used for
-// qemu builds and debugging."
-#define FEATURE_FLAG_DEBUG_OUTPUT 1
-
-// "debug_traces" - "Enables additional debug traces in the kernel, which can help to identify
-// issues during execution."
-#define FEATURE_FLAG_DEBUG_TRACES 1
-
-// "single_trace_max_size" - "Maximum size of a single debug trace entry in bytes."
-#define FEATURE_FLAG_SINGLE_TRACE_MAX_SIZE 2048
-
-// "trace_buffer_size" - "Size of the trace buffer in bytes."
-#define FEATURE_FLAG_TRACE_BUFFER_SIZE 65536
-
-// "memory_trace_level" - "Level of Memory module tracing"
-#define FEATURE_FLAG_MEMORY_TRACE_LEVEL 2
-
-// "interrupts_trace_level" - "Level of Interrupts module tracing"
-#define FEATURE_FLAG_INTERRUPTS_TRACE_LEVEL 2
-
-// "boot_trace_level" - "Level of Boot module tracing"
-#define FEATURE_FLAG_BOOT_TRACE_LEVEL 2
-
-// "general_trace_level" - "Level of General module tracing"
-#define FEATURE_FLAG_GENERAL_TRACE_LEVEL 2
-
-// =========================================================================================
-
-#ifdef __cplusplus
-// Code for feature flags in C++ code
-
-enum class FeatureFlag {
-    kRunTestMode,
-    kDebugSpinlock,
-    kDebugOutput,
-    kDebugTraces,
-    kSingleTraceMaxSize,
-    kTraceBufferSize,
-    kMemoryTraceLevel,
-    kInterruptsTraceLevel,
-    kBootTraceLevel,
-    kGeneralTraceLevel,
-    kLast,
-};
-
-// Boolean feature flags
-template <FeatureFlag Flag>
-inline constexpr bool FeatureEnabled = false;
-
-// run_test_mode - "Instead of proceeding to usual kernel boot enter the test mode, which allows to
-// run single test on the kernel."
-template <>
-inline constexpr bool FeatureEnabled<FeatureFlag::kRunTestMode> = false;
-
-// debug_spinlock - "Enables additional debug information for spinlocks, which can help to identify
-// deadlocks and other synchronization issues."
-template <>
-inline constexpr bool FeatureEnabled<FeatureFlag::kDebugSpinlock> = true;
-
-// debug_output - "Enables additional terminal output directed to serial port, mostly used for qemu
-// builds and debugging."
-template <>
-inline constexpr bool FeatureEnabled<FeatureFlag::kDebugOutput> = true;
-
-// debug_traces - "Enables additional debug traces in the kernel, which can help to identify issues
-// during execution."
-template <>
-inline constexpr bool FeatureEnabled<FeatureFlag::kDebugTraces> = true;
-
-// Integer feature flags
-template <FeatureFlag Flag>
-inline constexpr int FeatureValue = 0;
-
-// single_trace_max_size - "Maximum size of a single debug trace entry in bytes."
-template <>
-inline constexpr int FeatureValue<FeatureFlag::kSingleTraceMaxSize> = 2048;
-
-// trace_buffer_size - "Size of the trace buffer in bytes."
-template <>
-inline constexpr int FeatureValue<FeatureFlag::kTraceBufferSize> = 65536;
-
-// memory_trace_level - "Level of Memory module tracing"
-template <>
-inline constexpr int FeatureValue<FeatureFlag::kMemoryTraceLevel> = 2;
-
-// interrupts_trace_level - "Level of Interrupts module tracing"
-template <>
-inline constexpr int FeatureValue<FeatureFlag::kInterruptsTraceLevel> = 2;
-
-// boot_trace_level - "Level of Boot module tracing"
-template <>
-inline constexpr int FeatureValue<FeatureFlag::kBootTraceLevel> = 2;
-
-// general_trace_level - "Level of General module tracing"
-template <>
-inline constexpr int FeatureValue<FeatureFlag::kGeneralTraceLevel> = 2;
-
-#endif  // __cplusplus
-
-#endif  // ALKOS_GENERATED_INCLUDE_AUTOGEN_FEATURE_FLAGS_H_
diff --git a/kernel/arch/x86_64/src/hal/impl/constants.hpp b/kernel/arch/x86_64/src/hal/impl/constants.hpp
index bfe4207d..42c9f704 100644
--- a/kernel/arch/x86_64/src/hal/impl/constants.hpp
+++ b/kernel/arch/x86_64/src/hal/impl/constants.hpp
@@ -19,6 +19,7 @@ static constexpr size_t kCacheLineSizeBytes = 64;
 static constexpr size_t kPageSizeBytes      = 4096;
 static constexpr size_t kPageShift          = 12;
 static constexpr u32 kMaxCores              = 512;
+static constexpr u16 kElfMachineType        = 0x3E;
 
 // ------------------------------
 // Enums
diff --git a/kernel/src/hal/constants.hpp b/kernel/src/hal/constants.hpp
index e9f00523..78f67d6b 100644
--- a/kernel/src/hal/constants.hpp
+++ b/kernel/src/hal/constants.hpp
@@ -19,6 +19,8 @@ static constexpr size_t kPageShift          = arch::kPageShift;
 static constexpr u32 kMaxCores = arch::kMaxCores;
 static_assert(kMaxCores <= kBitMask16);  // Must fit in u16
 
+static constexpr u16 kElfMachineType = arch::kElfMachineType;
+
 using arch::HardwareClockId;
 using arch::HardwareEventClockId;
 }  // namespace hal
diff --git a/kernel/src/sys/elf/elf.hpp b/kernel/src/sys/elf/elf.hpp
new file mode 100644
index 00000000..1c832d8d
--- /dev/null
+++ b/kernel/src/sys/elf/elf.hpp
@@ -0,0 +1,50 @@
+#ifndef KERNEL_SRC_SYS_ELF_ELF_HPP_
+#define KERNEL_SRC_SYS_ELF_ELF_HPP_
+
+#include <defines.hpp>
+#include <types.hpp>
+
+namespace System::Elf
+{
+
+// ELF-64 Structures based on System V ABI
+
+struct Header {
+    unsigned char identifier[16];
+    u16 type;
+    u16 machine;
+    u32 version;
+    u64 entry;
+    u64 phoff;
+    u64 shoff;
+    u32 flags;
+    u16 ehsize;
+    u16 phentsize;
+    u16 phnum;
+    u16 shentsize;
+    u16 shnum;
+    u16 shstrndx;
+
+    static constexpr unsigned char kMagic[4] = {0x7F, 'E', 'L', 'F'};
+    static constexpr u16 kTypeExec           = 2;
+} PACK;
+
+struct ProgramHeader {
+    u32 type;
+    u32 flags;
+    u64 offset;
+    u64 vaddr;
+    u64 paddr;
+    u64 filesz;
+    u64 memsz;
+    u64 align;
+
+    static constexpr u32 kTypeLoad  = 1;
+    static constexpr u32 kFlagExec  = 1;
+    static constexpr u32 kFlagWrite = 2;
+    static constexpr u32 kFlagRead  = 4;
+} PACK;
+
+}  // namespace System::Elf
+
+#endif  // KERNEL_SRC_SYS_ELF_ELF_HPP_
diff --git a/kernel/src/sys/loader.cpp b/kernel/src/sys/loader.cpp
new file mode 100644
index 00000000..8b523e00
--- /dev/null
+++ b/kernel/src/sys/loader.cpp
@@ -0,0 +1,142 @@
+#include "sys/loader.hpp"
+
+#include <string.h>
+#include <bits_ext.hpp>
+#include <template/scope_guard.hpp>
+
+#include "hal/constants.hpp"
+#include "modules/memory.hpp"
+#include "modules/vfs.hpp"
+#include "sys/elf/elf.hpp"
+#include "trace_framework.hpp"
+
+namespace System
+{
+
+using namespace Mem;
+using std::expected;
+using std::unexpected;
+
+namespace
+{
+bool ValidateElfHeader(const Elf::Header &header)
+{
+    if (memcmp(header.identifier, Elf::Header::kMagic, 4) != 0) {
+        TRACE_WARN_GENERAL("Invalid ELF magic");
+        return false;
+    }
+
+    if (header.machine != hal::kElfMachineType) {
+        TRACE_WARN_GENERAL(
+            "Invalid ELF machine type: expected 0x%X, got 0x%X", hal::kElfMachineType,
+            header.machine
+        );
+        return false;
+    }
+
+    return true;
+}
+}  // namespace
+
+expected<Mem::VPtr<void>, LoadError> ElfLoader::Load(const vfs::Path &path, Mem::AddressSpace &as)
+{
+    auto &vfs = VfsModule::Get();
+
+    // 1. Check if file exists
+    auto exists_res = vfs.FileExists(path);
+    if (!exists_res.has_value() || !exists_res.value()) {
+        return unexpected(LoadError::FileNotFound);
+    }
+
+    // 2. Read ELF Header
+    Elf::Header header;
+    auto read_res = vfs.ReadFile(path, &header, sizeof(header), 0);
+    if (!read_res.has_value() || read_res.value() != sizeof(header)) {
+        return unexpected(LoadError::IoError);
+    }
+
+    // 3. Validate ELF
+    if (!ValidateElfHeader(header)) {
+        return unexpected(LoadError::InvalidElf);
+    }
+
+    // 4. Read Program Headers
+    size_t ph_size     = static_cast<size_t>(header.phnum * header.phentsize);
+    auto ph_buffer_res = Mem::KMalloc(ph_size);
+    if (!ph_buffer_res) {
+        return unexpected(LoadError::MemoryError);
+    }
+
+    // Auto-free buffer on exit
+    VPtr<void> ph_raw = *ph_buffer_res;
+    template_lib::ScopeGuard guard([ph_raw]() {
+        Mem::KFree(ph_raw);
+    });
+
+    read_res = vfs.ReadFile(path, ph_raw, ph_size, header.phoff);
+    if (!read_res.has_value() || read_res.value() != ph_size) {
+        return unexpected(LoadError::IoError);
+    }
+
+    auto *ph_table = reinterpret_cast<Elf::ProgramHeader *>(ph_raw);
+
+    // 5. Load Segments
+    for (u16 i = 0; i < header.phnum; ++i) {
+        auto &ph = ph_table[i];
+        if (ph.type != Elf::ProgramHeader::kTypeLoad) {
+            continue;
+        }
+        if (ph.memsz == 0) {
+            continue;
+        }
+
+        u64 virt_start = AlignDown(ph.vaddr, hal::kPageSizeBytes);
+        u64 virt_end   = AlignUp(ph.vaddr + ph.memsz, hal::kPageSizeBytes);
+        u64 size       = virt_end - virt_start;
+
+        // Permissions
+        VirtualMemAreaFlags flags = {};
+        flags.readable            = (ph.flags & Elf::ProgramHeader::kFlagRead) != 0U;
+        flags.writable            = (ph.flags & Elf::ProgramHeader::kFlagWrite) != 0U;
+        flags.executable          = (ph.flags & Elf::ProgramHeader::kFlagExec) != 0U;
+
+        // Add VMA to Address Space
+        VMemArea vma{
+            .start                = UptrToPtr<void>(virt_start),
+            .size                 = size,
+            .flags                = flags,
+            .type                 = VirtualMemAreaT::Anonymous,
+            .direct_mapping_start = nullptr,
+        };
+
+        if (auto res = MemoryModule::Get().GetVmm().AddArea(&as, vma); !res) {
+            TRACE_WARN_GENERAL("Failed to add VMA for segment %d", i);
+            return unexpected(LoadError::MemoryError);
+        }
+
+        // Copy file data into the mapped region
+        // Since we are in the same address space (kernel), we can just write to the virtual
+        // address. The Page Fault handler will catch the write to the anonymous area and allocate
+        // the page.
+        if (ph.filesz > 0) {
+            void *dest = reinterpret_cast<void *>(ph.vaddr);
+            read_res   = vfs.ReadFile(path, dest, ph.filesz, ph.offset);
+            if (!read_res.has_value() || read_res.value() != ph.filesz) {
+                return unexpected(LoadError::IoError);
+            }
+        }
+
+        // Zero out BSS
+        if (ph.memsz > ph.filesz) {
+            void *bss_dest = reinterpret_cast<void *>(ph.vaddr + ph.filesz);
+            memset(bss_dest, 0, ph.memsz - ph.filesz);
+        }
+
+        TRACE_INFO_GENERAL("Loaded segment %d: [0x%llX - 0x%llX]", i, virt_start, virt_end);
+    }
+
+    u64 entry_point = header.entry;
+    return UptrToPtr<void>(entry_point);
+}
+
+}  // namespace System
diff --git a/kernel/src/sys/loader.hpp b/kernel/src/sys/loader.hpp
new file mode 100644
index 00000000..6fd1ec84
--- /dev/null
+++ b/kernel/src/sys/loader.hpp
@@ -0,0 +1,29 @@
+#ifndef KERNEL_SRC_SYS_LOADER_HPP_
+#define KERNEL_SRC_SYS_LOADER_HPP_
+
+#include <expected.hpp>
+
+#include "mem/virt/addr_space.hpp"
+#include "vfs/path.hpp"
+
+namespace System
+{
+using std::expected;
+
+enum class LoadError : u8 { FileNotFound, InvalidElf, IoError, MemoryError };
+
+class ElfLoader
+{
+    public:
+    /**
+     * @brief Loads an ELF executable from the filesystem into the specified address space.
+     * @param path Path to the ELF file.
+     * @param as The target address space to load into.
+     * @return The entry point address or an error.
+     */
+    static expected<Mem::VPtr<void>, LoadError> Load(const vfs::Path &path, Mem::AddressSpace &as);
+};
+
+}  // namespace System
+
+#endif  // KERNEL_SRC_SYS_LOADER_HPP_
diff --git a/kernel/src/sys/shell.cpp b/kernel/src/sys/shell.cpp
index 63b925bc..2ebb186f 100644
--- a/kernel/src/sys/shell.cpp
+++ b/kernel/src/sys/shell.cpp
@@ -1,9 +1,31 @@
 #include "sys/shell.hpp"
+
 #include <string.h>
-#include <modules/memory.hpp>
-#include <modules/vfs.hpp>
 #include <string.hpp>
-#include <vfs/path.hpp>
+
+#include "modules/memory.hpp"
+#include "modules/vfs.hpp"
+#include "sys/loader.hpp"
+#include "vfs/path.hpp"
+
+// !!! TEMPORARY !!!
+using UserEntry = void (*)(void (*)(const char *));
+
+// Static pointer to the active console for the callback
+static System::GraphicsConsole *g_active_console = nullptr;
+
+extern "C" void KernelPrintHelper(const char *msg)
+{
+    if (g_active_console) {
+        g_active_console->Write(
+            std::span<const byte>(reinterpret_cast<const byte *>(msg), strlen(msg))
+        );
+    } else {
+        // Fallback or ignore
+    }
+}
+
+// !!! TEMPORARY !!!
 
 namespace System
 {
@@ -11,6 +33,9 @@ namespace System
 Shell::Shell(GraphicsConsole &console, IO::IReader &input_reader)
     : console_(console), input_reader_(input_reader), current_dir_(vfs::Path::kRoot)
 {
+    // !!! TEMPORARY !!!
+    g_active_console = &console_;
+    // !!! TEMPORARY !!!
 }
 
 void Shell::Init()
@@ -90,6 +115,10 @@ void Shell::ProcessCommand()
         CmdCat(args);
     } else if (cmd == "pwd") {
         CmdPwd();
+    } else if (cmd.starts_with("./")) {
+        CmdExec(cmd.substr(2));
+    } else if (cmd == "exec") {
+        CmdExec(args);
     } else {
         console_.Write(
             std::span<const byte>(reinterpret_cast<const byte *>("Unknown command: "), 17)
@@ -111,7 +140,9 @@ void Shell::CmdHelp()
         "  pwd         - Print working directory\n"
         "  cd <path>   - Change directory\n"
         "  ls [path]   - List directory contents\n"
-        "  cat <file>  - Display file contents\n";
+        "  cat <file>  - Display file contents\n"
+        "  exec <file> - Execute a user program\n"
+        "  ./<file>    - Execute a user program\n";
     console_.Write(std::span<const byte>(reinterpret_cast<const byte *>(msg), strlen(msg)));
 }
 
@@ -304,4 +335,48 @@ void Shell::CmdCat(std::string_view args)
     console_.PutChar('\n');
 }
 
+void Shell::CmdExec(std::string_view args)
+{
+    // Trim leading/trailing spaces
+    while (!args.empty() && args.front() == ' ') {
+        args.remove_prefix(1);
+    }
+    while (!args.empty() && args.back() == ' ') {
+        args.remove_suffix(1);
+    }
+
+    if (args.empty()) {
+        const char *err = "exec: missing file operand\n";
+        console_.Write(std::span<const byte>(reinterpret_cast<const byte *>(err), strlen(err)));
+        return;
+    }
+
+    vfs::Path programPath = ResolvePath(args);
+
+    auto &as       = MemoryModule::Get().GetKernelAddressSpace();
+    auto entry_res = ElfLoader::Load(programPath, as);
+
+    if (entry_res) {
+        Mem::VPtr<void> entry_addr = entry_res.value();
+        auto user_main             = reinterpret_cast<UserEntry>(entry_addr);
+
+        console_.Write(
+            std::span<const byte>(reinterpret_cast<const byte *>("Executing user program...\n"), 26)
+        );
+
+        // Execute the program
+        user_main(&KernelPrintHelper);
+
+        console_.Write(
+            std::span<const byte>(reinterpret_cast<const byte *>("User program returned.\n"), 23)
+        );
+    } else {
+        console_.Write(
+            std::span<const byte>(
+                reinterpret_cast<const byte *>("Failed to load executable.\n"), 27
+            )
+        );
+    }
+}
+
 }  // namespace System
diff --git a/kernel/src/sys/shell.hpp b/kernel/src/sys/shell.hpp
index 1b5e9715..669aa380 100644
--- a/kernel/src/sys/shell.hpp
+++ b/kernel/src/sys/shell.hpp
@@ -52,6 +52,7 @@ class Shell
     void CmdCd(std::string_view args);
     void CmdLs(std::string_view args);
     void CmdCat(std::string_view args);
+    void CmdExec(std::string_view args);
     void CmdPwd();
 
     // -------------------------------------------------------------------------
diff --git a/kernel/src/vfs/path.hpp b/kernel/src/vfs/path.hpp
index 425f499b..edd91160 100644
--- a/kernel/src/vfs/path.hpp
+++ b/kernel/src/vfs/path.hpp
@@ -83,12 +83,41 @@ class Path
         Parse();
     }
 
-    Path(const Path &other)                = default;
-    Path(Path &&other) noexcept            = default;
-    Path &operator=(const Path &other)     = default;
-    Path &operator=(Path &&other) noexcept = default;
+    Path(const Path &other)
+    {
+        raw_path_ = other.raw_path_;
+        path_len_ = other.path_len_;
+        Parse();
+    }
+
+    Path &operator=(const Path &other)
+    {
+        if (this != &other) {
+            raw_path_ = other.raw_path_;
+            path_len_ = other.path_len_;
+            Parse();
+        }
+        return *this;
+    }
+
+    Path(Path &&other) noexcept
+    {
+        raw_path_ = other.raw_path_;
+        path_len_ = other.path_len_;
+        Parse();
+    }
+
+    Path &operator=(Path &&other) noexcept
+    {
+        if (this != &other) {
+            raw_path_ = other.raw_path_;
+            path_len_ = other.path_len_;
+            Parse();
+        }
+        return *this;
+    }
 
-    // --- Basic properties ---
+    // Basic properties
     bool IsEmpty() const noexcept { return path_len_ == 0; }
     bool IsAbsolute() const noexcept { return is_absolute_; }
     bool IsRelative() const noexcept { return !is_absolute_; }
@@ -100,7 +129,7 @@ class Path
         return std::string_view(raw_path_.data(), path_len_);
     }
 
-    // --- Component access ---
+    // Component access
     size_t ComponentCount() const noexcept { return num_components_; }
     bool HasComponents() const noexcept { return num_components_ > 0; }
 
@@ -158,7 +187,7 @@ class Path
         return parent;
     }
 
-    // --- Iterator interface ---
+    // Iterator interface
     using iterator       = PathIterator;
     using const_iterator = PathIterator;
 
@@ -169,7 +198,7 @@ class Path
     const_iterator cbegin() const { return begin(); }
     const_iterator cend() const { return end(); }
 
-    // --- Path manipulation ---
+    // Path manipulation
     Path operator/(const Path &other) const
     {
         if (other.IsAbsolute())
@@ -205,7 +234,7 @@ class Path
         return *this /= Path(std::forward<T>(component));
     }
 
-    // --- Canonical path operations ---
+    // Canonical path operations
     Path GetWeaklyCanonical() const
     {
         Path canonical;
@@ -241,7 +270,7 @@ class Path
 
     Path GetNormalized() const { return GetWeaklyCanonical(); }
 
-    // --- Callback-based iteration ---
+    // Callback-based iteration
     template <PathComponentCallback Callback>
     void ForEachComponent(Callback &&callback) const
     {
@@ -270,7 +299,7 @@ class Path
         }
     }
 
-    // --- Comparison operators ---
+    // Comparison operators
     bool operator==(const Path &other) const noexcept
     {
         if (is_absolute_ != other.is_absolute_ || num_components_ != other.num_components_) {
@@ -306,7 +335,7 @@ class Path
         return num_components_ < other.num_components_;
     }
 
-    // --- Static utility methods ---
+    // Static utility methods
 
     template <PathStringLike... Args>
     static Path Join(Args &&...args)
diff --git a/rootfs/CMakeLists.txt b/rootfs/CMakeLists.txt
index 94066710..eb8fd80e 100644
--- a/rootfs/CMakeLists.txt
+++ b/rootfs/CMakeLists.txt
@@ -31,3 +31,10 @@ else()
             ROOTFS_OVERLAY_DIR ${CMAKE_CURRENT_SOURCE_DIR}/overlay
     )
 endif()
+
+set(USERSPACE_BIN_DIR "${CMAKE_BINARY_DIR}/userspace_bin")
+alkos_add_to_bash_config("CONF_USERSPACE_BIN_DIR" "${USERSPACE_BIN_DIR}")
+
+if(TARGET rootfs AND TARGET userspace_apps)
+    add_dependencies(rootfs userspace_apps)
+endif()
diff --git a/scripts/actions/make_rootfs.bash b/scripts/actions/make_rootfs.bash
index 9df143fe..59f34f59 100755
--- a/scripts/actions/make_rootfs.bash
+++ b/scripts/actions/make_rootfs.bash
@@ -44,6 +44,16 @@ copy_overlay_files() {
     fi
 }
 
+copy_userspace_files() {
+    local userspace_dir="${CONF_USERSPACE_BIN_DIR}"
+    local target_dir="${CONF_ROOTFS_DIR}/bin"
+
+    if [[ -n "${userspace_dir}" && -d "${userspace_dir}" ]]; then
+        mkdir -p "${target_dir}"
+        cp -v "${userspace_dir}"/* "${target_dir}/" || true
+    fi
+}
+
 run_delegate() {
     local fs_type="$(argparse_get "filesystem")"
     local fs_script="${MAKE_ROOTFS_IMPL_DIR}/make_${fs_type}.bash"
@@ -61,6 +71,7 @@ run_delegate() {
 main() {
     parse_args "$@"
     copy_overlay_files
+    copy_userspace_files
     run_delegate
 }
 
diff --git a/userspace/.gitignore b/userspace/.gitignore
new file mode 100644
index 00000000..71860a75
--- /dev/null
+++ b/userspace/.gitignore
@@ -0,0 +1 @@
+!build
diff --git a/userspace/CMakeLists.txt b/userspace/CMakeLists.txt
new file mode 100644
index 00000000..c67d5275
--- /dev/null
+++ b/userspace/CMakeLists.txt
@@ -0,0 +1,49 @@
+message(STATUS "Configuring Userspace programs...")
+
+# !!!
+# NOTE: Hardcoded logic for x86_64 for now
+# !!!
+
+# Directory where we collect user binaries
+set(USERSPACE_BIN_DIR "${CMAKE_BINARY_DIR}/userspace_bin")
+file(MAKE_DIRECTORY ${USERSPACE_BIN_DIR})
+
+set(USER_LINKER_SCRIPT "${CMAKE_CURRENT_SOURCE_DIR}/build/linker.ld")
+# Temporarily hardcode x86_64 stub for passing printf
+# To be removed after proper libc is done
+set(CRT0_SRC "${CMAKE_CURRENT_SOURCE_DIR}/crt0.nasm")
+
+# Create a target to collect all user programs
+add_custom_target(userspace_apps COMMENT "Building all userspace applications")
+
+function(add_user_program PROG_NAME SRC_FILES)
+    add_executable(${PROG_NAME} ${CRT0_SRC} ${SRC_FILES})
+    
+    # Temporarily hardcode flags for x86_64
+    target_compile_options(${PROG_NAME} PRIVATE
+        $<$<COMPILE_LANGUAGE:CXX>:
+            -fno-builtin
+            -fno-rtti
+            -fno-exceptions
+            -fno-stack-protector
+            -mcmodel=small
+            -mno-red-zone
+        >
+    )
+
+    target_link_options(${PROG_NAME} PRIVATE
+        -T "${USER_LINKER_SCRIPT}"
+        -nostdlib
+        -z max-page-size=0x1000
+        -static
+    )
+
+    add_custom_command(TARGET ${PROG_NAME} POST_BUILD
+        COMMAND ${CMAKE_COMMAND} -E copy $<TARGET_FILE:${PROG_NAME}> ${USERSPACE_BIN_DIR}/${PROG_NAME}
+        COMMENT "Installing ${PROG_NAME} to ${USERSPACE_BIN_DIR}"
+    )
+    
+    add_dependencies(userspace_apps ${PROG_NAME})
+endfunction()
+
+add_user_program(hello programs/hello_world/main.cpp)
diff --git a/userspace/build/linker.ld b/userspace/build/linker.ld
new file mode 100644
index 00000000..ae5a1d6c
--- /dev/null
+++ b/userspace/build/linker.ld
@@ -0,0 +1,24 @@
+ENTRY(_start)
+
+SECTIONS
+{
+    /* Standard User Space Entry Point */
+    . = 0x400000;
+
+    .text : ALIGN(4K) {
+        *(.text)
+    }
+
+    .rodata : ALIGN(4K) {
+        *(.rodata)
+    }
+
+    .data : ALIGN(4K) {
+        *(.data)
+    }
+
+    .bss : ALIGN(4K) {
+        *(COMMON)
+        *(.bss)
+    }
+}
diff --git a/userspace/crt0.nasm b/userspace/crt0.nasm
new file mode 100644
index 00000000..5685d4a2
--- /dev/null
+++ b/userspace/crt0.nasm
@@ -0,0 +1,22 @@
+; !!! Temporary file 
+; !!! Will be deleted after userspace is linked against libc
+
+bits 64
+global _start
+extern main
+
+section .bss
+    global g_print_fn
+    g_print_fn: resq 1
+
+section .text
+_start:
+    ; System V ABI: The first argument (RDI) passed by the kernel
+    ; contains the function pointer to the print helper.
+    mov [rel g_print_fn], rdi
+
+    ; Call the main C++ function
+    call main
+
+    ; Return to kernel (for now, just ret, kernel wrapper will handle this)
+    ret
diff --git a/userspace/programs/hello_world/main.cpp b/userspace/programs/hello_world/main.cpp
new file mode 100644
index 00000000..55d4a73d
--- /dev/null
+++ b/userspace/programs/hello_world/main.cpp
@@ -0,0 +1,15 @@
+extern "C" void (*g_print_fn)(const char *);
+
+void print(const char *msg)
+{
+    if (g_print_fn) {
+        g_print_fn(msg);
+    }
+}
+
+extern "C" int main()
+{
+    print("Hello from User Space (Address 0x400000)!\n");
+    print("I was loaded from the file system.\n");
+    return 0;
+}

From 045f0e93bc2e151f084d2bdaedddac6530b0f723 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C5=81ukasz=20Kryczka?=
 <60490378+kryczkal@users.noreply.github.com>
Date: Sat, 27 Dec 2025 19:43:01 +0100
Subject: [PATCH 19/56] MMU Proper Unmap function (#244)

## Problem
MMU was simplfied and there was no recursive unmapping of previous
pages.

## Solution
Implemented reference counting for all page directories in the page
metadata, that allowed to know when to cleanup an entry.
Implemneted cleaning up stale entries.
---
 kernel/arch/x86_64/src/hal/impl/mmu.cpp | 192 ++++++++++++++++++++++--
 kernel/arch/x86_64/src/hal/impl/mmu.hpp |   5 -
 kernel/arch/x86_64/src/hal/impl/mmu.tpp | 122 ---------------
 kernel/src/mem/page_meta.hpp            |  23 +++
 kernel/src/mem/virt/page_fault.cpp      |   7 +-
 kernel/src/mem/virt/vmm.cpp             |  11 +-
 kernel/src/modules/memory.cpp           |  12 ++
 7 files changed, 226 insertions(+), 146 deletions(-)
 delete mode 100644 kernel/arch/x86_64/src/hal/impl/mmu.tpp

diff --git a/kernel/arch/x86_64/src/hal/impl/mmu.cpp b/kernel/arch/x86_64/src/hal/impl/mmu.cpp
index 145cbac5..5459f301 100644
--- a/kernel/arch/x86_64/src/hal/impl/mmu.cpp
+++ b/kernel/arch/x86_64/src/hal/impl/mmu.cpp
@@ -1,7 +1,8 @@
 #include "hal/impl/mmu.hpp"
-#include <macros.hpp>
 
+#include <macros.hpp>
 #include <modules/memory.hpp>
+
 #include "mem/page_map.hpp"
 
 using namespace arch;
@@ -10,6 +11,25 @@ using namespace Mem;
 using std::expected;
 using std::unexpected;
 
+namespace
+{
+
+// Helper to get PageMeta from a physical pointer to a table/page
+PageMeta &GetPageMeta(PPtr<void> phys_ptr)
+{
+    auto *aligned_phys = AlignDown(phys_ptr, hal::kPageSizeBytes);
+    return MemoryModule::Get().GetPageMetaTable().GetPageMeta(aligned_phys);
+}
+
+// Helper to get PageMeta from a virtual pointer (e.g. inside a table)
+PageMeta &GetPageMetaFromVirt(VPtr<void> virt_ptr)
+{
+    auto *phys_ptr = VirtToPhys(virt_ptr);
+    return GetPageMeta(phys_ptr);
+}
+
+}  // namespace
+
 u64 Mmu::ToArchFlags(PageFlags flags)
 {
     u64 arch_flags = 0;
@@ -37,6 +57,110 @@ u64 Mmu::ToArchFlags(PageFlags flags)
     return arch_flags;
 }
 
+template <size_t kLevel>
+u64 Mmu::PmeIdx(Mem::VPtr<void> vaddr)
+{
+    static_assert(kLevel > 0);
+    static_assert(kLevel <= 4);
+
+    static constexpr u64 kDefaultOffset     = 12;
+    static constexpr u64 kBitOffsetPerLevel = 9;
+
+    static constexpr u32 kIndexMask = kBitMaskRight<u64, 9>;
+    uptr addr                       = Mem::PtrToUptr(vaddr);
+    return (addr >> (kDefaultOffset + (kLevel - 1) * kBitOffsetPerLevel)) & kIndexMask;
+}
+
+template <size_t kLevel>
+expected<Mem::VPtr<PageMapEntry<kLevel>>, Mem::MemError> Mmu::WalkToEntry(
+    Mem::VPtr<Mem::AddressSpace> as, Mem::VPtr<void> vaddr, bool create_if_missing
+)
+{
+    static_assert(kLevel > 0);
+    static_assert(kLevel <= 4);
+
+    static constexpr u64 kDefFlags = kPresentBit | kWriteBit | kUserAccessibleBit;
+
+    // Helper lambda to process each level
+    auto ProcessLevel = [&]<size_t L>(
+                            Mem::VPtr<PageMapEntry<L>> pme, bool create
+                        ) -> expected<Mem::VPtr<PageMapEntry<L - 1>>, Mem::MemError> {
+        if (pme->IsPresent()) {
+            return reinterpret_cast<PageMapEntry<L - 1> *>(
+                Mem::PhysToVirt(pme->GetNextLevelTable())
+            );
+        }
+
+        if (!create) {
+            return unexpected(Mem::MemError::NotFound);
+        }
+
+        auto res = Mem::KMalloc<PageMapTable<L - 1>>();
+        if (!res) {
+            return unexpected(res.error());
+        }
+
+        memset(*res, 0, sizeof(PageMapTable<L - 1>));
+
+        // Initialize Metadata for the new table
+        auto *table_phys = Mem::VirtToPhys(*res);
+        auto &new_meta   = GetPageMeta(table_phys);
+        // pme points inside the parent table
+        auto &parent_meta = GetPageMetaFromVirt(pme);
+
+        new_meta.InitPageTable(L - 1, &parent_meta);
+        pme->SetNextLevelTable(table_phys, kDefFlags);
+
+        // Increment parent ref count
+        PageMeta::AsPageTable(parent_meta).ref_count++;
+
+        return reinterpret_cast<PageMapEntry<L - 1> *>(*res);
+    };
+
+    // PML4
+    auto *pmt_l4 = reinterpret_cast<PageMapEntry<4> *>(Mem::PhysToVirt(as->PageTableRoot()));
+    auto *pme_l4 = &pmt_l4[PmeIdx<4>(vaddr)];
+
+    if constexpr (kLevel == 4) {
+        return pme_l4;
+    }
+
+    // PDP (L3)
+    auto res_l3 = ProcessLevel.template operator()<4>(pme_l4, create_if_missing);
+    if (!res_l3) {
+        return unexpected(res_l3.error());
+    }
+    auto *pme_l3 = &(*res_l3)[PmeIdx<3>(vaddr)];
+
+    if constexpr (kLevel == 3) {
+        return pme_l3;
+    }
+
+    // PD (L2)
+    auto res_l2 = ProcessLevel.template operator()<3>(pme_l3, create_if_missing);
+    if (!res_l2) {
+        return unexpected(res_l2.error());
+    }
+    auto *pme_l2 = &(*res_l2)[PmeIdx<2>(vaddr)];
+
+    if constexpr (kLevel == 2) {
+        return pme_l2;
+    }
+
+    // PT (L1)
+    auto res_l1 = ProcessLevel.template operator()<2>(pme_l2, create_if_missing);
+    if (!res_l1) {
+        return unexpected(res_l1.error());
+    }
+    auto *pme_l1 = &(*res_l1)[PmeIdx<1>(vaddr)];
+
+    if constexpr (kLevel == 1) {
+        return pme_l1;
+    }
+
+    return unexpected(Mem::MemError::InvalidArgument);
+}
+
 expected<void, MemError> Mmu::Map(
     VPtr<AddressSpace> as, VPtr<void> vaddr, PPtr<void> paddr, PageFlags flags
 )
@@ -44,14 +168,18 @@ expected<void, MemError> Mmu::Map(
     auto res = WalkToEntry<1>(as, vaddr, true);
     UNEXPECTED_RET_IF_ERR(res);
 
-    auto pme_l1 = *res;
+    auto *pme_l1 = *res;
     if (pme_l1->IsPresent()) {
-        // Page is already mapped, unmap first
+        // Page is already mapped
         return unexpected(MemError::InvalidArgument);
     }
 
     pme_l1->SetFrameAddress(paddr, ToArchFlags(flags));
 
+    // Increment Page Table (L1) ref count
+    auto &meta = GetPageMetaFromVirt(pme_l1);
+    PageMeta::AsPageTable(meta).ref_count++;
+
     MemoryModule::Get().GetTlb().InvalidatePage(vaddr);
 
     return {};
@@ -59,16 +187,62 @@ expected<void, MemError> Mmu::Map(
 
 expected<void, MemError> Mmu::UnMap(VPtr<AddressSpace> as, VPtr<void> vaddr)
 {
+    // 1. Find Leaf (L1 entry)
     auto res = WalkToEntry<1>(as, vaddr, false);
-    UNEXPECTED_RET_IF_ERR(res);
+    if (!res) {
+        return {};  // Already unmapped
+    }
 
-    auto pme_l1 = *res;
+    auto *pme_l1 = *res;
     if (!pme_l1->IsPresent()) {
-        return {};  // Already unmapped
+        return {};  // Entry not present
     }
 
-    // Clear the entry
-    *reinterpret_cast<u64 *>(pme_l1) = 0;
+    // 2. Clear Entry
+    pme_l1->SetFrameAddress(0, 0);
+
+    // 3. Update RefCount
+    auto *l1_table_virt = AlignDown(pme_l1, hal::kPageSizeBytes);
+    auto &l1_meta       = GetPageMetaFromVirt(l1_table_virt);
+
+    auto *curr_meta = &l1_meta;
+    u8 curr_level   = 1;
+
+    PageMeta::AsPageTable(*curr_meta).ref_count--;
+
+    // 4. Cleanup loop
+    while (PageMeta::AsPageTable(*curr_meta).ref_count == 0 && curr_level < 4) {
+        auto *parent_meta = PageMeta::AsPageTable(*curr_meta).parent;
+        if (parent_meta == nullptr) {
+            break;
+        }
+
+        // Get parent table physical address from its metadata
+        size_t parent_pfn = MemoryModule::Get().GetPageMetaTable().GetPageFrameNumber(parent_meta);
+        auto *parent_table_virt =
+            reinterpret_cast<u64 *>(Mem::PhysToVirt(PageFrameAddr(parent_pfn)));
+
+        u64 idx = 0;
+        if (curr_level == 1) {
+            idx = PmeIdx<2>(vaddr);
+        } else if (curr_level == 2) {
+            idx = PmeIdx<3>(vaddr);
+        } else if (curr_level == 3) {
+            idx = PmeIdx<4>(vaddr);
+        }
+
+        // Clear entry in parent
+        parent_table_virt[idx] = 0;
+
+        // Free current table page
+        size_t curr_pfn = MemoryModule::Get().GetPageMetaTable().GetPageFrameNumber(curr_meta);
+        Mem::KFree(Mem::PhysToVirt(PageFrameAddr(curr_pfn)));
+
+        // Move up to parent
+        curr_meta = parent_meta;
+        curr_level++;
+        PageMeta::AsPageTable(*curr_meta).ref_count--;
+    }
 
     MemoryModule::Get().GetTlb().InvalidatePage(vaddr);
 
@@ -80,7 +254,7 @@ expected<PPtr<void>, MemError> Mmu::Translate(VPtr<AddressSpace> as, VPtr<void>
     auto res = WalkToEntry<1>(as, vaddr, false);
     UNEXPECTED_RET_IF_ERR(res);
 
-    auto pme_l1 = *res;
+    auto *pme_l1 = *res;
     if (!pme_l1->IsPresent()) {
         return unexpected(MemError::InvalidArgument);
     }
diff --git a/kernel/arch/x86_64/src/hal/impl/mmu.hpp b/kernel/arch/x86_64/src/hal/impl/mmu.hpp
index d4913561..80b66039 100644
--- a/kernel/arch/x86_64/src/hal/impl/mmu.hpp
+++ b/kernel/arch/x86_64/src/hal/impl/mmu.hpp
@@ -40,9 +40,6 @@ class Mmu : public MmuAPI
 
     u64 ToArchFlags(PageFlags flags);
 
-    template <size_t kLevel = 0>
-    void DestroyPageMapEntry(Mem::VPtr<PageMapEntry<kLevel>> pme);
-
     template <size_t kLevel = 0>
     expected<Mem::VPtr<PageMapEntry<kLevel>>, Mem::MemError> WalkToEntry(
         Mem::VPtr<Mem::AddressSpace> as, Mem::VPtr<void> vaddr, bool create_if_missing = false
@@ -51,6 +48,4 @@ class Mmu : public MmuAPI
 
 }  // namespace arch
 
-#include "hal/impl/mmu.tpp"
-
 #endif  // KERNEL_ARCH_X86_64_SRC_HAL_IMPL_MMU_HPP_
diff --git a/kernel/arch/x86_64/src/hal/impl/mmu.tpp b/kernel/arch/x86_64/src/hal/impl/mmu.tpp
deleted file mode 100644
index d3d43aa6..00000000
--- a/kernel/arch/x86_64/src/hal/impl/mmu.tpp
+++ /dev/null
@@ -1,122 +0,0 @@
-#ifndef ALKOS_KERNEL_ARCH_X86_64_SRC_HAL_IMPL_MMU_TPP_
-#define ALKOS_KERNEL_ARCH_X86_64_SRC_HAL_IMPL_MMU_TPP_
-
-#include "hal/impl/mmu.hpp"
-#include "mem/heap.hpp"
-
-#include <mem/types.hpp>
-#include <types.hpp>
-
-namespace arch
-{
-
-using std::expected;
-using std::unexpected;
-
-template <size_t kLevel>
-u64 Mmu::PmeIdx(Mem::VPtr<void> vaddr)
-{
-    static_assert(kLevel > 0);
-    static_assert(kLevel <= 4);
-
-    static constexpr u64 kDefaultOffset     = 12;
-    static constexpr u64 kBitOffsetPerLevel = 9;
-
-    static constexpr u32 kIndexMask = kBitMaskRight<u64, 9>;
-    uptr addr                       = Mem::PtrToUptr(vaddr);
-    return (addr >> (kDefaultOffset + (kLevel - 1) * kBitOffsetPerLevel)) & kIndexMask;
-}
-
-template <size_t kLevel = 0>
-void DestroyPageMapEntry(Mem::VPtr<PageMapEntry<kLevel>> pme)
-{
-    static_assert(kLevel > 0);
-    static_assert(kLevel <= 4);
-}
-
-template <size_t kLevel>
-expected<Mem::VPtr<PageMapEntry<kLevel>>, Mem::MemError> Mmu::WalkToEntry(
-    Mem::VPtr<Mem::AddressSpace> as, Mem::VPtr<void> vaddr, bool create_if_missing
-)
-{
-    static_assert(kLevel > 0);
-    static_assert(kLevel <= 4);
-
-    static constexpr u64 kDefFlags = kPresentBit | kWriteBit | kUserAccessibleBit;
-
-    // PML4
-    auto *pmt_l4 = reinterpret_cast<PageMapEntry<4> *>(Mem::PhysToVirt(as->PageTableRoot()));
-    auto *pme_l4 = &pmt_l4[PmeIdx<4>(vaddr)];
-
-    if (!pme_l4->IsPresent()) {
-        if (!create_if_missing) {
-            return unexpected(Mem::MemError::NotFound);
-        }
-
-        auto res = Mem::KMalloc<PageMapTable<3>>();
-        if (!res) {
-            return unexpected(res.error());
-        }
-
-        memset(*res, 0, sizeof(PageMapTable<3>));
-        pme_l4->SetNextLevelTable(Mem::VirtToPhys(*res), kDefFlags);
-    }
-    if constexpr (kLevel == 4)
-        return pme_l4;
-
-    // PDP (L3)
-    auto *pmt_l3 =
-        reinterpret_cast<PageMapEntry<3> *>(Mem::PhysToVirt(pme_l4->GetNextLevelTable()));
-    auto *pme_l3 = &pmt_l3[PmeIdx<3>(vaddr)];
-
-    if (!pme_l3->IsPresent()) {
-        if (!create_if_missing) {
-            return unexpected(Mem::MemError::NotFound);
-        }
-
-        auto res = Mem::KMalloc<PageMapTable<2>>();
-        if (!res) {
-            return unexpected(res.error());
-        }
-
-        memset(*res, 0, sizeof(PageMapTable<2>));
-        pme_l3->SetNextLevelTable(Mem::VirtToPhys(*res), kDefFlags);
-    }
-    if constexpr (kLevel == 3)
-        return pme_l3;
-
-    // PD (L2)
-    auto *pmt_l2 =
-        reinterpret_cast<PageMapEntry<2> *>(Mem::PhysToVirt(pme_l3->GetNextLevelTable()));
-    auto *pme_l2 = &pmt_l2[PmeIdx<2>(vaddr)];
-
-    if (!pme_l2->IsPresent()) {
-        if (!create_if_missing) {
-            return unexpected(Mem::MemError::NotFound);
-        }
-
-        auto res = Mem::KMalloc<PageMapTable<1>>();
-        if (!res) {
-            return unexpected(res.error());
-        }
-
-        memset(*res, 0, sizeof(PageMapTable<1>));
-        pme_l2->SetNextLevelTable(Mem::VirtToPhys(*res), kDefFlags);
-    }
-    if constexpr (kLevel == 2)
-        return pme_l2;
-
-    // PT (L1)
-    auto *pmt_l1 =
-        reinterpret_cast<PageMapEntry<1> *>(Mem::PhysToVirt(pme_l2->GetNextLevelTable()));
-    auto *pme_l1 = &pmt_l1[PmeIdx<1>(vaddr)];
-
-    if constexpr (kLevel == 1)
-        return pme_l1;
-
-    return unexpected(Mem::MemError::InvalidArgument);
-}
-
-}  // namespace arch
-
-#endif  // ALKOS_KERNEL_ARCH_X86_64_SRC_HAL_IMPL_MMU_TPP_
diff --git a/kernel/src/mem/page_meta.hpp b/kernel/src/mem/page_meta.hpp
index e756235f..a0ce8b91 100644
--- a/kernel/src/mem/page_meta.hpp
+++ b/kernel/src/mem/page_meta.hpp
@@ -22,6 +22,7 @@ enum class PageMetaType : u8 {
     Buddy,
     Allocated,
     Slab,
+    PageTable,
     Dummy,
 };
 
@@ -40,6 +41,12 @@ struct SlabMeta {
     u16 inuse;
 } PACK;
 
+struct PageTableMeta {
+    VPtr<PageMeta> parent;
+    u16 ref_count;
+    u8 level;
+} PACK;
+
 struct AllocatedMeta {
     u8 _unused[16];
 } PACK;
@@ -52,6 +59,7 @@ struct PageMeta {
     union {
         BuddyMeta buddy;
         SlabMeta slab;
+        PageTableMeta page_table;
         AllocatedMeta allocated;
         DummyMeta dummy;
     } data;
@@ -82,6 +90,15 @@ struct PageMeta {
         data.slab.inuse    = inuse;
     }
 
+    void InitPageTable(u8 level, VPtr<PageMeta> parent)
+    {
+        type                      = PageMetaType::PageTable;
+        this->order               = 0;
+        data.page_table.ref_count = 0;
+        data.page_table.level     = level;
+        data.page_table.parent    = parent;
+    }
+
     void InitAllocated(u8 order)
     {
         type        = PageMetaType::Allocated;
@@ -100,6 +117,12 @@ struct PageMeta {
         return meta.data.slab;
     }
 
+    static PageTableMeta &AsPageTable(PageMeta &meta)
+    {
+        ASSERT_EQ(meta.type, PageMetaType::PageTable);
+        return meta.data.page_table;
+    }
+
     static AllocatedMeta &AsAllocated(PageMeta &meta)
     {
         ASSERT_EQ(meta.type, PageMetaType::Allocated);
diff --git a/kernel/src/mem/virt/page_fault.cpp b/kernel/src/mem/virt/page_fault.cpp
index d80406f1..93009926 100644
--- a/kernel/src/mem/virt/page_fault.cpp
+++ b/kernel/src/mem/virt/page_fault.cpp
@@ -3,7 +3,6 @@
 #include "hal/intr_parser.hpp"
 #include "hal/panic.hpp"
 #include "mem/virt/page_fault.hpp"
-#include "modules/hardware.hpp"
 #include "modules/memory.hpp"
 #include "trace_framework.hpp"
 
@@ -12,7 +11,7 @@ namespace Mem
 
 void PageFaultHandler(intr::LitExcEntry &, hal::ExceptionData *data)
 {
-    TRACE_INFO_GENERAL("PageFaultHandler: Handling Anonymous VMA");
+    TRACE_INFO_GENERAL("PageFaultHandler: Enter");
     using namespace hal;
     ASSERT_NOT_NULL(data);
 
@@ -45,8 +44,8 @@ void PageFaultHandler(intr::LitExcEntry &, hal::ExceptionData *data)
             if (!new_page_or_error) {
                 hal::KernelPanic("Out of memory during page fault handling");
             }
-            auto new_page_phys = *new_page_or_error;
-            auto new_page_virt = Mem::PhysToVirt(new_page_phys);
+            auto *new_page_phys = *new_page_or_error;
+            auto *new_page_virt = Mem::PhysToVirt(new_page_phys);
 
             memset(new_page_virt, 0, hal::kPageSizeBytes);
 
diff --git a/kernel/src/mem/virt/vmm.cpp b/kernel/src/mem/virt/vmm.cpp
index 94242ffe..50c31f5f 100644
--- a/kernel/src/mem/virt/vmm.cpp
+++ b/kernel/src/mem/virt/vmm.cpp
@@ -31,9 +31,8 @@ expected<VirtualPtr<AddressSpace>, MemError> Vmm::CreateAddrSpace()
 expected<void, MemError> Vmm::DestroyAddrSpace(VPtr<AddressSpace> as)
 {
     for (const VMemArea &vma : *as) {
-        // Unmap all pages in the VMA
-        mmu_->UnMapRange(as, vma.start, vma.size);
-        tlb_->InvalidateRange(vma.start, vma.size);
+        auto res = RmArea(as, vma.start);
+        UNEXPECTED_RET_IF_ERR(res);
     }
     KFree(as);
     return {};
@@ -58,9 +57,9 @@ expected<void, MemError> Vmm::RmArea(VPtr<AddrSp> as, VPtr<void> region_start)
     // Get area start/end
     auto a_or_err = as->FindArea(region_start);
     UNEXPECTED_RET_IF_ERR(a_or_err);
-    auto area  = *a_or_err;
-    auto start = area->start;
-    auto size  = area->size;
+    auto *area  = *a_or_err;
+    auto *start = area->start;
+    auto size   = area->size;
 
     // Unmap the range
     auto unmap_res = mmu_->UnMapRange(as, start, size);
diff --git a/kernel/src/modules/memory.cpp b/kernel/src/modules/memory.cpp
index 64728818..3c571bfd 100644
--- a/kernel/src/modules/memory.cpp
+++ b/kernel/src/modules/memory.cpp
@@ -32,6 +32,18 @@ internal::MemoryModule::MemoryModule(const BootArguments &args) noexcept
     // could offload this operation to.
     BuddyPmm_.Init(BitmapPmm_, PageMetaTable_, kInitialBuddyPagesLimit);
 
+    // Initialize metadata for the Kernel PML4 (Root Page Table).
+    // The bootloader passes it, so it's already allocated but its metadata
+    // needs to be correctly set as a PageTable to support MMU operations.
+    {
+        auto &root_meta = PageMetaTable_.GetPageMeta(args.root_page_table);
+
+        // Initialize as a Level 4 page table with no parent.
+        // We set ref_count to 1 to represent the kernel's static presence and prevent freeing.
+        root_meta.InitPageTable(4, nullptr);
+        root_meta.data.page_table.ref_count = 1;
+    }
+
     SlabAllocator_.Init(BuddyPmm_);
 
     Heap_.Init(PageMetaTable_, BuddyPmm_, SlabAllocator_);

From e354c98eff24911dcfccff56f1bc44ae74095a7b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C5=81ukasz=20Kryczka?=
 <60490378+kryczkal@users.noreply.github.com>
Date: Sat, 27 Dec 2025 23:54:47 +0100
Subject: [PATCH 20/56] Kryczkal/vmm coherency (#245)

## Problem
Since leaving bootloader, there were still some issues and
inconsistencies with the state of AlkOS kernel.
Namely:
- The first 10gb of mem were still identity mapped by the bootloader (a
legacy mapping)
- The kernel was mapped into the vmem, but the virtual memory manager
wasn't AWARE that the kernel itself is mapped.
- The hardware (page tables) and software (bookkeeping info) were
desynced

## Solution
This PR:
- Tears down all memory mappings below the higher half
- Implements bookkeeping that allows to effectively unmap pages
- Synchronizes hardware with the bookkeeping structures
- Fixes all legacy direct uses of physical ptrs

## Bugs
Tearing down the identity mapping exposed a BUG which behaved this way:
- The MSR GsBase register is set up to point to a valid address
- After flushing a new GDT, the MSR GsBase is set to 0x0 as a side
effect
- The GsBase is not adjusted, so it points to 0x0
- 0x0 is a valid address under the legacy mapping. Code reads garbage
- After tearing down the legacy mapping it stops working
- This means the trace framework itself is paralyzed and doesn't work
- Nothing is reported or logged. Just random crash SOMEWHERE.
This is fixed. :DD and it took me a long time.
---
 kernel/arch/x86_64/CMakeLists.txt             |  2 +-
 .../arch/x86_64/src/drivers/apic/io_apic.cpp  |  8 +-
 .../x86_64/src/drivers/apic/local_apic.hpp    | 14 +--
 kernel/arch/x86_64/src/drivers/hpet/hpet.hpp  | 13 +--
 kernel/arch/x86_64/src/hal/impl/core.cpp      |  3 +-
 .../arch/x86_64/src/hal/impl/interrupts.cpp   |  1 -
 kernel/arch/x86_64/src/hal/impl/mmu.cpp       | 91 +++++++++++++++++++
 kernel/arch/x86_64/src/hal/impl/mmu.hpp       |  6 ++
 kernel/arch/x86_64/src/kernel/init.cpp        |  2 +
 kernel/arch/x86_64/src/mem/page_map.hpp       | 12 +++
 kernel/src/hal/api/mmu.hpp                    | 38 ++++++++
 kernel/src/hal/panic.hpp                      |  1 +
 kernel/src/kernel.cpp                         |  4 +-
 kernel/src/mem/phys/mngr/buddy.cpp            |  2 +-
 kernel/src/mem/virt/page_fault.cpp            | 10 +-
 kernel/src/modules/memory.cpp                 | 58 +++++++++---
 16 files changed, 223 insertions(+), 42 deletions(-)

diff --git a/kernel/arch/x86_64/CMakeLists.txt b/kernel/arch/x86_64/CMakeLists.txt
index 6daf8839..370b1df9 100644
--- a/kernel/arch/x86_64/CMakeLists.txt
+++ b/kernel/arch/x86_64/CMakeLists.txt
@@ -58,7 +58,7 @@ alkos_register_runtime_environment(
     QEMU_COMMAND
         "qemu-system-x86_64"
     QEMU_NORMAL_FLAGS
-    "-serial stdio -enable-kvm -cpu max -display default,show-cursor=on -k en-us -m 4G -smp sockets=1,cores=4,threads=1 -no-reboot"
+        "-serial stdio -enable-kvm -cpu max -display default,show-cursor=on -k en-us -m 4G -smp sockets=1,cores=4,threads=1 -no-reboot"
     QEMU_TEST_FLAGS
         "-serial stdio -enable-kvm -cpu max -display none -m 4G -smp sockets=1,cores=4,threads=1 -no-reboot"
     MODULES
diff --git a/kernel/arch/x86_64/src/drivers/apic/io_apic.cpp b/kernel/arch/x86_64/src/drivers/apic/io_apic.cpp
index 8ce05053..3a3c5582 100644
--- a/kernel/arch/x86_64/src/drivers/apic/io_apic.cpp
+++ b/kernel/arch/x86_64/src/drivers/apic/io_apic.cpp
@@ -1,4 +1,5 @@
 #include "drivers/apic/io_apic.hpp"
+#include <mem/types.hpp>
 #include "drivers/apic/local_apic.hpp"
 
 #include <bit.hpp>
@@ -35,9 +36,10 @@ IoApic::IoApic(const u8 id, const u32 address, const u32 gsi_base)
 {
     ASSERT_NOT_ZERO(address);
 
-    TODO_WHEN_VMEM_WORKS
-    /* TODO: Map the address first, currently identity */
-    virtual_address_ = physical_address_;
+    /* Map the address first */
+    virtual_address_ = reinterpret_cast<uintptr_t>(
+        Mem::PhysToVirt(reinterpret_cast<void *>(static_cast<uintptr_t>(physical_address_)))
+    );
 
     version_ = static_cast<u8>(ReadRegister(kIoApicVerReg)); /* Removes upper bits */
     num_entries_ =
diff --git a/kernel/arch/x86_64/src/drivers/apic/local_apic.hpp b/kernel/arch/x86_64/src/drivers/apic/local_apic.hpp
index 9321894e..796aeec1 100644
--- a/kernel/arch/x86_64/src/drivers/apic/local_apic.hpp
+++ b/kernel/arch/x86_64/src/drivers/apic/local_apic.hpp
@@ -5,8 +5,8 @@
 #include <cpuid.h>
 #include <bit.hpp>
 #include <defines.hpp>
+#include <mem/types.hpp>
 #include <todo.hpp>
-#include <types.hpp>
 #include "cpu/msrs.hpp"
 #include "hal/impl/constants.hpp"
 #include "include/memory_io.hpp"
@@ -345,12 +345,8 @@ class LocalApic
     template <class InputT>
     FAST_CALL void WriteRegister(const u32 offset, const InputT value)
     {
-        TODO_WHEN_VMEM_WORKS
         WriteMemoryIo<u32>(
-            reinterpret_cast<byte *>(
-                GetPhysicalAddressOnCore()
-            ),  // TODO : REPLACE WITH VIRTUAL ADDRESS
-            offset, value
+            Mem::PhysToVirt(reinterpret_cast<byte *>(GetPhysicalAddressOnCore())), offset, value
         );
     }
 
@@ -365,12 +361,8 @@ class LocalApic
     template <class RetT = u32>
     FAST_CALL RetT ReadRegister(const u32 offset)
     {
-        TODO_WHEN_VMEM_WORKS
         return ReadMemoryIo<u32, RetT>(
-            reinterpret_cast<byte *>(
-                GetPhysicalAddressOnCore()
-            ),  // TODO : REPLACE WITH VIRTUAL ADDRESS
-            offset
+            Mem::PhysToVirt(reinterpret_cast<byte *>(GetPhysicalAddressOnCore())), offset
         );
     }
 
diff --git a/kernel/arch/x86_64/src/drivers/hpet/hpet.hpp b/kernel/arch/x86_64/src/drivers/hpet/hpet.hpp
index 783ff4c7..6bbc07aa 100644
--- a/kernel/arch/x86_64/src/drivers/hpet/hpet.hpp
+++ b/kernel/arch/x86_64/src/drivers/hpet/hpet.hpp
@@ -4,6 +4,7 @@
 #include <uacpi/acpi.h>
 #include <array.hpp>
 #include <data_structures/bit_array.hpp>
+#include <mem/types.hpp>
 #include <time.hpp>
 #include <todo.hpp>
 #include <types.hpp>
@@ -215,17 +216,17 @@ class Hpet final
     template <class InputT>
     FORCE_INLINE_F void WriteRegister(const u32 offset, const InputT value)
     {
-        TODO_WHEN_VMEM_WORKS
-        // TODO : REPLACE WITH VIRTUAL ADDRESS
-        WriteMemoryIo<u64>(reinterpret_cast<byte *>(GetPhysicalAddress()), offset, value);
+        WriteMemoryIo<u64>(
+            Mem::PhysToVirt(reinterpret_cast<byte *>(GetPhysicalAddress())), offset, value
+        );
     }
 
     template <class RetT>
     FORCE_INLINE_F RetT ReadRegister(const u32 offset) const
     {
-        TODO_WHEN_VMEM_WORKS
-        // TODO : REPLACE WITH VIRTUAL ADDRESS
-        return ReadMemoryIo<u64, RetT>(reinterpret_cast<byte *>(GetPhysicalAddress()), offset);
+        return ReadMemoryIo<u64, RetT>(
+            Mem::PhysToVirt(reinterpret_cast<byte *>(GetPhysicalAddress())), offset
+        );
     }
 
     // ------------------------------
diff --git a/kernel/arch/x86_64/src/hal/impl/core.cpp b/kernel/arch/x86_64/src/hal/impl/core.cpp
index 485bc7f9..02273e36 100644
--- a/kernel/arch/x86_64/src/hal/impl/core.cpp
+++ b/kernel/arch/x86_64/src/hal/impl/core.cpp
@@ -15,13 +15,14 @@ void Core::EnableCore()
 
 void arch::InitializeCoreLocal()
 {
-    auto core_local = static_cast<hardware::CoreLocal *>(GetCoreLocalData());
+    auto *core_local = static_cast<hardware::CoreLocal *>(GetCoreLocalData());
 
     cpu::DefaultGdtInit(core_local->gdt, reinterpret_cast<u64>(&core_local->tss));
     core_local->gdtr.limit = sizeof(cpu::GDT) - 1;
     core_local->gdtr.base  = reinterpret_cast<u64>(&core_local->gdt);
 
     GdtFlush(&core_local->gdtr, cpu::GDT::kKernelCodeSelector, cpu::GDT::kKernelDataSelector);
+    SetCoreLocalData(core_local);
     cpu::LoadTss(cpu::GDT::kTssSelector);
 
     DEBUG_INFO_HARDWARE(
diff --git a/kernel/arch/x86_64/src/hal/impl/interrupts.cpp b/kernel/arch/x86_64/src/hal/impl/interrupts.cpp
index bc011ba0..7db36b0a 100644
--- a/kernel/arch/x86_64/src/hal/impl/interrupts.cpp
+++ b/kernel/arch/x86_64/src/hal/impl/interrupts.cpp
@@ -40,7 +40,6 @@ void Interrupts::FirstStageInit()
     InitPic8259(kIrq1Offset, kIrq2Offset);
     MapToLogicalInterrupts_();
     SetupPicAsDefaultDriver_();
-    trace::AdvanceTracingStage();
     InitializeDefaultIdt_();
 }
 
diff --git a/kernel/arch/x86_64/src/hal/impl/mmu.cpp b/kernel/arch/x86_64/src/hal/impl/mmu.cpp
index 5459f301..a3cc6434 100644
--- a/kernel/arch/x86_64/src/hal/impl/mmu.cpp
+++ b/kernel/arch/x86_64/src/hal/impl/mmu.cpp
@@ -15,6 +15,7 @@ namespace
 {
 
 // Helper to get PageMeta from a physical pointer to a table/page
+// Used by Map/UnMap where MemoryModule is fully initialized
 PageMeta &GetPageMeta(PPtr<void> phys_ptr)
 {
     auto *aligned_phys = AlignDown(phys_ptr, hal::kPageSizeBytes);
@@ -28,6 +29,67 @@ PageMeta &GetPageMetaFromVirt(VPtr<void> virt_ptr)
     return GetPageMeta(phys_ptr);
 }
 
+// Helper to get PageMeta using explicit PageMetaTable (safe during initialization)
+PageMeta &GetPageMeta(PPtr<void> phys_ptr, PageMetaTable &pmt)
+{
+    auto *aligned_phys = AlignDown(phys_ptr, hal::kPageSizeBytes);
+    return pmt.GetPageMeta(aligned_phys);
+}
+
+// Helper to recursively free page table frames
+template <size_t kLevel>
+void FreeTableRecursive(PPtr<void> table_phys, PageMetaTable &pmt, BitmapPmm &pmm)
+{
+    auto *table_virt = reinterpret_cast<PageMapTable<kLevel> *>(PhysToVirt(table_phys));
+
+    for (auto &entry : *table_virt) {
+        if (entry.IsPresent()) {
+            bool is_huge = entry.IsHuge();
+
+            if constexpr (kLevel > 1) {
+                if (!is_huge) {
+                    PPtr<void> child_phys = reinterpret_cast<PPtr<void>>(entry.GetNextLevelTable());
+                    FreeTableRecursive<kLevel - 1>(child_phys, pmt, pmm);
+                }
+            }
+            // If it is a leaf (Level 1, or Huge Level 2/3), we do NOTHING.
+            // We are only destroying the mapping structure, not the memory it points to.
+        }
+    }
+
+    // Now free the table frame itself
+    pmm.Free(reinterpret_cast<PPtr<Page>>(table_phys));
+
+    // Invalidate metadata
+    auto &meta = GetPageMeta(table_phys, pmt);
+    meta.type  = PageMetaType::Dummy;
+}
+
+template <size_t kLevel>
+void ReconstructRecursive(PPtr<void> table_phys, PageMeta *parent, PageMetaTable &pmt)
+{
+    // Initialize metadata for the current table frame
+    auto &meta = GetPageMeta(table_phys, pmt);
+    meta.InitPageTable(kLevel, parent);
+
+    auto *table_virt = reinterpret_cast<PageMapTable<kLevel> *>(PhysToVirt(table_phys));
+
+    u16 ref_count = 0;
+    for (const auto &entry : *table_virt) {
+        if (entry.IsPresent()) {
+            ref_count++;
+            if constexpr (kLevel > 1) {
+                if (!entry.IsHuge()) {
+                    PPtr<void> child_phys = reinterpret_cast<PPtr<void>>(entry.GetNextLevelTable());
+                    ReconstructRecursive<kLevel - 1>(child_phys, &meta, pmt);
+                }
+                // If page_size is set, then it's a huge page
+            }
+        }
+    }
+    meta.data.page_table.ref_count = ref_count;
+}
+
 }  // namespace
 
 u64 Mmu::ToArchFlags(PageFlags flags)
@@ -261,3 +323,32 @@ expected<PPtr<void>, MemError> Mmu::Translate(VPtr<AddressSpace> as, VPtr<void>
 
     return pme_l1->GetFrameAddress();
 }
+
+void Mmu::ReconstructAddressSpace(Mem::PPtr<void> root_page_table, Mem::PageMetaTable &pmt)
+{
+    ReconstructRecursive<4>(root_page_table, nullptr, pmt);
+}
+
+void Mmu::UnmapLowerHalf(
+    Mem::PPtr<void> root_page_table, Mem::PageMetaTable &pmt, Mem::BitmapPmm &pmm, hal::Tlb &tlb
+)
+{
+    auto *pml4_virt = reinterpret_cast<PageMapTable<4> *>(PhysToVirt(root_page_table));
+    auto &pml4_meta = GetPageMeta(root_page_table, pmt);
+
+    constexpr size_t kLowerHalfLimit = 256;
+    for (size_t i = 0; i < kLowerHalfLimit; ++i) {
+        auto &entry = (*pml4_virt)[i];
+        if (entry.IsPresent()) {
+            // Free the table the entry points to
+            PPtr<void> pdpt_phys = reinterpret_cast<PPtr<void>>(entry.GetNextLevelTable());
+            FreeTableRecursive<3>(pdpt_phys, pmt, pmm);
+
+            // Free the entry
+            *reinterpret_cast<u64 *>(&entry) = 0;
+        }
+    }
+
+    // Flush TLB to ensure CPU doesn't retain old mappings
+    tlb.FlushAll();
+}
diff --git a/kernel/arch/x86_64/src/hal/impl/mmu.hpp b/kernel/arch/x86_64/src/hal/impl/mmu.hpp
index 80b66039..a8dacf5f 100644
--- a/kernel/arch/x86_64/src/hal/impl/mmu.hpp
+++ b/kernel/arch/x86_64/src/hal/impl/mmu.hpp
@@ -34,6 +34,12 @@ class Mmu : public MmuAPI
 
     void DestroyRootPageMapTable(Mem::PPtr<void> pmt4) { (void)pmt4; }
 
+    void ReconstructAddressSpace(Mem::PPtr<void> root_page_table, Mem::PageMetaTable &pmt);
+
+    void UnmapLowerHalf(
+        Mem::PPtr<void> root_page_table, Mem::PageMetaTable &pmt, Mem::BitmapPmm &pmm, hal::Tlb &tlb
+    );
+
     private:
     template <size_t kLevel>
     u64 PmeIdx(Mem::VPtr<void> vaddr);
diff --git a/kernel/arch/x86_64/src/kernel/init.cpp b/kernel/arch/x86_64/src/kernel/init.cpp
index 847b175f..4b5d6032 100644
--- a/kernel/arch/x86_64/src/kernel/init.cpp
+++ b/kernel/arch/x86_64/src/kernel/init.cpp
@@ -70,6 +70,8 @@ void ArchInit(const RawBootArguments &)
     hal::SetCoreLocalData(&g_CoreLocal);
     InitializeCoreLocal();
 
+    trace::AdvanceTracingStage();
+
     EnableHardwareInterrupts();
 
     DEBUG_INFO_BOOT("Leaving ArchInit");
diff --git a/kernel/arch/x86_64/src/mem/page_map.hpp b/kernel/arch/x86_64/src/mem/page_map.hpp
index a85ecd8b..ae1a4998 100644
--- a/kernel/arch/x86_64/src/mem/page_map.hpp
+++ b/kernel/arch/x86_64/src/mem/page_map.hpp
@@ -93,6 +93,8 @@ struct PageMapEntry<4> {
 
     NODISCARD bool IsPresent() const { return present; }
 
+    NODISCARD bool IsHuge() const { return false; }
+
     NODISCARD Mem::PPtr<PageMapTable<3>> GetNextLevelTable() const
     {
         return Mem::UptrToPtr<PageMapTable<3>>(static_cast<u64>(frame) << 12);
@@ -131,6 +133,8 @@ struct PageMapEntry<3> {
 
     NODISCARD bool IsPresent() const { return present; }
 
+    NODISCARD bool IsHuge() const { return page_size; }
+
     NODISCARD Mem::PPtr<PageMapTable<2>> GetNextLevelTable() const
     {
         return Mem::UptrToPtr<PageMapTable<2>>(static_cast<u64>(frame) << 12);
@@ -168,6 +172,8 @@ struct PageMapEntry<3, kHugePage> {
 
     NODISCARD bool IsPresent() const { return present; }
 
+    NODISCARD bool IsHuge() const { return true; }
+
     NODISCARD Mem::PPtr<void> GetFrameAddress() const
     {
         return Mem::UptrToPtr<void>(static_cast<u64>(frame) << 30);
@@ -205,6 +211,8 @@ struct PageMapEntry<2> {
 
     NODISCARD bool IsPresent() const { return present; }
 
+    NODISCARD bool IsHuge() const { return page_size; }
+
     NODISCARD Mem::PPtr<PageMapTable<1>> GetNextLevelTable() const
     {
         return Mem::UptrToPtr<PageMapTable<1>>(static_cast<u64>(frame) << 12);
@@ -242,6 +250,8 @@ struct PageMapEntry<2, kHugePage> {
 
     NODISCARD bool IsPresent() const { return present; }
 
+    NODISCARD bool IsHuge() const { return true; }
+
     NODISCARD Mem::PPtr<void> GetFrameAddress() const
     {
         return Mem::UptrToPtr<void>(static_cast<u64>(frame) << 21);
@@ -281,6 +291,8 @@ struct PageMapEntry<1> {
 
     NODISCARD bool IsPresent() const { return present; }
 
+    NODISCARD bool IsHuge() const { return false; }
+
     NODISCARD Mem::PPtr<void> GetFrameAddress() const
     {
         return Mem::UptrToPtr<void>(static_cast<u64>(frame) << 12);
diff --git a/kernel/src/hal/api/mmu.hpp b/kernel/src/hal/api/mmu.hpp
index 8ccc5b91..35b59a88 100644
--- a/kernel/src/hal/api/mmu.hpp
+++ b/kernel/src/hal/api/mmu.hpp
@@ -9,7 +9,14 @@ namespace Mem
 {
 
 class AddressSpace;
+class PageMetaTable;
+class BitmapPmm;
 
+}  // namespace Mem
+
+namespace hal
+{
+class Tlb;
 }
 
 namespace arch
@@ -77,6 +84,37 @@ struct MmuAPI {
      *
      */
     void CleanRootPageMapTable(Mem::PPtr<void> root_page_table);
+
+    /**
+     * @brief Reconstructs the PageMeta metadata for an existing page table hierarchy.
+     *
+     * This is used during kernel initialization to synchronize the software metadata
+     * (PageMeta) with the hardware page tables set up by the bootloader. It recursively
+     * walks the tables, initializing PageMeta types and reference counts.
+     *
+     * @param root_page_table Physical pointer to the top-level page table.
+     * @param pmt Reference to the PageMetaTable instance.
+     */
+    void ReconstructAddressSpace(Mem::PPtr<void> root_page_table, Mem::PageMetaTable &pmt);
+
+    /**
+     * @brief Unmaps the lower half of the address space (entries 0-255 of PML4).
+     *
+     * This removes the identity mapping established by the bootloader.
+     * It recursively frees the page tables used for this mapping but does NOT
+     * free the underlying physical frames (leaf nodes) mapped by them.
+     *
+     * @note THIS IS TO BE USED DIRECTLY AFTER RECONSTRUCTING BITMAP PMM, BEFORE BUDDY PMM
+     * IS INITIALIZED
+     *
+     * @param root_page_table Physical pointer to the top-level page table.
+     * @param pmt Reference to the PageMetaTable instance.
+     * @param pmm Reference to the BitmapPmm instance (for freeing tables).
+     * @param tlb Reference to the TLB instance (for flushing).
+     */
+    void UnmapLowerHalf(
+        Mem::PPtr<void> root_page_table, Mem::PageMetaTable &pmt, Mem::BitmapPmm &pmm, hal::Tlb &tlb
+    );
 };
 
 }  // namespace arch
diff --git a/kernel/src/hal/panic.hpp b/kernel/src/hal/panic.hpp
index 5d052de1..7152180b 100644
--- a/kernel/src/hal/panic.hpp
+++ b/kernel/src/hal/panic.hpp
@@ -27,6 +27,7 @@ WRAP_CALL void KernelPanic(const char *msg)
 template <typename... Args>
 FAST_CALL NO_RET void KernelPanicFormat(const char *fmt, Args... args)
 {
+    TRACE_FATAL_GENERAL("[ KERNEL PANIC ]");
     TRACE_FATAL_GENERAL(fmt, args...);
     arch::KernelPanic();
 
diff --git a/kernel/src/kernel.cpp b/kernel/src/kernel.cpp
index 50ef88c5..4e95538c 100644
--- a/kernel/src/kernel.cpp
+++ b/kernel/src/kernel.cpp
@@ -52,12 +52,12 @@ static void KernelRun()
     }
 }
 
-extern "C" void KernelMain(const hal::RawBootArguments *raw_args)
+extern "C" void KernelMain(const Mem::PPtr<hal::RawBootArguments> raw_args)
 {
     ASSERT_NOT_NULL(raw_args, "Raw boot arguments are null");
     TRACE_INFO_GENERAL("Running kernel initialization...");
 
-    KernelInit(*raw_args);
+    KernelInit(*Mem::PhysToVirt(raw_args));
 
     if constexpr (FeatureEnabled<FeatureFlag::kRunTestMode>) {
         TRACE_INFO_GENERAL("Running tests...");
diff --git a/kernel/src/mem/phys/mngr/buddy.cpp b/kernel/src/mem/phys/mngr/buddy.cpp
index 18baa419..d0b2d87a 100644
--- a/kernel/src/mem/phys/mngr/buddy.cpp
+++ b/kernel/src/mem/phys/mngr/buddy.cpp
@@ -169,7 +169,7 @@ void B::Free(PPtr<Page> page)
     size_t pfn     = PageFrameNumber(page);
     PageMeta &meta = pmt_->GetPageMeta(pfn);
 
-    ASSERT_EQ(
+    R_ASSERT_EQ(
         meta.type, PageMetaType::Allocated, "Double free detected or freeing an invalid page!"
     );
 
diff --git a/kernel/src/mem/virt/page_fault.cpp b/kernel/src/mem/virt/page_fault.cpp
index 93009926..569aa953 100644
--- a/kernel/src/mem/virt/page_fault.cpp
+++ b/kernel/src/mem/virt/page_fault.cpp
@@ -22,7 +22,7 @@ void PageFaultHandler(intr::LitExcEntry &, hal::ExceptionData *data)
     auto &as           = MemoryModule::Get().GetKernelAddressSpace();
     auto area_or_error = as.FindArea(f_ptr);
     if (!area_or_error) {
-        KernelPanicFormat("Page fault in unmapped memory at 0x%p", f_ptr);
+        KernelPanicFormat("Page fault in unmapped memory at %p", f_ptr);
         return;
     }
     VPtr<VMemArea> vma_ptr = *area_or_error;
@@ -30,7 +30,7 @@ void PageFaultHandler(intr::LitExcEntry &, hal::ExceptionData *data)
 
     if (!err.present) {  // Page just wasn't there
         if (err.write && !vma.flags.writable) {
-            hal::KernelPanicFormat("Write to read-only memory area at 0x%p", f_ptr);
+            hal::KernelPanicFormat("Write to read-only memory area at %p", f_ptr);
             return;
         }
 
@@ -58,7 +58,7 @@ void PageFaultHandler(intr::LitExcEntry &, hal::ExceptionData *data)
             );
         } else {
             hal::KernelPanicFormat(
-                "Unsupported VMA type %d at 0x%p", static_cast<int>(vma.type), f_ptr
+                "Unsupported VMA type %d at %p", static_cast<int>(vma.type), f_ptr
             );
             return;
         }
@@ -76,11 +76,11 @@ void PageFaultHandler(intr::LitExcEntry &, hal::ExceptionData *data)
         auto map_res = mmu.Map(&as, AlignDown(f_ptr, hal::kPageSizeBytes), map_to, page_flags);
 
         if (!map_res) {
-            hal::KernelPanicFormat("Failed to map page for address 0x%p", f_ptr);
+            hal::KernelPanicFormat("Failed to map page for address %p", f_ptr);
         }
 
         TRACE_INFO_GENERAL(
-            "Handled page fault at 0x%p by mapping to physical page at 0x%p", f_ptr, map_to
+            "Handled page fault at %p by mapping to physical page at %p", f_ptr, map_to
         );
         return;
     }
diff --git a/kernel/src/modules/memory.cpp b/kernel/src/modules/memory.cpp
index 3c571bfd..b52685fc 100644
--- a/kernel/src/modules/memory.cpp
+++ b/kernel/src/modules/memory.cpp
@@ -25,6 +25,12 @@ internal::MemoryModule::MemoryModule(const BootArguments &args) noexcept
 
     PageMetaTable_.Init(args.total_page_frames, BitmapPmm_);
 
+    // Prune whatever bootloader had left over
+    TRACE_INFO_MEMORY("Unmapping lower half of memory");
+    {
+        Mmu_.UnmapLowerHalf(args.root_page_table, PageMetaTable_, BitmapPmm_, Tlb_);
+    }
+
     constexpr size_t kInitialBuddyPagesLimit = 4096;  // 16MB
     // Note: Initializing buddy with all pages is a slow operation.
     // This limit is for speed of boot. This operation should have
@@ -32,23 +38,53 @@ internal::MemoryModule::MemoryModule(const BootArguments &args) noexcept
     // could offload this operation to.
     BuddyPmm_.Init(BitmapPmm_, PageMetaTable_, kInitialBuddyPagesLimit);
 
-    // Initialize metadata for the Kernel PML4 (Root Page Table).
-    // The bootloader passes it, so it's already allocated but its metadata
-    // needs to be correctly set as a PageTable to support MMU operations.
-    {
-        auto &root_meta = PageMetaTable_.GetPageMeta(args.root_page_table);
-
-        // Initialize as a Level 4 page table with no parent.
-        // We set ref_count to 1 to represent the kernel's static presence and prevent freeing.
-        root_meta.InitPageTable(4, nullptr);
-        root_meta.data.page_table.ref_count = 1;
-    }
+    TRACE_INFO_MEMORY("Reconstructing page table metadata from root: 0x%p", args.root_page_table);
+    Mmu_.ReconstructAddressSpace(args.root_page_table, PageMetaTable_);
 
     SlabAllocator_.Init(BuddyPmm_);
 
     Heap_.Init(PageMetaTable_, BuddyPmm_, SlabAllocator_);
 
     Vmm_.Init(Tlb_, Mmu_);
+
+    // TODO: This makes kernel stuck in infninite loop? Shoudnt?
+    // Register initial Virtual Memory Areas (VMAs) so the VMM is aware of them.
+    // These areas were set up by the bootloader but are invisible to the generic VMM until
+    // registered.
+    // {
+    //     // Kernel Image
+    //     size_t kernel_size =
+    //         reinterpret_cast<uptr>(args.kernel_end) - reinterpret_cast<uptr>(args.kernel_start);
+    //
+    //     VMemArea kernel_vma{
+    //         .start                = args.kernel_start,
+    //         .size                 = kernel_size,
+    //         .flags                = {.readable = true, .writable = true, .executable = true},
+    //         .type                 = VirtualMemAreaT::Anonymous,
+    //         .direct_mapping_start = VirtToPhys(args.kernel_start),
+    //         .next                 = nullptr
+    //     };
+
+    //     TRACE_INFO_MEMORY("Adding VMemArea for kernel");
+    //     if (auto res = Vmm_.AddArea(&KernelAddressSpace_, kernel_vma); !res) {
+    //         TRACE_WARN_MEMORY("Failed to register Kernel VMA");
+    //     }
+
+    //     // Direct Physical Map
+    //     VMemArea dm_vma{
+    //         .start                = UptrToPtr<void>(hal::kDirectMapAddrStart),
+    //         .size                 = hal::kDirectMemMapSizeGb * 1024ULL * 1024ULL * 1024ULL,
+    //         .flags                = {.readable = true, .writable = true, .executable = false},
+    //         .type                 = VirtualMemAreaT::DirectMapping,
+    //         .direct_mapping_start = UptrToPtr<void>(0),
+    //         .next                 = nullptr
+    //     };
+
+    //     TRACE_INFO_MEMORY("Adding VMemArea for direct mem mapping");
+    //     if (auto res = Vmm_.AddArea(&KernelAddressSpace_, dm_vma); !res) {
+    //         TRACE_WARN_MEMORY("Failed to register Direct Map VMA");
+    //     }
+    // }
 }
 
 void internal::MemoryModule::RegisterPageFault(HardwareModule &hw)

From 760269823a1ccfec28add559ca38551755b6febb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C5=81ukasz=20Kryczka?=
 <60490378+kryczkal@users.noreply.github.com>
Date: Sun, 28 Dec 2025 01:11:38 +0100
Subject: [PATCH 21/56] Kryczkal/vmm set vma flags (#246)

## Problem:
Page flags need to enable writing during loading an elf, but need to be
set to
read only after it is loaded.

## Solution
Added mechanizm to update the flags of a vmemarea
Also fixed various bugs
most noticalbly - stack misalignment after return from error idt.
---
 kernel/arch/x86_64/src/cpu/enable_nxe.nasm | 47 ++++++++++++++++++++++
 kernel/arch/x86_64/src/hal/impl/mmu.cpp    | 33 +++++++++++++--
 kernel/arch/x86_64/src/hal/impl/mmu.hpp    |  4 ++
 kernel/arch/x86_64/src/interrupts/idt.nasm |  1 +
 kernel/arch/x86_64/src/kernel/init.cpp     |  2 +
 kernel/arch/x86_64/src/mem/page_map.hpp    |  9 +++--
 kernel/src/hal/api/mmu.hpp                 | 11 +++++
 kernel/src/mem/virt/page_fault.cpp         |  9 ++++-
 kernel/src/mem/virt/vmm.cpp                | 39 ++++++++++++++++++
 kernel/src/mem/virt/vmm.hpp                |  6 +--
 kernel/src/sys/loader.cpp                  | 30 +++++++++++---
 11 files changed, 174 insertions(+), 17 deletions(-)
 create mode 100644 kernel/arch/x86_64/src/cpu/enable_nxe.nasm

diff --git a/kernel/arch/x86_64/src/cpu/enable_nxe.nasm b/kernel/arch/x86_64/src/cpu/enable_nxe.nasm
new file mode 100644
index 00000000..3153cd17
--- /dev/null
+++ b/kernel/arch/x86_64/src/cpu/enable_nxe.nasm
@@ -0,0 +1,47 @@
+    bits 64
+
+    %include "startup/panic.nasm"
+
+    ; Extended Feature Enable Register (EFER)
+    EFER_MSR        equ 0xC0000080
+    EFER_NXE_BIT    equ 1 << 11
+
+    ; CPUID Extended Processor Info
+    CPUID_EXT_FUNC  equ 0x80000001
+    CPUID_NX_BIT    equ 1 << 20    ; In EDX
+
+    section .rodata
+    FAIL_NX         db "CPU does not support No-Execute (NX) bit. Halting.", 0
+
+    section .text
+    global EnableNXE
+
+EnableNXE:
+    push rbx
+    push rcx
+    push rdx
+
+    ; Check if CPU supports NX (CPUID 0x80000001, Bit 20 of EDX)
+    mov eax, 0x80000000
+    cpuid
+    cmp eax, CPUID_EXT_FUNC
+    jb .no_nx_support       ; Extended functions not supported
+
+    mov eax, CPUID_EXT_FUNC
+    cpuid
+    test edx, CPUID_NX_BIT
+    jz .no_nx_support
+
+    ; Enable NXE in EFER MSR
+    mov ecx, EFER_MSR
+    rdmsr                   ; Read EFER into EDX:EAX
+    bts eax, 11             ; Set bit 11 (NXE)
+    wrmsr                   ; Write EFER back
+
+    pop rdx
+    pop rcx
+    pop rbx
+    ret
+
+.no_nx_support:
+    panic FAIL_NX
diff --git a/kernel/arch/x86_64/src/hal/impl/mmu.cpp b/kernel/arch/x86_64/src/hal/impl/mmu.cpp
index a3cc6434..ad53e2bb 100644
--- a/kernel/arch/x86_64/src/hal/impl/mmu.cpp
+++ b/kernel/arch/x86_64/src/hal/impl/mmu.cpp
@@ -141,12 +141,14 @@ expected<Mem::VPtr<PageMapEntry<kLevel>>, Mem::MemError> Mmu::WalkToEntry(
     static_assert(kLevel > 0);
     static_assert(kLevel <= 4);
 
-    static constexpr u64 kDefFlags = kPresentBit | kWriteBit | kUserAccessibleBit;
+    // static constexpr u64 kDefFlags = kPresentBit | kWriteBit | kUserAccessibleBit;
 
     // Helper lambda to process each level
     auto ProcessLevel = [&]<size_t L>(
                             Mem::VPtr<PageMapEntry<L>> pme, bool create
                         ) -> expected<Mem::VPtr<PageMapEntry<L - 1>>, Mem::MemError> {
+        constexpr u64 kDefFlags = kPresentBit | kWriteBit | kUserAccessibleBit;
+
         if (pme->IsPresent()) {
             return reinterpret_cast<PageMapEntry<L - 1> *>(
                 Mem::PhysToVirt(pme->GetNextLevelTable())
@@ -261,7 +263,7 @@ expected<void, MemError> Mmu::UnMap(VPtr<AddressSpace> as, VPtr<void> vaddr)
     }
 
     // 2. Clear Entry
-    pme_l1->SetFrameAddress(0, 0);
+    *reinterpret_cast<u64 *>(pme_l1) = 0;
 
     // 3. Update RefCount
     auto *l1_table_virt = AlignDown(pme_l1, hal::kPageSizeBytes);
@@ -324,6 +326,32 @@ expected<PPtr<void>, MemError> Mmu::Translate(VPtr<AddressSpace> as, VPtr<void>
     return pme_l1->GetFrameAddress();
 }
 
+expected<void, MemError> Mmu::SetPageFlags(VPtr<AddressSpace> as, VPtr<void> vaddr, PageFlags flags)
+{
+    auto res = WalkToEntry<1>(as, vaddr, false);
+    if (!res) {
+        return unexpected(MemError::NotFound);
+    }
+
+    auto *pme_l1 = *res;
+    if (!pme_l1->IsPresent()) {
+        return unexpected(MemError::NotFound);
+    }
+
+    // Preserve address, update flags
+    auto *paddr = pme_l1->GetFrameAddress();
+
+    // We need to clear the entry before setting it again to avoid ORing flags
+    *reinterpret_cast<u64 *>(pme_l1) = 0;
+
+    pme_l1->SetFrameAddress(paddr, ToArchFlags(flags));
+
+    // Flush TLB for this page immediately to ensure CPU sees new permissions
+    MemoryModule::Get().GetTlb().InvalidatePage(vaddr);
+
+    return {};
+}
+
 void Mmu::ReconstructAddressSpace(Mem::PPtr<void> root_page_table, Mem::PageMetaTable &pmt)
 {
     ReconstructRecursive<4>(root_page_table, nullptr, pmt);
@@ -334,7 +362,6 @@ void Mmu::UnmapLowerHalf(
 )
 {
     auto *pml4_virt = reinterpret_cast<PageMapTable<4> *>(PhysToVirt(root_page_table));
-    auto &pml4_meta = GetPageMeta(root_page_table, pmt);
 
     constexpr size_t kLowerHalfLimit = 256;
     for (size_t i = 0; i < kLowerHalfLimit; ++i) {
diff --git a/kernel/arch/x86_64/src/hal/impl/mmu.hpp b/kernel/arch/x86_64/src/hal/impl/mmu.hpp
index a8dacf5f..431343ea 100644
--- a/kernel/arch/x86_64/src/hal/impl/mmu.hpp
+++ b/kernel/arch/x86_64/src/hal/impl/mmu.hpp
@@ -40,6 +40,10 @@ class Mmu : public MmuAPI
         Mem::PPtr<void> root_page_table, Mem::PageMetaTable &pmt, Mem::BitmapPmm &pmm, hal::Tlb &tlb
     );
 
+    expected<void, Mem::MemError> SetPageFlags(
+        Mem::VPtr<Mem::AddressSpace> as, Mem::VPtr<void> vaddr, PageFlags flags
+    );
+
     private:
     template <size_t kLevel>
     u64 PmeIdx(Mem::VPtr<void> vaddr);
diff --git a/kernel/arch/x86_64/src/interrupts/idt.nasm b/kernel/arch/x86_64/src/interrupts/idt.nasm
index 239beff3..d929b564 100644
--- a/kernel/arch/x86_64/src/interrupts/idt.nasm
+++ b/kernel/arch/x86_64/src/interrupts/idt.nasm
@@ -38,6 +38,7 @@ isr_wrapper_%+%1:
     add rsp, _shadow_space      ; Deallocate shadow space.
     pop_all_regs                    ; Restore registers.
     add rsp, _all_reg_size          ; Deallocate register save space.
+    add rsp, 8                      ; Pop error code.
     iretq
 %endmacro
 
diff --git a/kernel/arch/x86_64/src/kernel/init.cpp b/kernel/arch/x86_64/src/kernel/init.cpp
index 4b5d6032..53012ec3 100644
--- a/kernel/arch/x86_64/src/kernel/init.cpp
+++ b/kernel/arch/x86_64/src/kernel/init.cpp
@@ -33,6 +33,7 @@ BEGIN_DECL_C
 void EnableOSXSave();
 void EnableSSE();
 void EnableAVX();
+void EnableNXE();
 
 END_DECL_C
 
@@ -63,6 +64,7 @@ void ArchInit(const RawBootArguments &)
     EnableOSXSave();
     EnableSSE();
     EnableAVX();
+    EnableNXE();
 
     HardwareModule::Init();
     HardwareModule::Get().GetInterrupts().FirstStageInit();
diff --git a/kernel/arch/x86_64/src/mem/page_map.hpp b/kernel/arch/x86_64/src/mem/page_map.hpp
index ae1a4998..1cedf95b 100644
--- a/kernel/arch/x86_64/src/mem/page_map.hpp
+++ b/kernel/arch/x86_64/src/mem/page_map.hpp
@@ -181,7 +181,8 @@ struct PageMapEntry<3, kHugePage> {
 
     void SetFrameAddress(Mem::PPtr<void> page_addr, u64 flags)
     {
-        frame = Mem::PtrToUptr(page_addr) >> 30;
+        *reinterpret_cast<u64 *>(this) = 0;
+        frame                          = Mem::PtrToUptr(page_addr) >> 30;
         *reinterpret_cast<u64 *>(this) |= flags | kHugePageBit;
     }
 } PACK;
@@ -259,7 +260,8 @@ struct PageMapEntry<2, kHugePage> {
 
     void SetFrameAddress(Mem::PPtr<void> page_addr, u64 flags)
     {
-        frame = Mem::PtrToUptr(page_addr) >> 21;
+        *reinterpret_cast<u64 *>(this) = 0;
+        frame                          = Mem::PtrToUptr(page_addr) >> 21;
         *reinterpret_cast<u64 *>(this) |= flags | kHugePageBit;
     }
 } PACK;
@@ -300,7 +302,8 @@ struct PageMapEntry<1> {
 
     void SetFrameAddress(Mem::PPtr<void> page_addr, u64 flags)
     {
-        frame = Mem::PtrToUptr(page_addr) >> 12;
+        *reinterpret_cast<u64 *>(this) = 0;
+        frame                          = Mem::PtrToUptr(page_addr) >> 12;
         *reinterpret_cast<u64 *>(this) |= flags;
     }
 } PACK;
diff --git a/kernel/src/hal/api/mmu.hpp b/kernel/src/hal/api/mmu.hpp
index 35b59a88..df422383 100644
--- a/kernel/src/hal/api/mmu.hpp
+++ b/kernel/src/hal/api/mmu.hpp
@@ -115,6 +115,17 @@ struct MmuAPI {
     void UnmapLowerHalf(
         Mem::PPtr<void> root_page_table, Mem::PageMetaTable &pmt, Mem::BitmapPmm &pmm, hal::Tlb &tlb
     );
+
+    /**
+     * @brief Updates the flags of an existing mapping.
+     * @param as The address space.
+     * @param vaddr The virtual address.
+     * @param flags The new flags.
+     * @return Success, or NotFound if page is not mapped.
+     */
+    expected<void, Mem::MemError> SetPageFlags(
+        Mem::VPtr<Mem::AddressSpace> as, Mem::VPtr<void> vaddr, PageFlags flags
+    );
 };
 
 }  // namespace arch
diff --git a/kernel/src/mem/virt/page_fault.cpp b/kernel/src/mem/virt/page_fault.cpp
index 569aa953..5240cdc2 100644
--- a/kernel/src/mem/virt/page_fault.cpp
+++ b/kernel/src/mem/virt/page_fault.cpp
@@ -11,7 +11,7 @@ namespace Mem
 
 void PageFaultHandler(intr::LitExcEntry &, hal::ExceptionData *data)
 {
-    TRACE_INFO_GENERAL("PageFaultHandler: Enter");
+    TRACE_INFO_GENERAL("PageFaultHandler()");
     using namespace hal;
     ASSERT_NOT_NULL(data);
 
@@ -19,6 +19,11 @@ void PageFaultHandler(intr::LitExcEntry &, hal::ExceptionData *data)
     const auto &f_ptr = pfd.faulting_ptr;
     const auto &err   = pfd.error;
 
+    TRACE_INFO_GENERAL(
+        "PageFaultHandler: Addr=%p, P=%d, W=%d, U=%d, R=%d, I=%d", f_ptr, err.present, err.write,
+        err.user, err.reserved_bits, err.instruction_fetch
+    );
+
     auto &as           = MemoryModule::Get().GetKernelAddressSpace();
     auto area_or_error = as.FindArea(f_ptr);
     if (!area_or_error) {
@@ -66,7 +71,7 @@ void PageFaultHandler(intr::LitExcEntry &, hal::ExceptionData *data)
         hal::PageFlags page_flags{
             .Present        = true,
             .Writable       = vma.flags.writable,
-            .UserAccessible = false,
+            .UserAccessible = true,
             .WriteThrough   = false,
             .CacheDisable   = false,
             .Global         = false,
diff --git a/kernel/src/mem/virt/vmm.cpp b/kernel/src/mem/virt/vmm.cpp
index 50c31f5f..24bccbb5 100644
--- a/kernel/src/mem/virt/vmm.cpp
+++ b/kernel/src/mem/virt/vmm.cpp
@@ -74,4 +74,43 @@ expected<void, MemError> Vmm::RmArea(VPtr<AddrSp> as, VPtr<void> region_start)
     return {};
 }
 
+expected<void, MemError> Vmm::UpdateAreaFlags(
+    VPtr<AddressSpace> as, VPtr<void> region_start, VirtualMemAreaFlags vmaf
+)
+{
+    auto a_or_err = as->FindArea(region_start);
+    UNEXPECTED_RET_IF_ERR(a_or_err);
+    auto *area = *a_or_err;
+    if (area->start != region_start) {
+        return unexpected(MemError::InvalidArgument);
+    }
+
+    area->flags = vmaf;
+    hal::PageFlags pf{
+        .Present        = true,
+        .Writable       = vmaf.writable,
+        .UserAccessible = true,  // User space VMA
+        .WriteThrough   = false,
+        .CacheDisable   = false,
+        .Global         = false,
+        .NoExecute      = !vmaf.executable
+    };
+
+    uptr start = PtrToUptr(area->start);
+    uptr end   = start + area->size;
+
+    for (uptr v = start; v < end; v += hal::kPageSizeBytes) {
+        auto res = mmu_->SetPageFlags(as, UptrToPtr<void>(v), pf);
+        if (res) {
+            tlb_->InvalidatePage(UptrToPtr<void>(v));
+        } else if (res.error() != MemError::NotFound) {
+            return unexpected(res.error());
+        }
+        // NotFound means page not mapped yet (lazy allocation),
+        // which is fine as future faults will use new VMA flags.
+    }
+
+    return {};
+}
+
 }  // namespace Mem
diff --git a/kernel/src/mem/virt/vmm.hpp b/kernel/src/mem/virt/vmm.hpp
index bb05c21f..7a87f6b7 100644
--- a/kernel/src/mem/virt/vmm.hpp
+++ b/kernel/src/mem/virt/vmm.hpp
@@ -40,9 +40,9 @@ class VirtualMemoryManager
 
     expected<VPtr<void>, MemError> AddArea(VPtr<AddressSpace> as, VMemArea vma);
     expected<void, MemError> RmArea(VPtr<AddressSpace> as, VPtr<void> region_start);
-    // expected<void, MemError> UpdateAreaFlags(
-    //     VPtr<AddressSpace> as, VPtr<void> region_start, VirtualMemAreaFlags vmaf
-    // );
+    expected<void, MemError> UpdateAreaFlags(
+        VPtr<AddressSpace> as, VPtr<void> region_start, VirtualMemAreaFlags vmaf
+    );
 
     private:
     // ------------------------------
diff --git a/kernel/src/sys/loader.cpp b/kernel/src/sys/loader.cpp
index 8b523e00..82906a34 100644
--- a/kernel/src/sys/loader.cpp
+++ b/kernel/src/sys/loader.cpp
@@ -8,6 +8,7 @@
 #include "modules/memory.hpp"
 #include "modules/vfs.hpp"
 #include "sys/elf/elf.hpp"
+
 #include "trace_framework.hpp"
 
 namespace System
@@ -40,9 +41,11 @@ bool ValidateElfHeader(const Elf::Header &header)
 
 expected<Mem::VPtr<void>, LoadError> ElfLoader::Load(const vfs::Path &path, Mem::AddressSpace &as)
 {
+    TRACE_INFO_GENERAL("ElfLoader::Load()");
     auto &vfs = VfsModule::Get();
 
     // 1. Check if file exists
+    TRACE_FREQ_INFO_GENERAL("Validating the file exists");
     auto exists_res = vfs.FileExists(path);
     if (!exists_res.has_value() || !exists_res.value()) {
         return unexpected(LoadError::FileNotFound);
@@ -56,6 +59,7 @@ expected<Mem::VPtr<void>, LoadError> ElfLoader::Load(const vfs::Path &path, Mem:
     }
 
     // 3. Validate ELF
+    TRACE_FREQ_INFO_GENERAL("Validating the ELF header");
     if (!ValidateElfHeader(header)) {
         return unexpected(LoadError::InvalidElf);
     }
@@ -73,6 +77,7 @@ expected<Mem::VPtr<void>, LoadError> ElfLoader::Load(const vfs::Path &path, Mem:
         Mem::KFree(ph_raw);
     });
 
+    TRACE_FREQ_INFO_GENERAL("Validating the ELF header");
     read_res = vfs.ReadFile(path, ph_raw, ph_size, header.phoff);
     if (!read_res.has_value() || read_res.value() != ph_size) {
         return unexpected(LoadError::IoError);
@@ -81,6 +86,7 @@ expected<Mem::VPtr<void>, LoadError> ElfLoader::Load(const vfs::Path &path, Mem:
     auto *ph_table = reinterpret_cast<Elf::ProgramHeader *>(ph_raw);
 
     // 5. Load Segments
+    TRACE_FREQ_INFO_GENERAL("Validating the ELF header");
     for (u16 i = 0; i < header.phnum; ++i) {
         auto &ph = ph_table[i];
         if (ph.type != Elf::ProgramHeader::kTypeLoad) {
@@ -93,18 +99,22 @@ expected<Mem::VPtr<void>, LoadError> ElfLoader::Load(const vfs::Path &path, Mem:
         u64 virt_start = AlignDown(ph.vaddr, hal::kPageSizeBytes);
         u64 virt_end   = AlignUp(ph.vaddr + ph.memsz, hal::kPageSizeBytes);
         u64 size       = virt_end - virt_start;
+        TRACE_INFO_GENERAL("Loading segment %d: [0x%llX - 0x%llX]", i, virt_start, virt_end);
 
         // Permissions
-        VirtualMemAreaFlags flags = {};
-        flags.readable            = (ph.flags & Elf::ProgramHeader::kFlagRead) != 0U;
-        flags.writable            = (ph.flags & Elf::ProgramHeader::kFlagWrite) != 0U;
-        flags.executable          = (ph.flags & Elf::ProgramHeader::kFlagExec) != 0U;
+        VirtualMemAreaFlags original_flags = {};
+        original_flags.readable            = (ph.flags & Elf::ProgramHeader::kFlagRead) != 0U;
+        original_flags.writable            = (ph.flags & Elf::ProgramHeader::kFlagWrite) != 0U;
+        original_flags.executable          = (ph.flags & Elf::ProgramHeader::kFlagExec) != 0U;
+
+        VirtualMemAreaFlags loading_flags = original_flags;
+        loading_flags.writable            = true;
 
         // Add VMA to Address Space
         VMemArea vma{
             .start                = UptrToPtr<void>(virt_start),
             .size                 = size,
-            .flags                = flags,
+            .flags                = loading_flags,
             .type                 = VirtualMemAreaT::Anonymous,
             .direct_mapping_start = nullptr,
         };
@@ -132,7 +142,15 @@ expected<Mem::VPtr<void>, LoadError> ElfLoader::Load(const vfs::Path &path, Mem:
             memset(bss_dest, 0, ph.memsz - ph.filesz);
         }
 
-        TRACE_INFO_GENERAL("Loaded segment %d: [0x%llX - 0x%llX]", i, virt_start, virt_end);
+        // Restore flags
+        if (loading_flags.writable != original_flags.writable) {
+            if (auto res =
+                    MemoryModule::Get().GetVmm().UpdateAreaFlags(&as, vma.start, original_flags);
+                !res) {
+                TRACE_WARN_GENERAL("Failed to restore flags for segment %d", i);
+                return unexpected(LoadError::MemoryError);
+            }
+        }
     }
 
     u64 entry_point = header.entry;

From b65354a289fe59e9ac3afde5033d15b0c0a3a69d Mon Sep 17 00:00:00 2001
From: Jakub Lisowski <115403674+Jlisowskyy@users.noreply.github.com>
Date: Sun, 28 Dec 2025 13:50:20 +0100
Subject: [PATCH 22/56] Jlisowskyy/scheduler 1 (#247)

Things done in this PR:
- Finished switch task function for kernel threads
- introduced concept of kthreads
- added convertion function
- tested context switching
---
 kernel/arch/x86_64/src/hal/impl/core.cpp      |  11 +-
 kernel/arch/x86_64/src/hal/impl/core.hpp      |   8 ++
 .../arch/x86_64/src/hal/impl/scheduling.cpp   |  35 ++++++
 .../arch/x86_64/src/hal/impl/scheduling.hpp   |  10 +-
 kernel/arch/x86_64/src/include/thread.nasm    |   2 +
 kernel/arch/x86_64/src/kernel/init.cpp        |   5 +
 .../x86_64/src/scheduling/scheduling.nasm     | 101 ++++++++++++++----
 kernel/src/hal/constants.hpp                  |  11 ++
 kernel/src/hal/scheduling.hpp                 |  12 ++-
 kernel/src/hardware/core_local.hpp            |   7 +-
 kernel/src/scheduling/kworker.cpp             |   9 ++
 kernel/src/scheduling/kworker.hpp             |   9 ++
 kernel/src/scheduling/process.hpp             |   6 ++
 kernel/src/scheduling/task_mgr.cpp            |  93 ++++++++++------
 kernel/src/scheduling/task_mgr.hpp            |   6 +-
 kernel/src/scheduling/thread.hpp              |   2 +
 kernel/src/scheduling/threads.cpp             |  21 +++-
 kernel/src/scheduling/threads.hpp             |   7 +-
 kernel/src/trace.cpp                          |  16 +--
 kernel/test/manual_tests.cpp                  |  69 ++++++++++++
 20 files changed, 371 insertions(+), 69 deletions(-)
 create mode 100644 kernel/arch/x86_64/src/hal/impl/scheduling.cpp
 create mode 100644 kernel/src/scheduling/kworker.cpp
 create mode 100644 kernel/src/scheduling/kworker.hpp

diff --git a/kernel/arch/x86_64/src/hal/impl/core.cpp b/kernel/arch/x86_64/src/hal/impl/core.cpp
index 02273e36..eec13c4c 100644
--- a/kernel/arch/x86_64/src/hal/impl/core.cpp
+++ b/kernel/arch/x86_64/src/hal/impl/core.cpp
@@ -6,16 +6,16 @@
 
 extern "C" void GdtFlush(cpu::Gdtr *gdtr, u64 kernel_code_offset, u64 kernel_data_offset);
 
-using namespace arch;
-
+namespace arch
+{
 void Core::EnableCore()
 {
     // TODO:
 }
 
-void arch::InitializeCoreLocal()
+void InitializeCoreLocal()
 {
-    auto *core_local = static_cast<hardware::CoreLocal *>(GetCoreLocalData());
+    auto core_local = static_cast<hardware::CoreLocal *>(GetCoreLocalData());
 
     cpu::DefaultGdtInit(core_local->gdt, reinterpret_cast<u64>(&core_local->tss));
     core_local->gdtr.limit = sizeof(cpu::GDT) - 1;
@@ -29,3 +29,6 @@ void arch::InitializeCoreLocal()
         "Successfully initialized GDT and TSS for core with id %hu", core_local->lid
     );
 }
+}  // namespace arch
+
+void cdecl_SetTssRsp0(const u64 rsp0) { arch::SetTssRsp0(rsp0); }
diff --git a/kernel/arch/x86_64/src/hal/impl/core.hpp b/kernel/arch/x86_64/src/hal/impl/core.hpp
index da10466b..cddb9254 100644
--- a/kernel/arch/x86_64/src/hal/impl/core.hpp
+++ b/kernel/arch/x86_64/src/hal/impl/core.hpp
@@ -96,8 +96,16 @@ FAST_CALL void SetCoreLocalData(void *data)
 
 FAST_CALL void *GetCoreLocalData() { return reinterpret_cast<void *>(cpu::GetMSR(kIa32GsBase)); }
 
+FAST_CALL void SetTssRsp0(const u64 rsp0)
+{
+    const auto core_local = static_cast<CoreLocal *>(GetCoreLocalData());
+    core_local->tss.rsp0  = rsp0;
+}
+
 void InitializeCoreLocal();
 
 }  // namespace arch
 
+extern "C" void cdecl_SetTssRsp0(u64 rsp0);
+
 #endif  // KERNEL_ARCH_X86_64_SRC_HAL_IMPL_CORE_HPP_
diff --git a/kernel/arch/x86_64/src/hal/impl/scheduling.cpp b/kernel/arch/x86_64/src/hal/impl/scheduling.cpp
new file mode 100644
index 00000000..d7f87e40
--- /dev/null
+++ b/kernel/arch/x86_64/src/hal/impl/scheduling.cpp
@@ -0,0 +1,35 @@
+#include "hal/impl/scheduling.hpp"
+#include "scheduling/threads.hpp"
+
+#include <string.h>
+
+template <auto func = Sched::KThreadEntrypoint>
+FAST_CALL void InitializeStack(void **stack, void (*f)())
+{
+    static constexpr size_t kStackSpace = 16 * 8;  // 15 regs + rip
+    static constexpr size_t kRipOffset  = 15 * 8;  // 15 regs
+    static constexpr size_t kRdiOffset  = 4 * 8;   // rdi = 5th reg
+
+    auto stack_top = static_cast<byte *>(*stack) - kStackSpace;
+
+    memset(stack_top, 0, kStackSpace);
+    *reinterpret_cast<u64 *>(stack_top + kRdiOffset) = reinterpret_cast<u64>(f);
+    *reinterpret_cast<u64 *>(stack_top + kRipOffset) = reinterpret_cast<u64>(func);
+
+    *stack = reinterpret_cast<void *>(stack_top);
+}
+
+namespace arch
+{
+void InitializeStackKThread(void **stack, void (*f)())
+{
+    InitializeStack<Sched::KThreadEntrypoint>(stack, f);
+}
+
+void InitializeStackUserThread(void **stack, void (*f)())
+{
+    DEBUG_INFO_SCHEDULING("XD");
+    InitializeStack<Sched::UserThreadEntrypoint>(stack, f);
+}
+
+}  // namespace arch
diff --git a/kernel/arch/x86_64/src/hal/impl/scheduling.hpp b/kernel/arch/x86_64/src/hal/impl/scheduling.hpp
index a9e17a49..d7061285 100644
--- a/kernel/arch/x86_64/src/hal/impl/scheduling.hpp
+++ b/kernel/arch/x86_64/src/hal/impl/scheduling.hpp
@@ -3,11 +3,17 @@
 
 #include "scheduling/thread.hpp"
 
-extern "C" void SwitchToTask(Sched::Thread *thread);
+extern "C" void ConvertToKernelTask(Sched::Thread *thread);
+extern "C" void SwitchToKernelTask(Sched::Thread *thread);
+extern "C" void SwitchToUserTask(Sched::Thread *thread);
 
 namespace arch
 {
-using ::SwitchToTask;
+using ::ConvertToKernelTask;
+using ::SwitchToKernelTask;
+using ::SwitchToUserTask;
+void InitializeStackKThread(void **stack, void (*f)());
+void InitializeStackUserThread(void **stack, void (*f)());
 }  // namespace arch
 
 #endif  // KERNEL_ARCH_X86_64_SRC_HAL_IMPL_SCHEDULING_HPP_
diff --git a/kernel/arch/x86_64/src/include/thread.nasm b/kernel/arch/x86_64/src/include/thread.nasm
index 220ed410..6c0a445f 100644
--- a/kernel/arch/x86_64/src/include/thread.nasm
+++ b/kernel/arch/x86_64/src/include/thread.nasm
@@ -7,5 +7,7 @@ struc Thread
     .owner:        resq 1
     .next:         resq 1
     .kernel_stack: resq 1
+    .kernel_stack_bottom: resq 1
     .user_stack:   resq 1
+    .user_stack_bottom:   resq 1
 endstruc
diff --git a/kernel/arch/x86_64/src/kernel/init.cpp b/kernel/arch/x86_64/src/kernel/init.cpp
index 53012ec3..57cb496d 100644
--- a/kernel/arch/x86_64/src/kernel/init.cpp
+++ b/kernel/arch/x86_64/src/kernel/init.cpp
@@ -54,6 +54,8 @@ namespace arch
 {
 void ArchInit(const RawBootArguments &)
 {
+    hal::SetCoreLocalData(nullptr);
+
     DEBUG_INFO_BOOT("In ArchInit...");
     DEBUG_INFO_BOOT("CPU Model: %d / %08X", GetCpuModel(), GetCpuModel());
 
@@ -69,6 +71,9 @@ void ArchInit(const RawBootArguments &)
     HardwareModule::Init();
     HardwareModule::Get().GetInterrupts().FirstStageInit();
 
+    /* Zero mem core local as no global constructors available yet */
+    memset(&g_CoreLocal, 0, sizeof(hardware::CoreLocal));
+
     hal::SetCoreLocalData(&g_CoreLocal);
     InitializeCoreLocal();
 
diff --git a/kernel/arch/x86_64/src/scheduling/scheduling.nasm b/kernel/arch/x86_64/src/scheduling/scheduling.nasm
index c2c52717..812455d7 100644
--- a/kernel/arch/x86_64/src/scheduling/scheduling.nasm
+++ b/kernel/arch/x86_64/src/scheduling/scheduling.nasm
@@ -10,43 +10,104 @@ bits 64
 extern cdecl_GetCurrentTCB
 extern cdecl_SetCurrentTCB
 extern cdecl_GetThreadsPageTable
+extern cdecl_SetTssRsp0
 
 section .text
-global SwitchToTask
+global SwitchToKernelTask
+global SwitchToUserTask
+global ConvertToKernelTask
 
 ; c_decl
-; void SwitchToTask(Thread* thread)q
+; void ConvertToKernelTask(Thread* thread)
 ;   RDI = thread
 ; Note: Caller is responsible for ensuring proper environment before calling (disabling IRQs)
-; Layout:
-;   RAX = current TCB
-;   RDI = next TCB
-;   R10 = next cr3
-;   R11 = next kernel stack | current cr3
-SwitchToTask:
+ConvertToKernelTask:
+    mov r12, rdi                          ; Save next TCB pointer in r12 (non-volatile) to survive C++ calls
+    call cdecl_SetCurrentTCB              ; Change TCB
+    mov  rsp, [r12+Thread.kernel_stack]   ; Change the stack
+
+    pop_all_regs                    ; Restore registers of NEW thread's stack
+    add rsp, _all_reg_size          ; Deallocate register save space.
+
+    ret                             ; Load next thread's RIP from its stack
+
+; c_decl
+; void SwitchToKernelTask(Thread* thread)
+;   RDI = thread
+; Note: Caller is responsible for ensuring proper environment before calling (disabling IRQs)
+SwitchToKernelTask:
     ; ------------------------
     ; Save current task state
 
-    sub rsp, _sysv_reg_size          ; Allocate space for saving registers.
-    push_sysv_regs                   ; Save registers of calling TCB on ITS stack
+    sub rsp, _all_reg_size             ; Allocate space for saving registers.
+    push_all_regs                      ; Save registers of calling TCB on ITS stack
 
-    call cdecl_GetCurrentTCB         ; RAX = pointer to TCB
-    mov [rax+Thread.user_stack], esp ; Save ESP for previous task's kernel stack in the thread's TCB
+    mov r12, rdi                       ; Save next TCB pointer in r12 (non-volatile) to survive C++ calls
+
+    call cdecl_GetCurrentTCB           ; RAX = pointer to TCB
+    mov [rax+Thread.kernel_stack], rsp ; Save RSP for previous task's kernel stack in the thread's TCB
 
     ; ------------------------
     ; Setup next task state
 
-    call cdecl_SetCurrentTCB           ; Next task TCB already in RDI
-    mov esp, [rdi+Thread.user_stack]   ; Change the stack
-    mov r11, [rdi+Thread.kernel_stack] ; Load next task's kernel stack
-;    mov [TSS.ESP0]
+    mov rdi, r12                         ; Restore next TCB pointer to RDI for the next call
+    call cdecl_SetCurrentTCB
+    mov rsp, [r12+Thread.kernel_stack]   ; Change the stack
 
-;    call cdecl_GetThreadsPageTable   ; RAX = next cr3
+    mov rdi, r12                       ; Set RDI for GetThreadsPageTable
+    call cdecl_GetThreadsPageTable     ; RAX = next cr3
+    mov r11, cr3                       ; R11 = current cr3
 
+    cmp r11, rax                       ; Skip virtual address space change if not needed - omit tlb flushes
+    je .done
+    mov cr3, rax                       ; Load next task's virtual address space
 
 .done:
 
-    pop_sysv_regs                    ; Restore registers of NEW thread's stack
-    add rsp, _sysv_reg_size          ; Deallocate register save space.
+    pop_all_regs                    ; Restore registers of NEW thread's stack
+    add rsp, _all_reg_size          ; Deallocate register save space.
+
+    ret                             ; Load next thread's RIP from its stack
+
+; c_decl
+; void SwitchToUserTask(Thread* thread)
+;   RDI = thread
+; Note: Caller is responsible for ensuring proper environment before calling (disabling IRQs)
+SwitchToUserTask:
+    ret
 
-    ret ; Load next thread's EIP from its kernel stack
+;    ; ------------------------
+;    ; Save current task state
+;
+;    sub rsp, _all_reg_size          ; Allocate space for saving registers.
+;    push_all_regs                   ; Save registers of calling TCB on ITS stack
+;
+;    mov r12, rdi                     ; Save next TCB pointer in r12 (non-volatile) to survive C++ calls
+;
+;    call cdecl_GetCurrentTCB           ; RAX = pointer to TCB
+;    mov [rax+Thread.kernel_stack], rsp ; Save RSP for previous task's kernel stack in the thread's TCB
+;
+;    ; ------------------------
+;    ; Setup next task state
+;
+;    mov rdi, r12                       ; Restore next TCB pointer to RDI for the next call
+;    call cdecl_SetCurrentTCB
+;    mov rsp, [r12+Thread.user_stack]   ; Change the stack
+;
+;    mov rdi, r12                     ; Set RDI for GetThreadsPageTable
+;    call cdecl_GetThreadsPageTable     ; RAX = next cr3
+;    mov r11, cr3                       ; R11 = current cr3
+;
+;    mov rdi, [r12+Thread.kernel_stack] ; Load next task's kernel stack
+;    call cdecl_SetTssRsp0
+;
+;    cmp r11, rax ; Skip virtual address space change if not needed - omit tlb flushes
+;    je .done
+;    mov cr3, rax ; Load next task's virtual address space
+;
+;.done:
+;
+;    pop_all_regs                    ; Restore registers of NEW thread's stack
+;    add rsp, _all_reg_size          ; Deallocate register save space.
+;
+;    ret ; Load next thread's RIP from its stack
diff --git a/kernel/src/hal/constants.hpp b/kernel/src/hal/constants.hpp
index 78f67d6b..9c8a96ad 100644
--- a/kernel/src/hal/constants.hpp
+++ b/kernel/src/hal/constants.hpp
@@ -23,6 +23,17 @@ static constexpr u16 kElfMachineType = arch::kElfMachineType;
 
 using arch::HardwareClockId;
 using arch::HardwareEventClockId;
+
+NODISCARD FAST_CALL bool IsKernelSpace(const u64 address)
+{
+    return address >= kKernelVirtualAddressStart;
+}
+
+NODISCARD FAST_CALL bool IsKernelSpace(const void *address)
+{
+    return IsKernelSpace(reinterpret_cast<u64>(address));
+}
+
 }  // namespace hal
 
 #endif  // KERNEL_SRC_HAL_CONSTANTS_HPP_
diff --git a/kernel/src/hal/scheduling.hpp b/kernel/src/hal/scheduling.hpp
index 6f0030ee..acfb0c69 100644
--- a/kernel/src/hal/scheduling.hpp
+++ b/kernel/src/hal/scheduling.hpp
@@ -8,7 +8,17 @@
 
 namespace hal
 {
-WRAP_CALL void SwitchToTask(Sched::Thread *thread) { arch::SwitchToTask(thread); }
+WRAP_CALL void SwitchToKernelTask(Sched::Thread *thread) { arch::SwitchToKernelTask(thread); }
+WRAP_CALL void SwitchToUserTask(Sched::Thread *thread) { arch::SwitchToUserTask(thread); }
+WRAP_CALL void ConvertToKernelTask(Sched::Thread *thread) { arch::ConvertToKernelTask(thread); }
+WRAP_CALL void InitializeStackKThread(void **stack, void (*f)())
+{
+    arch::InitializeStackKThread(stack, f);
+}
+WRAP_CALL void InitializeStackUserThread(void **stack, void (*f)())
+{
+    arch::InitializeStackUserThread(stack, f);
+}
 }  // namespace hal
 
 #endif  // KERNEL_SRC_HAL_SCHEDULING_HPP_
diff --git a/kernel/src/hardware/core_local.hpp b/kernel/src/hardware/core_local.hpp
index cf33a4b0..3a92d179 100644
--- a/kernel/src/hardware/core_local.hpp
+++ b/kernel/src/hardware/core_local.hpp
@@ -19,10 +19,15 @@ FAST_CALL CoreLocal &GetCoreLocalData()
     return *static_cast<CoreLocal *>(hal::GetCoreLocalData());
 }
 
-FAST_CALL Sched::Thread *GetCurrentTCB() { return GetCoreLocalData().thread_control_block; }
+NODISCARD FAST_CALL Sched::Thread *GetCurrentTCB()
+{
+    return GetCoreLocalData().thread_control_block;
+}
 
 FAST_CALL void SetCurrentTCB(Sched::Thread *tcb) { GetCoreLocalData().thread_control_block = tcb; }
 
+NODISCARD FAST_CALL Sched::Pid GetRunningPid() { return GetCurrentTCB()->owner; }
+
 }  // namespace hardware
 
 extern "C" Sched::Thread *cdecl_GetCurrentTCB();
diff --git a/kernel/src/scheduling/kworker.cpp b/kernel/src/scheduling/kworker.cpp
new file mode 100644
index 00000000..f7f26383
--- /dev/null
+++ b/kernel/src/scheduling/kworker.cpp
@@ -0,0 +1,9 @@
+#include "kworker.hpp"
+#include "trace_framework.hpp"
+
+void Sched::KWorkerMain()
+{
+    TRACE_INFO_SCHEDULING("Created new KWorker!");
+    while (true) {
+    }
+}
diff --git a/kernel/src/scheduling/kworker.hpp b/kernel/src/scheduling/kworker.hpp
new file mode 100644
index 00000000..6f300ac0
--- /dev/null
+++ b/kernel/src/scheduling/kworker.hpp
@@ -0,0 +1,9 @@
+#ifndef KERNEL_SRC_SCHEDULING_KWORKER_HPP_
+#define KERNEL_SRC_SCHEDULING_KWORKER_HPP_
+
+namespace Sched
+{
+void KWorkerMain();
+}  // namespace Sched
+
+#endif  // KERNEL_SRC_SCHEDULING_KWORKER_HPP_
diff --git a/kernel/src/scheduling/process.hpp b/kernel/src/scheduling/process.hpp
index a568a46d..73a0dc35 100644
--- a/kernel/src/scheduling/process.hpp
+++ b/kernel/src/scheduling/process.hpp
@@ -13,9 +13,15 @@ struct PACK Pid {
     u64 count : 48;
 };
 
+struct PACK ProcessFlags {
+    bool KernelSpaceOnly : 1;
+};
+static_assert(sizeof(ProcessFlags) == 1);
+
 struct Process {
     /* Management */
     Pid pid;
+    ProcessFlags flags;
 
     /* Process resources */
     Mem::VirtualPtr<Mem::AddressSpace> address_space;
diff --git a/kernel/src/scheduling/task_mgr.cpp b/kernel/src/scheduling/task_mgr.cpp
index 4b6b19ff..b9905869 100644
--- a/kernel/src/scheduling/task_mgr.cpp
+++ b/kernel/src/scheduling/task_mgr.cpp
@@ -2,6 +2,7 @@
 
 #include "modules/memory.hpp"
 #include "modules/scheduling.hpp"
+#include "scheduling/kworker.hpp"
 #include "task_mgr.hpp"
 #include "trace_framework.hpp"
 
@@ -20,9 +21,9 @@ namespace Sched
 void TaskMgr::InitializeMultitasking()
 {
     // Spawn 3 Kernel Workers
-    static constexpr size_t kNumKWorkers = 3;
+    static constexpr size_t kNumKWorkers = 0;
     for (size_t i = 0; i < kNumKWorkers; ++i) {
-        auto result = SpawnProcess();
+        auto result = SpawnProcess(KWorkerMain, true);
         R_ASSERT_TRUE(
             static_cast<bool>(result),
             "Failed to spawn kernel workers. Not enough resources for the system"
@@ -34,10 +35,18 @@ void TaskMgr::InitializeMultitasking()
     }
 }
 
-std::expected<Pid, Error> TaskMgr::SpawnProcess()
+std::expected<std::tuple<Pid, Tid>, Error> TaskMgr::SpawnProcess(
+    void (*f)(), const bool kernel_only
+)
 {
     bool dismiss = false;
 
+    if (kernel_only) {
+        ASSERT_TRUE(hal::IsKernelSpace(reinterpret_cast<void *>(f)));
+    } else {
+        ASSERT_FALSE(hal::IsKernelSpace(reinterpret_cast<void *>(f)));
+    }
+
     // 1. Prepare internal structure for the process
     auto process = SchedulingModule::Get().GetProcesses().PrepareProcess();
     if (!process) {
@@ -53,25 +62,31 @@ std::expected<Pid, Error> TaskMgr::SpawnProcess()
     });
 
     // 2. Fill process data and resources - TODO: replace with proper one
-    TODO_WHEN_VMEM_WORKS
-    process.value()->address_space = &MemoryModule::Get().GetKernelAddressSpace();
-    // auto addr_space = MemoryModule::Get().GetVmm().CreateAddrSpace();
-    // if (!addr_space) {
-    //     DEBUG_WARN_SCHEDULING(
-    //         "Failed to create process. Failed on AddressSpace creation: %s",
-    //         template_lib::to_string(addr_space.error()).data()
-    //     );
-    //     return std::unexpected(Error::OutOfMemory);
-    // }
-    // process.value()->address_space = addr_space.value();
-    // template_lib::BatchedScopeGuard addr_space_guard(dismiss, [&]() {
-    //     [[maybe_unused]] const auto result =
-    //         MemoryModule::Get().GetVmm().DestroyAddrSpace(addr_space.value());
-    //     ASSERT_TRUE(static_cast<bool>(result));
-    // });
+    if (kernel_only) {
+        process.value()->address_space         = &MemoryModule::Get().GetKernelAddressSpace();
+        process.value()->flags.KernelSpaceOnly = true;
+    } else {
+        R_FAIL_ALWAYS("User space tasks not supported!");
+
+        TODO_WHEN_VMEM_WORKS
+        // auto addr_space = MemoryModule::Get().GetVmm().CreateAddrSpace();
+        // if (!addr_space) {
+        //     DEBUG_WARN_SCHEDULING(
+        //         "Failed to create process. Failed on AddressSpace creation: %s",
+        //         template_lib::to_string(addr_space.error()).data()
+        //     );
+        //     return std::unexpected(Error::OutOfMemory);
+        // }
+        // process.value()->address_space = addr_space.value();
+        // template_lib::BatchedScopeGuard addr_space_guard(dismiss, [&]() {
+        //     [[maybe_unused]] const auto result =
+        //         MemoryModule::Get().GetVmm().DestroyAddrSpace(addr_space.value());
+        //     ASSERT_TRUE(static_cast<bool>(result));
+        // });
+    }
 
     // 3. Spawn first thread
-    const auto tid = SpawnThread(process.value()->pid);
+    const auto tid = SpawnThread(process.value()->pid, f);
     if (!tid) {
         DEBUG_WARN_SCHEDULING(
             "Failed to create process. Failed on initial thread creation: %s",
@@ -88,13 +103,16 @@ std::expected<Pid, Error> TaskMgr::SpawnProcess()
     );
 
     dismiss = true;
-    return process.value()->pid;
+    return std::make_tuple(process.value()->pid, tid.value());
 }
 
-std::expected<Tid, Error> TaskMgr::SpawnThread(const Pid pid)
+std::expected<Tid, Error> TaskMgr::SpawnThread(const Pid pid, void (*f)())
 {
     bool dismiss = false;
 
+    const auto process = SchedulingModule::Get().GetProcesses().GetProcess(pid);
+    ASSERT_TRUE(static_cast<bool>(process));
+
     // 1. Prepare internal structure for execution unit - thread:
     auto thread = SchedulingModule::Get().GetThreads().PrepareThread();
     if (!thread) {
@@ -127,19 +145,32 @@ std::expected<Tid, Error> TaskMgr::SpawnThread(const Pid pid)
     template_lib::BatchedScopeGuard esp0_guard(dismiss, [&]() {
         Mem::KFreeAligned(kernel_stack.value());
     });
-    thread.value()->kernel_stack = kernel_stack.value();
+    thread.value()->kernel_stack        = kernel_stack.value();
+    thread.value()->kernel_stack_bottom = kernel_stack.value();
 
     // 2.2 Thread Stack
-    const auto thread_stack = Mem::KMallocAligned({kStackSize, kStackAlignment});
-    if (!thread_stack) {
-        DEBUG_WARN_SCHEDULING(
-            "Failed to create thread for %llu. Failed on thread stack allocation: %s", pid,
-            to_string(thread_stack.error())
-        );
+    if (!process.value()->flags.KernelSpaceOnly) {
+        const auto thread_stack = Mem::KMallocAligned({kStackSize, kStackAlignment});
+        if (!thread_stack) {
+            DEBUG_WARN_SCHEDULING(
+                "Failed to create thread for %llu. Failed on thread stack allocation: %s", pid,
+                to_string(thread_stack.error())
+            );
+
+            return std::unexpected(Error::OutOfMemory);
+        }
+        thread.value()->user_stack        = thread_stack.value();
+        thread.value()->user_stack_bottom = thread_stack.value();
+    } else {
+        thread.value()->user_stack        = nullptr;
+        thread.value()->user_stack_bottom = nullptr;
+    }
 
-        return std::unexpected(Error::OutOfMemory);
+    if (process.value()->flags.KernelSpaceOnly) {
+        hal::InitializeStackKThread(&thread.value()->kernel_stack, f);
+    } else {
+        hal::InitializeStackUserThread(&thread.value()->kernel_stack, f);
     }
-    thread.value()->user_stack = thread_stack.value();
 
     dismiss = true;
     return thread.value()->tid;
diff --git a/kernel/src/scheduling/task_mgr.hpp b/kernel/src/scheduling/task_mgr.hpp
index c6eb8621..17f2c8da 100644
--- a/kernel/src/scheduling/task_mgr.hpp
+++ b/kernel/src/scheduling/task_mgr.hpp
@@ -24,9 +24,11 @@ class TaskMgr
 
     void InitializeMultitasking();
 
-    NODISCARD std::expected<Pid, Error> SpawnProcess();
+    NODISCARD std::expected<std::tuple<Pid, Tid>, Error> SpawnProcess(
+        void (*f)(), bool kernel_only
+    );
 
-    NODISCARD std::expected<Tid, Error> SpawnThread(Pid pid);
+    NODISCARD std::expected<Tid, Error> SpawnThread(Pid pid, void (*f)());
 
     // ------------------------------
     // Private methods
diff --git a/kernel/src/scheduling/thread.hpp b/kernel/src/scheduling/thread.hpp
index 6b5a67ca..9816ee17 100644
--- a/kernel/src/scheduling/thread.hpp
+++ b/kernel/src/scheduling/thread.hpp
@@ -24,7 +24,9 @@ struct PACK Thread {
 
     /* Thread resources */
     void *kernel_stack;
+    void *kernel_stack_bottom;
     void *user_stack;
+    void *user_stack_bottom;
 };
 }  // namespace Sched
 
diff --git a/kernel/src/scheduling/threads.cpp b/kernel/src/scheduling/threads.cpp
index 7678615e..f890dfec 100644
--- a/kernel/src/scheduling/threads.cpp
+++ b/kernel/src/scheduling/threads.cpp
@@ -1,7 +1,9 @@
 #include "threads.hpp"
 #include "modules/scheduling.hpp"
 
-std::expected<Sched::Thread *, Sched::Error> Sched::Threads::PrepareThread()
+namespace Sched
+{
+std::expected<Thread *, Error> Threads::PrepareThread()
 {
     const size_t idx = threads_.Allocate();
 
@@ -17,6 +19,23 @@ std::expected<Sched::Thread *, Sched::Error> Sched::Threads::PrepareThread()
     return thread;
 }
 
+void KThreadEntrypoint(void (*f)())
+{
+    f();
+    OnKThreadExit();
+}
+
+void UserThreadEntrypoint(void (*f)()) { R_FAIL_ALWAYS("Not implemented..."); }
+
+void OnKThreadExit()
+{
+    R_FAIL_ALWAYS("Not implemented. KThread should never return at this stage...");
+}
+
+void OnThreadExit() {}
+
+}  // namespace Sched
+
 void *cdecl_GetThreadsPageTable(Sched::Thread *thread)
 {
     ASSERT_NOT_NULL(thread);
diff --git a/kernel/src/scheduling/threads.hpp b/kernel/src/scheduling/threads.hpp
index 62004d99..4bebdda5 100644
--- a/kernel/src/scheduling/threads.hpp
+++ b/kernel/src/scheduling/threads.hpp
@@ -74,8 +74,13 @@ class Threads
     hal::Atomic64 thread_counter_{};
 };
 
-extern "C" void *cdecl_GetThreadsPageTable(Thread *thread);
+void KThreadEntrypoint(void (*f)());
+void UserThreadEntrypoint(void (*f)());
+void OnKThreadExit();
+void OnThreadExit();
 
 }  // namespace Sched
 
+extern "C" void *cdecl_GetThreadsPageTable(Sched::Thread *thread);
+
 #endif  // KERNEL_SRC_SCHEDULING_THREADS_HPP_
diff --git a/kernel/src/trace.cpp b/kernel/src/trace.cpp
index e21d24cf..820dace6 100644
--- a/kernel/src/trace.cpp
+++ b/kernel/src/trace.cpp
@@ -437,15 +437,19 @@ int WriteTraceData(char *dst, TraceModule module, const TraceType type)
         core_id = ::HardwareModule::Get().GetCoresController().MapHwToLogical(core_id);
     }
 
+    Sched::Pid pid{};
+    if (hal::GetCoreLocalData() != nullptr && hardware::GetCurrentTCB() != nullptr) {
+        pid = hardware::GetRunningPid();
+    }
+
     return snprintf(
         dst, FeatureValue<FeatureFlag::kSingleTraceMaxSize>,
         "[%s] "
-        "[MOD:%s] "     // Module name
-        "[TIME:%llu] "  // Timestamp
-        "[CORE:%u] "    // Core ID
-        "[PROC:%u] ",   // Process ID
-        type == TraceType::kKernelLog ? "LOG" : "DEBUG", module_name, system_time, core_id,
-        0u  // TODO: process ID
+        "[MOD:%s] "      // Module name
+        "[TIME:%llu] "   // Timestamp
+        "[CORE:%u] "     // Core ID
+        "[PROC:%llu] ",  // Process ID
+        type == TraceType::kKernelLog ? "LOG" : "DEBUG", module_name, system_time, core_id, pid
     );
 }
 
diff --git a/kernel/test/manual_tests.cpp b/kernel/test/manual_tests.cpp
index c04e2e6b..1b16eefb 100644
--- a/kernel/test/manual_tests.cpp
+++ b/kernel/test/manual_tests.cpp
@@ -1,4 +1,73 @@
 #include <assert.h>
+
 #include <test_module/test.hpp>
 
+#include "hal/debug.hpp"
+#include "hal/scheduling.hpp"
+#include "hardware/core_local.hpp"
+#include "modules/scheduling.hpp"
+#include "trace_framework.hpp"
+
 MTEST(AssertSnprintfTest) { ASSERT_EQ(2 + 2, 3 + 3, "Values used in the test: %d, %d", 2, 3); }
+
+// ------------------------------
+// KernelTaskSwitchTest
+// ------------------------------
+
+static void Task0()
+{
+    while (true) {
+        TRACE_INFO_GENERAL("Ack from Task0!");
+
+        static constexpr size_t kIters = 1'000'000;
+        for (size_t i = 0; i < kIters; i++) {
+            hal::Noop();
+            hal::Noop();
+            hal::Noop();
+            hal::Noop();
+        }
+
+        const auto tcb = hardware::GetCurrentTCB();
+        hal::SwitchToKernelTask(tcb->next);
+    }
+}
+
+static void Task1()
+{
+    while (true) {
+        TRACE_INFO_GENERAL("Ack from Task1!");
+
+        static constexpr size_t kIters = 1'000'000;
+        for (size_t i = 0; i < kIters; i++) {
+            hal::Noop();
+            hal::Noop();
+            hal::Noop();
+            hal::Noop();
+        }
+
+        const auto tcb = hardware::GetCurrentTCB();
+        hal::SwitchToKernelTask(tcb->next);
+    }
+}
+
+MTEST(KernelTaskSwitchTest)
+{
+    auto p0 = SchedulingModule::Get().GetTaskMgr().SpawnProcess(Task0, true);
+    ASSERT_TRUE(static_cast<bool>(p0));
+    auto p1 = SchedulingModule::Get().GetTaskMgr().SpawnProcess(Task1, true);
+    ASSERT_TRUE(static_cast<bool>(p1));
+
+    const auto tid0 = std::get<1>(p0.value());
+    const auto tid1 = std::get<1>(p1.value());
+
+    const auto t0 = SchedulingModule::Get().GetThreads().GetThread(tid0);
+    ASSERT_TRUE(static_cast<bool>(t0));
+    const auto t1 = SchedulingModule::Get().GetThreads().GetThread(tid1);
+    ASSERT_TRUE(static_cast<bool>(t1));
+
+    t0.value()->next = t1.value();
+    t1.value()->next = t0.value();
+
+    // hal::TerminalWriteString("\nXDDD\n");
+    hal::ConvertToKernelTask(t0.value());
+}

From f1bc62400d4310bc4c82ae892230c3e534335877 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C5=81ukasz=20Kryczka?=
 <60490378+kryczkal@users.noreply.github.com>
Date: Sun, 28 Dec 2025 20:44:03 +0100
Subject: [PATCH 23/56] Fix vmm refactor (#248)

The past 3 mmu/vmm commits redone in a cleaner way.
---
 kernel/arch/x86_64/src/cpu/enable_nxe.nasm    |   2 +-
 .../arch/x86_64/src/drivers/apic/io_apic.cpp  |   5 +-
 .../x86_64/src/drivers/apic/local_apic.cpp    |  15 +-
 .../x86_64/src/drivers/apic/local_apic.hpp    |   8 +-
 kernel/arch/x86_64/src/drivers/hpet/hpet.hpp  |   4 +-
 kernel/arch/x86_64/src/hal/impl/core.cpp      |   2 +-
 kernel/arch/x86_64/src/hal/impl/mmu.cpp       | 362 ++----------------
 kernel/arch/x86_64/src/hal/impl/mmu.hpp       |  53 ++-
 kernel/arch/x86_64/src/hal/impl/mmu.tpp       | 259 +++++++++++++
 kernel/arch/x86_64/src/interrupts/idt.nasm    |   2 +-
 kernel/arch/x86_64/src/mem/page_map.hpp       |  36 +-
 kernel/src/hal/api/mmu.hpp                    | 150 ++++----
 kernel/src/hal/mmu.hpp                        | 187 ++++++++-
 kernel/src/io/pipe.hpp                        |   9 +-
 kernel/src/io/stream.hpp                      |  10 +-
 kernel/src/macros.hpp                         |   6 +-
 kernel/src/mem/allocators.hpp                 |   2 +-
 kernel/src/mem/heap.cpp                       |  17 +-
 kernel/src/mem/page_meta.hpp                  |  21 +-
 kernel/src/mem/phys/mngr/bitmap.cpp           |  10 +-
 kernel/src/mem/phys/mngr/buddy.cpp            |   5 +-
 kernel/src/mem/phys/mngr/slab.cpp             |   9 +-
 kernel/src/mem/virt/addr_space.cpp            |   2 +-
 kernel/src/mem/virt/page_fault.cpp            |  15 +-
 kernel/src/mem/virt/vmm.cpp                   |  70 ++--
 kernel/src/mem/virt/vmm.hpp                   |   5 +-
 kernel/src/modules/memory.cpp                 |  13 +-
 kernel/src/modules/vfs.cpp                    | 108 ++----
 kernel/src/sys/loader.cpp                     |   2 +-
 kernel/src/vfs/fat/fat.hpp                    | 111 ++----
 kernel/test/mmu_test.cpp                      | 141 ++++---
 31 files changed, 857 insertions(+), 784 deletions(-)
 create mode 100644 kernel/arch/x86_64/src/hal/impl/mmu.tpp

diff --git a/kernel/arch/x86_64/src/cpu/enable_nxe.nasm b/kernel/arch/x86_64/src/cpu/enable_nxe.nasm
index 3153cd17..f3d84779 100644
--- a/kernel/arch/x86_64/src/cpu/enable_nxe.nasm
+++ b/kernel/arch/x86_64/src/cpu/enable_nxe.nasm
@@ -1,4 +1,4 @@
-    bits 64
+bits 64
 
     %include "startup/panic.nasm"
 
diff --git a/kernel/arch/x86_64/src/drivers/apic/io_apic.cpp b/kernel/arch/x86_64/src/drivers/apic/io_apic.cpp
index 3a3c5582..38d8c739 100644
--- a/kernel/arch/x86_64/src/drivers/apic/io_apic.cpp
+++ b/kernel/arch/x86_64/src/drivers/apic/io_apic.cpp
@@ -1,12 +1,12 @@
 #include "drivers/apic/io_apic.hpp"
-#include <mem/types.hpp>
 #include "drivers/apic/local_apic.hpp"
 
 #include <bit.hpp>
+#include <mem/types.hpp>
 #include <todo.hpp>
+#include <trace_framework.hpp>
 
 #include "interrupts/idt.hpp"
-#include "trace_framework.hpp"
 
 // ------------------------------
 // static functions
@@ -36,7 +36,6 @@ IoApic::IoApic(const u8 id, const u32 address, const u32 gsi_base)
 {
     ASSERT_NOT_ZERO(address);
 
-    /* Map the address first */
     virtual_address_ = reinterpret_cast<uintptr_t>(
         Mem::PhysToVirt(reinterpret_cast<void *>(static_cast<uintptr_t>(physical_address_)))
     );
diff --git a/kernel/arch/x86_64/src/drivers/apic/local_apic.cpp b/kernel/arch/x86_64/src/drivers/apic/local_apic.cpp
index 10dc681b..670c61d5 100644
--- a/kernel/arch/x86_64/src/drivers/apic/local_apic.cpp
+++ b/kernel/arch/x86_64/src/drivers/apic/local_apic.cpp
@@ -1,11 +1,14 @@
 #include "drivers/apic/local_apic.hpp"
-#include <acpi/acpi.hpp>
-#include <modules/hardware.hpp>
-#include "drivers/pic8259/pic8259.hpp"
 
 #include <assert.h>
 #include <todo.hpp>
-#include "trace_framework.hpp"
+
+#include <acpi/acpi.hpp>
+#include <mem/types.hpp>
+#include <modules/hardware.hpp>
+#include <trace_framework.hpp>
+
+#include "drivers/pic8259/pic8259.hpp"
 
 // ------------------------------
 // Static functions
@@ -69,10 +72,6 @@ void LocalApic::Enable()
 {
     R_ASSERT_TRUE(IsSupported(), "APIC is not supported on this platform...");
 
-    TODO_WHEN_VMEM_WORKS
-    /* Map local apic address to vmem */
-    // TODO: currently: identity
-
     DEBUG_INFO_INTERRUPTS("Assuming APIC address as: %016llX", local_apic_physical_address_);
 
     /* Enable Local Apic by ENABLE flag added to address (Might be enabled or might be not) */
diff --git a/kernel/arch/x86_64/src/drivers/apic/local_apic.hpp b/kernel/arch/x86_64/src/drivers/apic/local_apic.hpp
index 796aeec1..099c0c8c 100644
--- a/kernel/arch/x86_64/src/drivers/apic/local_apic.hpp
+++ b/kernel/arch/x86_64/src/drivers/apic/local_apic.hpp
@@ -2,11 +2,13 @@
 #define KERNEL_ARCH_X86_64_SRC_DRIVERS_APIC_LOCAL_APIC_HPP_
 
 #include <assert.h>
-#include <cpuid.h>
 #include <bit.hpp>
 #include <defines.hpp>
-#include <mem/types.hpp>
 #include <todo.hpp>
+
+#include <cpuid.h>
+#include <mem/types.hpp>
+
 #include "cpu/msrs.hpp"
 #include "hal/impl/constants.hpp"
 #include "include/memory_io.hpp"
@@ -345,6 +347,7 @@ class LocalApic
     template <class InputT>
     FAST_CALL void WriteRegister(const u32 offset, const InputT value)
     {
+        TODO_WHEN_VMEM_WORKS
         WriteMemoryIo<u32>(
             Mem::PhysToVirt(reinterpret_cast<byte *>(GetPhysicalAddressOnCore())), offset, value
         );
@@ -361,6 +364,7 @@ class LocalApic
     template <class RetT = u32>
     FAST_CALL RetT ReadRegister(const u32 offset)
     {
+        TODO_WHEN_VMEM_WORKS
         return ReadMemoryIo<u32, RetT>(
             Mem::PhysToVirt(reinterpret_cast<byte *>(GetPhysicalAddressOnCore())), offset
         );
diff --git a/kernel/arch/x86_64/src/drivers/hpet/hpet.hpp b/kernel/arch/x86_64/src/drivers/hpet/hpet.hpp
index 6bbc07aa..22ac070e 100644
--- a/kernel/arch/x86_64/src/drivers/hpet/hpet.hpp
+++ b/kernel/arch/x86_64/src/drivers/hpet/hpet.hpp
@@ -4,10 +4,12 @@
 #include <uacpi/acpi.h>
 #include <array.hpp>
 #include <data_structures/bit_array.hpp>
-#include <mem/types.hpp>
 #include <time.hpp>
 #include <todo.hpp>
 #include <types.hpp>
+
+#include <mem/types.hpp>
+
 #include "include/memory_io.hpp"
 #include "trace_framework.hpp"
 
diff --git a/kernel/arch/x86_64/src/hal/impl/core.cpp b/kernel/arch/x86_64/src/hal/impl/core.cpp
index eec13c4c..11abbce2 100644
--- a/kernel/arch/x86_64/src/hal/impl/core.cpp
+++ b/kernel/arch/x86_64/src/hal/impl/core.cpp
@@ -15,7 +15,7 @@ void Core::EnableCore()
 
 void InitializeCoreLocal()
 {
-    auto core_local = static_cast<hardware::CoreLocal *>(GetCoreLocalData());
+    auto *core_local = static_cast<hardware::CoreLocal *>(GetCoreLocalData());
 
     cpu::DefaultGdtInit(core_local->gdt, reinterpret_cast<u64>(&core_local->tss));
     core_local->gdtr.limit = sizeof(cpu::GDT) - 1;
diff --git a/kernel/arch/x86_64/src/hal/impl/mmu.cpp b/kernel/arch/x86_64/src/hal/impl/mmu.cpp
index ad53e2bb..d974452d 100644
--- a/kernel/arch/x86_64/src/hal/impl/mmu.cpp
+++ b/kernel/arch/x86_64/src/hal/impl/mmu.cpp
@@ -1,96 +1,12 @@
 #include "hal/impl/mmu.hpp"
-
 #include <macros.hpp>
-#include <modules/memory.hpp>
-
+#include "cpu/control_registers.hpp"
 #include "mem/page_map.hpp"
 
-using namespace arch;
-using namespace Mem;
-
-using std::expected;
-using std::unexpected;
-
-namespace
-{
-
-// Helper to get PageMeta from a physical pointer to a table/page
-// Used by Map/UnMap where MemoryModule is fully initialized
-PageMeta &GetPageMeta(PPtr<void> phys_ptr)
-{
-    auto *aligned_phys = AlignDown(phys_ptr, hal::kPageSizeBytes);
-    return MemoryModule::Get().GetPageMetaTable().GetPageMeta(aligned_phys);
-}
-
-// Helper to get PageMeta from a virtual pointer (e.g. inside a table)
-PageMeta &GetPageMetaFromVirt(VPtr<void> virt_ptr)
-{
-    auto *phys_ptr = VirtToPhys(virt_ptr);
-    return GetPageMeta(phys_ptr);
-}
-
-// Helper to get PageMeta using explicit PageMetaTable (safe during initialization)
-PageMeta &GetPageMeta(PPtr<void> phys_ptr, PageMetaTable &pmt)
-{
-    auto *aligned_phys = AlignDown(phys_ptr, hal::kPageSizeBytes);
-    return pmt.GetPageMeta(aligned_phys);
-}
-
-// Helper to recursively free page table frames
-template <size_t kLevel>
-void FreeTableRecursive(PPtr<void> table_phys, PageMetaTable &pmt, BitmapPmm &pmm)
-{
-    auto *table_virt = reinterpret_cast<PageMapTable<kLevel> *>(PhysToVirt(table_phys));
-
-    for (auto &entry : *table_virt) {
-        if (entry.IsPresent()) {
-            bool is_huge = entry.IsHuge();
-
-            if constexpr (kLevel > 1) {
-                if (!is_huge) {
-                    PPtr<void> child_phys = reinterpret_cast<PPtr<void>>(entry.GetNextLevelTable());
-                    FreeTableRecursive<kLevel - 1>(child_phys, pmt, pmm);
-                }
-            }
-            // If it is a leaf (Level 1, or Huge Level 2/3), we do NOTHING.
-            // We are only destroying the mapping structure, not the memory it points to.
-        }
-    }
-
-    // Now free the table frame itself
-    pmm.Free(reinterpret_cast<PPtr<Page>>(table_phys));
-
-    // Invalidate metadata
-    auto &meta = GetPageMeta(table_phys, pmt);
-    meta.type  = PageMetaType::Dummy;
-}
-
-template <size_t kLevel>
-void ReconstructRecursive(PPtr<void> table_phys, PageMeta *parent, PageMetaTable &pmt)
+namespace arch
 {
-    // Initialize metadata for the current table frame
-    auto &meta = GetPageMeta(table_phys, pmt);
-    meta.InitPageTable(kLevel, parent);
-
-    auto *table_virt = reinterpret_cast<PageMapTable<kLevel> *>(PhysToVirt(table_phys));
-
-    u16 ref_count = 0;
-    for (const auto &entry : *table_virt) {
-        if (entry.IsPresent()) {
-            ref_count++;
-            if constexpr (kLevel > 1) {
-                if (!entry.IsHuge()) {
-                    PPtr<void> child_phys = reinterpret_cast<PPtr<void>>(entry.GetNextLevelTable());
-                    ReconstructRecursive<kLevel - 1>(child_phys, &meta, pmt);
-                }
-                // If page_size is set, then it's a huge page
-            }
-        }
-    }
-    meta.data.page_table.ref_count = ref_count;
-}
 
-}  // namespace
+using namespace Mem;
 
 u64 Mmu::ToArchFlags(PageFlags flags)
 {
@@ -119,263 +35,41 @@ u64 Mmu::ToArchFlags(PageFlags flags)
     return arch_flags;
 }
 
-template <size_t kLevel>
-u64 Mmu::PmeIdx(Mem::VPtr<void> vaddr)
-{
-    static_assert(kLevel > 0);
-    static_assert(kLevel <= 4);
-
-    static constexpr u64 kDefaultOffset     = 12;
-    static constexpr u64 kBitOffsetPerLevel = 9;
-
-    static constexpr u32 kIndexMask = kBitMaskRight<u64, 9>;
-    uptr addr                       = Mem::PtrToUptr(vaddr);
-    return (addr >> (kDefaultOffset + (kLevel - 1) * kBitOffsetPerLevel)) & kIndexMask;
-}
-
-template <size_t kLevel>
-expected<Mem::VPtr<PageMapEntry<kLevel>>, Mem::MemError> Mmu::WalkToEntry(
-    Mem::VPtr<Mem::AddressSpace> as, Mem::VPtr<void> vaddr, bool create_if_missing
-)
+void Mmu::SwitchRoot(Mem::PPtr<void> root)
 {
-    static_assert(kLevel > 0);
-    static_assert(kLevel <= 4);
-
-    // static constexpr u64 kDefFlags = kPresentBit | kWriteBit | kUserAccessibleBit;
-
-    // Helper lambda to process each level
-    auto ProcessLevel = [&]<size_t L>(
-                            Mem::VPtr<PageMapEntry<L>> pme, bool create
-                        ) -> expected<Mem::VPtr<PageMapEntry<L - 1>>, Mem::MemError> {
-        constexpr u64 kDefFlags = kPresentBit | kWriteBit | kUserAccessibleBit;
-
-        if (pme->IsPresent()) {
-            return reinterpret_cast<PageMapEntry<L - 1> *>(
-                Mem::PhysToVirt(pme->GetNextLevelTable())
-            );
-        }
-
-        if (!create) {
-            return unexpected(Mem::MemError::NotFound);
-        }
-
-        auto res = Mem::KMalloc<PageMapTable<L - 1>>();
-        if (!res) {
-            return unexpected(res.error());
-        }
-
-        memset(*res, 0, sizeof(PageMapTable<L - 1>));
-
-        // Initialize Metadata for the new table
-        auto *table_phys = Mem::VirtToPhys(*res);
-        auto &new_meta   = GetPageMeta(table_phys);
-        // pme points inside the parent table
-        auto &parent_meta = GetPageMetaFromVirt(pme);
-
-        new_meta.InitPageTable(L - 1, &parent_meta);
-        pme->SetNextLevelTable(table_phys, kDefFlags);
-
-        // Increment parent ref count
-        PageMeta::AsPageTable(parent_meta).ref_count++;
-
-        return reinterpret_cast<PageMapEntry<L - 1> *>(*res);
-    };
-
-    // PML4
-    auto *pmt_l4 = reinterpret_cast<PageMapEntry<4> *>(Mem::PhysToVirt(as->PageTableRoot()));
-    auto *pme_l4 = &pmt_l4[PmeIdx<4>(vaddr)];
-
-    if constexpr (kLevel == 4) {
-        return pme_l4;
-    }
-
-    // PDP (L3)
-    auto res_l3 = ProcessLevel.template operator()<4>(pme_l4, create_if_missing);
-    if (!res_l3) {
-        return unexpected(res_l3.error());
-    }
-    auto *pme_l3 = &(*res_l3)[PmeIdx<3>(vaddr)];
-
-    if constexpr (kLevel == 3) {
-        return pme_l3;
-    }
-
-    // PD (L2)
-    auto res_l2 = ProcessLevel.template operator()<3>(pme_l3, create_if_missing);
-    if (!res_l2) {
-        return unexpected(res_l2.error());
-    }
-    auto *pme_l2 = &(*res_l2)[PmeIdx<2>(vaddr)];
-
-    if constexpr (kLevel == 2) {
-        return pme_l2;
-    }
-
-    // PT (L1)
-    auto res_l1 = ProcessLevel.template operator()<2>(pme_l2, create_if_missing);
-    if (!res_l1) {
-        return unexpected(res_l1.error());
-    }
-    auto *pme_l1 = &(*res_l1)[PmeIdx<1>(vaddr)];
-
-    if constexpr (kLevel == 1) {
-        return pme_l1;
-    }
-
-    return unexpected(Mem::MemError::InvalidArgument);
+    cpu::Cr3 cr3{};
+    cr3.PageMapLevel4Address = Mem::PtrToUptr(root) >> 12;
+    cpu::SetCR(cr3);
 }
 
-expected<void, MemError> Mmu::Map(
-    VPtr<AddressSpace> as, VPtr<void> vaddr, PPtr<void> paddr, PageFlags flags
+expected<void, MemError> Mmu::SetPageFlags(
+    Mem::PPtr<void> root, Mem::VPtr<void> vaddr, PageFlags flags
 )
 {
-    auto res = WalkToEntry<1>(as, vaddr, true);
-    UNEXPECTED_RET_IF_ERR(res);
-
-    auto *pme_l1 = *res;
-    if (pme_l1->IsPresent()) {
-        // Page is already mapped
-        return unexpected(MemError::InvalidArgument);
-    }
-
-    pme_l1->SetFrameAddress(paddr, ToArchFlags(flags));
-
-    // Increment Page Table (L1) ref count
-    auto &meta = GetPageMetaFromVirt(pme_l1);
-    PageMeta::AsPageTable(meta).ref_count++;
-
-    MemoryModule::Get().GetTlb().InvalidatePage(vaddr);
-
-    return {};
-}
-
-expected<void, MemError> Mmu::UnMap(VPtr<AddressSpace> as, VPtr<void> vaddr)
-{
-    // 1. Find Leaf (L1 entry)
-    auto res = WalkToEntry<1>(as, vaddr, false);
-    if (!res) {
-        return {};  // Already unmapped
-    }
-
-    auto *pme_l1 = *res;
-    if (!pme_l1->IsPresent()) {
-        return {};  // Entry not present
-    }
-
-    // 2. Clear Entry
-    *reinterpret_cast<u64 *>(pme_l1) = 0;
-
-    // 3. Update RefCount
-    auto *l1_table_virt = AlignDown(pme_l1, hal::kPageSizeBytes);
-    auto &l1_meta       = GetPageMetaFromVirt(l1_table_virt);
+    // Walk to leaf without allocating
+    auto *pml4  = reinterpret_cast<PageMapTable<4> *>(Mem::PhysToVirt(root));
+    auto &pml4e = (*pml4)[PmeIdx<4>(vaddr)];
+    RET_UNEXPECTED_IF(!pml4e.IsPresent(), MemError::NotFound);
 
-    auto *curr_meta = &l1_meta;
-    u8 curr_level   = 1;
+    auto *pdpt  = reinterpret_cast<PageMapTable<3> *>(Mem::PhysToVirt(pml4e.GetNextLevelTable()));
+    auto &pdpte = (*pdpt)[PmeIdx<3>(vaddr)];
+    RET_UNEXPECTED_IF(!pdpte.IsPresent(), MemError::NotFound);
+    RET_UNEXPECTED_IF(pdpte.IsHuge(), MemError::InvalidArgument);  // TODO: Support huge pages
 
-    PageMeta::AsPageTable(*curr_meta).ref_count--;
+    auto *pd  = reinterpret_cast<PageMapTable<2> *>(Mem::PhysToVirt(pdpte.GetNextLevelTable()));
+    auto &pde = (*pd)[PmeIdx<2>(vaddr)];
+    RET_UNEXPECTED_IF(!pde.IsPresent(), MemError::NotFound);
+    RET_UNEXPECTED_IF(pde.IsHuge(), MemError::InvalidArgument);
 
-    // 4. Cleanup loop
-    while (PageMeta::AsPageTable(*curr_meta).ref_count == 0 && curr_level < 4) {
-        auto *parent_meta = PageMeta::AsPageTable(*curr_meta).parent;
-        if (parent_meta == nullptr) {
-            break;
-        }
+    auto *pt  = reinterpret_cast<PageMapTable<1> *>(Mem::PhysToVirt(pde.GetNextLevelTable()));
+    auto &pte = (*pt)[PmeIdx<1>(vaddr)];
+    RET_UNEXPECTED_IF(!pte.IsPresent(), MemError::NotFound);
 
-        // Get parent table physical address from its metadata
-        size_t parent_pfn = MemoryModule::Get().GetPageMetaTable().GetPageFrameNumber(parent_meta);
-        auto *parent_table_virt =
-            reinterpret_cast<u64 *>(Mem::PhysToVirt(PageFrameAddr(parent_pfn)));
-
-        u64 idx = 0;
-        if (curr_level == 1) {
-            idx = PmeIdx<2>(vaddr);
-        } else if (curr_level == 2) {
-            idx = PmeIdx<3>(vaddr);
-        } else if (curr_level == 3) {
-            idx = PmeIdx<4>(vaddr);
-        }
-
-        // Clear entry in parent
-        parent_table_virt[idx] = 0;
-
-        // Free current table page
-        size_t curr_pfn = MemoryModule::Get().GetPageMetaTable().GetPageFrameNumber(curr_meta);
-        Mem::KFree(Mem::PhysToVirt(PageFrameAddr(curr_pfn)));
-
-        // Move up to parent
-        curr_meta = parent_meta;
-        curr_level++;
-        PageMeta::AsPageTable(*curr_meta).ref_count--;
-    }
-
-    MemoryModule::Get().GetTlb().InvalidatePage(vaddr);
+    // Update flags
+    auto paddr = pte.GetFrameAddress();
+    pte.SetFrameAddress(paddr, ToArchFlags(flags));
 
     return {};
 }
 
-expected<PPtr<void>, MemError> Mmu::Translate(VPtr<AddressSpace> as, VPtr<void> vaddr)
-{
-    auto res = WalkToEntry<1>(as, vaddr, false);
-    UNEXPECTED_RET_IF_ERR(res);
-
-    auto *pme_l1 = *res;
-    if (!pme_l1->IsPresent()) {
-        return unexpected(MemError::InvalidArgument);
-    }
-
-    return pme_l1->GetFrameAddress();
-}
-
-expected<void, MemError> Mmu::SetPageFlags(VPtr<AddressSpace> as, VPtr<void> vaddr, PageFlags flags)
-{
-    auto res = WalkToEntry<1>(as, vaddr, false);
-    if (!res) {
-        return unexpected(MemError::NotFound);
-    }
-
-    auto *pme_l1 = *res;
-    if (!pme_l1->IsPresent()) {
-        return unexpected(MemError::NotFound);
-    }
-
-    // Preserve address, update flags
-    auto *paddr = pme_l1->GetFrameAddress();
-
-    // We need to clear the entry before setting it again to avoid ORing flags
-    *reinterpret_cast<u64 *>(pme_l1) = 0;
-
-    pme_l1->SetFrameAddress(paddr, ToArchFlags(flags));
-
-    // Flush TLB for this page immediately to ensure CPU sees new permissions
-    MemoryModule::Get().GetTlb().InvalidatePage(vaddr);
-
-    return {};
-}
-
-void Mmu::ReconstructAddressSpace(Mem::PPtr<void> root_page_table, Mem::PageMetaTable &pmt)
-{
-    ReconstructRecursive<4>(root_page_table, nullptr, pmt);
-}
-
-void Mmu::UnmapLowerHalf(
-    Mem::PPtr<void> root_page_table, Mem::PageMetaTable &pmt, Mem::BitmapPmm &pmm, hal::Tlb &tlb
-)
-{
-    auto *pml4_virt = reinterpret_cast<PageMapTable<4> *>(PhysToVirt(root_page_table));
-
-    constexpr size_t kLowerHalfLimit = 256;
-    for (size_t i = 0; i < kLowerHalfLimit; ++i) {
-        auto &entry = (*pml4_virt)[i];
-        if (entry.IsPresent()) {
-            // Free the table the entry points to
-            PPtr<void> pdpt_phys = reinterpret_cast<PPtr<void>>(entry.GetNextLevelTable());
-            FreeTableRecursive<3>(pdpt_phys, pmt, pmm);
-
-            // Free the entry
-            *reinterpret_cast<u64 *>(&entry) = 0;
-        }
-    }
-
-    // Flush TLB to ensure CPU doesn't retain old mappings
-    tlb.FlushAll();
-}
+}  // namespace arch
diff --git a/kernel/arch/x86_64/src/hal/impl/mmu.hpp b/kernel/arch/x86_64/src/hal/impl/mmu.hpp
index 431343ea..95f15803 100644
--- a/kernel/arch/x86_64/src/hal/impl/mmu.hpp
+++ b/kernel/arch/x86_64/src/hal/impl/mmu.hpp
@@ -1,10 +1,9 @@
 #ifndef KERNEL_ARCH_X86_64_SRC_HAL_IMPL_MMU_HPP_
 #define KERNEL_ARCH_X86_64_SRC_HAL_IMPL_MMU_HPP_
 
+#include <expected.hpp>
 #include <hal/api/mmu.hpp>
-#include <mem/virt/addr_space.hpp>
-#include "cpu/control_registers.hpp"
-#include "mem/page_map.hpp"
+#include <mem/types.hpp>
 
 namespace arch
 {
@@ -15,47 +14,45 @@ using std::unexpected;
 class Mmu : public MmuAPI
 {
     public:
+    template <MmuContext Context>
     expected<void, Mem::MemError> Map(
-        Mem::VPtr<Mem::AddressSpace> as, Mem::VPtr<void> vaddr, Mem::PPtr<void> paddr, PageFlags
+        Context &ctx, Mem::PPtr<void> root, Mem::VPtr<void> vaddr, Mem::PPtr<void> paddr,
+        PageFlags flags
     );
 
-    expected<void, Mem::MemError> UnMap(Mem::VPtr<Mem::AddressSpace> as, Mem::VPtr<void> vaddr);
+    template <MmuContext Context>
+    void Unmap(Context &ctx, Mem::PPtr<void> root, Mem::VPtr<void> vaddr);
 
+    template <MmuContext Context>
     expected<Mem::PPtr<void>, Mem::MemError> Translate(
-        Mem::VPtr<Mem::AddressSpace> as, Mem::VPtr<void> vaddr
+        Context &ctx, Mem::PPtr<void> root, Mem::VPtr<void> vaddr
     );
 
-    void SwitchRootPageMapTable(Mem::PPtr<void> pmt4)
-    {
-        cpu::Cr3 cr3{};
-        cr3.PageMapLevel4Address = Mem::PtrToUptr(pmt4) >> 12;
-        cpu::SetCR(cr3);
-    }
+    expected<void, Mem::MemError> SetPageFlags(
+        Mem::PPtr<void> root, Mem::VPtr<void> vaddr, PageFlags flags
+    );
 
-    void DestroyRootPageMapTable(Mem::PPtr<void> pmt4) { (void)pmt4; }
+    void SwitchRoot(Mem::PPtr<void> root);
 
-    void ReconstructAddressSpace(Mem::PPtr<void> root_page_table, Mem::PageMetaTable &pmt);
+    template <TableVisitor Visitor>
+    void VisitTables(Mem::PPtr<void> root, Visitor visitor);
 
-    void UnmapLowerHalf(
-        Mem::PPtr<void> root_page_table, Mem::PageMetaTable &pmt, Mem::BitmapPmm &pmm, hal::Tlb &tlb
-    );
-
-    expected<void, Mem::MemError> SetPageFlags(
-        Mem::VPtr<Mem::AddressSpace> as, Mem::VPtr<void> vaddr, PageFlags flags
-    );
+    /**
+     * @brief Recursively destroys a page table tree.
+     * Used for cleanup operations (e.g. destroying an address space or cleaning lower half).
+     */
+    template <MmuContext Context>
+    void DestroyTable(Context &ctx, Mem::PPtr<void> table, uint8_t level);
 
     private:
-    template <size_t kLevel>
-    u64 PmeIdx(Mem::VPtr<void> vaddr);
-
     u64 ToArchFlags(PageFlags flags);
 
-    template <size_t kLevel = 0>
-    expected<Mem::VPtr<PageMapEntry<kLevel>>, Mem::MemError> WalkToEntry(
-        Mem::VPtr<Mem::AddressSpace> as, Mem::VPtr<void> vaddr, bool create_if_missing = false
-    );
+    template <size_t kLevel>
+    u64 PmeIdx(Mem::VPtr<void> vaddr);
 };
 
 }  // namespace arch
 
+#include "hal/impl/mmu.tpp"
+
 #endif  // KERNEL_ARCH_X86_64_SRC_HAL_IMPL_MMU_HPP_
diff --git a/kernel/arch/x86_64/src/hal/impl/mmu.tpp b/kernel/arch/x86_64/src/hal/impl/mmu.tpp
new file mode 100644
index 00000000..4018573e
--- /dev/null
+++ b/kernel/arch/x86_64/src/hal/impl/mmu.tpp
@@ -0,0 +1,259 @@
+#ifndef KERNEL_ARCH_X86_64_SRC_HAL_IMPL_MMU_TPP_
+#define KERNEL_ARCH_X86_64_SRC_HAL_IMPL_MMU_TPP_
+
+#include "hal/impl/mmu.hpp"
+#include "macros.hpp"
+#include "mem/page_map.hpp"
+
+#include <string.h>
+
+namespace arch
+{
+
+template <size_t kLevel>
+u64 Mmu::PmeIdx(Mem::VPtr<void> vaddr)
+{
+    static_assert(kLevel > 0);
+    static_assert(kLevel <= 4);
+
+    static constexpr u64 kDefaultOffset     = 12;
+    static constexpr u64 kBitOffsetPerLevel = 9;
+
+    static constexpr u32 kIndexMask = kBitMaskRight<u64, 9>;
+    uptr addr                       = Mem::PtrToUptr(vaddr);
+    return (addr >> (kDefaultOffset + (kLevel - 1) * kBitOffsetPerLevel)) & kIndexMask;
+}
+
+template <MmuContext Context>
+expected<void, Mem::MemError> Mmu::Map(
+    Context &ctx, Mem::PPtr<void> root, Mem::VPtr<void> vaddr, Mem::PPtr<void> paddr,
+    PageFlags flags
+)
+{
+    static constexpr u64 kDefTableFlags = kPresentBit | kWriteBit | kUserAccessibleBit;
+
+    // Level 4
+    auto *pml4  = reinterpret_cast<PageMapTable<4> *>(Mem::PhysToVirt(root));
+    auto &pml4e = (*pml4)[PmeIdx<4>(vaddr)];
+
+    if (!pml4e.IsPresent()) {
+        auto res = ctx.AllocateTable(3);
+        RET_UNEXPECTED_IF_ERR(res);
+        pml4e.SetNextLevelTable(reinterpret_cast<PageMapTable<3> *>(*res), kDefTableFlags);
+        ctx.IncreaseUsage(root);
+    }
+
+    // Level 3
+    auto *pdpt  = reinterpret_cast<PageMapTable<3> *>(Mem::PhysToVirt(pml4e.GetNextLevelTable()));
+    auto &pdpte = (*pdpt)[PmeIdx<3>(vaddr)];
+
+    if (!pdpte.IsPresent()) {
+        auto res = ctx.AllocateTable(2);
+        RET_UNEXPECTED_IF_ERR(res);
+        pdpte.SetNextLevelTable(reinterpret_cast<PageMapTable<2> *>(*res), kDefTableFlags);
+        ctx.IncreaseUsage(reinterpret_cast<Mem::PPtr<void>>(pml4e.GetNextLevelTable()));
+    }
+
+    // Level 2
+    auto *pd  = reinterpret_cast<PageMapTable<2> *>(Mem::PhysToVirt(pdpte.GetNextLevelTable()));
+    auto &pde = (*pd)[PmeIdx<2>(vaddr)];
+
+    if (!pde.IsPresent()) {
+        auto res = ctx.AllocateTable(1);
+        RET_UNEXPECTED_IF_ERR(res);
+        pde.SetNextLevelTable(reinterpret_cast<PageMapTable<1> *>(*res), kDefTableFlags);
+        ctx.IncreaseUsage(reinterpret_cast<Mem::PPtr<void>>(pdpte.GetNextLevelTable()));
+    }
+
+    // Level 1
+    auto *pt  = reinterpret_cast<PageMapTable<1> *>(Mem::PhysToVirt(pde.GetNextLevelTable()));
+    auto &pte = (*pt)[PmeIdx<1>(vaddr)];
+
+    RET_UNEXPECTED_IF(pte.IsPresent(), Mem::MemError::InvalidArgument);
+
+    pte.SetFrameAddress(paddr, ToArchFlags(flags));
+    ctx.IncreaseUsage(reinterpret_cast<Mem::PPtr<void>>(pde.GetNextLevelTable()));
+
+    return {};
+}
+
+template <MmuContext Context>
+void Mmu::Unmap(Context &ctx, Mem::PPtr<void> root, Mem::VPtr<void> vaddr)
+{
+    // Track path for cleanup
+    struct PathEntry {
+        Mem::PPtr<void> table_phys;
+        u64 index;
+    };
+    PathEntry path[4];  // Indices: 0=PML4, 1=PDPT, 2=PD, 3=PT
+
+    // Walk down
+    auto *pml4  = reinterpret_cast<PageMapTable<4> *>(Mem::PhysToVirt(root));
+    path[0]     = {root, PmeIdx<4>(vaddr)};
+    auto &pml4e = (*pml4)[path[0].index];
+    if (!pml4e.IsPresent())
+        return;
+
+    path[1]     = {reinterpret_cast<Mem::PPtr<void>>(pml4e.GetNextLevelTable()), PmeIdx<3>(vaddr)};
+    auto *pdpt  = reinterpret_cast<PageMapTable<3> *>(Mem::PhysToVirt(path[1].table_phys));
+    auto &pdpte = (*pdpt)[path[1].index];
+    if (!pdpte.IsPresent())
+        return;
+
+    path[2]   = {reinterpret_cast<Mem::PPtr<void>>(pdpte.GetNextLevelTable()), PmeIdx<2>(vaddr)};
+    auto *pd  = reinterpret_cast<PageMapTable<2> *>(Mem::PhysToVirt(path[2].table_phys));
+    auto &pde = (*pd)[path[2].index];
+    if (!pde.IsPresent())
+        return;
+
+    path[3]   = {reinterpret_cast<Mem::PPtr<void>>(pde.GetNextLevelTable()), PmeIdx<1>(vaddr)};
+    auto *pt  = reinterpret_cast<PageMapTable<1> *>(Mem::PhysToVirt(path[3].table_phys));
+    auto &pte = (*pt)[path[3].index];
+    if (!pte.IsPresent())
+        return;
+
+    // Clear leaf
+    pte.Clear();
+
+    // Bubble up cleanup
+    // Start checking from the leaf table (level 1, path[3]) up to PDPT (level 3, path[1])
+    // If a table becomes empty, remove it from its parent.
+
+    // Check PT (Level 1)
+    if (ctx.DecreaseUsage(path[3].table_phys)) {
+        // PT is empty, free it and remove from PD
+        ctx.FreeTable(path[3].table_phys, 1);
+
+        auto *parent_pd  = reinterpret_cast<PageMapTable<2> *>(Mem::PhysToVirt(path[2].table_phys));
+        auto &parent_pde = (*parent_pd)[path[2].index];
+        parent_pde.Clear();  // Clear PD entry
+
+        // Check PD (Level 2)
+        if (ctx.DecreaseUsage(path[2].table_phys)) {
+            // PD is empty, free it and remove from PDPT
+            ctx.FreeTable(path[2].table_phys, 2);
+
+            auto *parent_pdpt =
+                reinterpret_cast<PageMapTable<3> *>(Mem::PhysToVirt(path[1].table_phys));
+            auto &parent_pdpte = (*parent_pdpt)[path[1].index];
+            parent_pdpte.Clear();
+
+            // Check PDPT (Level 3)
+            if (ctx.DecreaseUsage(path[1].table_phys)) {
+                // PDPT is empty, free it and remove from PML4
+                ctx.FreeTable(path[1].table_phys, 3);
+
+                auto *parent_pml4 =
+                    reinterpret_cast<PageMapTable<4> *>(Mem::PhysToVirt(path[0].table_phys));
+                auto &parent_pml4e = (*parent_pml4)[path[0].index];
+                parent_pml4e.Clear();
+
+                // Decrease usage of PML4
+                ctx.DecreaseUsage(path[0].table_phys);
+            }
+        }
+    } else {
+        // Leaf table not empty, nothing more to do
+    }
+}
+
+template <MmuContext Context>
+expected<Mem::PPtr<void>, Mem::MemError> Mmu::Translate(
+    Context &, Mem::PPtr<void> root, Mem::VPtr<void> vaddr
+)
+{
+    auto *pml4  = reinterpret_cast<PageMapTable<4> *>(Mem::PhysToVirt(root));
+    auto &pml4e = (*pml4)[PmeIdx<4>(vaddr)];
+    RET_UNEXPECTED_IF(!pml4e.IsPresent(), Mem::MemError::NotFound);
+
+    auto *pdpt  = reinterpret_cast<PageMapTable<3> *>(Mem::PhysToVirt(pml4e.GetNextLevelTable()));
+    auto &pdpte = (*pdpt)[PmeIdx<3>(vaddr)];
+    RET_UNEXPECTED_IF(!pdpte.IsPresent(), Mem::MemError::NotFound);
+    if (pdpte.IsHuge())
+        return reinterpret_cast<const PageMapEntry<3, kHugePage> &>(pdpte).GetFrameAddress() +
+               (Mem::PtrToUptr(vaddr) & kBitMaskRight<u64, 30>);
+
+    auto *pd  = reinterpret_cast<PageMapTable<2> *>(Mem::PhysToVirt(pdpte.GetNextLevelTable()));
+    auto &pde = (*pd)[PmeIdx<2>(vaddr)];
+    RET_UNEXPECTED_IF(!pde.IsPresent(), Mem::MemError::NotFound);
+    if (pde.IsHuge())
+        return reinterpret_cast<const PageMapEntry<2, kHugePage> &>(pde).GetFrameAddress() +
+               (Mem::PtrToUptr(vaddr) & kBitMaskRight<u64, 21>);
+
+    auto *pt  = reinterpret_cast<PageMapTable<1> *>(Mem::PhysToVirt(pde.GetNextLevelTable()));
+    auto &pte = (*pt)[PmeIdx<1>(vaddr)];
+    RET_UNEXPECTED_IF(!pte.IsPresent(), Mem::MemError::NotFound);
+
+    return pte.GetFrameAddress() + (Mem::PtrToUptr(vaddr) & kBitMaskRight<u64, 12>);
+}
+
+template <TableVisitor Visitor>
+void Mmu::VisitTables(Mem::PPtr<void> root, Visitor visitor)
+{
+    // Visitor signature: void(Mem::PPtr<void> table, uint8_t level)
+
+    // We traverse recursively
+    auto RecVisit = [&]<size_t Level>(this auto &&self, Mem::PPtr<void> table_phys) -> void {
+        visitor(table_phys, Level);
+
+        if constexpr (Level > 1) {
+            auto *table = reinterpret_cast<PageMapTable<Level> *>(Mem::PhysToVirt(table_phys));
+            for (const auto &entry : *table) {
+                if (entry.IsPresent() && !entry.IsHuge()) {
+                    self.template operator()<Level - 1>(
+                        reinterpret_cast<Mem::PPtr<void>>(entry.GetNextLevelTable())
+                    );
+                }
+            }
+        }
+    };
+
+    RecVisit.template operator()<4>(root);
+}
+
+template <MmuContext Context>
+void Mmu::DestroyTable(Context &ctx, Mem::PPtr<void> table_phys, u8 level)
+{
+    // Recursive destruction
+
+    auto RecDestroy = [&]<size_t Level>(this auto &&self, Mem::PPtr<void> curr_table) -> void {
+        auto *table = reinterpret_cast<PageMapTable<Level> *>(Mem::PhysToVirt(curr_table));
+
+        if constexpr (Level > 1) {
+            for (auto &entry : *table) {
+                if (entry.IsPresent() && !entry.IsHuge()) {
+                    self.template operator()<Level - 1>(
+                        reinterpret_cast<Mem::PPtr<void>>(entry.GetNextLevelTable())
+                    );
+                }
+                entry.Clear();
+            }
+        } else {
+            // Level 1: Just clear entries
+            for (auto &entry : *table) {
+                entry.Clear();
+            }
+        }
+
+        ctx.FreeTable(curr_table, Level);
+    };
+
+    switch (level) {
+        case 4:
+            RecDestroy.template operator()<4>(table_phys);
+            break;
+        case 3:
+            RecDestroy.template operator()<3>(table_phys);
+            break;
+        case 2:
+            RecDestroy.template operator()<2>(table_phys);
+            break;
+        case 1:
+            RecDestroy.template operator()<1>(table_phys);
+            break;
+    }
+}
+
+}  // namespace arch
+
+#endif  // KERNEL_ARCH_X86_64_SRC_HAL_IMPL_MMU_TPP_
diff --git a/kernel/arch/x86_64/src/interrupts/idt.nasm b/kernel/arch/x86_64/src/interrupts/idt.nasm
index d929b564..f77b9db3 100644
--- a/kernel/arch/x86_64/src/interrupts/idt.nasm
+++ b/kernel/arch/x86_64/src/interrupts/idt.nasm
@@ -38,7 +38,7 @@ isr_wrapper_%+%1:
     add rsp, _shadow_space      ; Deallocate shadow space.
     pop_all_regs                    ; Restore registers.
     add rsp, _all_reg_size          ; Deallocate register save space.
-    add rsp, 8                      ; Pop error code.
+    add rsp, 8                  ; Pop error code.
     iretq
 %endmacro
 
diff --git a/kernel/arch/x86_64/src/mem/page_map.hpp b/kernel/arch/x86_64/src/mem/page_map.hpp
index 1cedf95b..f0988206 100644
--- a/kernel/arch/x86_64/src/mem/page_map.hpp
+++ b/kernel/arch/x86_64/src/mem/page_map.hpp
@@ -91,10 +91,10 @@ struct PageMapEntry<4> {
 
     // Accessors
 
-    NODISCARD bool IsPresent() const { return present; }
-
     NODISCARD bool IsHuge() const { return false; }
 
+    NODISCARD bool IsPresent() const { return present; }
+
     NODISCARD Mem::PPtr<PageMapTable<3>> GetNextLevelTable() const
     {
         return Mem::UptrToPtr<PageMapTable<3>>(static_cast<u64>(frame) << 12);
@@ -105,6 +105,8 @@ struct PageMapEntry<4> {
         frame = Mem::PtrToUptr(table_addr) >> 12;
         *reinterpret_cast<u64 *>(this) |= flags;
     }
+
+    FORCE_INLINE_F void Clear() { *reinterpret_cast<u64 *>(this) = 0; }
 } PACK;
 
 //------------------------------------------------------------------------------
@@ -131,10 +133,10 @@ struct PageMapEntry<3> {
 
     // Accessors
 
-    NODISCARD bool IsPresent() const { return present; }
-
     NODISCARD bool IsHuge() const { return page_size; }
 
+    NODISCARD bool IsPresent() const { return present; }
+
     NODISCARD Mem::PPtr<PageMapTable<2>> GetNextLevelTable() const
     {
         return Mem::UptrToPtr<PageMapTable<2>>(static_cast<u64>(frame) << 12);
@@ -145,6 +147,8 @@ struct PageMapEntry<3> {
         frame = Mem::PtrToUptr(table_addr) >> 12;
         *reinterpret_cast<u64 *>(this) |= flags;
     }
+
+    FORCE_INLINE_F void Clear() { *reinterpret_cast<u64 *>(this) = 0; }
 } PACK;
 
 // Table 5-16. Format of a Page-Directory-Pointer-Table Entry (PDPTE) that Maps a 1-GByte Page
@@ -170,9 +174,9 @@ struct PageMapEntry<3, kHugePage> {
 
     // Accessors
 
-    NODISCARD bool IsPresent() const { return present; }
+    NODISCARD bool IsHuge() const { return page_size; }
 
-    NODISCARD bool IsHuge() const { return true; }
+    NODISCARD bool IsPresent() const { return present; }
 
     NODISCARD Mem::PPtr<void> GetFrameAddress() const
     {
@@ -185,6 +189,8 @@ struct PageMapEntry<3, kHugePage> {
         frame                          = Mem::PtrToUptr(page_addr) >> 30;
         *reinterpret_cast<u64 *>(this) |= flags | kHugePageBit;
     }
+
+    FORCE_INLINE_F void Clear() { *reinterpret_cast<u64 *>(this) = 0; }
 } PACK;
 
 //------------------------------------------------------------------------------
@@ -210,10 +216,10 @@ struct PageMapEntry<2> {
 
     // Accessors
 
-    NODISCARD bool IsPresent() const { return present; }
-
     NODISCARD bool IsHuge() const { return page_size; }
 
+    NODISCARD bool IsPresent() const { return present; }
+
     NODISCARD Mem::PPtr<PageMapTable<1>> GetNextLevelTable() const
     {
         return Mem::UptrToPtr<PageMapTable<1>>(static_cast<u64>(frame) << 12);
@@ -224,6 +230,8 @@ struct PageMapEntry<2> {
         frame = Mem::PtrToUptr(table_addr) >> 12;
         *reinterpret_cast<u64 *>(this) |= flags;
     }
+
+    FORCE_INLINE_F void Clear() { *reinterpret_cast<u64 *>(this) = 0; }
 } PACK;
 
 // Table 5-18. Format of a Page-Directory Entry (PDE) that Maps a 2-MByte Page
@@ -249,9 +257,9 @@ struct PageMapEntry<2, kHugePage> {
 
     // Accessors
 
-    NODISCARD bool IsPresent() const { return present; }
+    NODISCARD bool IsHuge() const { return page_size; }
 
-    NODISCARD bool IsHuge() const { return true; }
+    NODISCARD bool IsPresent() const { return present; }
 
     NODISCARD Mem::PPtr<void> GetFrameAddress() const
     {
@@ -264,6 +272,8 @@ struct PageMapEntry<2, kHugePage> {
         frame                          = Mem::PtrToUptr(page_addr) >> 21;
         *reinterpret_cast<u64 *>(this) |= flags | kHugePageBit;
     }
+
+    FORCE_INLINE_F void Clear() { *reinterpret_cast<u64 *>(this) = 0; }
 } PACK;
 
 //------------------------------------------------------------------------------
@@ -291,10 +301,10 @@ struct PageMapEntry<1> {
 
     // Accessors
 
-    NODISCARD bool IsPresent() const { return present; }
-
     NODISCARD bool IsHuge() const { return false; }
 
+    NODISCARD bool IsPresent() const { return present; }
+
     NODISCARD Mem::PPtr<void> GetFrameAddress() const
     {
         return Mem::UptrToPtr<void>(static_cast<u64>(frame) << 12);
@@ -306,6 +316,8 @@ struct PageMapEntry<1> {
         frame                          = Mem::PtrToUptr(page_addr) >> 12;
         *reinterpret_cast<u64 *>(this) |= flags;
     }
+
+    FORCE_INLINE_F void Clear() { *reinterpret_cast<u64 *>(this) = 0; }
 } PACK;
 
 //==============================================================================
diff --git a/kernel/src/hal/api/mmu.hpp b/kernel/src/hal/api/mmu.hpp
index df422383..11508c92 100644
--- a/kernel/src/hal/api/mmu.hpp
+++ b/kernel/src/hal/api/mmu.hpp
@@ -1,24 +1,12 @@
 #ifndef KERNEL_SRC_HAL_API_MMU_HPP_
 #define KERNEL_SRC_HAL_API_MMU_HPP_
 
+#include <concepts.hpp>
 #include <expected.hpp>
+
 #include "mem/error.hpp"
 #include "mem/types.hpp"
 
-namespace Mem
-{
-
-class AddressSpace;
-class PageMetaTable;
-class BitmapPmm;
-
-}  // namespace Mem
-
-namespace hal
-{
-class Tlb;
-}
-
 namespace arch
 {
 
@@ -38,94 +26,106 @@ struct PageFlags {
     bool NoExecute : 1;
 };
 
-struct MmuAPI {
+/**
+ * @brief Concept defining the context required by the MMU for memory operations.
+ *
+ * This context abstracts the management of page table pages (allocation/freeing)
+ * and the tracking of their usage (reference counting). This allows the
+ * architecture-specific MMU code to be decoupled from the kernel's memory
+ * management implementation.
+ */
+template <typename T>
+concept MmuContext = requires(T ctx, u8 level, Mem::PPtr<void> table) {
     /**
-     * @brief Maps a physical page to a virtual address in a given address space.
-     * This function is responsible for walking the page tables and creating entries
-     * as needed.
-     * @param as The target address space.
-     * @param vaddr The virtual address to map. Must be page-aligned.
-     * @param paddr The physical address to map to. Must be page-aligned.
-     * @param flags Page protection and control flags.
-     * @return Success or a memory error.
+     * @brief Allocates a zeroed physical page for a translation table at the specified level.
+     * @param level The level of the table being allocated (e.g., 3 for PDPT in x86_64).
+     * @return Physical pointer to the allocated page, or error.
      */
-    expected<void, Mem::MemError> Map(
-        Mem::VPtr<Mem::AddressSpace> as, Mem::VPtr<void> vaddr, Mem::PPtr<void> paddr, PageFlags
-    );
+    { ctx.AllocateTable(level) } -> std::same_as<expected<Mem::PPtr<void>, Mem::MemError>>;
 
     /**
-     * @brief Unmaps a virtual address, invalidating its page table entry.
-     * should also free the pme entries and tables if adequate
-     *
-     * @param as The target address space.
-     * @param vaddr The virtual address to unmap.
-     * @return Success or a memory error if the page is not mapped.
+     * @brief Frees a translation table page.
+     * @param table Physical pointer to the table to free.
+     * @param level The level of the table.
      */
-    expected<void, Mem::MemError> UnMap(Mem::VPtr<Mem::AddressSpace> as, Mem::VPtr<void> vaddr);
+    { ctx.FreeTable(table, level) } -> std::same_as<void>;
 
     /**
-     * @brief Translates a virtual address to its corresponding physical address.
-     * @param as The address space to perform the translation in.
-     * @param vaddr The virtual address to translate.
-     * @return The physical address, or a memory error if the address is not mapped.
+     * @brief Called when a new entry is inserted into a table (increasing its usage).
+     * @param table Physical pointer to the table.
      */
-    expected<Mem::PPtr<void>, Mem::MemError> Translate(
-        Mem::VPtr<Mem::AddressSpace> as, Mem::VPtr<void> vaddr
-    );
+    { ctx.IncreaseUsage(table) } -> std::same_as<void>;
 
     /**
-     * @brief Switches the current root page table
+     * @brief Called when an entry is removed from a table (decreasing its usage).
+     * @param table Physical pointer to the table.
+     * @return true if the table is now empty and should be freed/removed from its parent.
      */
-    void SwitchRootPageMapTable(Mem::PPtr<void> root_page_table);
+    { ctx.DecreaseUsage(table) } -> std::same_as<bool>;
+};
+
+/**
+ * @brief Concept for a visitor function used to traverse page tables.
+ */
+template <typename Func>
+concept TableVisitor = requires(Func f, Mem::PPtr<void> table, u8 level) {
+    { f(table, level) } -> std::same_as<void>;
+};
 
+struct MmuAPI {
     /**
-     * @brief Destroys and free's the current root page table entries,
-     * subentries, subsubentries etc
+     * @brief Maps a physical page to a virtual address in the specified page table hierarchy.
      *
+     * @param ctx The MMU context for managing table allocations and metadata.
+     * @param root The physical address of the root page table (e.g., PML4).
+     * @param vaddr The virtual address to map. Must be page-aligned.
+     * @param paddr The physical address to map to. Must be page-aligned.
+     * @param flags Page protection and control flags.
      */
-    void CleanRootPageMapTable(Mem::PPtr<void> root_page_table);
+    template <MmuContext Context>
+    expected<void, Mem::MemError> Map(
+        Context &ctx, Mem::PPtr<void> root, Mem::VPtr<void> vaddr, Mem::PPtr<void> paddr,
+        PageFlags flags
+    );
 
     /**
-     * @brief Reconstructs the PageMeta metadata for an existing page table hierarchy.
-     *
-     * This is used during kernel initialization to synchronize the software metadata
-     * (PageMeta) with the hardware page tables set up by the bootloader. It recursively
-     * walks the tables, initializing PageMeta types and reference counts.
+     * @brief Unmaps a virtual address from the specified page table hierarchy.
      *
-     * @param root_page_table Physical pointer to the top-level page table.
-     * @param pmt Reference to the PageMetaTable instance.
+     * @param ctx The MMU context for managing table freeing and metadata.
+     * @param root The physical address of the root page table.
+     * @param vaddr The virtual address to unmap.
      */
-    void ReconstructAddressSpace(Mem::PPtr<void> root_page_table, Mem::PageMetaTable &pmt);
+    template <MmuContext Context>
+    void Unmap(Context &ctx, Mem::PPtr<void> root, Mem::VPtr<void> vaddr);
 
     /**
-     * @brief Unmaps the lower half of the address space (entries 0-255 of PML4).
-     *
-     * This removes the identity mapping established by the bootloader.
-     * It recursively frees the page tables used for this mapping but does NOT
-     * free the underlying physical frames (leaf nodes) mapped by them.
-     *
-     * @note THIS IS TO BE USED DIRECTLY AFTER RECONSTRUCTING BITMAP PMM, BEFORE BUDDY PMM
-     * IS INITIALIZED
-     *
-     * @param root_page_table Physical pointer to the top-level page table.
-     * @param pmt Reference to the PageMetaTable instance.
-     * @param pmm Reference to the BitmapPmm instance (for freeing tables).
-     * @param tlb Reference to the TLB instance (for flushing).
+     * @brief Updates flags for an existing mapping.
      */
-    void UnmapLowerHalf(
-        Mem::PPtr<void> root_page_table, Mem::PageMetaTable &pmt, Mem::BitmapPmm &pmm, hal::Tlb &tlb
+    expected<void, Mem::MemError> SetPageFlags(
+        Mem::PPtr<void> root, Mem::VPtr<void> vaddr, PageFlags flags
     );
 
     /**
-     * @brief Updates the flags of an existing mapping.
-     * @param as The address space.
-     * @param vaddr The virtual address.
-     * @param flags The new flags.
-     * @return Success, or NotFound if page is not mapped.
+     * @brief Translates a virtual address to physical using the specified root.
+     * @param ctx The MMU context (unused for simple translation but kept for API consistency if
+     * needed).
      */
-    expected<void, Mem::MemError> SetPageFlags(
-        Mem::VPtr<Mem::AddressSpace> as, Mem::VPtr<void> vaddr, PageFlags flags
+    template <MmuContext Context>
+    expected<Mem::PPtr<void>, Mem::MemError> Translate(
+        Context &ctx, Mem::PPtr<void> root, Mem::VPtr<void> vaddr
     );
+
+    /**
+     * @brief Switches the active page table root (e.g., loads CR3).
+     */
+    void SwitchRoot(Mem::PPtr<void> root);
+
+    /**
+     * @brief Walks the page table hierarchy and calls the visitor for each present table.
+     * Useful for reconstructing metadata or debugging.
+     */
+    template <TableVisitor Visitor>
+    void VisitTables(Mem::PPtr<void> root, Visitor visitor);
 };
 
 }  // namespace arch
diff --git a/kernel/src/hal/mmu.hpp b/kernel/src/hal/mmu.hpp
index e56b8de0..c82eb087 100644
--- a/kernel/src/hal/mmu.hpp
+++ b/kernel/src/hal/mmu.hpp
@@ -4,27 +4,108 @@
 #include <hal/impl/mmu.hpp>
 #include <macros.hpp>
 
-#include <bits_ext.hpp>
 #include "hal/constants.hpp"
+#include "hal/tlb.hpp"
+#include "mem/page_meta_table.hpp"
+#include "mem/phys/mngr/bitmap.hpp"
+#include "mem/phys/mngr/buddy.hpp"
 
 namespace hal
 {
 
+using arch::MmuContext;
+
 using std::expected;
 using std::unexpected;
 
 using PageFlags = arch::PageFlags;
 
+/**
+ * @brief Default MMU Context using the full kernel memory subsystem.
+ */
+struct KernelMmuContext {
+    Mem::BuddyPmm &pmm;
+    Mem::PageMetaTable &pmt;
+
+    expected<Mem::PPtr<void>, Mem::MemError> AllocateTable(uint8_t level)
+    {
+        auto res = pmm.Alloc({.order = 0});
+        if (!res)
+            return unexpected(res.error());
+        auto ptr = *res;
+        memset(Mem::PhysToVirt(ptr), 0, hal::kPageSizeBytes);
+
+        auto &meta = pmt.GetPageMeta(ptr);
+        // Parent tracking is not strictly enforced by this context during alloc,
+        // but we init the metadata type.
+        meta.InitPageTable(level);
+        return reinterpret_cast<Mem::PPtr<void>>(ptr);
+    }
+
+    void FreeTable(Mem::PPtr<void> table, uint8_t level)
+    {
+        (void)level;
+        auto &meta = pmt.GetPageMeta(table);
+        meta.InitAllocated(0);  // Reset type to generic allocated before freeing
+        pmm.Free(reinterpret_cast<Mem::PPtr<Mem::Page>>(table));
+    }
+
+    void IncreaseUsage(Mem::PPtr<void> table)
+    {
+        auto &meta = pmt.GetPageMeta(table);
+        Mem::PageMeta::AsPageTable(meta).ref_count++;
+    }
+
+    bool DecreaseUsage(Mem::PPtr<void> table)
+    {
+        auto &meta = pmt.GetPageMeta(table);
+        auto &pt   = Mem::PageMeta::AsPageTable(meta);
+        if (pt.ref_count > 0)
+            pt.ref_count--;
+        return pt.ref_count == 0;
+    }
+};
+
+/**
+ * @brief Boot MMU Context using BitmapPmm (before Buddy is ready).
+ * Used for cleaning up bootloader tables.
+ */
+struct BootstrapMmuContext {
+    Mem::BitmapPmm &pmm;
+    Mem::PageMetaTable &pmt;
+
+    expected<Mem::PPtr<void>, Mem::MemError> AllocateTable(uint8_t)
+    {
+        // Not implemented/Needed for cleanup
+        return unexpected(Mem::MemError::OutOfMemory);
+    }
+
+    void FreeTable(Mem::PPtr<void> table, uint8_t level)
+    {
+        (void)level;
+        auto &meta = pmt.GetPageMeta(table);
+        meta.InitAllocated(0);
+        pmm.Free(reinterpret_cast<Mem::PPtr<Mem::Page>>(table));
+    }
+
+    void IncreaseUsage(Mem::PPtr<void>) {}
+    bool DecreaseUsage(Mem::PPtr<void>)
+    {
+        return true;
+    }  // Always assume empty/freeable during force cleanup
+};
+
 class Mmu : public arch::Mmu
 {
-    using arch::Mmu::Mmu;
+    Tlb *tlb_;
 
     public:
-    /// Maps a range of virtual memory to physical memory
+    void Init(Tlb &tlb) { tlb_ = &tlb; }
+
     /// The range is treated as half-open: [start, start + size)
     expected<void, Mem::MemError> MapRange(
-        Mem::VPtr<Mem::AddressSpace> as, Mem::VPtr<void> vaddr_start, Mem::PPtr<void> paddr_start,
-        size_t size, PageFlags flags
+        KernelMmuContext &ctx, Mem::PPtr<void> root, Mem::VPtr<void> vaddr_start,
+        Mem::PPtr<void> paddr_start, size_t size, PageFlags flags
     )
     {
         using namespace Mem;
@@ -34,17 +115,31 @@ class Mmu : public arch::Mmu
         auto end   = AlignUp(PtrToUptr(vaddr_start) + size, kPageSizeBytes);
 
         for (auto v = vaddr, p = paddr; v < end; v += kPageSizeBytes, p += kPageSizeBytes) {
-            auto map_res = Map(as, UptrToPtr<void>(v), UptrToPtr<void>(p), flags);
-            UNEXPECTED_RET_IF_ERR(map_res);
+            auto map_res = Map(ctx, root, UptrToPtr<void>(v), UptrToPtr<void>(p), flags);
+            RET_UNEXPECTED_IF_ERR(map_res);
         }
         return {};
     }
 
-    /// Unmaps a range of virtual memory
-    /// The range is treated as half-open: [start, start + size)
-    expected<void, Mem::MemError> UnMapRange(
-        Mem::VPtr<Mem::AddressSpace> as, Mem::VPtr<void> start, size_t size
+    template <MmuContext Context>
+    void Unmap(Context &ctx, Mem::PPtr<void> root, Mem::VPtr<void> vaddr)
+    {
+        arch::Mmu::Unmap(ctx, root, vaddr);
+        tlb_->InvalidatePage(vaddr);
+    }
+
+    expected<void, Mem::MemError> SetPageFlags(
+        Mem::PPtr<void> root, Mem::VPtr<void> vaddr, PageFlags flags
     )
+    {
+        auto res = arch::Mmu::SetPageFlags(root, vaddr, flags);
+        if (res)
+            tlb_->InvalidatePage(vaddr);
+        return {};
+    }
+
+    /// The range is treated as half-open: [start, start + size)
+    void UnmapRange(KernelMmuContext &ctx, Mem::PPtr<void> root, Mem::VPtr<void> start, size_t size)
     {
         using namespace Mem;
 
@@ -52,10 +147,74 @@ class Mmu : public arch::Mmu
         auto e = AlignUp(PtrToUptr(start) + size, kPageSizeBytes);
 
         for (auto addr = s; addr < e; addr += kPageSizeBytes) {
-            auto unmap_res = UnMap(as, UptrToPtr<void>(addr));
-            // Continue even if unmap fails (page might not have been mapped yet)
+            arch::Mmu::Unmap(ctx, root, UptrToPtr<void>(addr));
         }
-        return {};
+
+        tlb_->InvalidateRange(start, size);
+    }
+
+    /// Reconstructs metadata for an existing page table tree
+    void ReconstructAddressSpace(Mem::PPtr<void> root, Mem::PageMetaTable &pmt)
+    {
+        // Counts refs for a table by inspecting its entries
+        // Note: this assumes we are iterating a valid tree
+        // The Visitor in arch::Mmu doesn't provide entry counts, so we do it manually or
+        // rely on the fact that we can just set type for now.
+        // To strictly restore ref_counts, we need to count bits.
+
+        VisitTables(root, [&](Mem::PPtr<void> table, uint8_t level) {
+            auto &meta = pmt.GetPageMeta(table);
+            meta.InitPageTable(level);
+
+            // Count entries for ref_count
+            if (level > 1) {
+                u16 count = 0;
+                // Hack: we cast to generic array to count present bits
+                // This assumes standard x86 layout which HAL technically shouldn't know,
+                // but Mmu inherits from arch::Mmu so it can access Arch defs if included.
+                // We can't access PageMapTable<L> easily here without template.
+                // Let's rely on a simplified assumption or add a helper in Arch.
+                // For now, we set ref_count to 1 to prevent accidental freeing
+                // until we implement proper counting or let the system run.
+                // Ideally, we would iterate the table.
+                auto *virt = reinterpret_cast<u64 *>(Mem::PhysToVirt(table));
+                for (int i = 0; i < 512; ++i) {
+                    if (virt[i] & 1)
+                        count++;
+                }
+                Mem::PageMeta::AsPageTable(meta).ref_count = count;
+            } else {
+                // Level 1 (PT)
+                u16 count  = 0;
+                auto *virt = reinterpret_cast<u64 *>(Mem::PhysToVirt(table));
+                for (int i = 0; i < 512; ++i) {
+                    if (virt[i] & 1)
+                        count++;
+                }
+                Mem::PageMeta::AsPageTable(meta).ref_count = count;
+            }
+        });
+    }
+
+    void UnmapLowerHalf(Mem::PPtr<void> root, Mem::PageMetaTable &pmt, Mem::BitmapPmm &pmm)
+    {
+        BootstrapMmuContext ctx{pmm, pmt};
+
+        // Manual iteration of PML4 lower half
+        auto *pml4                         = reinterpret_cast<u64 *>(Mem::PhysToVirt(root));
+        constexpr size_t kLowerHalfEntries = 256;
+
+        for (size_t i = 0; i < kLowerHalfEntries; ++i) {
+            if (pml4[i] & 1) {  // Present
+                Mem::PPtr<void> child =
+                    reinterpret_cast<Mem::PPtr<void>>(pml4[i] & 0x000FFFFFFFFFF000);  // Mask flags
+                DestroyTable(ctx, child, 3);  // Child is Level 3 (PDPT)
+                pml4[i] = 0;
+            }
+        }
+
+        // TLB flush should be handled by caller or here
+        SwitchRoot(root);  // Reload CR3 flushes TLB
     }
 };
 
diff --git a/kernel/src/io/pipe.hpp b/kernel/src/io/pipe.hpp
index fc2464b2..b573aa40 100644
--- a/kernel/src/io/pipe.hpp
+++ b/kernel/src/io/pipe.hpp
@@ -5,6 +5,7 @@
 #include <hal/spinlock.hpp>
 
 #include "io/stream.hpp"
+#include "macros.hpp"
 
 namespace IO
 {
@@ -25,9 +26,7 @@ class Pipe : public IStream
     {
         size_t bytes_written = buffer_.Write(buffer);
 
-        if (bytes_written == 0 && buffer.size() > 0) {
-            return std::unexpected(Error::Retry);
-        }
+        RET_UNEXPECTED_IF(bytes_written == 0 && buffer.size() > 0, Error::Retry);
         return bytes_written;
     }
 
@@ -35,9 +34,7 @@ class Pipe : public IStream
     {
         size_t bytes_read = buffer_.Read(buffer);
 
-        if (bytes_read == 0 && buffer.size() > 0) {
-            return std::unexpected(Error::Retry);
-        }
+        RET_UNEXPECTED_IF(bytes_read == 0 && buffer.size() > 0, Error::Retry);
         return bytes_read;
     }
 
diff --git a/kernel/src/io/stream.hpp b/kernel/src/io/stream.hpp
index 7e92c138..9ab2bded 100644
--- a/kernel/src/io/stream.hpp
+++ b/kernel/src/io/stream.hpp
@@ -4,6 +4,8 @@
 #include <expected.hpp>
 #include <span.hpp>
 
+#include "macros.hpp"
+
 #include "io/error.hpp"
 #include "mem/types.hpp"
 
@@ -33,12 +35,8 @@ class IReader
     {
         byte c;
         auto res = Read(std::span<byte>(&c, 1));
-        if (!res) {
-            return std::unexpected(res.error());
-        }
-        if (*res == 0) {
-            return unexpected(Error::Retry);
-        }
+        RET_UNEXPECTED_IF_ERR(res);
+        RET_UNEXPECTED_IF(*res == 0, Error::Retry);
         return static_cast<char>(c);
     }
 };
diff --git a/kernel/src/macros.hpp b/kernel/src/macros.hpp
index f9a7db29..a7e7a60c 100644
--- a/kernel/src/macros.hpp
+++ b/kernel/src/macros.hpp
@@ -3,8 +3,12 @@
 
 #include <expected.hpp>
 
-#define UNEXPECTED_RET_IF_ERR(res) \
+#define RET_UNEXPECTED_IF_ERR(res) \
     if (!res)                      \
     return std::unexpected(res.error())
 
+#define RET_UNEXPECTED_IF(cond, err) \
+    if (cond)                        \
+    return std::unexpected(err)
+
 #endif  // KERNEL_SRC_MACROS_HPP_
diff --git a/kernel/src/mem/allocators.hpp b/kernel/src/mem/allocators.hpp
index d71ccbcc..ffa1d4ef 100644
--- a/kernel/src/mem/allocators.hpp
+++ b/kernel/src/mem/allocators.hpp
@@ -91,7 +91,7 @@ class DynArray
             KFreeAligned(mem_);
         }
         auto alloc = KMallocAligned({.size = size * sizeof(T), .alignment = kAlign});
-        UNEXPECTED_RET_IF_ERR(alloc);
+        RET_UNEXPECTED_IF_ERR(alloc);
 
         mem_  = static_cast<T *>(alloc.value());
         size_ = size;
diff --git a/kernel/src/mem/heap.cpp b/kernel/src/mem/heap.cpp
index 9e327418..1d85e120 100644
--- a/kernel/src/mem/heap.cpp
+++ b/kernel/src/mem/heap.cpp
@@ -29,9 +29,7 @@ void Heap::Init(PageMetaTable &pmt, BuddyPmm &pmm, SlabAllocator &slab)
 
 expected<VPtr<void>, MemError> Heap::Malloc(size_t size)
 {
-    if (size == 0) {
-        return unexpected(MemError::InvalidArgument);
-    }
+    RET_UNEXPECTED_IF(size == 0, MemError::InvalidArgument);
 
     // Small Allocations -> Slab Allocator
     if (size < hal::kPageSizeBytes) {
@@ -42,13 +40,13 @@ expected<VPtr<void>, MemError> Heap::Malloc(size_t size)
         }
 
         auto res = cache->Alloc();
-        UNEXPECTED_RET_IF_ERR(res);
+        RET_UNEXPECTED_IF_ERR(res);
         return *res;
     }
 
     // Large Allocations -> Buddy Allocator
     auto res = pmm_->Alloc({.order = BuddyPmm::SizeToPageOrder(size)});
-    UNEXPECTED_RET_IF_ERR(res);
+    RET_UNEXPECTED_IF_ERR(res);
 
     return PhysToVirt(*res);
 }
@@ -83,15 +81,14 @@ expected<VPtr<void>, MemError> Heap::MallocAligned(KMallocRequest r)
     size_t size      = r.size;
 
     // Sanity checks
-    if (alignment == 0 || (alignment & (alignment - 1)) != 0) {
-        // Alignment must be power of 2
-        return unexpected(MemError::InvalidArgument);
-    }
+    RET_UNEXPECTED_IF(
+        alignment == 0 || (alignment & (alignment - 1)) != 0, MemError::InvalidArgument
+    );
 
     size_t alloc_size = size + alignment + sizeof(AllocationHeader);
 
     auto res = Malloc(alloc_size);
-    UNEXPECTED_RET_IF_ERR(res);
+    RET_UNEXPECTED_IF_ERR(res);
 
     VPtr<void> raw_ptr = *res;
     uptr raw_addr      = PtrToUptr(raw_ptr);
diff --git a/kernel/src/mem/page_meta.hpp b/kernel/src/mem/page_meta.hpp
index a0ce8b91..ddf27cfb 100644
--- a/kernel/src/mem/page_meta.hpp
+++ b/kernel/src/mem/page_meta.hpp
@@ -42,9 +42,8 @@ struct SlabMeta {
 } PACK;
 
 struct PageTableMeta {
-    VPtr<PageMeta> parent;
     u16 ref_count;
-    u8 level;
+    u8 _unused[14];
 } PACK;
 
 struct AllocatedMeta {
@@ -59,8 +58,8 @@ struct PageMeta {
     union {
         BuddyMeta buddy;
         SlabMeta slab;
-        PageTableMeta page_table;
         AllocatedMeta allocated;
+        PageTableMeta page_table;
         DummyMeta dummy;
     } data;
 
@@ -90,21 +89,19 @@ struct PageMeta {
         data.slab.inuse    = inuse;
     }
 
-    void InitPageTable(u8 level, VPtr<PageMeta> parent)
-    {
-        type                      = PageMetaType::PageTable;
-        this->order               = 0;
-        data.page_table.ref_count = 0;
-        data.page_table.level     = level;
-        data.page_table.parent    = parent;
-    }
-
     void InitAllocated(u8 order)
     {
         type        = PageMetaType::Allocated;
         this->order = order;
     }
 
+    void InitPageTable(u8 order)
+    {
+        type                      = PageMetaType::PageTable;
+        this->order               = order;
+        data.page_table.ref_count = 0;
+    }
+
     static BuddyMeta &AsBuddy(PageMeta &meta)
     {
         ASSERT_EQ(meta.type, PageMetaType::Buddy);
diff --git a/kernel/src/mem/phys/mngr/bitmap.cpp b/kernel/src/mem/phys/mngr/bitmap.cpp
index e53258c5..34a833d2 100644
--- a/kernel/src/mem/phys/mngr/bitmap.cpp
+++ b/kernel/src/mem/phys/mngr/bitmap.cpp
@@ -2,6 +2,7 @@
 
 #include <data_structures/bit_array.hpp>
 #include <expected.hpp>
+#include <macros.hpp>
 #include "hal/constants.hpp"
 #include "mem/page_meta.hpp"
 #include "mem/types.hpp"
@@ -20,9 +21,8 @@ void BitmapPmm::Init(data_structures::BitMapView bmv)
 
 expected<PPtr<Page>, MemError> BitmapPmm::Alloc(AllocationRequest ar)
 {
-    if (ar.num_pages == 0) {
-        return unexpected(MemError::InvalidArgument);
-    }
+    RET_UNEXPECTED_IF(ar.num_pages == 0, MemError::InvalidArgument);
+
     const u64 total_pages = bitmap_view_.Size();
 
     FindBlockResult fbr;
@@ -47,9 +47,7 @@ expected<PPtr<Page>, MemError> BitmapPmm::Alloc(AllocationRequest ar)
         }
     }
 
-    if (!found) {
-        return unexpected(MemError::OutOfMemory);
-    }
+    RET_UNEXPECTED_IF(!found, MemError::OutOfMemory);
 
     MarkAllocated(fbr.start_pfn, fbr.start_pfn + ar.num_pages);
     last_alloc_idx_ = fbr.start_pfn;
diff --git a/kernel/src/mem/phys/mngr/buddy.cpp b/kernel/src/mem/phys/mngr/buddy.cpp
index d0b2d87a..d2793126 100644
--- a/kernel/src/mem/phys/mngr/buddy.cpp
+++ b/kernel/src/mem/phys/mngr/buddy.cpp
@@ -1,6 +1,7 @@
 #include "mem/phys/mngr/buddy.hpp"
 
 #include <algorithm.hpp>
+#include <macros.hpp>
 #include <mutex.hpp>
 
 #include "mem/page_meta_table.hpp"
@@ -141,9 +142,7 @@ expected<PPtr<Page>, MemError> B::Alloc(AllocationRequest ar)
     std::lock_guard guard{lock_};
     u8 order = ar.order;
 
-    if (order > kMaxOrder) {
-        return unexpected(MemError::InvalidArgument);
-    }
+    RET_UNEXPECTED_IF(order > kMaxOrder, MemError::InvalidArgument);
 
     // Find the smallest available block that is large enough
     for (u8 current_order = order; current_order <= kMaxOrder; current_order++) {
diff --git a/kernel/src/mem/phys/mngr/slab.cpp b/kernel/src/mem/phys/mngr/slab.cpp
index 06678c53..dca6384c 100644
--- a/kernel/src/mem/phys/mngr/slab.cpp
+++ b/kernel/src/mem/phys/mngr/slab.cpp
@@ -1,6 +1,7 @@
 #include "mem/phys/mngr/slab.hpp"
 
 #include <limits.hpp>
+#include <macros.hpp>
 #include <mutex.hpp>
 
 #include "mem/page_meta_table.hpp"
@@ -113,9 +114,7 @@ expected<VPtr<void>, MemError> KmemCache::AllocSlab()
     ASSERT_NOT_NULL(buddy_pmm_, "BuddyPmm must be initialized");
 
     auto res = buddy_pmm_->Alloc({.order = block_order_});
-    if (!res) {
-        return unexpected(res.error());
-    }
+    RET_UNEXPECTED_IF_ERR(res);
 
     PPtr<Page> phys_page = *res;
     VPtr<Page> virt_page = PhysToVirt(phys_page);
@@ -212,9 +211,7 @@ expected<VPtr<void>, MemError> KmemCache::Alloc()
             num_slabs_free_--;
             num_slabs_partial_++;
         } else {
-            if (!Grow()) {
-                return unexpected(MemError::OutOfMemory);
-            }
+            RET_UNEXPECTED_IF(!Grow(), MemError::OutOfMemory);
         }
     }
 
diff --git a/kernel/src/mem/virt/addr_space.cpp b/kernel/src/mem/virt/addr_space.cpp
index 874824aa..a33e4b3a 100644
--- a/kernel/src/mem/virt/addr_space.cpp
+++ b/kernel/src/mem/virt/addr_space.cpp
@@ -20,7 +20,7 @@ AS::~AddressSpace()
 expected<void, MemError> AS::AddArea(VMemArea vma)
 {
     auto res = KMalloc<VMemArea>();
-    UNEXPECTED_RET_IF_ERR(res);
+    RET_UNEXPECTED_IF_ERR(res);
 
     VPtr<VMemArea> n_area = *res;
     *n_area               = vma;
diff --git a/kernel/src/mem/virt/page_fault.cpp b/kernel/src/mem/virt/page_fault.cpp
index 5240cdc2..19b92a6b 100644
--- a/kernel/src/mem/virt/page_fault.cpp
+++ b/kernel/src/mem/virt/page_fault.cpp
@@ -1,8 +1,12 @@
+#include "mem/virt/page_fault.hpp"
+
 #include "interrupts/interrupt_types.hpp"
 
 #include "hal/intr_parser.hpp"
 #include "hal/panic.hpp"
+#include "mem/phys/mngr/buddy.hpp"
 #include "mem/virt/page_fault.hpp"
+#include "modules/hardware.hpp"
 #include "modules/memory.hpp"
 #include "trace_framework.hpp"
 
@@ -78,7 +82,16 @@ void PageFaultHandler(intr::LitExcEntry &, hal::ExceptionData *data)
             .NoExecute      = !vma.flags.executable
         };
 
-        auto map_res = mmu.Map(&as, AlignDown(f_ptr, hal::kPageSizeBytes), map_to, page_flags);
+        // We need a context to Map.
+        // For now, we construct a KernelMmuContext on the fly using the global PMM/PMT
+        // FIXME: This is slightly inefficient to reconstruct on every fault, but valid.
+        hal::KernelMmuContext ctx{
+            MemoryModule::Get().GetBuddyPmm(), MemoryModule::Get().GetPageMetaTable()
+        };
+
+        auto map_res = mmu.Map(
+            ctx, as.PageTableRoot(), AlignDown(f_ptr, hal::kPageSizeBytes), map_to, page_flags
+        );
 
         if (!map_res) {
             hal::KernelPanicFormat("Failed to map page for address %p", f_ptr);
diff --git a/kernel/src/mem/virt/vmm.cpp b/kernel/src/mem/virt/vmm.cpp
index 24bccbb5..61da3ec3 100644
--- a/kernel/src/mem/virt/vmm.cpp
+++ b/kernel/src/mem/virt/vmm.cpp
@@ -1,9 +1,15 @@
 #include "mem/virt/vmm.hpp"
+
+#include <bits_ext.hpp>
 #include <macros.hpp>
+
+#include "hal/constants.hpp"
 #include "mem/heap.hpp"
+#include "mem/phys/mngr/buddy.hpp"
 #include "mem/types.hpp"
 #include "mem/virt/addr_space.hpp"
 #include "mem/virt/area.hpp"
+#include "modules/memory.hpp"
 #include "trace_framework.hpp"
 
 namespace Mem
@@ -16,61 +22,60 @@ using Vmm = VirtualMemoryManager;
 using AS  = AddressSpace;
 
 TODO_WHEN_MULTITHREADING
-void Vmm::Init(hal::Tlb &tlb, hal::Mmu &mmu) noexcept
+void Vmm::Init(hal::Tlb &tlb, hal::Mmu &mmu, BuddyPmm &pmm) noexcept
 {
     DEBUG_INFO_MEMORY("VirtualMemoryManager::Init()");
-    tlb_ = &tlb;
-    mmu_ = &mmu;
+    tlb_  = &tlb;
+    mmu_  = &mmu;
+    bpmm_ = &pmm;
 }
 
 expected<VirtualPtr<AddressSpace>, MemError> Vmm::CreateAddrSpace()
 {
-    return KMalloc<AddressSpace>();
+    auto as_res = KNew<AddressSpace>(nullptr);
+    RET_UNEXPECTED_IF_ERR(as_res);
+    return *as_res;
 }
 
 expected<void, MemError> Vmm::DestroyAddrSpace(VPtr<AddressSpace> as)
 {
-    for (const VMemArea &vma : *as) {
-        auto res = RmArea(as, vma.start);
-        UNEXPECTED_RET_IF_ERR(res);
-    }
-    KFree(as);
+    KDelete(as);
     return {};
 }
 
 void Vmm::SwitchAddrSpace(VPtr<AddressSpace> as)
 {
-    mmu_->SwitchRootPageMapTable(as->PageTableRoot());
-    tlb_->FlushAll();
+    mmu_->SwitchRoot(as->PageTableRoot());
+    // SwitchRoot does CR3 load which flushes TLB
 }
 
 expected<VPtr<void>, MemError> Vmm::AddArea(VPtr<AddrSp> as, VMemArea vma)
 {
     auto res = as->AddArea(vma);
-    UNEXPECTED_RET_IF_ERR(res);
+    RET_UNEXPECTED_IF_ERR(res);
 
     return vma.start;
 }
 
 expected<void, MemError> Vmm::RmArea(VPtr<AddrSp> as, VPtr<void> region_start)
 {
-    // Get area start/end
     auto a_or_err = as->FindArea(region_start);
-    UNEXPECTED_RET_IF_ERR(a_or_err);
+    RET_UNEXPECTED_IF_ERR(a_or_err);
     auto *area  = *a_or_err;
     auto *start = area->start;
     auto size   = area->size;
 
-    // Unmap the range
-    auto unmap_res = mmu_->UnMapRange(as, start, size);
-    UNEXPECTED_RET_IF_ERR(unmap_res);
+    auto &pmt = MemoryModule::Get().GetPageMetaTable();
+    hal::KernelMmuContext ctx{*bpmm_, pmt};
+
+    mmu_->UnmapRange(ctx, as->PageTableRoot(), start, size);
 
-    // Remove from address space
     auto err = as->RmArea(region_start);
-    UNEXPECTED_RET_IF_ERR(err);
+    RET_UNEXPECTED_IF_ERR(err);
+
+    // TLB invalidation handled inside UnMapRange or via explicit flush if needed.
+    // But UnMapRange implementation in HAL Mmu calls Unmap which calls invlpg.
 
-    // Invalidate TLB
-    tlb_->InvalidateRange(start, size);
     return {};
 }
 
@@ -79,20 +84,21 @@ expected<void, MemError> Vmm::UpdateAreaFlags(
 )
 {
     auto a_or_err = as->FindArea(region_start);
-    UNEXPECTED_RET_IF_ERR(a_or_err);
+    RET_UNEXPECTED_IF_ERR(a_or_err);
     auto *area = *a_or_err;
-    if (area->start != region_start) {
-        return unexpected(MemError::InvalidArgument);
-    }
+    RET_UNEXPECTED_IF(area->start != region_start, MemError::InvalidArgument);
 
     area->flags = vmaf;
+
+    bool is_kernel = (PtrToUptr(region_start) >= hal::kKernelVirtualAddressStart);
+
     hal::PageFlags pf{
         .Present        = true,
         .Writable       = vmaf.writable,
-        .UserAccessible = true,  // User space VMA
+        .UserAccessible = !is_kernel,
         .WriteThrough   = false,
         .CacheDisable   = false,
-        .Global         = false,
+        .Global         = is_kernel,
         .NoExecute      = !vmaf.executable
     };
 
@@ -100,14 +106,8 @@ expected<void, MemError> Vmm::UpdateAreaFlags(
     uptr end   = start + area->size;
 
     for (uptr v = start; v < end; v += hal::kPageSizeBytes) {
-        auto res = mmu_->SetPageFlags(as, UptrToPtr<void>(v), pf);
-        if (res) {
-            tlb_->InvalidatePage(UptrToPtr<void>(v));
-        } else if (res.error() != MemError::NotFound) {
-            return unexpected(res.error());
-        }
-        // NotFound means page not mapped yet (lazy allocation),
-        // which is fine as future faults will use new VMA flags.
+        auto res = mmu_->SetPageFlags(as->PageTableRoot(), UptrToPtr<void>(v), pf);
+        RET_UNEXPECTED_IF(!res && res.error() != MemError::NotFound, res.error());
     }
 
     return {};
diff --git a/kernel/src/mem/virt/vmm.hpp b/kernel/src/mem/virt/vmm.hpp
index 7a87f6b7..7b159a01 100644
--- a/kernel/src/mem/virt/vmm.hpp
+++ b/kernel/src/mem/virt/vmm.hpp
@@ -13,6 +13,8 @@
 namespace Mem
 {
 
+class BuddyPmm;
+
 using std::expected;
 using std::unexpected;
 
@@ -28,7 +30,7 @@ class VirtualMemoryManager
     // ------------------------------
 
     VirtualMemoryManager() = default;
-    void Init(hal::Tlb &tlb, hal::Mmu &mmu) noexcept;
+    void Init(hal::Tlb &tlb, hal::Mmu &mmu, BuddyPmm &bpmm) noexcept;
 
     // ------------------------------
     // Class interaction
@@ -50,6 +52,7 @@ class VirtualMemoryManager
     // ------------------------------
     hal::Tlb *tlb_;
     hal::Mmu *mmu_;
+    BuddyPmm *bpmm_;
 };
 using Vmm = VirtualMemoryManager;
 
diff --git a/kernel/src/modules/memory.cpp b/kernel/src/modules/memory.cpp
index b52685fc..178f84eb 100644
--- a/kernel/src/modules/memory.cpp
+++ b/kernel/src/modules/memory.cpp
@@ -25,11 +25,9 @@ internal::MemoryModule::MemoryModule(const BootArguments &args) noexcept
 
     PageMetaTable_.Init(args.total_page_frames, BitmapPmm_);
 
-    // Prune whatever bootloader had left over
     TRACE_INFO_MEMORY("Unmapping lower half of memory");
-    {
-        Mmu_.UnmapLowerHalf(args.root_page_table, PageMetaTable_, BitmapPmm_, Tlb_);
-    }
+    Mmu_.Init(Tlb_);
+    Mmu_.UnmapLowerHalf(args.root_page_table, PageMetaTable_, BitmapPmm_);
 
     constexpr size_t kInitialBuddyPagesLimit = 4096;  // 16MB
     // Note: Initializing buddy with all pages is a slow operation.
@@ -38,6 +36,7 @@ internal::MemoryModule::MemoryModule(const BootArguments &args) noexcept
     // could offload this operation to.
     BuddyPmm_.Init(BitmapPmm_, PageMetaTable_, kInitialBuddyPagesLimit);
 
+    // Reconstruct metadata for the existing page table hierarchy passed by the bootloader.
     TRACE_INFO_MEMORY("Reconstructing page table metadata from root: 0x%p", args.root_page_table);
     Mmu_.ReconstructAddressSpace(args.root_page_table, PageMetaTable_);
 
@@ -45,9 +44,8 @@ internal::MemoryModule::MemoryModule(const BootArguments &args) noexcept
 
     Heap_.Init(PageMetaTable_, BuddyPmm_, SlabAllocator_);
 
-    Vmm_.Init(Tlb_, Mmu_);
+    Vmm_.Init(Tlb_, Mmu_, BuddyPmm_);
 
-    // TODO: This makes kernel stuck in infninite loop? Shoudnt?
     // Register initial Virtual Memory Areas (VMAs) so the VMM is aware of them.
     // These areas were set up by the bootloader but are invisible to the generic VMM until
     // registered.
@@ -65,7 +63,6 @@ internal::MemoryModule::MemoryModule(const BootArguments &args) noexcept
     //         .next                 = nullptr
     //     };
 
-    //     TRACE_INFO_MEMORY("Adding VMemArea for kernel");
     //     if (auto res = Vmm_.AddArea(&KernelAddressSpace_, kernel_vma); !res) {
     //         TRACE_WARN_MEMORY("Failed to register Kernel VMA");
     //     }
@@ -80,10 +77,10 @@ internal::MemoryModule::MemoryModule(const BootArguments &args) noexcept
     //         .next                 = nullptr
     //     };
 
-    //     TRACE_INFO_MEMORY("Adding VMemArea for direct mem mapping");
     //     if (auto res = Vmm_.AddArea(&KernelAddressSpace_, dm_vma); !res) {
     //         TRACE_WARN_MEMORY("Failed to register Direct Map VMA");
     //     }
+    //
     // }
 }
 
diff --git a/kernel/src/modules/vfs.cpp b/kernel/src/modules/vfs.cpp
index cb07626f..a0d40078 100644
--- a/kernel/src/modules/vfs.cpp
+++ b/kernel/src/modules/vfs.cpp
@@ -8,6 +8,7 @@
 #include <vfs/fat/fat12.hpp>
 #include <vfs/io/in_memory.hpp>
 #include "boot_args.hpp"
+#include "macros.hpp"
 
 using namespace vfs;
 
@@ -59,18 +60,12 @@ Result<> internal::VfsModule::Mount(
     const Path &mount_path, MountOptions options, Filesystem &driver
 )
 {
-    if (mount_path.IsEmpty() || !mount_path.IsAbsolute()) {
-        return std::unexpected(VfsError::kInvalidPath);
-    }
+    RET_UNEXPECTED_IF(mount_path.IsEmpty() || !mount_path.IsAbsolute(), VfsError::kInvalidPath);
 
-    if (GetMounts().Contains(mount_path.CString())) {
-        return std::unexpected(VfsError::kAlreadyMounted);
-    }
+    RET_UNEXPECTED_IF(GetMounts().Contains(mount_path.CString()), VfsError::kAlreadyMounted);
 
     bool inserted = GetMounts().Insert(mount_path.CString(), mount_path, options, driver);
-    if (!inserted) {
-        return std::unexpected(VfsError::kUnknownError);
-    }
+    RET_UNEXPECTED_IF(!inserted, VfsError::kUnknownError);
 
     TRACE_INFO_VFS("Mounted %s filesystem at %s", driver.GetInfo().name, mount_path.CString());
     return {};
@@ -78,18 +73,12 @@ Result<> internal::VfsModule::Mount(
 
 Result<> internal::VfsModule::Unmount(const Path &mount_path)
 {
-    if (mount_path.IsEmpty() || !mount_path.IsAbsolute()) {
-        return std::unexpected(VfsError::kInvalidPath);
-    }
+    RET_UNEXPECTED_IF(mount_path.IsEmpty() || !mount_path.IsAbsolute(), VfsError::kInvalidPath);
 
-    if (!GetMounts().Contains(mount_path.CString())) {
-        return std::unexpected(VfsError::kNotMounted);
-    }
+    RET_UNEXPECTED_IF(!GetMounts().Contains(mount_path.CString()), VfsError::kNotMounted);
 
     bool removed = GetMounts().Remove(mount_path.CString());
-    if (!removed) {
-        return std::unexpected(VfsError::kUnknownError);
-    }
+    RET_UNEXPECTED_IF(!removed, VfsError::kUnknownError);
 
     TRACE_INFO_VFS("Unmounted filesystem at %s", mount_path.CString());
     return {};
@@ -97,16 +86,11 @@ Result<> internal::VfsModule::Unmount(const Path &mount_path)
 
 Result<MountPoint *> internal::VfsModule::FindMountPoint(const Path &path)
 {
-    if (path.IsEmpty()) {
-        return std::unexpected(VfsError::kInvalidPath);
-    }
+    RET_UNEXPECTED_IF(path.IsEmpty(), VfsError::kInvalidPath);
 
     auto match = GetMounts().GetLongestPrefixMatch(path.CString());
-    if (match) {
-        return *match;
-    }
-
-    return std::unexpected(VfsError::kMountPointNotFound);
+    RET_UNEXPECTED_IF(!match, VfsError::kMountPointNotFound);
+    return *match;
 }
 
 // ------------------------------
@@ -145,15 +129,11 @@ Path internal::VfsModule::GetRelativePath_(const Path &absolute_path, const Path
 Result<> internal::VfsModule::CreateFile(const Path &path)
 {
     auto mount_result = FindMountPoint(path);
-    if (!mount_result.has_value()) {
-        return std::unexpected(mount_result.error());
-    }
+    RET_UNEXPECTED_IF_ERR(mount_result);
 
     MountPoint *mount = mount_result.value();
 
-    if (mount->options.read_only) {
-        return std::unexpected(VfsError::kReadOnly);
-    }
+    RET_UNEXPECTED_IF(mount->options.read_only, VfsError::kReadOnly);
 
     Path relative_path = GetRelativePath_(path, mount->path);
     return mount->fs.CreateFile(relative_path);
@@ -164,9 +144,7 @@ Result<size_t> internal::VfsModule::ReadFile(
 )
 {
     auto mount_result = FindMountPoint(path);
-    if (!mount_result.has_value()) {
-        return std::unexpected(mount_result.error());
-    }
+    RET_UNEXPECTED_IF_ERR(mount_result);
 
     MountPoint *mount  = mount_result.value();
     Path relative_path = GetRelativePath_(path, mount->path);
@@ -178,15 +156,11 @@ Result<size_t> internal::VfsModule::WriteFile(
 )
 {
     auto mount_result = FindMountPoint(path);
-    if (!mount_result.has_value()) {
-        return std::unexpected(mount_result.error());
-    }
+    RET_UNEXPECTED_IF_ERR(mount_result);
 
     MountPoint *mount = mount_result.value();
 
-    if (mount->options.read_only) {
-        return std::unexpected(VfsError::kReadOnly);
-    }
+    RET_UNEXPECTED_IF(mount->options.read_only, VfsError::kReadOnly);
 
     Path relative_path = GetRelativePath_(path, mount->path);
     return mount->fs.WriteFile(relative_path, buffer, size, offset);
@@ -195,15 +169,11 @@ Result<size_t> internal::VfsModule::WriteFile(
 Result<> internal::VfsModule::DeleteFile(const Path &path)
 {
     auto mount_result = FindMountPoint(path);
-    if (!mount_result.has_value()) {
-        return std::unexpected(mount_result.error());
-    }
+    RET_UNEXPECTED_IF_ERR(mount_result);
 
     MountPoint *mount = mount_result.value();
 
-    if (mount->options.read_only) {
-        return std::unexpected(VfsError::kReadOnly);
-    }
+    RET_UNEXPECTED_IF(mount->options.read_only, VfsError::kReadOnly);
 
     Path relative_path = GetRelativePath_(path, mount->path);
     return mount->fs.DeleteFile(relative_path);
@@ -212,9 +182,7 @@ Result<> internal::VfsModule::DeleteFile(const Path &path)
 Result<bool> internal::VfsModule::FileExists(const Path &path)
 {
     auto mount_result = FindMountPoint(path);
-    if (!mount_result.has_value()) {
-        return std::unexpected(mount_result.error());
-    }
+    RET_UNEXPECTED_IF_ERR(mount_result);
 
     MountPoint *mount  = mount_result.value();
     Path relative_path = GetRelativePath_(path, mount->path);
@@ -224,9 +192,7 @@ Result<bool> internal::VfsModule::FileExists(const Path &path)
 Result<size_t> internal::VfsModule::GetFileSize(const Path &path)
 {
     auto mount_result = FindMountPoint(path);
-    if (!mount_result.has_value()) {
-        return std::unexpected(mount_result.error());
-    }
+    RET_UNEXPECTED_IF_ERR(mount_result);
 
     MountPoint *mount  = mount_result.value();
     Path relative_path = GetRelativePath_(path, mount->path);
@@ -240,15 +206,11 @@ Result<size_t> internal::VfsModule::GetFileSize(const Path &path)
 Result<> internal::VfsModule::CreateDirectory(const Path &path)
 {
     auto mount_result = FindMountPoint(path);
-    if (!mount_result.has_value()) {
-        return std::unexpected(mount_result.error());
-    }
+    RET_UNEXPECTED_IF_ERR(mount_result);
 
     MountPoint *mount = mount_result.value();
 
-    if (mount->options.read_only) {
-        return std::unexpected(VfsError::kReadOnly);
-    }
+    RET_UNEXPECTED_IF(mount->options.read_only, VfsError::kReadOnly);
 
     Path relative_path = GetRelativePath_(path, mount->path);
     return mount->fs.CreateDirectory(relative_path);
@@ -257,15 +219,11 @@ Result<> internal::VfsModule::CreateDirectory(const Path &path)
 Result<> internal::VfsModule::RemoveDirectory(const Path &path)
 {
     auto mount_result = FindMountPoint(path);
-    if (!mount_result.has_value()) {
-        return std::unexpected(mount_result.error());
-    }
+    RET_UNEXPECTED_IF_ERR(mount_result);
 
     MountPoint *mount = mount_result.value();
 
-    if (mount->options.read_only) {
-        return std::unexpected(VfsError::kReadOnly);
-    }
+    RET_UNEXPECTED_IF(mount->options.read_only, VfsError::kReadOnly);
 
     Path relative_path = GetRelativePath_(path, mount->path);
     return mount->fs.RemoveDirectory(relative_path);
@@ -274,9 +232,7 @@ Result<> internal::VfsModule::RemoveDirectory(const Path &path)
 Result<bool> internal::VfsModule::DirectoryExists(const Path &path)
 {
     auto mount_result = FindMountPoint(path);
-    if (!mount_result.has_value()) {
-        return std::unexpected(mount_result.error());
-    }
+    RET_UNEXPECTED_IF_ERR(mount_result);
 
     MountPoint *mount  = mount_result.value();
     Path relative_path = GetRelativePath_(path, mount->path);
@@ -290,9 +246,7 @@ Result<bool> internal::VfsModule::DirectoryExists(const Path &path)
 Result<bool> internal::VfsModule::Exists(const Path &path)
 {
     auto mount_result = FindMountPoint(path);
-    if (!mount_result.has_value()) {
-        return std::unexpected(mount_result.error());
-    }
+    RET_UNEXPECTED_IF_ERR(mount_result);
 
     MountPoint *mount  = mount_result.value();
     Path relative_path = GetRelativePath_(path, mount->path);
@@ -303,22 +257,16 @@ Result<> internal::VfsModule::Move(const Path &old_path, const Path &new_path)
 {
     // Find mount points for both paths
     auto old_mount_result = FindMountPoint(old_path);
-    if (!old_mount_result.has_value()) {
-        return std::unexpected(old_mount_result.error());
-    }
+    RET_UNEXPECTED_IF_ERR(old_mount_result);
 
     auto new_mount_result = FindMountPoint(new_path);
-    if (!new_mount_result.has_value()) {
-        return std::unexpected(new_mount_result.error());
-    }
+    RET_UNEXPECTED_IF_ERR(new_mount_result);
 
     MountPoint *old_mount = old_mount_result.value();
     MountPoint *new_mount = new_mount_result.value();
 
     // Cross-filesystem move is not supported
-    if (old_mount != new_mount) {
-        return std::unexpected(VfsError::kCrossFilesystemRename);
-    }
+    RET_UNEXPECTED_IF(old_mount != new_mount, VfsError::kCrossFilesystemRename);
 
     if (old_mount->options.read_only) {
         return std::unexpected(VfsError::kReadOnly);
diff --git a/kernel/src/sys/loader.cpp b/kernel/src/sys/loader.cpp
index 82906a34..51126607 100644
--- a/kernel/src/sys/loader.cpp
+++ b/kernel/src/sys/loader.cpp
@@ -8,7 +8,6 @@
 #include "modules/memory.hpp"
 #include "modules/vfs.hpp"
 #include "sys/elf/elf.hpp"
-
 #include "trace_framework.hpp"
 
 namespace System
@@ -99,6 +98,7 @@ expected<Mem::VPtr<void>, LoadError> ElfLoader::Load(const vfs::Path &path, Mem:
         u64 virt_start = AlignDown(ph.vaddr, hal::kPageSizeBytes);
         u64 virt_end   = AlignUp(ph.vaddr + ph.memsz, hal::kPageSizeBytes);
         u64 size       = virt_end - virt_start;
+
         TRACE_INFO_GENERAL("Loading segment %d: [0x%llX - 0x%llX]", i, virt_start, virt_end);
 
         // Permissions
diff --git a/kernel/src/vfs/fat/fat.hpp b/kernel/src/vfs/fat/fat.hpp
index 47d1c8db..d754dd38 100644
--- a/kernel/src/vfs/fat/fat.hpp
+++ b/kernel/src/vfs/fat/fat.hpp
@@ -12,6 +12,7 @@
 #include <vfs/error.hpp>
 #include <vfs/interface.hpp>
 #include <vfs/path.hpp>
+#include "macros.hpp"
 
 namespace vfs
 {
@@ -289,23 +290,17 @@ class Fat
 
     NODISCARD Result<> CreateFile(const Path &path)
     {
-        if (path.IsEmpty() || !path.HasComponents()) {
-            return std::unexpected(VfsError::kInvalidPath);
-        }
+        RET_UNEXPECTED_IF(path.IsEmpty() || !path.HasComponents(), VfsError::kInvalidPath);
 
         char formatted_name[kMaxNameLength];
-        if (!FormatFilename_(path.GetFilename(), formatted_name)) {
-            return std::unexpected(VfsError::kInvalidName);
-        }
+        RET_UNEXPECTED_IF(
+            !FormatFilename_(path.GetFilename(), formatted_name), VfsError::kInvalidName
+        );
 
-        if (LookupPath_(path).found) {
-            return std::unexpected(VfsError::kAlreadyExists);
-        }
+        RET_UNEXPECTED_IF(LookupPath_(path).found, VfsError::kAlreadyExists);
 
         auto parent_cluster = GetParentCluster_(path);
-        if (!parent_cluster.has_value()) {
-            return std::unexpected(VfsError::kDirectoryNotFound);
-        }
+        RET_UNEXPECTED_IF_ERR(parent_cluster);
 
         return CreateEntry_(
             parent_cluster.value(), formatted_name, DirectoryEntry::Attributes::Archive, 0
@@ -314,18 +309,12 @@ class Fat
 
     NODISCARD Result<size_t> ReadFile(const Path &path, void *buffer, size_t size, size_t offset)
     {
-        if (!buffer || size == 0) {
-            return std::unexpected(VfsError::kInvalidArgument);
-        }
+        RET_UNEXPECTED_IF(!buffer || size == 0, VfsError::kInvalidArgument);
 
         auto lookup = LookupPath_(path);
-        if (!lookup.found) {
-            return std::unexpected(VfsError::kFileNotFound);
-        }
+        RET_UNEXPECTED_IF(!lookup.found, VfsError::kFileNotFound);
 
-        if (!lookup.entry.IsFile()) {
-            return std::unexpected(VfsError::kNotAFile);
-        }
+        RET_UNEXPECTED_IF(!lookup.entry.IsFile(), VfsError::kNotAFile);
 
         if (offset >= lookup.entry.file_size) {
             return 0;
@@ -338,18 +327,12 @@ class Fat
         const Path &path, const void *buffer, size_t size, size_t offset
     )
     {
-        if (!buffer || size == 0) {
-            return std::unexpected(VfsError::kInvalidArgument);
-        }
+        RET_UNEXPECTED_IF(!buffer || size == 0, VfsError::kInvalidArgument);
 
         auto lookup = LookupPath_(path);
-        if (!lookup.found) {
-            return std::unexpected(VfsError::kFileNotFound);
-        }
+        RET_UNEXPECTED_IF(!lookup.found, VfsError::kFileNotFound);
 
-        if (!lookup.entry.IsFile()) {
-            return std::unexpected(VfsError::kNotAFile);
-        }
+        RET_UNEXPECTED_IF(!lookup.entry.IsFile(), VfsError::kNotAFile);
 
         return WriteFileData_(lookup, buffer, size, offset);
     }
@@ -357,13 +340,9 @@ class Fat
     NODISCARD Result<> DeleteFile(const Path &path)
     {
         auto lookup = LookupPath_(path);
-        if (!lookup.found) {
-            return std::unexpected(VfsError::kFileNotFound);
-        }
+        RET_UNEXPECTED_IF(!lookup.found, VfsError::kFileNotFound);
 
-        if (!lookup.entry.IsFile()) {
-            return std::unexpected(VfsError::kNotAFile);
-        }
+        RET_UNEXPECTED_IF(!lookup.entry.IsFile(), VfsError::kNotAFile);
 
         return DeleteEntry_(lookup);
     }
@@ -377,12 +356,8 @@ class Fat
     NODISCARD Result<size_t> GetFileSize(const Path &path)
     {
         auto lookup = LookupPath_(path);
-        if (!lookup.found) {
-            return std::unexpected(VfsError::kFileNotFound);
-        }
-        if (!lookup.entry.IsFile()) {
-            return std::unexpected(VfsError::kNotAFile);
-        }
+        RET_UNEXPECTED_IF(!lookup.found, VfsError::kFileNotFound);
+        RET_UNEXPECTED_IF(!lookup.entry.IsFile(), VfsError::kNotAFile);
         return static_cast<size_t>(lookup.entry.file_size);
     }
 
@@ -392,23 +367,17 @@ class Fat
 
     NODISCARD Result<> CreateDirectory(const Path &path)
     {
-        if (path.IsEmpty() || !path.HasComponents()) {
-            return std::unexpected(VfsError::kInvalidPath);
-        }
+        RET_UNEXPECTED_IF(path.IsEmpty() || !path.HasComponents(), VfsError::kInvalidPath);
 
         char formatted_name[kMaxNameLength];
-        if (!FormatFilename_(path.GetFilename(), formatted_name)) {
-            return std::unexpected(VfsError::kInvalidName);
-        }
+        RET_UNEXPECTED_IF(
+            !FormatFilename_(path.GetFilename(), formatted_name), VfsError::kInvalidName
+        );
 
-        if (LookupPath_(path).found) {
-            return std::unexpected(VfsError::kAlreadyExists);
-        }
+        RET_UNEXPECTED_IF(LookupPath_(path).found, VfsError::kAlreadyExists);
 
         auto parent_cluster = GetParentCluster_(path);
-        if (!parent_cluster.has_value()) {
-            return std::unexpected(VfsError::kDirectoryNotFound);
-        }
+        RET_UNEXPECTED_IF_ERR(parent_cluster);
 
         return CreateDirectoryWithCluster_(parent_cluster.value(), formatted_name);
     }
@@ -416,17 +385,11 @@ class Fat
     NODISCARD Result<> RemoveDirectory(const Path &path)
     {
         auto lookup = LookupPath_(path);
-        if (!lookup.found) {
-            return std::unexpected(VfsError::kDirectoryNotFound);
-        }
+        RET_UNEXPECTED_IF(!lookup.found, VfsError::kDirectoryNotFound);
 
-        if (!lookup.entry.IsDirectory()) {
-            return std::unexpected(VfsError::kNotADirectory);
-        }
+        RET_UNEXPECTED_IF(!lookup.entry.IsDirectory(), VfsError::kNotADirectory);
 
-        if (!IsDirectoryEmpty_(lookup.entry)) {
-            return std::unexpected(VfsError::kNotEmpty);
-        }
+        RET_UNEXPECTED_IF(!IsDirectoryEmpty_(lookup.entry), VfsError::kNotEmpty);
 
         return DeleteEntry_(lookup);
     }
@@ -471,23 +434,17 @@ class Fat
     NODISCARD Result<> Move(const Path &old_path, const Path &new_path)
     {
         auto old_lookup = LookupPath_(old_path);
-        if (!old_lookup.found) {
-            return std::unexpected(VfsError::kFileNotFound);
-        }
+        RET_UNEXPECTED_IF(!old_lookup.found, VfsError::kFileNotFound);
 
-        if (LookupPath_(new_path).found) {
-            return std::unexpected(VfsError::kAlreadyExists);
-        }
+        RET_UNEXPECTED_IF(LookupPath_(new_path).found, VfsError::kAlreadyExists);
 
         char new_formatted[kMaxNameLength];
-        if (!FormatFilename_(new_path.GetFilename(), new_formatted)) {
-            return std::unexpected(VfsError::kInvalidName);
-        }
+        RET_UNEXPECTED_IF(
+            !FormatFilename_(new_path.GetFilename(), new_formatted), VfsError::kInvalidName
+        );
 
         auto new_parent_cluster = GetParentCluster_(new_path);
-        if (!new_parent_cluster.has_value()) {
-            return std::unexpected(VfsError::kDirectoryNotFound);
-        }
+        RET_UNEXPECTED_IF_ERR(new_parent_cluster);
 
         return MoveEntry_(old_lookup, new_formatted, new_parent_cluster.value());
     }
@@ -1050,9 +1007,7 @@ class Fat
             new_parent_cluster, new_name, old_lookup.entry.attributes,
             GetFirstCluster_(old_lookup.entry)
         );
-        if (!result.has_value()) {
-            return std::unexpected(result.error());
-        }
+        RET_UNEXPECTED_IF_ERR(result);
 
         old_lookup.entry.filename[0] = DirectoryEntry::kDeletedEntry;
         UpdateDirectoryEntry_(old_lookup.parent_cluster, old_lookup.entry_offset, old_lookup.entry);
diff --git a/kernel/test/mmu_test.cpp b/kernel/test/mmu_test.cpp
index 4686c24d..0e7cce8e 100644
--- a/kernel/test/mmu_test.cpp
+++ b/kernel/test/mmu_test.cpp
@@ -1,7 +1,10 @@
 #include <string.h>
+#include "data_structures/hash_maps.hpp"
+#include "mem/heap.hpp"
 #include "test_module/test.hpp"
 
 #include "hal/mmu.hpp"
+#include "hal/tlb.hpp"
 #include "mem/page.hpp"
 #include "mem/virt/addr_space.hpp"
 #include "modules/memory.hpp"
@@ -9,6 +12,52 @@
 using namespace Mem;
 using namespace hal;
 
+struct TestMmuContext {
+    Mem::BitmapPmm &pmm;
+    data_structures::FastMinimalStaticHashmap<uintptr_t, int, 60> ref_counts;
+
+    TestMmuContext(Mem::BitmapPmm &pmm) : pmm(pmm) {}
+
+    expected<Mem::PPtr<void>, Mem::MemError> AllocateTable(uint8_t level)
+    {
+        (void)level;
+        auto res = pmm.Alloc();
+        if (!res)
+            return unexpected(res.error());
+        auto ptr = *res;
+        memset(Mem::PhysToVirt(ptr), 0, hal::kPageSizeBytes);
+        return reinterpret_cast<Mem::PPtr<void>>(ptr);
+    }
+
+    void FreeTable(Mem::PPtr<void> table, uint8_t level)
+    {
+        (void)level;
+        pmm.Free(reinterpret_cast<Mem::PPtr<Mem::Page>>(table));
+        ref_counts.Remove(Mem::PtrToUptr(table));
+    }
+
+    void IncreaseUsage(Mem::PPtr<void> table)
+    {
+        auto key = Mem::PtrToUptr(table);
+        if (auto *val = ref_counts.Find(key)) {
+            (*val)++;
+        } else {
+            ref_counts.Insert(key, 1);
+        }
+    }
+
+    bool DecreaseUsage(Mem::PPtr<void> table)
+    {
+        auto key = Mem::PtrToUptr(table);
+        if (auto *val = ref_counts.Find(key)) {
+            if (*val > 0)
+                (*val)--;
+            return *val == 0;
+        }
+        return true;
+    }
+};
+
 class MmuTest : public TestGroupBase
 {
     protected:
@@ -25,30 +74,31 @@ class MmuTest : public TestGroupBase
         // Zero out the PML4 to ensure it's clean and valid
         memset(pml4_virt_, 0, hal::kPageSizeBytes);
 
-        // Initialize AddressSpace with this root
-        auto test_as_or_err = KNew<AddressSpace>(pml4_phys_);
-        R_ASSERT_TRUE(test_as_or_err);
-        test_as_ = test_as_or_err.value();
+        // Initialize Mmu
+        mmu_.Init(tlb_);
+
+        // Initialize Context
+        auto ctx_res = KNew<TestMmuContext>(pmm);
+        R_ASSERT_TRUE(ctx_res.has_value());
+        ctx_ = *ctx_res;
     }
 
     void TearDown_() override
     {
-        if (test_as_ != nullptr) {
-            KDelete(test_as_);
-            test_as_ = nullptr;
+        if (ctx_) {
+            KDelete(ctx_);
+            ctx_ = nullptr;
         }
 
-        // NOTE: There is no cleanup of the PML pages here. But since each test runs
-        // in a separate AlkOS instace, this is ok
-
         auto &pmm = MemoryModule::Get().GetBitmapPmm();
         pmm.Free(pml4_phys_);
     }
 
     Mem::PPtr<Mem::Page> pml4_phys_;
     Mem::VPtr<void> pml4_virt_;
-    Mem::VPtr<Mem::AddressSpace> test_as_{nullptr};
+    hal::Tlb tlb_{};
     hal::Mmu mmu_{};
+    TestMmuContext *ctx_{nullptr};
 
     // Default flags for testing
     PageFlags kDefaultFlags{
@@ -71,14 +121,15 @@ TEST_F(MmuTest, Map_GivenValidUnmappedPage_SucceedsAndTranslateReturnsPhys)
     // Given
     VPtr<void> vaddr = reinterpret_cast<VPtr<void>>(0x100000);
     PPtr<void> paddr = reinterpret_cast<PPtr<void>>(0x200000);
+    auto root        = reinterpret_cast<Mem::PPtr<void>>(pml4_phys_);
 
     // When
-    auto result = mmu_.Map(test_as_, vaddr, paddr, kDefaultFlags);
+    auto result = mmu_.Map(*ctx_, root, vaddr, paddr, kDefaultFlags);
 
     // Then
     EXPECT_TRUE(result.has_value());
 
-    auto trans_res = mmu_.Translate(test_as_, vaddr);
+    auto trans_res = mmu_.Translate(*ctx_, root, vaddr);
     EXPECT_TRUE(trans_res.has_value());
     EXPECT_EQ(paddr, trans_res.value());
 }
@@ -89,18 +140,19 @@ TEST_F(MmuTest, Map_GivenAlreadyMappedPage_ReturnsError)
     VPtr<void> vaddr  = reinterpret_cast<VPtr<void>>(0x100000);
     PPtr<void> paddr1 = reinterpret_cast<PPtr<void>>(0x200000);
     PPtr<void> paddr2 = reinterpret_cast<PPtr<void>>(0x300000);
+    auto root         = reinterpret_cast<Mem::PPtr<void>>(pml4_phys_);
 
-    EXPECT_TRUE(mmu_.Map(test_as_, vaddr, paddr1, kDefaultFlags).has_value());
+    EXPECT_TRUE(mmu_.Map(*ctx_, root, vaddr, paddr1, kDefaultFlags).has_value());
 
     // When
-    auto result = mmu_.Map(test_as_, vaddr, paddr2, kDefaultFlags);
+    auto result = mmu_.Map(*ctx_, root, vaddr, paddr2, kDefaultFlags);
 
     // Then
     EXPECT_FALSE(result.has_value());
     EXPECT_EQ(Mem::MemError::InvalidArgument, result.error());
 
     // Verify mapping hasn't changed
-    auto trans_res = mmu_.Translate(test_as_, vaddr);
+    auto trans_res = mmu_.Translate(*ctx_, root, vaddr);
     EXPECT_TRUE(trans_res.has_value());
     EXPECT_EQ(paddr1, trans_res.value());
 }
@@ -111,15 +163,16 @@ TEST_F(MmuTest, Map_GivenUnalignedAddress_BehavesConsistency)
     VPtr<void> vaddr_aligned   = reinterpret_cast<VPtr<void>>(0x100000);
     VPtr<void> vaddr_unaligned = reinterpret_cast<VPtr<void>>(0x100055);
     PPtr<void> paddr           = reinterpret_cast<PPtr<void>>(0x200000);
+    auto root                  = reinterpret_cast<Mem::PPtr<void>>(pml4_phys_);
 
     // When: Mapping with unaligned address
-    auto result = mmu_.Map(test_as_, vaddr_unaligned, paddr, kDefaultFlags);
+    auto result = mmu_.Map(*ctx_, root, vaddr_unaligned, paddr, kDefaultFlags);
 
     // Then
     EXPECT_TRUE(result.has_value());
 
     // Check that the aligned address is now mapped
-    auto trans_res = mmu_.Translate(test_as_, vaddr_aligned);
+    auto trans_res = mmu_.Translate(*ctx_, root, vaddr_aligned);
     EXPECT_TRUE(trans_res.has_value());
     EXPECT_EQ(paddr, trans_res.value());
 }
@@ -129,49 +182,51 @@ TEST_F(MmuTest, Map_GivenZeroAddress_Succeeds)
     // Given
     VPtr<void> vaddr = nullptr;
     PPtr<void> paddr = reinterpret_cast<PPtr<void>>(0x5000);
+    auto root        = reinterpret_cast<Mem::PPtr<void>>(pml4_phys_);
 
     // When
-    auto result = mmu_.Map(test_as_, vaddr, paddr, kDefaultFlags);
+    auto result = mmu_.Map(*ctx_, root, vaddr, paddr, kDefaultFlags);
 
     // Then
     EXPECT_TRUE(result.has_value());
-    auto trans_res = mmu_.Translate(test_as_, vaddr);
+    auto trans_res = mmu_.Translate(*ctx_, root, vaddr);
     EXPECT_TRUE(trans_res.has_value());
     EXPECT_EQ(paddr, trans_res.value());
 }
 
 // ------------------------------
-// UnMap Tests
+// Unmap Tests
 // ------------------------------
 
-TEST_F(MmuTest, UnMap_GivenMappedPage_Succeeds)
+TEST_F(MmuTest, Unmap_GivenMappedPage_Succeeds)
 {
     // Given
     VPtr<void> vaddr = reinterpret_cast<VPtr<void>>(0x400000);
     PPtr<void> paddr = reinterpret_cast<PPtr<void>>(0x800000);
-    mmu_.Map(test_as_, vaddr, paddr, kDefaultFlags);
+    auto root        = reinterpret_cast<Mem::PPtr<void>>(pml4_phys_);
+    mmu_.Map(*ctx_, root, vaddr, paddr, kDefaultFlags);
 
     // When
-    auto result = mmu_.UnMap(test_as_, vaddr);
+    mmu_.Unmap(*ctx_, root, vaddr);
 
     // Then
-    EXPECT_TRUE(result.has_value());
-
     // Verify it is no longer translated
-    auto trans_res = mmu_.Translate(test_as_, vaddr);
+    auto trans_res = mmu_.Translate(*ctx_, root, vaddr);
     EXPECT_FALSE(trans_res.has_value());
 }
 
-TEST_F(MmuTest, UnMap_GivenUnmappedPage_ReturnsError)
+TEST_F(MmuTest, Unmap_GivenUnmappedPage_NoOp)
 {
     // Given
     VPtr<void> vaddr = reinterpret_cast<VPtr<void>>(0x500000);  // Never mapped
+    auto root        = reinterpret_cast<Mem::PPtr<void>>(pml4_phys_);
 
     // When
-    auto result = mmu_.UnMap(test_as_, vaddr);
+    mmu_.Unmap(*ctx_, root, vaddr);
 
-    // Then: Should have memory error
-    EXPECT_TRUE(result.error());
+    // Then: Should not crash and still be unmapped
+    auto trans_res = mmu_.Translate(*ctx_, root, vaddr);
+    EXPECT_FALSE(trans_res.has_value());
 }
 
 // ------------------------------
@@ -183,10 +238,11 @@ TEST_F(MmuTest, Translate_GivenMappedPage_ReturnsPhysicalAddress)
     // Given
     VPtr<void> vaddr = reinterpret_cast<VPtr<void>>(0x1000);
     PPtr<void> paddr = reinterpret_cast<PPtr<void>>(0x2000);
-    mmu_.Map(test_as_, vaddr, paddr, kDefaultFlags);
+    auto root        = reinterpret_cast<Mem::PPtr<void>>(pml4_phys_);
+    mmu_.Map(*ctx_, root, vaddr, paddr, kDefaultFlags);
 
     // When
-    auto result = mmu_.Translate(test_as_, vaddr);
+    auto result = mmu_.Translate(*ctx_, root, vaddr);
 
     // Then
     EXPECT_TRUE(result.has_value());
@@ -197,9 +253,10 @@ TEST_F(MmuTest, Translate_GivenUnmappedPage_ReturnsError)
 {
     // Given
     VPtr<void> vaddr = reinterpret_cast<VPtr<void>>(0xDEADBEEF);
+    auto root        = reinterpret_cast<Mem::PPtr<void>>(pml4_phys_);
 
     // When
-    auto result = mmu_.Translate(test_as_, vaddr);
+    auto result = mmu_.Translate(*ctx_, root, vaddr);
 
     // Then
     EXPECT_FALSE(result.has_value());
@@ -209,27 +266,15 @@ TEST_F(MmuTest, Translate_GivenUnmappedPage_ReturnsError)
 // Control Register Tests
 // ------------------------------
 
-TEST_F(MmuTest, SwitchRootPageMapTable_GivenCurrentRoot_DoesNotCrash)
+TEST_F(MmuTest, SwitchRoot_GivenCurrentRoot_DoesNotCrash)
 {
     // Given: The current kernel address space root
     auto &kernel_as              = MemoryModule::Get().GetKernelAddressSpace();
     Mem::PPtr<void> current_root = kernel_as.PageTableRoot();
 
     // When: We switch to the SAME root (safe to do)
-    mmu_.SwitchRootPageMapTable(current_root);
+    mmu_.SwitchRoot(current_root);
 
     // Then: Execution continues
     EXPECT_TRUE(true);
 }
-
-TEST_F(MmuTest, DestroyRootPageMapTable_GivenAnyPtr_NoOp)
-{
-    // Given
-    Mem::PPtr<void> dummy_root = reinterpret_cast<Mem::PPtr<void>>(0x1000);
-
-    // When
-    mmu_.DestroyRootPageMapTable(dummy_root);
-
-    // Then: Nothing happens (no crash)
-    EXPECT_TRUE(true);
-}

From 419b1f8b73ce24683fc5cb6ce6ae9d91f17fd869 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C5=81ukasz=20Kryczka?= <lukasz.kryczka000@gmail.com>
Date: Sun, 28 Dec 2025 20:49:25 +0100
Subject: [PATCH 24/56] chore: Minor mmu test fix

---
 kernel/test/mmu_test.cpp | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/kernel/test/mmu_test.cpp b/kernel/test/mmu_test.cpp
index 0e7cce8e..8e1d275e 100644
--- a/kernel/test/mmu_test.cpp
+++ b/kernel/test/mmu_test.cpp
@@ -13,15 +13,15 @@ using namespace Mem;
 using namespace hal;
 
 struct TestMmuContext {
-    Mem::BitmapPmm &pmm;
+    Mem::BuddyPmm &pmm;
     data_structures::FastMinimalStaticHashmap<uintptr_t, int, 60> ref_counts;
 
-    TestMmuContext(Mem::BitmapPmm &pmm) : pmm(pmm) {}
+    TestMmuContext(Mem::BuddyPmm &pmm) : pmm(pmm) {}
 
     expected<Mem::PPtr<void>, Mem::MemError> AllocateTable(uint8_t level)
     {
         (void)level;
-        auto res = pmm.Alloc();
+        auto res = pmm.Alloc({.order = 0});
         if (!res)
             return unexpected(res.error());
         auto ptr = *res;
@@ -64,8 +64,8 @@ class MmuTest : public TestGroupBase
     void Setup_() override
     {
         // Allocate a physical page for the root page table (PML4)
-        auto &pmm     = MemoryModule::Get().GetBitmapPmm();
-        auto page_res = pmm.Alloc();
+        auto &pmm     = MemoryModule::Get().GetBuddyPmm();
+        auto page_res = pmm.Alloc({.order = 0});
         R_ASSERT_TRUE(page_res.has_value());
 
         pml4_phys_ = *page_res;
@@ -90,7 +90,7 @@ class MmuTest : public TestGroupBase
             ctx_ = nullptr;
         }
 
-        auto &pmm = MemoryModule::Get().GetBitmapPmm();
+        auto &pmm = MemoryModule::Get().GetBuddyPmm();
         pmm.Free(pml4_phys_);
     }
 

From 582a8f199008328312c24ce1cd1a9f5ca0bc5e41 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C5=81ukasz=20Kryczka?=
 <60490378+kryczkal@users.noreply.github.com>
Date: Sun, 28 Dec 2025 21:33:46 +0100
Subject: [PATCH 25/56] Kryczkal/fix vmm refactor 02 (#249)

## Problem
The functions that restore the coherency of VMM after bootloader, were
completely out of place.

## Solution
Refactored the code so it makes sense
---
 kernel/arch/x86_64/src/hal/impl/mmu.hpp |   3 +
 kernel/arch/x86_64/src/hal/impl/mmu.tpp |  35 +++++++-
 kernel/src/hal/api/mmu.hpp              |  21 ++++-
 kernel/src/hal/mmu.hpp                  | 104 ++----------------------
 kernel/src/mem/init/boot_mmu.hpp        |  78 ++++++++++++++++++
 kernel/src/modules/memory.cpp           |  10 ++-
 scripts/tests/runner.py                 |   1 -
 7 files changed, 146 insertions(+), 106 deletions(-)
 create mode 100644 kernel/src/mem/init/boot_mmu.hpp

diff --git a/kernel/arch/x86_64/src/hal/impl/mmu.hpp b/kernel/arch/x86_64/src/hal/impl/mmu.hpp
index 95f15803..8c709575 100644
--- a/kernel/arch/x86_64/src/hal/impl/mmu.hpp
+++ b/kernel/arch/x86_64/src/hal/impl/mmu.hpp
@@ -23,6 +23,9 @@ class Mmu : public MmuAPI
     template <MmuContext Context>
     void Unmap(Context &ctx, Mem::PPtr<void> root, Mem::VPtr<void> vaddr);
 
+    template <MmuContext Context>
+    void ClearUserMappings(Context &ctx, Mem::PPtr<void> root);
+
     template <MmuContext Context>
     expected<Mem::PPtr<void>, Mem::MemError> Translate(
         Context &ctx, Mem::PPtr<void> root, Mem::VPtr<void> vaddr
diff --git a/kernel/arch/x86_64/src/hal/impl/mmu.tpp b/kernel/arch/x86_64/src/hal/impl/mmu.tpp
index 4018573e..120f753b 100644
--- a/kernel/arch/x86_64/src/hal/impl/mmu.tpp
+++ b/kernel/arch/x86_64/src/hal/impl/mmu.tpp
@@ -157,6 +157,25 @@ void Mmu::Unmap(Context &ctx, Mem::PPtr<void> root, Mem::VPtr<void> vaddr)
     }
 }
 
+template <MmuContext Context>
+void Mmu::ClearUserMappings(Context &ctx, Mem::PPtr<void> root)
+{
+    // On x86_64, the lower half of the address space corresponds to
+    // the first 256 entries of PML4.
+    constexpr size_t kLowerHalfEntries = 256;
+
+    auto *pml4 = reinterpret_cast<PageMapTable<4> *>(Mem::PhysToVirt(root));
+
+    for (size_t i = 0; i < kLowerHalfEntries; ++i) {
+        auto &entry = (*pml4)[i];
+        if (entry.IsPresent()) {
+            // Recursively destroy the sub-tables
+            DestroyTable(ctx, reinterpret_cast<Mem::PPtr<void>>(entry.GetNextLevelTable()), 3);
+            entry.Clear();
+        }
+    }
+}
+
 template <MmuContext Context>
 expected<Mem::PPtr<void>, Mem::MemError> Mmu::Translate(
     Context &, Mem::PPtr<void> root, Mem::VPtr<void> vaddr
@@ -190,14 +209,24 @@ expected<Mem::PPtr<void>, Mem::MemError> Mmu::Translate(
 template <TableVisitor Visitor>
 void Mmu::VisitTables(Mem::PPtr<void> root, Visitor visitor)
 {
-    // Visitor signature: void(Mem::PPtr<void> table, uint8_t level)
+    // Visitor signature: void(Mem::PPtr<void> table, uint8_t level, size_t entry_count)
 
     // We traverse recursively
     auto RecVisit = [&]<size_t Level>(this auto &&self, Mem::PPtr<void> table_phys) -> void {
-        visitor(table_phys, Level);
+        auto *table = reinterpret_cast<PageMapTable<Level> *>(Mem::PhysToVirt(table_phys));
+
+        // First pass: count entries
+        size_t count = 0;
+        for (const auto &entry : *table) {
+            if (entry.IsPresent()) {
+                count++;
+            }
+        }
+
+        // Invoke visitor with stats
+        visitor(table_phys, Level, count);
 
         if constexpr (Level > 1) {
-            auto *table = reinterpret_cast<PageMapTable<Level> *>(Mem::PhysToVirt(table_phys));
             for (const auto &entry : *table) {
                 if (entry.IsPresent() && !entry.IsHuge()) {
                     self.template operator()<Level - 1>(
diff --git a/kernel/src/hal/api/mmu.hpp b/kernel/src/hal/api/mmu.hpp
index 11508c92..0f0bc945 100644
--- a/kernel/src/hal/api/mmu.hpp
+++ b/kernel/src/hal/api/mmu.hpp
@@ -66,10 +66,11 @@ concept MmuContext = requires(T ctx, u8 level, Mem::PPtr<void> table) {
 
 /**
  * @brief Concept for a visitor function used to traverse page tables.
+ * Visitor signature: void(Mem::PPtr<void> table, u8 level, size_t entry_count)
  */
 template <typename Func>
-concept TableVisitor = requires(Func f, Mem::PPtr<void> table, u8 level) {
-    { f(table, level) } -> std::same_as<void>;
+concept TableVisitor = requires(Func f, Mem::PPtr<void> table, u8 level, size_t count) {
+    { f(table, level, count) } -> std::same_as<void>;
 };
 
 struct MmuAPI {
@@ -98,6 +99,15 @@ struct MmuAPI {
     template <MmuContext Context>
     void Unmap(Context &ctx, Mem::PPtr<void> root, Mem::VPtr<void> vaddr);
 
+    /**
+     * @brief Clears the user-space portion of the virtual address space.
+     *
+     * This destroys all page tables associated with the lower half (user space)
+     * of the address space, freeing them via the provided context.
+     */
+    template <MmuContext Context>
+    void ClearUserMappings(Context &ctx, Mem::PPtr<void> root);
+
     /**
      * @brief Updates flags for an existing mapping.
      */
@@ -121,8 +131,11 @@ struct MmuAPI {
     void SwitchRoot(Mem::PPtr<void> root);
 
     /**
-     * @brief Walks the page table hierarchy and calls the visitor for each present table.
-     * Useful for reconstructing metadata or debugging.
+     * @brief Walks the page table hierarchy.
+     *
+     * Calls the visitor for each present table in the hierarchy.
+     * The visitor receives the table address, its level, and the number of active entries
+     * within that table (useful for reconstructing reference counts).
      */
     template <TableVisitor Visitor>
     void VisitTables(Mem::PPtr<void> root, Visitor visitor);
diff --git a/kernel/src/hal/mmu.hpp b/kernel/src/hal/mmu.hpp
index c82eb087..46c45012 100644
--- a/kernel/src/hal/mmu.hpp
+++ b/kernel/src/hal/mmu.hpp
@@ -36,8 +36,6 @@ struct KernelMmuContext {
         memset(Mem::PhysToVirt(ptr), 0, hal::kPageSizeBytes);
 
         auto &meta = pmt.GetPageMeta(ptr);
-        // Parent tracking is not strictly enforced by this context during alloc,
-        // but we init the metadata type.
         meta.InitPageTable(level);
         return reinterpret_cast<Mem::PPtr<void>>(ptr);
     }
@@ -46,7 +44,7 @@ struct KernelMmuContext {
     {
         (void)level;
         auto &meta = pmt.GetPageMeta(table);
-        meta.InitAllocated(0);  // Reset type to generic allocated before freeing
+        meta.InitAllocated(0);
         pmm.Free(reinterpret_cast<Mem::PPtr<Mem::Page>>(table));
     }
 
@@ -66,35 +64,6 @@ struct KernelMmuContext {
     }
 };
 
-/**
- * @brief Boot MMU Context using BitmapPmm (before Buddy is ready).
- * Used for cleaning up bootloader tables.
- */
-struct BootstrapMmuContext {
-    Mem::BitmapPmm &pmm;
-    Mem::PageMetaTable &pmt;
-
-    expected<Mem::PPtr<void>, Mem::MemError> AllocateTable(uint8_t)
-    {
-        // Not implemented/Needed for cleanup
-        return unexpected(Mem::MemError::OutOfMemory);
-    }
-
-    void FreeTable(Mem::PPtr<void> table, uint8_t level)
-    {
-        (void)level;
-        auto &meta = pmt.GetPageMeta(table);
-        meta.InitAllocated(0);
-        pmm.Free(reinterpret_cast<Mem::PPtr<Mem::Page>>(table));
-    }
-
-    void IncreaseUsage(Mem::PPtr<void>) {}
-    bool DecreaseUsage(Mem::PPtr<void>)
-    {
-        return true;
-    }  // Always assume empty/freeable during force cleanup
-};
-
 class Mmu : public arch::Mmu
 {
     Tlb *tlb_;
@@ -128,6 +97,13 @@ class Mmu : public arch::Mmu
         tlb_->InvalidatePage(vaddr);
     }
 
+    template <MmuContext Context>
+    void ClearUserMappings(Context &ctx, Mem::PPtr<void> root)
+    {
+        arch::Mmu::ClearUserMappings(ctx, root);
+        tlb_->FlushAll();
+    }
+
     expected<void, Mem::MemError> SetPageFlags(
         Mem::PPtr<void> root, Mem::VPtr<void> vaddr, PageFlags flags
     )
@@ -152,70 +128,6 @@ class Mmu : public arch::Mmu
 
         tlb_->InvalidateRange(start, size);
     }
-
-    /// Reconstructs metadata for an existing page table tree
-    void ReconstructAddressSpace(Mem::PPtr<void> root, Mem::PageMetaTable &pmt)
-    {
-        // Counts refs for a table by inspecting its entries
-        // Note: this assumes we are iterating a valid tree
-        // The Visitor in arch::Mmu doesn't provide entry counts, so we do it manually or
-        // rely on the fact that we can just set type for now.
-        // To strictly restore ref_counts, we need to count bits.
-
-        VisitTables(root, [&](Mem::PPtr<void> table, uint8_t level) {
-            auto &meta = pmt.GetPageMeta(table);
-            meta.InitPageTable(level);
-
-            // Count entries for ref_count
-            if (level > 1) {
-                u16 count = 0;
-                // Hack: we cast to generic array to count present bits
-                // This assumes standard x86 layout which HAL technically shouldn't know,
-                // but Mmu inherits from arch::Mmu so it can access Arch defs if included.
-                // We can't access PageMapTable<L> easily here without template.
-                // Let's rely on a simplified assumption or add a helper in Arch.
-                // For now, we set ref_count to 1 to prevent accidental freeing
-                // until we implement proper counting or let the system run.
-                // Ideally, we would iterate the table.
-                auto *virt = reinterpret_cast<u64 *>(Mem::PhysToVirt(table));
-                for (int i = 0; i < 512; ++i) {
-                    if (virt[i] & 1)
-                        count++;
-                }
-                Mem::PageMeta::AsPageTable(meta).ref_count = count;
-            } else {
-                // Level 1 (PT)
-                u16 count  = 0;
-                auto *virt = reinterpret_cast<u64 *>(Mem::PhysToVirt(table));
-                for (int i = 0; i < 512; ++i) {
-                    if (virt[i] & 1)
-                        count++;
-                }
-                Mem::PageMeta::AsPageTable(meta).ref_count = count;
-            }
-        });
-    }
-
-    void UnmapLowerHalf(Mem::PPtr<void> root, Mem::PageMetaTable &pmt, Mem::BitmapPmm &pmm)
-    {
-        BootstrapMmuContext ctx{pmm, pmt};
-
-        // Manual iteration of PML4 lower half
-        auto *pml4                         = reinterpret_cast<u64 *>(Mem::PhysToVirt(root));
-        constexpr size_t kLowerHalfEntries = 256;
-
-        for (size_t i = 0; i < kLowerHalfEntries; ++i) {
-            if (pml4[i] & 1) {  // Present
-                Mem::PPtr<void> child =
-                    reinterpret_cast<Mem::PPtr<void>>(pml4[i] & 0x000FFFFFFFFFF000);  // Mask flags
-                DestroyTable(ctx, child, 3);  // Child is Level 3 (PDPT)
-                pml4[i] = 0;
-            }
-        }
-
-        // TLB flush should be handled by caller or here
-        SwitchRoot(root);  // Reload CR3 flushes TLB
-    }
 };
 
 }  // namespace hal
diff --git a/kernel/src/mem/init/boot_mmu.hpp b/kernel/src/mem/init/boot_mmu.hpp
new file mode 100644
index 00000000..d408af3e
--- /dev/null
+++ b/kernel/src/mem/init/boot_mmu.hpp
@@ -0,0 +1,78 @@
+#ifndef KERNEL_SRC_MEM_INIT_BOOT_MMU_HPP_
+#define KERNEL_SRC_MEM_INIT_BOOT_MMU_HPP_
+
+#include <expected.hpp>
+#include "hal/mmu.hpp"
+#include "mem/page_meta_table.hpp"
+#include "mem/phys/mngr/bitmap.hpp"
+
+namespace Mem::Boot
+{
+
+/**
+ * @brief Boot MMU Context using BitmapPmm (before Buddy is ready).
+ * Used for cleaning up bootloader tables.
+ */
+struct BootstrapMmuContext {
+    Mem::BitmapPmm &pmm;
+    Mem::PageMetaTable &pmt;
+
+    std::expected<Mem::PPtr<void>, Mem::MemError> AllocateTable(uint8_t)
+    {
+        // Allocation is not supported during cleanup phase
+        return std::unexpected(Mem::MemError::OutOfMemory);
+    }
+
+    void FreeTable(Mem::PPtr<void> table, uint8_t level)
+    {
+        (void)level;
+        auto &meta = pmt.GetPageMeta(table);
+        meta.InitAllocated(0);
+        pmm.Free(reinterpret_cast<Mem::PPtr<Mem::Page>>(table));
+    }
+
+    void IncreaseUsage(Mem::PPtr<void>) {}
+    bool DecreaseUsage(Mem::PPtr<void>)
+    {
+        // Always assume empty/freeable during force cleanup
+        return true;
+    }
+};
+
+class BootMmuCleaner
+{
+    public:
+    /**
+     * @brief Clears the identity mappings (user/lower half) left by the bootloader.
+     * This ensures the kernel starts with a clean user-space address range.
+     */
+    void CleanIdentityMappings(
+        hal::Mmu &mmu, Mem::BitmapPmm &pmm, Mem::PageMetaTable &pmt, Mem::PPtr<void> root
+    )
+    {
+        BootstrapMmuContext ctx{pmm, pmt};
+        mmu.ClearUserMappings(ctx, root);
+    }
+
+    /**
+     * @brief Reconstructs metadata (PageMetaTable) for the existing kernel page tables.
+     * The bootloader creates the initial tables, but our memory manager needs
+     * to know about them (type: PageTable, ref_count, etc.) to manage them later.
+     */
+    void ReconstructMetadata(hal::Mmu &mmu, Mem::PageMetaTable &pmt, Mem::PPtr<void> root)
+    {
+        mmu.VisitTables(root, [&](Mem::PPtr<void> table, uint8_t level, size_t entry_count) {
+            auto &meta = pmt.GetPageMeta(table);
+            meta.InitPageTable(level);
+
+            // Set the reference count based on the number of present entries
+            // This prevents the kernel from prematurely freeing these tables.
+            // Note: We cast entry_count to u16, assuming it fits (max 512).
+            Mem::PageMeta::AsPageTable(meta).ref_count = static_cast<u16>(entry_count);
+        });
+    }
+};
+
+}  // namespace Mem::Boot
+
+#endif  // KERNEL_SRC_MEM_INIT_BOOT_MMU_HPP_
diff --git a/kernel/src/modules/memory.cpp b/kernel/src/modules/memory.cpp
index 178f84eb..0e7d016d 100644
--- a/kernel/src/modules/memory.cpp
+++ b/kernel/src/modules/memory.cpp
@@ -2,6 +2,7 @@
 
 #include "boot_args.hpp"
 #include "hal/constants.hpp"
+#include "mem/init/boot_mmu.hpp"
 #include "mem/page_meta_table.hpp"
 #include "mem/phys/mngr/bitmap.hpp"
 #include "mem/types.hpp"
@@ -25,9 +26,14 @@ internal::MemoryModule::MemoryModule(const BootArguments &args) noexcept
 
     PageMetaTable_.Init(args.total_page_frames, BitmapPmm_);
 
+    Mmu_.Init(Tlb_);
+
+    // Cleanup bootloader mappings and reconstruct metadata for kernel mappings
+    Mem::Boot::BootMmuCleaner boot_cleaner;
+
     TRACE_INFO_MEMORY("Unmapping lower half of memory");
     Mmu_.Init(Tlb_);
-    Mmu_.UnmapLowerHalf(args.root_page_table, PageMetaTable_, BitmapPmm_);
+    boot_cleaner.CleanIdentityMappings(Mmu_, BitmapPmm_, PageMetaTable_, args.root_page_table);
 
     constexpr size_t kInitialBuddyPagesLimit = 4096;  // 16MB
     // Note: Initializing buddy with all pages is a slow operation.
@@ -38,7 +44,7 @@ internal::MemoryModule::MemoryModule(const BootArguments &args) noexcept
 
     // Reconstruct metadata for the existing page table hierarchy passed by the bootloader.
     TRACE_INFO_MEMORY("Reconstructing page table metadata from root: 0x%p", args.root_page_table);
-    Mmu_.ReconstructAddressSpace(args.root_page_table, PageMetaTable_);
+    boot_cleaner.ReconstructMetadata(Mmu_, PageMetaTable_, args.root_page_table);
 
     SlabAllocator_.Init(BuddyPmm_);
 
diff --git a/scripts/tests/runner.py b/scripts/tests/runner.py
index 9cfe1d75..0583321e 100755
--- a/scripts/tests/runner.py
+++ b/scripts/tests/runner.py
@@ -42,7 +42,6 @@ def __init__(self, name: str, test_filters: list[str], test_blockers: list[str])
         [
             "SnprintfTest_BufferSizeHandling",  # Fails <- issue added on low prio
             "SnprintfTest_EdgeCases",  # Fails <- issue added on low prio
-            "PageFaultHandlerTest*DirectMappedMemory*",
         ]
     )
 ]

From 9926e8451a022f9429dc9a0431df6eaf73acea0a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C5=81ukasz=20Kryczka?=
 <60490378+kryczkal@users.noreply.github.com>
Date: Sun, 28 Dec 2025 21:53:01 +0100
Subject: [PATCH 26/56] Kryczkal/fix timetest (#250)

Minor PR that fixes the `TimeTests_TestTime`
---
 kernel/arch/x86_64/src/drivers/cmos/rtc.cpp |  2 +-
 kernel/src/libc_backend.cpp                 | 10 +++++++---
 kernel/src/system_time.cpp                  |  2 +-
 kernel/test/test_time.cpp                   |  6 +++++-
 4 files changed, 14 insertions(+), 6 deletions(-)

diff --git a/kernel/arch/x86_64/src/drivers/cmos/rtc.cpp b/kernel/arch/x86_64/src/drivers/cmos/rtc.cpp
index 35febfaa..9f5c271e 100644
--- a/kernel/arch/x86_64/src/drivers/cmos/rtc.cpp
+++ b/kernel/arch/x86_64/src/drivers/cmos/rtc.cpp
@@ -65,7 +65,7 @@ FAST_CALL bool CompareTimes(const RtcTime &time, const RtcTime &last_time)
 
 FAST_CALL RtcTime FillRtcStruct()
 {
-    RtcTime time;
+    RtcTime time{};
 
     while (IsUpdateInProgress()) {
         /* Wait for the update to finish */
diff --git a/kernel/src/libc_backend.cpp b/kernel/src/libc_backend.cpp
index a9d1cf0b..97bdc7d9 100644
--- a/kernel/src/libc_backend.cpp
+++ b/kernel/src/libc_backend.cpp
@@ -20,8 +20,10 @@ void __platform_get_clock_value(const ClockType type, TimeVal *time, Timezone *t
     ASSERT_NOT_NULL(time_zone);
 
     if (!TimingModule::IsInited()) {
-        time->seconds   = 0;
-        time->remainder = 0;
+        if (time != nullptr) {
+            time->seconds   = 0;
+            time->remainder = 0;
+        }
         return;
     }
 
@@ -64,7 +66,9 @@ u64 __platform_get_clock_ticks_in_second(const ClockType type)
 
 void __platform_get_timezone(Timezone *time_zone)
 {
-    assert(time_zone != nullptr);
+    ASSERT_NOT_NULL(time_zone);
+
+    ASSERT_TRUE(TimingModule::IsInited(), "Timing module is not initialized");
     *time_zone = TimingModule::Get().GetSystemTime().GetTimezone();
 }
 
diff --git a/kernel/src/system_time.cpp b/kernel/src/system_time.cpp
index 6cb3505c..266520ef 100644
--- a/kernel/src/system_time.cpp
+++ b/kernel/src/system_time.cpp
@@ -21,7 +21,7 @@ void timing::SystemTime::SyncWithHardware()
     boot_time_read_utc_ = arch::QuerySystemTime(kUtcTimezone);
     sys_time_on_read_   = ReadLifeTimeNs();
 
-    tm time;
+    tm time{};
     ConvertFromPosixToTm(boot_time_read_utc_, time, kUtcTimezone);
     boot_time_read_local_ = ConvertDateTimeToPosix(time, GetTimezone());
 
diff --git a/kernel/test/test_time.cpp b/kernel/test/test_time.cpp
index 76d5468b..4bc90d81 100644
--- a/kernel/test/test_time.cpp
+++ b/kernel/test/test_time.cpp
@@ -9,4 +9,8 @@ class TimeTests : public TestGroupBase
     static constexpr time_t kTestTime1 = 1737117056;
 };
 
-TEST_F(TimeTests, TestTime) { localtime_r(&kTestTime1, nullptr); }
+TEST_F(TimeTests, TestTime)
+{
+    tm result;
+    localtime_r(&kTestTime1, &result);
+}

From c0e1ff1caaa8b19e8cbff5194c37338fbbcc409c Mon Sep 17 00:00:00 2001
From: Adam Ogieniewski <ogieniewski.dev@gmail.com>
Date: Mon, 29 Dec 2025 12:24:22 +0100
Subject: [PATCH 27/56] Implement userspace system call interface (#251)

Introduces a new system call mechanism for userspace programs via `int
0x80`.
Refactors libc to use this interface for platform-specific functions
like time, debug I/O, and panic.
Updates the kernel's Interrupt Descriptor Table (IDT) and interrupt
handling to support the new syscall vector and an increased number of
software interrupts.
Restructures the CMake build system for libc and userspace applications,
including a new `alkos_add_subdirs` helper.
Splits ACPI initialization into early and full stages for better
control.
Updates QEMU flags for x86_64 to use the `q35` machine type.

<img width="577" height="337" alt="image"
src="https://github.com/user-attachments/assets/53751f7b-7701-4bd7-8dc3-db9e476325f6"
/>
---
 cmake/MiscHelpers.cmake                       |  21 +++
 cmake/RuntimeHelpers.cmake                    |   9 +-
 kernel/arch/x86_64/CMakeLists.txt             |   4 +-
 .../arch/x86_64/boot/lib/sys/libc_backend.cpp |  33 ----
 kernel/arch/x86_64/src/cpu/utils.hpp          |   4 +-
 .../arch/x86_64/src/hal/impl/interrupts.cpp   |   2 +-
 .../arch/x86_64/src/hal/impl/interrupts.hpp   |   4 +-
 kernel/arch/x86_64/src/hal/impl/types.hpp     |  11 ++
 kernel/arch/x86_64/src/include/regs.nasm      |  24 +++
 kernel/arch/x86_64/src/interrupts/idt.cpp     |  26 +++-
 kernel/arch/x86_64/src/interrupts/idt.hpp     |  33 +++-
 kernel/arch/x86_64/src/interrupts/idt.nasm    |  91 ++++++++---
 kernel/src/acpi/acpi.cpp                      |  56 +++----
 kernel/src/acpi/acpi.hpp                      |  11 +-
 kernel/src/acpi/acpi_power.cpp                |  14 +-
 kernel/src/acpi/osl.cpp                       |  29 +++-
 kernel/src/hal/types.hpp                      |  11 ++
 kernel/src/init.cpp                           |  10 +-
 kernel/src/libc_backend.cpp                   |  70 ++-------
 kernel/src/sys/shell.cpp                      |  37 ++---
 kernel/src/sys/shell.hpp                      |   4 +-
 kernel/src/syscalls/dispatch_table.hpp        |  44 ++++++
 kernel/src/syscalls/handler.hpp               |  98 ++++++++++++
 kernel/src/syscalls/syscalls.cpp              |  29 ++++
 kernel/src/syscalls/syscalls.hpp              | 144 ++++++++++++++++++
 kernel/src/trace.cpp                          |   1 +
 kernel/src/trace_framework.hpp                |   5 +
 kernel/thirdparty/CMakeLists.txt              |   8 +-
 libs/libc/CMakeLists.txt                      |   8 +-
 libs/libc/arch/x86_64/CMakeLists.txt          |  14 ++
 libs/libc/arch/x86_64/syscall.h               | 111 ++++++++++++++
 libs/libc/include/sys/calls.h                 |  12 --
 libs/libc/internal/defines.cpp                |  14 --
 libs/libc/{ => src}/abi/platform.h            |   1 +
 libs/libc/{ => src}/errno/errno.cpp           |   0
 libs/libc/{ => src}/include/assert.h          |   0
 libs/libc/{ => src}/include/assert_base.hpp   |   0
 libs/libc/{ => src}/include/ctype.h           |   0
 libs/libc/{ => src}/include/defines.h         |   5 +-
 libs/libc/{ => src}/include/errno.h           |   0
 libs/libc/{ => src}/include/libssp.h          |   0
 libs/libc/{ => src}/include/math.h            |   0
 libs/libc/{ => src}/include/math/checks.h     |   0
 .../{ => src}/include/math/operations.hpp     |   0
 libs/libc/{ => src}/include/stdio.h           |   0
 libs/libc/{ => src}/include/stdlib.h          |   0
 libs/libc/{ => src}/include/string.h          |   0
 libs/libc/src/include/sys/calls.h             |  49 ++++++
 libs/libc/{ => src}/include/sys/calls/time.h  |   0
 libs/libc/{ => src}/include/sys/time.h        |   0
 libs/libc/{ => src}/include/time.h            |   0
 libs/libc/{ => src}/include/todo.h            |   0
 libs/libc/{ => src}/include/types.h           |   0
 libs/libc/{ => src}/internal/debug.hpp        |   0
 libs/libc/src/internal/libc_backend.cpp       |  19 +++
 .../include => libc/src}/internal/macro.hpp   |  22 +--
 .../libc/{ => src}/internal/time_internal.cpp |   0
 .../libc/{ => src}/internal/time_internal.hpp |   0
 libs/libc/{ => src}/io/snprintf.cpp           |   0
 libs/libc/{ => src}/math/math.cpp             |   0
 libs/libc/{ => src}/memory/memory.cpp         |   0
 libs/libc/{ => src}/string/string.cpp         |   0
 libs/libc/{ => src}/time/asctime.cpp          |   0
 libs/libc/{ => src}/time/ctime.cpp            |   0
 libs/libc/{ => src}/time/gmtime.cpp           |   0
 libs/libc/{ => src}/time/localtime.cpp        |   0
 libs/libc/{ => src}/time/mktime.cpp           |   0
 libs/libc/{ => src}/time/strftime.cpp         |   0
 libs/libc/{ => src}/time/time.cpp             |   0
 libs/libc/{ => src}/time/time_ext.cpp         |   0
 libs/libcpp/CMakeLists.txt                    |   5 +-
 libs/libcpp/include/defines.hpp               |  11 --
 libs/libcpp/include/internal/empty.hpp        |  27 ++++
 libs/libcpp/include/span.hpp                  |   3 +-
 libs/libcpp/include/utility.hpp               |   3 +
 libs/libtemplate/include/template/utils.hpp   |   1 +
 rootfs/CMakeLists.txt                         |   7 +-
 scripts/config/feature_flags_schema.yaml      |  14 ++
 tests/libcpp_mocks/defines.hpp                |   3 +-
 userspace/CMakeLists.txt                      |  35 +++--
 userspace/build/linker.ld                     |   2 +-
 userspace/crt0.nasm                           |  22 ---
 userspace/programs/hello_world/CMakeLists.txt |   3 +
 userspace/programs/hello_world/main.cpp       |  34 ++++-
 84 files changed, 940 insertions(+), 318 deletions(-)
 create mode 100644 cmake/MiscHelpers.cmake
 create mode 100644 kernel/arch/x86_64/src/hal/impl/types.hpp
 create mode 100644 kernel/src/hal/types.hpp
 create mode 100644 kernel/src/syscalls/dispatch_table.hpp
 create mode 100644 kernel/src/syscalls/handler.hpp
 create mode 100644 kernel/src/syscalls/syscalls.cpp
 create mode 100644 kernel/src/syscalls/syscalls.hpp
 create mode 100644 libs/libc/arch/x86_64/CMakeLists.txt
 create mode 100644 libs/libc/arch/x86_64/syscall.h
 delete mode 100644 libs/libc/include/sys/calls.h
 delete mode 100644 libs/libc/internal/defines.cpp
 rename libs/libc/{ => src}/abi/platform.h (92%)
 rename libs/libc/{ => src}/errno/errno.cpp (100%)
 rename libs/libc/{ => src}/include/assert.h (100%)
 rename libs/libc/{ => src}/include/assert_base.hpp (100%)
 rename libs/libc/{ => src}/include/ctype.h (100%)
 rename libs/libc/{ => src}/include/defines.h (93%)
 rename libs/libc/{ => src}/include/errno.h (100%)
 rename libs/libc/{ => src}/include/libssp.h (100%)
 rename libs/libc/{ => src}/include/math.h (100%)
 rename libs/libc/{ => src}/include/math/checks.h (100%)
 rename libs/libc/{ => src}/include/math/operations.hpp (100%)
 rename libs/libc/{ => src}/include/stdio.h (100%)
 rename libs/libc/{ => src}/include/stdlib.h (100%)
 rename libs/libc/{ => src}/include/string.h (100%)
 create mode 100644 libs/libc/src/include/sys/calls.h
 rename libs/libc/{ => src}/include/sys/calls/time.h (100%)
 rename libs/libc/{ => src}/include/sys/time.h (100%)
 rename libs/libc/{ => src}/include/time.h (100%)
 rename libs/libc/{ => src}/include/todo.h (100%)
 rename libs/libc/{ => src}/include/types.h (100%)
 rename libs/libc/{ => src}/internal/debug.hpp (100%)
 create mode 100644 libs/libc/src/internal/libc_backend.cpp
 rename libs/{libcpp/include => libc/src}/internal/macro.hpp (63%)
 rename libs/libc/{ => src}/internal/time_internal.cpp (100%)
 rename libs/libc/{ => src}/internal/time_internal.hpp (100%)
 rename libs/libc/{ => src}/io/snprintf.cpp (100%)
 rename libs/libc/{ => src}/math/math.cpp (100%)
 rename libs/libc/{ => src}/memory/memory.cpp (100%)
 rename libs/libc/{ => src}/string/string.cpp (100%)
 rename libs/libc/{ => src}/time/asctime.cpp (100%)
 rename libs/libc/{ => src}/time/ctime.cpp (100%)
 rename libs/libc/{ => src}/time/gmtime.cpp (100%)
 rename libs/libc/{ => src}/time/localtime.cpp (100%)
 rename libs/libc/{ => src}/time/mktime.cpp (100%)
 rename libs/libc/{ => src}/time/strftime.cpp (100%)
 rename libs/libc/{ => src}/time/time.cpp (100%)
 rename libs/libc/{ => src}/time/time_ext.cpp (100%)
 create mode 100644 libs/libcpp/include/internal/empty.hpp
 delete mode 100644 userspace/crt0.nasm
 create mode 100644 userspace/programs/hello_world/CMakeLists.txt

diff --git a/cmake/MiscHelpers.cmake b/cmake/MiscHelpers.cmake
new file mode 100644
index 00000000..60f91541
--- /dev/null
+++ b/cmake/MiscHelpers.cmake
@@ -0,0 +1,21 @@
+#
+# Miscellaneous CMake helper functions
+#
+
+#===============================================================================
+# alkos_add_subdirs
+#===============================================================================
+# Recursively adds all subdirectories in the given BASE_DIR.
+## Parameters:
+#   BASE_DIR          The base directory to search for subdirectories.
+## Example:
+#   alkos_add_subdirs(${CMAKE_CURRENT_SOURCE_DIR}/modules)
+#
+function(alkos_add_subdirs BASE_DIR)
+    file(GLOB directories RELATIVE "${BASE_DIR}" "${BASE_DIR}/*")
+    foreach(dir ${directories})
+        if(IS_DIRECTORY "${BASE_DIR}/${dir}")
+            add_subdirectory("${BASE_DIR}/${dir}")
+        endif()
+    endforeach()
+endfunction()
diff --git a/cmake/RuntimeHelpers.cmake b/cmake/RuntimeHelpers.cmake
index bf670134..522f193a 100644
--- a/cmake/RuntimeHelpers.cmake
+++ b/cmake/RuntimeHelpers.cmake
@@ -136,7 +136,6 @@ function(register_filesystem)
     set(oneValueArgs
         TYPE
         ROOTFS_TYPE
-        ROOTFS_DIR
         ROOTFS_TARGET_PATH
         ROOTFS_OVERLAY_DIR
         MODULE
@@ -149,7 +148,7 @@ function(register_filesystem)
     alkos_ensure_called_once(NAME ${CMAKE_CURRENT_FUNCTION})
 
     alkos_ensure_defined(
-        VARS ARG_TYPE ARG_ROOTFS_TYPE ARG_ROOTFS_DIR ARG_ROOTFS_TARGET_PATH ARG_ROOTFS_OVERLAY_DIR
+        VARS ARG_TYPE ARG_ROOTFS_TYPE ARG_ROOTFS_TARGET_PATH ARG_ROOTFS_OVERLAY_DIR
     )
 
     # Resolve target defaults and feature flags
@@ -163,7 +162,6 @@ function(register_filesystem)
     endif()
 
     # Export variables for the rootfs maker
-    alkos_add_to_bash_config("CONF_ROOTFS_DIR" "${ARG_ROOTFS_DIR}")
     alkos_add_to_bash_config("CONF_ROOTFS_TARGET_PATH" "${ARG_ROOTFS_TARGET_PATH}")
     alkos_add_to_bash_config("CONF_ROOTFS_OVERLAY_DIR" "${ARG_ROOTFS_OVERLAY_DIR}")
 
@@ -179,6 +177,11 @@ function(register_filesystem)
     alkos_ensure_path_exists(PATHS ${MAKE_ROOTFS_SCRIPT_PATH})
 
     add_custom_target(rootfs
+            # Ensure the staging directory is clean before building the rootfs.
+            # Remove the directory and recreate it so the generator starts from
+            # an empty staging area.
+            COMMAND ${CMAKE_COMMAND} -E rm -rf "${ROOTFS_DIR}"
+            COMMAND ${CMAKE_COMMAND} -E make_directory "${ROOTFS_DIR}"
             COMMAND ${MAKE_ROOTFS_SCRIPT_PATH} -v -- ${ARG_ROOTFS_TYPE}
             WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
             COMMENT "Building root filesystem"
diff --git a/kernel/arch/x86_64/CMakeLists.txt b/kernel/arch/x86_64/CMakeLists.txt
index 370b1df9..9015dd3d 100644
--- a/kernel/arch/x86_64/CMakeLists.txt
+++ b/kernel/arch/x86_64/CMakeLists.txt
@@ -58,9 +58,9 @@ alkos_register_runtime_environment(
     QEMU_COMMAND
         "qemu-system-x86_64"
     QEMU_NORMAL_FLAGS
-        "-serial stdio -enable-kvm -cpu max -display default,show-cursor=on -k en-us -m 4G -smp sockets=1,cores=4,threads=1 -no-reboot"
+        "-serial stdio -enable-kvm -cpu max -machine type=q35,accel=kvm -display default,show-cursor=on -k en-us -m 4G -smp sockets=1,cores=4,threads=1"
     QEMU_TEST_FLAGS
-        "-serial stdio -enable-kvm -cpu max -display none -m 4G -smp sockets=1,cores=4,threads=1 -no-reboot"
+        "-serial stdio -enable-kvm -cpu max -machine type=q35,accel=kvm -display none -m 4G -smp sockets=1,cores=4,threads=1 -no-reboot"
     MODULES
         alkos.boot.loader.64
         alkos.kernel
diff --git a/kernel/arch/x86_64/boot/lib/sys/libc_backend.cpp b/kernel/arch/x86_64/boot/lib/sys/libc_backend.cpp
index c5cc87f2..011ce98c 100644
--- a/kernel/arch/x86_64/boot/lib/sys/libc_backend.cpp
+++ b/kernel/arch/x86_64/boot/lib/sys/libc_backend.cpp
@@ -16,42 +16,9 @@ void __platform_panic(const char *msg)
     OsHang();
 }
 
-void __platform_get_clock_value(ClockType /*type*/, TimeVal *time, Timezone *time_zone)
-{
-    if (time != nullptr) {
-        time->seconds   = 0;
-        time->remainder = 0;
-    }
-
-    if (time_zone != nullptr) {
-        time_zone->west_offset_minutes     = 0;
-        time_zone->dst_time_offset_minutes = 0;
-        time_zone->dst_time_start_seconds  = 0;
-        time_zone->dst_time_end_seconds    = 0;
-    }
-}
-
-u64 __platform_get_clock_ticks_in_second(ClockType /*type*/) { return 1; }
-
-void __platform_get_timezone(Timezone *time_zone)
-{
-    if (time_zone != nullptr) {
-        time_zone->west_offset_minutes     = 0;
-        time_zone->dst_time_offset_minutes = 0;
-        time_zone->dst_time_start_seconds  = 0;
-        time_zone->dst_time_end_seconds    = 0;
-    }
-}
-
 void __platform_debug_write(const char *buffer)
 {
     if constexpr (FeatureEnabled<FeatureFlag::kDebugOutput>) {
         QemuTerminalWriteString(buffer);
     }
 }
-
-size_t __platform_debug_read_line(char * /*buffer*/, size_t /*buffer_size*/)
-{
-    /* Not implemented in loader */
-    return 0;
-}
diff --git a/kernel/arch/x86_64/src/cpu/utils.hpp b/kernel/arch/x86_64/src/cpu/utils.hpp
index 6fc01238..2f3fd3b7 100644
--- a/kernel/arch/x86_64/src/cpu/utils.hpp
+++ b/kernel/arch/x86_64/src/cpu/utils.hpp
@@ -75,12 +75,12 @@ FAST_CALL void OsHangNoInterrupts()
 template <const u8 idx>
 FAST_CALL void InvokeInterrupt()
 {
-    __asm__ volatile("int %0" : : "N"(idx));
+    __asm__ volatile("int %0" : : "N"(static_cast<size_t>(idx)));
 }
 
 FAST_CALL void InvokeInterruptDynamic(const u8 idx)
 {
-    template_lib::RolledSwitch<u8, 64, 1>(
+    template_lib::RolledSwitch<u8, 255, 1>(
         []<const u64 idx> {
             return InvokeInterrupt<idx>();
         },
diff --git a/kernel/arch/x86_64/src/hal/impl/interrupts.cpp b/kernel/arch/x86_64/src/hal/impl/interrupts.cpp
index 7db36b0a..844d9566 100644
--- a/kernel/arch/x86_64/src/hal/impl/interrupts.cpp
+++ b/kernel/arch/x86_64/src/hal/impl/interrupts.cpp
@@ -132,7 +132,7 @@ void Interrupts::MapToLogicalInterrupts_()
     HardwareModule::Get()
         .GetInterrupts()
         .GetLit()
-        .MapLogicalInterruptToHw<intr::InterruptType::kSoftwareInterrupt>(0, 48);
+        .MapLogicalInterruptToHw<intr::InterruptType::kSoftwareInterrupt>(0, 129);
 }
 
 void Interrupts::SetupPicAsDefaultDriver_()
diff --git a/kernel/arch/x86_64/src/hal/impl/interrupts.hpp b/kernel/arch/x86_64/src/hal/impl/interrupts.hpp
index cb168f45..1ed2d890 100644
--- a/kernel/arch/x86_64/src/hal/impl/interrupts.hpp
+++ b/kernel/arch/x86_64/src/hal/impl/interrupts.hpp
@@ -16,8 +16,8 @@
 
 namespace arch
 {
-// TODO: In reality IDT has size of 256, but currently only 48 isrs are defined
-static constexpr size_t kMaxInterruptsSupported = 48;
+// TODO: In reality IDT has size of 256, but currently only 144 isrs are defined
+static constexpr size_t kMaxInterruptsSupported = 144;
 class Interrupts : public InterruptsAPI
 {
     TODO_WHEN_VMEM_WORKS
diff --git a/kernel/arch/x86_64/src/hal/impl/types.hpp b/kernel/arch/x86_64/src/hal/impl/types.hpp
new file mode 100644
index 00000000..21245078
--- /dev/null
+++ b/kernel/arch/x86_64/src/hal/impl/types.hpp
@@ -0,0 +1,11 @@
+#ifndef KERNEL_ARCH_X86_64_SRC_HAL_IMPL_TYPES_HPP_
+#define KERNEL_ARCH_X86_64_SRC_HAL_IMPL_TYPES_HPP_
+
+#include <types.hpp>
+
+namespace arch
+{
+using reg_t = u64;
+}  // namespace arch
+
+#endif  // KERNEL_ARCH_X86_64_SRC_HAL_IMPL_TYPES_HPP_
diff --git a/kernel/arch/x86_64/src/include/regs.nasm b/kernel/arch/x86_64/src/include/regs.nasm
index b4878045..0bfb8670 100644
--- a/kernel/arch/x86_64/src/include/regs.nasm
+++ b/kernel/arch/x86_64/src/include/regs.nasm
@@ -39,6 +39,18 @@ _shadow_space equ 8*4
     mov qword [rsp + _rbp], rbp
 %endmacro
 
+%macro push_sysv_regs_without_rax 0
+    mov qword [rsp + _rcx], rcx
+    mov qword [rsp + _rdx], rdx
+    mov qword [rsp + _rsi], rsi
+    mov qword [rsp + _rdi], rdi
+    mov qword [rsp + _r8], r8
+    mov qword [rsp + _r9], r9
+    mov qword [rsp + _r10], r10
+    mov qword [rsp + _r11], r11
+    mov qword [rsp + _rbp], rbp
+%endmacro
+
 ; Macro to restore all volatile registers (SysV ABI) from the stack.
 %macro pop_sysv_regs 0
     mov rax, qword [rsp + _rax]
@@ -53,6 +65,18 @@ _shadow_space equ 8*4
     mov rbp, qword [rsp + _rbp]
 %endmacro
 
+%macro pop_sysv_regs_without_rax 0
+    mov rcx, qword [rsp + _rcx]
+    mov rdx, qword [rsp + _rdx]
+    mov rsi, qword [rsp + _rsi]
+    mov rdi, qword [rsp + _rdi]
+    mov r8, qword [rsp + _r8]
+    mov r9, qword [rsp + _r9]
+    mov r10, qword [rsp + _r10]
+    mov r11, qword [rsp + _r11]
+    mov rbp, qword [rsp + _rbp]
+%endmacro
+
 ; Size needed to save the registers on the stack
 _all_reg_size equ 8*15
 
diff --git a/kernel/arch/x86_64/src/interrupts/idt.cpp b/kernel/arch/x86_64/src/interrupts/idt.cpp
index 1f89eeac..60ec55ff 100644
--- a/kernel/arch/x86_64/src/interrupts/idt.cpp
+++ b/kernel/arch/x86_64/src/interrupts/idt.cpp
@@ -15,7 +15,7 @@
 
 #include "trace_framework.hpp"
 
-static constexpr u32 kStubTableSize = 64;
+static constexpr u32 kStubTableSize = 144;
 
 /**
  * Flags for ISRs (Interrupt Service Routines):
@@ -25,8 +25,21 @@ static constexpr u32 kStubTableSize = 64;
  *   that can access this interrupt via the INT instruction. Hardware interrupts ignore this.
  * - Bit 7: Present bit (must be set to 1 for the descriptor to be valid).
  */
-static constexpr u8 kTrapFlags      = 0x8F;
-static constexpr u8 kInterruptFlags = 0x8E;
+static constexpr IdtEntryFlags kTrapFlags = {
+    .type = IdtGateType::k64BitTrapGate, .zero = 0, .dpl = IdtPrivilegeLevel::kRing0, .present = 1
+};
+static constexpr IdtEntryFlags kInterruptFlags = {
+    .type    = IdtGateType::k64BitInterruptGate,
+    .zero    = 0,
+    .dpl     = IdtPrivilegeLevel::kRing0,
+    .present = 1
+};
+static constexpr IdtEntryFlags kSyscallFlags = {
+    .type    = IdtGateType::k64BitInterruptGate,
+    .zero    = 0,
+    .dpl     = IdtPrivilegeLevel::kRing3,
+    .present = 1
+};
 
 /* gdt kernel code offset */
 extern "C" u32 kKernelCodeOffset;
@@ -176,7 +189,7 @@ const char *GetExceptionMsg(const u8 exc_idx)
     return nullptr;
 }
 
-static void IdtSetDescriptor(Idt &idt, const u8 idx, const u64 isr, const u8 flags)
+static void IdtSetDescriptor(Idt &idt, const u8 idx, const u64 isr, const IdtEntryFlags flags)
 {
     IdtEntry &entry = idt.idt[idx];
 
@@ -204,6 +217,11 @@ void arch::Interrupts::InitializeDefaultIdt_()
         );
     }
 
+    // Set syscall interrupt
+    IdtSetDescriptor(
+        idt_, kSyscallVector, reinterpret_cast<u64>(IsrWrapperTable[kSyscallVector]), kSyscallFlags
+    );
+
     /* load the new IDT */
     __asm__ volatile("lidt %0" : : "m"(idt_.idtr));
 
diff --git a/kernel/arch/x86_64/src/interrupts/idt.hpp b/kernel/arch/x86_64/src/interrupts/idt.hpp
index f95435d3..a76e3e33 100644
--- a/kernel/arch/x86_64/src/interrupts/idt.hpp
+++ b/kernel/arch/x86_64/src/interrupts/idt.hpp
@@ -14,6 +14,7 @@ static constexpr u32 kIdtEntries = 256;
 static constexpr u16 kIrq1Offset     = 0x20; /* Start for hardware interrupts */
 static constexpr u16 kIrq2Offset     = 0x28;
 static constexpr u16 kSpuriousVector = 0xFF; /* Spurious interrupt vector */
+static constexpr u16 kSyscallVector  = 0x80; /* Syscall interrupt vector */
 
 static constexpr u8 kExceptionIdx[]{0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15,
                                     16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31};
@@ -64,6 +65,27 @@ static_assert(
 // Data layout
 // ------------------------------
 
+enum class IdtGateType : u8 {
+    k16BitTaskGate      = 0x5,
+    k16BitInterruptGate = 0x6,
+    k16BitTrapGate      = 0x7,
+    k32BitTaskGate      = 0x9,
+    k32BitInterruptGate = 0xA,
+    k32BitTrapGate      = 0xB,
+    k64BitInterruptGate = 0xE,
+    k64BitTrapGate      = 0xF,
+};
+
+enum class IdtPrivilegeLevel : u8 { kRing0 = 0, kRing1 = 1, kRing2 = 2, kRing3 = 3 };
+
+struct PACK IdtEntryFlags {
+    IdtGateType type : 4;
+    u8 zero : 1;
+    IdtPrivilegeLevel dpl : 2;
+    u8 present : 1;
+};
+static_assert(sizeof(IdtEntryFlags) == 1, "IdtEntryFlags size must be 1 byte");
+
 /**
  * @brief Data layout of x86_64 interrupt service routines, refer to intel manual for details
  */
@@ -71,11 +93,11 @@ struct PACK IdtEntry {
     u16 isr_low;    // The lower 16 bits of the ISR's address
     u16 kernel_cs;  // The GDT segment selector that the CPU will load into CS before calling the
     // ISR
-    u8 ist;         // The IST in the TSS that the CPU will load into RSP; set to zero for now
-    u8 attributes;  // Type and attributes; see the IDT page
-    u16 isr_mid;    // The higher 16 bits of the lower 32 bits of the ISR's address
-    u32 isr_high;   // The higher 32 bits of the ISR's address
-    u32 reserved;   // Set to zero
+    u8 ist;  // The IST in the TSS that the CPU will load into RSP; set to zero for now
+    IdtEntryFlags attributes;  // Type and attributes; see the IDT page
+    u16 isr_mid;               // The higher 16 bits of the lower 32 bits of the ISR's address
+    u32 isr_high;              // The higher 32 bits of the ISR's address
+    u32 reserved;              // Set to zero
 };
 
 /**
@@ -102,7 +124,6 @@ const char *GetExceptionMsg(u8 idx);
 void DefaultInterruptHandler(u8 idt_idx);
 void DefaultExceptionHandler(intr::LitExcEntry &entry, hal::ExceptionData *data);
 void SimpleIrqHandler(intr::LitHwEntry &entry);
-void TestIsr(intr::LitSwEntry &entry);
 void TimerIsr(intr::LitHwEntry &entry);
 
 #endif  // KERNEL_ARCH_X86_64_SRC_INTERRUPTS_IDT_HPP_
diff --git a/kernel/arch/x86_64/src/interrupts/idt.nasm b/kernel/arch/x86_64/src/interrupts/idt.nasm
index f77b9db3..5d35dcea 100644
--- a/kernel/arch/x86_64/src/interrupts/idt.nasm
+++ b/kernel/arch/x86_64/src/interrupts/idt.nasm
@@ -58,18 +58,57 @@ isr_wrapper_%+%2:
     iretq                       ; Return from interrupt.
 %endmacro
 
+bits 64
+section .text
+
 ; ------------------------------
-; ISR wrappers definitions
+; Syscall wrapper definitions
 ; ------------------------------
 
-bits 64
+extern g_syscall_dispatch_table
+extern g_syscall_count
+
+; Expected system call convention:
+; - RAX: syscall number
+; - RDI: arg0
+; - RSI: arg1
+; - RDX: arg2
+; - R10: arg3
+; - R8:  arg4
+; - R9:  arg5
+; - Return value: RAX
+isr_wrapper_128:  ; Syscall interrupt (128)
+    sub rsp, _sysv_reg_size          ; Allocate space for saving registers.
+    push_sysv_regs_without_rax       ; Save registers except RAX.
+    cld                              ; Clear direction flag for string operations.
+
+    ; Syscall to Sys V ABI conversion
+    mov rcx, r10
+
+    ; Check syscall number bounds
+    cmp rax, [rel g_syscall_count]
+    jae .invalid_syscall
+
+    ; Get pointer to syscall_dispatch_table and dispatch
+    call qword [rel g_syscall_dispatch_table + rax*8]
+    jmp .return
+
+.invalid_syscall:
+    mov rax, -1                      ; Set error return value
+
+.return:
+    pop_sysv_regs_without_rax        ; Restore registers except RAX.
+    add rsp, _sysv_reg_size          ; Deallocate register save space.
+    iretq                            ; Return from interrupt.
+
+; ------------------------------
+; ISR wrappers definitions
+; ------------------------------
 
 extern HandleException
 extern HandleHardwareInterrupt
 extern HandleSoftwareInterrupt
 
-section .text
-
 ; Intel-defined interrupts (0-31) -> HandleException
 exception_wrapper 0  ; Division Error: Divide by zero error
 exception_wrapper 1  ; Debug: Reserved for debugging exceptions
@@ -122,28 +161,36 @@ interrupt_wrapper 13, 45, HandleHardwareInterrupt ; IRQ13: FPU (legacy)
 interrupt_wrapper 14, 46, HandleHardwareInterrupt ; IRQ14: Primary ATA channel
 interrupt_wrapper 15, 47, HandleHardwareInterrupt ; IRQ15: Secondary ATA channel
 
+; IRQs for APICs and other devices (48–127) -> HandleHardwareInterrupt
+%assign idt_num 48
+%assign irq_num 16
+%rep 127-48+1
+    interrupt_wrapper irq_num, idt_num, HandleHardwareInterrupt
+%assign idt_num idt_num + 1
+%assign irq_num irq_num + 1
+%endrep
 
-; Software interrupts (48–63) -> HandleSoftwareInterrupt
-interrupt_wrapper 0, 48, HandleSoftwareInterrupt
-interrupt_wrapper 1, 49, HandleSoftwareInterrupt
-interrupt_wrapper 2, 50, HandleSoftwareInterrupt
-interrupt_wrapper 3, 51, HandleSoftwareInterrupt
-interrupt_wrapper 4, 52, HandleSoftwareInterrupt
-interrupt_wrapper 5, 53, HandleSoftwareInterrupt
-interrupt_wrapper 6, 54, HandleSoftwareInterrupt
-interrupt_wrapper 7, 55, HandleSoftwareInterrupt
-interrupt_wrapper 8, 56, HandleSoftwareInterrupt
-interrupt_wrapper 9, 57, HandleSoftwareInterrupt
-interrupt_wrapper 10, 58, HandleSoftwareInterrupt
-interrupt_wrapper 11, 59, HandleSoftwareInterrupt
-interrupt_wrapper 12, 60, HandleSoftwareInterrupt
-interrupt_wrapper 13, 61, HandleSoftwareInterrupt
-interrupt_wrapper 14, 62, HandleSoftwareInterrupt
-interrupt_wrapper 15, 63, HandleSoftwareInterrupt
+; Software interrupts (128–143) -> HandleSoftwareInterrupt
+; interrupt_wrapper 0, 128, HandleSoftwareInterrupt ; Syscall handled separately above
+interrupt_wrapper 0, 129, HandleSoftwareInterrupt
+interrupt_wrapper 1, 130, HandleSoftwareInterrupt
+interrupt_wrapper 2, 131, HandleSoftwareInterrupt
+interrupt_wrapper 3, 132, HandleSoftwareInterrupt
+interrupt_wrapper 4, 133, HandleSoftwareInterrupt
+interrupt_wrapper 5, 134, HandleSoftwareInterrupt
+interrupt_wrapper 6, 135, HandleSoftwareInterrupt
+interrupt_wrapper 7, 136, HandleSoftwareInterrupt
+interrupt_wrapper 8, 137, HandleSoftwareInterrupt
+interrupt_wrapper 9, 138, HandleSoftwareInterrupt
+interrupt_wrapper 10, 139, HandleSoftwareInterrupt
+interrupt_wrapper 11, 140, HandleSoftwareInterrupt
+interrupt_wrapper 12, 141, HandleSoftwareInterrupt
+interrupt_wrapper 13, 142, HandleSoftwareInterrupt
+interrupt_wrapper 14, 143, HandleSoftwareInterrupt
 
 
 ; Total number of ISRs.
-_num_isrs equ 64
+_num_isrs equ 144
 
 ; ----------------------------------
 ; ISR wrapper table definition
diff --git a/kernel/src/acpi/acpi.cpp b/kernel/src/acpi/acpi.cpp
index 401c6131..ff1a5dcf 100644
--- a/kernel/src/acpi/acpi.cpp
+++ b/kernel/src/acpi/acpi.cpp
@@ -3,52 +3,46 @@
 #include <internal/formats.hpp>
 #include "trace_framework.hpp"
 
-/* External includes */
 #include <uacpi/event.h>
 #include <uacpi/uacpi.h>
 
-int ACPI::ACPIController::Init(const BootArguments &args)
+void ACPI::ACPIController::EarlyInit(const BootArguments &args)
 {
     TODO_WHEN_VMEM_WORKS
-    DEBUG_INFO_GENERAL("ACPI initialization...");
+    DEBUG_INFO_ACPI("Early ACPI initialization...");
 
-    DEBUG_INFO_GENERAL("Getting RSDP from boot arguments...");
+    DEBUG_INFO_ACPI("Getting RSDP from boot arguments...");
     R_ASSERT_NOT_NULL(
         args.rsdp,
         "RSDP address not provided in boot arguments, only platforms with ACPI supported..."
     );
 
     RsdpAddress_ = args.rsdp;
-    DEBUG_INFO_GENERAL("RSDP address: 0x%016p", RsdpAddress_);
+    DEBUG_INFO_ACPI("RSDP address: 0x%016p", RsdpAddress_);
 
     /* Load all tables, bring the event subsystem online, and enter ACPI mode */
     uacpi_status ret = uacpi_initialize(0);
     R_ASSERT_ACPI_SUCCESS(ret, "uacpi_initialize error: %s", uacpi_status_to_string(ret));
+}
 
-    // TODO: When OSL finished
-    // /* Load the AML namespace */
-    // ret = uacpi_namespace_load();
-    // if (uacpi_unlikely_error(ret)) {
-    //     TRACE_ERROR("uacpi_namespace_load error: %s", uacpi_status_to_string(ret));
-    //     return -1;
-    // }
-    //
-    // /* Initialize the namespace */
-    // ret = uacpi_namespace_initialize();
-    // if (uacpi_unlikely_error(ret)) {
-    //     TRACE_ERROR("uacpi_namespace_initialize error: %s", uacpi_status_to_string(ret));
-    //     return -1;
-    // }
-    //
-    // /*
-    //  * Tell uACPI that we have marked all GPEs we wanted for wake. This is needed to
-    //  * let uACPI enable all unmarked GPEs that have a corresponding AML handler.
-    //  */
-    // ret = uacpi_finalize_gpe_initialization();
-    // if (uacpi_unlikely_error(ret)) {
-    //     TRACE_ERROR("uACPI GPE initialization error: %s", uacpi_status_to_string(ret));
-    //     return -1;
-    // }
-
-    return 0;
+void ACPI::ACPIController::Init()
+{
+    DEBUG_INFO_ACPI("Full ACPI initialization...");
+
+    /* Load the AML namespace */
+    uacpi_status ret = uacpi_namespace_load();
+    R_ASSERT_ACPI_SUCCESS(ret, "uacpi_namespace_load error: %s", uacpi_status_to_string(ret));
+
+    /* Initialize the namespace */
+    ret = uacpi_namespace_initialize();
+    R_ASSERT_ACPI_SUCCESS(ret, "uacpi_namespace_initialize error: %s", uacpi_status_to_string(ret));
+
+    /*
+     * Tell uACPI that we have marked all GPEs we wanted for wake. This is needed to
+     * let uACPI enable all unmarked GPEs that have a corresponding AML handler.
+     */
+    ret = uacpi_finalize_gpe_initialization();
+    R_ASSERT_ACPI_SUCCESS(
+        ret, "uacpi_finalize_gpe_initialization error: %s", uacpi_status_to_string(ret)
+    );
 }
diff --git a/kernel/src/acpi/acpi.hpp b/kernel/src/acpi/acpi.hpp
index c3615e12..bd170df4 100644
--- a/kernel/src/acpi/acpi.hpp
+++ b/kernel/src/acpi/acpi.hpp
@@ -43,10 +43,15 @@ class ACPIController final : public hal::AcpiController
     // ------------------------------
 
     /**
-     * @brief Initialize the ACPI subsystem.
-     * @return Status code
+     * @brief Early initialize the ACPI subsystem.
+     * @param args Boot arguments passed from the bootloader.
      */
-    int Init(const BootArguments &args);
+    void EarlyInit(const BootArguments &args);
+
+    /**
+     * @brief Fully initialize the ACPI subsystem.
+     */
+    void Init();
 
     /**
      * @brief Deinitialize the ACPI subsystem.
diff --git a/kernel/src/acpi/acpi_power.cpp b/kernel/src/acpi/acpi_power.cpp
index 6b43c183..7d8ff95b 100644
--- a/kernel/src/acpi/acpi_power.cpp
+++ b/kernel/src/acpi/acpi_power.cpp
@@ -1,6 +1,5 @@
 #include <acpi/acpi_power.hpp>
 
-#include <todo.hpp>
 #include "hal/panic.hpp"
 #include "trace_framework.hpp"
 
@@ -19,7 +18,7 @@ bool ACPI::SystemShutdown()
      */
     uacpi_status ret = uacpi_prepare_for_sleep_state(UACPI_SLEEP_STATE_S5);
     if (uacpi_unlikely_error(ret)) {
-        TRACE_FATAL_GENERAL("failed to prepare for sleep: %s", uacpi_status_to_string(ret));
+        TRACE_FATAL_ACPI("Failed to prepare for sleep: %s", uacpi_status_to_string(ret));
         return false;
     }
 
@@ -37,13 +36,13 @@ bool ACPI::SystemShutdown()
      */
     ret = uacpi_enter_sleep_state(UACPI_SLEEP_STATE_S5);
     if (uacpi_unlikely_error(ret)) {
-        TRACE_FATAL_GENERAL("failed to enter sleep: %s", uacpi_status_to_string(ret));
+        TRACE_FATAL_ACPI("Failed to enter sleep: %s", uacpi_status_to_string(ret));
         EnableHardwareInterrupts();
         return false;
     }
 
     hal::KernelPanic("Shutdown failed");
-    return false;
+    __builtin_unreachable();
 }
 
 bool ACPI::SystemReboot()
@@ -54,10 +53,9 @@ bool ACPI::SystemReboot()
      * some work to fetch the \_S5 and \_S0 values to make system wake
      * possible later on.
      */
-    TODO_WHEN_VMEM_WORKS
     uacpi_status ret = uacpi_prepare_for_sleep_state(UACPI_SLEEP_STATE_S5);
     if (uacpi_unlikely_error(ret)) {
-        TRACE_FATAL_GENERAL("failed to prepare for sleep: %s", uacpi_status_to_string(ret));
+        TRACE_FATAL_ACPI("Failed to prepare for sleep: %s", uacpi_status_to_string(ret));
         return false;
     }
 
@@ -70,11 +68,11 @@ bool ACPI::SystemReboot()
     /* Attempt to reboot via ACPI */
     ret = uacpi_reboot();
     if (uacpi_unlikely_error(ret)) {
-        TRACE_FATAL_GENERAL("failed to reboot: %s", uacpi_status_to_string(ret));
+        TRACE_FATAL_ACPI("Failed to reboot: %s", uacpi_status_to_string(ret));
         EnableHardwareInterrupts();
         return false;
     }
 
     hal::KernelPanic("Reboot failed");
-    return false;
+    __builtin_unreachable();
 }
diff --git a/kernel/src/acpi/osl.cpp b/kernel/src/acpi/osl.cpp
index 3ae035d2..0816a562 100644
--- a/kernel/src/acpi/osl.cpp
+++ b/kernel/src/acpi/osl.cpp
@@ -129,19 +129,19 @@ void uacpi_kernel_log(uacpi_log_level level, const uacpi_char *log)
 {
     switch (level) {
         case UACPI_LOG_ERROR:
-            TRACE_FATAL_GENERAL(log);
+            TRACE_FATAL_ACPI(log);
             break;
         case UACPI_LOG_WARN:
-            TRACE_WARN_GENERAL(log);
+            TRACE_WARN_ACPI(log);
             break;
         case UACPI_LOG_INFO:
-            TRACE_INFO_GENERAL(log);
+            TRACE_INFO_ACPI(log);
             break;
         case UACPI_LOG_DEBUG:
-            DEBUG_INFO_GENERAL(log);
+            DEBUG_INFO_ACPI(log);
             break;
         case UACPI_LOG_TRACE:
-            TRACE_INFO_GENERAL(log);
+            TRACE_INFO_ACPI(log);
             break;
     }
 }
@@ -158,13 +158,26 @@ void uacpi_kernel_stall(uacpi_u8 usec) { (void)usec; }
 
 void uacpi_kernel_sleep(uacpi_u64 msec) { (void)msec; }
 
-uacpi_handle uacpi_kernel_create_event() { return nullptr; }
+// TODO: Replace with real event implementation
+struct uacpi_event_internal {
+};
+
+uacpi_handle uacpi_kernel_create_event()
+{
+    static uacpi_event_internal event;
+    return &event;
+}
 
 void uacpi_kernel_free_event(uacpi_handle) {}
 
 uacpi_thread_id uacpi_kernel_get_thread_id() { return nullptr; }
 
-uacpi_bool uacpi_kernel_wait_for_event(uacpi_handle, uacpi_u16) { return UACPI_FALSE; }
+uacpi_bool uacpi_kernel_wait_for_event(uacpi_handle event, uacpi_u16 timeout_msec)
+{
+    (void)event;
+    (void)timeout_msec;
+    return UACPI_FALSE;
+}
 
 void uacpi_kernel_signal_event(uacpi_handle) {}
 
@@ -191,7 +204,7 @@ uacpi_status uacpi_kernel_install_interrupt_handler(
     uacpi_handle *out_irq_handle
 )
 {
-    DEBUG_INFO_BOOT(
+    DEBUG_INFO_ACPI(
         "Installing uacpi irq: %u with handler: %p", irq, reinterpret_cast<void *>(uacpi_handler)
     );
 
diff --git a/kernel/src/hal/types.hpp b/kernel/src/hal/types.hpp
new file mode 100644
index 00000000..5f85ce9e
--- /dev/null
+++ b/kernel/src/hal/types.hpp
@@ -0,0 +1,11 @@
+#ifndef KERNEL_SRC_HAL_TYPES_HPP_
+#define KERNEL_SRC_HAL_TYPES_HPP_
+
+#include "hal/impl/types.hpp"
+
+namespace hal
+{
+using reg_t = arch::reg_t;
+}  // namespace hal
+
+#endif  // KERNEL_SRC_HAL_TYPES_HPP_
diff --git a/kernel/src/init.cpp b/kernel/src/init.cpp
index 6007fc42..c7507a1c 100644
--- a/kernel/src/init.cpp
+++ b/kernel/src/init.cpp
@@ -36,8 +36,8 @@ void KernelInit(const hal::RawBootArguments &raw_args)
     /* Initialize the global state module */
     GlobalStateModule::Init();
 
-    /* Initialize ACPI */
-    HardwareModule::Get().GetACPIController().Init(args);
+    /* Early Initialize ACPI subsystem for table parsing */
+    HardwareModule::Get().GetACPIController().EarlyInit(args);
 
     /* Extract all necessary data from ACPI tables */
     HardwareModule::Get().GetACPIController().ParseTables();
@@ -45,12 +45,14 @@ void KernelInit(const hal::RawBootArguments &raw_args)
     /* Allow hardware to fully initialise interrupt system */
     HardwareModule::Get().GetInterrupts().Init();
 
-    /* Initialize the timing system */
     TimingModule::Init();
 
-    // Register Interrupts
+    /* Register interrupt handlers */
     HardwareModule::Get().RegisterInterruptHandlers();
 
+    /* Fully Initialize ACPI subsystem */
+    // HardwareModule::Get().GetACPIController().Init();
+
     SchedulingModule::Init();
     SchedulingModule::Get().GetTaskMgr().InitializeMultitasking();
 
diff --git a/kernel/src/libc_backend.cpp b/kernel/src/libc_backend.cpp
index 97bdc7d9..4ecaa8c0 100644
--- a/kernel/src/libc_backend.cpp
+++ b/kernel/src/libc_backend.cpp
@@ -1,4 +1,5 @@
 /// This file provides the kernel's implementation of the libc platform ABI.
+#ifdef __ALKOS_KERNEL__
 #include <assert.h>
 #include <platform.h>
 
@@ -7,74 +8,31 @@
 #include "hal/spinlock.hpp"
 #include "modules/timing.hpp"
 #include "modules/timing_constants.hpp"
+#include "syscalls/syscalls.hpp"
 
-void __platform_panic(const char *msg)
-{
-    hal::KernelPanic(msg);
-    __builtin_unreachable();
-}
+using namespace Syscall;
+
+void __platform_panic(const char *msg) { SysPanic(msg); }
 
 void __platform_get_clock_value(const ClockType type, TimeVal *time, Timezone *time_zone)
 {
-    ASSERT_NOT_NULL(time);
-    ASSERT_NOT_NULL(time_zone);
-
-    if (!TimingModule::IsInited()) {
-        if (time != nullptr) {
-            time->seconds   = 0;
-            time->remainder = 0;
-        }
-        return;
-    }
-
-    if (time_zone != nullptr) {
-        __platform_get_timezone(time_zone);
-    }
-
-    if (time != nullptr) {
-        switch (type) {
-            case kTimeUtc: {
-                time->seconds   = TimingModule::Get().GetSystemTime().Read();
-                time->remainder = 0;
-            } break;
-            case kProcTime: {  // In microseconds
-                time->seconds   = 0;
-                time->remainder = timing::SystemTime::ReadLifeTimeNs() / 1000;
-            } break;
-            case kProcTimePrecise: {  // In nanoseconds
-                time->seconds   = 0;
-                time->remainder = timing::SystemTime::ReadLifeTimeNs();
-            } break;
-            default:
-                R_FAIL_ALWAYS("Provided invalid ClockType!");
-        }
-    }
+    SysGetClockValue(type, time, time_zone);
 }
 
 u64 __platform_get_clock_ticks_in_second(const ClockType type)
 {
-    const auto idx = static_cast<size_t>(type);
-    ASSERT(idx != 0 && idx < timing_constants::kClockTicksInSecondSize);
-
-    TODO_USERSPACE
-    //    if (idx == 0 || idx >= kResoSize) {
-    //        return 0;
-    //    }
-
-    return timing_constants::kClockTicksInSecond[idx];
+    return SysGetClockTicksInSecond(type);
 }
 
-void __platform_get_timezone(Timezone *time_zone)
-{
-    ASSERT_NOT_NULL(time_zone);
-
-    ASSERT_TRUE(TimingModule::IsInited(), "Timing module is not initialized");
-    *time_zone = TimingModule::Get().GetSystemTime().GetTimezone();
-}
+void __platform_get_timezone(Timezone *time_zone) { SysGetTimezone(time_zone); }
 
-void __platform_debug_write(const char *buffer) { DEBUG_INFO_GENERAL(buffer); }
+void __platform_debug_write(const char *buffer) { SysDebugWrite(buffer); }
 
 size_t __platform_debug_read_line(char *buffer, const size_t buffer_size)
 {
-    return hal::DebugTerminalReadLine(buffer, buffer_size);
+    return SysDebugReadLine(buffer, buffer_size);
 }
+
+void __platform_write_console(const char *buffer) { SysWriteConsole(buffer); }
+
+#endif
diff --git a/kernel/src/sys/shell.cpp b/kernel/src/sys/shell.cpp
index 2ebb186f..ef3eaf52 100644
--- a/kernel/src/sys/shell.cpp
+++ b/kernel/src/sys/shell.cpp
@@ -3,35 +3,18 @@
 #include <string.h>
 #include <string.hpp>
 
+#include "acpi/acpi_power.hpp"
 #include "modules/memory.hpp"
 #include "modules/vfs.hpp"
 #include "sys/loader.hpp"
-#include "vfs/path.hpp"
-
-// !!! TEMPORARY !!!
-using UserEntry = void (*)(void (*)(const char *));
-
-// Static pointer to the active console for the callback
-static System::GraphicsConsole *g_active_console = nullptr;
-
-extern "C" void KernelPrintHelper(const char *msg)
-{
-    if (g_active_console) {
-        g_active_console->Write(
-            std::span<const byte>(reinterpret_cast<const byte *>(msg), strlen(msg))
-        );
-    } else {
-        // Fallback or ignore
-    }
-}
-
-// !!! TEMPORARY !!!
 
 namespace System
 {
 
+GraphicsConsole *g_active_console = nullptr;
+
 Shell::Shell(GraphicsConsole &console, IO::IReader &input_reader)
-    : console_(console), input_reader_(input_reader), current_dir_(vfs::Path::kRoot)
+    : console_(console), input_reader_(input_reader)
 {
     // !!! TEMPORARY !!!
     g_active_console = &console_;
@@ -119,6 +102,10 @@ void Shell::ProcessCommand()
         CmdExec(cmd.substr(2));
     } else if (cmd == "exec") {
         CmdExec(args);
+    } else if (cmd == "shutdown") {
+        ACPI::SystemShutdown();
+    } else if (cmd == "reboot") {
+        ACPI::SystemReboot();
     } else {
         console_.Write(
             std::span<const byte>(reinterpret_cast<const byte *>("Unknown command: "), 17)
@@ -142,7 +129,9 @@ void Shell::CmdHelp()
         "  ls [path]   - List directory contents\n"
         "  cat <file>  - Display file contents\n"
         "  exec <file> - Execute a user program\n"
-        "  ./<file>    - Execute a user program\n";
+        "  ./<file>    - Execute a user program\n"
+        "  shutdown    - Shutdown the system\n"
+        "  reboot      - Reboot the system\n";
     console_.Write(std::span<const byte>(reinterpret_cast<const byte *>(msg), strlen(msg)));
 }
 
@@ -358,14 +347,14 @@ void Shell::CmdExec(std::string_view args)
 
     if (entry_res) {
         Mem::VPtr<void> entry_addr = entry_res.value();
-        auto user_main             = reinterpret_cast<UserEntry>(entry_addr);
+        auto user_main             = reinterpret_cast<void (*)()>(entry_addr);
 
         console_.Write(
             std::span<const byte>(reinterpret_cast<const byte *>("Executing user program...\n"), 26)
         );
 
         // Execute the program
-        user_main(&KernelPrintHelper);
+        user_main();
 
         console_.Write(
             std::span<const byte>(reinterpret_cast<const byte *>("User program returned.\n"), 23)
diff --git a/kernel/src/sys/shell.hpp b/kernel/src/sys/shell.hpp
index 669aa380..2b5db9ae 100644
--- a/kernel/src/sys/shell.hpp
+++ b/kernel/src/sys/shell.hpp
@@ -12,6 +12,8 @@
 namespace System
 {
 
+extern GraphicsConsole *g_active_console;
+
 // --------------------------------------------------------------------------------
 // Shell
 // --------------------------------------------------------------------------------
@@ -70,7 +72,7 @@ class Shell
     // Data
     GraphicsConsole &console_;
     IO::IReader &input_reader_;
-    vfs::Path current_dir_;
+    vfs::Path current_dir_{vfs::Path::kRoot};
 
     static constexpr size_t kMaxInput = 128;
     data_structures::StaticVector<char, kMaxInput> input_buffer_;
diff --git a/kernel/src/syscalls/dispatch_table.hpp b/kernel/src/syscalls/dispatch_table.hpp
new file mode 100644
index 00000000..62c654f3
--- /dev/null
+++ b/kernel/src/syscalls/dispatch_table.hpp
@@ -0,0 +1,44 @@
+#ifndef KERNEL_SRC_SYSCALLS_DISPATCH_TABLE_HPP_
+#define KERNEL_SRC_SYSCALLS_DISPATCH_TABLE_HPP_
+
+#include <sys/calls.h>
+#include <defines.hpp>
+
+#include "hal/types.hpp"
+#include "syscalls/handler.hpp"
+
+namespace Syscall
+{
+
+inline constexpr auto kNotImplemented = static_cast<hal::reg_t>(-1);
+
+struct SyscallDispatchTable {
+    consteval SyscallDispatchTable()
+    {
+        for (size_t i = 0; i < kSysMax; ++i) {
+            handlers_[i] = kDefaultHandler;
+        }
+    }
+
+    // Register a syscall handler at compile time
+    template <SyscallNumber num, auto kHandler>
+    consteval void RegisterHandler()
+    {
+        constexpr auto kIdx = static_cast<size_t>(num);
+        static_assert(kIdx < kSysMax, "Syscall number out of bounds");
+
+        handlers_[kIdx] = &SyscallWrapper<kHandler>::Invoke;
+    }
+
+    private:
+    static constexpr auto kDefaultHandler = [](hal::reg_t, hal::reg_t, hal::reg_t, hal::reg_t,
+                                               hal::reg_t, hal::reg_t) -> hal::reg_t {
+        return kNotImplemented;
+    };
+
+    SyscallHandler handlers_[kSysMax];
+};
+
+}  // namespace Syscall
+
+#endif  // KERNEL_SRC_SYSCALLS_DISPATCH_TABLE_HPP_
diff --git a/kernel/src/syscalls/handler.hpp b/kernel/src/syscalls/handler.hpp
new file mode 100644
index 00000000..7d22dec2
--- /dev/null
+++ b/kernel/src/syscalls/handler.hpp
@@ -0,0 +1,98 @@
+#ifndef KERNEL_SRC_SYSCALLS_HANDLER_HPP_
+#define KERNEL_SRC_SYSCALLS_HANDLER_HPP_
+
+#include <type_traits.hpp>
+#include <types.hpp>
+#include <utility.hpp>
+
+#include "hal/types.hpp"
+
+namespace Syscall
+{
+
+// Forward declaration
+struct SyscallArgs;
+
+// Base handler type
+using SyscallHandler =
+    hal::reg_t (*)(hal::reg_t, hal::reg_t, hal::reg_t, hal::reg_t, hal::reg_t, hal::reg_t);
+
+// Syscall argument structure
+struct SyscallArgs {
+    hal::reg_t arg0, arg1, arg2, arg3, arg4, arg5;
+};
+
+template <typename T>
+concept SyscallRetType = std::is_integral_v<T> || std::is_pointer_v<T> || std::is_same_v<T, void>;
+
+template <typename T>
+concept SyscallArgType = std::is_integral_v<T> || std::is_pointer_v<T> || std::is_enum_v<T>;
+
+template <auto TargetFunc>
+class SyscallWrapper
+{
+    public:
+    static hal::reg_t Invoke(
+        hal::reg_t a0, hal::reg_t a1, hal::reg_t a2, hal::reg_t a3, hal::reg_t a4, hal::reg_t a5
+    )
+    {
+        SyscallArgs args{a0, a1, a2, a3, a4, a5};
+        return DeduceAndDispatch(args, TargetFunc);
+    }
+
+    private:
+    // Argument Extraction and Conversion
+    template <size_t Idx>
+    static hal::reg_t GetRawArg(const SyscallArgs &args)
+    {
+        static constexpr hal::reg_t SyscallArgs::*members[] = {
+            &SyscallArgs::arg0, &SyscallArgs::arg1, &SyscallArgs::arg2,
+            &SyscallArgs::arg3, &SyscallArgs::arg4, &SyscallArgs::arg5
+        };
+        static_assert(Idx < (sizeof(members) / sizeof(members[0])), "Syscall index out of bounds");
+        return args.*(members[Idx]);
+    }
+
+    template <typename T>
+    static T ConvertArg(hal::reg_t val)
+    {
+        if constexpr (std::is_pointer_v<T>)
+            return reinterpret_cast<T>(val);
+        else
+            return static_cast<T>(val);
+    }
+
+    // Dispatcher
+    template <typename Ret, typename Seq, typename... Args>
+    struct Dispatch;
+
+    template <typename Ret, size_t... Is, typename... Args>
+    struct Dispatch<Ret, std::index_sequence<Is...>, Args...> {
+        static hal::reg_t operator()(const SyscallArgs &args)
+        {
+            if constexpr (std::is_void_v<Ret>) {
+                TargetFunc(ConvertArg<Args>(GetRawArg<Is>(args))...);
+                return 0;
+            } else {
+                auto result = TargetFunc(ConvertArg<Args>(GetRawArg<Is>(args))...);
+
+                if constexpr (std::is_pointer_v<Ret>)
+                    return reinterpret_cast<hal::reg_t>(result);
+                else
+                    return static_cast<hal::reg_t>(result);
+            }
+        }
+    };
+
+    // Type Deduction Helper
+    template <typename Ret, typename... Args>
+        requires SyscallRetType<Ret> && (SyscallArgType<Args> && ...)
+    static hal::reg_t DeduceAndDispatch(const SyscallArgs &args, Ret (*)(Args...))
+    {
+        return Dispatch<Ret, std::index_sequence_for<Args...>, Args...>::operator()(args);
+    }
+};
+
+}  // namespace Syscall
+
+#endif  // KERNEL_SRC_SYSCALLS_HANDLER_HPP_
diff --git a/kernel/src/syscalls/syscalls.cpp b/kernel/src/syscalls/syscalls.cpp
new file mode 100644
index 00000000..85d6ab25
--- /dev/null
+++ b/kernel/src/syscalls/syscalls.cpp
@@ -0,0 +1,29 @@
+#include "syscalls.hpp"
+
+#include <sys/calls.h>
+
+using namespace Syscall;
+
+BEGIN_DECL_C
+
+size_t g_syscall_count                                  = kSysMax;
+constinit SyscallDispatchTable g_syscall_dispatch_table = []() consteval {
+    SyscallDispatchTable table{};
+
+    // Time related syscalls
+    table.RegisterHandler<kSysGetClockValue, SysGetClockValue>();
+    table.RegisterHandler<kSysGetTimezone, SysGetTimezone>();
+    table.RegisterHandler<kSysGetClockTicksInSecond, SysGetClockTicksInSecond>();
+
+    // Debug IO syscalls
+    table.RegisterHandler<kSysDebugWrite, SysDebugWrite>();
+    table.RegisterHandler<kSysDebugReadLine, SysDebugReadLine>();
+    table.RegisterHandler<kSysWriteConsole, SysWriteConsole>();
+
+    // Panic syscall
+    table.RegisterHandler<kSysPanic, SysPanic>();
+
+    return table;
+}();
+
+END_DECL_C
diff --git a/kernel/src/syscalls/syscalls.hpp b/kernel/src/syscalls/syscalls.hpp
new file mode 100644
index 00000000..4ec0706d
--- /dev/null
+++ b/kernel/src/syscalls/syscalls.hpp
@@ -0,0 +1,144 @@
+#ifndef KERNEL_SRC_SYSCALLS_SYSCALLS_HPP_
+#define KERNEL_SRC_SYSCALLS_SYSCALLS_HPP_
+
+#include <defines.h>
+#include <sys/time.h>
+#include <types.hpp>
+
+#include "dispatch_table.hpp"
+#include "hal/debug_terminal.hpp"
+#include "hal/panic.hpp"
+#include "modules/timing.hpp"
+#include "modules/timing_constants.hpp"
+
+#include <span.hpp>
+#include <sys/shell.hpp>
+
+namespace Syscall
+{
+
+// ------------------------------
+// Panic Syscall
+// ------------------------------
+
+/**
+ * @brief Trigger a kernel panic with a message
+ * @param msg Panic message
+ */
+NO_RET FORCE_INLINE_F void SysPanic(const char *msg)
+{
+    hal::KernelPanic(msg);
+    __builtin_unreachable();
+}
+
+// ------------------------------
+// Time Syscalls
+// ------------------------------
+
+/**
+ * @brief Get clock value
+ * @param type Clock type to query
+ * @param time Output time value
+ * @param time_zone Output timezone
+ */
+FORCE_INLINE_F void SysGetClockValue(ClockType type, TimeVal *time, Timezone *time_zone)
+{
+    ASSERT_NOT_NULL(time);
+    ASSERT_NOT_NULL(time_zone);
+
+    if (!TimingModule::IsInited()) {
+        if (time != nullptr) {
+            time->seconds   = 0;
+            time->remainder = 0;
+        }
+        return;
+    }
+
+    if (time_zone != nullptr) {
+        __platform_get_timezone(time_zone);
+    }
+
+    if (time != nullptr) {
+        switch (type) {
+            case kTimeUtc: {
+                time->seconds   = TimingModule::Get().GetSystemTime().Read();
+                time->remainder = 0;
+            } break;
+            case kProcTime: {  // In microseconds
+                time->seconds   = 0;
+                time->remainder = timing::SystemTime::ReadLifeTimeNs() / 1000;
+            } break;
+            case kProcTimePrecise: {  // In nanoseconds
+                time->seconds   = 0;
+                time->remainder = timing::SystemTime::ReadLifeTimeNs();
+            } break;
+            default:
+                R_FAIL_ALWAYS("Provided invalid ClockType!");
+        }
+    }
+}
+
+/**
+ * @brief Get timezone information
+ * @param time_zone Output timezone
+ */
+FORCE_INLINE_F void SysGetTimezone(Timezone *time_zone)
+{
+    ASSERT_NOT_NULL(time_zone);
+
+    ASSERT_TRUE(TimingModule::IsInited(), "Timing module is not initialized");
+    *time_zone = TimingModule::Get().GetSystemTime().GetTimezone();
+}
+
+/**
+ * @brief Get clock ticks per second for a given clock type
+ * @param type Clock type
+ * @return Ticks per second
+ */
+FORCE_INLINE_F u64 SysGetClockTicksInSecond(ClockType type)
+{
+    const auto idx = static_cast<size_t>(type);
+    ASSERT(idx != 0 && idx < timing_constants::kClockTicksInSecondSize);
+
+    TODO_USERSPACE
+    //    if (idx == 0 || idx >= kResoSize) {
+    //        return 0;
+    //    }
+
+    return timing_constants::kClockTicksInSecond[idx];
+}
+
+// ------------------------------
+// Debug IO Syscalls
+// ------------------------------
+
+/**
+ * @brief Write string to debug output
+ * @param buffer String to write (null-terminated)
+ */
+FORCE_INLINE_F void SysDebugWrite(const char *buffer) { DEBUG_INFO_GENERAL(buffer); }
+
+/**
+ * @brief Read line from debug input
+ * @param buffer Buffer to store input
+ * @param buffer_size Size of buffer
+ * @return Number of characters read
+ */
+FORCE_INLINE_F u64 SysDebugReadLine(char *buffer, size_t buffer_size)
+{
+    return hal::DebugTerminalReadLine(buffer, buffer_size);
+}
+
+// !!! TEMPORARY !!!
+FORCE_INLINE_F void SysWriteConsole(const char *buffer)
+{
+    if (System::g_active_console) {
+        System::g_active_console->Write(
+            std::span<const byte>(reinterpret_cast<const byte *>(buffer), strlen(buffer))
+        );
+    }
+}
+
+}  // namespace Syscall
+
+#endif  // KERNEL_SRC_SYSCALLS_SYSCALLS_HPP_
diff --git a/kernel/src/trace.cpp b/kernel/src/trace.cpp
index 820dace6..46a137ea 100644
--- a/kernel/src/trace.cpp
+++ b/kernel/src/trace.cpp
@@ -46,6 +46,7 @@ static struct TraceFramework {
             rv[static_cast<size_t>(TraceModule::kVfs)]        = "VFSModule";
             rv[static_cast<size_t>(TraceModule::kVideo)]      = "VideoModule";
             rv[static_cast<size_t>(TraceModule::kHardware)]   = "HardwareModule";
+            rv[static_cast<size_t>(TraceModule::kAcpi)]       = "ACPIModule";
             rv[static_cast<size_t>(TraceModule::kScheduling)] = "SchedulingModule";
 
             return rv;
diff --git a/kernel/src/trace_framework.hpp b/kernel/src/trace_framework.hpp
index 5dfaabad..a8303c88 100644
--- a/kernel/src/trace_framework.hpp
+++ b/kernel/src/trace_framework.hpp
@@ -45,6 +45,7 @@ enum class TraceModule {
     kVfs,
     kVideo,
     kHardware,
+    kAcpi,
     kScheduling,
     kLast,
 };
@@ -121,6 +122,10 @@ CREATE_TRACE_HELPERS(kVideo, VIDEO)
 CREATE_DEBUG_HELPERS(kHardware, HARDWARE)
 CREATE_TRACE_HELPERS(kHardware, HARDWARE)
 
+// ACPI
+CREATE_DEBUG_HELPERS(kAcpi, ACPI)
+CREATE_TRACE_HELPERS(kAcpi, ACPI)
+
 // SCHEDULING
 CREATE_DEBUG_HELPERS(kScheduling, SCHEDULING)
 CREATE_TRACE_HELPERS(kScheduling, SCHEDULING)
diff --git a/kernel/thirdparty/CMakeLists.txt b/kernel/thirdparty/CMakeLists.txt
index 74bc4233..bd1a54c5 100644
--- a/kernel/thirdparty/CMakeLists.txt
+++ b/kernel/thirdparty/CMakeLists.txt
@@ -1,12 +1,8 @@
 message(STATUS "  -> Adding third-party libraries...")
 include(FetchContent)
+include(MiscHelpers)
 
 add_library(alkos.kernel.thirdparty INTERFACE)
 
 # Iterate over all dependencies and add them to the thirdparty library
-file(GLOB directories RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
-foreach(dir ${directories})
-    if(IS_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/${dir})
-        add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/${dir})
-    endif()
-endforeach()
+alkos_add_subdirs(${CMAKE_CURRENT_SOURCE_DIR})
diff --git a/libs/libc/CMakeLists.txt b/libs/libc/CMakeLists.txt
index 4b9eb92b..0cc81232 100644
--- a/libs/libc/CMakeLists.txt
+++ b/libs/libc/CMakeLists.txt
@@ -18,8 +18,8 @@ set(ALKOS_LIBC_SOURCES ${ALKOS_LIBC_SOURCES} CACHE INTERNAL "Source files for li
 add_library(alkos.libc.interface INTERFACE)
 
 target_include_directories(alkos.libc.interface INTERFACE
-    "${CMAKE_CURRENT_SOURCE_DIR}/include"
-    "${CMAKE_CURRENT_SOURCE_DIR}/abi"
+    "${CMAKE_CURRENT_SOURCE_DIR}/src/include"
+    "${CMAKE_CURRENT_SOURCE_DIR}/src/abi"
 
     # At the time of their making, both libc and libcpp were in the same directory
     # Decoupling them now brings too little benefit and too much complexity to justify the effort
@@ -27,10 +27,12 @@ target_include_directories(alkos.libc.interface INTERFACE
 )
 
 target_include_directories(alkos.libc.interface INTERFACE
-    "${CMAKE_CURRENT_SOURCE_DIR}/internal"
+    "${CMAKE_CURRENT_SOURCE_DIR}/src/internal"
 )
 
 target_link_libraries(alkos.libc.interface INTERFACE
     alkos.libcpp.interface
     alkos.autogen.interface
 )
+
+add_subdirectory(arch/${ARCH})
diff --git a/libs/libc/arch/x86_64/CMakeLists.txt b/libs/libc/arch/x86_64/CMakeLists.txt
new file mode 100644
index 00000000..7ccf4a72
--- /dev/null
+++ b/libs/libc/arch/x86_64/CMakeLists.txt
@@ -0,0 +1,14 @@
+message(STATUS "  -> Configuring for x86_64")
+
+############################### Adding Sources ###############################
+
+alkos_target_sources(alkos.libc.interface
+  SOURCES
+    "${CMAKE_CURRENT_SOURCE_DIR}/*.c"
+    "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp"
+    "${CMAKE_CURRENT_SOURCE_DIR}/*.nasm"
+)
+
+target_include_directories(alkos.libc.interface INTERFACE
+    ${CMAKE_CURRENT_SOURCE_DIR}
+)
diff --git a/libs/libc/arch/x86_64/syscall.h b/libs/libc/arch/x86_64/syscall.h
new file mode 100644
index 00000000..71abff3c
--- /dev/null
+++ b/libs/libc/arch/x86_64/syscall.h
@@ -0,0 +1,111 @@
+#ifndef LIBS_LIBC_ARCH_X86_64_SYSCALL_H_
+#define LIBS_LIBC_ARCH_X86_64_SYSCALL_H_
+
+#include "defines.h"
+#include "macro.hpp"
+#include "types.hpp"
+
+/**
+ * @file syscall.h
+ * @brief Userspace syscall interface for x86_64
+ *
+ * This header provides inline assembly wrappers for making system calls.
+ * On x86_64, we use the int 0x80 instruction with the following convention:
+ * - RAX: syscall number
+ * - RDI: arg0
+ * - RSI: arg1
+ * - RDX: arg2
+ * - R10: arg3
+ * - R8:  arg4
+ * - R9:  arg5
+ * - Return value: RAX
+ */
+
+#define syscall0(num)                                                                             \
+    ({                                                                                            \
+        size_t __ret;                                                                             \
+        __asm__ volatile("int    $0x80\n\t" : "=a"(__ret) : "0"((size_t)(num)) : "memory", "cc"); \
+        __ret;                                                                                    \
+    })
+
+#define syscall1(num, arg0)                                        \
+    ({                                                             \
+        size_t __ret;                                              \
+        __asm__ volatile("int    $0x80\n\t"                        \
+                         : "=a"(__ret)                             \
+                         : "0"((size_t)(num)), "D"((size_t)(arg0)) \
+                         : "memory", "cc");                        \
+        __ret;                                                     \
+    })
+
+#define syscall2(num, arg0, arg1)                                                       \
+    ({                                                                                  \
+        size_t __ret;                                                                   \
+        __asm__ volatile("int    $0x80\n\t"                                             \
+                         : "=a"(__ret)                                                  \
+                         : "0"((size_t)(num)), "D"((size_t)(arg0)), "S"((size_t)(arg1)) \
+                         : "memory", "cc");                                             \
+        __ret;                                                                          \
+    })
+
+#define syscall3(num, arg0, arg1, arg2)                                                  \
+    ({                                                                                   \
+        size_t __ret;                                                                    \
+        __asm__ volatile("int    $0x80\n\t"                                              \
+                         : "=a"(__ret)                                                   \
+                         : "0"((size_t)(num)), "D"((size_t)(arg0)), "S"((size_t)(arg1)), \
+                           "d"((size_t)(arg2))                                           \
+                         : "memory", "cc");                                              \
+        __ret;                                                                           \
+    })
+
+#define syscall4(num, arg0, arg1, arg2, arg3)                                            \
+    ({                                                                                   \
+        size_t __ret;                                                                    \
+        register size_t __r10 asm("r10") = (size_t)(arg3);                               \
+        __asm__ volatile("int    $0x80\n\t"                                              \
+                         : "=a"(__ret)                                                   \
+                         : "0"((size_t)(num)), "D"((size_t)(arg0)), "S"((size_t)(arg1)), \
+                           "d"((size_t)(arg2)), "r"(__r10)                               \
+                         : "memory", "cc");                                              \
+        __ret;                                                                           \
+    })
+
+#define syscall5(num, arg0, arg1, arg2, arg3, arg4)                                      \
+    ({                                                                                   \
+        size_t __ret;                                                                    \
+        register size_t __r10 asm("r10") = (size_t)(arg3);                               \
+        register size_t __r8 asm("r8")   = (size_t)(arg4);                               \
+        __asm__ volatile("int    $0x80\n\t"                                              \
+                         : "=a"(__ret)                                                   \
+                         : "0"((size_t)(num)), "D"((size_t)(arg0)), "S"((size_t)(arg1)), \
+                           "d"((size_t)(arg2)), "r"(__r10), "r"(__r8)                    \
+                         : "memory", "cc");                                              \
+        __ret;                                                                           \
+    })
+
+#define syscall6(num, arg0, arg1, arg2, arg3, arg4, arg5)                                \
+    ({                                                                                   \
+        size_t __ret;                                                                    \
+        register size_t __r10 asm("r10") = (size_t)(arg3);                               \
+        register size_t __r8 asm("r8")   = (size_t)(arg4);                               \
+        register size_t __r9 asm("r9")   = (size_t)(arg5);                               \
+        __asm__ volatile("int    $0x80\n\t"                                              \
+                         : "=a"(__ret)                                                   \
+                         : "0"((size_t)(num)), "D"((size_t)(arg0)), "S"((size_t)(arg1)), \
+                           "d"((size_t)(arg2)), "r"(__r10), "r"(__r8), "r"(__r9)         \
+                         : "memory", "cc");                                              \
+        __ret;                                                                           \
+    })
+
+#define _SYSCALL_PP_NARG(...)                             _SYSCALL_PP_NARG_(__VA_ARGS__ __VA_OPT__(, ) _SYSCALL_PP_RSEQ_N())
+#define _SYSCALL_PP_NARG_(...)                            _SYSCALL_PP_ARG_N(__VA_ARGS__)
+#define _SYSCALL_PP_ARG_N(_1, _2, _3, _4, _5, _6, N, ...) N
+#define _SYSCALL_PP_RSEQ_N()                              6, 5, 4, 3, 2, 1, 0
+
+#define _SYSCALL_DISPATCH_(n, ...) CONCAT(syscall, n)(__VA_ARGS__)
+
+#define _SYSCALL_DISPATCH(num, ...) \
+    _SYSCALL_DISPATCH_(_SYSCALL_PP_NARG(__VA_ARGS__), num __VA_OPT__(, ) __VA_ARGS__)
+
+#endif  // LIBS_LIBC_ARCH_X86_64_SYSCALL_H_
diff --git a/libs/libc/include/sys/calls.h b/libs/libc/include/sys/calls.h
deleted file mode 100644
index 1c4285ff..00000000
--- a/libs/libc/include/sys/calls.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#ifndef LIBS_LIBC_INCLUDE_SYS_CALLS_H_
-#define LIBS_LIBC_INCLUDE_SYS_CALLS_H_
-
-/**
- * @brief This file collects all the system calls that are used by the libc.
- *
- * Calls should be specified in other header files and then included here.
- */
-
-#include <sys/calls/time.h>
-
-#endif  // LIBS_LIBC_INCLUDE_SYS_CALLS_H_
diff --git a/libs/libc/internal/defines.cpp b/libs/libc/internal/defines.cpp
deleted file mode 100644
index 06021804..00000000
--- a/libs/libc/internal/defines.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#include <compare.hpp>
-#include <defines.hpp>
-
-template <size_t ID, size_t OtherID>
-constexpr bool operator==(empty_t<ID>, empty_t<OtherID>) noexcept
-{
-    return true;
-}
-
-template <size_t ID, size_t OtherID>
-constexpr std::strong_ordering operator<=>(empty_t<ID>, empty_t<OtherID>) noexcept
-{
-    return std::strong_ordering::equal;
-}
diff --git a/libs/libc/abi/platform.h b/libs/libc/src/abi/platform.h
similarity index 92%
rename from libs/libc/abi/platform.h
rename to libs/libc/src/abi/platform.h
index 716e82ce..3d732684 100644
--- a/libs/libc/abi/platform.h
+++ b/libs/libc/src/abi/platform.h
@@ -18,6 +18,7 @@ void __platform_get_timezone(Timezone *time_zone);
 // Debug IO
 void __platform_debug_write(const char *buffer);
 size_t __platform_debug_read_line(char *buffer, size_t buffer_size);
+void __platform_write_console(const char *buffer);
 
 END_DECL_C
 
diff --git a/libs/libc/errno/errno.cpp b/libs/libc/src/errno/errno.cpp
similarity index 100%
rename from libs/libc/errno/errno.cpp
rename to libs/libc/src/errno/errno.cpp
diff --git a/libs/libc/include/assert.h b/libs/libc/src/include/assert.h
similarity index 100%
rename from libs/libc/include/assert.h
rename to libs/libc/src/include/assert.h
diff --git a/libs/libc/include/assert_base.hpp b/libs/libc/src/include/assert_base.hpp
similarity index 100%
rename from libs/libc/include/assert_base.hpp
rename to libs/libc/src/include/assert_base.hpp
diff --git a/libs/libc/include/ctype.h b/libs/libc/src/include/ctype.h
similarity index 100%
rename from libs/libc/include/ctype.h
rename to libs/libc/src/include/ctype.h
diff --git a/libs/libc/include/defines.h b/libs/libc/src/include/defines.h
similarity index 93%
rename from libs/libc/include/defines.h
rename to libs/libc/src/include/defines.h
index de6fa2c3..5521ff28 100644
--- a/libs/libc/include/defines.h
+++ b/libs/libc/src/include/defines.h
@@ -45,6 +45,9 @@ static constexpr bool kIsKernel = false;
 /* Marks a function or variable as unused */
 #define UNUSED __attribute__((unused))
 
+/* Marks a function as naked (no prologue/epilogue) */
+#define NAKED __attribute__((naked))
+
 // ------------------------------
 // Useful macros
 // ------------------------------
@@ -62,7 +65,7 @@ static constexpr bool kIsKernel = false;
 #define CONCAT(a, b) CONCAT_IMPL(a, b)
 
 /* Creates a COMPILER LEVEL memory barrier forcing optimizer to not re-order memory accesses */
-#define BARRIER() __asm__ volatile("" : : : "memory")
+#define COMPILER_FENCE __asm__ volatile("" : : : "memory");
 
 /* Create reserved structure member */
 #define RESERVED(size) byte CONCAT(__reserved_, __COUNTER__)[size] UNUSED
diff --git a/libs/libc/include/errno.h b/libs/libc/src/include/errno.h
similarity index 100%
rename from libs/libc/include/errno.h
rename to libs/libc/src/include/errno.h
diff --git a/libs/libc/include/libssp.h b/libs/libc/src/include/libssp.h
similarity index 100%
rename from libs/libc/include/libssp.h
rename to libs/libc/src/include/libssp.h
diff --git a/libs/libc/include/math.h b/libs/libc/src/include/math.h
similarity index 100%
rename from libs/libc/include/math.h
rename to libs/libc/src/include/math.h
diff --git a/libs/libc/include/math/checks.h b/libs/libc/src/include/math/checks.h
similarity index 100%
rename from libs/libc/include/math/checks.h
rename to libs/libc/src/include/math/checks.h
diff --git a/libs/libc/include/math/operations.hpp b/libs/libc/src/include/math/operations.hpp
similarity index 100%
rename from libs/libc/include/math/operations.hpp
rename to libs/libc/src/include/math/operations.hpp
diff --git a/libs/libc/include/stdio.h b/libs/libc/src/include/stdio.h
similarity index 100%
rename from libs/libc/include/stdio.h
rename to libs/libc/src/include/stdio.h
diff --git a/libs/libc/include/stdlib.h b/libs/libc/src/include/stdlib.h
similarity index 100%
rename from libs/libc/include/stdlib.h
rename to libs/libc/src/include/stdlib.h
diff --git a/libs/libc/include/string.h b/libs/libc/src/include/string.h
similarity index 100%
rename from libs/libc/include/string.h
rename to libs/libc/src/include/string.h
diff --git a/libs/libc/src/include/sys/calls.h b/libs/libc/src/include/sys/calls.h
new file mode 100644
index 00000000..88c31628
--- /dev/null
+++ b/libs/libc/src/include/sys/calls.h
@@ -0,0 +1,49 @@
+#ifndef LIBS_LIBC_SRC_INCLUDE_SYS_CALLS_H_
+#define LIBS_LIBC_SRC_INCLUDE_SYS_CALLS_H_
+
+#include "macro.hpp"
+#include "syscall.h"
+
+/**
+ * @brief Syscall numbers
+ *
+ * This is the single source of truth for syscall numbers.
+ */
+enum SyscallNumber {
+    /* Time related syscalls */
+    kSysGetClockValue = 0,
+    kSysGetClockTicksInSecond,
+    kSysGetTimezone,
+
+    /* Debug IO */
+    kSysDebugWrite,
+    kSysDebugReadLine,
+    kSysWriteConsole,
+
+    /* Panic/Program termination */
+    kSysPanic,
+
+    kSysMax,
+};
+
+#define DEFINE_SYSCALL(name, num, ret_type, ...)                                             \
+    ret_type __platform_##name(FOR_EACH_PAIR(MERGE, __VA_ARGS__))                            \
+    {                                                                                        \
+        return (ret_type)_SYSCALL_DISPATCH(num, FOR_EACH_PAIR(GET_SECOND_ARG, __VA_ARGS__)); \
+    }
+
+#define DEFINE_SYSCALL_VOID(name, num, ...)                                       \
+    void __platform_##name(FOR_EACH_PAIR(MERGE, __VA_ARGS__))                     \
+    {                                                                             \
+        (void)_SYSCALL_DISPATCH(num, FOR_EACH_PAIR(GET_SECOND_ARG, __VA_ARGS__)); \
+    }
+
+/**
+ * @brief This file collects all the system calls that are used by the libc.
+ *
+ * Calls should be specified in other header files and then included here.
+ */
+
+#include <sys/calls/time.h>
+
+#endif  // LIBS_LIBC_SRC_INCLUDE_SYS_CALLS_H_
diff --git a/libs/libc/include/sys/calls/time.h b/libs/libc/src/include/sys/calls/time.h
similarity index 100%
rename from libs/libc/include/sys/calls/time.h
rename to libs/libc/src/include/sys/calls/time.h
diff --git a/libs/libc/include/sys/time.h b/libs/libc/src/include/sys/time.h
similarity index 100%
rename from libs/libc/include/sys/time.h
rename to libs/libc/src/include/sys/time.h
diff --git a/libs/libc/include/time.h b/libs/libc/src/include/time.h
similarity index 100%
rename from libs/libc/include/time.h
rename to libs/libc/src/include/time.h
diff --git a/libs/libc/include/todo.h b/libs/libc/src/include/todo.h
similarity index 100%
rename from libs/libc/include/todo.h
rename to libs/libc/src/include/todo.h
diff --git a/libs/libc/include/types.h b/libs/libc/src/include/types.h
similarity index 100%
rename from libs/libc/include/types.h
rename to libs/libc/src/include/types.h
diff --git a/libs/libc/internal/debug.hpp b/libs/libc/src/internal/debug.hpp
similarity index 100%
rename from libs/libc/internal/debug.hpp
rename to libs/libc/src/internal/debug.hpp
diff --git a/libs/libc/src/internal/libc_backend.cpp b/libs/libc/src/internal/libc_backend.cpp
new file mode 100644
index 00000000..63ecc380
--- /dev/null
+++ b/libs/libc/src/internal/libc_backend.cpp
@@ -0,0 +1,19 @@
+#ifndef __ALKOS_KERNEL__
+
+#include "platform.h"
+#include "sys/calls.h"
+
+DEFINE_SYSCALL_VOID(
+    get_clock_value, kSysGetClockValue, const ClockType, type, TimeVal *, time, Timezone *,
+    time_zone
+)
+DEFINE_SYSCALL(get_clock_ticks_in_second, kSysGetClockTicksInSecond, u64, const ClockType, type)
+DEFINE_SYSCALL_VOID(get_timezone, kSysGetTimezone, Timezone *, time_zone)
+
+DEFINE_SYSCALL_VOID(debug_write, kSysDebugWrite, const char *, buffer)
+DEFINE_SYSCALL(debug_read_line, kSysDebugReadLine, size_t, char *, buff, size_t, size)
+DEFINE_SYSCALL_VOID(write_console, kSysWriteConsole, const char *, buffer)
+
+DEFINE_SYSCALL_VOID(panic, kSysPanic, const char *, msg)
+
+#endif  // __ALKOS_KERNEL__
diff --git a/libs/libcpp/include/internal/macro.hpp b/libs/libc/src/internal/macro.hpp
similarity index 63%
rename from libs/libcpp/include/internal/macro.hpp
rename to libs/libc/src/internal/macro.hpp
index b82385cd..86abb687 100644
--- a/libs/libcpp/include/internal/macro.hpp
+++ b/libs/libc/src/internal/macro.hpp
@@ -1,5 +1,5 @@
-#ifndef LIBS_LIBCPP_INCLUDE_INTERNAL_MACRO_HPP_
-#define LIBS_LIBCPP_INCLUDE_INTERNAL_MACRO_HPP_
+#ifndef LIBS_LIBC_INTERNAL_MACRO_HPP_
+#define LIBS_LIBC_INTERNAL_MACRO_HPP_
 
 // https://www.scs.stanford.edu/~dm/blog/va-opt.html
 #define PARENS      ()
@@ -14,24 +14,28 @@
 
 #define FOR_EACH(macro, ...) __VA_OPT__(EXPAND(FOR_EACH_HELPER(macro, __VA_ARGS__)))
 #define FOR_EACH_HELPER(macro, a1, ...) \
-    macro(a1) __VA_OPT__(, FOR_EACH_AGAIN PARENS(macro, __VA_ARGS__))
+macro(a1) __VA_OPT__(, FOR_EACH_AGAIN PARENS(macro, __VA_ARGS__))
 #define FOR_EACH_AGAIN() FOR_EACH_HELPER
 
 #define FOR_EACH_PAIR_SEP(sep, macro, ...) \
-    __VA_OPT__(EXPAND(FOR_EACH_PAIR_SEP_HELPER(sep, macro, __VA_ARGS__)))
+__VA_OPT__(EXPAND(FOR_EACH_PAIR_SEP_HELPER(sep, macro, __VA_ARGS__)))
 #define FOR_EACH_PAIR_SEP_HELPER(sep, macro, a1, a2, ...) \
-    macro(a1, a2) __VA_OPT__(sep PARENS FOR_EACH_PAIR_SEP_AGAIN PARENS(sep, macro, __VA_ARGS__))
+macro(a1, a2) __VA_OPT__(sep PARENS FOR_EACH_PAIR_SEP_AGAIN PARENS(sep, macro, __VA_ARGS__))
 #define FOR_EACH_PAIR_SEP_AGAIN() FOR_EACH_PAIR_SEP_HELPER
 
 #define FOR_EACH_PAIR(macro, ...) FOR_EACH_PAIR_SEP(COMMA, macro, __VA_ARGS__)
 
 #define FOR_EACH_PAIR_CTX_SEP(sep, macro, ctx, ...) \
-    __VA_OPT__(EXPAND(FOR_EACH_PAIR_CTX_SEP_HELPER(sep, macro, ctx, __VA_ARGS__)))
+__VA_OPT__(EXPAND(FOR_EACH_PAIR_CTX_SEP_HELPER(sep, macro, ctx, __VA_ARGS__)))
 #define FOR_EACH_PAIR_CTX_SEP_HELPER(sep, macro, ctx, a1, a2, ...) \
-    macro(ctx, a1, a2)                                             \
-        __VA_OPT__(sep PARENS FOR_EACH_PAIR_CTX_SEP_AGAIN PARENS(sep, macro, ctx, __VA_ARGS__))
+macro(ctx, a1, a2)                                             \
+__VA_OPT__(sep PARENS FOR_EACH_PAIR_CTX_SEP_AGAIN PARENS(sep, macro, ctx, __VA_ARGS__))
 #define FOR_EACH_PAIR_CTX_SEP_AGAIN() FOR_EACH_PAIR_CTX_SEP_HELPER
 
 #define FOR_EACH_PAIR_CTX(macro, ctx, ...) FOR_EACH_PAIR_CTX_SEP(COMMA, macro, ctx, __VA_ARGS__)
 
-#endif  // LIBS_LIBCPP_INCLUDE_INTERNAL_MACRO_HPP_
+#define MERGE(x, y) x y
+#define GET_FIRST_ARG(x, y) x
+#define GET_SECOND_ARG(x, y) y
+
+#endif  // LIBS_LIBC_INTERNAL_MACRO_HPP_
diff --git a/libs/libc/internal/time_internal.cpp b/libs/libc/src/internal/time_internal.cpp
similarity index 100%
rename from libs/libc/internal/time_internal.cpp
rename to libs/libc/src/internal/time_internal.cpp
diff --git a/libs/libc/internal/time_internal.hpp b/libs/libc/src/internal/time_internal.hpp
similarity index 100%
rename from libs/libc/internal/time_internal.hpp
rename to libs/libc/src/internal/time_internal.hpp
diff --git a/libs/libc/io/snprintf.cpp b/libs/libc/src/io/snprintf.cpp
similarity index 100%
rename from libs/libc/io/snprintf.cpp
rename to libs/libc/src/io/snprintf.cpp
diff --git a/libs/libc/math/math.cpp b/libs/libc/src/math/math.cpp
similarity index 100%
rename from libs/libc/math/math.cpp
rename to libs/libc/src/math/math.cpp
diff --git a/libs/libc/memory/memory.cpp b/libs/libc/src/memory/memory.cpp
similarity index 100%
rename from libs/libc/memory/memory.cpp
rename to libs/libc/src/memory/memory.cpp
diff --git a/libs/libc/string/string.cpp b/libs/libc/src/string/string.cpp
similarity index 100%
rename from libs/libc/string/string.cpp
rename to libs/libc/src/string/string.cpp
diff --git a/libs/libc/time/asctime.cpp b/libs/libc/src/time/asctime.cpp
similarity index 100%
rename from libs/libc/time/asctime.cpp
rename to libs/libc/src/time/asctime.cpp
diff --git a/libs/libc/time/ctime.cpp b/libs/libc/src/time/ctime.cpp
similarity index 100%
rename from libs/libc/time/ctime.cpp
rename to libs/libc/src/time/ctime.cpp
diff --git a/libs/libc/time/gmtime.cpp b/libs/libc/src/time/gmtime.cpp
similarity index 100%
rename from libs/libc/time/gmtime.cpp
rename to libs/libc/src/time/gmtime.cpp
diff --git a/libs/libc/time/localtime.cpp b/libs/libc/src/time/localtime.cpp
similarity index 100%
rename from libs/libc/time/localtime.cpp
rename to libs/libc/src/time/localtime.cpp
diff --git a/libs/libc/time/mktime.cpp b/libs/libc/src/time/mktime.cpp
similarity index 100%
rename from libs/libc/time/mktime.cpp
rename to libs/libc/src/time/mktime.cpp
diff --git a/libs/libc/time/strftime.cpp b/libs/libc/src/time/strftime.cpp
similarity index 100%
rename from libs/libc/time/strftime.cpp
rename to libs/libc/src/time/strftime.cpp
diff --git a/libs/libc/time/time.cpp b/libs/libc/src/time/time.cpp
similarity index 100%
rename from libs/libc/time/time.cpp
rename to libs/libc/src/time/time.cpp
diff --git a/libs/libc/time/time_ext.cpp b/libs/libc/src/time/time_ext.cpp
similarity index 100%
rename from libs/libc/time/time_ext.cpp
rename to libs/libc/src/time/time_ext.cpp
diff --git a/libs/libcpp/CMakeLists.txt b/libs/libcpp/CMakeLists.txt
index ca5ddf4c..5f33a7f1 100644
--- a/libs/libcpp/CMakeLists.txt
+++ b/libs/libcpp/CMakeLists.txt
@@ -22,8 +22,9 @@ target_include_directories(alkos.libcpp.interface INTERFACE
 
     # At the time of their making, both libc and libcpp were in the same directory
     # Decoupling them now brings too little benefit and too much complexity to justify the effort
-    "${CMAKE_CURRENT_SOURCE_DIR}/../libc/include"
-    "${CMAKE_CURRENT_SOURCE_DIR}/../libc/abi"
+    "${CMAKE_CURRENT_SOURCE_DIR}/../libc/src/include"
+    "${CMAKE_CURRENT_SOURCE_DIR}/../libc/src/abi"
+    "${CMAKE_CURRENT_SOURCE_DIR}/../libc/src"
 )
 
 target_link_libraries(alkos.libcpp.interface INTERFACE
diff --git a/libs/libcpp/include/defines.hpp b/libs/libcpp/include/defines.hpp
index a853bfc8..7e94ceac 100644
--- a/libs/libcpp/include/defines.hpp
+++ b/libs/libcpp/include/defines.hpp
@@ -11,8 +11,6 @@ static constexpr bool kIsDebugBuild = false;
 static constexpr bool kIsDebugBuild = true;
 #endif  // NDEBUG
 
-#define COMPILER_FENCE __asm__ volatile("" ::: "memory");
-
 #define NODISCARD         [[nodiscard]]
 #define NO_UNIQUE_ADDRESS [[no_unique_address]]
 #define MAYBE_UNUSED      [[maybe_unused]]
@@ -127,13 +125,4 @@ constexpr byte operator""_byte(const unsigned long long value) { return static_c
 constexpr f32 operator""_f32(const long double value) { return static_cast<f32>(value); }
 constexpr f64 operator""_f64(const long double value) { return static_cast<f64>(value); }
 
-// ------------------------------
-// Unique empty struct
-// ------------------------------
-template <size_t ID>
-struct empty_t {
-};
-
-#define UNIQUE_EMPTY empty_t<__COUNTER__>
-
 #endif  // LIBS_LIBCPP_INCLUDE_DEFINES_HPP_
diff --git a/libs/libcpp/include/internal/empty.hpp b/libs/libcpp/include/internal/empty.hpp
new file mode 100644
index 00000000..a0d39ec1
--- /dev/null
+++ b/libs/libcpp/include/internal/empty.hpp
@@ -0,0 +1,27 @@
+#ifndef LIBS_LIBCPP_INCLUDE_INTERNAL_EMPTY_HPP_
+#define LIBS_LIBCPP_INCLUDE_INTERNAL_EMPTY_HPP_
+
+#include <compare.hpp>
+
+// ------------------------------
+// Unique empty struct
+// ------------------------------
+template <size_t ID>
+struct empty_t {
+};
+
+#define UNIQUE_EMPTY empty_t<__COUNTER__>
+
+template <size_t ID, size_t OtherID>
+constexpr bool operator==(empty_t<ID>, empty_t<OtherID>) noexcept
+{
+    return true;
+}
+
+template <size_t ID, size_t OtherID>
+constexpr std::strong_ordering operator<=>(empty_t<ID>, empty_t<OtherID>) noexcept
+{
+    return std::strong_ordering::equal;
+}
+
+#endif  // LIBS_LIBCPP_INCLUDE_INTERNAL_EMPTY_HPP_
diff --git a/libs/libcpp/include/span.hpp b/libs/libcpp/include/span.hpp
index fd012228..c67fa8f0 100644
--- a/libs/libcpp/include/span.hpp
+++ b/libs/libcpp/include/span.hpp
@@ -8,6 +8,7 @@
 #include <initializer_list.hpp>
 #include <internal/utility.hpp>
 #include <memory.hpp>
+#include <template/utils.hpp>
 #include <type_traits.hpp>
 
 namespace std
@@ -364,7 +365,7 @@ class span
     // Data members
     // ------------------------------
     pointer data_;
-    NO_UNIQUE_ADDRESS std::conditional_t<is_dynamic_extent_, size_type, UNIQUE_EMPTY> size_;
+    OPTIONAL_FIELD(is_dynamic_extent_, size_type) size_;
 };
 
 // ------------------------------
diff --git a/libs/libcpp/include/utility.hpp b/libs/libcpp/include/utility.hpp
index 96fa054b..4736027d 100644
--- a/libs/libcpp/include/utility.hpp
+++ b/libs/libcpp/include/utility.hpp
@@ -142,5 +142,8 @@ using make_integer_sequence
 template <size_t N>
 using make_index_sequence = make_integer_sequence<size_t, N>;
 
+template <typename... Args>
+using index_sequence_for = make_index_sequence<sizeof...(Args)>;
+
 }  // namespace std
 #endif  // LIBS_LIBCPP_INCLUDE_UTILITY_HPP_
diff --git a/libs/libtemplate/include/template/utils.hpp b/libs/libtemplate/include/template/utils.hpp
index 715aadce..daf1596f 100644
--- a/libs/libtemplate/include/template/utils.hpp
+++ b/libs/libtemplate/include/template/utils.hpp
@@ -2,6 +2,7 @@
 #define LIBS_LIBTEMPLATE_INCLUDE_TEMPLATE_UTILS_HPP_
 
 #include <defines.hpp>
+#include <internal/empty.hpp>
 #include <type_traits.hpp>
 
 namespace template_lib
diff --git a/rootfs/CMakeLists.txt b/rootfs/CMakeLists.txt
index eb8fd80e..5907b172 100644
--- a/rootfs/CMakeLists.txt
+++ b/rootfs/CMakeLists.txt
@@ -11,12 +11,13 @@ include(RuntimeHelpers)
 ################################################################################
 
 set(ROOTFS_TYPE fat CACHE STRING "Type of root filesystem to create (e.g. fat)")
+set(ROOTFS_DIR ${CMAKE_CURRENT_BINARY_DIR}/target CACHE PATH "Staging directory for building root filesystem image")
+alkos_add_to_bash_config("CONF_ROOTFS_DIR" "${ROOTFS_DIR}")
 
 if(CMAKE_FEATURE_FLAG_RAMDISK)
     register_filesystem(
             TYPE INITRD
             ROOTFS_TYPE ${ROOTFS_TYPE}
-            ROOTFS_DIR ${CMAKE_CURRENT_BINARY_DIR}/target
             ROOTFS_TARGET_PATH ${CMAKE_BINARY_DIR}/sysroot/boot/alkos.initrd
             ROOTFS_OVERLAY_DIR ${CMAKE_CURRENT_SOURCE_DIR}/overlay
             MODULE alkos.initrd
@@ -26,15 +27,11 @@ else()
     register_filesystem(
             TYPE IMAGE
             ROOTFS_TYPE ${ROOTFS_TYPE}
-            ROOTFS_DIR ${CMAKE_CURRENT_BINARY_DIR}/target
             ROOTFS_TARGET_PATH ${CMAKE_BINARY_DIR}/alkos.rootfs.img
             ROOTFS_OVERLAY_DIR ${CMAKE_CURRENT_SOURCE_DIR}/overlay
     )
 endif()
 
-set(USERSPACE_BIN_DIR "${CMAKE_BINARY_DIR}/userspace_bin")
-alkos_add_to_bash_config("CONF_USERSPACE_BIN_DIR" "${USERSPACE_BIN_DIR}")
-
 if(TARGET rootfs AND TARGET userspace_apps)
     add_dependencies(rootfs userspace_apps)
 endif()
diff --git a/scripts/config/feature_flags_schema.yaml b/scripts/config/feature_flags_schema.yaml
index c44d1fec..a870d0d8 100644
--- a/scripts/config/feature_flags_schema.yaml
+++ b/scripts/config/feature_flags_schema.yaml
@@ -64,6 +64,20 @@ feature_flags:
     min: 0
     max: 3
 
+  - name: vfs_trace_level
+    description: Level of VFS module tracing
+    type: integer
+    default: 2
+    min: 0
+    max: 3
+
+  - name: acpi_trace_level
+    description: Level of ACPI module tracing
+    type: integer
+    default: 2
+    min: 0
+    max: 3
+
   - name: ramdisk
     description: Load root filesystem from ramdisk instead of block device.
     default: true
diff --git a/tests/libcpp_mocks/defines.hpp b/tests/libcpp_mocks/defines.hpp
index 5b7648d4..2a4c40ef 100644
--- a/tests/libcpp_mocks/defines.hpp
+++ b/tests/libcpp_mocks/defines.hpp
@@ -43,8 +43,7 @@ static constexpr bool kIsKernel = false;
 
 #define STRINGIFY(x)   #x
 #define TOSTRING(x)    STRINGIFY(x)
-#define BARRIER()      std::atomic_thread_fence(std::memory_order_seq_cst)
-#define COMPILER_FENCE std::atomic_signal_fence(std::memory_order_seq_cst)
+#define COMPILER_FENCE std::atomic_signal_fence(std::memory_order_seq_cst);
 
 // Map kernel asserts to standard asserts
 #undef assert
diff --git a/userspace/CMakeLists.txt b/userspace/CMakeLists.txt
index c67d5275..6e74cca4 100644
--- a/userspace/CMakeLists.txt
+++ b/userspace/CMakeLists.txt
@@ -1,23 +1,31 @@
 message(STATUS "Configuring Userspace programs...")
 
-# !!!
-# NOTE: Hardcoded logic for x86_64 for now
-# !!!
-
 # Directory where we collect user binaries
-set(USERSPACE_BIN_DIR "${CMAKE_BINARY_DIR}/userspace_bin")
-file(MAKE_DIRECTORY ${USERSPACE_BIN_DIR})
+set(USERSPACE_BIN_DIR "${CMAKE_CURRENT_BINARY_DIR}/bin")
+alkos_add_to_bash_config("CONF_USERSPACE_BIN_DIR" "${USERSPACE_BIN_DIR}")
 
 set(USER_LINKER_SCRIPT "${CMAKE_CURRENT_SOURCE_DIR}/build/linker.ld")
-# Temporarily hardcode x86_64 stub for passing printf
-# To be removed after proper libc is done
-set(CRT0_SRC "${CMAKE_CURRENT_SOURCE_DIR}/crt0.nasm")
+
+# Create the Userspace Standard Library (libc)
+add_library(c.userspace STATIC ${ALKOS_LIBC_SOURCES})
+target_link_libraries(c.userspace PUBLIC alkos.libc.interface gcc)
+
+target_compile_options(c.userspace PRIVATE
+    $<$<COMPILE_LANGUAGE:CXX>:
+        -fno-builtin
+        -fno-rtti
+        -fno-exceptions
+        -fno-stack-protector
+        -mcmodel=small
+        -mno-red-zone
+    >
+)
 
 # Create a target to collect all user programs
 add_custom_target(userspace_apps COMMENT "Building all userspace applications")
 
-function(add_user_program PROG_NAME SRC_FILES)
-    add_executable(${PROG_NAME} ${CRT0_SRC} ${SRC_FILES})
+function(alkos_register_userspace_app PROG_NAME SRC_FILES)
+    add_executable(${PROG_NAME} ${SRC_FILES})
     
     # Temporarily hardcode flags for x86_64
     target_compile_options(${PROG_NAME} PRIVATE
@@ -38,6 +46,8 @@ function(add_user_program PROG_NAME SRC_FILES)
         -static
     )
 
+    target_link_libraries(${PROG_NAME} PRIVATE c.userspace)
+
     add_custom_command(TARGET ${PROG_NAME} POST_BUILD
         COMMAND ${CMAKE_COMMAND} -E copy $<TARGET_FILE:${PROG_NAME}> ${USERSPACE_BIN_DIR}/${PROG_NAME}
         COMMENT "Installing ${PROG_NAME} to ${USERSPACE_BIN_DIR}"
@@ -46,4 +56,5 @@ function(add_user_program PROG_NAME SRC_FILES)
     add_dependencies(userspace_apps ${PROG_NAME})
 endfunction()
 
-add_user_program(hello programs/hello_world/main.cpp)
+# Register all user programs
+alkos_add_subdirs(${CMAKE_CURRENT_SOURCE_DIR}/programs)
diff --git a/userspace/build/linker.ld b/userspace/build/linker.ld
index ae5a1d6c..04e633e2 100644
--- a/userspace/build/linker.ld
+++ b/userspace/build/linker.ld
@@ -1,4 +1,4 @@
-ENTRY(_start)
+ENTRY(main)
 
 SECTIONS
 {
diff --git a/userspace/crt0.nasm b/userspace/crt0.nasm
deleted file mode 100644
index 5685d4a2..00000000
--- a/userspace/crt0.nasm
+++ /dev/null
@@ -1,22 +0,0 @@
-; !!! Temporary file 
-; !!! Will be deleted after userspace is linked against libc
-
-bits 64
-global _start
-extern main
-
-section .bss
-    global g_print_fn
-    g_print_fn: resq 1
-
-section .text
-_start:
-    ; System V ABI: The first argument (RDI) passed by the kernel
-    ; contains the function pointer to the print helper.
-    mov [rel g_print_fn], rdi
-
-    ; Call the main C++ function
-    call main
-
-    ; Return to kernel (for now, just ret, kernel wrapper will handle this)
-    ret
diff --git a/userspace/programs/hello_world/CMakeLists.txt b/userspace/programs/hello_world/CMakeLists.txt
new file mode 100644
index 00000000..f328b930
--- /dev/null
+++ b/userspace/programs/hello_world/CMakeLists.txt
@@ -0,0 +1,3 @@
+message(STATUS "  -> hello")
+alkos_find_sources(HELLO_WORLD_SOURCES)
+alkos_register_userspace_app(hello "${HELLO_WORLD_SOURCES}")
diff --git a/userspace/programs/hello_world/main.cpp b/userspace/programs/hello_world/main.cpp
index 55d4a73d..4ec10136 100644
--- a/userspace/programs/hello_world/main.cpp
+++ b/userspace/programs/hello_world/main.cpp
@@ -1,15 +1,35 @@
-extern "C" void (*g_print_fn)(const char *);
+#include <platform.h>
+#include <stdio.h>
+#include <sys/calls.h>
 
-void print(const char *msg)
+template <typename... Args>
+void printf(const char *format, Args... args)
 {
-    if (g_print_fn) {
-        g_print_fn(msg);
-    }
+    char buffer[256];
+    snprintf(buffer, sizeof(buffer), format, args...);
+    __platform_write_console(buffer);
 }
 
 extern "C" int main()
 {
-    print("Hello from User Space (Address 0x400000)!\n");
-    print("I was loaded from the file system.\n");
+    __platform_write_console(
+        "\n----------------------------------\n"
+        "Hello from User Space via Syscall!\n"
+        "----------------------------------\n"
+    );
+
+    printf("\nFormatting Test: %d + %d = %d\n\n", 2, 2, 4);
+
+    Timezone tz;
+    __platform_get_timezone(&tz);
+    printf("Timezone offset (minutes): %d\n\n", tz.west_offset_minutes);
+
+    u64 ticks = __platform_get_clock_ticks_in_second(kTimeUtc);
+    printf("Ticks per second (UTC): %llu\n\n", ticks);
+
+    TimeVal tv;
+    __platform_get_clock_value(kTimeUtc, &tv, &tz);
+    printf("Current Timestamp: %llu\n\n", tv.seconds);
+
     return 0;
 }

From 33ca2a1b0a01416fbe4f001793be078b04662051 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C5=81ukasz=20Kryczka?=
 <60490378+kryczkal@users.noreply.github.com>
Date: Mon, 29 Dec 2025 17:55:03 +0100
Subject: [PATCH 28/56] Kryczkal/vmm ref 01 (#253)

---
 kernel/src/hal/mmu.hpp             |  85 ++----------------
 kernel/src/init.cpp                |   1 +
 kernel/src/mem/mmu/contexts.hpp    |  71 +++++++++++++++
 kernel/src/mem/virt/addr_space.cpp | 137 +++++++++++++++++++++++++----
 kernel/src/mem/virt/addr_space.hpp |  35 ++++++--
 kernel/src/mem/virt/area.hpp       |   2 +
 kernel/src/mem/virt/page_fault.cpp |   9 +-
 kernel/src/mem/virt/vmm.cpp        |  83 +++++++----------
 kernel/src/mem/virt/vmm.hpp        |  16 +++-
 kernel/src/modules/memory.cpp      |  86 +++++++++---------
 kernel/src/modules/memory.hpp      |  13 ++-
 11 files changed, 330 insertions(+), 208 deletions(-)
 create mode 100644 kernel/src/mem/mmu/contexts.hpp

diff --git a/kernel/src/hal/mmu.hpp b/kernel/src/hal/mmu.hpp
index 46c45012..e07edc88 100644
--- a/kernel/src/hal/mmu.hpp
+++ b/kernel/src/hal/mmu.hpp
@@ -5,10 +5,7 @@
 #include <macros.hpp>
 
 #include "hal/constants.hpp"
-#include "hal/tlb.hpp"
-#include "mem/page_meta_table.hpp"
-#include "mem/phys/mngr/bitmap.hpp"
-#include "mem/phys/mngr/buddy.hpp"
+#include "mem/mmu/contexts.hpp"
 
 namespace hal
 {
@@ -20,60 +17,13 @@ using std::unexpected;
 
 using PageFlags = arch::PageFlags;
 
-/**
- * @brief Default MMU Context using the full kernel memory subsystem.
- */
-struct KernelMmuContext {
-    Mem::BuddyPmm &pmm;
-    Mem::PageMetaTable &pmt;
-
-    expected<Mem::PPtr<void>, Mem::MemError> AllocateTable(uint8_t level)
-    {
-        auto res = pmm.Alloc({.order = 0});
-        if (!res)
-            return unexpected(res.error());
-        auto ptr = *res;
-        memset(Mem::PhysToVirt(ptr), 0, hal::kPageSizeBytes);
-
-        auto &meta = pmt.GetPageMeta(ptr);
-        meta.InitPageTable(level);
-        return reinterpret_cast<Mem::PPtr<void>>(ptr);
-    }
-
-    void FreeTable(Mem::PPtr<void> table, uint8_t level)
-    {
-        (void)level;
-        auto &meta = pmt.GetPageMeta(table);
-        meta.InitAllocated(0);
-        pmm.Free(reinterpret_cast<Mem::PPtr<Mem::Page>>(table));
-    }
-
-    void IncreaseUsage(Mem::PPtr<void> table)
-    {
-        auto &meta = pmt.GetPageMeta(table);
-        Mem::PageMeta::AsPageTable(meta).ref_count++;
-    }
-
-    bool DecreaseUsage(Mem::PPtr<void> table)
-    {
-        auto &meta = pmt.GetPageMeta(table);
-        auto &pt   = Mem::PageMeta::AsPageTable(meta);
-        if (pt.ref_count > 0)
-            pt.ref_count--;
-        return pt.ref_count == 0;
-    }
-};
-
 class Mmu : public arch::Mmu
 {
-    Tlb *tlb_;
-
     public:
-    void Init(Tlb &tlb) { tlb_ = &tlb; }
-
     /// The range is treated as half-open: [start, start + size)
+    template <MmuContext Context>
     expected<void, Mem::MemError> MapRange(
-        KernelMmuContext &ctx, Mem::PPtr<void> root, Mem::VPtr<void> vaddr_start,
+        Context &ctx, Mem::PPtr<void> root, Mem::VPtr<void> vaddr_start,
         Mem::PPtr<void> paddr_start, size_t size, PageFlags flags
     )
     {
@@ -90,32 +40,9 @@ class Mmu : public arch::Mmu
         return {};
     }
 
-    template <MmuContext Context>
-    void Unmap(Context &ctx, Mem::PPtr<void> root, Mem::VPtr<void> vaddr)
-    {
-        arch::Mmu::Unmap(ctx, root, vaddr);
-        tlb_->InvalidatePage(vaddr);
-    }
-
-    template <MmuContext Context>
-    void ClearUserMappings(Context &ctx, Mem::PPtr<void> root)
-    {
-        arch::Mmu::ClearUserMappings(ctx, root);
-        tlb_->FlushAll();
-    }
-
-    expected<void, Mem::MemError> SetPageFlags(
-        Mem::PPtr<void> root, Mem::VPtr<void> vaddr, PageFlags flags
-    )
-    {
-        auto res = arch::Mmu::SetPageFlags(root, vaddr, flags);
-        if (res)
-            tlb_->InvalidatePage(vaddr);
-        return {};
-    }
-
     /// The range is treated as half-open: [start, start + size)
-    void UnmapRange(KernelMmuContext &ctx, Mem::PPtr<void> root, Mem::VPtr<void> start, size_t size)
+    template <MmuContext Context>
+    void UnmapRange(Context &ctx, Mem::PPtr<void> root, Mem::VPtr<void> start, size_t size)
     {
         using namespace Mem;
 
@@ -125,8 +52,6 @@ class Mmu : public arch::Mmu
         for (auto addr = s; addr < e; addr += kPageSizeBytes) {
             arch::Mmu::Unmap(ctx, root, UptrToPtr<void>(addr));
         }
-
-        tlb_->InvalidateRange(start, size);
     }
 };
 
diff --git a/kernel/src/init.cpp b/kernel/src/init.cpp
index c7507a1c..8ff34aa5 100644
--- a/kernel/src/init.cpp
+++ b/kernel/src/init.cpp
@@ -26,6 +26,7 @@ void KernelInit(const hal::RawBootArguments &raw_args)
     BootArguments args = SanitizeBootArgs(raw_args);
 
     MemoryModule::Init(args);
+    MemoryModule::Get().RegisterKernelVMAreas(args);
 
     /* GCC CXX provided function initializing global constructors */
     _init();
diff --git a/kernel/src/mem/mmu/contexts.hpp b/kernel/src/mem/mmu/contexts.hpp
new file mode 100644
index 00000000..be352d03
--- /dev/null
+++ b/kernel/src/mem/mmu/contexts.hpp
@@ -0,0 +1,71 @@
+#ifndef KERNEL_SRC_MEM_MMU_CONTEXTS_HPP_
+#define KERNEL_SRC_MEM_MMU_CONTEXTS_HPP_
+
+#include <expected.hpp>
+#include <hal/api/mmu.hpp>
+#include <macros.hpp>
+
+#include "hal/constants.hpp"
+#include "mem/page_meta_table.hpp"
+#include "mem/phys/mngr/buddy.hpp"
+#include "mem/types.hpp"
+
+namespace Mem
+{
+
+/**
+ * @brief Default MMU Context using the full kernel memory subsystem.
+ */
+class KernelMmuContext
+{
+    private:
+    Mem::BuddyPmm *pmm_;
+    Mem::PageMetaTable *pmt_;
+
+    public:
+    void Init(Mem::BuddyPmm *pmm, Mem::PageMetaTable *pmt)
+    {
+        pmm_ = pmm;
+        pmt_ = pmt;
+    }
+
+    std::expected<Mem::PPtr<void>, Mem::MemError> AllocateTable(uint8_t level)
+    {
+        auto res = pmm_->Alloc({.order = 0});
+        if (!res)
+            return std::unexpected(res.error());
+        auto ptr = *res;
+        memset(Mem::PhysToVirt(ptr), 0, hal::kPageSizeBytes);
+
+        auto &meta = pmt_->GetPageMeta(ptr);
+        meta.InitPageTable(level);
+        return reinterpret_cast<Mem::PPtr<void>>(ptr);
+    }
+
+    void FreeTable(Mem::PPtr<void> table, uint8_t level)
+    {
+        (void)level;
+        auto &meta = pmt_->GetPageMeta(table);
+        meta.InitAllocated(0);
+        pmm_->Free(reinterpret_cast<Mem::PPtr<Mem::Page>>(table));
+    }
+
+    void IncreaseUsage(Mem::PPtr<void> table)
+    {
+        auto &meta = pmt_->GetPageMeta(table);
+        Mem::PageMeta::AsPageTable(meta).ref_count++;
+    }
+
+    bool DecreaseUsage(Mem::PPtr<void> table)
+    {
+        auto &meta = pmt_->GetPageMeta(table);
+        auto &pt   = Mem::PageMeta::AsPageTable(meta);
+        if (pt.ref_count > 0)
+            pt.ref_count--;
+        return pt.ref_count == 0;
+    }
+};
+
+}  // namespace Mem
+
+#endif  // KERNEL_SRC_MEM_MMU_CONTEXTS_HPP_
diff --git a/kernel/src/mem/virt/addr_space.cpp b/kernel/src/mem/virt/addr_space.cpp
index a33e4b3a..aa24b72d 100644
--- a/kernel/src/mem/virt/addr_space.cpp
+++ b/kernel/src/mem/virt/addr_space.cpp
@@ -1,12 +1,47 @@
 #include "mem/virt/addr_space.hpp"
+
 #include <macros.hpp>
+#include "hal/constants.hpp"
+#include "hal/mmu.hpp"
 #include "mem/error.hpp"
 #include "mem/heap.hpp"
+#include "mem/mmu/contexts.hpp"
+#include "mem/page_meta_table.hpp"
+#include "mem/phys/mngr/buddy.hpp"
 #include "mem/types.hpp"
 
 using namespace Mem;
 using AS = AddressSpace;
 
+AS::AddressSpace()
+    : page_table_root_{nullptr}, owns_page_table_root_{false}, area_list_head_{nullptr}
+{
+}
+
+expected<void, MemError> AS::InitUser(KernelMmuContext &ctx, hal::Mmu &mmu)
+{
+    ctx_ = &ctx;
+    mmu_ = &mmu;
+
+    auto page_table_root_res = ctx_->AllocateTable(0);
+    RET_UNEXPECTED_IF_ERR(page_table_root_res);
+    page_table_root_      = *page_table_root_res;
+    owns_page_table_root_ = true;
+
+    return {};
+}
+
+expected<void, MemError> AS::InitKernel(
+    const PPtr<void> kernel_root, KernelMmuContext &ctx, hal::Mmu &mmu
+)
+{
+    page_table_root_      = kernel_root;
+    mmu_                  = &mmu;
+    ctx_                  = &ctx;
+    owns_page_table_root_ = false;
+
+    return {};
+}
 AS::~AddressSpace()
 {
     // Free all allocated areas
@@ -15,6 +50,12 @@ AS::~AddressSpace()
         area_list_head_ = area_list_head_->next;
         KFree(to_free);
     }
+
+    if (ctx_) {
+        if (owns_page_table_root_ && page_table_root_ != nullptr) {
+            ctx_->FreeTable(page_table_root_, 0);
+        }
+    }
 }
 
 expected<void, MemError> AS::AddArea(VMemArea vma)
@@ -54,39 +95,97 @@ bool AS::AreasOverlap(VPtr<VMemArea> a, VPtr<VMemArea> b)
     return a_s_addr < b_e_addr && b_s_addr < a_e_addr;
 }
 
-expected<void, MemError> AS::RmArea(VPtr<void> ptr)
+expected<TlbHint, MemError> AS::RmArea(VPtr<void> ptr)
 {
     area_list_lock_.Lock();
 
-    if (!area_list_head_) {
+    VPtr<VMemArea> to_free = nullptr;
+    VPtr<VMemArea> prev    = nullptr;
+
+    auto iterator = area_list_head_;
+    while (iterator) {
+        if (IsAddrInArea(iterator, ptr)) {
+            to_free = iterator;
+            break;
+        }
+        prev     = iterator;
+        iterator = iterator->next;
+    }
+
+    if (!to_free) {
         area_list_lock_.Unlock();
-        return {};  // Nothing to remove
+        return unexpected(MemError::NotFound);
     }
 
-    // Head is to be removed
-    if (IsAddrInArea(area_list_head_, ptr)) {
-        auto to_free    = area_list_head_;
-        area_list_head_ = area_list_head_->next;
+    // Do MMU unmap while we have the area info
+    auto start = to_free->start;
+    auto size  = to_free->size;
+
+    mmu_->UnmapRange(*ctx_, page_table_root_, start, size);
+
+    if (prev) {
+        prev->next = to_free->next;
+    } else {
+        area_list_head_ = to_free->next;
+    }
+
+    area_list_lock_.Unlock();
+    KFree(to_free);
+
+    return TlbHint{start, size};
+}
+
+expected<TlbHint, MemError> AS::UpdateAreaFlags(VPtr<void> ptr, VirtualMemAreaFlags vmaf)
+{
+    area_list_lock_.Lock();
+
+    VPtr<VMemArea> area = area_list_head_;
+    while (area != nullptr) {
+        if (IsAddrInArea(area, ptr)) {
+            break;
+        }
+        area = area->next;
+    }
+
+    if (!area) {
         area_list_lock_.Unlock();
-        KFree(to_free);
-        return {};
+        return unexpected(MemError::NotFound);
     }
 
-    // Traverse rest
-    auto iterator = area_list_head_;
-    while (iterator->next) {
-        if (IsAddrInArea(iterator->next, ptr)) {
-            auto to_free   = iterator->next;
-            iterator->next = to_free->next;
+    if (area->start != ptr) {
+        area_list_lock_.Unlock();
+        return unexpected(MemError::InvalidArgument);
+    }
+
+    area->flags = vmaf;
+    auto start  = area->start;
+    auto size   = area->size;
+
+    bool is_kernel = (PtrToUptr(start) >= hal::kKernelVirtualAddressStart);
+
+    hal::PageFlags pf{
+        .Present        = true,
+        .Writable       = vmaf.writable,
+        .UserAccessible = !is_kernel,
+        .WriteThrough   = vmaf.write_through,
+        .CacheDisable   = vmaf.cache_disable,
+        .Global         = is_kernel,
+        .NoExecute      = !vmaf.executable
+    };
+
+    uptr start_u = PtrToUptr(start);
+    uptr end_u   = start_u + size;
+
+    for (uptr v = start_u; v < end_u; v += hal::kPageSizeBytes) {
+        auto res = mmu_->SetPageFlags(page_table_root_, UptrToPtr<void>(v), pf);
+        if (!res && res.error() != MemError::NotFound) {
             area_list_lock_.Unlock();
-            KFree(to_free);
-            return {};
+            return unexpected(res.error());
         }
-        iterator = iterator->next;
     }
 
     area_list_lock_.Unlock();
-    return unexpected(MemError::InvalidArgument);
+    return TlbHint{start, size};
 }
 
 expected<VPtr<VMemArea>, MemError> AS::FindArea(VPtr<void> ptr)
diff --git a/kernel/src/mem/virt/addr_space.hpp b/kernel/src/mem/virt/addr_space.hpp
index 3c754e26..46cf8c28 100644
--- a/kernel/src/mem/virt/addr_space.hpp
+++ b/kernel/src/mem/virt/addr_space.hpp
@@ -12,9 +12,16 @@
 #include "mem/virt/addr_space_iterator.hpp"
 #include "mem/virt/area.hpp"
 
+namespace hal
+{
+class Mmu;
+}
+
 namespace Mem
 {
 
+struct KernelMmuContext;
+
 using std::expected;
 using std::unexpected;
 
@@ -23,18 +30,28 @@ using std::unexpected;
 //==============================================================================
 
 class VirtualMemoryManager;
+class BuddyPmm;
+class PageMetaTable;
 
 //==============================================================================
 // AddressSpace
 //==============================================================================
 
+struct TlbHint {
+    VPtr<void> start;
+    size_t size;
+};
+
 class AddressSpace
 {
     public:
-    AddressSpace(PPtr<void> page_table_root)
-        : page_table_root_{page_table_root}, area_list_head_{nullptr}
-    {
-    }
+    explicit AddressSpace();
+
+    expected<void, MemError> InitUser(KernelMmuContext &ctx, hal::Mmu &mmu);
+    expected<void, MemError> InitKernel(
+        const PPtr<void> kernel_root, KernelMmuContext &ctx, hal::Mmu &mmu
+    );
+
     ~AddressSpace();
     AddressSpace(const AddressSpace &)            = delete;
     AddressSpace &operator=(const AddressSpace &) = delete;
@@ -48,17 +65,25 @@ class AddressSpace
     private:
     // This is orchestrated in VMM (For proper TLB management)
     expected<void, MemError> AddArea(VMemArea vma);
-    expected<void, MemError> RmArea(VPtr<void> ptr);
+    expected<TlbHint, MemError> RmArea(VPtr<void> ptr);
+    expected<TlbHint, MemError> UpdateAreaFlags(VPtr<void> ptr, VirtualMemAreaFlags flags);
 
     // Helpers
     expected<VPtr<VMemArea>, MemError> FindArea(VPtr<void> ptr);
     bool IsAddrInArea(VPtr<VMemArea> vma, VPtr<void> ptr);
     bool AreasOverlap(VPtr<VMemArea> a, VPtr<VMemArea> b);
 
+    // Fields
     PPtr<void> page_table_root_;
+    bool owns_page_table_root_;
     VPtr<VMemArea> area_list_head_;
     hal::Spinlock area_list_lock_;
 
+    // Dependencies
+    KernelMmuContext *ctx_;
+    hal::Mmu *mmu_;
+
+    // Friends
     friend VirtualMemoryManager;
     friend void PageFaultHandler(intr::LitExcEntry &entry, hal::ExceptionData *data);
 
diff --git a/kernel/src/mem/virt/area.hpp b/kernel/src/mem/virt/area.hpp
index c276e433..717d2e7f 100644
--- a/kernel/src/mem/virt/area.hpp
+++ b/kernel/src/mem/virt/area.hpp
@@ -14,6 +14,8 @@ struct VirtualMemAreaFlags {
     bool readable : 1;
     bool writable : 1;
     bool executable : 1;
+    bool write_through : 1 = false;
+    bool cache_disable : 1 = false;
     // Future flags: bool user_accessible, bool copy_on_write, etc.
 };
 using VMemAreaFlags = VirtualMemAreaFlags;
diff --git a/kernel/src/mem/virt/page_fault.cpp b/kernel/src/mem/virt/page_fault.cpp
index 19b92a6b..a530a401 100644
--- a/kernel/src/mem/virt/page_fault.cpp
+++ b/kernel/src/mem/virt/page_fault.cpp
@@ -4,6 +4,7 @@
 
 #include "hal/intr_parser.hpp"
 #include "hal/panic.hpp"
+#include "mem/mmu/contexts.hpp"
 #include "mem/phys/mngr/buddy.hpp"
 #include "mem/virt/page_fault.hpp"
 #include "modules/hardware.hpp"
@@ -76,8 +77,8 @@ void PageFaultHandler(intr::LitExcEntry &, hal::ExceptionData *data)
             .Present        = true,
             .Writable       = vma.flags.writable,
             .UserAccessible = true,
-            .WriteThrough   = false,
-            .CacheDisable   = false,
+            .WriteThrough   = vma.flags.write_through,
+            .CacheDisable   = vma.flags.cache_disable,
             .Global         = false,
             .NoExecute      = !vma.flags.executable
         };
@@ -85,9 +86,7 @@ void PageFaultHandler(intr::LitExcEntry &, hal::ExceptionData *data)
         // We need a context to Map.
         // For now, we construct a KernelMmuContext on the fly using the global PMM/PMT
         // FIXME: This is slightly inefficient to reconstruct on every fault, but valid.
-        hal::KernelMmuContext ctx{
-            MemoryModule::Get().GetBuddyPmm(), MemoryModule::Get().GetPageMetaTable()
-        };
+        auto &ctx = MemoryModule::Get().GetKernelMmuContext();
 
         auto map_res = mmu.Map(
             ctx, as.PageTableRoot(), AlignDown(f_ptr, hal::kPageSizeBytes), map_to, page_flags
diff --git a/kernel/src/mem/virt/vmm.cpp b/kernel/src/mem/virt/vmm.cpp
index 61da3ec3..adadf4d0 100644
--- a/kernel/src/mem/virt/vmm.cpp
+++ b/kernel/src/mem/virt/vmm.cpp
@@ -5,7 +5,7 @@
 
 #include "hal/constants.hpp"
 #include "mem/heap.hpp"
-#include "mem/phys/mngr/buddy.hpp"
+#include "mem/mmu/contexts.hpp"
 #include "mem/types.hpp"
 #include "mem/virt/addr_space.hpp"
 #include "mem/virt/area.hpp"
@@ -22,23 +22,38 @@ using Vmm = VirtualMemoryManager;
 using AS  = AddressSpace;
 
 TODO_WHEN_MULTITHREADING
-void Vmm::Init(hal::Tlb &tlb, hal::Mmu &mmu, BuddyPmm &pmm) noexcept
+void Vmm::Init(
+    hal::Tlb &tlb, hal::Mmu &mmu, KernelMmuContext &ctx, Heap &heap, const PPtr<void> kernel_root
+) noexcept
 {
     DEBUG_INFO_MEMORY("VirtualMemoryManager::Init()");
-    tlb_  = &tlb;
-    mmu_  = &mmu;
-    bpmm_ = &pmm;
+    tlb_ = &tlb;
+    mmu_ = &mmu;
+    ctx_ = &ctx;
+    // Heap is used implicitly via KNew / KDelete
+    heap_ = &heap;
+    (void)heap;
+
+    TRACE_INFO_MEMORY("Initializing Kernel Address Space");
+    auto init_res = kernel_as_.InitKernel(kernel_root, *ctx_, *mmu_);
+    R_ASSERT_TRUE(init_res);
 }
 
-expected<VirtualPtr<AddressSpace>, MemError> Vmm::CreateAddrSpace()
+expected<VPtr<AddressSpace>, MemError> Vmm::CreateUserAddrSpace()
 {
-    auto as_res = KNew<AddressSpace>(nullptr);
+    auto as_res = KNew<AddressSpace>();
     RET_UNEXPECTED_IF_ERR(as_res);
-    return *as_res;
+    auto as = *as_res;
+
+    auto init_res = as->InitUser(*ctx_, *mmu_);
+    RET_UNEXPECTED_IF_ERR(init_res);
+
+    return as;
 }
 
-expected<void, MemError> Vmm::DestroyAddrSpace(VPtr<AddressSpace> as)
+expected<void, MemError> Vmm::DestroyUserAddrSpace(VPtr<AddressSpace> as)
 {
+    mmu_->ClearUserMappings(*ctx_, as->PageTableRoot());
     KDelete(as);
     return {};
 }
@@ -59,22 +74,11 @@ expected<VPtr<void>, MemError> Vmm::AddArea(VPtr<AddrSp> as, VMemArea vma)
 
 expected<void, MemError> Vmm::RmArea(VPtr<AddrSp> as, VPtr<void> region_start)
 {
-    auto a_or_err = as->FindArea(region_start);
-    RET_UNEXPECTED_IF_ERR(a_or_err);
-    auto *area  = *a_or_err;
-    auto *start = area->start;
-    auto size   = area->size;
-
-    auto &pmt = MemoryModule::Get().GetPageMetaTable();
-    hal::KernelMmuContext ctx{*bpmm_, pmt};
+    auto hint_res = as->RmArea(region_start);
+    RET_UNEXPECTED_IF_ERR(hint_res);
+    auto hint = *hint_res;
 
-    mmu_->UnmapRange(ctx, as->PageTableRoot(), start, size);
-
-    auto err = as->RmArea(region_start);
-    RET_UNEXPECTED_IF_ERR(err);
-
-    // TLB invalidation handled inside UnMapRange or via explicit flush if needed.
-    // But UnMapRange implementation in HAL Mmu calls Unmap which calls invlpg.
+    tlb_->InvalidateRange(hint.start, hint.size);
 
     return {};
 }
@@ -83,32 +87,11 @@ expected<void, MemError> Vmm::UpdateAreaFlags(
     VPtr<AddressSpace> as, VPtr<void> region_start, VirtualMemAreaFlags vmaf
 )
 {
-    auto a_or_err = as->FindArea(region_start);
-    RET_UNEXPECTED_IF_ERR(a_or_err);
-    auto *area = *a_or_err;
-    RET_UNEXPECTED_IF(area->start != region_start, MemError::InvalidArgument);
-
-    area->flags = vmaf;
-
-    bool is_kernel = (PtrToUptr(region_start) >= hal::kKernelVirtualAddressStart);
-
-    hal::PageFlags pf{
-        .Present        = true,
-        .Writable       = vmaf.writable,
-        .UserAccessible = !is_kernel,
-        .WriteThrough   = false,
-        .CacheDisable   = false,
-        .Global         = is_kernel,
-        .NoExecute      = !vmaf.executable
-    };
-
-    uptr start = PtrToUptr(area->start);
-    uptr end   = start + area->size;
-
-    for (uptr v = start; v < end; v += hal::kPageSizeBytes) {
-        auto res = mmu_->SetPageFlags(as->PageTableRoot(), UptrToPtr<void>(v), pf);
-        RET_UNEXPECTED_IF(!res && res.error() != MemError::NotFound, res.error());
-    }
+    auto hint_res = as->UpdateAreaFlags(region_start, vmaf);
+    RET_UNEXPECTED_IF_ERR(hint_res);
+    auto hint = *hint_res;
+
+    tlb_->InvalidateRange(hint.start, hint.size);
 
     return {};
 }
diff --git a/kernel/src/mem/virt/vmm.hpp b/kernel/src/mem/virt/vmm.hpp
index 7b159a01..40265d11 100644
--- a/kernel/src/mem/virt/vmm.hpp
+++ b/kernel/src/mem/virt/vmm.hpp
@@ -14,6 +14,7 @@ namespace Mem
 {
 
 class BuddyPmm;
+class Heap;
 
 using std::expected;
 using std::unexpected;
@@ -30,14 +31,19 @@ class VirtualMemoryManager
     // ------------------------------
 
     VirtualMemoryManager() = default;
-    void Init(hal::Tlb &tlb, hal::Mmu &mmu, BuddyPmm &bpmm) noexcept;
+    void Init(
+        hal::Tlb &tlb, hal::Mmu &mmu, KernelMmuContext &ctx, Heap &heap,
+        const PPtr<void> kernel_root
+    ) noexcept;
 
     // ------------------------------
     // Class interaction
     // ------------------------------
 
-    expected<VPtr<AddressSpace>, MemError> CreateAddrSpace();
-    expected<void, MemError> DestroyAddrSpace(VPtr<AddressSpace> as);
+    AddressSpace &GetKernelAddressSpace() { return kernel_as_; }
+
+    expected<VPtr<AddressSpace>, MemError> CreateUserAddrSpace();
+    expected<void, MemError> DestroyUserAddrSpace(VPtr<AddressSpace> as);
     void SwitchAddrSpace(VPtr<AddressSpace> as);
 
     expected<VPtr<void>, MemError> AddArea(VPtr<AddressSpace> as, VMemArea vma);
@@ -52,7 +58,9 @@ class VirtualMemoryManager
     // ------------------------------
     hal::Tlb *tlb_;
     hal::Mmu *mmu_;
-    BuddyPmm *bpmm_;
+    KernelMmuContext *ctx_;
+    Heap *heap_;
+    AddressSpace kernel_as_;
 };
 using Vmm = VirtualMemoryManager;
 
diff --git a/kernel/src/modules/memory.cpp b/kernel/src/modules/memory.cpp
index 0e7d016d..034e80d4 100644
--- a/kernel/src/modules/memory.cpp
+++ b/kernel/src/modules/memory.cpp
@@ -1,5 +1,6 @@
 #include "modules/memory.hpp"
 
+#include <assert.h>
 #include "boot_args.hpp"
 #include "hal/constants.hpp"
 #include "mem/init/boot_mmu.hpp"
@@ -12,7 +13,6 @@
 using namespace Mem;
 
 internal::MemoryModule::MemoryModule(const BootArguments &args) noexcept
-    : KernelAddressSpace_(args.root_page_table)
 {
     DEBUG_INFO_MEMORY("MemoryModule::MemoryModule()");
 
@@ -26,68 +26,70 @@ internal::MemoryModule::MemoryModule(const BootArguments &args) noexcept
 
     PageMetaTable_.Init(args.total_page_frames, BitmapPmm_);
 
-    Mmu_.Init(Tlb_);
-
     // Cleanup bootloader mappings and reconstruct metadata for kernel mappings
     Mem::Boot::BootMmuCleaner boot_cleaner;
 
     TRACE_INFO_MEMORY("Unmapping lower half of memory");
-    Mmu_.Init(Tlb_);
     boot_cleaner.CleanIdentityMappings(Mmu_, BitmapPmm_, PageMetaTable_, args.root_page_table);
+    Tlb_.FlushAll();
 
     constexpr size_t kInitialBuddyPagesLimit = 4096;  // 16MB
     // Note: Initializing buddy with all pages is a slow operation.
     // This limit is for speed of boot. This operation should have
     // a follow up once kernel is booted, and we have another CPU, we
     // could offload this operation to.
+    TRACE_INFO_MEMORY("Initializing Buddy PMM");
     BuddyPmm_.Init(BitmapPmm_, PageMetaTable_, kInitialBuddyPagesLimit);
 
     // Reconstruct metadata for the existing page table hierarchy passed by the bootloader.
     TRACE_INFO_MEMORY("Reconstructing page table metadata from root: 0x%p", args.root_page_table);
     boot_cleaner.ReconstructMetadata(Mmu_, PageMetaTable_, args.root_page_table);
 
+    TRACE_INFO_MEMORY("Initializing Slab Allocator");
     SlabAllocator_.Init(BuddyPmm_);
 
+    TRACE_INFO_MEMORY("Initializing Heap");
     Heap_.Init(PageMetaTable_, BuddyPmm_, SlabAllocator_);
 
-    Vmm_.Init(Tlb_, Mmu_, BuddyPmm_);
-
-    // Register initial Virtual Memory Areas (VMAs) so the VMM is aware of them.
-    // These areas were set up by the bootloader but are invisible to the generic VMM until
-    // registered.
-    // {
-    //     // Kernel Image
-    //     size_t kernel_size =
-    //         reinterpret_cast<uptr>(args.kernel_end) - reinterpret_cast<uptr>(args.kernel_start);
-    //
-    //     VMemArea kernel_vma{
-    //         .start                = args.kernel_start,
-    //         .size                 = kernel_size,
-    //         .flags                = {.readable = true, .writable = true, .executable = true},
-    //         .type                 = VirtualMemAreaT::Anonymous,
-    //         .direct_mapping_start = VirtToPhys(args.kernel_start),
-    //         .next                 = nullptr
-    //     };
-
-    //     if (auto res = Vmm_.AddArea(&KernelAddressSpace_, kernel_vma); !res) {
-    //         TRACE_WARN_MEMORY("Failed to register Kernel VMA");
-    //     }
-
-    //     // Direct Physical Map
-    //     VMemArea dm_vma{
-    //         .start                = UptrToPtr<void>(hal::kDirectMapAddrStart),
-    //         .size                 = hal::kDirectMemMapSizeGb * 1024ULL * 1024ULL * 1024ULL,
-    //         .flags                = {.readable = true, .writable = true, .executable = false},
-    //         .type                 = VirtualMemAreaT::DirectMapping,
-    //         .direct_mapping_start = UptrToPtr<void>(0),
-    //         .next                 = nullptr
-    //     };
-
-    //     if (auto res = Vmm_.AddArea(&KernelAddressSpace_, dm_vma); !res) {
-    //         TRACE_WARN_MEMORY("Failed to register Direct Map VMA");
-    //     }
-    //
-    // }
+    KernelMmuContext_.Init(&BuddyPmm_, &PageMetaTable_);
+
+    TRACE_INFO_MEMORY("Initializing Virtual Memory Manager");
+    Vmm_.Init(Tlb_, Mmu_, KernelMmuContext_, Heap_, args.root_page_table);
+}
+
+void internal::MemoryModule::RegisterKernelVMAreas(const BootArguments &args)
+{
+    DEBUG_INFO_MEMORY("Registering Kernel VMAreas...");
+
+    // Kernel Image
+    size_t kernel_size =
+        reinterpret_cast<uptr>(args.kernel_end) - reinterpret_cast<uptr>(args.kernel_start);
+    VMemArea kernel_vma{
+        .start                = args.kernel_start,
+        .size                 = kernel_size,
+        .flags                = {.readable = true, .writable = true, .executable = true},
+        .type                 = VirtualMemAreaT::Anonymous,
+        .direct_mapping_start = VirtToPhys(args.kernel_start),
+        .next                 = nullptr
+    };
+
+    if (auto res = Vmm_.AddArea(&Vmm_.GetKernelAddressSpace(), kernel_vma); !res) {
+        TRACE_WARN_MEMORY("Failed to register Kernel VMA");
+    }
+
+    // Direct Physical Map
+    VMemArea dm_vma{
+        .start                = UptrToPtr<void>(hal::kDirectMapAddrStart),
+        .size                 = hal::kDirectMemMapSizeGb * 1024ULL * 1024ULL * 1024ULL,
+        .flags                = {.readable = true, .writable = true, .executable = false},
+        .type                 = VirtualMemAreaT::DirectMapping,
+        .direct_mapping_start = UptrToPtr<void>(0),
+        .next                 = nullptr
+    };
+
+    if (auto res = Vmm_.AddArea(&Vmm_.GetKernelAddressSpace(), dm_vma); !res) {
+        TRACE_WARN_MEMORY("Failed to register Direct Map VMA");
+    }
 }
 
 void internal::MemoryModule::RegisterPageFault(HardwareModule &hw)
diff --git a/kernel/src/modules/memory.hpp b/kernel/src/modules/memory.hpp
index 592c8b1d..08ca1904 100644
--- a/kernel/src/modules/memory.hpp
+++ b/kernel/src/modules/memory.hpp
@@ -9,6 +9,7 @@
 #include "hal/mmu.hpp"
 #include "hal/tlb.hpp"
 #include "mem/heap.hpp"
+#include "mem/mmu/contexts.hpp"
 #include "mem/page_meta_table.hpp"
 #include "mem/phys/mngr/bitmap.hpp"
 #include "mem/phys/mngr/buddy.hpp"
@@ -32,8 +33,6 @@ class MemoryModule : template_lib::StaticSingletonHelper
     // Module fields
     // ------------------------------
 
-    using KernelAddressSpace = Mem::AddressSpace;
-
     DEFINE_MODULE_FIELD(Mem, PageMetaTable);
     DEFINE_MODULE_FIELD(Mem, BitmapPmm);
     DEFINE_MODULE_FIELD(Mem, BuddyPmm);
@@ -42,10 +41,18 @@ class MemoryModule : template_lib::StaticSingletonHelper
     DEFINE_MODULE_FIELD(Mem, Vmm);
     DEFINE_MODULE_FIELD(hal, Tlb);
     DEFINE_MODULE_FIELD(hal, Mmu);
-    DEFINE_MODULE_FIELD(MemoryModule, KernelAddressSpace);
+    DEFINE_MODULE_FIELD(Mem, KernelMmuContext);
 
     public:
     void RegisterPageFault(HardwareModule &hw);
+
+    Mem::AddressSpace &GetKernelAddressSpace() { return Vmm_.GetKernelAddressSpace(); }
+
+    /// @brief Register initial Virtual Memory Areas (VMAs) so the VMM is aware of them.
+    /// These areas were set up by the bootloader but are invisible to the generic VMM until
+    /// registered.
+    /// @note This can't be done in Init() because it requires MemoryModule to be fully initialized.
+    void RegisterKernelVMAreas(const BootArguments &args);
 };
 }  // namespace internal
 

From 71b8b8e68755d8c4be2114ca59cf8b7b0038bba7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C5=81ukasz=20Kryczka?= <lukasz.kryczka000@gmail.com>
Date: Mon, 29 Dec 2025 18:05:00 +0100
Subject: [PATCH 29/56] chore: Mmu Test quickfix

---
 kernel/test/mmu_test.cpp | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/kernel/test/mmu_test.cpp b/kernel/test/mmu_test.cpp
index 8e1d275e..ea88ab87 100644
--- a/kernel/test/mmu_test.cpp
+++ b/kernel/test/mmu_test.cpp
@@ -74,9 +74,6 @@ class MmuTest : public TestGroupBase
         // Zero out the PML4 to ensure it's clean and valid
         memset(pml4_virt_, 0, hal::kPageSizeBytes);
 
-        // Initialize Mmu
-        mmu_.Init(tlb_);
-
         // Initialize Context
         auto ctx_res = KNew<TestMmuContext>(pmm);
         R_ASSERT_TRUE(ctx_res.has_value());

From 6a81b6a9faa8c212ed05d4115d79a62d04b51621 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C5=81ukasz=20Kryczka?=
 <60490378+kryczkal@users.noreply.github.com>
Date: Mon, 29 Dec 2025 18:42:25 +0100
Subject: [PATCH 30/56] Kryczkal/addrsp linkedlist (#254)

---
 kernel/arch/x86_64/boot/lib/mem/vmm.tpp       |   2 +-
 .../arch/x86_64/boot/loader_64/src/main.cpp   |   2 +-
 kernel/arch/x86_64/src/hal/impl/spinlock.hpp  |   3 +
 kernel/src/mem/virt/addr_space.cpp            | 130 ++++++------------
 kernel/src/mem/virt/addr_space.hpp            |  12 +-
 kernel/src/mem/virt/addr_space_iterator.hpp   |  70 ----------
 kernel/src/mem/virt/area.hpp                  |   2 -
 kernel/src/modules/memory.cpp                 |   6 +-
 8 files changed, 56 insertions(+), 171 deletions(-)
 delete mode 100644 kernel/src/mem/virt/addr_space_iterator.hpp

diff --git a/kernel/arch/x86_64/boot/lib/mem/vmm.tpp b/kernel/arch/x86_64/boot/lib/mem/vmm.tpp
index dda0a7e3..4fd25fca 100644
--- a/kernel/arch/x86_64/boot/lib/mem/vmm.tpp
+++ b/kernel/arch/x86_64/boot/lib/mem/vmm.tpp
@@ -43,7 +43,7 @@ void VirtualMemoryManager::Map(
     MapOnePageTag, const u64 virt_addr, const u64 phys_addr, const u64 flags
 )
 {
-    static constexpr u64 kDefaultFlags = kPresentBit | kWriteBit | kUserAccessibleBit;
+    static constexpr u64 kDefaultFlags = kPresentBit | kWriteBit;
 
     // !!!
     // Note: Has to be understood that this whole function
diff --git a/kernel/arch/x86_64/boot/loader_64/src/main.cpp b/kernel/arch/x86_64/boot/loader_64/src/main.cpp
index 3ecb475a..505db757 100644
--- a/kernel/arch/x86_64/boot/loader_64/src/main.cpp
+++ b/kernel/arch/x86_64/boot/loader_64/src/main.cpp
@@ -150,7 +150,7 @@ static u64 LoadKernelIntoMemory(
     auto mmap_tag_res = multiboot_info.FindTag<TagMmap>();
     ASSERT_TRUE(mmap_tag_res, "Failed to find memory map tag in multiboot info");
 
-    vmm.Alloc(kKernelVirtualAddressStart, kernel_info.size, kPresentBit | kWriteBit);
+    vmm.Alloc(kKernelVirtualAddressStart, kernel_info.size, kPresentBit | kWriteBit | kGlobalBit);
 
     // Load the ELF file from the module into the newly mapped memory
     byte *module_start   = reinterpret_cast<byte *>(kernel_info.tag->mod_start);
diff --git a/kernel/arch/x86_64/src/hal/impl/spinlock.hpp b/kernel/arch/x86_64/src/hal/impl/spinlock.hpp
index 3d61e2d5..a160a861 100644
--- a/kernel/arch/x86_64/src/hal/impl/spinlock.hpp
+++ b/kernel/arch/x86_64/src/hal/impl/spinlock.hpp
@@ -35,6 +35,9 @@ class alignas(kCacheLineSizeBytes) Spinlock : public SpinlockAPI
     // ABI implementations
     // ------------------------------
 
+    FORCE_INLINE_F void lock() { Lock(); }
+    FORCE_INLINE_F void unlock() { Unlock(); }
+
     FORCE_INLINE_F void Lock()
     {
         if constexpr (FeatureEnabled<FeatureFlag::kDebugSpinlock>) {
diff --git a/kernel/src/mem/virt/addr_space.cpp b/kernel/src/mem/virt/addr_space.cpp
index aa24b72d..d14a6c1e 100644
--- a/kernel/src/mem/virt/addr_space.cpp
+++ b/kernel/src/mem/virt/addr_space.cpp
@@ -1,6 +1,7 @@
 #include "mem/virt/addr_space.hpp"
 
 #include <macros.hpp>
+#include <mutex.hpp>
 #include "hal/constants.hpp"
 #include "hal/mmu.hpp"
 #include "mem/error.hpp"
@@ -13,10 +14,7 @@
 using namespace Mem;
 using AS = AddressSpace;
 
-AS::AddressSpace()
-    : page_table_root_{nullptr}, owns_page_table_root_{false}, area_list_head_{nullptr}
-{
-}
+AS::AddressSpace() : page_table_root_{nullptr}, owns_page_table_root_{false} {}
 
 expected<void, MemError> AS::InitUser(KernelMmuContext &ctx, hal::Mmu &mmu)
 {
@@ -45,11 +43,7 @@ expected<void, MemError> AS::InitKernel(
 AS::~AddressSpace()
 {
     // Free all allocated areas
-    while (area_list_head_) {
-        auto to_free    = area_list_head_;
-        area_list_head_ = area_list_head_->next;
-        KFree(to_free);
-    }
+    // area_list_ destructor will handle freeing nodes and data
 
     if (ctx_) {
         if (owns_page_table_root_ && page_table_root_ != nullptr) {
@@ -60,28 +54,20 @@ AS::~AddressSpace()
 
 expected<void, MemError> AS::AddArea(VMemArea vma)
 {
-    auto res = KMalloc<VMemArea>();
-    RET_UNEXPECTED_IF_ERR(res);
-
-    VPtr<VMemArea> n_area = *res;
-    *n_area               = vma;
-    n_area->next          = nullptr;
-
-    area_list_lock_.Lock();
+    std::lock_guard guard(area_list_lock_);
 
     // Check for overlapping areas
-    for (auto it = area_list_head_; it; it = it->next) {
-        if (AreasOverlap(it, n_area)) {
-            area_list_lock_.Unlock();
-            KFree(n_area);
+    for (auto it = area_list_.begin(); it != area_list_.end(); ++it) {
+        if (AreasOverlap(&(*it), &vma)) {
             return unexpected(MemError::InvalidArgument);
         }
     }
 
-    n_area->next    = area_list_head_;
-    area_list_head_ = n_area;
+    auto node = area_list_.PushFront(vma);
+    if (!node) {
+        return unexpected(MemError::OutOfMemory);
+    }
 
-    area_list_lock_.Unlock();
     return {};
 }
 
@@ -97,69 +83,35 @@ bool AS::AreasOverlap(VPtr<VMemArea> a, VPtr<VMemArea> b)
 
 expected<TlbHint, MemError> AS::RmArea(VPtr<void> ptr)
 {
-    area_list_lock_.Lock();
+    std::lock_guard guard(area_list_lock_);
 
-    VPtr<VMemArea> to_free = nullptr;
-    VPtr<VMemArea> prev    = nullptr;
-
-    auto iterator = area_list_head_;
-    while (iterator) {
-        if (IsAddrInArea(iterator, ptr)) {
-            to_free = iterator;
-            break;
-        }
-        prev     = iterator;
-        iterator = iterator->next;
-    }
-
-    if (!to_free) {
-        area_list_lock_.Unlock();
-        return unexpected(MemError::NotFound);
-    }
+    auto res = FindAreaLocked(ptr);
+    RET_UNEXPECTED_IF_ERR(res);
+    auto it = *res;
 
     // Do MMU unmap while we have the area info
-    auto start = to_free->start;
-    auto size  = to_free->size;
+    auto start = it->start;
+    auto size  = it->size;
 
     mmu_->UnmapRange(*ctx_, page_table_root_, start, size);
 
-    if (prev) {
-        prev->next = to_free->next;
-    } else {
-        area_list_head_ = to_free->next;
-    }
-
-    area_list_lock_.Unlock();
-    KFree(to_free);
+    area_list_.Remove(it.GetNode());
 
     return TlbHint{start, size};
 }
 
 expected<TlbHint, MemError> AS::UpdateAreaFlags(VPtr<void> ptr, VirtualMemAreaFlags vmaf)
 {
-    area_list_lock_.Lock();
+    std::lock_guard guard(area_list_lock_);
 
-    VPtr<VMemArea> area = area_list_head_;
-    while (area != nullptr) {
-        if (IsAddrInArea(area, ptr)) {
-            break;
-        }
-        area = area->next;
-    }
-
-    if (!area) {
-        area_list_lock_.Unlock();
-        return unexpected(MemError::NotFound);
-    }
-
-    if (area->start != ptr) {
-        area_list_lock_.Unlock();
-        return unexpected(MemError::InvalidArgument);
-    }
+    auto res = FindAreaLocked(ptr);
+    RET_UNEXPECTED_IF_ERR(res);
+    VMemArea &area = *res.value();
+    RET_UNEXPECTED_IF(area.start != ptr, MemError::InvalidArgument);
 
-    area->flags = vmaf;
-    auto start  = area->start;
-    auto size   = area->size;
+    area.flags = vmaf;
+    auto start = area.start;
+    auto size  = area.size;
 
     bool is_kernel = (PtrToUptr(start) >= hal::kKernelVirtualAddressStart);
 
@@ -178,33 +130,33 @@ expected<TlbHint, MemError> AS::UpdateAreaFlags(VPtr<void> ptr, VirtualMemAreaFl
 
     for (uptr v = start_u; v < end_u; v += hal::kPageSizeBytes) {
         auto res = mmu_->SetPageFlags(page_table_root_, UptrToPtr<void>(v), pf);
-        if (!res && res.error() != MemError::NotFound) {
-            area_list_lock_.Unlock();
-            return unexpected(res.error());
-        }
+        RET_UNEXPECTED_IF(!res && res.error() != MemError::NotFound, res.error());
     }
 
-    area_list_lock_.Unlock();
     return TlbHint{start, size};
 }
 
-expected<VPtr<VMemArea>, MemError> AS::FindArea(VPtr<void> ptr)
+expected<AS::AddrSpMutIt, MemError> AS::FindAreaLocked(VPtr<void> ptr)
 {
-    area_list_lock_.Lock();
-
-    VPtr<VMemArea> vma = area_list_head_;
-    while (vma != nullptr) {
-        if (IsAddrInArea(vma, ptr)) {
-            area_list_lock_.Unlock();
-            return vma;
+    for (auto it = area_list_.begin(); it != area_list_.end(); ++it) {
+        if (IsAddrInArea(&(*it), ptr)) {
+            return it;
         }
-        vma = vma->next;
     }
-
-    area_list_lock_.Unlock();
     return unexpected(MemError::NotFound);
 }
 
+expected<VPtr<VMemArea>, MemError> AS::FindArea(VPtr<void> ptr)
+{
+    std::lock_guard guard(area_list_lock_);
+
+    auto res = FindAreaLocked(ptr);
+    RET_UNEXPECTED_IF_ERR(res);
+
+    VPtr<VMemArea> vma = &(*res.value());
+    return vma;
+}
+
 bool AS::IsAddrInArea(VPtr<VMemArea> vma, VPtr<void> ptr)
 {
     ASSERT_NOT_NULL(vma, "Virtual memory area is null");
diff --git a/kernel/src/mem/virt/addr_space.hpp b/kernel/src/mem/virt/addr_space.hpp
index 46cf8c28..a52e4bf6 100644
--- a/kernel/src/mem/virt/addr_space.hpp
+++ b/kernel/src/mem/virt/addr_space.hpp
@@ -4,12 +4,12 @@
 #include <expected.hpp>
 #include <types.hpp>
 
+#include <data_structures/linked_list.hpp>
 #include "hal/interrupt_params.hpp"
 #include "hal/spinlock.hpp"
 #include "interrupts/interrupt_types.hpp"
 #include "mem/error.hpp"
 #include "mem/types.hpp"
-#include "mem/virt/addr_space_iterator.hpp"
 #include "mem/virt/area.hpp"
 
 namespace hal
@@ -58,9 +58,11 @@ class AddressSpace
 
     PPtr<void> PageTableRoot() const { return page_table_root_; }
 
+    using AddrSpIt = data_structures::DoubleLinkedList<VMemArea>::ConstIterator;
+
     // Iterator
-    AddrSpIt begin() const { return AddrSpIt(area_list_head_); }
-    AddrSpIt end() const { return AddrSpIt(nullptr); }
+    AddrSpIt begin() const { return area_list_.begin(); }
+    AddrSpIt end() const { return area_list_.end(); }
 
     private:
     // This is orchestrated in VMM (For proper TLB management)
@@ -69,6 +71,8 @@ class AddressSpace
     expected<TlbHint, MemError> UpdateAreaFlags(VPtr<void> ptr, VirtualMemAreaFlags flags);
 
     // Helpers
+    using AddrSpMutIt = data_structures::DoubleLinkedList<VMemArea>::Iterator;
+    expected<AddrSpMutIt, MemError> FindAreaLocked(VPtr<void> ptr);
     expected<VPtr<VMemArea>, MemError> FindArea(VPtr<void> ptr);
     bool IsAddrInArea(VPtr<VMemArea> vma, VPtr<void> ptr);
     bool AreasOverlap(VPtr<VMemArea> a, VPtr<VMemArea> b);
@@ -76,7 +80,7 @@ class AddressSpace
     // Fields
     PPtr<void> page_table_root_;
     bool owns_page_table_root_;
-    VPtr<VMemArea> area_list_head_;
+    data_structures::DoubleLinkedList<VMemArea> area_list_;
     hal::Spinlock area_list_lock_;
 
     // Dependencies
diff --git a/kernel/src/mem/virt/addr_space_iterator.hpp b/kernel/src/mem/virt/addr_space_iterator.hpp
deleted file mode 100644
index 2d7ddd72..00000000
--- a/kernel/src/mem/virt/addr_space_iterator.hpp
+++ /dev/null
@@ -1,70 +0,0 @@
-#ifndef KERNEL_SRC_MEM_VIRT_ADDR_SPACE_ITERATOR_HPP_
-#define KERNEL_SRC_MEM_VIRT_ADDR_SPACE_ITERATOR_HPP_
-
-#include <expected.hpp>
-#include <types.hpp>
-
-#include "mem/error.hpp"
-#include "mem/types.hpp"
-#include "mem/virt/area.hpp"
-
-namespace Mem
-{
-
-//==============================================================================
-// Forward Declarations
-//==============================================================================
-
-class VirtualMemoryManager;
-class AddressSpace;
-
-//==============================================================================
-// AddressSpaceConstIterator
-//==============================================================================
-
-class AddressSpaceConstIterator
-{
-    public:
-    using value_type      = VMemArea;
-    using difference_type = std::ptrdiff_t;
-    using pointer         = VPtr<const VMemArea>;
-    using reference       = const VMemArea &;
-
-    explicit AddressSpaceConstIterator(pointer ptr) : m_ptr_(ptr) {}
-
-    reference operator*() const { return *m_ptr_; }
-    pointer operator->() const { return m_ptr_; }
-
-    AddressSpaceConstIterator &operator++()
-    {
-        if (m_ptr_) {
-            m_ptr_ = m_ptr_->next;
-        }
-        return *this;
-    }
-
-    AddressSpaceConstIterator operator++(int)
-    {
-        AddressSpaceConstIterator tmp = *this;
-        ++(*this);
-        return tmp;
-    }
-
-    friend bool operator==(const AddressSpaceConstIterator &a, const AddressSpaceConstIterator &b)
-    {
-        return a.m_ptr_ == b.m_ptr_;
-    }
-    friend bool operator!=(const AddressSpaceConstIterator &a, const AddressSpaceConstIterator &b)
-    {
-        return a.m_ptr_ != b.m_ptr_;
-    }
-
-    private:
-    pointer m_ptr_;
-};
-
-using AddrSpIt = AddressSpaceConstIterator;
-
-}  // namespace Mem
-
-#endif  // KERNEL_SRC_MEM_VIRT_ADDR_SPACE_ITERATOR_HPP_
diff --git a/kernel/src/mem/virt/area.hpp b/kernel/src/mem/virt/area.hpp
index 717d2e7f..6e645d18 100644
--- a/kernel/src/mem/virt/area.hpp
+++ b/kernel/src/mem/virt/area.hpp
@@ -28,8 +28,6 @@ struct VirtualMemArea {
     TODO_STD_VARIANT
     VirtualMemAreaT type;
     PPtr<void> direct_mapping_start;
-
-    VirtualMemArea *next = nullptr;
 };
 using VMemArea = VirtualMemArea;
 
diff --git a/kernel/src/modules/memory.cpp b/kernel/src/modules/memory.cpp
index 034e80d4..15a82ce8 100644
--- a/kernel/src/modules/memory.cpp
+++ b/kernel/src/modules/memory.cpp
@@ -69,8 +69,7 @@ void internal::MemoryModule::RegisterKernelVMAreas(const BootArguments &args)
         .size                 = kernel_size,
         .flags                = {.readable = true, .writable = true, .executable = true},
         .type                 = VirtualMemAreaT::Anonymous,
-        .direct_mapping_start = VirtToPhys(args.kernel_start),
-        .next                 = nullptr
+        .direct_mapping_start = VirtToPhys(args.kernel_start)
     };
 
     if (auto res = Vmm_.AddArea(&Vmm_.GetKernelAddressSpace(), kernel_vma); !res) {
@@ -83,8 +82,7 @@ void internal::MemoryModule::RegisterKernelVMAreas(const BootArguments &args)
         .size                 = hal::kDirectMemMapSizeGb * 1024ULL * 1024ULL * 1024ULL,
         .flags                = {.readable = true, .writable = true, .executable = false},
         .type                 = VirtualMemAreaT::DirectMapping,
-        .direct_mapping_start = UptrToPtr<void>(0),
-        .next                 = nullptr
+        .direct_mapping_start = UptrToPtr<void>(0)
     };
 
     if (auto res = Vmm_.AddArea(&Vmm_.GetKernelAddressSpace(), dm_vma); !res) {

From 497f265b50f20c998bb25f58d620a8c45bac38da Mon Sep 17 00:00:00 2001
From: Jakub Lisowski <115403674+Jlisowskyy@users.noreply.github.com>
Date: Mon, 29 Dec 2025 19:18:14 +0100
Subject: [PATCH 31/56] Jlisowskyy/scheduler 2 (#252)

Things done in this PR:
- added driver of lapic Event Clock
- added driver of Hpet Event Clock
- added minimal driver of PIT Event Clock
- enabled TSC time clock
- Added calibration (frequency detection using HPET clock)
- Calibrated TSC
- Calibrated Lapic Timer
- Removed stub timer isr
- Adjusted stack initialization function to use `iretq`
- Enabled User Space Context Switch
- Added Event Clock picking scheme
- Cleaned up code slightly
- Changed LIT schemed - allowed kernel to return void* after Handler*
calls to the architecture layer
- Added minimalistic round-robin scheduler code
- Added minimalistic event framework managing event clocks with only
periodic option enabled
---
 kernel/arch/x86_64/CMakeLists.txt             |   4 +-
 .../arch/x86_64/src/drivers/apic/io_apic.cpp  |  16 ++
 .../arch/x86_64/src/drivers/apic/io_apic.hpp  |   6 +
 .../x86_64/src/drivers/apic/local_apic.cpp    | 101 ++++++++++++
 .../x86_64/src/drivers/apic/local_apic.hpp    |  31 +++-
 kernel/arch/x86_64/src/drivers/hpet/hpet.cpp  |  90 +++++++++++
 kernel/arch/x86_64/src/drivers/hpet/hpet.hpp  |  44 +++++-
 kernel/arch/x86_64/src/drivers/pit/pit.hpp    |  66 ++++++++
 kernel/arch/x86_64/src/drivers/tsc/tsc.cpp    |  28 +++-
 kernel/arch/x86_64/src/drivers/tsc/tsc.hpp    |   6 +-
 .../x86_64/src/hal/impl/interrupt_params.hpp  |   2 +
 .../arch/x86_64/src/hal/impl/interrupts.cpp   |  23 ++-
 .../arch/x86_64/src/hal/impl/interrupts.hpp   |   2 +
 .../arch/x86_64/src/hal/impl/scheduling.cpp   |  38 +++--
 .../arch/x86_64/src/hal/impl/scheduling.hpp   |  10 +-
 kernel/arch/x86_64/src/hal/impl/time.cpp      |  41 +++++
 kernel/arch/x86_64/src/hal/impl/timers.hpp    |   1 +
 kernel/arch/x86_64/src/include/regs.nasm      |   3 -
 kernel/arch/x86_64/src/interrupts/idt.cpp     |  41 ++---
 kernel/arch/x86_64/src/interrupts/idt.hpp     |   7 +-
 kernel/arch/x86_64/src/interrupts/idt.nasm    |  29 ++--
 .../x86_64/src/scheduling/scheduling.nasm     | 146 +++++++++++-------
 .../x86_64/src/tests/interrupts_tests.cpp     |   7 +-
 kernel/src/acpi/osl.cpp                       |   3 +-
 kernel/src/hal/debug.hpp                      |   2 +
 kernel/src/hal/scheduling.hpp                 |   5 +-
 kernel/src/hal/timers.hpp                     |   3 +-
 kernel/src/hardware/event_clock_infra.hpp     |  15 +-
 kernel/src/init.cpp                           |   2 +-
 kernel/src/interrupts/interrupt_types.hpp     |  10 +-
 kernel/src/interrupts/interrupts.cpp          |  12 +-
 .../interrupts/logical_interrupt_table.hpp    |  24 ++-
 kernel/src/kernel.cpp                         |  47 +++---
 kernel/src/mem/virt/addr_space.hpp            |   2 +-
 kernel/src/mem/virt/page_fault.cpp            |  11 +-
 kernel/src/mem/virt/page_fault.hpp            |   2 +-
 kernel/src/modules/hardware.cpp               |   3 +-
 kernel/src/modules/scheduling.hpp             |   2 +
 kernel/src/modules/timing.hpp                 |   2 +
 kernel/src/scheduling/kworker.cpp             |  10 ++
 kernel/src/scheduling/scheduler.cpp           |  82 ++++++++++
 kernel/src/scheduling/scheduler.hpp           |  47 ++++++
 kernel/src/scheduling/task_mgr.cpp            |  23 +--
 kernel/src/scheduling/task_mgr.hpp            |   2 +-
 kernel/src/scheduling/thread.hpp              |   2 +-
 kernel/src/time/event_framework.cpp           |  38 +++++
 kernel/src/time/event_framework.hpp           |  40 +++++
 kernel/src/timing.cpp                         |  15 +-
 kernel/test/manual_tests.cpp                  |  12 +-
 libs/libcpp/include/formats.hpp               |  28 ++++
 50 files changed, 960 insertions(+), 226 deletions(-)
 create mode 100644 kernel/arch/x86_64/src/drivers/pit/pit.hpp
 create mode 100644 kernel/src/scheduling/scheduler.cpp
 create mode 100644 kernel/src/scheduling/scheduler.hpp
 create mode 100644 kernel/src/time/event_framework.cpp
 create mode 100644 kernel/src/time/event_framework.hpp

diff --git a/kernel/arch/x86_64/CMakeLists.txt b/kernel/arch/x86_64/CMakeLists.txt
index 9015dd3d..8302dcfb 100644
--- a/kernel/arch/x86_64/CMakeLists.txt
+++ b/kernel/arch/x86_64/CMakeLists.txt
@@ -58,9 +58,9 @@ alkos_register_runtime_environment(
     QEMU_COMMAND
         "qemu-system-x86_64"
     QEMU_NORMAL_FLAGS
-        "-serial stdio -enable-kvm -cpu max -machine type=q35,accel=kvm -display default,show-cursor=on -k en-us -m 4G -smp sockets=1,cores=4,threads=1"
+        "-serial stdio -enable-kvm -cpu max,+invtsc,migratable=off -machine type=q35,accel=kvm -display default,show-cursor=on -k en-us -m 4G -smp sockets=1,cores=4,threads=1"
     QEMU_TEST_FLAGS
-        "-serial stdio -enable-kvm -cpu max -machine type=q35,accel=kvm -display none -m 4G -smp sockets=1,cores=4,threads=1 -no-reboot"
+        "-serial stdio -enable-kvm -cpu max,+invtsc,migratable=off -machine type=q35,accel=kvm -display none -m 4G -smp sockets=1,cores=4,threads=1 -no-reboot"
     MODULES
         alkos.boot.loader.64
         alkos.kernel
diff --git a/kernel/arch/x86_64/src/drivers/apic/io_apic.cpp b/kernel/arch/x86_64/src/drivers/apic/io_apic.cpp
index 38d8c739..6cd9434e 100644
--- a/kernel/arch/x86_64/src/drivers/apic/io_apic.cpp
+++ b/kernel/arch/x86_64/src/drivers/apic/io_apic.cpp
@@ -1,5 +1,6 @@
 #include "drivers/apic/io_apic.hpp"
 #include "drivers/apic/local_apic.hpp"
+#include "trace_framework.hpp"
 
 #include <bit.hpp>
 #include <mem/types.hpp>
@@ -114,3 +115,18 @@ void IoApic::ApplyNmiRule(const acpi_madt_nmi_source *nmi_source) const
     /* Write back */
     WriteLowerTableRegister(nmi_source->gsi - GetGsiBase(), reg_low);
 }
+void IoApic::MaskIrq(const u32 gsi) const { SetMask(gsi, true); }
+
+void IoApic::UnmaskIrq(const u32 gsi) const { SetMask(gsi, false); }
+
+void IoApic::SetMask(const u32 gsi, const bool masked) const
+{
+    R_ASSERT_TRUE(IsInChargeOfGsi(gsi));
+
+    const u32 idx = gsi - gsi_base_;
+    auto reg_low  = ReadLowerTableRegister(idx);
+    reg_low.mask  = masked ? LowerTableRegister::EnabledFlag::kDisabled
+                           : LowerTableRegister::EnabledFlag::kEnabled;
+
+    WriteLowerTableRegister(idx, reg_low);
+}
diff --git a/kernel/arch/x86_64/src/drivers/apic/io_apic.hpp b/kernel/arch/x86_64/src/drivers/apic/io_apic.hpp
index 3f54f5de..f6f7efad 100644
--- a/kernel/arch/x86_64/src/drivers/apic/io_apic.hpp
+++ b/kernel/arch/x86_64/src/drivers/apic/io_apic.hpp
@@ -208,6 +208,12 @@ class IoApic final
 
     void ApplyNmiRule(const acpi_madt_nmi_source *nmi_source) const;
 
+    void MaskIrq(u32 gsi) const;
+
+    void UnmaskIrq(u32 gsi) const;
+
+    void SetMask(u32 gsi, bool masked) const;
+
     // ------------------------------
     // Class Fields
     // ------------------------------
diff --git a/kernel/arch/x86_64/src/drivers/apic/local_apic.cpp b/kernel/arch/x86_64/src/drivers/apic/local_apic.cpp
index 670c61d5..a0f542ea 100644
--- a/kernel/arch/x86_64/src/drivers/apic/local_apic.cpp
+++ b/kernel/arch/x86_64/src/drivers/apic/local_apic.cpp
@@ -57,6 +57,54 @@ static void ParseMadtRules_()
 
 static void LApicACK(intr::LitHwEntry &) { LocalApic::SendEOI(); }
 
+static u32 NextEventCb(hardware::EventClockRegistryEntry *entry, const u64 time_ns)
+{
+    static constexpr u32 kTimerDivider = 8;
+
+    if (entry->state == hardware::EventClockState::kDisabled) {
+        return 1;
+    }
+
+    const u64 lapic_freq   = static_cast<LocalApic *>(entry->own_data)->GetFreqHz();
+    const u64 divided_freq = lapic_freq / kTimerDivider;
+
+    LocalApic::DisableTimer();
+
+    LocalApic::SetTimerDivider(kTimerDivider);
+    LocalApic::SetTimerCounter((time_ns * kNanosInSecond) / divided_freq);
+
+    LocalApic::LocalVectorTableTimerRegister reg{};
+    reg.mask       = LocalApic::LocalVectorTableTimerRegister::Mask::kEnabled;
+    reg.timer_mode = entry->state == hardware::EventClockState::kPeriodic
+                         ? LocalApic::LocalVectorTableTimerRegister::TimerMode::kPeriodic
+                         : LocalApic::LocalVectorTableTimerRegister::TimerMode::kOneShot;
+    reg.vector     = arch::kTimerHwInt;
+
+    LocalApic::WriteRegister(LocalApic::kLvtTimerRegRW, reg);
+    return 0;
+}
+
+static u32 SetPeriodicCb(hardware::EventClockRegistryEntry *entry)
+{
+    if (entry->state != hardware::EventClockState::kPeriodic) {
+        LocalApic::DisableTimer();
+        entry->state = hardware::EventClockState::kPeriodic;
+    }
+
+    return 0;
+}
+
+static u32 SetOneshotCb(hardware::EventClockRegistryEntry *entry)
+{
+    if (entry->state != hardware::EventClockState::kOneshot &&
+        entry->state != hardware::EventClockState::kOneshotIdle) {
+        LocalApic::DisableTimer();
+        entry->state = hardware::EventClockState::kOneshotIdle;
+    }
+
+    return 0;
+}
+
 // ------------------------------
 // Implementations
 // ------------------------------
@@ -93,3 +141,56 @@ void LocalApic::Enable()
 
     DEBUG_INFO_INTERRUPTS("Local APIC enabled...");
 }
+void LocalApic::RegisterAsEventClock()
+{
+    timer_freq_hz_ = MeasureFreqHz_();
+
+    hardware::EventClockRegistryEntry lapic_entry{};
+
+    lapic_entry.id                 = static_cast<u64>(arch::HardwareEventClockId::kLapic);
+    lapic_entry.state              = hardware::EventClockState::kDisabled;
+    lapic_entry.flags.IsCoreLocal  = true;
+    lapic_entry.next_event_time_ns = 0;
+    lapic_entry.own_data           = this;
+
+    lapic_entry.supported_cores.SetAll(true);
+    lapic_entry.min_next_event_time_ns = kNanosInSecond / timer_freq_hz_;
+
+    lapic_entry.cbs.next_event   = NextEventCb;
+    lapic_entry.cbs.set_oneshot  = SetOneshotCb;
+    lapic_entry.cbs.set_periodic = SetPeriodicCb;
+    lapic_entry.cbs.on_entry     = nullptr;
+    lapic_entry.cbs.on_exit      = nullptr;
+
+    HardwareModule::Get().GetEventClockRegistry().Register(lapic_entry);
+}
+
+u64 LocalApic::MeasureFreqHz_()
+{
+    static constexpr u64 kCalibrationTimeMs = 200;
+
+    const u64 hw_irq =
+        HardwareModule::Get()
+            .GetInterrupts()
+            .GetLit()
+            .TranslateToHw<intr::InterruptType::kHardwareInterrupt>(hal::kTimerHwLirq);
+
+    LocalVectorTableTimerRegister enabled_reg{};
+    enabled_reg.vector     = hw_irq;
+    enabled_reg.timer_mode = LocalVectorTableTimerRegister::TimerMode::kOneShot;
+    enabled_reg.mask       = LocalVectorTableTimerRegister::Mask::kEnabled;
+
+    LocalVectorTableTimerRegister disabled_reg = enabled_reg;
+    disabled_reg.mask                          = LocalVectorTableTimerRegister::Mask::kDisabled;
+
+    SetTimerDivider(1);
+    SetTimerCounter(-1);
+    WriteRegister(kLvtTimerRegRW, enabled_reg);
+    const u64 lapic_freq_hz = HardwareModule::Get().GetInterrupts().GetHpet()->CalibrateByHpetHz(
+        GetTimerCounter, kCalibrationTimeMs
+    );
+    WriteRegister(kLvtTimerRegRW, disabled_reg);
+
+    DEBUG_INFO_INTERRUPTS("Lapic Timer frequency in Hz: %llu", lapic_freq_hz);
+    return lapic_freq_hz;
+}
diff --git a/kernel/arch/x86_64/src/drivers/apic/local_apic.hpp b/kernel/arch/x86_64/src/drivers/apic/local_apic.hpp
index 099c0c8c..915db9d0 100644
--- a/kernel/arch/x86_64/src/drivers/apic/local_apic.hpp
+++ b/kernel/arch/x86_64/src/drivers/apic/local_apic.hpp
@@ -382,6 +382,8 @@ class LocalApic
 
     FAST_CALL u8 GetCoreId() { return ReadRegister(kIdRegRW) >> 24; }
 
+    NODISCARD FORCE_INLINE_F u64 GetFreqHz() const { return timer_freq_hz_; }
+
     // ------------------------------
     // Class creation
     // ------------------------------
@@ -403,24 +405,49 @@ class LocalApic
      */
     void Enable();
 
+    void RegisterAsEventClock();
+
     FORCE_INLINE_F void SetPhysicalAddress(const u64 address)
     {
         local_apic_physical_address_ = address;
     }
 
-    FORCE_INLINE_F u64 GetPhysicalAddress() const { return local_apic_physical_address_; }
+    NODISCARD FORCE_INLINE_F u64 GetPhysicalAddress() const { return local_apic_physical_address_; }
 
     NODISCARD FORCE_INLINE_F bool IsEnabled() const { return is_enabled_; }
 
     NODISCARD FORCE_INLINE_F intr::InterruptDriver &GetInterruptDriver() { return driver_; }
 
+    FAST_CALL void SetTimerDivider(const u32 divider)
+    {
+        WriteRegister(kDivideConfigRegRW, divider);
+    }
+
+    FAST_CALL void SetTimerCounter(const u32 value) { WriteRegister(kInitialCountRegRW, value); }
+
+    NODISCARD FAST_CALL u32 GetTimerCounter() { return ReadRegister(kCurrentCountRegRO); }
+
+    FAST_CALL void DisableTimer()
+    {
+        LocalVectorTableTimerRegister disabled_reg{};
+        disabled_reg.mask = LocalVectorTableTimerRegister::Mask::kDisabled;
+        WriteRegister(kLvtTimerRegRW, disabled_reg);
+    }
+
     // ------------------------------
-    // Class fields
+    // Private methods
     // ------------------------------
 
     protected:
+    NODISCARD static u64 MeasureFreqHz_();
+
+    // ------------------------------
+    // Class fields
+    // ------------------------------
+
     bool is_enabled_{};
     u64 local_apic_physical_address_{};
+    u64 timer_freq_hz_{};
     intr::InterruptDriver driver_{};
 };
 #endif  // KERNEL_ARCH_X86_64_SRC_DRIVERS_APIC_LOCAL_APIC_HPP_
diff --git a/kernel/arch/x86_64/src/drivers/hpet/hpet.cpp b/kernel/arch/x86_64/src/drivers/hpet/hpet.cpp
index a51e27d2..42039333 100644
--- a/kernel/arch/x86_64/src/drivers/hpet/hpet.cpp
+++ b/kernel/arch/x86_64/src/drivers/hpet/hpet.cpp
@@ -1,5 +1,6 @@
 #include "drivers/hpet/hpet.hpp"
 #include "cpu/utils.hpp"
+#include "hal/interrupt_params.hpp"
 #include "modules/hardware.hpp"
 
 // ------------------------------
@@ -41,6 +42,72 @@ static void ResumeCounterCb(hardware::ClockRegistryEntry *clock_entry)
     GetHpetFromClockEntry(clock_entry)->StartMainCounter();
 }
 
+// ------------------------------
+// Event Clock callbacks
+// ------------------------------
+
+static void OnEntryCb(hardware::EventClockRegistryEntry *clock_entry)
+{
+    if (clock_entry->state == hardware::EventClockState::kOneshot) {
+        clock_entry->state = hardware::EventClockState::kOneshotIdle;
+    }
+}
+
+static u32 NextEventCb(hardware::EventClockRegistryEntry *entry, const u64 time_ns)
+{
+    if (entry->state == hardware::EventClockState::kDisabled) {
+        return 1;
+    }
+
+    const auto hpet = static_cast<Hpet *>(entry->own_data);
+    hpet->DisableTimer(0);
+
+    const u64 hw_irq =
+        HardwareModule::Get()
+            .GetInterrupts()
+            .GetLit()
+            .TranslateToHw<intr::InterruptType::kHardwareInterrupt>(hal::kTimerHwLirq);
+    const u64 time_femto = time_ns * Hpet::kNsToFemto;
+
+    if (entry->state == hardware::EventClockState::kPeriodic) {
+        hpet->SetupPeriodicTimer(0, time_femto, hw_irq);
+    } else {
+        entry->state = hardware::EventClockState::kOneshot;
+        hpet->SetupOneShotTimer(0, time_femto, hw_irq);
+    }
+
+    return 0;
+}
+
+static u32 SetPeriodicCb(hardware::EventClockRegistryEntry *entry)
+{
+    if (entry->state != hardware::EventClockState::kPeriodic) {
+        const auto hpet = static_cast<Hpet *>(entry->own_data);
+
+        if (!hpet->IsTimerSupportingPeriodic(0)) {
+            DEBUG_WARN_TIME("Hpet does not support periodic!");
+            return 1;
+        }
+
+        hpet->DisableTimer(0);
+        entry->state = hardware::EventClockState::kPeriodic;
+    }
+
+    return 0;
+}
+
+static u32 SetOneshotCb(hardware::EventClockRegistryEntry *entry)
+{
+    if (entry->state != hardware::EventClockState::kOneshot &&
+        entry->state != hardware::EventClockState::kOneshotIdle) {
+        const auto hpet = static_cast<Hpet *>(entry->own_data);
+        hpet->DisableTimer(0);
+        entry->state = hardware::EventClockState::kOneshotIdle;
+    }
+
+    return 0;
+}
+
 // ------------------------------
 // Implementations
 // ------------------------------
@@ -113,6 +180,8 @@ Hpet::Hpet(acpi_hpet *table)
     SetupStandardMapping();
     StopMainCounter();
 
+    // ========================
+    // Register as clock
     hardware::ClockRegistryEntry hpet_entry = {};
 
     /* Clock data */
@@ -134,6 +203,27 @@ Hpet::Hpet(acpi_hpet *table)
     hpet_entry.own_data = this;
 
     HardwareModule::Get().GetClockRegistry().Register(hpet_entry);
+
+    // ========================
+    // Register as event clock
+    hardware::EventClockRegistryEntry hpet_event_entry{};
+
+    hpet_event_entry.id                 = static_cast<u64>(arch::HardwareEventClockId::kHpet);
+    hpet_event_entry.state              = hardware::EventClockState::kDisabled;
+    hpet_event_entry.flags.IsCoreLocal  = false;
+    hpet_event_entry.next_event_time_ns = 0;
+    hpet_event_entry.own_data           = this;
+
+    hpet_event_entry.supported_cores.SetAll(true);
+    hpet_event_entry.min_next_event_time_ns = clock_period_ / 1'000'000;
+
+    hpet_event_entry.cbs.next_event   = NextEventCb;
+    hpet_event_entry.cbs.set_oneshot  = SetOneshotCb;
+    hpet_event_entry.cbs.set_periodic = SetPeriodicCb;
+    hpet_event_entry.cbs.on_entry     = OnEntryCb;
+    hpet_event_entry.cbs.on_exit      = nullptr;
+
+    HardwareModule::Get().GetEventClockRegistry().Register(hpet_event_entry);
 }
 
 u64 Hpet::AdjustTimeToHpetCapabilities(const u64 time_femto) const
diff --git a/kernel/arch/x86_64/src/drivers/hpet/hpet.hpp b/kernel/arch/x86_64/src/drivers/hpet/hpet.hpp
index 22ac070e..9253f10c 100644
--- a/kernel/arch/x86_64/src/drivers/hpet/hpet.hpp
+++ b/kernel/arch/x86_64/src/drivers/hpet/hpet.hpp
@@ -1,6 +1,7 @@
 #ifndef KERNEL_ARCH_X86_64_SRC_DRIVERS_HPET_HPET_HPP_
 #define KERNEL_ARCH_X86_64_SRC_DRIVERS_HPET_HPET_HPP_
 
+#include <stdlib.h>
 #include <uacpi/acpi.h>
 #include <array.hpp>
 #include <data_structures/bit_array.hpp>
@@ -54,6 +55,8 @@ class Hpet final
     static constexpr u32 kMaxComparators              = 32;
     static constexpr u64 kFemtoSecondsPerSecond =
         1'000'000'000'000'000;  // 1 second in femto-seconds
+    static constexpr u64 kNsToFemto         = 1'000'000;
+    static constexpr u64 kFemtoSecondsPerMs = kFemtoSecondsPerSecond / 1'000;
 
     /**
      * Returns the memory offset for a timer's configuration register
@@ -224,7 +227,7 @@ class Hpet final
     }
 
     template <class RetT>
-    FORCE_INLINE_F RetT ReadRegister(const u32 offset) const
+    NODISCARD FORCE_INLINE_F RetT ReadRegister(const u32 offset) const
     {
         return ReadMemoryIo<u64, RetT>(
             Mem::PhysToVirt(reinterpret_cast<byte *>(GetPhysicalAddress())), offset
@@ -235,6 +238,35 @@ class Hpet final
     // Class methods
     // ------------------------------
 
+    template <class ReadF>
+    NODISCARD FORCE_INLINE_F u64 CalibrateByHpetHz(ReadF func, const u64 time_ms)
+    {
+        /* Prepare */
+        StartMainCounter();
+        const u64 hpet_period_femto = GetPeriod();
+        const u64 wait_time_cycles  = (time_ms * kFemtoSecondsPerMs) / hpet_period_femto;
+
+        /* Measure */
+
+        const u64 hpet_start = ReadMainCounter();
+        const u64 time_start = func();
+        while ((ReadMainCounter() - hpet_start) < wait_time_cycles) {
+        }
+        const u64 time_end = func();
+        const u64 hpet_end = ReadMainCounter();
+
+        /* Calibrate */
+        const u64 hpet_diff = hpet_end - hpet_start;
+        const u64 time_diff =
+            time_end >= time_start ? time_end - time_start : time_start - time_end;
+
+        __uint128_t val = static_cast<__uint128_t>(time_diff) * kFemtoSecondsPerSecond;
+        val /= static_cast<__uint128_t>(hpet_diff) * hpet_period_femto;
+        return static_cast<u64>(val);
+    }
+
+    NODISCARD FORCE_INLINE_F u32 GetPeriod() const { return clock_period_; }
+
     NODISCARD FORCE_INLINE_F bool IsTimerSupportingPeriodic(const u32 timer_idx) const
     {
         ASSERT_LT(timer_idx, num_comparators_);
@@ -326,6 +358,16 @@ class Hpet final
         );
     }
 
+    FORCE_INLINE_F void DisableTimer(const u32 timer_idx)
+    {
+        ASSERT_LT(timer_idx, num_comparators_);
+
+        auto timer_conf =
+            ReadRegister<TimerConfigurationReg>(GetTimerConfigurationRegRW(timer_idx));
+        timer_conf.enabled = TimerConfigurationReg::Enabled::kDisable;
+        WriteRegister(GetTimerConfigurationRegRW(timer_idx), timer_conf);
+    }
+
     NODISCARD FORCE_INLINE_F bool IsLegacyReplacementSupported() const
     {
         return is_legacy_mode_available_;
diff --git a/kernel/arch/x86_64/src/drivers/pit/pit.hpp b/kernel/arch/x86_64/src/drivers/pit/pit.hpp
new file mode 100644
index 00000000..67f9ea64
--- /dev/null
+++ b/kernel/arch/x86_64/src/drivers/pit/pit.hpp
@@ -0,0 +1,66 @@
+#ifndef KERNEL_ARCH_X86_64_SRC_DRIVERS_PIT_PIT_HPP_
+#define KERNEL_ARCH_X86_64_SRC_DRIVERS_PIT_PIT_HPP_
+
+#include <defines.hpp>
+#include <types.hpp>
+#include "include/io.hpp"
+
+namespace pit
+{
+
+static constexpr u32 kBaseFrequency = 1193182;
+
+enum class Port : u16 { kChannel0 = 0x40, kChannel1 = 0x41, kChannel2 = 0x42, kCommand = 0x43 };
+
+struct CommandRegister {
+    enum class BinaryMode : u8 {
+        kBinary = 0,  // 16-bit binary counter
+        kBcd    = 1   // Binary Coded Decimal
+    };
+
+    enum class OperatingMode : u8 {
+        kMode0 = 0,  // Interrupt on Terminal Count (One-shot)
+        kMode1 = 1,  // Hardware Retriggerable One-Shot
+        kMode2 = 2,  // Rate Generator (Periodic)
+        kMode3 = 3,  // Square Wave Generator (Periodic)
+        kMode4 = 4,  // Software Triggered Strobe
+        kMode5 = 5   // Hardware Triggered Strobe
+    };
+
+    enum class AccessMode : u8 {
+        kLatch      = 0,  // Latch Count Value
+        kLsbOnly    = 1,  // Access LSB only
+        kMsbOnly    = 2,  // Access MSB only
+        kLsbThenMsb = 3   // Access LSB then MSB
+    };
+
+    enum class Channel : u8 { kChannel0 = 0, kChannel1 = 1, kChannel2 = 2, kReadBack = 3 };
+
+    BinaryMode binary_mode : 1;
+    OperatingMode operating_mode : 3;
+    AccessMode access_mode : 2;
+    Channel channel : 2;
+};
+static_assert(sizeof(CommandRegister) == sizeof(u8));
+
+FAST_CALL void WriteCommand(CommandRegister reg)
+{
+    io::out(static_cast<u16>(Port::kCommand), *reinterpret_cast<u8 *>(&reg));
+}
+
+FAST_CALL void Disable()
+{
+    CommandRegister reg{};
+    reg.access_mode    = CommandRegister::AccessMode::kLsbThenMsb;
+    reg.operating_mode = CommandRegister::OperatingMode::kMode0;
+    reg.channel        = CommandRegister::Channel::kChannel0;
+    reg.binary_mode    = CommandRegister::BinaryMode::kBinary;
+
+    WriteCommand(reg);
+    io::out(static_cast<u16>(Port::kChannel0), static_cast<u8>(0));
+    io::out(static_cast<u16>(Port::kChannel0), static_cast<u8>(0));
+}
+
+}  // namespace pit
+
+#endif  // KERNEL_ARCH_X86_64_SRC_DRIVERS_PIT_PIT_HPP_
diff --git a/kernel/arch/x86_64/src/drivers/tsc/tsc.cpp b/kernel/arch/x86_64/src/drivers/tsc/tsc.cpp
index 4619fac9..40d8043d 100644
--- a/kernel/arch/x86_64/src/drivers/tsc/tsc.cpp
+++ b/kernel/arch/x86_64/src/drivers/tsc/tsc.cpp
@@ -15,9 +15,29 @@ static u64 ReadCb(hardware::ClockRegistryEntry *)
 // Private functions
 // ------------------------------
 
-static void AlternativeTscCheck(hardware::ClockRegistryEntry &)
+static void CalibrateByHpet(hardware::ClockRegistryEntry &entry)
 {
-    FAIL_ALWAYS("Not implemented yet: Alternative TSC check");
+    static constexpr u64 kCalibrationTimeMs = 200;
+
+    const u64 freq_hz = HardwareModule::Get().GetInterrupts().GetHpet()->CalibrateByHpetHz(
+        tsc::Read, kCalibrationTimeMs
+    );
+
+    DEBUG_INFO_TIME("Calculated frequency of TSC: %llu, by reading HPET values", freq_hz);
+
+    entry.frequency_kHz     = freq_hz / 1'000;
+    entry.clock_numerator   = kNanosInSecond;
+    entry.clock_denominator = freq_hz;
+}
+
+static void AlternativeTscCheck(hardware::ClockRegistryEntry &entry)
+{
+    if (HardwareModule::Get().GetInterrupts().GetHpet().has_value()) {
+        CalibrateByHpet(entry);
+        return;
+    }
+
+    FAIL_ALWAYS("Not implemented yet: Alternative TSC check - PIT");
 }
 
 static void PrepareTscInfo(hardware::ClockRegistryEntry &entry)
@@ -25,9 +45,10 @@ static void PrepareTscInfo(hardware::ClockRegistryEntry &entry)
     u32 eax, ebx, ecx, unused;
     __get_cpuid(tsc::kIA32CpuidClockInfo, &eax, &ebx, &ecx, &unused);
 
-    if (ebx == 0) {
+    if (ebx == 0 || eax == 0) {
         /* According to 19.17.4 of Intel SDM, EBX might be 0 */
         AlternativeTscCheck(entry);
+        return;
     }
 
     const u64 denominator  = eax;
@@ -53,6 +74,7 @@ static void PrepareTscInfo(hardware::ClockRegistryEntry &entry)
 // Implementations
 // ------------------------------
 
+/* INTERRUPTS MUST BE DISABLED */
 void tsc::Initialize()
 {
     if (!IsAvailable()) {
diff --git a/kernel/arch/x86_64/src/drivers/tsc/tsc.hpp b/kernel/arch/x86_64/src/drivers/tsc/tsc.hpp
index 03a25ea8..d4297252 100644
--- a/kernel/arch/x86_64/src/drivers/tsc/tsc.hpp
+++ b/kernel/arch/x86_64/src/drivers/tsc/tsc.hpp
@@ -51,9 +51,9 @@ static constexpr u64 kCpuIdTscInvariantLeaf = 0x80000007;
 
 FAST_CALL void SetUserSpaceAccess(const bool enabled)
 {
-    auto cr3             = cpu::GetCR<cpu::Cr4>();
-    cr3.TimeStampDisable = !enabled;
-    cpu::SetCR(cr3);
+    auto cr4             = cpu::GetCR<cpu::Cr4>();
+    cr4.TimeStampDisable = !enabled;
+    cpu::SetCR(cr4);
 }
 
 NODISCARD FAST_CALL u64 Read()
diff --git a/kernel/arch/x86_64/src/hal/impl/interrupt_params.hpp b/kernel/arch/x86_64/src/hal/impl/interrupt_params.hpp
index 53735e60..10efd68e 100644
--- a/kernel/arch/x86_64/src/hal/impl/interrupt_params.hpp
+++ b/kernel/arch/x86_64/src/hal/impl/interrupt_params.hpp
@@ -28,6 +28,7 @@ struct PACK IsrStackFrame {
     u64 cs;
     u64 rflags;
     u64 rsp;
+    u64 ss;
 };
 
 struct PACK IsrErrorStackFrame {
@@ -50,6 +51,7 @@ struct ExceptionData : IsrErrorStackFrame {
 /* Mapping params */
 static constexpr u16 kTimerHwLirq      = 0;
 static constexpr u16 kPageFaultExcLirq = 14;
+static constexpr u16 kTimerHwInt       = 32;
 
 /**
  * @brief x86_64 Page Fault Error Code structure.
diff --git a/kernel/arch/x86_64/src/hal/impl/interrupts.cpp b/kernel/arch/x86_64/src/hal/impl/interrupts.cpp
index 844d9566..41028002 100644
--- a/kernel/arch/x86_64/src/hal/impl/interrupts.cpp
+++ b/kernel/arch/x86_64/src/hal/impl/interrupts.cpp
@@ -3,6 +3,7 @@
 #include "cpu/utils.hpp"
 #include "drivers/apic/local_apic.hpp"
 #include "drivers/pic8259/pic8259.hpp"
+#include "drivers/pit/pit.hpp"
 #include "drivers/tsc/tsc.hpp"
 #include "interrupts/idt.hpp"
 #include "trace_framework.hpp"
@@ -24,6 +25,8 @@ void Interrupts::Init()
     /* Replace first stage PIC with new APIC chip on startup Core */
     local_apic_.Enable();
 
+    local_apic_.RegisterAsEventClock();
+
     ReplacePicDriverWithLapic_();
 
     tsc::Initialize();
@@ -37,6 +40,7 @@ void Interrupts::FirstStageInit()
 {
     DEBUG_INFO_INTERRUPTS("Interrupts first stage init...");
 
+    pit::Disable();
     InitPic8259(kIrq1Offset, kIrq2Offset);
     MapToLogicalInterrupts_();
     SetupPicAsDefaultDriver_();
@@ -119,20 +123,6 @@ void Interrupts::MapToLogicalInterrupts_()
                 idx, intr::HwHandler{.handler = SimpleIrqHandler}
             );
     }
-
-    // Map timer handler
-    HardwareModule::Get()
-        .GetInterrupts()
-        .GetLit()
-        .InstallInterruptHandler<intr::InterruptType::kHardwareInterrupt>(
-            0, intr::HwHandler{.handler = TimerIsr}
-        );
-
-    // Map test software irq
-    HardwareModule::Get()
-        .GetInterrupts()
-        .GetLit()
-        .MapLogicalInterruptToHw<intr::InterruptType::kSoftwareInterrupt>(0, 129);
 }
 
 void Interrupts::SetupPicAsDefaultDriver_()
@@ -152,3 +142,8 @@ void Interrupts::ReplacePicDriverWithLapic_()
         );
     }
 }
+
+void cdecl_EnableHardwareInterrupts()
+{
+    HardwareModule::Get().GetInterrupts().EnableHardwareInterrupts();
+}
diff --git a/kernel/arch/x86_64/src/hal/impl/interrupts.hpp b/kernel/arch/x86_64/src/hal/impl/interrupts.hpp
index 1ed2d890..dc7772af 100644
--- a/kernel/arch/x86_64/src/hal/impl/interrupts.hpp
+++ b/kernel/arch/x86_64/src/hal/impl/interrupts.hpp
@@ -92,4 +92,6 @@ class Interrupts : public InterruptsAPI
 };
 }  // namespace arch
 
+extern "C" void cdecl_EnableHardwareInterrupts();
+
 #endif  // KERNEL_ARCH_X86_64_SRC_HAL_IMPL_INTERRUPTS_HPP_
diff --git a/kernel/arch/x86_64/src/hal/impl/scheduling.cpp b/kernel/arch/x86_64/src/hal/impl/scheduling.cpp
index d7f87e40..4f4c2572 100644
--- a/kernel/arch/x86_64/src/hal/impl/scheduling.cpp
+++ b/kernel/arch/x86_64/src/hal/impl/scheduling.cpp
@@ -2,34 +2,44 @@
 #include "scheduling/threads.hpp"
 
 #include <string.h>
+#include <bits_ext.hpp>
 
-template <auto func = Sched::KThreadEntrypoint>
+template <bool kIsKernelTask = true>
 FAST_CALL void InitializeStack(void **stack, void (*f)())
 {
-    static constexpr size_t kStackSpace = 16 * 8;  // 15 regs + rip
-    static constexpr size_t kRipOffset  = 15 * 8;  // 15 regs
-    static constexpr size_t kRdiOffset  = 4 * 8;   // rdi = 5th reg
+    /* NOTE: Thread entry always starts in Kernel Code */
+    static constexpr auto kFunc =
+        kIsKernelTask ? Sched::KThreadEntrypoint : Sched::UserThreadEntrypoint;
+    static constexpr u64 kInitialFlags =
+        kSingleBit<u64, 1> | kSingleBit<u64, 9>;  // Bit1 - Reserved, Bit9 - Interrupt flag
+
+    static constexpr size_t kStackSpace  = 20 * 8;  // 15 regs + InterruptStackFrame
+    static constexpr size_t kRdiOffset   = 4 * 8;   // rdi = 5th reg
+    static constexpr size_t kRipOffset   = 15 * 8;  // 15 regs
+    static constexpr size_t kCsOffset    = kRipOffset + sizeof(u64);
+    static constexpr size_t kFlagsOffset = kCsOffset + sizeof(u64);
+    static constexpr size_t kSpOffset    = kFlagsOffset + sizeof(u64);
+    static constexpr size_t kSsOffset    = kSpOffset + sizeof(u64);
 
     auto stack_top = static_cast<byte *>(*stack) - kStackSpace;
 
     memset(stack_top, 0, kStackSpace);
     *reinterpret_cast<u64 *>(stack_top + kRdiOffset) = reinterpret_cast<u64>(f);
-    *reinterpret_cast<u64 *>(stack_top + kRipOffset) = reinterpret_cast<u64>(func);
+    *reinterpret_cast<u64 *>(stack_top + kRipOffset) = reinterpret_cast<u64>(kFunc);
+    *reinterpret_cast<u64 *>(stack_top + kCsOffset) =
+        static_cast<u64>(cpu::GDT::kKernelCodeSelector);
+    *reinterpret_cast<u64 *>(stack_top + kSsOffset) =
+        static_cast<u64>(cpu::GDT::kKernelDataSelector);
+    *reinterpret_cast<u64 *>(stack_top + kSpOffset)    = reinterpret_cast<u64>(*stack);
+    *reinterpret_cast<u64 *>(stack_top + kFlagsOffset) = kInitialFlags;
 
     *stack = reinterpret_cast<void *>(stack_top);
 }
 
 namespace arch
 {
-void InitializeStackKThread(void **stack, void (*f)())
-{
-    InitializeStack<Sched::KThreadEntrypoint>(stack, f);
-}
+void InitializeStackKThread(void **stack, void (*f)()) { InitializeStack<true>(stack, f); }
 
-void InitializeStackUserThread(void **stack, void (*f)())
-{
-    DEBUG_INFO_SCHEDULING("XD");
-    InitializeStack<Sched::UserThreadEntrypoint>(stack, f);
-}
+void InitializeStackUserThread(void **stack, void (*f)()) { InitializeStack<false>(stack, f); }
 
 }  // namespace arch
diff --git a/kernel/arch/x86_64/src/hal/impl/scheduling.hpp b/kernel/arch/x86_64/src/hal/impl/scheduling.hpp
index d7061285..8a752866 100644
--- a/kernel/arch/x86_64/src/hal/impl/scheduling.hpp
+++ b/kernel/arch/x86_64/src/hal/impl/scheduling.hpp
@@ -3,15 +3,13 @@
 
 #include "scheduling/thread.hpp"
 
-extern "C" void ConvertToKernelTask(Sched::Thread *thread);
-extern "C" void SwitchToKernelTask(Sched::Thread *thread);
-extern "C" void SwitchToUserTask(Sched::Thread *thread);
+extern "C" void ConvertContext(Sched::Thread *thread);
+extern "C" void ContextSwitch(Sched::Thread *thread);
 
 namespace arch
 {
-using ::ConvertToKernelTask;
-using ::SwitchToKernelTask;
-using ::SwitchToUserTask;
+using ::ContextSwitch;
+using ::ConvertContext;
 void InitializeStackKThread(void **stack, void (*f)());
 void InitializeStackUserThread(void **stack, void (*f)());
 }  // namespace arch
diff --git a/kernel/arch/x86_64/src/hal/impl/time.cpp b/kernel/arch/x86_64/src/hal/impl/time.cpp
index 6d073919..91d62a24 100644
--- a/kernel/arch/x86_64/src/hal/impl/time.cpp
+++ b/kernel/arch/x86_64/src/hal/impl/time.cpp
@@ -22,6 +22,21 @@ NODISCARD FAST_CALL bool PickClock(arch::HardwareClockId clock_id)
     return false;
 }
 
+NODISCARD FAST_CALL bool PickEventClock(arch::HardwareEventClockId clock_id)
+{
+    if (HardwareModule::Get().GetEventClockRegistry().HasKey(clock_id)) {
+        HardwareModule::Get().GetEventClockRegistry().SwitchSelected(clock_id);
+        TRACE_INFO_INTERRUPTS(
+            "Picked %s event clock source as active",
+            data_structures::IntegralToStringArray(static_cast<u64>(clock_id))
+                .GetSafeStr()
+                .GetCStr()
+        );
+        return true;
+    }
+    return false;
+}
+
 // ------------------------------
 // Implementations
 // ------------------------------
@@ -41,6 +56,8 @@ void PickSystemClockSource()
         return;
     }
 
+    R_FAIL_ALWAYS("Support for available clocks is not implemented!");
+
     TODO_DEVICE_SUPPORT
     if (PickClock(HardwareClockId::kRtc)) {
         return;
@@ -59,4 +76,28 @@ void PickSystemClockSource()
     R_FAIL_ALWAYS("Failed to pick system clock source, no clocks available!");
 }
 
+void PickSystemEventClockSource()
+{
+    ASSERT_FALSE(HardwareModule::Get().GetEventClockRegistry().IsSelectedPicked());
+
+    if (PickEventClock(HardwareEventClockId::kLapic)) {
+        return;
+    }
+
+    R_FAIL_ALWAYS("Support for available event clocks is not implemented!");
+
+    TODO_DEVICE_SUPPORT  // NO CORE LOCAl
+        if (PickEventClock(HardwareEventClockId::kHpet))
+    {
+        return;
+    }
+
+    TODO_DEVICE_SUPPORT
+    if (PickEventClock(HardwareEventClockId::kPit)) {
+        return;
+    }
+
+    R_FAIL_ALWAYS("Failed to pick system clock source, no clocks available!");
+}
+
 }  // namespace arch
diff --git a/kernel/arch/x86_64/src/hal/impl/timers.hpp b/kernel/arch/x86_64/src/hal/impl/timers.hpp
index be30fb6f..38eb93fe 100644
--- a/kernel/arch/x86_64/src/hal/impl/timers.hpp
+++ b/kernel/arch/x86_64/src/hal/impl/timers.hpp
@@ -24,6 +24,7 @@ WRAP_CALL time_t QuerySystemTime(const timezone &tz)
 }
 
 void PickSystemClockSource();
+void PickSystemEventClockSource();
 
 }  // namespace arch
 
diff --git a/kernel/arch/x86_64/src/include/regs.nasm b/kernel/arch/x86_64/src/include/regs.nasm
index 0bfb8670..9b015279 100644
--- a/kernel/arch/x86_64/src/include/regs.nasm
+++ b/kernel/arch/x86_64/src/include/regs.nasm
@@ -22,9 +22,6 @@ _r15 equ 112
 ; Size needed to save the sysv registers on the stack
 _sysv_reg_size equ 8*10
 
-; Shadow space required for C++ function calls
-_shadow_space equ 8*4
-
 ; Macro to save all volatile registers (SysV ABI) onto the stack.
 %macro push_sysv_regs 0
     mov qword [rsp + _rax], rax
diff --git a/kernel/arch/x86_64/src/interrupts/idt.cpp b/kernel/arch/x86_64/src/interrupts/idt.cpp
index 60ec55ff..9d383c75 100644
--- a/kernel/arch/x86_64/src/interrupts/idt.cpp
+++ b/kernel/arch/x86_64/src/interrupts/idt.cpp
@@ -5,6 +5,7 @@
 #include <hal/panic.hpp>  // I dislike this import architecturally, but let it be for now
 #include <modules/timing.hpp>
 
+#include "cpu/gdt.hpp"
 #include "cpu/utils.hpp"
 #include "hal/interrupts.hpp"
 #include "interrupts/interrupt_types.hpp"
@@ -41,9 +42,6 @@ static constexpr IdtEntryFlags kSyscallFlags = {
     .present = 1
 };
 
-/* gdt kernel code offset */
-extern "C" u32 kKernelCodeOffset;
-
 /* isr stub table initialized in nasm */
 extern "C" void *IsrWrapperTable[];
 
@@ -57,9 +55,10 @@ extern "C" void *IsrWrapperTable[];
  *
  * @param idt_idx index of interrupt triggered.
  */
-NO_RET void DefaultInterruptHandler(const u8 idt_idx)
+NO_RET void *DefaultInterruptHandler(const u8 idt_idx)
 {
     hal::KernelPanicFormat("Received unsupported interrupt with code: %hhu\n", idt_idx);
+    return nullptr;
 }
 
 static void FormatIsrRegisters(
@@ -118,9 +117,10 @@ NO_RET FAST_CALL void DefaultExceptionHandler(
     );
 }
 
-void DefaultExceptionHandler(intr::LitExcEntry &entry, hal::ExceptionData *data)
+void *DefaultExceptionHandler(intr::LitExcEntry &entry, hal::ExceptionData *data)
 {
     DefaultExceptionHandler(data, entry.hardware_irq);
+    return nullptr;
 }
 
 FAST_CALL void LogIrqReceived(const u16 idt_idx, const u16 lirq)
@@ -128,31 +128,10 @@ FAST_CALL void LogIrqReceived(const u16 idt_idx, const u16 lirq)
     TRACE_FREQ_INFO_INTERRUPTS("Received interrupt with idt idx: %hu and lirq: %hu", idt_idx, lirq);
 }
 
-void SimpleIrqHandler(intr::LitHwEntry &entry)
+void *SimpleIrqHandler(intr::LitHwEntry &entry)
 {
     LogIrqReceived(entry.hardware_irq, entry.logical_irq);
-}
-
-void TimerIsr(intr::LitHwEntry &)
-{
-    // LogIrqReceived(entry.hardware_irq, entry.logical_irq);
-
-    // TODO: Temporary code
-    static u64 counter = 0;
-    if (!FeatureEnabled<FeatureFlag::kRunTestMode> && counter++ % 33 == 0) {
-        static constexpr size_t kBuffSize = 256;
-        char buff[kBuffSize]{};
-
-        if (TimingModule::IsInited()) {
-            const auto t = time(nullptr);
-            strftime(buff, kBuffSize, "%Y-%m-%d %H:%M:%S", localtime(&t));
-        }
-
-        TRACE_INFO_TIME(
-            "Kernel time update: %s, have a nice day!",
-            TimingModule::IsInited() ? buff : "Timing module is not initialized!"
-        );
-    }
+    return nullptr;
 }
 
 // ------------------------------
@@ -194,7 +173,7 @@ static void IdtSetDescriptor(Idt &idt, const u8 idx, const u64 isr, const IdtEnt
     IdtEntry &entry = idt.idt[idx];
 
     entry.isr_low    = isr & kBitMask16;
-    entry.kernel_cs  = kKernelCodeOffset;
+    entry.kernel_cs  = cpu::GDT::kKernelCodeSelector;
     entry.ist        = 0;
     entry.attributes = flags;
     entry.isr_mid    = (isr >> 16) & kBitMask16;
@@ -204,8 +183,8 @@ static void IdtSetDescriptor(Idt &idt, const u8 idx, const u64 isr, const IdtEnt
 
 void arch::Interrupts::InitializeDefaultIdt_()
 {
-    R_ASSERT_LT(kKernelCodeOffset, static_cast<u32>(UINT16_MAX));
-    R_ASSERT_NEQ(static_cast<u32>(0), kKernelCodeOffset);
+    R_ASSERT_LT(cpu::GDT::kKernelCodeSelector, static_cast<u32>(UINT16_MAX));
+    R_ASSERT_NEQ(static_cast<u32>(0), cpu::GDT::kKernelCodeSelector);
 
     idt_.idtr.base  = reinterpret_cast<uintptr_t>(idt_.idt);
     idt_.idtr.limit = static_cast<u16>(sizeof(IdtEntry)) * kIdtEntries - 1;
diff --git a/kernel/arch/x86_64/src/interrupts/idt.hpp b/kernel/arch/x86_64/src/interrupts/idt.hpp
index a76e3e33..7d9ef79c 100644
--- a/kernel/arch/x86_64/src/interrupts/idt.hpp
+++ b/kernel/arch/x86_64/src/interrupts/idt.hpp
@@ -121,9 +121,8 @@ struct Idt {
 // ------------------------------
 
 const char *GetExceptionMsg(u8 idx);
-void DefaultInterruptHandler(u8 idt_idx);
-void DefaultExceptionHandler(intr::LitExcEntry &entry, hal::ExceptionData *data);
-void SimpleIrqHandler(intr::LitHwEntry &entry);
-void TimerIsr(intr::LitHwEntry &entry);
+void *DefaultInterruptHandler(u8 idt_idx);
+void *DefaultExceptionHandler(intr::LitExcEntry &entry, hal::ExceptionData *data);
+void *SimpleIrqHandler(intr::LitHwEntry &entry);
 
 #endif  // KERNEL_ARCH_X86_64_SRC_INTERRUPTS_IDT_HPP_
diff --git a/kernel/arch/x86_64/src/interrupts/idt.nasm b/kernel/arch/x86_64/src/interrupts/idt.nasm
index 5d35dcea..b9941c8f 100644
--- a/kernel/arch/x86_64/src/interrupts/idt.nasm
+++ b/kernel/arch/x86_64/src/interrupts/idt.nasm
@@ -12,12 +12,12 @@ isr_wrapper_%+%1:
     push 0                      ; Push a dummy error code for alignment.
     sub rsp, _all_reg_size          ; Allocate space for saving registers.
     push_all_regs                   ; Save registers.
-    sub rsp, _shadow_space      ; Allocate shadow space.
+
     cld                         ; Clear direction flag.
     mov rdi, %1                 ; Arg1: interrupt number.
-    lea rsi, [rsp + _shadow_space] ; Arg2: pointer to stack frame.
+    mov rsi, rsp                ; Arg2: pointer to stack frame.
     call HandleException
-    add rsp, _shadow_space      ; Deallocate shadow space.
+
     pop_all_regs                    ; Restore registers.
     add rsp, _all_reg_size          ; Deallocate register save space.
     add rsp, 8                  ; Pop dummy error code.
@@ -30,12 +30,12 @@ isr_wrapper_%+%1:
 isr_wrapper_%+%1:
     sub rsp, _all_reg_size          ; Allocate space for saving registers.
     push_all_regs                   ; Save registers.
-    sub rsp, _shadow_space      ; Allocate shadow space.
+
     cld                         ; Clear direction flag.
     mov rdi, %1                 ; Arg1: interrupt number.
-    lea rsi, [rsp + _shadow_space] ; Arg2: pointer to stack frame.
+    mov rsi, rsp                ; Arg2: pointer to stack frame.
     call HandleException
-    add rsp, _shadow_space      ; Deallocate shadow space.
+
     pop_all_regs                    ; Restore registers.
     add rsp, _all_reg_size          ; Deallocate register save space.
     add rsp, 8                  ; Pop error code.
@@ -48,11 +48,11 @@ isr_wrapper_%+%1:
 isr_wrapper_%+%2:
     sub rsp, _sysv_reg_size          ; Allocate space for saving registers.
     push_sysv_regs                   ; Save registers.
-    sub rsp, _shadow_space      ; Allocate shadow space for function calls.
+
     cld                         ; Clear direction flag for string operations.
     mov rdi, %1                 ; Pass the mapped IRQ number as the first argument.
     call %3                     ; Call the specific ISR handler.
-    add rsp, _shadow_space      ; Deallocate shadow space.
+
     pop_sysv_regs                    ; Restore registers.
     add rsp, _sysv_reg_size          ; Deallocate register save space.
     iretq                       ; Return from interrupt.
@@ -108,6 +108,7 @@ isr_wrapper_128:  ; Syscall interrupt (128)
 extern HandleException
 extern HandleHardwareInterrupt
 extern HandleSoftwareInterrupt
+extern TimerContextSwitch
 
 ; Intel-defined interrupts (0-31) -> HandleException
 exception_wrapper 0  ; Division Error: Divide by zero error
@@ -144,7 +145,7 @@ exception_error_wrapper 30 ; Security Exception: Security-related error
 exception_wrapper 31 ; Reserved: Reserved by Intel
 
 ; IRQs for PICs (32–47) -> HandleHardwareInterrupt
-interrupt_wrapper 0, 32, HandleHardwareInterrupt ; IRQ0: System timer
+; DEFINED in SCHEDULING FILE ; IRQ0: System timer
 interrupt_wrapper 1, 33, HandleHardwareInterrupt ; IRQ1: Keyboard
 interrupt_wrapper 2, 34, HandleHardwareInterrupt ; IRQ2: Cascade
 interrupt_wrapper 3, 35, HandleHardwareInterrupt ; IRQ3: Serial port 2
@@ -202,7 +203,15 @@ section .data
 global IsrWrapperTable
 IsrWrapperTable:
 %assign i 0
-%rep    _num_isrs
+%rep    32
+    dq isr_wrapper_%+i
+%assign i i+1
+%endrep
+
+dq TimerContextSwitch
+
+%assign i 33
+%rep    31
     dq isr_wrapper_%+i
 %assign i i+1
 %endrep
diff --git a/kernel/arch/x86_64/src/scheduling/scheduling.nasm b/kernel/arch/x86_64/src/scheduling/scheduling.nasm
index 812455d7..91758041 100644
--- a/kernel/arch/x86_64/src/scheduling/scheduling.nasm
+++ b/kernel/arch/x86_64/src/scheduling/scheduling.nasm
@@ -11,37 +11,79 @@ extern cdecl_GetCurrentTCB
 extern cdecl_SetCurrentTCB
 extern cdecl_GetThreadsPageTable
 extern cdecl_SetTssRsp0
+extern cdecl_EnableHardwareInterrupts
+extern HandleHardwareInterrupt
+
+_context_switch_stack_space equ 20*8
+_context_switch_stack_space_ext equ 19*8; 8 bytes already reserved by caller
+_rip_call_offset equ _context_switch_stack_space_ext
+_rip_int_frame_offset equ _all_reg_size
+_cs_int_frame_offset equ _rip_int_frame_offset + 8
+_flags_int_frame_offset equ _cs_int_frame_offset + 8
+_sp_int_frame_offset equ _flags_int_frame_offset + 8
+_ss_int_frame_offset equ _sp_int_frame_offset + 8
+_kernel_code_selector equ 0x08
+_kernel_data_selector equ 0x10
+_user_code_selector equ 0x18
+_user_data_selector equ 0x20
 
 section .text
-global SwitchToKernelTask
-global SwitchToUserTask
-global ConvertToKernelTask
+global ContextSwitch
+global ConvertContext
+global TimerContextSwitch
 
 ; c_decl
-; void ConvertToKernelTask(Thread* thread)
+; void ConvertContext(Thread* thread)
 ;   RDI = thread
 ; Note: Caller is responsible for ensuring proper environment before calling (disabling IRQs)
-ConvertToKernelTask:
+; Note: ASSUMPTION ConvertContext is always called inside KERNEL code
+ConvertContext:
     mov r12, rdi                          ; Save next TCB pointer in r12 (non-volatile) to survive C++ calls
     call cdecl_SetCurrentTCB              ; Change TCB
     mov  rsp, [r12+Thread.kernel_stack]   ; Change the stack
 
+    mov rdi, [r12+Thread.kernel_stack_bottom]
+    call cdecl_SetTssRsp0
+
     pop_all_regs                    ; Restore registers of NEW thread's stack
     add rsp, _all_reg_size          ; Deallocate register save space.
 
-    ret                             ; Load next thread's RIP from its stack
+    iretq
 
 ; c_decl
-; void SwitchToKernelTask(Thread* thread)
+; void ContextSwitch(Thread* thread)
 ;   RDI = thread
 ; Note: Caller is responsible for ensuring proper environment before calling (disabling IRQs)
-SwitchToKernelTask:
+; Note: ASSUMPTION ContextSwitch is always called inside KERNEL code
+ContextSwitch:
     ; ------------------------
     ; Save current task state
 
-    sub rsp, _all_reg_size             ; Allocate space for saving registers.
+    sub rsp, _context_switch_stack_space_ext             ; Allocate space for saving registers.
     push_all_regs                      ; Save registers of calling TCB on ITS stack
 
+    ; Move RIP from call to align with Interrupt frame
+    ; RIP
+    mov r12, [rsp + _rip_call_offset]
+    mov [rsp + _rip_int_frame_offset], r12
+
+    ; CS
+    mov qword [rsp + _cs_int_frame_offset], _kernel_code_selector
+
+    ; FLAGS
+    pushfq
+    pop r12
+    or r12, 0x200 ; Ensure Interrupts are enabled after the context switch
+    mov qword [rsp + _flags_int_frame_offset], r12
+
+    ; RSP
+    mov r13, rsp
+    add r13, _context_switch_stack_space
+    mov [rsp + _sp_int_frame_offset], r13
+
+    ; SS
+    mov qword [rsp + _ss_int_frame_offset], _kernel_data_selector
+
     mov r12, rdi                       ; Save next TCB pointer in r12 (non-volatile) to survive C++ calls
 
     call cdecl_GetCurrentTCB           ; RAX = pointer to TCB
@@ -54,6 +96,9 @@ SwitchToKernelTask:
     call cdecl_SetCurrentTCB
     mov rsp, [r12+Thread.kernel_stack]   ; Change the stack
 
+    mov rdi, [r12+Thread.kernel_stack_bottom]
+    call cdecl_SetTssRsp0
+
     mov rdi, r12                       ; Set RDI for GetThreadsPageTable
     call cdecl_GetThreadsPageTable     ; RAX = next cr3
     mov r11, cr3                       ; R11 = current cr3
@@ -63,51 +108,48 @@ SwitchToKernelTask:
     mov cr3, rax                       ; Load next task's virtual address space
 
 .done:
-
     pop_all_regs                    ; Restore registers of NEW thread's stack
     add rsp, _all_reg_size          ; Deallocate register save space.
 
-    ret                             ; Load next thread's RIP from its stack
+    iretq                             ; Load next thread's RIP from its stack
 
 ; c_decl
-; void SwitchToUserTask(Thread* thread)
-;   RDI = thread
-; Note: Caller is responsible for ensuring proper environment before calling (disabling IRQs)
-SwitchToUserTask:
-    ret
-
-;    ; ------------------------
-;    ; Save current task state
-;
-;    sub rsp, _all_reg_size          ; Allocate space for saving registers.
-;    push_all_regs                   ; Save registers of calling TCB on ITS stack
-;
-;    mov r12, rdi                     ; Save next TCB pointer in r12 (non-volatile) to survive C++ calls
-;
-;    call cdecl_GetCurrentTCB           ; RAX = pointer to TCB
-;    mov [rax+Thread.kernel_stack], rsp ; Save RSP for previous task's kernel stack in the thread's TCB
-;
-;    ; ------------------------
-;    ; Setup next task state
-;
-;    mov rdi, r12                       ; Restore next TCB pointer to RDI for the next call
-;    call cdecl_SetCurrentTCB
-;    mov rsp, [r12+Thread.user_stack]   ; Change the stack
-;
-;    mov rdi, r12                     ; Set RDI for GetThreadsPageTable
-;    call cdecl_GetThreadsPageTable     ; RAX = next cr3
-;    mov r11, cr3                       ; R11 = current cr3
-;
-;    mov rdi, [r12+Thread.kernel_stack] ; Load next task's kernel stack
-;    call cdecl_SetTssRsp0
-;
-;    cmp r11, rax ; Skip virtual address space change if not needed - omit tlb flushes
-;    je .done
-;    mov cr3, rax ; Load next task's virtual address space
-;
-;.done:
-;
-;    pop_all_regs                    ; Restore registers of NEW thread's stack
-;    add rsp, _all_reg_size          ; Deallocate register save space.
-;
-;    ret ; Load next thread's RIP from its stack
+; void TimerContextSwitch(void)
+TimerContextSwitch:
+    sub rsp, _all_reg_size           ; Allocate space for saving registers.
+    push_all_regs                   ; Save registers.
+
+    mov rdi, 0                       ; Pass the mapped IRQ number as the first argument.
+    call HandleHardwareInterrupt    ; Call the specific ISR handler.
+
+    cmp rax, 0
+    je .done                         ; Omit context switch if there is no need to change it
+
+    mov r13, rax                     ; save next TCB
+
+    call cdecl_GetCurrentTCB           ; RAX = pointer to TCB
+    mov [rax+Thread.kernel_stack], rsp ; Save RSP for previous task's kernel stack in the thread's TCB
+
+    ; ------------------------
+    ; Setup next task state
+
+    mov rdi, r13                         ; Restore next TCB pointer to RDI for the next call
+    call cdecl_SetCurrentTCB
+    mov rsp, [r13+Thread.kernel_stack]   ; Change the stack
+
+    mov rdi, [r13+Thread.kernel_stack_bottom]
+    call cdecl_SetTssRsp0
+
+    mov rdi, r13                       ; Set RDI for GetThreadsPageTable
+    call cdecl_GetThreadsPageTable     ; RAX = next cr3
+    mov r11, cr3                       ; R11 = current cr3
+
+    cmp r11, rax                       ; Skip virtual address space change if not needed - omit tlb flushes
+    je .done
+    mov cr3, rax                       ; Load next task's virtual address space
+
+.done:
+    pop_all_regs                     ; Restore registers.
+    add rsp, _all_reg_size           ; Deallocate register save space.
+
+    iretq                            ; Return from interrupt.
diff --git a/kernel/arch/x86_64/src/tests/interrupts_tests.cpp b/kernel/arch/x86_64/src/tests/interrupts_tests.cpp
index 4d6d61a6..f5ec3650 100644
--- a/kernel/arch/x86_64/src/tests/interrupts_tests.cpp
+++ b/kernel/arch/x86_64/src/tests/interrupts_tests.cpp
@@ -6,7 +6,7 @@
 // Preserve cpu state test
 // ------------------------------
 
-static void PolluteAllRegistersSw(intr::LitSwEntry &)
+static void *PolluteAllRegistersSw(intr::LitSwEntry &)
 {
     /* pollute all registers possible */
     __asm__ volatile("movq $-1, %%rax" : : : "rax");
@@ -23,11 +23,13 @@ static void PolluteAllRegistersSw(intr::LitSwEntry &)
     __asm__ volatile("movq $-1, %%r13" : : : "r13");
     __asm__ volatile("movq $-1, %%r14" : : : "r14");
     __asm__ volatile("movq $-1, %%r15" : : : "r15");
+
+    return nullptr;
 }
 
 static DumpedRegisters g_DumpedRegisters{};
 
-static void DivZeroExceptionHandler(intr::LitExcEntry &, hal::ExceptionData *data)
+static void *DivZeroExceptionHandler(intr::LitExcEntry &, hal::ExceptionData *data)
 {
     g_DumpedRegisters.rax = data->registers.rax;
     g_DumpedRegisters.rbx = data->registers.rbx;
@@ -49,6 +51,7 @@ static void DivZeroExceptionHandler(intr::LitExcEntry &, hal::ExceptionData *dat
     g_DumpedRegisters.r15 = data->registers.r15;
 
     TraceDumpedRegisters(&g_DumpedRegisters);
+    return nullptr;
 }
 
 void ExceptionTestSavesAllRegisters()
diff --git a/kernel/src/acpi/osl.cpp b/kernel/src/acpi/osl.cpp
index 0816a562..f9f6cc27 100644
--- a/kernel/src/acpi/osl.cpp
+++ b/kernel/src/acpi/osl.cpp
@@ -193,10 +193,11 @@ struct UacpiInterrupt {
     uacpi_handle ctx;
 };
 
-static void UacpiHander(intr::LitHwEntry &handler)
+static void *UacpiHander(intr::LitHwEntry &handler)
 {
     auto *uacpi_interrupt = static_cast<UacpiInterrupt *>(handler.handler_data.data);
     uacpi_interrupt->uacpi_handler(uacpi_interrupt->ctx);
+    return nullptr;
 }
 
 uacpi_status uacpi_kernel_install_interrupt_handler(
diff --git a/kernel/src/hal/debug.hpp b/kernel/src/hal/debug.hpp
index f55953e8..7a8d5e9d 100644
--- a/kernel/src/hal/debug.hpp
+++ b/kernel/src/hal/debug.hpp
@@ -3,6 +3,8 @@
 
 #include <hal/impl/debug.hpp>
 
+#include <defines.hpp>
+
 namespace hal
 {
 /**
diff --git a/kernel/src/hal/scheduling.hpp b/kernel/src/hal/scheduling.hpp
index acfb0c69..8beaabda 100644
--- a/kernel/src/hal/scheduling.hpp
+++ b/kernel/src/hal/scheduling.hpp
@@ -8,9 +8,8 @@
 
 namespace hal
 {
-WRAP_CALL void SwitchToKernelTask(Sched::Thread *thread) { arch::SwitchToKernelTask(thread); }
-WRAP_CALL void SwitchToUserTask(Sched::Thread *thread) { arch::SwitchToUserTask(thread); }
-WRAP_CALL void ConvertToKernelTask(Sched::Thread *thread) { arch::ConvertToKernelTask(thread); }
+WRAP_CALL void ContextSwitch(Sched::Thread *thread) { arch::ContextSwitch(thread); }
+WRAP_CALL void ConvertContext(Sched::Thread *thread) { arch::ConvertContext(thread); }
 WRAP_CALL void InitializeStackKThread(void **stack, void (*f)())
 {
     arch::InitializeStackKThread(stack, f);
diff --git a/kernel/src/hal/timers.hpp b/kernel/src/hal/timers.hpp
index aff45980..9146cbe5 100644
--- a/kernel/src/hal/timers.hpp
+++ b/kernel/src/hal/timers.hpp
@@ -18,7 +18,8 @@ WRAP_CALL time_t QuerySystemTime(const timezone &tz) { return arch::QuerySystemT
  *
  * @note All clock sources should be registered before this function is called.
  */
-WRAP_CALL void PickSystemClockSource() { return arch::PickSystemClockSource(); }
+WRAP_CALL void PickSystemClockSource() { arch::PickSystemClockSource(); }
+WRAP_CALL void PickSystemEventClockSource() { arch::PickSystemEventClockSource(); }
 }  // namespace hal
 
 #endif  // KERNEL_SRC_HAL_TIMERS_HPP_
diff --git a/kernel/src/hardware/event_clock_infra.hpp b/kernel/src/hardware/event_clock_infra.hpp
index f800855e..53ec3da3 100644
--- a/kernel/src/hardware/event_clock_infra.hpp
+++ b/kernel/src/hardware/event_clock_infra.hpp
@@ -8,10 +8,12 @@
 
 namespace hardware
 {
-enum class EventClockFeatures : u8 {
-    kIsCoreLocal = 0,  // Clock is local to the core
-    kLast,
+
+struct PACK EventClockFlags {
+    bool IsCoreLocal : 1;
+    u32 padding : 31;
 };
+static_assert(sizeof(EventClockFlags) == sizeof(u32));
 
 enum class EventClockState : u8 {
     kDisabled = 0,  // Clock is disabled
@@ -24,11 +26,10 @@ enum class EventClockState : u8 {
 struct alignas(arch::kCacheLineSizeBytes) EventClockRegistryEntry : data_structures::RegistryEntry {
     /* Clock numbers */
     u64 min_next_event_time_ns;  // Minimum time for the next event in nanoseconds
-    u64 max_event_time_ns;       // Maximum time for the event in nanoseconds
 
     /* Clock specific data */
-    data_structures::BitArray<32> features;  // Features of the event clock, e.g., core-local
-    CoreMask supported_cores;                // Cores that support this event clock
+    EventClockFlags flags;     // Features of the event clock, e.g., core-local
+    CoreMask supported_cores;  // Cores that support this event clock
 
     /* infra data */
     u64 next_event_time_ns;  // Time for the next event in nanoseconds
@@ -45,6 +46,8 @@ struct alignas(arch::kCacheLineSizeBytes) EventClockRegistryEntry : data_structu
         u32 (*next_event)(EventClockRegistryEntry *, u64);  // Callback to set next event time
         u32 (*set_oneshot)(EventClockRegistryEntry *);      // Callback to set clock state
         u32 (*set_periodic)(EventClockRegistryEntry *);     // Callback to set clock state
+        void (*on_entry)(EventClockRegistryEntry *);        // optional
+        void (*on_exit)(EventClockRegistryEntry *);         // optional
     } cbs;
 };
 
diff --git a/kernel/src/init.cpp b/kernel/src/init.cpp
index 8ff34aa5..bae1ad25 100644
--- a/kernel/src/init.cpp
+++ b/kernel/src/init.cpp
@@ -43,7 +43,7 @@ void KernelInit(const hal::RawBootArguments &raw_args)
     /* Extract all necessary data from ACPI tables */
     HardwareModule::Get().GetACPIController().ParseTables();
 
-    /* Allow hardware to fully initialise interrupt system */
+    /* Allow hardware to fully initialize interrupt system */
     HardwareModule::Get().GetInterrupts().Init();
 
     TimingModule::Init();
diff --git a/kernel/src/interrupts/interrupt_types.hpp b/kernel/src/interrupts/interrupt_types.hpp
index d738c891..96f5f248 100644
--- a/kernel/src/interrupts/interrupt_types.hpp
+++ b/kernel/src/interrupts/interrupt_types.hpp
@@ -15,11 +15,11 @@ enum class InterruptType : uint8_t {
 template <InterruptType kInterruptType>
 struct InterruptHandlerEntry {
     /* Interrupt handler */
-    using InterruptHandler = void (*)(InterruptHandlerEntry &entry);
-    using InterruptHandlerException =
-        void (*)(InterruptHandlerEntry &entry, hal::ExceptionData *data);
-    using HandlerType = std::conditional_t<
-        kInterruptType == InterruptType::kException, InterruptHandlerException, InterruptHandler>;
+    using InterruptHandler          = void *(*)(InterruptHandlerEntry & entry);
+    using InterruptHandlerException = void *(*)(InterruptHandlerEntry & entry,
+                                                hal::ExceptionData *data);
+    using HandlerType               = std::conditional_t<
+                      kInterruptType == InterruptType::kException, InterruptHandlerException, InterruptHandler>;
 
     /* Interrupt driver */
     struct InterruptDriver {
diff --git a/kernel/src/interrupts/interrupts.cpp b/kernel/src/interrupts/interrupts.cpp
index 7a687965..18ea3f8d 100644
--- a/kernel/src/interrupts/interrupts.cpp
+++ b/kernel/src/interrupts/interrupts.cpp
@@ -3,22 +3,22 @@
 // Assembly interface
 // ------------------------------
 
-extern "C" void HandleException(const u16 lirq, hal::ExceptionData *data)
+extern "C" void *HandleException(const u16 lirq, hal::ExceptionData *data)
 {
-    HardwareModule::Get().GetInterrupts().GetLit().HandleInterrupt(lirq, data);
+    return HardwareModule::Get().GetInterrupts().GetLit().HandleInterrupt(lirq, data);
 }
 
-extern "C" void HandleHardwareInterrupt(const u16 lirq)
+extern "C" void *HandleHardwareInterrupt(const u16 lirq)
 {
-    HardwareModule::Get()
+    return HardwareModule::Get()
         .GetInterrupts()
         .GetLit()
         .HandleInterrupt<intr::InterruptType::kHardwareInterrupt>(lirq);
 }
 
-extern "C" void HandleSoftwareInterrupt(const u16 lirq)
+extern "C" void *HandleSoftwareInterrupt(const u16 lirq)
 {
-    HardwareModule::Get()
+    return HardwareModule::Get()
         .GetInterrupts()
         .GetLit()
         .HandleInterrupt<intr::InterruptType::kSoftwareInterrupt>(lirq);
diff --git a/kernel/src/interrupts/logical_interrupt_table.hpp b/kernel/src/interrupts/logical_interrupt_table.hpp
index 93bb33ff..557ed2af 100644
--- a/kernel/src/interrupts/logical_interrupt_table.hpp
+++ b/kernel/src/interrupts/logical_interrupt_table.hpp
@@ -40,7 +40,7 @@ class LogicalInterruptTable
     // Class interaction
     // ------------------------------
 
-    FORCE_INLINE_F void HandleInterrupt(const u16 lirq, hal::ExceptionData *data)
+    FORCE_INLINE_F void *HandleInterrupt(const u16 lirq, hal::ExceptionData *data)
     {
         hardware::GetCoreLocalData().nested_interrupts++;
         hal::FullMemFence();
@@ -50,15 +50,17 @@ class LogicalInterruptTable
         auto &entry = GetTable_<InterruptType::kException>()[lirq];
 
         /* Exception MUST be handled */
-        (*entry.handler_data.handler)(entry, data);
+        void *rv = (*entry.handler_data.handler)(entry, data);
 
-        hal::FullMemFence();
         hardware::GetCoreLocalData().nested_interrupts--;
+        hal::FullMemFence();
+
+        return rv;
     }
 
     template <InterruptType kInterruptType>
         requires(kInterruptType != InterruptType::kException)
-    FORCE_INLINE_F void HandleInterrupt(const u16 lirq)
+    FORCE_INLINE_F void *HandleInterrupt(const u16 lirq)
     {
         hardware::GetCoreLocalData().nested_interrupts++;
         hal::FullMemFence();
@@ -67,8 +69,9 @@ class LogicalInterruptTable
         ASSERT_FALSE(IsUnmapped_<kInterruptType>(lirq));
         auto &entry = GetTable_<kInterruptType>()[lirq];
 
+        void *rv = nullptr;
         if (entry.handler_data.handler) {
-            (*entry.handler_data.handler)(entry);
+            rv = (*entry.handler_data.handler)(entry);
         }
 
         if constexpr (kInterruptType == InterruptType::kHardwareInterrupt) {
@@ -76,8 +79,17 @@ class LogicalInterruptTable
             entry.driver->cbs.ack(entry);
         }
 
-        hal::FullMemFence();
         hardware::GetCoreLocalData().nested_interrupts--;
+        hal::FullMemFence();
+
+        return rv;
+    }
+
+    template <InterruptType kInterruptType>
+    FORCE_INLINE_F u64 TranslateToHw(const u16 lirq)
+    {
+        ASSERT_LT(lirq, GetTableSize_<kInterruptType>());
+        return GetTable_<kInterruptType>()[lirq].hardware_irq;
     }
 
     template <InterruptType kInterruptType>
diff --git a/kernel/src/kernel.cpp b/kernel/src/kernel.cpp
index 4e95538c..51afe0f0 100644
--- a/kernel/src/kernel.cpp
+++ b/kernel/src/kernel.cpp
@@ -18,6 +18,7 @@
 #include "drivers/apic/local_apic.hpp"
 #include "hal/boot_args.hpp"
 #include "modules/hardware.hpp"
+#include "modules/scheduling.hpp"
 #include "todo.hpp"
 
 extern void KernelInit(const hal::RawBootArguments &);
@@ -27,29 +28,31 @@ static void KernelRun()
     TRACE_INFO_GENERAL("Hello from AlkOS!");
     trace::Flush();
 
-    auto &video = VideoModule::Get();
-    Graphics::Painter painter(video.GetScreen(), video.GetFormat());
-    Graphics::Psf2Font font(drdos8x8_psfu);
+    SchedulingModule::Get().GetScheduler().ConvertToScheduling();
 
-    if (!font.IsValid()) {
-        TRACE_WARN_VIDEO("Invalid font");
-    }
-
-    System::GraphicsConsole console(painter, font);
-    System::Shell shell(console, HardwareModule::Get().GetPs2Keyboard());
-
-    shell.Init();
-    video.Flush();
-
-    while (true) {
-        shell.Update();
-        video.Flush();
-
-        // TODO: Replace with CpuHalt or smth like scheduler sleep.
-        for (volatile i32 i = 0; i < 10000; ++i) {
-        }
-        trace::Flush();
-    }
+    // auto &video = VideoModule::Get();
+    // Graphics::Painter painter(video.GetScreen(), video.GetFormat());
+    // Graphics::Psf2Font font(drdos8x8_psfu);
+    //
+    // if (!font.IsValid()) {
+    //     TRACE_WARN_VIDEO("Invalid font");
+    // }
+    //
+    // System::GraphicsConsole console(painter, font);
+    // System::Shell shell(console, HardwareModule::Get().GetPs2Keyboard());
+    //
+    // shell.Init();
+    // video.Flush();
+    //
+    // while (true) {
+    //     shell.Update();
+    //     video.Flush();
+    //
+    //     // TODO: Replace with CpuHalt or smth like scheduler sleep.
+    //     for (volatile i32 i = 0; i < 10000; ++i) {
+    //     }
+    //     trace::Flush();
+    // }
 }
 
 extern "C" void KernelMain(const Mem::PPtr<hal::RawBootArguments> raw_args)
diff --git a/kernel/src/mem/virt/addr_space.hpp b/kernel/src/mem/virt/addr_space.hpp
index a52e4bf6..e8edf4f8 100644
--- a/kernel/src/mem/virt/addr_space.hpp
+++ b/kernel/src/mem/virt/addr_space.hpp
@@ -89,7 +89,7 @@ class AddressSpace
 
     // Friends
     friend VirtualMemoryManager;
-    friend void PageFaultHandler(intr::LitExcEntry &entry, hal::ExceptionData *data);
+    friend void *PageFaultHandler(intr::LitExcEntry &entry, hal::ExceptionData *data);
 
     public:
 };
diff --git a/kernel/src/mem/virt/page_fault.cpp b/kernel/src/mem/virt/page_fault.cpp
index a530a401..f1b877f3 100644
--- a/kernel/src/mem/virt/page_fault.cpp
+++ b/kernel/src/mem/virt/page_fault.cpp
@@ -14,7 +14,7 @@
 namespace Mem
 {
 
-void PageFaultHandler(intr::LitExcEntry &, hal::ExceptionData *data)
+void *PageFaultHandler(intr::LitExcEntry &, hal::ExceptionData *data)
 {
     TRACE_INFO_GENERAL("PageFaultHandler()");
     using namespace hal;
@@ -33,7 +33,7 @@ void PageFaultHandler(intr::LitExcEntry &, hal::ExceptionData *data)
     auto area_or_error = as.FindArea(f_ptr);
     if (!area_or_error) {
         KernelPanicFormat("Page fault in unmapped memory at %p", f_ptr);
-        return;
+        return nullptr;
     }
     VPtr<VMemArea> vma_ptr = *area_or_error;
     const auto &vma        = *vma_ptr;
@@ -41,7 +41,7 @@ void PageFaultHandler(intr::LitExcEntry &, hal::ExceptionData *data)
     if (!err.present) {  // Page just wasn't there
         if (err.write && !vma.flags.writable) {
             hal::KernelPanicFormat("Write to read-only memory area at %p", f_ptr);
-            return;
+            return nullptr;
         }
 
         auto &pmm = MemoryModule::Get().GetBitmapPmm();
@@ -70,7 +70,7 @@ void PageFaultHandler(intr::LitExcEntry &, hal::ExceptionData *data)
             hal::KernelPanicFormat(
                 "Unsupported VMA type %d at %p", static_cast<int>(vma.type), f_ptr
             );
-            return;
+            return nullptr;
         }
 
         hal::PageFlags page_flags{
@@ -99,10 +99,11 @@ void PageFaultHandler(intr::LitExcEntry &, hal::ExceptionData *data)
         TRACE_INFO_GENERAL(
             "Handled page fault at %p by mapping to physical page at %p", f_ptr, map_to
         );
-        return;
+        return nullptr;
     }
 
     hal::KernelPanicFormat("Unhandled page fault type at 0x%p", f_ptr);
+    return nullptr;
 }
 
 }  // namespace Mem
diff --git a/kernel/src/mem/virt/page_fault.hpp b/kernel/src/mem/virt/page_fault.hpp
index d97c9795..250ba368 100644
--- a/kernel/src/mem/virt/page_fault.hpp
+++ b/kernel/src/mem/virt/page_fault.hpp
@@ -7,7 +7,7 @@
 namespace Mem
 {
 
-void PageFaultHandler(intr::LitExcEntry &entry, hal::ExceptionData *data);
+void *PageFaultHandler(intr::LitExcEntry &entry, hal::ExceptionData *data);
 
 }  // namespace Mem
 
diff --git a/kernel/src/modules/hardware.cpp b/kernel/src/modules/hardware.cpp
index 1cbc11eb..21c20f2e 100644
--- a/kernel/src/modules/hardware.cpp
+++ b/kernel/src/modules/hardware.cpp
@@ -3,9 +3,10 @@
 
 #include "trace_framework.hpp"
 
-static void Ps2KeyboardHandler(intr::LitHwEntry &)
+static void *Ps2KeyboardHandler(intr::LitHwEntry &)
 {
     HardwareModule::Get().GetPs2Keyboard().OnInterrupt();
+    return nullptr;
 }
 
 internal::HardwareModule::HardwareModule() noexcept
diff --git a/kernel/src/modules/scheduling.hpp b/kernel/src/modules/scheduling.hpp
index 7aeda93a..e607a312 100644
--- a/kernel/src/modules/scheduling.hpp
+++ b/kernel/src/modules/scheduling.hpp
@@ -5,6 +5,7 @@
 
 #include "modules/helpers.hpp"
 #include "scheduling/processes.hpp"
+#include "scheduling/scheduler.hpp"
 #include "scheduling/task_mgr.hpp"
 #include "scheduling/threads.hpp"
 
@@ -26,6 +27,7 @@ class SchedulingModule : template_lib::StaticSingletonHelper
     DEFINE_MODULE_FIELD(Sched, Processes)
     DEFINE_MODULE_FIELD(Sched, Threads)
     DEFINE_MODULE_FIELD(Sched, TaskMgr)
+    DEFINE_MODULE_FIELD(Sched, Scheduler)
 
     public:
 };
diff --git a/kernel/src/modules/timing.hpp b/kernel/src/modules/timing.hpp
index 1c79f6f4..f1f2c6c7 100644
--- a/kernel/src/modules/timing.hpp
+++ b/kernel/src/modules/timing.hpp
@@ -5,6 +5,7 @@
 
 #include "modules/helpers.hpp"
 #include "modules/timing_constants.hpp"
+#include "time/event_framework.hpp"
 #include "time/system_time.hpp"
 
 namespace internal
@@ -28,6 +29,7 @@ class TimingModule : template_lib::StaticSingletonHelper
     // ------------------------------
 
     DEFINE_MODULE_FIELD(timing, SystemTime)
+    DEFINE_MODULE_FIELD(timing, EventFramework)
 };
 }  // namespace internal
 
diff --git a/kernel/src/scheduling/kworker.cpp b/kernel/src/scheduling/kworker.cpp
index f7f26383..2cebe2fc 100644
--- a/kernel/src/scheduling/kworker.cpp
+++ b/kernel/src/scheduling/kworker.cpp
@@ -1,9 +1,19 @@
 #include "kworker.hpp"
+#include "hal/debug.hpp"
 #include "trace_framework.hpp"
 
 void Sched::KWorkerMain()
 {
     TRACE_INFO_SCHEDULING("Created new KWorker!");
     while (true) {
+        trace::Flush();
+
+        static size_t kSpins = 1'000'000;
+        for (size_t i = 0; i < kSpins; i++) {
+            hal::Noop();
+            hal::Noop();
+            hal::Noop();
+            hal::Noop();
+        }
     }
 }
diff --git a/kernel/src/scheduling/scheduler.cpp b/kernel/src/scheduling/scheduler.cpp
new file mode 100644
index 00000000..72620869
--- /dev/null
+++ b/kernel/src/scheduling/scheduler.cpp
@@ -0,0 +1,82 @@
+#include "scheduling/scheduler.hpp"
+
+#include "autogen/feature_flags.h"
+#include "hal/scheduling.hpp"
+#include "modules/hardware.hpp"
+#include "modules/scheduling.hpp"
+#include "modules/timing.hpp"
+
+namespace Sched
+{
+void Scheduler::AddReadyThread(Thread *thread)
+{
+    HardwareModule::Get().GetInterrupts().BlockHardwareInterrupts();
+
+    if (threads_ == nullptr) {
+        threads_     = thread;
+        thread->next = thread;
+        return;
+    }
+
+    thread->next   = threads_->next;
+    threads_->next = thread;
+    threads_       = thread;
+
+    HardwareModule::Get().GetInterrupts().EnableHardwareInterrupts();
+}
+
+Thread *Scheduler::Schedule()
+{
+    if constexpr (FeatureEnabled<FeatureFlag::kRunTestMode>) {
+        return nullptr;
+    }
+
+    ASSERT_NOT_NULL(threads_);
+
+    auto thread = GetNext_();
+    ASSERT_NOT_NULL(thread);
+
+    auto owner = SchedulingModule::Get().GetProcesses().GetProcess(thread->owner);
+    ASSERT_TRUE(static_cast<bool>(owner));
+
+    if (thread == hardware::GetCurrentTCB()) {
+        return nullptr;
+    }
+
+    return thread;
+}
+void Scheduler::Yield()
+{
+    HardwareModule::Get().GetInterrupts().BlockHardwareInterrupts();
+    auto thread = Schedule();
+
+    if (thread != nullptr) {
+        hal::ContextSwitch(thread);
+    }
+}
+
+void Scheduler::ConvertToScheduling()
+{
+    HardwareModule::Get().GetInterrupts().BlockHardwareInterrupts();
+
+    static constexpr u64 kPeriodicTime1Ms = kNanosInSecond / 1'000;
+    TimingModule::Get().GetEventFramework().SetupPeriodic(kPeriodicTime1Ms);
+
+    ASSERT_NOT_NULL(threads_);
+
+    auto thread = GetNext_();
+    ASSERT_NOT_NULL(thread);
+
+    auto owner = SchedulingModule::Get().GetProcesses().GetProcess(thread->owner);
+    ASSERT_TRUE(static_cast<bool>(owner));
+
+    hal::ConvertContext(thread);
+}
+
+Thread *Scheduler::GetNext_()
+{
+    Thread *thread = threads_;
+    threads_       = threads_->next;
+    return thread;
+}
+}  // namespace Sched
diff --git a/kernel/src/scheduling/scheduler.hpp b/kernel/src/scheduling/scheduler.hpp
new file mode 100644
index 00000000..86894167
--- /dev/null
+++ b/kernel/src/scheduling/scheduler.hpp
@@ -0,0 +1,47 @@
+#ifndef KERNEL_SRC_SCHEDULING_SCHEDULER_HPP_
+#define KERNEL_SRC_SCHEDULING_SCHEDULER_HPP_
+
+#include <defines.hpp>
+#include "thread.hpp"
+
+namespace Sched
+{
+
+class Scheduler
+{
+    public:
+    // ------------------------------
+    // Class creation
+    // ------------------------------
+
+    Scheduler()  = default;
+    ~Scheduler() = default;
+
+    // ------------------------------
+    // Class interaction
+    // ------------------------------
+
+    void AddReadyThread(Thread *thread);
+
+    Thread *Schedule();
+
+    void Yield();
+
+    void ConvertToScheduling();
+
+    // ------------------------------
+    // Private methods
+    // ------------------------------
+
+    protected:
+    NODISCARD FORCE_INLINE_F Thread *GetNext_();
+
+    // ------------------------------
+    // Class fields
+    // ------------------------------
+
+    Thread *threads_{};
+};
+}  // namespace Sched
+
+#endif  // KERNEL_SRC_SCHEDULING_SCHEDULER_HPP_
diff --git a/kernel/src/scheduling/task_mgr.cpp b/kernel/src/scheduling/task_mgr.cpp
index b9905869..8f6229f9 100644
--- a/kernel/src/scheduling/task_mgr.cpp
+++ b/kernel/src/scheduling/task_mgr.cpp
@@ -21,7 +21,7 @@ namespace Sched
 void TaskMgr::InitializeMultitasking()
 {
     // Spawn 3 Kernel Workers
-    static constexpr size_t kNumKWorkers = 0;
+    static constexpr size_t kNumKWorkers = 3;
     for (size_t i = 0; i < kNumKWorkers; ++i) {
         auto result = SpawnProcess(KWorkerMain, true);
         R_ASSERT_TRUE(
@@ -30,7 +30,7 @@ void TaskMgr::InitializeMultitasking()
         );
 
         TRACE_INFO_SCHEDULING(
-            "Created initial Kernel Worker process with Pid: %llu", result.value()
+            "Created initial Kernel Worker process with Pid: %llu", result.value().get<0>()
         );
     }
 }
@@ -86,27 +86,28 @@ std::expected<std::tuple<Pid, Tid>, Error> TaskMgr::SpawnProcess(
     }
 
     // 3. Spawn first thread
-    const auto tid = SpawnThread(process.value()->pid, f);
-    if (!tid) {
+    const auto thread = SpawnThread(process.value()->pid, f);
+    if (!thread) {
         DEBUG_WARN_SCHEDULING(
             "Failed to create process. Failed on initial thread creation: %s",
-            to_string(tid.error())
+            to_string(thread.error())
         );
-        return std::unexpected(tid.error());
+        return std::unexpected(thread.error());
     }
 
-    // 4. Add to scheduler - TODO
+    // 4. Add to scheduler
+    SchedulingModule::Get().GetScheduler().AddReadyThread(thread.value());
 
     DEBUG_INFO_SCHEDULING(
         "Created process with pid: %llu, and initial thread with tid: %llu", process.value()->pid,
-        tid.value()
+        thread.value()->tid
     );
 
     dismiss = true;
-    return std::make_tuple(process.value()->pid, tid.value());
+    return std::make_tuple(process.value()->pid, thread.value()->tid);
 }
 
-std::expected<Tid, Error> TaskMgr::SpawnThread(const Pid pid, void (*f)())
+std::expected<Thread *, Error> TaskMgr::SpawnThread(const Pid pid, void (*f)())
 {
     bool dismiss = false;
 
@@ -173,6 +174,6 @@ std::expected<Tid, Error> TaskMgr::SpawnThread(const Pid pid, void (*f)())
     }
 
     dismiss = true;
-    return thread.value()->tid;
+    return thread.value();
 }
 }  // namespace Sched
diff --git a/kernel/src/scheduling/task_mgr.hpp b/kernel/src/scheduling/task_mgr.hpp
index 17f2c8da..a921e241 100644
--- a/kernel/src/scheduling/task_mgr.hpp
+++ b/kernel/src/scheduling/task_mgr.hpp
@@ -28,7 +28,7 @@ class TaskMgr
         void (*f)(), bool kernel_only
     );
 
-    NODISCARD std::expected<Tid, Error> SpawnThread(Pid pid, void (*f)());
+    NODISCARD std::expected<Thread *, Error> SpawnThread(Pid pid, void (*f)());
 
     // ------------------------------
     // Private methods
diff --git a/kernel/src/scheduling/thread.hpp b/kernel/src/scheduling/thread.hpp
index 9816ee17..96dd8250 100644
--- a/kernel/src/scheduling/thread.hpp
+++ b/kernel/src/scheduling/thread.hpp
@@ -14,7 +14,7 @@ struct PACK Tid {
     u64 count : 48;
 };
 
-struct PACK Thread {
+struct Thread {
     /* Management */
     Tid tid;
     Pid owner;
diff --git a/kernel/src/time/event_framework.cpp b/kernel/src/time/event_framework.cpp
new file mode 100644
index 00000000..07c588a7
--- /dev/null
+++ b/kernel/src/time/event_framework.cpp
@@ -0,0 +1,38 @@
+#include "event_framework.hpp"
+#include "modules/hardware.hpp"
+#include "modules/scheduling.hpp"
+
+// ------------------------------
+// statics
+// ------------------------------
+
+static void *TimerHandler(intr::LitHwEntry &)
+{
+    return SchedulingModule::Get().GetScheduler().Schedule();
+}
+
+// ------------------------------
+// Implementations
+// ------------------------------
+
+namespace timing
+{
+void EventFramework::InstallInterruptHandler()
+{
+    HardwareModule::Get()
+        .GetInterrupts()
+        .GetLit()
+        .InstallInterruptHandler<intr::InterruptType::kHardwareInterrupt>(
+            hal::kTimerHwLirq, intr::HwHandler{.handler = TimerHandler}
+        );
+}
+
+void EventFramework::SetupPeriodic(const u64 time_ns)
+{
+    ASSERT_TRUE(HardwareModule::Get().GetEventClockRegistry().IsSelectedPicked());
+
+    auto event_clock = HardwareModule::Get().GetEventClockRegistry().GetSelected();
+    event_clock.cbs.set_periodic(&event_clock);
+    event_clock.cbs.next_event(&event_clock, time_ns);
+}
+}  // namespace timing
diff --git a/kernel/src/time/event_framework.hpp b/kernel/src/time/event_framework.hpp
new file mode 100644
index 00000000..3516b9a9
--- /dev/null
+++ b/kernel/src/time/event_framework.hpp
@@ -0,0 +1,40 @@
+#ifndef KERNEL_SRC_TIME_EVENT_FRAMEWORK_HPP_
+#define KERNEL_SRC_TIME_EVENT_FRAMEWORK_HPP_
+
+#include <defines.hpp>
+#include <types.hpp>
+
+namespace timing
+{
+
+class EventFramework
+{
+    public:
+    // ------------------------------
+    // Class creation
+    // ------------------------------
+
+    EventFramework()  = default;
+    ~EventFramework() = default;
+
+    // ------------------------------
+    // Class interaction
+    // ------------------------------
+
+    void InstallInterruptHandler();
+
+    void SetupPeriodic(u64 time_ns);
+
+    // ------------------------------
+    // Private methods
+    // ------------------------------
+
+    protected:
+    // ------------------------------
+    // Class fields
+    // ------------------------------
+};
+
+}  // namespace timing
+
+#endif  // KERNEL_SRC_TIME_EVENT_FRAMEWORK_HPP_
diff --git a/kernel/src/timing.cpp b/kernel/src/timing.cpp
index 56094558..789dfc2c 100644
--- a/kernel/src/timing.cpp
+++ b/kernel/src/timing.cpp
@@ -6,8 +6,10 @@
 
 internal::TimingModule::TimingModule() noexcept
 {
-    BlockHardwareInterrupts();
-    arch::PickSystemClockSource();
+    ::HardwareModule::Get().GetInterrupts().BlockHardwareInterrupts();
+
+    // 1. Prepare System time clock source
+    hal::PickSystemClockSource();
     auto &clock_source = ::HardwareModule::Get().GetClockRegistry().GetSelected();
 
     if (clock_source.enable_device) {
@@ -19,7 +21,14 @@ internal::TimingModule::TimingModule() noexcept
     }
 
     GetSystemTime().SyncWithHardware();
-    EnableHardwareInterrupts();
+
+    // 2. Prepare system event clock source
+    hal::PickSystemEventClockSource();
+
+    // 3. Register Timer Handler
+    GetEventFramework().InstallInterruptHandler();
+
+    ::HardwareModule::Get().GetInterrupts().EnableHardwareInterrupts();
 
     DEBUG_INFO_TIME("TimingModule::TimingModule()");
 }
diff --git a/kernel/test/manual_tests.cpp b/kernel/test/manual_tests.cpp
index 1b16eefb..a804ae43 100644
--- a/kernel/test/manual_tests.cpp
+++ b/kernel/test/manual_tests.cpp
@@ -5,6 +5,7 @@
 #include "hal/debug.hpp"
 #include "hal/scheduling.hpp"
 #include "hardware/core_local.hpp"
+#include "modules/hardware.hpp"
 #include "modules/scheduling.hpp"
 #include "trace_framework.hpp"
 
@@ -28,7 +29,8 @@ static void Task0()
         }
 
         const auto tcb = hardware::GetCurrentTCB();
-        hal::SwitchToKernelTask(tcb->next);
+        HardwareModule::Get().GetInterrupts().BlockHardwareInterrupts();
+        hal::ContextSwitch(tcb->next);
     }
 }
 
@@ -46,7 +48,9 @@ static void Task1()
         }
 
         const auto tcb = hardware::GetCurrentTCB();
-        hal::SwitchToKernelTask(tcb->next);
+
+        HardwareModule::Get().GetInterrupts().BlockHardwareInterrupts();
+        hal::ContextSwitch(tcb->next);
     }
 }
 
@@ -68,6 +72,6 @@ MTEST(KernelTaskSwitchTest)
     t0.value()->next = t1.value();
     t1.value()->next = t0.value();
 
-    // hal::TerminalWriteString("\nXDDD\n");
-    hal::ConvertToKernelTask(t0.value());
+    HardwareModule::Get().GetInterrupts().BlockHardwareInterrupts();
+    hal::ConvertContext(t0.value());
 }
diff --git a/libs/libcpp/include/formats.hpp b/libs/libcpp/include/formats.hpp
index d42f0865..b461b6c9 100644
--- a/libs/libcpp/include/formats.hpp
+++ b/libs/libcpp/include/formats.hpp
@@ -71,4 +71,32 @@ void DumpObjHexWithSep(FuncT func, const ObjT &obj)
     func(buffer);
 }
 
+template <size_t kSize, size_t kSepDist = 8, typename FuncT>
+void DumpMemHex(FuncT func, void *mem)
+{
+    static constexpr size_t kBuffSize = 4 * kSize;
+    char buffer[kBuffSize];
+
+    size_t sep_dist    = 0;
+    u8 *ptr            = reinterpret_cast<u8 *>(mem);
+    char *buff_ptr     = buffer;
+    size_t buffer_size = kBuffSize;
+    for (size_t i = 0; i < kSize; ++i) {
+        const int bytes_written =
+            snprintf(buff_ptr, buffer_size, ++sep_dist == kSepDist ? "%02X\n" : "%02X", ptr[i]);
+
+        sep_dist %= kSepDist;
+
+        assert(
+            bytes_written < static_cast<int>(buffer_size) &&
+            "DumpObjToBufferHexWithSep buffer fully used!"
+        );
+
+        buffer_size -= bytes_written;
+        buff_ptr += bytes_written;
+    }
+
+    func(buffer);
+}
+
 #endif  // LIBS_LIBCPP_INCLUDE_FORMATS_HPP_

From d45f60158dcbf7a9b4a72aa7ecfb14f3b3e4212f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C5=81ukasz=20Kryczka?=
 <60490378+kryczkal@users.noreply.github.com>
Date: Mon, 29 Dec 2025 20:18:55 +0100
Subject: [PATCH 32/56] Kryczkal/user addr space (#255)

---
 kernel/arch/x86_64/src/hal/impl/mmu.cpp       |  42 +++++
 kernel/arch/x86_64/src/hal/impl/mmu.hpp       |   4 +
 kernel/src/hal/api/mmu.hpp                    |  11 ++
 kernel/src/mem/virt/addr_space.cpp            |  80 ++++-----
 kernel/src/mem/virt/addr_space.hpp            |  28 ++--
 kernel/src/mem/virt/area.cpp                  | 152 ++++++++++++++++++
 kernel/src/mem/virt/area.hpp                  | 101 ++++++++++--
 kernel/src/mem/virt/page_fault.cpp            | 103 +++---------
 kernel/src/mem/virt/vmm.cpp                   |  26 ++-
 kernel/src/mem/virt/vmm.hpp                   |   4 +-
 kernel/src/modules/memory.cpp                 |  37 ++---
 kernel/src/sys/loader.cpp                     |  59 +++++--
 kernel/test/page_fault_handler_test.cpp       |  44 ++---
 .../allocators/custom_allocator_wrapper.hpp   |  67 +++++---
 14 files changed, 531 insertions(+), 227 deletions(-)
 create mode 100644 kernel/src/mem/virt/area.cpp

diff --git a/kernel/arch/x86_64/src/hal/impl/mmu.cpp b/kernel/arch/x86_64/src/hal/impl/mmu.cpp
index d974452d..1e81c6d2 100644
--- a/kernel/arch/x86_64/src/hal/impl/mmu.cpp
+++ b/kernel/arch/x86_64/src/hal/impl/mmu.cpp
@@ -1,5 +1,8 @@
 #include "hal/impl/mmu.hpp"
+
+#include <string.h>
 #include <macros.hpp>
+
 #include "cpu/control_registers.hpp"
 #include "mem/page_map.hpp"
 
@@ -42,6 +45,45 @@ void Mmu::SwitchRoot(Mem::PPtr<void> root)
     cpu::SetCR(cr3);
 }
 
+void Mmu::CopyKernelSpace(Mem::PPtr<void> dst_root, Mem::PPtr<void> kernel_root)
+{
+    // x86_64: Copy upper 256 entries of PML4 (indices 256-511)
+    auto *dst_pml4 = reinterpret_cast<PageMapTable<4> *>(Mem::PhysToVirt(dst_root));
+    auto *src_pml4 = reinterpret_cast<PageMapTable<4> *>(Mem::PhysToVirt(kernel_root));
+
+    // 256 * 8 bytes = 2048 bytes
+    memcpy(&((*dst_pml4)[256]), &((*src_pml4)[256]), 256 * sizeof(PageMapEntry<4>));
+}
+
+bool Mmu::SyncMapping(Mem::PPtr<void> dst_root, Mem::PPtr<void> src_root, Mem::VPtr<void> vaddr)
+{
+    // Synchronize the PML4 entry for the given virtual address.
+    auto *dst_pml4 = reinterpret_cast<PageMapTable<4> *>(Mem::PhysToVirt(dst_root));
+    auto *src_pml4 = reinterpret_cast<PageMapTable<4> *>(Mem::PhysToVirt(src_root));
+
+    // Calculate PML4 index
+    u64 idx = PmeIdx<4>(vaddr);
+
+    // Ensure we are operating in the upper half (kernel space)
+    if (idx < 256) {
+        return false;
+    }
+
+    auto &src_entry = (*src_pml4)[idx];
+    auto &dst_entry = (*dst_pml4)[idx];
+
+    // Check if the source entry is present and the destination is either
+    // missing or outdated (pointing to a different frame or having different flags).
+    if (src_entry.IsPresent()) {
+        if (!dst_entry.IsPresent() || dst_entry.frame != src_entry.frame) {
+            dst_entry = src_entry;
+            return true;
+        }
+    }
+
+    return false;
+}
+
 expected<void, MemError> Mmu::SetPageFlags(
     Mem::PPtr<void> root, Mem::VPtr<void> vaddr, PageFlags flags
 )
diff --git a/kernel/arch/x86_64/src/hal/impl/mmu.hpp b/kernel/arch/x86_64/src/hal/impl/mmu.hpp
index 8c709575..c121988b 100644
--- a/kernel/arch/x86_64/src/hal/impl/mmu.hpp
+++ b/kernel/arch/x86_64/src/hal/impl/mmu.hpp
@@ -37,6 +37,10 @@ class Mmu : public MmuAPI
 
     void SwitchRoot(Mem::PPtr<void> root);
 
+    void CopyKernelSpace(Mem::PPtr<void> dst_root, Mem::PPtr<void> kernel_root);
+
+    bool SyncMapping(Mem::PPtr<void> dst_root, Mem::PPtr<void> src_root, Mem::VPtr<void> vaddr);
+
     template <TableVisitor Visitor>
     void VisitTables(Mem::PPtr<void> root, Visitor visitor);
 
diff --git a/kernel/src/hal/api/mmu.hpp b/kernel/src/hal/api/mmu.hpp
index 0f0bc945..b58c6c11 100644
--- a/kernel/src/hal/api/mmu.hpp
+++ b/kernel/src/hal/api/mmu.hpp
@@ -139,6 +139,17 @@ struct MmuAPI {
      */
     template <TableVisitor Visitor>
     void VisitTables(Mem::PPtr<void> root, Visitor visitor);
+
+    /**
+     * @brief Synchronizes a top-level page table entry from a source root to a destination root.
+     * Used for lazy kernel mapping synchronization (e.g. updating a user process's kernel view).
+     *
+     * @param dst_root The physical address of the destination root page table.
+     * @param src_root The physical address of the source (master) root page table.
+     * @param vaddr The virtual address causing the fault/needing synchronization.
+     * @return true if synchronization was performed (entry copied), false otherwise.
+     */
+    bool SyncMapping(Mem::PPtr<void> dst_root, Mem::PPtr<void> src_root, Mem::VPtr<void> vaddr);
 };
 
 }  // namespace arch
diff --git a/kernel/src/mem/virt/addr_space.cpp b/kernel/src/mem/virt/addr_space.cpp
index d14a6c1e..92e73d06 100644
--- a/kernel/src/mem/virt/addr_space.cpp
+++ b/kernel/src/mem/virt/addr_space.cpp
@@ -40,10 +40,14 @@ expected<void, MemError> AS::InitKernel(
 
     return {};
 }
+
 AS::~AddressSpace()
 {
-    // Free all allocated areas
-    // area_list_ destructor will handle freeing nodes and data
+    // Manually free all VMA objects before the list destroys the nodes
+    for (auto *vma : area_list_) {
+        KDelete(vma);
+    }
+    area_list_.Clear();
 
     if (ctx_) {
         if (owns_page_table_root_ && page_table_root_ != nullptr) {
@@ -52,33 +56,36 @@ AS::~AddressSpace()
     }
 }
 
-expected<void, MemError> AS::AddArea(VMemArea vma)
+expected<void, MemError> AS::AddArea(VMemArea *vma)
 {
+    ASSERT_NOT_NULL(vma);
     std::lock_guard guard(area_list_lock_);
 
     // Check for overlapping areas
     for (auto it = area_list_.begin(); it != area_list_.end(); ++it) {
-        if (AreasOverlap(&(*it), &vma)) {
+        if (AreasOverlap(*it, vma)) {
+            // We own vma, so we must delete it on failure
+            KDelete(vma);
             return unexpected(MemError::InvalidArgument);
         }
     }
 
     auto node = area_list_.PushFront(vma);
     if (!node) {
+        KDelete(vma);
         return unexpected(MemError::OutOfMemory);
     }
 
     return {};
 }
 
-bool AS::AreasOverlap(VPtr<VMemArea> a, VPtr<VMemArea> b)
+bool AS::AreasOverlap(const VMemArea *a, const VMemArea *b)
 {
-    const auto a_s_addr = reinterpret_cast<uptr>(a->start);
-    const auto a_e_addr = a_s_addr + a->size;
-    const auto b_s_addr = reinterpret_cast<uptr>(b->start);
-    const auto b_e_addr = b_s_addr + b->size;
-
-    return a_s_addr < b_e_addr && b_s_addr < a_e_addr;
+    const auto a_s = reinterpret_cast<uptr>(a->GetStart());
+    const auto a_e = a_s + a->GetSize();
+    const auto b_s = reinterpret_cast<uptr>(b->GetStart());
+    const auto b_e = b_s + b->GetSize();
+    return a_s < b_e && b_s < a_e;
 }
 
 expected<TlbHint, MemError> AS::RmArea(VPtr<void> ptr)
@@ -87,15 +94,17 @@ expected<TlbHint, MemError> AS::RmArea(VPtr<void> ptr)
 
     auto res = FindAreaLocked(ptr);
     RET_UNEXPECTED_IF_ERR(res);
-    auto it = *res;
-
-    // Do MMU unmap while we have the area info
-    auto start = it->start;
-    auto size  = it->size;
+    auto it       = *res;
+    VMemArea *vma = *it;
 
+    // Do MMU unmap
+    auto start = vma->GetStart();
+    auto size  = vma->GetSize();
     mmu_->UnmapRange(*ctx_, page_table_root_, start, size);
 
+    // Remove from list and delete object
     area_list_.Remove(it.GetNode());
+    KDelete(vma);
 
     return TlbHint{start, size};
 }
@@ -106,12 +115,14 @@ expected<TlbHint, MemError> AS::UpdateAreaFlags(VPtr<void> ptr, VirtualMemAreaFl
 
     auto res = FindAreaLocked(ptr);
     RET_UNEXPECTED_IF_ERR(res);
-    VMemArea &area = *res.value();
-    RET_UNEXPECTED_IF(area.start != ptr, MemError::InvalidArgument);
+    VMemArea *vma = *res.value();
+
+    RET_UNEXPECTED_IF(vma->GetStart() != ptr, MemError::InvalidArgument);
+
+    vma->SetFlags(vmaf);
 
-    area.flags = vmaf;
-    auto start = area.start;
-    auto size  = area.size;
+    auto start = vma->GetStart();
+    auto size  = vma->GetSize();
 
     bool is_kernel = (PtrToUptr(start) >= hal::kKernelVirtualAddressStart);
 
@@ -139,36 +150,27 @@ expected<TlbHint, MemError> AS::UpdateAreaFlags(VPtr<void> ptr, VirtualMemAreaFl
 expected<AS::AddrSpMutIt, MemError> AS::FindAreaLocked(VPtr<void> ptr)
 {
     for (auto it = area_list_.begin(); it != area_list_.end(); ++it) {
-        if (IsAddrInArea(&(*it), ptr)) {
+        if (IsAddrInArea(*it, ptr)) {
             return it;
         }
     }
     return unexpected(MemError::NotFound);
 }
 
-expected<VPtr<VMemArea>, MemError> AS::FindArea(VPtr<void> ptr)
+expected<VMemArea *, MemError> AS::FindArea(VPtr<void> ptr)
 {
     std::lock_guard guard(area_list_lock_);
-
     auto res = FindAreaLocked(ptr);
     RET_UNEXPECTED_IF_ERR(res);
-
-    VPtr<VMemArea> vma = &(*res.value());
-    return vma;
+    return *(*res);
 }
 
-bool AS::IsAddrInArea(VPtr<VMemArea> vma, VPtr<void> ptr)
+bool AS::IsAddrInArea(const VMemArea *vma, VPtr<void> ptr)
 {
-    ASSERT_NOT_NULL(vma, "Virtual memory area is null");
-
-    const auto vma_s_addr = reinterpret_cast<uptr>(vma->start);
-    const auto vma_e_addr = vma_s_addr + vma->size;
-    const auto addr       = reinterpret_cast<uptr>(ptr);
-
-    // Check if ptr is in [vma start, vma end]
-    if (vma_s_addr <= addr && addr < vma_e_addr) {
-        return true;
-    }
+    ASSERT_NOT_NULL(vma);
 
-    return false;
+    const auto vma_s = reinterpret_cast<uptr>(vma->GetStart());
+    const auto vma_e = vma_s + vma->GetSize();
+    const auto addr  = reinterpret_cast<uptr>(ptr);
+    return vma_s <= addr && addr < vma_e;
 }
diff --git a/kernel/src/mem/virt/addr_space.hpp b/kernel/src/mem/virt/addr_space.hpp
index e8edf4f8..c682f542 100644
--- a/kernel/src/mem/virt/addr_space.hpp
+++ b/kernel/src/mem/virt/addr_space.hpp
@@ -58,29 +58,36 @@ class AddressSpace
 
     PPtr<void> PageTableRoot() const { return page_table_root_; }
 
-    using AddrSpIt = data_structures::DoubleLinkedList<VMemArea>::ConstIterator;
+    void Lock() { area_list_lock_.Lock(); }
+    void Unlock() { area_list_lock_.Unlock(); }
+
+    private:
+    // Store pointers to polymorphic VMemArea objects
+    using AddrSpIt = data_structures::DoubleLinkedList<VMemArea *>::ConstIterator;
 
     // Iterator
     AddrSpIt begin() const { return area_list_.begin(); }
     AddrSpIt end() const { return area_list_.end(); }
 
-    private:
-    // This is orchestrated in VMM (For proper TLB management)
-    expected<void, MemError> AddArea(VMemArea vma);
+    // Takes ownership of vma pointer
+    expected<void, MemError> AddArea(VMemArea *vma);
+
     expected<TlbHint, MemError> RmArea(VPtr<void> ptr);
     expected<TlbHint, MemError> UpdateAreaFlags(VPtr<void> ptr, VirtualMemAreaFlags flags);
 
     // Helpers
-    using AddrSpMutIt = data_structures::DoubleLinkedList<VMemArea>::Iterator;
+    using AddrSpMutIt = data_structures::DoubleLinkedList<VMemArea *>::Iterator;
     expected<AddrSpMutIt, MemError> FindAreaLocked(VPtr<void> ptr);
-    expected<VPtr<VMemArea>, MemError> FindArea(VPtr<void> ptr);
-    bool IsAddrInArea(VPtr<VMemArea> vma, VPtr<void> ptr);
-    bool AreasOverlap(VPtr<VMemArea> a, VPtr<VMemArea> b);
+    expected<VMemArea *, MemError> FindArea(VPtr<void> ptr);
+    bool IsAddrInArea(const VMemArea *vma, VPtr<void> ptr);
+    bool AreasOverlap(const VMemArea *a, const VMemArea *b);
 
     // Fields
     PPtr<void> page_table_root_;
     bool owns_page_table_root_;
-    data_structures::DoubleLinkedList<VMemArea> area_list_;
+
+    // List of pointers to VMA objects (we own these objects)
+    data_structures::DoubleLinkedList<VMemArea *> area_list_;
     hal::Spinlock area_list_lock_;
 
     // Dependencies
@@ -88,11 +95,12 @@ class AddressSpace
     hal::Mmu *mmu_;
 
     // Friends
-    friend VirtualMemoryManager;
+    friend class VirtualMemoryManager;
     friend void *PageFaultHandler(intr::LitExcEntry &entry, hal::ExceptionData *data);
 
     public:
 };
+
 using AddrSp = AddressSpace;
 
 }  // namespace Mem
diff --git a/kernel/src/mem/virt/area.cpp b/kernel/src/mem/virt/area.cpp
new file mode 100644
index 00000000..d7ab4c38
--- /dev/null
+++ b/kernel/src/mem/virt/area.cpp
@@ -0,0 +1,152 @@
+#include "mem/virt/area.hpp"
+
+#include <string.h>
+#include <bits_ext.hpp>
+#include <hal/constants.hpp>
+#include <hal/panic.hpp>
+#include <mem/mmu/contexts.hpp>
+#include <mem/virt/addr_space.hpp>
+#include <modules/memory.hpp>
+#include <trace_framework.hpp>
+
+namespace Mem
+{
+
+static bool MapPage(AddressSpace &as, VPtr<void> vaddr, PPtr<void> paddr, VirtualMemAreaFlags flags)
+{
+    auto &mmu      = MemoryModule::Get().GetMmu();
+    bool is_kernel = (Mem::PtrToUptr(vaddr) >= hal::kKernelVirtualAddressStart);
+
+    hal::PageFlags page_flags{
+        .Present        = true,
+        .Writable       = flags.writable,
+        .UserAccessible = !is_kernel,
+        .WriteThrough   = flags.write_through,
+        .CacheDisable   = flags.cache_disable,
+        .Global         = is_kernel,
+        .NoExecute      = !flags.executable
+    };
+
+    // We use the kernel context for mapping operations
+    auto &mmu_ctx = MemoryModule::Get().GetKernelMmuContext();
+
+    auto res = mmu.Map(mmu_ctx, as.PageTableRoot(), vaddr, paddr, page_flags);
+
+    if (!res) {
+        TRACE_WARN_MEMORY(
+            "Failed to map page at %p -> %p: %s", vaddr, paddr, to_string(res.error())
+        );
+        return false;
+    }
+
+    return true;
+}
+
+static bool CheckWritePermissions(
+    VPtr<void> addr, const PageFaultData::ErrorCode &err, VirtualMemAreaFlags flags
+)
+{
+    if (err.write && !flags.writable) {
+        hal::KernelPanicFormat("Write to read-only memory area at %p", addr);
+        return false;
+    }
+    return true;
+}
+
+// -----------------------------------------------------------------------------
+// AnonymousVMemArea
+// -----------------------------------------------------------------------------
+
+bool AnonymousVMemArea::HandleFault(
+    VPtr<void> fault_addr, const PageFaultData::ErrorCode &err, AddressSpace &as
+)
+{
+    if (!CheckWritePermissions(fault_addr, err, flags_)) {
+        return false;
+    }
+
+    TRACE_INFO_MEMORY("Handling Anonymous Fault at %p", fault_addr);
+
+    auto &pmm = MemoryModule::Get().GetBitmapPmm();
+
+    auto page_res = pmm.Alloc();
+    if (!page_res) {
+        TRACE_FATAL_MEMORY("OOM during anonymous page fault");
+        return false;
+    }
+
+    PPtr<void> phys_page = *page_res;
+
+    // TODO: optimization - zero page optimization (CoW zero page)
+    VPtr<void> virt_page = Mem::PhysToVirt(phys_page);
+    memset(virt_page, 0, hal::kPageSizeBytes);
+
+    VPtr<void> aligned_vaddr = AlignDown(fault_addr, hal::kPageSizeBytes);
+    return MapPage(as, aligned_vaddr, phys_page, flags_);
+}
+
+// -----------------------------------------------------------------------------
+// DirectMappingVMemArea
+// -----------------------------------------------------------------------------
+
+bool DirectMappingVMemArea::HandleFault(
+    VPtr<void> fault_addr, const PageFaultData::ErrorCode &err, AddressSpace &as
+)
+{
+    if (!CheckWritePermissions(fault_addr, err, flags_)) {
+        return false;
+    }
+
+    TRACE_INFO_MEMORY("Handling Direct Mapping Fault at %p", fault_addr);
+
+    // Calculate physical address based on offset
+    u64 offset         = Mem::PtrToUptr(fault_addr) - Mem::PtrToUptr(start_);
+    uptr phys_addr_val = Mem::PtrToUptr(phys_start_) + offset;
+
+    PPtr<void> phys_page     = Mem::UptrToPtr<void>(AlignDown(phys_addr_val, hal::kPageSizeBytes));
+    VPtr<void> aligned_vaddr = AlignDown(fault_addr, hal::kPageSizeBytes);
+
+    return MapPage(as, aligned_vaddr, phys_page, flags_);
+}
+
+// -----------------------------------------------------------------------------
+// KernelSyncVMemArea
+// -----------------------------------------------------------------------------
+
+KernelSyncVMemArea::KernelSyncVMemArea()
+    // Covers the entire upper half of the 64-bit address space
+    // 0x8000000000000000 - 0xFFFFFFFFFFFFFFFF
+    : VMemArea(
+          Mem::UptrToPtr<void>(kBitMaskLeft<u64, 1>), kBitMaskLeft<u64, 1> - 1,
+          // Permissions are determined by the actual kernel page table entries being copied,
+          // these flags are just placeholders for the VMA object.
+          VirtualMemAreaFlags{.readable = true, .writable = true, .executable = true}
+      )
+{
+}
+
+bool KernelSyncVMemArea::HandleFault(
+    VPtr<void> fault_addr, const PageFaultData::ErrorCode &, AddressSpace &as
+)
+{
+    auto &vmm = MemoryModule::Get().GetVmm();
+
+    auto kernel_root  = vmm.GetKernelAddressSpace().PageTableRoot();
+    auto current_root = as.PageTableRoot();
+
+    if (current_root == kernel_root) {
+        TRACE_FATAL_MEMORY("Kernel Page Fault in Kernel Address Space at %p", fault_addr);
+        return false;
+    }
+
+    auto &mmu = MemoryModule::Get().GetMmu();
+    if (mmu.SyncMapping(current_root, kernel_root, fault_addr)) {
+        MemoryModule::Get().GetTlb().InvalidatePage(AlignDown(fault_addr, hal::kPageSizeBytes));
+        return true;
+    }
+
+    TRACE_FATAL_MEMORY("Kernel Sync Fault failed at %p (not mapped in kernel)", fault_addr);
+    return false;
+}
+
+}  // namespace Mem
diff --git a/kernel/src/mem/virt/area.hpp b/kernel/src/mem/virt/area.hpp
index 6e645d18..d5937994 100644
--- a/kernel/src/mem/virt/area.hpp
+++ b/kernel/src/mem/virt/area.hpp
@@ -3,12 +3,12 @@
 
 #include <types.hpp>
 #include "mem/types.hpp"
+#include "mem/virt/page_fault_data.hpp"
 
 namespace Mem
 {
 
-TODO_STD_VARIANT
-enum class VirtualMemAreaT { Anonymous, DirectMapping };
+class AddressSpace;
 
 struct VirtualMemAreaFlags {
     bool readable : 1;
@@ -16,20 +16,99 @@ struct VirtualMemAreaFlags {
     bool executable : 1;
     bool write_through : 1 = false;
     bool cache_disable : 1 = false;
-    // Future flags: bool user_accessible, bool copy_on_write, etc.
 };
 using VMemAreaFlags = VirtualMemAreaFlags;
 
-struct VirtualMemArea {
-    VPtr<void> start;  // Page aligned
-    size_t size;       // Page size divisable
-    VirtualMemAreaFlags flags;
+/**
+ * @brief Abstract base class representing a Virtual Memory Area.
+ * Defines the range, permissions, and behavior on page faults.
+ */
+class VMemArea
+{
+    public:
+    VMemArea(VPtr<void> start, size_t size, VirtualMemAreaFlags flags)
+        : start_(start), size_(size), flags_(flags)
+    {
+    }
+
+    virtual ~VMemArea() = default;
+
+    /**
+     * @brief Handles a page fault occurring within this area.
+     * @param fault_addr The exact virtual address that caused the fault.
+     * @param err The error code provided by the CPU.
+     * @param as The address space this area belongs to.
+     * @return true if the fault was resolved, false otherwise.
+     */
+    virtual bool HandleFault(
+        VPtr<void> fault_addr, const PageFaultData::ErrorCode &err, AddressSpace &as
+    ) = 0;
+
+    // Getters
+    NODISCARD VPtr<void> GetStart() const { return start_; }
+    NODISCARD size_t GetSize() const { return size_; }
+    NODISCARD VPtr<void> GetEnd() const
+    {
+        return reinterpret_cast<VPtr<void>>(reinterpret_cast<uptr>(start_) + size_);
+    }
+    NODISCARD VirtualMemAreaFlags GetFlags() const { return flags_; }
+
+    // Mutators
+    void SetFlags(VirtualMemAreaFlags flags) { flags_ = flags; }
+
+    protected:
+    VPtr<void> start_;
+    size_t size_;
+    VirtualMemAreaFlags flags_;
+};
+
+/**
+ * @brief Represents anonymous memory (RAM), zero-initialized on demand.
+ */
+class AnonymousVMemArea final : public VMemArea
+{
+    public:
+    using VMemArea::VMemArea;
+
+    bool HandleFault(
+        VPtr<void> fault_addr, const PageFaultData::ErrorCode &err, AddressSpace &as
+    ) override;
+};
+
+/**
+ * @brief Represents a direct mapping to a physical address range (e.g., MMIO).
+ */
+class DirectMappingVMemArea final : public VMemArea
+{
+    public:
+    DirectMappingVMemArea(
+        VPtr<void> start, size_t size, VirtualMemAreaFlags flags, PPtr<void> phys_start
+    )
+        : VMemArea(start, size, flags), phys_start_(phys_start)
+    {
+    }
+
+    bool HandleFault(
+        VPtr<void> fault_addr, const PageFaultData::ErrorCode &err, AddressSpace &as
+    ) override;
+
+    private:
+    PPtr<void> phys_start_;
+};
+
+/**
+ * @brief Represents the kernel address space area.
+ * Handles lazy synchronization of kernel mappings into user address spaces.
+ */
+class KernelSyncVMemArea final : public VMemArea
+{
+    public:
+    KernelSyncVMemArea();
 
-    TODO_STD_VARIANT
-    VirtualMemAreaT type;
-    PPtr<void> direct_mapping_start;
+    bool HandleFault(
+        VPtr<void> fault_addr, const PageFaultData::ErrorCode &err, AddressSpace &as
+    ) override;
 };
-using VMemArea = VirtualMemArea;
 
 }  // namespace Mem
 
diff --git a/kernel/src/mem/virt/page_fault.cpp b/kernel/src/mem/virt/page_fault.cpp
index f1b877f3..1457e701 100644
--- a/kernel/src/mem/virt/page_fault.cpp
+++ b/kernel/src/mem/virt/page_fault.cpp
@@ -1,13 +1,10 @@
 #include "mem/virt/page_fault.hpp"
 
-#include "interrupts/interrupt_types.hpp"
+#include <template/scope_guard.hpp>
 
 #include "hal/intr_parser.hpp"
 #include "hal/panic.hpp"
-#include "mem/mmu/contexts.hpp"
-#include "mem/phys/mngr/buddy.hpp"
-#include "mem/virt/page_fault.hpp"
-#include "modules/hardware.hpp"
+#include "mem/virt/addr_space.hpp"
 #include "modules/memory.hpp"
 #include "trace_framework.hpp"
 
@@ -16,93 +13,37 @@ namespace Mem
 
 void *PageFaultHandler(intr::LitExcEntry &, hal::ExceptionData *data)
 {
-    TRACE_INFO_GENERAL("PageFaultHandler()");
-    using namespace hal;
     ASSERT_NOT_NULL(data);
 
-    PageFaultData pfd = ParsePageFaultData(*data);
+    PageFaultData pfd = hal::ParsePageFaultData(*data);
     const auto &f_ptr = pfd.faulting_ptr;
     const auto &err   = pfd.error;
 
-    TRACE_INFO_GENERAL(
-        "PageFaultHandler: Addr=%p, P=%d, W=%d, U=%d, R=%d, I=%d", f_ptr, err.present, err.write,
-        err.user, err.reserved_bits, err.instruction_fetch
-    );
+    auto &as = MemoryModule::Get().GetVmm().GetCurrentAddressSpace();
+
+    as.Lock();
+    template_lib::ScopeGuard guard([&]() {
+        as.Unlock();
+    });
+    auto vma_res = as.FindAreaLocked(f_ptr);
 
-    auto &as           = MemoryModule::Get().GetKernelAddressSpace();
-    auto area_or_error = as.FindArea(f_ptr);
-    if (!area_or_error) {
-        KernelPanicFormat("Page fault in unmapped memory at %p", f_ptr);
+    if (!vma_res) {
+        hal::KernelPanicFormat("Page fault in unmapped memory at %p", f_ptr);
         return nullptr;
     }
-    VPtr<VMemArea> vma_ptr = *area_or_error;
-    const auto &vma        = *vma_ptr;
-
-    if (!err.present) {  // Page just wasn't there
-        if (err.write && !vma.flags.writable) {
-            hal::KernelPanicFormat("Write to read-only memory area at %p", f_ptr);
-            return nullptr;
-        }
-
-        auto &pmm = MemoryModule::Get().GetBitmapPmm();
-        auto &mmu = MemoryModule::Get().GetMmu();
-
-        PPtr<void> map_to = nullptr;
-        if (vma.type == VirtualMemAreaT::Anonymous) {
-            TRACE_INFO_GENERAL("PageFaultHandler: Handling Anonymous VMA");
-            auto new_page_or_error = pmm.Alloc();
-            if (!new_page_or_error) {
-                hal::KernelPanic("Out of memory during page fault handling");
-            }
-            auto *new_page_phys = *new_page_or_error;
-            auto *new_page_virt = Mem::PhysToVirt(new_page_phys);
-
-            memset(new_page_virt, 0, hal::kPageSizeBytes);
-
-            map_to = new_page_phys;
-        } else if (vma.type == VirtualMemAreaT::DirectMapping) {
-            TRACE_INFO_GENERAL("PageFaultHandler: Handling DirectMapping VMA");
-            const auto offset = PtrToUptr(f_ptr) - PtrToUptr(vma.start);
-            map_to            = UptrToPtr<void>(
-                AlignDown(PtrToUptr(vma.direct_mapping_start) + offset, kPageSizeBytes)
-            );
-        } else {
-            hal::KernelPanicFormat(
-                "Unsupported VMA type %d at %p", static_cast<int>(vma.type), f_ptr
-            );
-            return nullptr;
-        }
+    VMemArea *vma = *(*vma_res);
 
-        hal::PageFlags page_flags{
-            .Present        = true,
-            .Writable       = vma.flags.writable,
-            .UserAccessible = true,
-            .WriteThrough   = vma.flags.write_through,
-            .CacheDisable   = vma.flags.cache_disable,
-            .Global         = false,
-            .NoExecute      = !vma.flags.executable
-        };
-
-        // We need a context to Map.
-        // For now, we construct a KernelMmuContext on the fly using the global PMM/PMT
-        // FIXME: This is slightly inefficient to reconstruct on every fault, but valid.
-        auto &ctx = MemoryModule::Get().GetKernelMmuContext();
-
-        auto map_res = mmu.Map(
-            ctx, as.PageTableRoot(), AlignDown(f_ptr, hal::kPageSizeBytes), map_to, page_flags
-        );
-
-        if (!map_res) {
-            hal::KernelPanicFormat("Failed to map page for address %p", f_ptr);
-        }
-
-        TRACE_INFO_GENERAL(
-            "Handled page fault at %p by mapping to physical page at %p", f_ptr, map_to
-        );
-        return nullptr;
+    if (err.present) {
+        // Protection violation
+        // TODO: CoW handling would go here via vma->HandleProtectionFault()
+        hal::KernelPanicFormat("Unhandled protection fault at %p", f_ptr);
     }
 
-    hal::KernelPanicFormat("Unhandled page fault type at 0x%p", f_ptr);
+    // Delegate to VMA
+    // The VMA knows if it's anonymous, file-backed, or MMIO, and handles it accordingly.
+    if (!vma->HandleFault(f_ptr, err, as)) {
+        hal::KernelPanicFormat("Failed to resolve page fault at %p", f_ptr);
+    }
     return nullptr;
 }
 
diff --git a/kernel/src/mem/virt/vmm.cpp b/kernel/src/mem/virt/vmm.cpp
index adadf4d0..1c6effe0 100644
--- a/kernel/src/mem/virt/vmm.cpp
+++ b/kernel/src/mem/virt/vmm.cpp
@@ -2,6 +2,7 @@
 
 #include <bits_ext.hpp>
 #include <macros.hpp>
+#include <template/scope_guard.hpp>
 
 #include "hal/constants.hpp"
 #include "mem/heap.hpp"
@@ -37,6 +38,8 @@ void Vmm::Init(
     TRACE_INFO_MEMORY("Initializing Kernel Address Space");
     auto init_res = kernel_as_.InitKernel(kernel_root, *ctx_, *mmu_);
     R_ASSERT_TRUE(init_res);
+
+    current_as_ = &kernel_as_;
 }
 
 expected<VPtr<AddressSpace>, MemError> Vmm::CreateUserAddrSpace()
@@ -45,9 +48,24 @@ expected<VPtr<AddressSpace>, MemError> Vmm::CreateUserAddrSpace()
     RET_UNEXPECTED_IF_ERR(as_res);
     auto as = *as_res;
 
+    template_lib::ScopeGuard as_guard([&] {
+        DestroyUserAddrSpace(as);
+    });
+
     auto init_res = as->InitUser(*ctx_, *mmu_);
     RET_UNEXPECTED_IF_ERR(init_res);
 
+    mmu_->CopyKernelSpace(as->PageTableRoot(), kernel_as_.PageTableRoot());
+
+    // This enables lazy synchronization of kernel mappings into user address spaces.
+    auto kernel_sync_vma = Mem::KNew<Mem::KernelSyncVMemArea>();
+    RET_UNEXPECTED_IF(!kernel_sync_vma, MemError::OutOfMemory);
+
+    // AddArea takes ownership of the VMA pointer
+    auto res = as->AddArea(*kernel_sync_vma);
+    RET_UNEXPECTED_IF_ERR(res);
+
+    as_guard.dismiss();
     return as;
 }
 
@@ -60,16 +78,18 @@ expected<void, MemError> Vmm::DestroyUserAddrSpace(VPtr<AddressSpace> as)
 
 void Vmm::SwitchAddrSpace(VPtr<AddressSpace> as)
 {
+    current_as_ = as;
     mmu_->SwitchRoot(as->PageTableRoot());
     // SwitchRoot does CR3 load which flushes TLB
 }
 
-expected<VPtr<void>, MemError> Vmm::AddArea(VPtr<AddrSp> as, VMemArea vma)
+expected<VPtr<void>, MemError> Vmm::AddArea(VPtr<AddrSp> as, VMemArea *vma)
 {
-    auto res = as->AddArea(vma);
+    auto start = vma->GetStart();
+    auto res   = as->AddArea(vma);
     RET_UNEXPECTED_IF_ERR(res);
 
-    return vma.start;
+    return start;
 }
 
 expected<void, MemError> Vmm::RmArea(VPtr<AddrSp> as, VPtr<void> region_start)
diff --git a/kernel/src/mem/virt/vmm.hpp b/kernel/src/mem/virt/vmm.hpp
index 40265d11..f21b1a5d 100644
--- a/kernel/src/mem/virt/vmm.hpp
+++ b/kernel/src/mem/virt/vmm.hpp
@@ -41,12 +41,13 @@ class VirtualMemoryManager
     // ------------------------------
 
     AddressSpace &GetKernelAddressSpace() { return kernel_as_; }
+    AddressSpace &GetCurrentAddressSpace() { return *current_as_; }
 
     expected<VPtr<AddressSpace>, MemError> CreateUserAddrSpace();
     expected<void, MemError> DestroyUserAddrSpace(VPtr<AddressSpace> as);
     void SwitchAddrSpace(VPtr<AddressSpace> as);
 
-    expected<VPtr<void>, MemError> AddArea(VPtr<AddressSpace> as, VMemArea vma);
+    expected<VPtr<void>, MemError> AddArea(VPtr<AddressSpace> as, VMemArea *vma);
     expected<void, MemError> RmArea(VPtr<AddressSpace> as, VPtr<void> region_start);
     expected<void, MemError> UpdateAreaFlags(
         VPtr<AddressSpace> as, VPtr<void> region_start, VirtualMemAreaFlags vmaf
@@ -61,6 +62,7 @@ class VirtualMemoryManager
     KernelMmuContext *ctx_;
     Heap *heap_;
     AddressSpace kernel_as_;
+    AddressSpace *current_as_;
 };
 using Vmm = VirtualMemoryManager;
 
diff --git a/kernel/src/modules/memory.cpp b/kernel/src/modules/memory.cpp
index 15a82ce8..f0306b1f 100644
--- a/kernel/src/modules/memory.cpp
+++ b/kernel/src/modules/memory.cpp
@@ -3,10 +3,12 @@
 #include <assert.h>
 #include "boot_args.hpp"
 #include "hal/constants.hpp"
+#include "mem/heap.hpp"
 #include "mem/init/boot_mmu.hpp"
 #include "mem/page_meta_table.hpp"
 #include "mem/phys/mngr/bitmap.hpp"
 #include "mem/types.hpp"
+#include "mem/virt/area.hpp"
 #include "mem/virt/page_fault.hpp"
 #include "trace_framework.hpp"
 
@@ -64,28 +66,27 @@ void internal::MemoryModule::RegisterKernelVMAreas(const BootArguments &args)
     // Kernel Image
     size_t kernel_size =
         reinterpret_cast<uptr>(args.kernel_end) - reinterpret_cast<uptr>(args.kernel_start);
-    VMemArea kernel_vma{
-        .start                = args.kernel_start,
-        .size                 = kernel_size,
-        .flags                = {.readable = true, .writable = true, .executable = true},
-        .type                 = VirtualMemAreaT::Anonymous,
-        .direct_mapping_start = VirtToPhys(args.kernel_start)
-    };
-
-    if (auto res = Vmm_.AddArea(&Vmm_.GetKernelAddressSpace(), kernel_vma); !res) {
+
+    auto kernel_vma_res = Mem::KNew<Mem::AnonymousVMemArea>(
+        args.kernel_start, kernel_size,
+        VirtualMemAreaFlags{.readable = true, .writable = true, .executable = true}
+    );
+    R_ASSERT_TRUE(kernel_vma_res);
+
+    if (auto res = Vmm_.AddArea(&Vmm_.GetKernelAddressSpace(), *kernel_vma_res); !res) {
         TRACE_WARN_MEMORY("Failed to register Kernel VMA");
     }
 
     // Direct Physical Map
-    VMemArea dm_vma{
-        .start                = UptrToPtr<void>(hal::kDirectMapAddrStart),
-        .size                 = hal::kDirectMemMapSizeGb * 1024ULL * 1024ULL * 1024ULL,
-        .flags                = {.readable = true, .writable = true, .executable = false},
-        .type                 = VirtualMemAreaT::DirectMapping,
-        .direct_mapping_start = UptrToPtr<void>(0)
-    };
-
-    if (auto res = Vmm_.AddArea(&Vmm_.GetKernelAddressSpace(), dm_vma); !res) {
+    auto dm_vma_res = Mem::KNew<Mem::DirectMappingVMemArea>(
+        Mem::UptrToPtr<void>(hal::kDirectMapAddrStart),
+        hal::kDirectMemMapSizeGb * 1024ULL * 1024ULL * 1024ULL,
+        VirtualMemAreaFlags{.readable = true, .writable = true, .executable = false},
+        Mem::UptrToPtr<void>(0)  // phys_start
+    );
+    R_ASSERT_TRUE(dm_vma_res);
+
+    if (auto res = Vmm_.AddArea(&Vmm_.GetKernelAddressSpace(), *dm_vma_res); !res) {
         TRACE_WARN_MEMORY("Failed to register Direct Map VMA");
     }
 }
diff --git a/kernel/src/sys/loader.cpp b/kernel/src/sys/loader.cpp
index 51126607..a26fade8 100644
--- a/kernel/src/sys/loader.cpp
+++ b/kernel/src/sys/loader.cpp
@@ -5,6 +5,8 @@
 #include <template/scope_guard.hpp>
 
 #include "hal/constants.hpp"
+#include "mem/heap.hpp"
+#include "mem/virt/area.hpp"
 #include "modules/memory.hpp"
 #include "modules/vfs.hpp"
 #include "sys/elf/elf.hpp"
@@ -84,6 +86,29 @@ expected<Mem::VPtr<void>, LoadError> ElfLoader::Load(const vfs::Path &path, Mem:
 
     auto *ph_table = reinterpret_cast<Elf::ProgramHeader *>(ph_raw);
 
+    // Track loaded segments so we can roll back changes to the address space
+    // if loading fails halfway through.
+    u16 loaded_segments_count = 0;
+    template_lib::ScopeGuard vma_cleanup_guard([&]() {
+        u16 segments_cleaned = 0;
+        for (u16 i = 0; i < header.phnum && segments_cleaned < loaded_segments_count; ++i) {
+            auto &ph = ph_table[i];
+            if (ph.type != Elf::ProgramHeader::kTypeLoad || ph.memsz == 0) {
+                continue;
+            }
+
+            u64 virt_start = AlignDown(ph.vaddr, hal::kPageSizeBytes);
+            if (auto res =
+                    MemoryModule::Get().GetVmm().RmArea(&as, Mem::UptrToPtr<void>(virt_start));
+                !res) {
+                TRACE_WARN_GENERAL(
+                    "Failed to clean up VMA for segment %d during error recovery", i
+                );
+            }
+            segments_cleaned++;
+        }
+    });
+
     // 5. Load Segments
     TRACE_FREQ_INFO_GENERAL("Validating the ELF header");
     for (u16 i = 0; i < header.phnum; ++i) {
@@ -111,23 +136,25 @@ expected<Mem::VPtr<void>, LoadError> ElfLoader::Load(const vfs::Path &path, Mem:
         loading_flags.writable            = true;
 
         // Add VMA to Address Space
-        VMemArea vma{
-            .start                = UptrToPtr<void>(virt_start),
-            .size                 = size,
-            .flags                = loading_flags,
-            .type                 = VirtualMemAreaT::Anonymous,
-            .direct_mapping_start = nullptr,
-        };
-
-        if (auto res = MemoryModule::Get().GetVmm().AddArea(&as, vma); !res) {
+        auto vma_res = Mem::KNew<Mem::AnonymousVMemArea>(
+            Mem::UptrToPtr<void>(virt_start), size, loading_flags
+        );
+
+        if (!vma_res) {
+            TRACE_WARN_GENERAL("Failed to allocate VMA for segment %d", i);
+            return unexpected(LoadError::MemoryError);
+        }
+
+        // AddArea takes ownership of the pointer
+        if (auto res = MemoryModule::Get().GetVmm().AddArea(&as, *vma_res); !res) {
             TRACE_WARN_GENERAL("Failed to add VMA for segment %d", i);
             return unexpected(LoadError::MemoryError);
         }
+        loaded_segments_count++;
+
+        VMemArea *vma = *vma_res;
 
         // Copy file data into the mapped region
-        // Since we are in the same address space (kernel), we can just write to the virtual
-        // address. The Page Fault handler will catch the write to the anonymous area and allocate
-        // the page.
         if (ph.filesz > 0) {
             void *dest = reinterpret_cast<void *>(ph.vaddr);
             read_res   = vfs.ReadFile(path, dest, ph.filesz, ph.offset);
@@ -144,8 +171,9 @@ expected<Mem::VPtr<void>, LoadError> ElfLoader::Load(const vfs::Path &path, Mem:
 
         // Restore flags
         if (loading_flags.writable != original_flags.writable) {
-            if (auto res =
-                    MemoryModule::Get().GetVmm().UpdateAreaFlags(&as, vma.start, original_flags);
+            if (auto res = MemoryModule::Get().GetVmm().UpdateAreaFlags(
+                    &as, vma->GetStart(), original_flags
+                );
                 !res) {
                 TRACE_WARN_GENERAL("Failed to restore flags for segment %d", i);
                 return unexpected(LoadError::MemoryError);
@@ -153,8 +181,9 @@ expected<Mem::VPtr<void>, LoadError> ElfLoader::Load(const vfs::Path &path, Mem:
         }
     }
 
+    vma_cleanup_guard.dismiss();
     u64 entry_point = header.entry;
-    return UptrToPtr<void>(entry_point);
+    return Mem::UptrToPtr<void>(entry_point);
 }
 
 }  // namespace System
diff --git a/kernel/test/page_fault_handler_test.cpp b/kernel/test/page_fault_handler_test.cpp
index d26fad87..77a8725d 100644
--- a/kernel/test/page_fault_handler_test.cpp
+++ b/kernel/test/page_fault_handler_test.cpp
@@ -23,13 +23,10 @@ TEST_F(PageFaultHandlerTest, AnonymousMemory_WhenWritingToUnmappedPage_ShouldHan
     auto &kernel_as = MemoryModule::Get().GetKernelAddressSpace();
 
     auto *vaddr = reinterpret_cast<Mem::VPtr<u64>>(0xABCD0000);
-    Mem::VMemArea vma{
-        .start                = vaddr,
-        .size                 = hal::kPageSizeBytes,
-        .flags                = {.readable = true, .writable = true, .executable = false},
-        .type                 = VirtualMemAreaT::Anonymous,
-        .direct_mapping_start = nullptr
-    };
+    Mem::VirtualMemAreaFlags flags{.readable = true, .writable = true, .executable = false};
+    auto vma_res = Mem::KNew<Mem::AnonymousVMemArea>(vaddr, hal::kPageSizeBytes, flags);
+    ASSERT_TRUE(vma_res, "Failed to allocate VMA");
+    auto *vma = *vma_res;
 
     auto add_res = vmm.AddArea(&kernel_as, vma);
     ASSERT_TRUE(add_res, "Failed to add anonymous memory area");
@@ -53,13 +50,10 @@ TEST_F(PageFaultHandlerTest, AnonymousMemory_WhenAccessingMultipleLocationsInSam
     auto &kernel_as = MemoryModule::Get().GetKernelAddressSpace();
 
     auto *vaddr = reinterpret_cast<Mem::VPtr<u64>>(0xABCD0000);
-    Mem::VMemArea vma{
-        .start                = vaddr,
-        .size                 = hal::kPageSizeBytes,
-        .flags                = {.readable = true, .writable = true, .executable = false},
-        .type                 = VirtualMemAreaT::Anonymous,
-        .direct_mapping_start = nullptr
-    };
+    Mem::VirtualMemAreaFlags flags{.readable = true, .writable = true, .executable = false};
+    auto vma_res = Mem::KNew<Mem::AnonymousVMemArea>(vaddr, hal::kPageSizeBytes, flags);
+    ASSERT_TRUE(vma_res, "Failed to allocate VMA");
+    auto *vma = *vma_res;
 
     auto add_res = vmm.AddArea(&kernel_as, vma);
     ASSERT_TRUE(add_res, "Failed to add anonymous memory area");
@@ -104,13 +98,10 @@ TEST_F(PageFaultHandlerTest, DirectMappedMemory_WhenReadingFromUnmappedPage_Shou
     auto &kernel_as = MemoryModule::Get().GetKernelAddressSpace();
     auto *vaddr     = reinterpret_cast<Mem::VPtr<u64>>(0xBCDE0000);
 
-    Mem::VMemArea vma{
-        .start                = vaddr,
-        .size                 = hal::kPageSizeBytes,
-        .flags                = {.readable = true, .writable = true, .executable = false},
-        .type                 = Mem::VirtualMemAreaT::DirectMapping,
-        .direct_mapping_start = paddr,
-    };
+    Mem::VirtualMemAreaFlags flags{.readable = true, .writable = true, .executable = false};
+    auto vma_res = Mem::KNew<Mem::DirectMappingVMemArea>(vaddr, hal::kPageSizeBytes, flags, paddr);
+    ASSERT_TRUE(vma_res, "Failed to allocate VMA");
+    auto *vma = *vma_res;
 
     auto add_res = vmm.AddArea(&kernel_as, vma);
     ASSERT_TRUE(add_res, "Failed to add direct-mapped memory area");
@@ -146,13 +137,10 @@ TEST_F(PageFaultHandlerTest, DirectMappedMemory_WhenWritingToVirtualAddress_Shou
     auto &kernel_as = MemoryModule::Get().GetKernelAddressSpace();
     auto *vaddr     = reinterpret_cast<Mem::VPtr<u64>>(0xBCDE0000);
 
-    Mem::VMemArea vma{
-        .start                = vaddr,
-        .size                 = hal::kPageSizeBytes,
-        .flags                = {.readable = true, .writable = true, .executable = false},
-        .type                 = Mem::VirtualMemAreaT::DirectMapping,
-        .direct_mapping_start = paddr,
-    };
+    Mem::VirtualMemAreaFlags flags{.readable = true, .writable = true, .executable = false};
+    auto vma_res = Mem::KNew<Mem::DirectMappingVMemArea>(vaddr, hal::kPageSizeBytes, flags, paddr);
+    ASSERT_TRUE(vma_res, "Failed to allocate VMA");
+    auto *vma = *vma_res;
 
     auto add_res = vmm.AddArea(&kernel_as, vma);
     ASSERT_TRUE(add_res, "Failed to add direct-mapped memory area");
diff --git a/libs/libcontainers/include/allocators/custom_allocator_wrapper.hpp b/libs/libcontainers/include/allocators/custom_allocator_wrapper.hpp
index 020d60ae..1d6d8d43 100644
--- a/libs/libcontainers/include/allocators/custom_allocator_wrapper.hpp
+++ b/libs/libcontainers/include/allocators/custom_allocator_wrapper.hpp
@@ -9,8 +9,8 @@
 namespace allocators
 {
 
-template <decltype(auto) AllocateFunc, decltype(auto) DeallocateFunc, typename AllocatorT = void>
-class CustomAllocatorWrapper : decltype(AllocateFunc), decltype(DeallocateFunc)
+template <typename AllocateFunc, typename DeallocateFunc, typename AllocatorT = void>
+class CustomAllocatorWrapper : public AllocateFunc, public DeallocateFunc
 {
     static constexpr bool kCondition = !std::is_void_v<AllocatorT>;
 
@@ -18,44 +18,69 @@ class CustomAllocatorWrapper : decltype(AllocateFunc), decltype(DeallocateFunc)
     template <typename U, typename... Args>
     FORCE_INLINE_F U *Allocate(Args &&...args)
     {
-        return decltype(AllocateFunc)::operator()(std::forward<Args>(args)...);
+        return AllocateFunc::template operator()<U>(std::forward<Args>(args)...);
     }
 
     template <typename U>
     FORCE_INLINE_F void Deallocate(U *ptr)
     {
-        decltype(DeallocateFunc)::operator()(ptr);
+        DeallocateFunc::operator()(ptr);
     }
 
     OPTIONAL_FIELD(kCondition, AllocatorT) Allocator {};
 };
 
-template <typename T>
-using KMallocAllocator = CustomAllocatorWrapper<
-    []<typename... Args>(this auto &, Args &&...args) FORCE_INLINE_L {
+// Stateless functor for KMalloc
+struct KMallocAllocate {
+    template <typename T, typename... Args>
+    static FORCE_INLINE_F T *operator()(Args &&...args)
+    {
         auto mem = Mem::KMalloc<T>();
         if (!mem) {
             return static_cast<T *>(nullptr);
         }
-
         return new (*mem) T(std::forward<Args>(args)...);
-    },
-    []<typename U>(this auto &, U *ptr) FORCE_INLINE_L {
+    }
+};
+
+struct KMallocDeallocate {
+    template <typename U>
+    static FORCE_INLINE_F void operator()(U *ptr)
+    {
         if (ptr) {
             ptr->~U();
             Mem::KFree(ptr);
         }
-    }>;
-
-template <typename T, size_t kPoolSize>
-using CyclicAllocatorWrapper = CustomAllocatorWrapper<
-    []<typename... Args>(this auto &self, Args &&...args) FORCE_INLINE_L {
-        return self.Allocator.Allocate(std::forward<Args>(args)...);
-    },
-    []<typename U>(this auto &self, U *ptr) FORCE_INLINE_L {
-        self.Allocator.Free(ptr);
-    },
-    CyclicAllocator<T, kPoolSize>>;
+    }
+};
+
+template <typename T>
+using KMallocAllocator = CustomAllocatorWrapper<KMallocAllocate, KMallocDeallocate>;
+
+template <typename T, size_t kSize>
+class CyclicAllocatorWrapper
+{
+    CyclicAllocator<T, kSize> allocator_;
+
+    public:
+    template <typename U, typename... Args>
+    U *Allocate(Args &&...args)
+    {
+        static_assert(
+            std::is_same_v<U, T>, "CyclicAllocatorWrapper can only allocate its underlying type"
+        );
+        return allocator_.Allocate(std::forward<Args>(args)...);
+    }
+
+    template <typename U>
+    void Deallocate(U *ptr)
+    {
+        static_assert(
+            std::is_same_v<U, T>, "CyclicAllocatorWrapper can only deallocate its underlying type"
+        );
+        allocator_.Free(ptr);
+    }
+};
 
 }  // namespace allocators
 

From 943347d313d704095fa91be108e9e6ef33ee3ee1 Mon Sep 17 00:00:00 2001
From: Jakub Lisowski <115403674+Jlisowskyy@users.noreply.github.com>
Date: Mon, 29 Dec 2025 23:38:47 +0100
Subject: [PATCH 33/56] Jlisowskyy/scheduler 3 (#256)

Things done in this PR:
- added support for context switching on interrupt return
- added support for gs fs saving
- added support for user space jump
---
 kernel/arch/x86_64/src/hal/impl/core.cpp      |  14 ++
 kernel/arch/x86_64/src/hal/impl/core.hpp      |   7 +-
 .../arch/x86_64/src/hal/impl/scheduling.cpp   |   5 +-
 .../arch/x86_64/src/hal/impl/scheduling.hpp   |   2 +
 kernel/arch/x86_64/src/hal/impl/tasks.hpp     |  17 +++
 .../arch/x86_64/src/include/scheduling.nasm   |  28 ++++
 kernel/arch/x86_64/src/include/thread.nasm    |   2 +
 kernel/arch/x86_64/src/interrupts/idt.nasm    | 109 ++++++++++++----
 kernel/arch/x86_64/src/kernel/init.cpp        |  11 +-
 .../x86_64/src/scheduling/scheduling.nasm     | 120 +++++++++---------
 kernel/src/hal/scheduling.hpp                 |   1 +
 kernel/src/hal/tasks.hpp                      |  12 ++
 kernel/src/scheduling/process.hpp             |  10 +-
 kernel/src/scheduling/thread.hpp              |   3 +-
 kernel/src/scheduling/threads.cpp             |  14 +-
 kernel/src/scheduling/threads.hpp             |   2 +-
 16 files changed, 262 insertions(+), 95 deletions(-)
 create mode 100644 kernel/arch/x86_64/src/hal/impl/tasks.hpp
 create mode 100644 kernel/arch/x86_64/src/include/scheduling.nasm
 create mode 100644 kernel/src/hal/tasks.hpp

diff --git a/kernel/arch/x86_64/src/hal/impl/core.cpp b/kernel/arch/x86_64/src/hal/impl/core.cpp
index 11abbce2..fec2b151 100644
--- a/kernel/arch/x86_64/src/hal/impl/core.cpp
+++ b/kernel/arch/x86_64/src/hal/impl/core.cpp
@@ -32,3 +32,17 @@ void InitializeCoreLocal()
 }  // namespace arch
 
 void cdecl_SetTssRsp0(const u64 rsp0) { arch::SetTssRsp0(rsp0); }
+
+void cdecl_SwapFsIfNeeded(Sched::Thread *thread)
+{
+    auto tcb = hardware::GetCurrentTCB();
+
+    if (tcb->fs_base != thread->fs_base) {
+        cpu::SetMSR(arch::kIa32FsBase, thread->fs_base);
+    }
+}
+
+void cdecl_SetNextThreadFs(Sched::Thread *thread)
+{
+    cpu::SetMSR(arch::kIa32FsBase, thread->fs_base);
+}
diff --git a/kernel/arch/x86_64/src/hal/impl/core.hpp b/kernel/arch/x86_64/src/hal/impl/core.hpp
index cddb9254..d2ebfea2 100644
--- a/kernel/arch/x86_64/src/hal/impl/core.hpp
+++ b/kernel/arch/x86_64/src/hal/impl/core.hpp
@@ -6,6 +6,7 @@
 #include "cpu/msrs.hpp"
 #include "cpu/utils.hpp"
 #include "drivers/apic/local_apic.hpp"
+#include "scheduling/thread.hpp"
 
 namespace arch
 {
@@ -14,7 +15,9 @@ namespace arch
 // defines
 // ------------------------------
 
-static constexpr u32 kIa32GsBase = 0xC0000101;
+static constexpr u32 kIa32FsBase       = 0xC0000100;
+static constexpr u32 kIa32GsBase       = 0xC0000101;
+static constexpr u32 kIa32GsKernelBase = 0xC0000102;
 
 struct CoreConfig {
     u16 acpi_id;
@@ -107,5 +110,7 @@ void InitializeCoreLocal();
 }  // namespace arch
 
 extern "C" void cdecl_SetTssRsp0(u64 rsp0);
+extern "C" void cdecl_SwapFsIfNeeded(Sched::Thread *thread);
+extern "C" void cdecl_SetNextThreadFs(Sched::Thread *thread);
 
 #endif  // KERNEL_ARCH_X86_64_SRC_HAL_IMPL_CORE_HPP_
diff --git a/kernel/arch/x86_64/src/hal/impl/scheduling.cpp b/kernel/arch/x86_64/src/hal/impl/scheduling.cpp
index 4f4c2572..0f1d741c 100644
--- a/kernel/arch/x86_64/src/hal/impl/scheduling.cpp
+++ b/kernel/arch/x86_64/src/hal/impl/scheduling.cpp
@@ -1,4 +1,5 @@
 #include "hal/impl/scheduling.hpp"
+#include "cpu/gdt.hpp"
 #include "scheduling/threads.hpp"
 
 #include <string.h>
@@ -13,9 +14,9 @@ FAST_CALL void InitializeStack(void **stack, void (*f)())
     static constexpr u64 kInitialFlags =
         kSingleBit<u64, 1> | kSingleBit<u64, 9>;  // Bit1 - Reserved, Bit9 - Interrupt flag
 
-    static constexpr size_t kStackSpace  = 20 * 8;  // 15 regs + InterruptStackFrame
+    static constexpr size_t kStackSpace  = 21 * 8;  // 15 regs + InterruptStackFrame
     static constexpr size_t kRdiOffset   = 4 * 8;   // rdi = 5th reg
-    static constexpr size_t kRipOffset   = 15 * 8;  // 15 regs
+    static constexpr size_t kRipOffset   = 16 * 8;  // 15 regs + error code
     static constexpr size_t kCsOffset    = kRipOffset + sizeof(u64);
     static constexpr size_t kFlagsOffset = kCsOffset + sizeof(u64);
     static constexpr size_t kSpOffset    = kFlagsOffset + sizeof(u64);
diff --git a/kernel/arch/x86_64/src/hal/impl/scheduling.hpp b/kernel/arch/x86_64/src/hal/impl/scheduling.hpp
index 8a752866..e01ab982 100644
--- a/kernel/arch/x86_64/src/hal/impl/scheduling.hpp
+++ b/kernel/arch/x86_64/src/hal/impl/scheduling.hpp
@@ -5,11 +5,13 @@
 
 extern "C" void ConvertContext(Sched::Thread *thread);
 extern "C" void ContextSwitch(Sched::Thread *thread);
+extern "C" void JumpToUserSpace(void (*f)());
 
 namespace arch
 {
 using ::ContextSwitch;
 using ::ConvertContext;
+using ::JumpToUserSpace;
 void InitializeStackKThread(void **stack, void (*f)());
 void InitializeStackUserThread(void **stack, void (*f)());
 }  // namespace arch
diff --git a/kernel/arch/x86_64/src/hal/impl/tasks.hpp b/kernel/arch/x86_64/src/hal/impl/tasks.hpp
new file mode 100644
index 00000000..6859dfaf
--- /dev/null
+++ b/kernel/arch/x86_64/src/hal/impl/tasks.hpp
@@ -0,0 +1,17 @@
+#ifndef KERNEL_ARCH_X86_64_SRC_HAL_IMPL_TASKS_HPP_
+#define KERNEL_ARCH_X86_64_SRC_HAL_IMPL_TASKS_HPP_
+
+#include <types.hpp>
+namespace arch
+{
+
+struct Thread {
+    u64 fs_base;
+    u64 gs_base;
+};
+struct Process {
+};
+
+}  // namespace arch
+
+#endif  // KERNEL_ARCH_X86_64_SRC_HAL_IMPL_TASKS_HPP_
diff --git a/kernel/arch/x86_64/src/include/scheduling.nasm b/kernel/arch/x86_64/src/include/scheduling.nasm
new file mode 100644
index 00000000..c2bd3c83
--- /dev/null
+++ b/kernel/arch/x86_64/src/include/scheduling.nasm
@@ -0,0 +1,28 @@
+; ------------------------------------------------------------
+; Scheduling/Interrupts helpers
+; ------------------------------------------------------------
+
+%include "include/regs.nasm"
+%include "include/thread.nasm"
+
+_context_switch_stack_space equ 21*8
+_context_switch_stack_space_ext equ 20*8; 8 bytes already reserved by caller
+_rip_call_offset equ _context_switch_stack_space_ext
+_rip_int_frame_offset equ _all_reg_size + 8
+_cs_int_frame_offset equ _rip_int_frame_offset + 8
+_flags_int_frame_offset equ _cs_int_frame_offset + 8
+_sp_int_frame_offset equ _flags_int_frame_offset + 8
+_ss_int_frame_offset equ _sp_int_frame_offset + 8
+
+_kernel_code_selector equ 0x08
+_kernel_data_selector equ 0x10
+_user_code_selector equ 0x18
+_user_data_selector equ 0x20
+
+_rip_user_space_offset equ 0
+_cs_user_space_offset equ _rip_user_space_offset + 8
+_flags_user_space_offset equ _cs_user_space_offset + 8
+_sp_user_space_offset equ _flags_user_space_offset + 8
+_ss_user_space_offset equ _sp_user_space_offset + 8
+_jump_userspace_stack_space equ  5*8
+_userspace_initial_flags equ 0x202
diff --git a/kernel/arch/x86_64/src/include/thread.nasm b/kernel/arch/x86_64/src/include/thread.nasm
index 6c0a445f..290a0cfd 100644
--- a/kernel/arch/x86_64/src/include/thread.nasm
+++ b/kernel/arch/x86_64/src/include/thread.nasm
@@ -3,6 +3,8 @@
 ; ------------------------------------------------------------
 
 struc Thread
+    .fs_base       resq 1
+    .gs_base       resq 1
     .tid:          resq 1
     .owner:        resq 1
     .next:         resq 1
diff --git a/kernel/arch/x86_64/src/interrupts/idt.nasm b/kernel/arch/x86_64/src/interrupts/idt.nasm
index b9941c8f..2df7f7fe 100644
--- a/kernel/arch/x86_64/src/interrupts/idt.nasm
+++ b/kernel/arch/x86_64/src/interrupts/idt.nasm
@@ -2,7 +2,63 @@
 ; ISR with full GPR save/restore
 ; ------------------------------------
 
-%include "include/regs.nasm"
+%include "include/scheduling.nasm"
+
+%macro load_user_gs_if_needed 0
+    mov r12, [rsp + _cs_int_frame_offset]
+    cmp qword r12, _kernel_code_selector
+    je .skip_user_gs_swap
+    call cdecl_SetKernelGs
+    swapgs
+.skip_user_gs_swap:
+%endmacro
+
+%macro context_switch_if_needed 0
+    cmp rax, 0
+    je .done                         ; Omit context switch if there is no need to change it
+
+    mov r13, rax                     ; save next TCB
+
+    call cdecl_GetCurrentTCB           ; RAX = pointer to TCB
+    mov [rax+Thread.kernel_stack], rsp ; Save RSP for previous task's kernel stack in the thread's TCB
+
+    ; ------------------------
+    ; Setup next task state
+
+    mov rdi, r13
+    call cdecl_SwapFsIfNeeded           ; Set FS base if needed
+
+    mov rdi, r13
+    call cdecl_SetCurrentTCB
+    mov rsp, [r13+Thread.kernel_stack]   ; Change the stack
+
+    mov rdi, [r13+Thread.kernel_stack_bottom]
+    call cdecl_SetTssRsp0                ; Adjust TSS.rsp0
+
+    mov rdi, r13
+    call cdecl_GetThreadsPageTable     ; RAX = next cr3
+    mov r11, cr3                       ; R11 = current cr3
+
+    cmp r11, rax                       ; Skip virtual address space change if not needed - omit tlb flushes
+    je .done
+    mov cr3, rax                       ; Load next task's virtual address space
+.done:
+
+    load_user_gs_if_needed
+
+    pop_all_regs                    ; Restore registers.
+    add rsp, _all_reg_size          ; Deallocate register save space.
+    add rsp, 8                  ; Pop dummy error code.
+    iretq
+%endmacro
+
+%macro load_kernel_gs_if_needed 0
+    mov r12, [rsp + _cs_int_frame_offset]
+    cmp qword r12, _kernel_code_selector
+    je .skip_kernel_gs_swap
+    swapgs
+.skip_kernel_gs_swap:
+%endmacro
 
 ; Macro for CPU exceptions that DO NOT push an error code.
 ; A dummy error code is pushed to create a consistent stack frame.
@@ -13,15 +69,14 @@ isr_wrapper_%+%1:
     sub rsp, _all_reg_size          ; Allocate space for saving registers.
     push_all_regs                   ; Save registers.
 
+    load_kernel_gs_if_needed
+
     cld                         ; Clear direction flag.
     mov rdi, %1                 ; Arg1: interrupt number.
     mov rsi, rsp                ; Arg2: pointer to stack frame.
     call HandleException
 
-    pop_all_regs                    ; Restore registers.
-    add rsp, _all_reg_size          ; Deallocate register save space.
-    add rsp, 8                  ; Pop dummy error code.
-    iretq
+    context_switch_if_needed
 %endmacro
 
 ; Macro for CPU exceptions that DO push an error code.
@@ -31,31 +86,31 @@ isr_wrapper_%+%1:
     sub rsp, _all_reg_size          ; Allocate space for saving registers.
     push_all_regs                   ; Save registers.
 
+    load_kernel_gs_if_needed
+
     cld                         ; Clear direction flag.
     mov rdi, %1                 ; Arg1: interrupt number.
     mov rsi, rsp                ; Arg2: pointer to stack frame.
     call HandleException
 
-    pop_all_regs                    ; Restore registers.
-    add rsp, _all_reg_size          ; Deallocate register save space.
-    add rsp, 8                  ; Pop error code.
-    iretq
+    context_switch_if_needed
 %endmacro
 
 ; Macro for hardware or software interrupts.
 ; Calls a handler with the signature 'void handler(u16 lirq)'.
 %macro interrupt_wrapper 3 ; %1: Logical IRQ, %2: idt idx %3: C handler function
 isr_wrapper_%+%2:
-    sub rsp, _sysv_reg_size          ; Allocate space for saving registers.
-    push_sysv_regs                   ; Save registers.
+    push 0                      ; Push a dummy error code for alignment.
+    sub rsp, _all_reg_size          ; Allocate space for saving registers.
+    push_all_regs                   ; Save registers.
+
+    load_kernel_gs_if_needed
 
     cld                         ; Clear direction flag for string operations.
     mov rdi, %1                 ; Pass the mapped IRQ number as the first argument.
     call %3                     ; Call the specific ISR handler.
 
-    pop_sysv_regs                    ; Restore registers.
-    add rsp, _sysv_reg_size          ; Deallocate register save space.
-    iretq                       ; Return from interrupt.
+    context_switch_if_needed
 %endmacro
 
 bits 64
@@ -67,6 +122,7 @@ section .text
 
 extern g_syscall_dispatch_table
 extern g_syscall_count
+extern cdecl_SetKernelGs
 
 ; Expected system call convention:
 ; - RAX: syscall number
@@ -89,6 +145,8 @@ isr_wrapper_128:  ; Syscall interrupt (128)
     cmp rax, [rel g_syscall_count]
     jae .invalid_syscall
 
+    swapgs
+
     ; Get pointer to syscall_dispatch_table and dispatch
     call qword [rel g_syscall_dispatch_table + rax*8]
     jmp .return
@@ -97,6 +155,10 @@ isr_wrapper_128:  ; Syscall interrupt (128)
     mov rax, -1                      ; Set error return value
 
 .return:
+
+    call cdecl_SetKernelGs
+    swapgs
+
     pop_sysv_regs_without_rax        ; Restore registers except RAX.
     add rsp, _sysv_reg_size          ; Deallocate register save space.
     iretq                            ; Return from interrupt.
@@ -105,10 +167,15 @@ isr_wrapper_128:  ; Syscall interrupt (128)
 ; ISR wrappers definitions
 ; ------------------------------
 
+extern cdecl_GetCurrentTCB
+extern cdecl_SetCurrentTCB
+extern cdecl_GetThreadsPageTable
+extern cdecl_SetTssRsp0
+extern cdecl_SetNextThreadFs
+extern cdecl_SwapFsIfNeeded
 extern HandleException
 extern HandleHardwareInterrupt
 extern HandleSoftwareInterrupt
-extern TimerContextSwitch
 
 ; Intel-defined interrupts (0-31) -> HandleException
 exception_wrapper 0  ; Division Error: Divide by zero error
@@ -145,7 +212,7 @@ exception_error_wrapper 30 ; Security Exception: Security-related error
 exception_wrapper 31 ; Reserved: Reserved by Intel
 
 ; IRQs for PICs (32–47) -> HandleHardwareInterrupt
-; DEFINED in SCHEDULING FILE ; IRQ0: System timer
+interrupt_wrapper 0, 32, HandleHardwareInterrupt ; IRQ0: System timer
 interrupt_wrapper 1, 33, HandleHardwareInterrupt ; IRQ1: Keyboard
 interrupt_wrapper 2, 34, HandleHardwareInterrupt ; IRQ2: Cascade
 interrupt_wrapper 3, 35, HandleHardwareInterrupt ; IRQ3: Serial port 2
@@ -203,15 +270,7 @@ section .data
 global IsrWrapperTable
 IsrWrapperTable:
 %assign i 0
-%rep    32
-    dq isr_wrapper_%+i
-%assign i i+1
-%endrep
-
-dq TimerContextSwitch
-
-%assign i 33
-%rep    31
+%rep    _num_isrs
     dq isr_wrapper_%+i
 %assign i i+1
 %endrep
diff --git a/kernel/arch/x86_64/src/kernel/init.cpp b/kernel/arch/x86_64/src/kernel/init.cpp
index 57cb496d..796b4ec8 100644
--- a/kernel/arch/x86_64/src/kernel/init.cpp
+++ b/kernel/arch/x86_64/src/kernel/init.cpp
@@ -50,6 +50,13 @@ static int GetCpuModel()
 
 static hardware::CoreLocal g_CoreLocal{};
 
+TODO_WHEN_MULTICORE
+// TODO: replace when core
+extern "C" void cdecl_SetKernelGs()
+{
+    cpu::SetMSR(arch::kIa32GsKernelBase, g_CoreLocal.thread_control_block->gs_base);
+}
+
 namespace arch
 {
 void ArchInit(const RawBootArguments &)
@@ -73,8 +80,8 @@ void ArchInit(const RawBootArguments &)
 
     /* Zero mem core local as no global constructors available yet */
     memset(&g_CoreLocal, 0, sizeof(hardware::CoreLocal));
-
-    hal::SetCoreLocalData(&g_CoreLocal);
+    cpu::SetMSR(kIa32GsBase, reinterpret_cast<u64>(&g_CoreLocal));
+    cpu::SetMSR(kIa32GsKernelBase, reinterpret_cast<u64>(&g_CoreLocal));
     InitializeCoreLocal();
 
     trace::AdvanceTracingStage();
diff --git a/kernel/arch/x86_64/src/scheduling/scheduling.nasm b/kernel/arch/x86_64/src/scheduling/scheduling.nasm
index 91758041..35eb7ca3 100644
--- a/kernel/arch/x86_64/src/scheduling/scheduling.nasm
+++ b/kernel/arch/x86_64/src/scheduling/scheduling.nasm
@@ -2,8 +2,7 @@
 ; Scheduling utilities and crucial functionality
 ; ------------------------------------------------------------
 
-%include "include/regs.nasm"
-%include "include/thread.nasm"
+%include "include/scheduling.nasm"
 
 bits 64
 
@@ -12,25 +11,15 @@ extern cdecl_SetCurrentTCB
 extern cdecl_GetThreadsPageTable
 extern cdecl_SetTssRsp0
 extern cdecl_EnableHardwareInterrupts
+extern cdecl_SetNextThreadFs
+extern cdecl_SwapFsIfNeeded
 extern HandleHardwareInterrupt
-
-_context_switch_stack_space equ 20*8
-_context_switch_stack_space_ext equ 19*8; 8 bytes already reserved by caller
-_rip_call_offset equ _context_switch_stack_space_ext
-_rip_int_frame_offset equ _all_reg_size
-_cs_int_frame_offset equ _rip_int_frame_offset + 8
-_flags_int_frame_offset equ _cs_int_frame_offset + 8
-_sp_int_frame_offset equ _flags_int_frame_offset + 8
-_ss_int_frame_offset equ _sp_int_frame_offset + 8
-_kernel_code_selector equ 0x08
-_kernel_data_selector equ 0x10
-_user_code_selector equ 0x18
-_user_data_selector equ 0x20
+extern cdecl_SetKernelGs
 
 section .text
 global ContextSwitch
 global ConvertContext
-global TimerContextSwitch
+global JumpToUserSpace
 
 ; c_decl
 ; void ConvertContext(Thread* thread)
@@ -39,14 +28,58 @@ global TimerContextSwitch
 ; Note: ASSUMPTION ConvertContext is always called inside KERNEL code
 ConvertContext:
     mov r12, rdi                          ; Save next TCB pointer in r12 (non-volatile) to survive C++ calls
+    call cdecl_SetNextThreadFs
+
+    mov rdi, r12
     call cdecl_SetCurrentTCB              ; Change TCB
     mov  rsp, [r12+Thread.kernel_stack]   ; Change the stack
 
     mov rdi, [r12+Thread.kernel_stack_bottom]
     call cdecl_SetTssRsp0
 
+    mov qword r13, [rsp+_cs_int_frame_offset]
+    cmp qword r13, _kernel_code_selector
+    je .done
+
+    call cdecl_SetKernelGs
+    swapgs
+
+.done:
     pop_all_regs                    ; Restore registers of NEW thread's stack
     add rsp, _all_reg_size          ; Deallocate register save space.
+    add rsp, 8                      ; pop error code
+
+    iretq
+
+; c_decl
+; void JumpToUserSpace(void (*func)())
+;   RDI = func
+; Note: Caller is responsible for ensuring proper environment before calling (disabling IRQs)
+; Note: FS already should be changed during contex switch
+JumpToUserSpace:
+    sub rsp, _context_switch_stack_space
+
+    mov [rsp + _rip_user_space_offset], rdi
+    mov qword [rsp + _cs_user_space_offset], _user_code_selector
+    mov qword [rsp + _flags_user_space_offset], _userspace_initial_flags
+
+    call cdecl_GetCurrentTCB
+    mov r12, [rax+Thread.kernel_stack_bottom]
+    mov [rax+Thread.kernel_stack], r12
+    mov r13, [rax+Thread.user_stack_bottom]
+
+    mov qword [rsp + _ss_user_space_offset], _user_data_selector
+    mov [rsp + _sp_user_space_offset], r13
+
+    call cdecl_SetKernelGs
+    swapgs
+
+    xor rax, rax
+    mov rax, _user_data_selector
+    mov ds, ax
+    mov es, ax
+    mov fs, ax
+    mov gs, ax
 
     iretq
 
@@ -85,7 +118,9 @@ ContextSwitch:
     mov qword [rsp + _ss_int_frame_offset], _kernel_data_selector
 
     mov r12, rdi                       ; Save next TCB pointer in r12 (non-volatile) to survive C++ calls
+    call cdecl_SwapFsIfNeeded
 
+    mov rdi, r12
     call cdecl_GetCurrentTCB           ; RAX = pointer to TCB
     mov [rax+Thread.kernel_stack], rsp ; Save RSP for previous task's kernel stack in the thread's TCB
 
@@ -104,52 +139,21 @@ ContextSwitch:
     mov r11, cr3                       ; R11 = current cr3
 
     cmp r11, rax                       ; Skip virtual address space change if not needed - omit tlb flushes
-    je .done
+    je .gs
     mov cr3, rax                       ; Load next task's virtual address space
 
-.done:
-    pop_all_regs                    ; Restore registers of NEW thread's stack
-    add rsp, _all_reg_size          ; Deallocate register save space.
-
-    iretq                             ; Load next thread's RIP from its stack
-
-; c_decl
-; void TimerContextSwitch(void)
-TimerContextSwitch:
-    sub rsp, _all_reg_size           ; Allocate space for saving registers.
-    push_all_regs                   ; Save registers.
-
-    mov rdi, 0                       ; Pass the mapped IRQ number as the first argument.
-    call HandleHardwareInterrupt    ; Call the specific ISR handler.
-
-    cmp rax, 0
-    je .done                         ; Omit context switch if there is no need to change it
-
-    mov r13, rax                     ; save next TCB
-
-    call cdecl_GetCurrentTCB           ; RAX = pointer to TCB
-    mov [rax+Thread.kernel_stack], rsp ; Save RSP for previous task's kernel stack in the thread's TCB
-
-    ; ------------------------
-    ; Setup next task state
-
-    mov rdi, r13                         ; Restore next TCB pointer to RDI for the next call
-    call cdecl_SetCurrentTCB
-    mov rsp, [r13+Thread.kernel_stack]   ; Change the stack
+.gs:
 
-    mov rdi, [r13+Thread.kernel_stack_bottom]
-    call cdecl_SetTssRsp0
-
-    mov rdi, r13                       ; Set RDI for GetThreadsPageTable
-    call cdecl_GetThreadsPageTable     ; RAX = next cr3
-    mov r11, cr3                       ; R11 = current cr3
-
-    cmp r11, rax                       ; Skip virtual address space change if not needed - omit tlb flushes
+    mov qword r13, [rsp+_cs_int_frame_offset]
+    cmp qword r13, _kernel_code_selector
     je .done
-    mov cr3, rax                       ; Load next task's virtual address space
+
+    call cdecl_SetKernelGs
+    swapgs
 
 .done:
-    pop_all_regs                     ; Restore registers.
-    add rsp, _all_reg_size           ; Deallocate register save space.
+    pop_all_regs                    ; Restore registers of NEW thread's stack
+    add rsp, _all_reg_size          ; Deallocate register save space.
+    add rsp, 8                      ; pop error code
 
-    iretq                            ; Return from interrupt.
+    iretq                             ; Load next thread's RIP from its stack
diff --git a/kernel/src/hal/scheduling.hpp b/kernel/src/hal/scheduling.hpp
index 8beaabda..b844a936 100644
--- a/kernel/src/hal/scheduling.hpp
+++ b/kernel/src/hal/scheduling.hpp
@@ -8,6 +8,7 @@
 
 namespace hal
 {
+WRAP_CALL void JumpToUserSpace(void (*f)()) { arch::JumpToUserSpace(f); }
 WRAP_CALL void ContextSwitch(Sched::Thread *thread) { arch::ContextSwitch(thread); }
 WRAP_CALL void ConvertContext(Sched::Thread *thread) { arch::ConvertContext(thread); }
 WRAP_CALL void InitializeStackKThread(void **stack, void (*f)())
diff --git a/kernel/src/hal/tasks.hpp b/kernel/src/hal/tasks.hpp
new file mode 100644
index 00000000..9f517a3d
--- /dev/null
+++ b/kernel/src/hal/tasks.hpp
@@ -0,0 +1,12 @@
+#ifndef KERNEL_SRC_HAL_TASKS_HPP_
+#define KERNEL_SRC_HAL_TASKS_HPP_
+
+#include "hal/impl/tasks.hpp"
+
+namespace hal
+{
+using arch::Process;
+using arch::Thread;
+}  // namespace hal
+
+#endif  // KERNEL_SRC_HAL_TASKS_HPP_
diff --git a/kernel/src/scheduling/process.hpp b/kernel/src/scheduling/process.hpp
index 73a0dc35..4e5b9502 100644
--- a/kernel/src/scheduling/process.hpp
+++ b/kernel/src/scheduling/process.hpp
@@ -4,7 +4,13 @@
 #include <defines.hpp>
 #include <types.hpp>
 
-#include "mem/virt/addr_space.hpp"
+#include "hal/tasks.hpp"
+#include "mem/types.hpp"
+
+namespace Mem
+{
+class AddressSpace;
+}
 
 namespace Sched
 {
@@ -18,7 +24,7 @@ struct PACK ProcessFlags {
 };
 static_assert(sizeof(ProcessFlags) == 1);
 
-struct Process {
+struct Process : hal::Process {
     /* Management */
     Pid pid;
     ProcessFlags flags;
diff --git a/kernel/src/scheduling/thread.hpp b/kernel/src/scheduling/thread.hpp
index 96dd8250..97beecd3 100644
--- a/kernel/src/scheduling/thread.hpp
+++ b/kernel/src/scheduling/thread.hpp
@@ -4,6 +4,7 @@
 #include <defines.hpp>
 #include <types.hpp>
 
+#include "hal/tasks.hpp"
 #include "process.hpp"
 
 namespace Sched
@@ -14,7 +15,7 @@ struct PACK Tid {
     u64 count : 48;
 };
 
-struct Thread {
+struct Thread : hal::Thread {
     /* Management */
     Tid tid;
     Pid owner;
diff --git a/kernel/src/scheduling/threads.cpp b/kernel/src/scheduling/threads.cpp
index f890dfec..0469e662 100644
--- a/kernel/src/scheduling/threads.cpp
+++ b/kernel/src/scheduling/threads.cpp
@@ -1,4 +1,8 @@
 #include "threads.hpp"
+
+#include <hal/scheduling.hpp>
+
+#include "mem/virt/addr_space.hpp"
 #include "modules/scheduling.hpp"
 
 namespace Sched
@@ -25,15 +29,19 @@ void KThreadEntrypoint(void (*f)())
     OnKThreadExit();
 }
 
-void UserThreadEntrypoint(void (*f)()) { R_FAIL_ALWAYS("Not implemented..."); }
+void UserThreadEntrypoint(void (*f)())
+{
+    OnUserThreadEntry();
+    hal::JumpToUserSpace(f);
+}
+
+void OnUserThreadEntry() {}
 
 void OnKThreadExit()
 {
     R_FAIL_ALWAYS("Not implemented. KThread should never return at this stage...");
 }
 
-void OnThreadExit() {}
-
 }  // namespace Sched
 
 void *cdecl_GetThreadsPageTable(Sched::Thread *thread)
diff --git a/kernel/src/scheduling/threads.hpp b/kernel/src/scheduling/threads.hpp
index 4bebdda5..d549c34b 100644
--- a/kernel/src/scheduling/threads.hpp
+++ b/kernel/src/scheduling/threads.hpp
@@ -76,8 +76,8 @@ class Threads
 
 void KThreadEntrypoint(void (*f)());
 void UserThreadEntrypoint(void (*f)());
+void OnUserThreadEntry();
 void OnKThreadExit();
-void OnThreadExit();
 
 }  // namespace Sched
 

From 4461a87cd579b6cad5aedf1868d773a396dfc39a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C5=81ukasz=20Kryczka?=
 <60490378+kryczkal@users.noreply.github.com>
Date: Tue, 30 Dec 2025 01:02:14 +0100
Subject: [PATCH 34/56] Kryczkal/userspace stack (#257)

## Problem
Userspace processes may need a stack. Currently there is no way to get
it

## Solution
Added functionality that finds gaps of desired size in a desired range
of the address space.
The gaps are then used to insert Anonymous Vmem Areas there (as stack,
or valloc, whatever you need)
---
 kernel/arch/x86_64/src/hal/impl/constants.hpp |  2 +
 kernel/src/constants.hpp                      | 15 +++-
 kernel/src/hal/constants.hpp                  | 13 +--
 kernel/src/mem/types.hpp                      |  3 +-
 kernel/src/mem/virt/addr_space.cpp            | 82 ++++++++++++++++---
 kernel/src/mem/virt/addr_space.hpp            | 11 ++-
 kernel/src/mem/virt/area.cpp                  | 18 ++--
 kernel/src/mem/virt/vmm.cpp                   | 52 ++++++++++++
 kernel/src/mem/virt/vmm.hpp                   | 13 +++
 kernel/src/scheduling/task_mgr.cpp            |  5 +-
 10 files changed, 179 insertions(+), 35 deletions(-)

diff --git a/kernel/arch/x86_64/src/hal/impl/constants.hpp b/kernel/arch/x86_64/src/hal/impl/constants.hpp
index 42c9f704..bfe5ed17 100644
--- a/kernel/arch/x86_64/src/hal/impl/constants.hpp
+++ b/kernel/arch/x86_64/src/hal/impl/constants.hpp
@@ -21,6 +21,8 @@ static constexpr size_t kPageShift          = 12;
 static constexpr u32 kMaxCores              = 512;
 static constexpr u16 kElfMachineType        = 0x3E;
 
+static constexpr bool kStackGrowsDown = true;
+
 // ------------------------------
 // Enums
 // ------------------------------
diff --git a/kernel/src/constants.hpp b/kernel/src/constants.hpp
index f4c8ad7e..6e8d82e0 100644
--- a/kernel/src/constants.hpp
+++ b/kernel/src/constants.hpp
@@ -1,7 +1,7 @@
 #ifndef KERNEL_SRC_CONSTANTS_HPP_
 #define KERNEL_SRC_CONSTANTS_HPP_
 
-#include "types.hpp"
+#include <types.hpp>
 
 static constexpr u16 kMaxProcesses    = 4096;
 static constexpr u32 kMaxThreads      = kMaxProcesses * 2;
@@ -9,4 +9,17 @@ static constexpr u32 kStackSize       = 64 * 1024;  // TODO 8 meg
 static constexpr u32 kKernelStackSize = 64 * 1024;  // TODO 1 meg
 static constexpr u32 kStackAlignment  = 64;
 
+static constexpr u64 kUserSpaceStart          = 0x0;
+static constexpr u64 kUserSpaceEndInclusive   = 0x00007FFFFFFFFFFF;
+static constexpr u64 kUserSpaceEndExclusive   = kUserSpaceEndInclusive + 1;
+static constexpr u64 kKernelSpaceStart        = 0xFFFF800000000000;
+static constexpr u64 kKernelSpaceEndInclusive = 0xFFFFFFFFFFFFFFFF;
+
+NODISCARD FAST_CALL bool IsKernelSpace(const u64 address) { return address >= kKernelSpaceStart; }
+
+NODISCARD FAST_CALL bool IsKernelSpace(const void *address)
+{
+    return IsKernelSpace(reinterpret_cast<u64>(address));
+}
+
 #endif  // KERNEL_SRC_CONSTANTS_HPP_
diff --git a/kernel/src/hal/constants.hpp b/kernel/src/hal/constants.hpp
index 9c8a96ad..069486a3 100644
--- a/kernel/src/hal/constants.hpp
+++ b/kernel/src/hal/constants.hpp
@@ -7,7 +7,6 @@
 
 namespace hal
 {
-static constexpr u64 kKernelVirtualAddressStart = arch::kKernelVirtualAddressStart;
 
 static constexpr u64 kDirectMapAddrStart = arch::kDirectMapAddrStart;
 static constexpr u64 kDirectMemMapSizeGb = arch::kDirectMemMapSizeGb;
@@ -21,19 +20,11 @@ static_assert(kMaxCores <= kBitMask16);  // Must fit in u16
 
 static constexpr u16 kElfMachineType = arch::kElfMachineType;
 
+static constexpr bool kStackGrowsDown = arch::kStackGrowsDown;
+
 using arch::HardwareClockId;
 using arch::HardwareEventClockId;
 
-NODISCARD FAST_CALL bool IsKernelSpace(const u64 address)
-{
-    return address >= kKernelVirtualAddressStart;
-}
-
-NODISCARD FAST_CALL bool IsKernelSpace(const void *address)
-{
-    return IsKernelSpace(reinterpret_cast<u64>(address));
-}
-
 }  // namespace hal
 
 #endif  // KERNEL_SRC_HAL_CONSTANTS_HPP_
diff --git a/kernel/src/mem/types.hpp b/kernel/src/mem/types.hpp
index f904b5c1..75e72ede 100644
--- a/kernel/src/mem/types.hpp
+++ b/kernel/src/mem/types.hpp
@@ -4,6 +4,7 @@
 #include <expected.hpp>
 #include <type_traits.hpp>
 #include <types.hpp>
+#include "constants.hpp"
 #include "hal/constants.hpp"
 
 namespace Mem
@@ -37,7 +38,7 @@ PPtr<T> VirtToPhys(VPtr<T> virtAddr)
         return reinterpret_cast<PPtr<T>>(vaddr - hal::kDirectMapAddrStart);
     }
 
-    return reinterpret_cast<PPtr<T>>(vaddr - hal::kKernelVirtualAddressStart);
+    return reinterpret_cast<PPtr<T>>(vaddr - kKernelSpaceStart);
 }
 
 template <typename T>
diff --git a/kernel/src/mem/virt/addr_space.cpp b/kernel/src/mem/virt/addr_space.cpp
index 92e73d06..2e85196a 100644
--- a/kernel/src/mem/virt/addr_space.cpp
+++ b/kernel/src/mem/virt/addr_space.cpp
@@ -2,8 +2,13 @@
 
 #include <macros.hpp>
 #include <mutex.hpp>
+
+#include <template/scope_guard.hpp>
+
+#include "constants.hpp"
 #include "hal/constants.hpp"
 #include "hal/mmu.hpp"
+
 #include "mem/error.hpp"
 #include "mem/heap.hpp"
 #include "mem/mmu/contexts.hpp"
@@ -59,22 +64,31 @@ AS::~AddressSpace()
 expected<void, MemError> AS::AddArea(VMemArea *vma)
 {
     ASSERT_NOT_NULL(vma);
+    R_ASSERT_TRUE(IsAligned(vma->GetStart(), hal::kPageSizeBytes), "VMA start is not aligned");
+    R_ASSERT_TRUE(IsAligned(vma->GetSize(), hal::kPageSizeBytes), "VMA size is not aligned");
+
     std::lock_guard guard(area_list_lock_);
+    template_lib::ScopeGuard vma_guard([&] {
+        KDelete(vma);
+    });
 
-    // Check for overlapping areas
     for (auto it = area_list_.begin(); it != area_list_.end(); ++it) {
-        if (AreasOverlap(*it, vma)) {
-            // We own vma, so we must delete it on failure
-            KDelete(vma);
-            return unexpected(MemError::InvalidArgument);
+        VMemArea *current = *it;
+        RET_UNEXPECTED_IF(AreasOverlap(current, vma), MemError::InvalidArgument);
+
+        if (vma->GetStart() < current->GetStart()) {
+            auto *pos = it.GetNode();
+            auto *new_node =
+                pos->prev ? area_list_.InsertAfter(pos->prev, vma) : area_list_.PushFront(vma);
+
+            RET_UNEXPECTED_IF(!new_node, MemError::OutOfMemory);
+            vma_guard.dismiss();
+            return {};
         }
     }
 
-    auto node = area_list_.PushFront(vma);
-    if (!node) {
-        KDelete(vma);
-        return unexpected(MemError::OutOfMemory);
-    }
+    RET_UNEXPECTED_IF(!area_list_.PushBack(vma), MemError::OutOfMemory);
+    vma_guard.dismiss();
 
     return {};
 }
@@ -124,7 +138,7 @@ expected<TlbHint, MemError> AS::UpdateAreaFlags(VPtr<void> ptr, VirtualMemAreaFl
     auto start = vma->GetStart();
     auto size  = vma->GetSize();
 
-    bool is_kernel = (PtrToUptr(start) >= hal::kKernelVirtualAddressStart);
+    bool is_kernel = IsKernelSpace(start);
 
     hal::PageFlags pf{
         .Present        = true,
@@ -174,3 +188,49 @@ bool AS::IsAddrInArea(const VMemArea *vma, VPtr<void> ptr)
     const auto addr  = reinterpret_cast<uptr>(ptr);
     return vma_s <= addr && addr < vma_e;
 }
+
+expected<GapInfo, MemError> AS::FindGap(size_t size, VPtr<void> range_start, VPtr<void> range_end)
+{
+    std::lock_guard guard(area_list_lock_);
+
+    uptr search_start = range_start ? PtrToUptr(range_start) : 0;
+    uptr search_end   = range_end ? PtrToUptr(range_end) : UINTPTR_MAX;
+
+    search_start = AlignUp(search_start, hal::kPageSizeBytes);
+    search_end   = AlignDown(search_end, hal::kPageSizeBytes);
+
+    uptr prev_end = search_start;
+
+    for (auto *vma : area_list_) {
+        uptr curr_start = PtrToUptr(vma->GetStart());
+        uptr curr_end   = curr_start + vma->GetSize();
+
+        // Search only in the range of interest
+        if (curr_end <= search_start) {
+            // Handle case where VMA overlaps the search_start boundary but ends after it
+            prev_end = std::max(prev_end, curr_end);
+            continue;
+        }
+        if (curr_start >= search_end) {
+            break;
+        }
+
+        // Gap found
+        uptr gap_start = AlignUp(prev_end, hal::kPageSizeBytes);
+        uptr gap_end   = AlignDown(curr_start, hal::kPageSizeBytes);
+
+        if (gap_end > gap_start && (gap_end - gap_start) >= size) {
+            return GapInfo{UptrToPtr<void>(gap_start), size};
+        }
+
+        prev_end = curr_end;
+    }
+
+    uptr gap_start = AlignUp(prev_end, hal::kPageSizeBytes);
+
+    if (search_end > gap_start && (search_end - gap_start) >= size) {
+        return GapInfo{UptrToPtr<void>(gap_start), size};
+    }
+
+    return unexpected(MemError::NotFound);
+}
diff --git a/kernel/src/mem/virt/addr_space.hpp b/kernel/src/mem/virt/addr_space.hpp
index c682f542..d9718f24 100644
--- a/kernel/src/mem/virt/addr_space.hpp
+++ b/kernel/src/mem/virt/addr_space.hpp
@@ -42,6 +42,11 @@ struct TlbHint {
     size_t size;
 };
 
+struct GapInfo {
+    VPtr<void> start;
+    size_t size;
+};
+
 class AddressSpace
 {
     public:
@@ -74,6 +79,9 @@ class AddressSpace
 
     expected<TlbHint, MemError> RmArea(VPtr<void> ptr);
     expected<TlbHint, MemError> UpdateAreaFlags(VPtr<void> ptr, VirtualMemAreaFlags flags);
+    expected<GapInfo, MemError> FindGap(
+        size_t size, VPtr<void> start = nullptr, VPtr<void> end = nullptr
+    );
 
     // Helpers
     using AddrSpMutIt = data_structures::DoubleLinkedList<VMemArea *>::Iterator;
@@ -86,7 +94,8 @@ class AddressSpace
     PPtr<void> page_table_root_;
     bool owns_page_table_root_;
 
-    // List of pointers to VMA objects (we own these objects)
+    /// @brief Sorted list of pointers to VMA objects. We own these objects.
+    /// @note The list is sorted by the start address of the VMA objects.
     data_structures::DoubleLinkedList<VMemArea *> area_list_;
     hal::Spinlock area_list_lock_;
 
diff --git a/kernel/src/mem/virt/area.cpp b/kernel/src/mem/virt/area.cpp
index d7ab4c38..4674c2f1 100644
--- a/kernel/src/mem/virt/area.cpp
+++ b/kernel/src/mem/virt/area.cpp
@@ -2,12 +2,14 @@
 
 #include <string.h>
 #include <bits_ext.hpp>
-#include <hal/constants.hpp>
-#include <hal/panic.hpp>
-#include <mem/mmu/contexts.hpp>
-#include <mem/virt/addr_space.hpp>
-#include <modules/memory.hpp>
-#include <trace_framework.hpp>
+
+#include "constants.hpp"
+#include "hal/constants.hpp"
+#include "hal/panic.hpp"
+#include "mem/mmu/contexts.hpp"
+#include "mem/virt/addr_space.hpp"
+#include "modules/memory.hpp"
+#include "trace_framework.hpp"
 
 namespace Mem
 {
@@ -15,7 +17,7 @@ namespace Mem
 static bool MapPage(AddressSpace &as, VPtr<void> vaddr, PPtr<void> paddr, VirtualMemAreaFlags flags)
 {
     auto &mmu      = MemoryModule::Get().GetMmu();
-    bool is_kernel = (Mem::PtrToUptr(vaddr) >= hal::kKernelVirtualAddressStart);
+    bool is_kernel = (Mem::PtrToUptr(vaddr) >= kKernelSpaceStart);
 
     hal::PageFlags page_flags{
         .Present        = true,
@@ -117,7 +119,7 @@ KernelSyncVMemArea::KernelSyncVMemArea()
     // Covers the entire upper half of the 64-bit address space
     // 0x8000000000000000 - 0xFFFFFFFFFFFFFFFF
     : VMemArea(
-          Mem::UptrToPtr<void>(kBitMaskLeft<u64, 1>), kBitMaskLeft<u64, 1> - 1,
+          Mem::UptrToPtr<void>(kKernelSpaceStart), kKernelSpaceEndInclusive - kKernelSpaceStart,
           // Permissions are determined by the actual kernel page table entries being copied,
           // these flags are just placeholders for the VMA object.
           VirtualMemAreaFlags{.readable = true, .writable = true, .executable = true}
diff --git a/kernel/src/mem/virt/vmm.cpp b/kernel/src/mem/virt/vmm.cpp
index 1c6effe0..d9fa292d 100644
--- a/kernel/src/mem/virt/vmm.cpp
+++ b/kernel/src/mem/virt/vmm.cpp
@@ -4,6 +4,7 @@
 #include <macros.hpp>
 #include <template/scope_guard.hpp>
 
+#include "constants.hpp"
 #include "hal/constants.hpp"
 #include "mem/heap.hpp"
 #include "mem/mmu/contexts.hpp"
@@ -116,4 +117,55 @@ expected<void, MemError> Vmm::UpdateAreaFlags(
     return {};
 }
 
+expected<VPtr<void>, MemError> Vmm::AllocAnonymous(
+    VPtr<AddressSpace> as, size_t size, VirtualMemAreaFlags flags, VPtr<void> range_start,
+    VPtr<void> range_end
+)
+{
+    auto gap_res = as->FindGap(size, range_start, range_end);
+    RET_UNEXPECTED_IF_ERR(gap_res);
+    auto gap = *gap_res;
+
+    auto vma_res = KNew<AnonymousVMemArea>(gap.start, gap.size, flags);
+    RET_UNEXPECTED_IF(!vma_res, MemError::OutOfMemory);
+    auto *vma = *vma_res;
+
+    auto add_res = as->AddArea(vma);
+    RET_UNEXPECTED_IF_ERR(add_res);
+
+    return gap.start;
+}
+
+expected<VPtr<void>, MemError> Vmm::AllocUserStack(VPtr<AddressSpace> as, size_t size)
+{
+    auto user_start = UptrToPtr<void>(kUserSpaceStart);
+    auto user_end   = UptrToPtr<void>(kUserSpaceEndExclusive);
+
+    VirtualMemAreaFlags flags = {
+        .readable = true, .writable = true, .executable = false, .cache_disable = true
+    };
+
+    auto res = AllocAnonymous(as, size, flags, user_start, user_end);
+    RET_UNEXPECTED_IF_ERR(res);
+
+    VPtr<void> base = *res;
+
+    if constexpr (hal::kStackGrowsDown) {
+        return reinterpret_cast<VPtr<void>>(reinterpret_cast<uptr>(base) + size);
+    } else {
+        return base;
+    }
+}
+
+expected<VPtr<void>, MemError> Vmm::AllocKernelHeap(size_t size)
+{
+    auto kernel_start = UptrToPtr<void>(kKernelSpaceStart);
+
+    VirtualMemAreaFlags flags = {
+        .readable = true, .writable = true, .executable = false, .cache_disable = false
+    };
+
+    return AllocAnonymous(&kernel_as_, size, flags, kernel_start, nullptr);
+}
+
 }  // namespace Mem
diff --git a/kernel/src/mem/virt/vmm.hpp b/kernel/src/mem/virt/vmm.hpp
index f21b1a5d..146b03c7 100644
--- a/kernel/src/mem/virt/vmm.hpp
+++ b/kernel/src/mem/virt/vmm.hpp
@@ -53,6 +53,19 @@ class VirtualMemoryManager
         VPtr<AddressSpace> as, VPtr<void> region_start, VirtualMemAreaFlags vmaf
     );
 
+    // ------------------------------
+    // Allocation Helpers
+    // ------------------------------
+
+    expected<VPtr<void>, MemError> AllocAnonymous(
+        VPtr<AddressSpace> as, size_t size, VirtualMemAreaFlags flags,
+        VPtr<void> range_start = nullptr, VPtr<void> range_end = nullptr
+    );
+
+    expected<VPtr<void>, MemError> AllocUserStack(VPtr<AddressSpace> as, size_t size);
+
+    expected<VPtr<void>, MemError> AllocKernelHeap(size_t size);
+
     private:
     // ------------------------------
     // Class fields
diff --git a/kernel/src/scheduling/task_mgr.cpp b/kernel/src/scheduling/task_mgr.cpp
index 8f6229f9..4c544cc3 100644
--- a/kernel/src/scheduling/task_mgr.cpp
+++ b/kernel/src/scheduling/task_mgr.cpp
@@ -1,5 +1,6 @@
 #include <template/scope_guard.hpp>
 
+#include "constants.hpp"
 #include "modules/memory.hpp"
 #include "modules/scheduling.hpp"
 #include "scheduling/kworker.hpp"
@@ -42,9 +43,9 @@ std::expected<std::tuple<Pid, Tid>, Error> TaskMgr::SpawnProcess(
     bool dismiss = false;
 
     if (kernel_only) {
-        ASSERT_TRUE(hal::IsKernelSpace(reinterpret_cast<void *>(f)));
+        ASSERT_TRUE(IsKernelSpace(reinterpret_cast<void *>(f)));
     } else {
-        ASSERT_FALSE(hal::IsKernelSpace(reinterpret_cast<void *>(f)));
+        ASSERT_FALSE(IsKernelSpace(reinterpret_cast<void *>(f)));
     }
 
     // 1. Prepare internal structure for the process

From 83bf61790aab7872bebeae9520661a5a75201879 Mon Sep 17 00:00:00 2001
From: Jakub Lisowski <115403674+Jlisowskyy@users.noreply.github.com>
Date: Tue, 30 Dec 2025 14:32:35 +0100
Subject: [PATCH 35/56] Jlisowskyy/float save (#258)

Things done in this PR:
- added float state save/restore
- cleaned up scheduling code
---
 kernel/arch/x86_64/CMakeLists.txt             |   2 +-
 kernel/arch/x86_64/src/cpu/msrs.hpp           |   2 +
 kernel/arch/x86_64/src/cpu/utils.hpp          |   4 +
 kernel/arch/x86_64/src/hal/impl/core.cpp      |  16 --
 kernel/arch/x86_64/src/hal/impl/core.hpp      |  10 -
 .../arch/x86_64/src/hal/impl/scheduling.cpp   |  37 ++--
 .../arch/x86_64/src/hal/impl/scheduling.hpp   |   2 +
 kernel/arch/x86_64/src/hal/impl/tasks.hpp     |  16 +-
 .../arch/x86_64/src/include/scheduling.nasm   |   8 +-
 kernel/arch/x86_64/src/include/thread.nasm    |   1 +
 kernel/arch/x86_64/src/interrupts/idt.nasm    |  39 +---
 .../arch/x86_64/src/scheduling/scheduling.cpp | 203 ++++++++++++++++++
 .../x86_64/src/scheduling/scheduling.nasm     | 109 ++--------
 kernel/src/hal/api/tasks.hpp                  |  11 +
 kernel/src/hardware/core_local.cpp            |   4 -
 kernel/src/hardware/core_local.hpp            |   3 -
 kernel/src/scheduling/process.hpp             |   1 +
 kernel/src/scheduling/task_mgr.cpp            |  56 ++---
 kernel/src/scheduling/task_mgr.hpp            |   2 +-
 kernel/src/scheduling/threads.cpp             |  11 +-
 kernel/src/scheduling/threads.hpp             |   2 -
 kernel/test/manual_tests.cpp                  |   8 +-
 .../include/data_structures/hash_maps.hpp     |   4 +-
 23 files changed, 319 insertions(+), 232 deletions(-)
 create mode 100644 kernel/arch/x86_64/src/scheduling/scheduling.cpp
 create mode 100644 kernel/src/hal/api/tasks.hpp
 delete mode 100644 kernel/src/hardware/core_local.cpp

diff --git a/kernel/arch/x86_64/CMakeLists.txt b/kernel/arch/x86_64/CMakeLists.txt
index 8302dcfb..ec7f105b 100644
--- a/kernel/arch/x86_64/CMakeLists.txt
+++ b/kernel/arch/x86_64/CMakeLists.txt
@@ -58,7 +58,7 @@ alkos_register_runtime_environment(
     QEMU_COMMAND
         "qemu-system-x86_64"
     QEMU_NORMAL_FLAGS
-        "-serial stdio -enable-kvm -cpu max,+invtsc,migratable=off -machine type=q35,accel=kvm -display default,show-cursor=on -k en-us -m 4G -smp sockets=1,cores=4,threads=1"
+        "-serial stdio -enable-kvm -cpu max,+invtsc,migratable=off -machine type=q35,accel=kvm -display default,show-cursor=on -k en-us -m 4G -smp sockets=1,cores=4,threads=1  -no-reboot"
     QEMU_TEST_FLAGS
         "-serial stdio -enable-kvm -cpu max,+invtsc,migratable=off -machine type=q35,accel=kvm -display none -m 4G -smp sockets=1,cores=4,threads=1 -no-reboot"
     MODULES
diff --git a/kernel/arch/x86_64/src/cpu/msrs.hpp b/kernel/arch/x86_64/src/cpu/msrs.hpp
index 4b5a4c7f..7432dcfa 100644
--- a/kernel/arch/x86_64/src/cpu/msrs.hpp
+++ b/kernel/arch/x86_64/src/cpu/msrs.hpp
@@ -3,6 +3,8 @@
 
 #include <types.hpp>
 
+#include <trace_framework.hpp>
+
 namespace cpu
 {
 NODISCARD FAST_CALL u64 GetMSR(const u32 msr)
diff --git a/kernel/arch/x86_64/src/cpu/utils.hpp b/kernel/arch/x86_64/src/cpu/utils.hpp
index 2f3fd3b7..a5354f0a 100644
--- a/kernel/arch/x86_64/src/cpu/utils.hpp
+++ b/kernel/arch/x86_64/src/cpu/utils.hpp
@@ -1,6 +1,7 @@
 #ifndef KERNEL_ARCH_X86_64_SRC_CPU_UTILS_HPP_
 #define KERNEL_ARCH_X86_64_SRC_CPU_UTILS_HPP_
 
+#include <bits_ext.hpp>
 #include <defines.hpp>
 #include <template/rolled_switch.hpp>
 #include <types.hpp>
@@ -201,4 +202,7 @@ FAST_CALL void DumpGeneralRegisters(DumpedRegisters *regs)
 
 void TraceDumpedRegisters(const DumpedRegisters *regs);
 
+static constexpr u64 kInitialRFlags =
+    kSingleBit<u64, 1> | kSingleBit<u64, 9>;  // Bit1 - Reserved, Bit9 - Interrupt flag
+
 #endif  // KERNEL_ARCH_X86_64_SRC_CPU_UTILS_HPP_
diff --git a/kernel/arch/x86_64/src/hal/impl/core.cpp b/kernel/arch/x86_64/src/hal/impl/core.cpp
index fec2b151..3158143e 100644
--- a/kernel/arch/x86_64/src/hal/impl/core.cpp
+++ b/kernel/arch/x86_64/src/hal/impl/core.cpp
@@ -30,19 +30,3 @@ void InitializeCoreLocal()
     );
 }
 }  // namespace arch
-
-void cdecl_SetTssRsp0(const u64 rsp0) { arch::SetTssRsp0(rsp0); }
-
-void cdecl_SwapFsIfNeeded(Sched::Thread *thread)
-{
-    auto tcb = hardware::GetCurrentTCB();
-
-    if (tcb->fs_base != thread->fs_base) {
-        cpu::SetMSR(arch::kIa32FsBase, thread->fs_base);
-    }
-}
-
-void cdecl_SetNextThreadFs(Sched::Thread *thread)
-{
-    cpu::SetMSR(arch::kIa32FsBase, thread->fs_base);
-}
diff --git a/kernel/arch/x86_64/src/hal/impl/core.hpp b/kernel/arch/x86_64/src/hal/impl/core.hpp
index d2ebfea2..053840af 100644
--- a/kernel/arch/x86_64/src/hal/impl/core.hpp
+++ b/kernel/arch/x86_64/src/hal/impl/core.hpp
@@ -99,18 +99,8 @@ FAST_CALL void SetCoreLocalData(void *data)
 
 FAST_CALL void *GetCoreLocalData() { return reinterpret_cast<void *>(cpu::GetMSR(kIa32GsBase)); }
 
-FAST_CALL void SetTssRsp0(const u64 rsp0)
-{
-    const auto core_local = static_cast<CoreLocal *>(GetCoreLocalData());
-    core_local->tss.rsp0  = rsp0;
-}
-
 void InitializeCoreLocal();
 
 }  // namespace arch
 
-extern "C" void cdecl_SetTssRsp0(u64 rsp0);
-extern "C" void cdecl_SwapFsIfNeeded(Sched::Thread *thread);
-extern "C" void cdecl_SetNextThreadFs(Sched::Thread *thread);
-
 #endif  // KERNEL_ARCH_X86_64_SRC_HAL_IMPL_CORE_HPP_
diff --git a/kernel/arch/x86_64/src/hal/impl/scheduling.cpp b/kernel/arch/x86_64/src/hal/impl/scheduling.cpp
index 0f1d741c..ffa8c1ed 100644
--- a/kernel/arch/x86_64/src/hal/impl/scheduling.cpp
+++ b/kernel/arch/x86_64/src/hal/impl/scheduling.cpp
@@ -1,5 +1,7 @@
 #include "hal/impl/scheduling.hpp"
 #include "cpu/gdt.hpp"
+#include "cpu/utils.hpp"
+#include "hal/interrupt_params.hpp"
 #include "scheduling/threads.hpp"
 
 #include <string.h>
@@ -11,28 +13,19 @@ FAST_CALL void InitializeStack(void **stack, void (*f)())
     /* NOTE: Thread entry always starts in Kernel Code */
     static constexpr auto kFunc =
         kIsKernelTask ? Sched::KThreadEntrypoint : Sched::UserThreadEntrypoint;
-    static constexpr u64 kInitialFlags =
-        kSingleBit<u64, 1> | kSingleBit<u64, 9>;  // Bit1 - Reserved, Bit9 - Interrupt flag
-
-    static constexpr size_t kStackSpace  = 21 * 8;  // 15 regs + InterruptStackFrame
-    static constexpr size_t kRdiOffset   = 4 * 8;   // rdi = 5th reg
-    static constexpr size_t kRipOffset   = 16 * 8;  // 15 regs + error code
-    static constexpr size_t kCsOffset    = kRipOffset + sizeof(u64);
-    static constexpr size_t kFlagsOffset = kCsOffset + sizeof(u64);
-    static constexpr size_t kSpOffset    = kFlagsOffset + sizeof(u64);
-    static constexpr size_t kSsOffset    = kSpOffset + sizeof(u64);
-
-    auto stack_top = static_cast<byte *>(*stack) - kStackSpace;
-
-    memset(stack_top, 0, kStackSpace);
-    *reinterpret_cast<u64 *>(stack_top + kRdiOffset) = reinterpret_cast<u64>(f);
-    *reinterpret_cast<u64 *>(stack_top + kRipOffset) = reinterpret_cast<u64>(kFunc);
-    *reinterpret_cast<u64 *>(stack_top + kCsOffset) =
-        static_cast<u64>(cpu::GDT::kKernelCodeSelector);
-    *reinterpret_cast<u64 *>(stack_top + kSsOffset) =
-        static_cast<u64>(cpu::GDT::kKernelDataSelector);
-    *reinterpret_cast<u64 *>(stack_top + kSpOffset)    = reinterpret_cast<u64>(*stack);
-    *reinterpret_cast<u64 *>(stack_top + kFlagsOffset) = kInitialFlags;
+
+    auto stack_top = static_cast<byte *>(*stack) - sizeof(IsrErrorStackFrame);
+    auto frame     = reinterpret_cast<IsrErrorStackFrame *>(stack_top);
+
+    memset(stack_top, 0, sizeof(IsrErrorStackFrame));
+
+    frame->registers.rdi          = reinterpret_cast<u64>(f);
+    frame->isr_stack_frame.rip    = reinterpret_cast<u64>(kFunc);
+    frame->error_code             = 0;
+    frame->isr_stack_frame.cs     = static_cast<u64>(cpu::GDT::kKernelCodeSelector);
+    frame->isr_stack_frame.rflags = kInitialRFlags;
+    frame->isr_stack_frame.rsp    = reinterpret_cast<u64>(*stack);
+    frame->isr_stack_frame.ss     = static_cast<u64>(cpu::GDT::kKernelDataSelector);
 
     *stack = reinterpret_cast<void *>(stack_top);
 }
diff --git a/kernel/arch/x86_64/src/hal/impl/scheduling.hpp b/kernel/arch/x86_64/src/hal/impl/scheduling.hpp
index e01ab982..9d243e71 100644
--- a/kernel/arch/x86_64/src/hal/impl/scheduling.hpp
+++ b/kernel/arch/x86_64/src/hal/impl/scheduling.hpp
@@ -1,6 +1,8 @@
 #ifndef KERNEL_ARCH_X86_64_SRC_HAL_IMPL_SCHEDULING_HPP_
 #define KERNEL_ARCH_X86_64_SRC_HAL_IMPL_SCHEDULING_HPP_
 
+#include <defines.hpp>
+
 #include "scheduling/thread.hpp"
 
 extern "C" void ConvertContext(Sched::Thread *thread);
diff --git a/kernel/arch/x86_64/src/hal/impl/tasks.hpp b/kernel/arch/x86_64/src/hal/impl/tasks.hpp
index 6859dfaf..3a33809e 100644
--- a/kernel/arch/x86_64/src/hal/impl/tasks.hpp
+++ b/kernel/arch/x86_64/src/hal/impl/tasks.hpp
@@ -1,13 +1,27 @@
 #ifndef KERNEL_ARCH_X86_64_SRC_HAL_IMPL_TASKS_HPP_
 #define KERNEL_ARCH_X86_64_SRC_HAL_IMPL_TASKS_HPP_
 
+#include <string.h>
+#include <defines.hpp>
 #include <types.hpp>
+
+#include "hal/api/tasks.hpp"
+
 namespace arch
 {
 
-struct Thread {
+struct Thread : ThreadAPI {
+    alignas(64) byte fp_state[4096];
+
     u64 fs_base;
     u64 gs_base;
+
+    FORCE_INLINE_F void InitMem()
+    {
+        fs_base = 0;
+        gs_base = 0;
+        memset(fp_state, 0, sizeof(fp_state));
+    }
 };
 struct Process {
 };
diff --git a/kernel/arch/x86_64/src/include/scheduling.nasm b/kernel/arch/x86_64/src/include/scheduling.nasm
index c2bd3c83..4045effb 100644
--- a/kernel/arch/x86_64/src/include/scheduling.nasm
+++ b/kernel/arch/x86_64/src/include/scheduling.nasm
@@ -19,10 +19,4 @@ _kernel_data_selector equ 0x10
 _user_code_selector equ 0x18
 _user_data_selector equ 0x20
 
-_rip_user_space_offset equ 0
-_cs_user_space_offset equ _rip_user_space_offset + 8
-_flags_user_space_offset equ _cs_user_space_offset + 8
-_sp_user_space_offset equ _flags_user_space_offset + 8
-_ss_user_space_offset equ _sp_user_space_offset + 8
-_jump_userspace_stack_space equ  5*8
-_userspace_initial_flags equ 0x202
+_jump_userspace_stack_space equ  5*8  ; sizeof(IsrStackFrame)
diff --git a/kernel/arch/x86_64/src/include/thread.nasm b/kernel/arch/x86_64/src/include/thread.nasm
index 290a0cfd..1baa7ad1 100644
--- a/kernel/arch/x86_64/src/include/thread.nasm
+++ b/kernel/arch/x86_64/src/include/thread.nasm
@@ -3,6 +3,7 @@
 ; ------------------------------------------------------------
 
 struc Thread
+    .fp_state      resb 4096
     .fs_base       resq 1
     .gs_base       resq 1
     .tid:          resq 1
diff --git a/kernel/arch/x86_64/src/interrupts/idt.nasm b/kernel/arch/x86_64/src/interrupts/idt.nasm
index 2df7f7fe..cb5d02d0 100644
--- a/kernel/arch/x86_64/src/interrupts/idt.nasm
+++ b/kernel/arch/x86_64/src/interrupts/idt.nasm
@@ -4,6 +4,12 @@
 
 %include "include/scheduling.nasm"
 
+extern cdecl_SetKernelGs
+extern cdecl_ContextSwitchOnInterrupt
+extern HandleException
+extern HandleHardwareInterrupt
+extern HandleSoftwareInterrupt
+
 %macro load_user_gs_if_needed 0
     mov r12, [rsp + _cs_int_frame_offset]
     cmp qword r12, _kernel_code_selector
@@ -19,29 +25,11 @@
 
     mov r13, rax                     ; save next TCB
 
-    call cdecl_GetCurrentTCB           ; RAX = pointer to TCB
-    mov [rax+Thread.kernel_stack], rsp ; Save RSP for previous task's kernel stack in the thread's TCB
-
-    ; ------------------------
-    ; Setup next task state
-
     mov rdi, r13
-    call cdecl_SwapFsIfNeeded           ; Set FS base if needed
+    mov rsi, rsp
+    call cdecl_ContextSwitchOnInterrupt
 
-    mov rdi, r13
-    call cdecl_SetCurrentTCB
     mov rsp, [r13+Thread.kernel_stack]   ; Change the stack
-
-    mov rdi, [r13+Thread.kernel_stack_bottom]
-    call cdecl_SetTssRsp0                ; Adjust TSS.rsp0
-
-    mov rdi, r13
-    call cdecl_GetThreadsPageTable     ; RAX = next cr3
-    mov r11, cr3                       ; R11 = current cr3
-
-    cmp r11, rax                       ; Skip virtual address space change if not needed - omit tlb flushes
-    je .done
-    mov cr3, rax                       ; Load next task's virtual address space
 .done:
 
     load_user_gs_if_needed
@@ -122,7 +110,6 @@ section .text
 
 extern g_syscall_dispatch_table
 extern g_syscall_count
-extern cdecl_SetKernelGs
 
 ; Expected system call convention:
 ; - RAX: syscall number
@@ -167,16 +154,6 @@ isr_wrapper_128:  ; Syscall interrupt (128)
 ; ISR wrappers definitions
 ; ------------------------------
 
-extern cdecl_GetCurrentTCB
-extern cdecl_SetCurrentTCB
-extern cdecl_GetThreadsPageTable
-extern cdecl_SetTssRsp0
-extern cdecl_SetNextThreadFs
-extern cdecl_SwapFsIfNeeded
-extern HandleException
-extern HandleHardwareInterrupt
-extern HandleSoftwareInterrupt
-
 ; Intel-defined interrupts (0-31) -> HandleException
 exception_wrapper 0  ; Division Error: Divide by zero error
 exception_wrapper 1  ; Debug: Reserved for debugging exceptions
diff --git a/kernel/arch/x86_64/src/scheduling/scheduling.cpp b/kernel/arch/x86_64/src/scheduling/scheduling.cpp
new file mode 100644
index 00000000..b45a6715
--- /dev/null
+++ b/kernel/arch/x86_64/src/scheduling/scheduling.cpp
@@ -0,0 +1,203 @@
+#include "modules/scheduling.hpp"
+
+#include <cpu/control_registers.hpp>
+
+#include "cpu/utils.hpp"
+#include "hal/interrupt_params.hpp"
+#include "hardware/core_local.hpp"
+#include "mem/virt/addr_space.hpp"
+#include "scheduling/thread.hpp"
+
+// ------------------------------
+// statics
+// ------------------------------
+
+FAST_CALL void SetThreadGs(Sched::Thread *thread)
+{
+    ASSERT_NOT_NULL(thread);
+
+    cpu::SetMSR(arch::kIa32GsKernelBase, thread->gs_base);
+}
+
+FAST_CALL void DumpFpStateIfNeeded(Sched::Thread *thread)
+{
+    ASSERT_NOT_NULL(thread);
+
+    auto proc = SchedulingModule::Get().GetProcesses().GetProcess(thread->owner);
+    ASSERT_TRUE(static_cast<bool>(proc));
+
+    if (proc.value()->flags.PreserveFloats) {
+        u8 *mem = thread->fp_state;
+
+        __asm__ volatile("xsave64 %0" : "=m"(*mem) : "a"(0xFFFFFFFF), "d"(0xFFFFFFFF) : "memory");
+    }
+}
+
+FAST_CALL void LoadFpStateIfNeeded(Sched::Thread *thread)
+{
+    ASSERT_NOT_NULL(thread);
+
+    auto proc = SchedulingModule::Get().GetProcesses().GetProcess(thread->owner);
+    ASSERT_TRUE(static_cast<bool>(proc));
+
+    if (proc.value()->flags.PreserveFloats) {
+        u8 *mem = thread->fp_state;
+
+        __asm__ volatile("xrstor64 %0" : : "m"(*mem), "a"(0xFFFFFFFF), "d"(0xFFFFFFFF) : "memory");
+    }
+}
+
+FAST_CALL void SetTssRsp0(const u64 rsp0)
+{
+    auto core_local     = hardware::GetCoreLocalData();
+    core_local.tss.rsp0 = rsp0;
+}
+
+FAST_CALL void SetNextThreadFs(Sched::Thread *thread)
+{
+    ASSERT_NOT_NULL(thread);
+
+    cpu::SetMSR(arch::kIa32FsBase, thread->fs_base);
+}
+
+FAST_CALL void SwapGsIfJumpingToUserspace(Sched::Thread *thread)
+{
+    ASSERT_NOT_NULL(thread);
+
+    auto frame = static_cast<IsrErrorStackFrame *>(thread->kernel_stack);
+
+    if (frame->isr_stack_frame.cs != cpu::GDT::kKernelCodeSelector) {
+        SetThreadGs(thread);
+        __asm__ volatile("swapgs" ::: "memory");
+    }
+}
+
+NODISCARD FAST_CALL u64 GetRFlags()
+{
+    uint64_t flags;
+
+    __asm__ volatile(
+        "pushfq \n\t"
+        "pop %0 \n\t"
+        : "=r"(flags)
+        :
+        : "memory"
+    );
+
+    return flags;
+}
+
+FAST_CALL void SwapFsIfNeeded(Sched::Thread *current_tcb, Sched::Thread *next_tcb)
+{
+    ASSERT_NOT_NULL(current_tcb);
+    ASSERT_NOT_NULL(next_tcb);
+
+    if (current_tcb->fs_base != next_tcb->fs_base) {
+        cpu::SetMSR(arch::kIa32FsBase, next_tcb->fs_base);
+    }
+}
+
+FAST_CALL u64 GetThreadsPageTable(Sched::Thread *thread)
+{
+    ASSERT_NOT_NULL(thread);
+
+    const auto proc = SchedulingModule::Get().GetProcesses().GetProcess(thread->owner);
+    ASSERT_TRUE(static_cast<bool>(proc), "Threads exists -> owner MUST exist");
+
+    return reinterpret_cast<u64>(proc.value()->address_space->PageTableRoot());
+}
+
+FAST_CALL void SwapCr3IfNeeded(Sched::Thread *tcb)
+{
+    ASSERT_NOT_NULL(tcb);
+
+    auto cr3 = cpu::GetCR<cpu::Cr3>();
+
+    auto next_cr3 = GetThreadsPageTable(tcb);
+    if (*reinterpret_cast<u64 *>(&cr3) != next_cr3) {
+        cpu::SetCR(*reinterpret_cast<cpu::Cr3 *>(&next_cr3));
+    }
+}
+
+// ------------------------------
+// asm interfaces
+// ------------------------------
+
+extern "C" void cdecl_ConvertContextEntry(Sched::Thread *thread)
+{
+    SetNextThreadFs(thread);
+    LoadFpStateIfNeeded(thread);
+    hardware::SetCurrentTCB(thread);
+    SetTssRsp0(reinterpret_cast<u64>(thread->kernel_stack_bottom));
+    SwapGsIfJumpingToUserspace(thread);
+}
+
+extern "C" void cdecl_JumpToUserSpaceEntry(void *addr, IsrStackFrame *frame)
+{
+    auto thread          = hardware::GetCurrentTCB();
+    thread->kernel_stack = thread->kernel_stack_bottom;
+
+    frame->rip    = reinterpret_cast<u64>(addr);
+    frame->cs     = static_cast<u64>(cpu::GDT::kUserCodeSelector);
+    frame->rflags = static_cast<u64>(kInitialRFlags);
+    frame->rsp    = reinterpret_cast<u64>(thread->user_stack_bottom);
+    frame->ss     = static_cast<u64>(cpu::GDT::kUserDataSelector);
+
+    SetThreadGs(thread);
+    __asm__ volatile("swapgs" ::: "memory");
+}
+
+extern "C" void cdecl_ContextSwitchEntry(
+    Sched::Thread *thread, IsrErrorStackFrame *mem, const u64 rip
+)
+{
+    mem->error_code             = 0;
+    mem->isr_stack_frame.rip    = rip;
+    mem->isr_stack_frame.cs     = static_cast<u64>(cpu::GDT::kKernelCodeSelector);
+    mem->isr_stack_frame.rflags = GetRFlags() | 0x200;
+    mem->isr_stack_frame.rsp    = reinterpret_cast<u64>(mem) + sizeof(IsrErrorStackFrame);
+    mem->isr_stack_frame.ss     = static_cast<u64>(cpu::GDT::kKernelDataSelector);
+
+    auto current_tcb = hardware::GetCurrentTCB();
+    SwapFsIfNeeded(current_tcb, thread);
+    current_tcb->kernel_stack = reinterpret_cast<void *>(mem);
+    hardware::SetCurrentTCB(thread);
+    SetTssRsp0(reinterpret_cast<u64>(thread->kernel_stack_bottom));
+    SwapGsIfJumpingToUserspace(thread);
+    LoadFpStateIfNeeded(thread);
+    SwapCr3IfNeeded(thread);
+}
+
+extern "C" void cdecl_ContextSwitchOnInterrupt(Sched::Thread *thread, void *rsp)
+{
+    auto current_tcb          = hardware::GetCurrentTCB();
+    current_tcb->kernel_stack = rsp;
+    SwapFsIfNeeded(current_tcb, thread);
+    hardware::SetCurrentTCB(thread);
+    SetTssRsp0(reinterpret_cast<u64>(thread->kernel_stack_bottom));
+    SwapCr3IfNeeded(thread);
+}
+
+// ===========================
+
+extern "C" void cdecl_SetTssRsp0(const u64 rsp0) { SetTssRsp0(rsp0); }
+
+extern "C" void cdecl_SwapFsIfNeeded(Sched::Thread *thread)
+{
+    SwapFsIfNeeded(hardware::GetCurrentTCB(), thread);
+}
+
+extern "C" void cdecl_SetNextThreadFs(Sched::Thread *thread) { SetNextThreadFs(thread); }
+
+extern "C" void cdecl_DumpFpStateIfNeeded(Sched::Thread *thread) { DumpFpStateIfNeeded(thread); }
+
+extern "C" void cdecl_LoadFpStateIfNeeded(Sched::Thread *thread) { LoadFpStateIfNeeded(thread); }
+
+extern "C" Sched::Thread *cdecl_GetCurrentTCB() { return hardware::GetCurrentTCB(); }
+
+extern "C" void cdecl_SetCurrentTCB(Sched::Thread *tcb) { hardware::SetCurrentTCB(tcb); }
+
+extern "C" u64 cdecl_GetThreadsPageTable(Sched::Thread *thread)
+{
+    return GetThreadsPageTable(thread);
+}
diff --git a/kernel/arch/x86_64/src/scheduling/scheduling.nasm b/kernel/arch/x86_64/src/scheduling/scheduling.nasm
index 35eb7ca3..e954c602 100644
--- a/kernel/arch/x86_64/src/scheduling/scheduling.nasm
+++ b/kernel/arch/x86_64/src/scheduling/scheduling.nasm
@@ -6,15 +6,9 @@
 
 bits 64
 
-extern cdecl_GetCurrentTCB
-extern cdecl_SetCurrentTCB
-extern cdecl_GetThreadsPageTable
-extern cdecl_SetTssRsp0
-extern cdecl_EnableHardwareInterrupts
-extern cdecl_SetNextThreadFs
-extern cdecl_SwapFsIfNeeded
-extern HandleHardwareInterrupt
-extern cdecl_SetKernelGs
+extern cdecl_ConvertContextEntry
+extern cdecl_JumpToUserSpaceEntry
+extern cdecl_ContextSwitchEntry
 
 section .text
 global ContextSwitch
@@ -27,24 +21,11 @@ global JumpToUserSpace
 ; Note: Caller is responsible for ensuring proper environment before calling (disabling IRQs)
 ; Note: ASSUMPTION ConvertContext is always called inside KERNEL code
 ConvertContext:
-    mov r12, rdi                          ; Save next TCB pointer in r12 (non-volatile) to survive C++ calls
-    call cdecl_SetNextThreadFs
-
-    mov rdi, r12
-    call cdecl_SetCurrentTCB              ; Change TCB
+    mov r12, rdi
+    call cdecl_ConvertContextEntry
+.done:
     mov  rsp, [r12+Thread.kernel_stack]   ; Change the stack
 
-    mov rdi, [r12+Thread.kernel_stack_bottom]
-    call cdecl_SetTssRsp0
-
-    mov qword r13, [rsp+_cs_int_frame_offset]
-    cmp qword r13, _kernel_code_selector
-    je .done
-
-    call cdecl_SetKernelGs
-    swapgs
-
-.done:
     pop_all_regs                    ; Restore registers of NEW thread's stack
     add rsp, _all_reg_size          ; Deallocate register save space.
     add rsp, 8                      ; pop error code
@@ -57,22 +38,10 @@ ConvertContext:
 ; Note: Caller is responsible for ensuring proper environment before calling (disabling IRQs)
 ; Note: FS already should be changed during contex switch
 JumpToUserSpace:
-    sub rsp, _context_switch_stack_space
+    sub rsp, _jump_userspace_stack_space
 
-    mov [rsp + _rip_user_space_offset], rdi
-    mov qword [rsp + _cs_user_space_offset], _user_code_selector
-    mov qword [rsp + _flags_user_space_offset], _userspace_initial_flags
-
-    call cdecl_GetCurrentTCB
-    mov r12, [rax+Thread.kernel_stack_bottom]
-    mov [rax+Thread.kernel_stack], r12
-    mov r13, [rax+Thread.user_stack_bottom]
-
-    mov qword [rsp + _ss_user_space_offset], _user_data_selector
-    mov [rsp + _sp_user_space_offset], r13
-
-    call cdecl_SetKernelGs
-    swapgs
+    mov rsi, rsp
+    call cdecl_JumpToUserSpaceEntry
 
     xor rax, rax
     mov rax, _user_data_selector
@@ -95,63 +64,15 @@ ContextSwitch:
     sub rsp, _context_switch_stack_space_ext             ; Allocate space for saving registers.
     push_all_regs                      ; Save registers of calling TCB on ITS stack
 
-    ; Move RIP from call to align with Interrupt frame
-    ; RIP
-    mov r12, [rsp + _rip_call_offset]
-    mov [rsp + _rip_int_frame_offset], r12
-
-    ; CS
-    mov qword [rsp + _cs_int_frame_offset], _kernel_code_selector
-
-    ; FLAGS
-    pushfq
-    pop r12
-    or r12, 0x200 ; Ensure Interrupts are enabled after the context switch
-    mov qword [rsp + _flags_int_frame_offset], r12
-
-    ; RSP
-    mov r13, rsp
-    add r13, _context_switch_stack_space
-    mov [rsp + _sp_int_frame_offset], r13
+    mov r13, rdi ; save rdi before c++ call
+    mov rsi, rsp
+    mov rdx, [rsp + _rip_call_offset]
 
-    ; SS
-    mov qword [rsp + _ss_int_frame_offset], _kernel_data_selector
-
-    mov r12, rdi                       ; Save next TCB pointer in r12 (non-volatile) to survive C++ calls
-    call cdecl_SwapFsIfNeeded
-
-    mov rdi, r12
-    call cdecl_GetCurrentTCB           ; RAX = pointer to TCB
-    mov [rax+Thread.kernel_stack], rsp ; Save RSP for previous task's kernel stack in the thread's TCB
-
-    ; ------------------------
-    ; Setup next task state
-
-    mov rdi, r12                         ; Restore next TCB pointer to RDI for the next call
-    call cdecl_SetCurrentTCB
-    mov rsp, [r12+Thread.kernel_stack]   ; Change the stack
-
-    mov rdi, [r12+Thread.kernel_stack_bottom]
-    call cdecl_SetTssRsp0
-
-    mov rdi, r12                       ; Set RDI for GetThreadsPageTable
-    call cdecl_GetThreadsPageTable     ; RAX = next cr3
-    mov r11, cr3                       ; R11 = current cr3
-
-    cmp r11, rax                       ; Skip virtual address space change if not needed - omit tlb flushes
-    je .gs
-    mov cr3, rax                       ; Load next task's virtual address space
-
-.gs:
-
-    mov qword r13, [rsp+_cs_int_frame_offset]
-    cmp qword r13, _kernel_code_selector
-    je .done
-
-    call cdecl_SetKernelGs
-    swapgs
+    call cdecl_ContextSwitchEntry
 
 .done:
+    mov rsp, [r13+Thread.kernel_stack]   ; Change the stack
+
     pop_all_regs                    ; Restore registers of NEW thread's stack
     add rsp, _all_reg_size          ; Deallocate register save space.
     add rsp, 8                      ; pop error code
diff --git a/kernel/src/hal/api/tasks.hpp b/kernel/src/hal/api/tasks.hpp
new file mode 100644
index 00000000..7af22ac0
--- /dev/null
+++ b/kernel/src/hal/api/tasks.hpp
@@ -0,0 +1,11 @@
+#ifndef KERNEL_SRC_HAL_API_TASKS_HPP_
+#define KERNEL_SRC_HAL_API_TASKS_HPP_
+
+namespace arch
+{
+struct ThreadAPI {
+    FORCE_INLINE_F void InitMem() {}
+};
+}  // namespace arch
+
+#endif  // KERNEL_SRC_HAL_API_TASKS_HPP_
diff --git a/kernel/src/hardware/core_local.cpp b/kernel/src/hardware/core_local.cpp
deleted file mode 100644
index 96186344..00000000
--- a/kernel/src/hardware/core_local.cpp
+++ /dev/null
@@ -1,4 +0,0 @@
-#include "core_local.hpp"
-
-Sched::Thread *cdecl_GetCurrentTCB() { return hardware::GetCurrentTCB(); }
-void cdecl_SetCurrentTCB(Sched::Thread *tcb) { hardware::SetCurrentTCB(tcb); }
diff --git a/kernel/src/hardware/core_local.hpp b/kernel/src/hardware/core_local.hpp
index 3a92d179..8c8193c9 100644
--- a/kernel/src/hardware/core_local.hpp
+++ b/kernel/src/hardware/core_local.hpp
@@ -30,7 +30,4 @@ NODISCARD FAST_CALL Sched::Pid GetRunningPid() { return GetCurrentTCB()->owner;
 
 }  // namespace hardware
 
-extern "C" Sched::Thread *cdecl_GetCurrentTCB();
-extern "C" void cdecl_SetCurrentTCB(Sched::Thread *tcb);
-
 #endif  // KERNEL_SRC_HARDWARE_CORE_LOCAL_HPP_
diff --git a/kernel/src/scheduling/process.hpp b/kernel/src/scheduling/process.hpp
index 4e5b9502..28b69be4 100644
--- a/kernel/src/scheduling/process.hpp
+++ b/kernel/src/scheduling/process.hpp
@@ -21,6 +21,7 @@ struct PACK Pid {
 
 struct PACK ProcessFlags {
     bool KernelSpaceOnly : 1;
+    bool PreserveFloats : 1;
 };
 static_assert(sizeof(ProcessFlags) == 1);
 
diff --git a/kernel/src/scheduling/task_mgr.cpp b/kernel/src/scheduling/task_mgr.cpp
index 4c544cc3..8f7438c6 100644
--- a/kernel/src/scheduling/task_mgr.cpp
+++ b/kernel/src/scheduling/task_mgr.cpp
@@ -24,7 +24,10 @@ void TaskMgr::InitializeMultitasking()
     // Spawn 3 Kernel Workers
     static constexpr size_t kNumKWorkers = 3;
     for (size_t i = 0; i < kNumKWorkers; ++i) {
-        auto result = SpawnProcess(KWorkerMain, true);
+        ProcessFlags flags{};
+        flags.KernelSpaceOnly = true;
+
+        auto result = SpawnProcess(KWorkerMain, flags);
         R_ASSERT_TRUE(
             static_cast<bool>(result),
             "Failed to spawn kernel workers. Not enough resources for the system"
@@ -36,13 +39,11 @@ void TaskMgr::InitializeMultitasking()
     }
 }
 
-std::expected<std::tuple<Pid, Tid>, Error> TaskMgr::SpawnProcess(
-    void (*f)(), const bool kernel_only
-)
+std::expected<std::tuple<Pid, Tid>, Error> TaskMgr::SpawnProcess(void (*f)(), ProcessFlags flags)
 {
     bool dismiss = false;
 
-    if (kernel_only) {
+    if (flags.KernelSpaceOnly) {
         ASSERT_TRUE(IsKernelSpace(reinterpret_cast<void *>(f)));
     } else {
         ASSERT_FALSE(IsKernelSpace(reinterpret_cast<void *>(f)));
@@ -61,30 +62,32 @@ std::expected<std::tuple<Pid, Tid>, Error> TaskMgr::SpawnProcess(
             SchedulingModule::Get().GetProcesses().Free(process.value()->pid);
         ASSERT_TRUE(static_cast<bool>(result));
     });
+    process.value()->flags = flags;
 
+    Mem::AddressSpace *address_space{};
     // 2. Fill process data and resources - TODO: replace with proper one
-    if (kernel_only) {
-        process.value()->address_space         = &MemoryModule::Get().GetKernelAddressSpace();
-        process.value()->flags.KernelSpaceOnly = true;
+    if (flags.KernelSpaceOnly) {
+        address_space = &MemoryModule::Get().GetKernelAddressSpace();
     } else {
-        R_FAIL_ALWAYS("User space tasks not supported!");
-
-        TODO_WHEN_VMEM_WORKS
-        // auto addr_space = MemoryModule::Get().GetVmm().CreateAddrSpace();
-        // if (!addr_space) {
-        //     DEBUG_WARN_SCHEDULING(
-        //         "Failed to create process. Failed on AddressSpace creation: %s",
-        //         template_lib::to_string(addr_space.error()).data()
-        //     );
-        //     return std::unexpected(Error::OutOfMemory);
-        // }
-        // process.value()->address_space = addr_space.value();
-        // template_lib::BatchedScopeGuard addr_space_guard(dismiss, [&]() {
-        //     [[maybe_unused]] const auto result =
-        //         MemoryModule::Get().GetVmm().DestroyAddrSpace(addr_space.value());
-        //     ASSERT_TRUE(static_cast<bool>(result));
-        // });
+        auto as = MemoryModule::Get().GetVmm().CreateUserAddrSpace();
+        if (!as) {
+            DEBUG_WARN_SCHEDULING(
+                "Failed to create process. Failed on AddressSpace creation: %s",
+                to_string(as.error())
+            );
+            return std::unexpected(Error::OutOfMemory);
+        }
+        address_space = as.value();
     }
+    process.value()->address_space = address_space;
+
+    template_lib::BatchedScopeGuard addr_space_guard(dismiss, [&]() {
+        if (!flags.KernelSpaceOnly) {
+            [[maybe_unused]] const auto result =
+                MemoryModule::Get().GetVmm().DestroyUserAddrSpace(address_space);
+            ASSERT_TRUE(static_cast<bool>(result));
+        }
+    });
 
     // 3. Spawn first thread
     const auto thread = SpawnThread(process.value()->pid, f);
@@ -152,7 +155,8 @@ std::expected<Thread *, Error> TaskMgr::SpawnThread(const Pid pid, void (*f)())
 
     // 2.2 Thread Stack
     if (!process.value()->flags.KernelSpaceOnly) {
-        const auto thread_stack = Mem::KMallocAligned({kStackSize, kStackAlignment});
+        const auto thread_stack =
+            MemoryModule::Get().GetVmm().AllocUserStack(process.value()->address_space, kStackSize);
         if (!thread_stack) {
             DEBUG_WARN_SCHEDULING(
                 "Failed to create thread for %llu. Failed on thread stack allocation: %s", pid,
diff --git a/kernel/src/scheduling/task_mgr.hpp b/kernel/src/scheduling/task_mgr.hpp
index a921e241..8753e26c 100644
--- a/kernel/src/scheduling/task_mgr.hpp
+++ b/kernel/src/scheduling/task_mgr.hpp
@@ -25,7 +25,7 @@ class TaskMgr
     void InitializeMultitasking();
 
     NODISCARD std::expected<std::tuple<Pid, Tid>, Error> SpawnProcess(
-        void (*f)(), bool kernel_only
+        void (*f)(), ProcessFlags flags
     );
 
     NODISCARD std::expected<Thread *, Error> SpawnThread(Pid pid, void (*f)());
diff --git a/kernel/src/scheduling/threads.cpp b/kernel/src/scheduling/threads.cpp
index 0469e662..bb41e8ca 100644
--- a/kernel/src/scheduling/threads.cpp
+++ b/kernel/src/scheduling/threads.cpp
@@ -16,6 +16,7 @@ std::expected<Thread *, Error> Threads::PrepareThread()
     }
 
     Thread *thread = threads_.Get(idx);
+    thread->InitMem();
 
     ASSERT_LE(idx, std::numeric_limits<u16>::max());
     thread->tid = AssignNewTid(static_cast<u16>(idx));
@@ -43,13 +44,3 @@ void OnKThreadExit()
 }
 
 }  // namespace Sched
-
-void *cdecl_GetThreadsPageTable(Sched::Thread *thread)
-{
-    ASSERT_NOT_NULL(thread);
-
-    const auto proc = SchedulingModule::Get().GetProcesses().GetProcess(thread->owner);
-    ASSERT_TRUE(static_cast<bool>(proc), "Threads exists -> owner MUST exist");
-
-    return proc.value()->address_space->PageTableRoot();
-}
diff --git a/kernel/src/scheduling/threads.hpp b/kernel/src/scheduling/threads.hpp
index d549c34b..788cf3c9 100644
--- a/kernel/src/scheduling/threads.hpp
+++ b/kernel/src/scheduling/threads.hpp
@@ -81,6 +81,4 @@ void OnKThreadExit();
 
 }  // namespace Sched
 
-extern "C" void *cdecl_GetThreadsPageTable(Sched::Thread *thread);
-
 #endif  // KERNEL_SRC_SCHEDULING_THREADS_HPP_
diff --git a/kernel/test/manual_tests.cpp b/kernel/test/manual_tests.cpp
index a804ae43..fea73157 100644
--- a/kernel/test/manual_tests.cpp
+++ b/kernel/test/manual_tests.cpp
@@ -56,9 +56,13 @@ static void Task1()
 
 MTEST(KernelTaskSwitchTest)
 {
-    auto p0 = SchedulingModule::Get().GetTaskMgr().SpawnProcess(Task0, true);
+    Sched::ProcessFlags flags{};
+    flags.KernelSpaceOnly = true;
+    flags.PreserveFloats  = true;
+
+    auto p0 = SchedulingModule::Get().GetTaskMgr().SpawnProcess(Task0, flags);
     ASSERT_TRUE(static_cast<bool>(p0));
-    auto p1 = SchedulingModule::Get().GetTaskMgr().SpawnProcess(Task1, true);
+    auto p1 = SchedulingModule::Get().GetTaskMgr().SpawnProcess(Task1, flags);
     ASSERT_TRUE(static_cast<bool>(p1));
 
     const auto tid0 = std::get<1>(p0.value());
diff --git a/libs/libcontainers/include/data_structures/hash_maps.hpp b/libs/libcontainers/include/data_structures/hash_maps.hpp
index 81dabfb9..24c3caf7 100644
--- a/libs/libcontainers/include/data_structures/hash_maps.hpp
+++ b/libs/libcontainers/include/data_structures/hash_maps.hpp
@@ -397,7 +397,7 @@ class PooledHashMap
 
         const size_t idx = pool_.Pop();
 
-        auto mem = Mem::KMalloc(sizeof(T));
+        auto mem = Mem::KMallocAligned({.size = sizeof(T), .alignment = alignof(T)});
         R_ASSERT_TRUE(static_cast<bool>(mem));
         map_[idx] = static_cast<T *>(mem.value());
 
@@ -409,7 +409,7 @@ class PooledHashMap
         ASSERT_LT(idx, kSize);
         ASSERT_NOT_NULL(Get(idx));
 
-        Mem::KFree(Get(idx));
+        Mem::KFreeAligned(Get(idx));
         map_[idx] = nullptr;
 
         pool_.Push(static_cast<Idx_t>(idx));

From cfaff52ab56022ef8030072b98de8c72c50371ff Mon Sep 17 00:00:00 2001
From: Jakub Lisowski <115403674+Jlisowskyy@users.noreply.github.com>
Date: Tue, 30 Dec 2025 18:03:35 +0100
Subject: [PATCH 36/56] Jlisowskyy/trace process (#259)

Things done in this PR:
- cleaned up task_mgr functions
- added first working process - trace dumper
---
 .../arch/x86_64/src/drivers/apic/io_apic.cpp  |   1 +
 .../arch/x86_64/src/scheduling/scheduling.cpp |   8 +-
 kernel/src/cores.cpp                          |   5 +
 kernel/src/hal/panic.hpp                      |   7 +
 kernel/src/hardware/core_controller.hpp       |   2 +
 kernel/src/kernel.cpp                         |  26 --
 kernel/src/scheduling/error.hpp               |   3 +
 kernel/src/scheduling/kworker.cpp             |  16 +-
 kernel/src/scheduling/kworker.hpp             |   1 +
 kernel/src/scheduling/process.hpp             |   3 +
 kernel/src/scheduling/scheduler.cpp           |   5 -
 kernel/src/scheduling/task_mgr.cpp            | 140 +++++++---
 kernel/src/scheduling/task_mgr.hpp            |  22 +-
 kernel/src/trace.cpp                          | 243 ++++++++----------
 kernel/src/trace_framework.hpp                |  13 +-
 kernel/test/manual_tests.cpp                  |   6 +-
 kernel/test/test_module.cpp                   |  16 +-
 17 files changed, 280 insertions(+), 237 deletions(-)

diff --git a/kernel/arch/x86_64/src/drivers/apic/io_apic.cpp b/kernel/arch/x86_64/src/drivers/apic/io_apic.cpp
index 6cd9434e..3141b9d5 100644
--- a/kernel/arch/x86_64/src/drivers/apic/io_apic.cpp
+++ b/kernel/arch/x86_64/src/drivers/apic/io_apic.cpp
@@ -83,6 +83,7 @@ void IoApic::PrepareDefaultConfig() const
         }
 
         WriteLowerTableRegister(idx, reg_low);
+        WriteHigherTableRegister(idx, reg_high);
     }
 }
 
diff --git a/kernel/arch/x86_64/src/scheduling/scheduling.cpp b/kernel/arch/x86_64/src/scheduling/scheduling.cpp
index b45a6715..099ead01 100644
--- a/kernel/arch/x86_64/src/scheduling/scheduling.cpp
+++ b/kernel/arch/x86_64/src/scheduling/scheduling.cpp
@@ -47,11 +47,7 @@ FAST_CALL void LoadFpStateIfNeeded(Sched::Thread *thread)
     }
 }
 
-FAST_CALL void SetTssRsp0(const u64 rsp0)
-{
-    auto core_local     = hardware::GetCoreLocalData();
-    core_local.tss.rsp0 = rsp0;
-}
+FAST_CALL void SetTssRsp0(const u64 rsp0) { hardware::GetCoreLocalData().tss.rsp0 = rsp0; }
 
 FAST_CALL void SetNextThreadFs(Sched::Thread *thread)
 {
@@ -154,7 +150,7 @@ extern "C" void cdecl_ContextSwitchEntry(
     mem->error_code             = 0;
     mem->isr_stack_frame.rip    = rip;
     mem->isr_stack_frame.cs     = static_cast<u64>(cpu::GDT::kKernelCodeSelector);
-    mem->isr_stack_frame.rflags = GetRFlags() | 0x200;
+    mem->isr_stack_frame.rflags = GetRFlags();
     mem->isr_stack_frame.rsp    = reinterpret_cast<u64>(mem) + sizeof(IsrErrorStackFrame);
     mem->isr_stack_frame.ss     = static_cast<u64>(cpu::GDT::kKernelDataSelector);
 
diff --git a/kernel/src/cores.cpp b/kernel/src/cores.cpp
index 7cc34765..c8645e02 100644
--- a/kernel/src/cores.cpp
+++ b/kernel/src/cores.cpp
@@ -62,3 +62,8 @@ void hardware::CoresController::BootUpAllCores()
 
     DEBUG_INFO_INTERRUPTS("Finished booting up all cores...");
 }
+
+void hardware::CoresController::PanicAllCores()
+{
+    TRACE_INFO_HARDWARE("Invoking panic on all cores...");
+}
diff --git a/kernel/src/hal/panic.hpp b/kernel/src/hal/panic.hpp
index 7152180b..f515e102 100644
--- a/kernel/src/hal/panic.hpp
+++ b/kernel/src/hal/panic.hpp
@@ -2,6 +2,7 @@
 #define KERNEL_SRC_HAL_PANIC_HPP_
 
 #include <hal/impl/panic.hpp>
+#include "modules/hardware.hpp"
 #include "trace_framework.hpp"
 
 #include <stdio.h>
@@ -17,6 +18,9 @@ namespace hal
  */
 WRAP_CALL void KernelPanic(const char *msg)
 {
+    HardwareModule::Get().GetInterrupts().BlockHardwareInterrupts();
+    HardwareModule::Get().GetCoresController().PanicAllCores();
+
     TRACE_FATAL_GENERAL("[ KERNEL PANIC ]");
     TRACE_FATAL_GENERAL(msg);
     TRACE_FATAL_GENERAL("\n");
@@ -27,6 +31,9 @@ WRAP_CALL void KernelPanic(const char *msg)
 template <typename... Args>
 FAST_CALL NO_RET void KernelPanicFormat(const char *fmt, Args... args)
 {
+    HardwareModule::Get().GetInterrupts().BlockHardwareInterrupts();
+    HardwareModule::Get().GetCoresController().PanicAllCores();
+
     TRACE_FATAL_GENERAL("[ KERNEL PANIC ]");
     TRACE_FATAL_GENERAL(fmt, args...);
     arch::KernelPanic();
diff --git a/kernel/src/hardware/core_controller.hpp b/kernel/src/hardware/core_controller.hpp
index c4b42748..5d6b79da 100644
--- a/kernel/src/hardware/core_controller.hpp
+++ b/kernel/src/hardware/core_controller.hpp
@@ -29,6 +29,8 @@ class CoresController final : public hal::CoreController
 
     void BootUpAllCores();
 
+    void PanicAllCores();
+
     void AllocateTables(size_t num_cores, size_t max_hw_id);
 
     Core &AllocateCore(const CoreConfig &config);
diff --git a/kernel/src/kernel.cpp b/kernel/src/kernel.cpp
index 51afe0f0..c8a23ccc 100644
--- a/kernel/src/kernel.cpp
+++ b/kernel/src/kernel.cpp
@@ -26,33 +26,7 @@ extern void KernelInit(const hal::RawBootArguments &);
 static void KernelRun()
 {
     TRACE_INFO_GENERAL("Hello from AlkOS!");
-    trace::Flush();
-
     SchedulingModule::Get().GetScheduler().ConvertToScheduling();
-
-    // auto &video = VideoModule::Get();
-    // Graphics::Painter painter(video.GetScreen(), video.GetFormat());
-    // Graphics::Psf2Font font(drdos8x8_psfu);
-    //
-    // if (!font.IsValid()) {
-    //     TRACE_WARN_VIDEO("Invalid font");
-    // }
-    //
-    // System::GraphicsConsole console(painter, font);
-    // System::Shell shell(console, HardwareModule::Get().GetPs2Keyboard());
-    //
-    // shell.Init();
-    // video.Flush();
-    //
-    // while (true) {
-    //     shell.Update();
-    //     video.Flush();
-    //
-    //     // TODO: Replace with CpuHalt or smth like scheduler sleep.
-    //     for (volatile i32 i = 0; i < 10000; ++i) {
-    //     }
-    //     trace::Flush();
-    // }
 }
 
 extern "C" void KernelMain(const Mem::PPtr<hal::RawBootArguments> raw_args)
diff --git a/kernel/src/scheduling/error.hpp b/kernel/src/scheduling/error.hpp
index 3293c847..e6b43dfd 100644
--- a/kernel/src/scheduling/error.hpp
+++ b/kernel/src/scheduling/error.hpp
@@ -11,6 +11,7 @@ enum class Error {
     ExceededMaxAllowedInstances,
     ProcessNotFound,
     ThreadNotFound,
+    ProcessNameTooLong,
 };
 
 }  // namespace Sched
@@ -26,6 +27,8 @@ static constexpr const char *to_string(const Sched::Error &error)
             return "ProcessNotFound";
         case Sched::Error::ThreadNotFound:
             return "ThreadNotFound";
+        case Sched::Error::ProcessNameTooLong:
+            return "ProcessNameTooLong";
     }
 
     return "unknown error";
diff --git a/kernel/src/scheduling/kworker.cpp b/kernel/src/scheduling/kworker.cpp
index 2cebe2fc..a4c021e7 100644
--- a/kernel/src/scheduling/kworker.cpp
+++ b/kernel/src/scheduling/kworker.cpp
@@ -1,13 +1,13 @@
 #include "kworker.hpp"
 #include "hal/debug.hpp"
+#include "modules/hardware.hpp"
+#include "modules/scheduling.hpp"
 #include "trace_framework.hpp"
 
 void Sched::KWorkerMain()
 {
     TRACE_INFO_SCHEDULING("Created new KWorker!");
     while (true) {
-        trace::Flush();
-
         static size_t kSpins = 1'000'000;
         for (size_t i = 0; i < kSpins; i++) {
             hal::Noop();
@@ -17,3 +17,15 @@ void Sched::KWorkerMain()
         }
     }
 }
+
+void Sched::TraceDumperMain()
+{
+    TRACE_INFO_SCHEDULING("Created new TraceDumper!");
+    while (true) {
+        trace::TraceDumperTask();
+
+        HardwareModule::Get().GetInterrupts().BlockHardwareInterrupts();
+        SchedulingModule::Get().GetScheduler().Yield();
+        HardwareModule::Get().GetInterrupts().EnableHardwareInterrupts();
+    }
+}
diff --git a/kernel/src/scheduling/kworker.hpp b/kernel/src/scheduling/kworker.hpp
index 6f300ac0..31abc3ac 100644
--- a/kernel/src/scheduling/kworker.hpp
+++ b/kernel/src/scheduling/kworker.hpp
@@ -4,6 +4,7 @@
 namespace Sched
 {
 void KWorkerMain();
+void TraceDumperMain();
 }  // namespace Sched
 
 #endif  // KERNEL_SRC_SCHEDULING_KWORKER_HPP_
diff --git a/kernel/src/scheduling/process.hpp b/kernel/src/scheduling/process.hpp
index 28b69be4..8b7e4ccc 100644
--- a/kernel/src/scheduling/process.hpp
+++ b/kernel/src/scheduling/process.hpp
@@ -26,7 +26,10 @@ struct PACK ProcessFlags {
 static_assert(sizeof(ProcessFlags) == 1);
 
 struct Process : hal::Process {
+    static constexpr size_t kMaxNameLength = 128;
+
     /* Management */
+    char name[kMaxNameLength];
     Pid pid;
     ProcessFlags flags;
 
diff --git a/kernel/src/scheduling/scheduler.cpp b/kernel/src/scheduling/scheduler.cpp
index 72620869..3165109d 100644
--- a/kernel/src/scheduling/scheduler.cpp
+++ b/kernel/src/scheduling/scheduler.cpp
@@ -10,8 +10,6 @@ namespace Sched
 {
 void Scheduler::AddReadyThread(Thread *thread)
 {
-    HardwareModule::Get().GetInterrupts().BlockHardwareInterrupts();
-
     if (threads_ == nullptr) {
         threads_     = thread;
         thread->next = thread;
@@ -21,8 +19,6 @@ void Scheduler::AddReadyThread(Thread *thread)
     thread->next   = threads_->next;
     threads_->next = thread;
     threads_       = thread;
-
-    HardwareModule::Get().GetInterrupts().EnableHardwareInterrupts();
 }
 
 Thread *Scheduler::Schedule()
@@ -47,7 +43,6 @@ Thread *Scheduler::Schedule()
 }
 void Scheduler::Yield()
 {
-    HardwareModule::Get().GetInterrupts().BlockHardwareInterrupts();
     auto thread = Schedule();
 
     if (thread != nullptr) {
diff --git a/kernel/src/scheduling/task_mgr.cpp b/kernel/src/scheduling/task_mgr.cpp
index 8f7438c6..0a37050d 100644
--- a/kernel/src/scheduling/task_mgr.cpp
+++ b/kernel/src/scheduling/task_mgr.cpp
@@ -24,10 +24,10 @@ void TaskMgr::InitializeMultitasking()
     // Spawn 3 Kernel Workers
     static constexpr size_t kNumKWorkers = 3;
     for (size_t i = 0; i < kNumKWorkers; ++i) {
-        ProcessFlags flags{};
-        flags.KernelSpaceOnly = true;
+        char name[] = "kworker-0";
 
-        auto result = SpawnProcess(KWorkerMain, flags);
+        name[sizeof(name) - 2] = static_cast<char>('0' + i);
+        auto result            = SpawnKernelProcess(name, {}, KWorkerMain);
         R_ASSERT_TRUE(
             static_cast<bool>(result),
             "Failed to spawn kernel workers. Not enough resources for the system"
@@ -37,16 +37,16 @@ void TaskMgr::InitializeMultitasking()
             "Created initial Kernel Worker process with Pid: %llu", result.value().get<0>()
         );
     }
+
+    // Spawn trace dumper
+    const auto result = SpawnKernelProcess("kworker-trace-dumper", {}, TraceDumperMain);
+    R_ASSERT_TRUE(static_cast<bool>(result), "Failed to spawn trace dumper process...");
 }
 
-std::expected<std::tuple<Pid, Tid>, Error> TaskMgr::SpawnProcess(void (*f)(), ProcessFlags flags)
+std::expected<Pid, Error> TaskMgr::SpawnEmptyProcess(const char *name, const ProcessFlags flags)
 {
-    bool dismiss = false;
-
-    if (flags.KernelSpaceOnly) {
-        ASSERT_TRUE(IsKernelSpace(reinterpret_cast<void *>(f)));
-    } else {
-        ASSERT_FALSE(IsKernelSpace(reinterpret_cast<void *>(f)));
+    if (strnlen(name, Process::kMaxNameLength) == Process::kMaxNameLength) {
+        return std::unexpected(Error::ProcessNameTooLong);
     }
 
     // 1. Prepare internal structure for the process
@@ -57,15 +57,18 @@ std::expected<std::tuple<Pid, Tid>, Error> TaskMgr::SpawnProcess(void (*f)(), Pr
         );
         return std::unexpected(process.error());
     }
-    template_lib::BatchedScopeGuard process_guard(dismiss, [&]() {
+    template_lib::ScopeGuard process_guard([&] {
         [[maybe_unused]] const auto result =
             SchedulingModule::Get().GetProcesses().Free(process.value()->pid);
         ASSERT_TRUE(static_cast<bool>(result));
     });
+
+    // 1.1 Fill process properties
     process.value()->flags = flags;
+    strcpy(process.value()->name, name);
 
+    // 2. Prepare address space
     Mem::AddressSpace *address_space{};
-    // 2. Fill process data and resources - TODO: replace with proper one
     if (flags.KernelSpaceOnly) {
         address_space = &MemoryModule::Get().GetKernelAddressSpace();
     } else {
@@ -79,36 +82,11 @@ std::expected<std::tuple<Pid, Tid>, Error> TaskMgr::SpawnProcess(void (*f)(), Pr
         }
         address_space = as.value();
     }
-    process.value()->address_space = address_space;
-
-    template_lib::BatchedScopeGuard addr_space_guard(dismiss, [&]() {
-        if (!flags.KernelSpaceOnly) {
-            [[maybe_unused]] const auto result =
-                MemoryModule::Get().GetVmm().DestroyUserAddrSpace(address_space);
-            ASSERT_TRUE(static_cast<bool>(result));
-        }
-    });
-
-    // 3. Spawn first thread
-    const auto thread = SpawnThread(process.value()->pid, f);
-    if (!thread) {
-        DEBUG_WARN_SCHEDULING(
-            "Failed to create process. Failed on initial thread creation: %s",
-            to_string(thread.error())
-        );
-        return std::unexpected(thread.error());
-    }
 
-    // 4. Add to scheduler
-    SchedulingModule::Get().GetScheduler().AddReadyThread(thread.value());
-
-    DEBUG_INFO_SCHEDULING(
-        "Created process with pid: %llu, and initial thread with tid: %llu", process.value()->pid,
-        thread.value()->tid
-    );
+    process.value()->address_space = address_space;
+    process_guard.dismiss();
 
-    dismiss = true;
-    return std::make_tuple(process.value()->pid, thread.value()->tid);
+    return process.value()->pid;
 }
 
 std::expected<Thread *, Error> TaskMgr::SpawnThread(const Pid pid, void (*f)())
@@ -118,6 +96,12 @@ std::expected<Thread *, Error> TaskMgr::SpawnThread(const Pid pid, void (*f)())
     const auto process = SchedulingModule::Get().GetProcesses().GetProcess(pid);
     ASSERT_TRUE(static_cast<bool>(process));
 
+    if (process.value()->flags.KernelSpaceOnly) {
+        ASSERT_TRUE(IsKernelSpace(reinterpret_cast<void *>(f)));
+    } else {
+        ASSERT_FALSE(IsKernelSpace(reinterpret_cast<void *>(f)));
+    }
+
     // 1. Prepare internal structure for execution unit - thread:
     auto thread = SchedulingModule::Get().GetThreads().PrepareThread();
     if (!thread) {
@@ -128,7 +112,7 @@ std::expected<Thread *, Error> TaskMgr::SpawnThread(const Pid pid, void (*f)())
 
         return std::unexpected(thread.error());
     }
-    template_lib::BatchedScopeGuard thread_guard(dismiss, [&]() {
+    template_lib::BatchedScopeGuard thread_guard(dismiss, [&] {
         [[maybe_unused]] const auto result =
             SchedulingModule::Get().GetThreads().Free(thread.value()->tid);
         ASSERT_TRUE(static_cast<bool>(result));
@@ -147,7 +131,7 @@ std::expected<Thread *, Error> TaskMgr::SpawnThread(const Pid pid, void (*f)())
 
         return std::unexpected(Error::OutOfMemory);
     }
-    template_lib::BatchedScopeGuard esp0_guard(dismiss, [&]() {
+    template_lib::BatchedScopeGuard esp0_guard(dismiss, [&] {
         Mem::KFreeAligned(kernel_stack.value());
     });
     thread.value()->kernel_stack        = kernel_stack.value();
@@ -181,4 +165,76 @@ std::expected<Thread *, Error> TaskMgr::SpawnThread(const Pid pid, void (*f)())
     dismiss = true;
     return thread.value();
 }
+
+std::expected<std::tuple<Pid, Tid>, Error> TaskMgr::SpawnKernelProcess(
+    const char *name, ProcessFlags flags, void (*f)()
+)
+{
+    flags.KernelSpaceOnly = true;
+    ASSERT_TRUE(IsKernelSpace(reinterpret_cast<void *>(f)));
+
+    auto process = SpawnEmptyProcess(name, flags);
+    if (!process) {
+        return std::unexpected(process.error());
+    }
+
+    template_lib::ScopeGuard process_guard([&] {
+        const auto result = SchedulingModule::Get().GetProcesses().Free(process.value());
+        ASSERT_TRUE(static_cast<bool>(result));
+    });
+
+    const auto thread = SpawnThread(process.value(), f);
+    if (!thread) {
+        return std::unexpected(thread.error());
+    }
+
+    HardwareModule::Get().GetInterrupts().BlockHardwareInterrupts();
+    SchedulingModule::Get().GetScheduler().AddReadyThread(thread.value());
+    HardwareModule::Get().GetInterrupts().EnableHardwareInterrupts();
+
+    DEBUG_INFO_SCHEDULING(
+        "Created kernel process with pid: %llu, name: %s and initial thread with tid: %llu",
+        process.value(), name, thread.value()->tid
+    );
+
+    process_guard.dismiss();
+    return std::make_tuple(process.value(), thread.value()->tid);
+}
+
+std::expected<Pid, Error> TaskMgr::CloneProcess(Pid) { R_FAIL_ALWAYS("NOT IMPLEMENTED"); }
+
+std::expected<Tid, Error> TaskMgr::ExecuteElf64(Pid, const char *)
+{
+    R_FAIL_ALWAYS("NOT IMPLEMENTED");
+}
+
+std::expected<std::tuple<Pid, Tid>, Error> TaskMgr::ExecuteElf64(
+    const char *path, const ProcessFlags flags
+)
+{
+    auto process = SpawnEmptyProcess(path, flags);
+    if (!process) {
+        return std::unexpected(process.error());
+    }
+
+    template_lib::ScopeGuard process_guard([&] {
+        const auto result = SchedulingModule::Get().GetProcesses().Free(process.value());
+        ASSERT_TRUE(static_cast<bool>(result));
+    });
+
+    auto thread = ExecuteElf64(process.value(), path);
+    if (!thread) {
+        return std::unexpected(thread.error());
+    }
+
+    process_guard.dismiss();
+    return std::make_tuple(process.value(), thread.value());
+}
+
+std::expected<void, Error> TaskMgr::KillProcess(Pid pid) { R_FAIL_ALWAYS("NOT IMPLEMENTED"); }
+
+std::expected<void, Error> TaskMgr::ExitProcess(Pid pid) { R_FAIL_ALWAYS("NOT IMPLEMENTED"); }
+
+std::expected<void, Error> TaskMgr::ExitThread(Tid tid) { R_FAIL_ALWAYS("NOT IMPLEMENTED"); }
+
 }  // namespace Sched
diff --git a/kernel/src/scheduling/task_mgr.hpp b/kernel/src/scheduling/task_mgr.hpp
index 8753e26c..bb592ad9 100644
--- a/kernel/src/scheduling/task_mgr.hpp
+++ b/kernel/src/scheduling/task_mgr.hpp
@@ -24,12 +24,28 @@ class TaskMgr
 
     void InitializeMultitasking();
 
-    NODISCARD std::expected<std::tuple<Pid, Tid>, Error> SpawnProcess(
-        void (*f)(), ProcessFlags flags
-    );
+    NODISCARD std::expected<Pid, Error> SpawnEmptyProcess(const char *name, ProcessFlags flags);
 
     NODISCARD std::expected<Thread *, Error> SpawnThread(Pid pid, void (*f)());
 
+    NODISCARD std::expected<std::tuple<Pid, Tid>, Error> SpawnKernelProcess(
+        const char *name, ProcessFlags flags, void (*f)()
+    );
+
+    NODISCARD std::expected<Pid, Error> CloneProcess(Pid pid);
+
+    NODISCARD std::expected<Tid, Error> ExecuteElf64(Pid pid, const char *path);
+
+    NODISCARD std::expected<std::tuple<Pid, Tid>, Error> ExecuteElf64(
+        const char *path, ProcessFlags flags
+    );
+
+    NODISCARD std::expected<void, Error> KillProcess(Pid pid);
+
+    NODISCARD std::expected<void, Error> ExitProcess(Pid pid);
+
+    NODISCARD std::expected<void, Error> ExitThread(Tid tid);
+
     // ------------------------------
     // Private methods
     // ------------------------------
diff --git a/kernel/src/trace.cpp b/kernel/src/trace.cpp
index 46a137ea..a0154e97 100644
--- a/kernel/src/trace.cpp
+++ b/kernel/src/trace.cpp
@@ -57,8 +57,7 @@ static struct TraceFramework {
     // ------------------------------
 
     struct SmallTraceCyclicBuffer {
-        static constexpr size_t kSize      = 65536;
-        static constexpr size_t kDumpSize  = kSize - (kSize / 16);
+        static constexpr size_t kSize      = FeatureValue<FeatureFlag::kTraceBufferSize>;
         static constexpr size_t kBatchSize = 256;
 
         hal::Atomic32 bytes_left{.value = kSize};
@@ -67,7 +66,7 @@ static struct TraceFramework {
         char buffer[kSize]{};
     };
 
-    struct MultithreadTraceCyclicBuffer {
+    struct MultiCoreTraceCyclicBuffer {
         static constexpr size_t kSize = FeatureValue<FeatureFlag::kTraceBufferSize>;
 
         hal::Atomic32 bytes_left{.value = kSize};
@@ -99,74 +98,113 @@ static struct TraceFramework {
         ASSERT_LT(stage, TracingStage::kLast);
 
         switch (stage) {
-            case TracingStage::kSingleThreadEnv:
-                AdvanceToSingleThreadInterruptsStage();
-                stage = TracingStage::kSingleThreadInterruptsEnv;
+            case TracingStage::kSingleCoreEnv:
+                AdvanceToSingleCoreInterruptsStage();
+                stage = TracingStage::kSingleCoreInterruptsEnv;
                 break;
 
-            case TracingStage::kSingleThreadInterruptsEnv:
-                AdvanceToMultiThreadStage();
-                stage = TracingStage::kMultiThreadEnv;
+            case TracingStage::kSingleCoreInterruptsEnv:
+                AdvanceToMultiCoreStage();
+                stage = TracingStage::kMultiCoreEnv;
                 break;
 
-            case TracingStage::kMultiThreadEnv:
+            case TracingStage::kMultiCoreEnv:
             case TracingStage::kLast:
-                R_FAIL_ALWAYS("Cannot advance tracing stage beyond multi thread env...");
+                R_FAIL_ALWAYS("Cannot advance tracing stage beyond multi core env...");
         }
     }
 
-    FORCE_INLINE_F void AdvanceToSingleThreadInterruptsStage()
+    FORCE_INLINE_F void AdvanceToSingleCoreInterruptsStage()
     {
         /* Should be executed before interrupts are enabled */
 
-        DEBUG_INFO_GENERAL("Updating tracing stage to stage 1 (Single thread with interrupts)");
-        stage_callbacks.get_workspace_cb = &TraceFramework::GetWorkspaceSingleThreadInterrupts;
-        stage_callbacks.commit_to_log_cb = &TraceFramework::CommitToLogSingleThreadInterrupts;
+        DEBUG_INFO_GENERAL("Updating tracing stage to stage 1 (Single Core with interrupts)");
+        stage_callbacks.get_workspace_cb = &TraceFramework::GetWorkspaceSingleCoreInterrupts;
+        stage_callbacks.commit_to_log_cb = &TraceFramework::CommitToLogSingleCoreInterrupts;
         stage_callbacks.commit_to_debug_log_cb =
-            &TraceFramework::CommitToDebugLogSingleThreadInterrupts;
-        stage_callbacks.dump_all = &TraceFramework::DumpAllSingleThreadInterrupts;
+            &TraceFramework::CommitToDebugLogSingleCoreInterrupts;
+        stage_callbacks.dump_all = &TraceFramework::DumpAllSingleCoreInterrupts;
     }
 
-    FORCE_INLINE_F void AdvanceToMultiThreadStage()
+    FORCE_INLINE_F void AdvanceToMultiCoreStage()
     {
         /* Should be executed before another cores are enabled!!! */
 
-        DEBUG_INFO_GENERAL("Updating tracing stage to stage 2 (Multithreaded environment)");
+        DEBUG_INFO_GENERAL("Updating tracing stage to stage 2 (Multicore environment)");
         HardwareModule::Get().GetInterrupts().BlockHardwareInterrupts();
 
-        stage_callbacks.get_workspace_cb       = &TraceFramework::GetWorkspaceMultithreaded;
-        stage_callbacks.commit_to_log_cb       = &TraceFramework::CommitToLogMultithreaded;
-        stage_callbacks.commit_to_debug_log_cb = &TraceFramework::CommitToDebugLogMultithreaded;
-        stage_callbacks.dump_all               = &TraceFramework::DumpAllMultithreaded;
+        stage_callbacks.get_workspace_cb       = &TraceFramework::GetWorkspaceMultiCore;
+        stage_callbacks.commit_to_log_cb       = &TraceFramework::CommitToLogMultiCore;
+        stage_callbacks.commit_to_debug_log_cb = &TraceFramework::CommitToDebugLogMultiCore;
+        stage_callbacks.dump_all               = &TraceFramework::DumpAllMultiCore;
 
         HardwareModule::Get().GetInterrupts().EnableHardwareInterrupts();
     }
 
     // --------------------------------------
-    // Single thread env implementation
+    // Single Core env implementation
     // --------------------------------------
 
-    char *GetWorkspaceSingleThread() { return single_thread_env.main_execution_workspace; }
+    FAST_CALL void CommitToLogPtrSingleCore(
+        SmallTraceCyclicBuffer &buffer, const size_t trace_size, const char *src
+    )
+    {
+        // 1. Allocate space for the trace
+        if (hal::AtomicSub(&buffer.bytes_left, static_cast<i32>(trace_size)) < 0) {
+            hal::AtomicAdd(&buffer.bytes_left, static_cast<i32>(trace_size));
+
+            /* No space for trace coming from this interrupt, we are dropping it */
+            return;
+        }
+
+        // 2. Adjust head ptr
+        i32 old_head;
+        i32 new_head;
+        do {
+            old_head = hal::AtomicLoad(&buffer.head);
+            new_head = (old_head + static_cast<i32>(trace_size)) %
+                       static_cast<i32>(SmallTraceCyclicBuffer::kSize);
+        } while (hal::AtomicCompareExchange(&buffer.head, old_head, new_head) != old_head);
+
+        // 3. Write the message
+        if (new_head < old_head) {
+            // We cross the boundary
 
-    void CommitToLogSingleThread(const size_t)
+            const i32 first_part  = static_cast<i32>(SmallTraceCyclicBuffer::kSize) - old_head;
+            const i32 second_part = static_cast<i32>(trace_size) - first_part;
+            memcpy(buffer.buffer + old_head, src, first_part);
+            memcpy(buffer.buffer, src + first_part, second_part);
+        } else {
+            memcpy(buffer.buffer + old_head, src, static_cast<i32>(trace_size));
+        }
+    }
+
+    char *GetWorkspaceSingleCore() { return single_core_env.main_execution_workspace; }
+
+    void CommitToLogSingleCore(const size_t size)
     {
-        /* Bypass kernel log as we are only writers and we do not care bout perf here */
-        HardenFullString(single_thread_env.main_execution_workspace);
+        CommitToLogPtrSingleCore(trace_log, size, GetWorkspaceSingleCore());
     }
 
-    void CommitToDebugLogSingleThread(const size_t)
+    void CommitToDebugLogSingleCore(const size_t size)
     {
-        hal::DebugTerminalWrite(single_thread_env.main_execution_workspace);
+        CommitToLogPtrSingleCore(trace_debug_log, size, GetWorkspaceSingleCore());
     }
 
-    void DumpAllSingleThread() { /* No need to dump */ }
+    void DumpAllSingleCore()
+    {
+        /* There is possibility to write out garbage at this stage but everything important is in
+         * place */
+        DumpBufferSingleCore<false>(trace_log);
+        DumpBufferSingleCore<true>(trace_debug_log);
+    }
 
     // -------------------------------------------------
-    // Single thread interrupts env implementation
+    // Single core interrupts env implementation
     // -------------------------------------------------
 
     template <bool kIsDebug>
-    FAST_CALL void HardenSingleThread(const char *src, const size_t size)
+    FAST_CALL void HardenSingleCore(const char *src, const size_t size)
     {
         const char *start = src;
         const char *end   = src + size;
@@ -185,19 +223,8 @@ static struct TraceFramework {
     }
 
     template <bool kIsDebug>
-    FORCE_INLINE_F void DumpBufferSingleThread(SmallTraceCyclicBuffer &buffer)
+    FAST_CALL void DumpBufferSingleCore(SmallTraceCyclicBuffer &buffer)
     {
-        // Assumptions:
-        // 1) bytes_left (1 thread, only main execution writes out) -> bytes_left may only decrement
-        // by interrupts, so
-        //    in worst case we will not write the most recent message from interrupts incoming
-        //    during dumping the buffer
-        // 2) tail is only moved by this function and only main execution can write out so we are
-        // safe to modify
-        //    it without atomics and any constraints
-        //
-        // Based on those two assumptions this function operates
-
         // 1. Save exact amount of bytes to write at entry level (IMPORTANT: to not write infinite)
         const i32 bytes_left = hal::AtomicLoad(&buffer.bytes_left);
         i32 bytes_to_write   = static_cast<i32>(SmallTraceCyclicBuffer::kSize) - bytes_left;
@@ -213,12 +240,10 @@ static struct TraceFramework {
                 // We cross the boundary
                 const size_t first_write  = SmallTraceCyclicBuffer::kSize - tail;
                 const size_t second_write = batch_write_size - first_write;
-                HardenSingleThread<kIsDebug>(
-                    buffer.buffer + tail, static_cast<size_t>(first_write)
-                );
-                HardenSingleThread<kIsDebug>(buffer.buffer, static_cast<size_t>(second_write));
+                HardenSingleCore<kIsDebug>(buffer.buffer + tail, static_cast<size_t>(first_write));
+                HardenSingleCore<kIsDebug>(buffer.buffer, static_cast<size_t>(second_write));
             } else {
-                HardenSingleThread<kIsDebug>(
+                HardenSingleCore<kIsDebug>(
                     buffer.buffer + tail, static_cast<size_t>(batch_write_size)
                 );
             }
@@ -237,121 +262,69 @@ static struct TraceFramework {
         }
     }
 
-    template <bool kIsDebug>
-    FORCE_INLINE_F void CommitToLogPtrSingleThreadInterrupts(
+    FORCE_INLINE_F void CommitToLogPtrSingleCoreInterrupts(
         SmallTraceCyclicBuffer &buffer, const size_t trace_size
     )
     {
-        // Assumptions:
-        // 1) Interrupt message will be dropped when there is no space left in the buffer
-        // 2) Main execution will try to immediately dump the buffers if there is no space
-        // 3) Only main execution may write the buffer out -> (interrupt writes -> no buffer dumps),
-        // (main exec writes ->
-        //    no buffer dumps) -> no buffer dumps during writing traces (it is safe to operate on
-        //    bytes_left)
-        // 4) Only full traces can be written out
-
         const u8 nested_intrs = hardware::GetCoreLocalData().nested_interrupts;
+        const char *src       = nested_intrs == 0 ? single_core_env.main_execution_workspace
+                                                  : single_core_env.interrupt_workspace[nested_intrs - 1];
 
-        // 1. Allocate space for the trace
-        while (true) {
-            if (hal::AtomicSub(&buffer.bytes_left, static_cast<i32>(trace_size)) < 0) {
-                hal::AtomicAdd(&buffer.bytes_left, static_cast<i32>(trace_size));
-
-                if (nested_intrs == 0) {
-                    DumpBufferSingleThread<kIsDebug>(buffer);
-                } else {
-                    /* No space for trace coming from this interrupt, we are dropping it */
-                    return;
-                }
-            } else {
-                break;
-            }
-        }
-
-        char *src = nested_intrs == 0 ? single_thread_env.main_execution_workspace
-                                      : single_thread_env.interrupt_workspace[nested_intrs - 1];
-
-        // 2. Adjust head ptr
-        i32 old_head;
-        i32 new_head;
-        do {
-            old_head = hal::AtomicLoad(&buffer.head);
-            new_head = (old_head + static_cast<i32>(trace_size)) %
-                       static_cast<i32>(SmallTraceCyclicBuffer::kSize);
-        } while (hal::AtomicCompareExchange(&buffer.head, old_head, new_head) != old_head);
-
-        // 3. Write the message
-        if (new_head < old_head) {
-            // We cross the boundary
-
-            const i32 first_part  = static_cast<i32>(SmallTraceCyclicBuffer::kSize) - old_head;
-            const i32 second_part = static_cast<i32>(trace_size) - first_part;
-            memcpy(buffer.buffer + old_head, src, first_part);
-            memcpy(buffer.buffer, src + first_part, second_part);
-        } else {
-            memcpy(buffer.buffer + old_head, src, static_cast<i32>(trace_size));
-        }
-
-        if (nested_intrs == 0 &&
-            buffer.bytes_left.value < static_cast<i32>(SmallTraceCyclicBuffer::kDumpSize)) {
-            // Dump the content on main execution if we used enough space
-            DumpBufferSingleThread<kIsDebug>(buffer);
-        }
+        CommitToLogPtrSingleCore(buffer, trace_size, src);
     }
 
-    char *GetWorkspaceSingleThreadInterrupts()
+    char *GetWorkspaceSingleCoreInterrupts()
     {
         const u8 nested_intrs = hardware::GetCoreLocalData().nested_interrupts;
 
         if (nested_intrs == 0) {
-            return single_thread_env.main_execution_workspace;
+            return single_core_env.main_execution_workspace;
         }
 
-        return single_thread_env.interrupt_workspace[nested_intrs - 1];
+        return single_core_env.interrupt_workspace[nested_intrs - 1];
     }
 
-    void CommitToLogSingleThreadInterrupts(const size_t trace_size)
+    void CommitToLogSingleCoreInterrupts(const size_t trace_size)
     {
-        CommitToLogPtrSingleThreadInterrupts<false>(trace_log, trace_size);
+        CommitToLogPtrSingleCoreInterrupts(trace_log, trace_size);
     }
 
-    void CommitToDebugLogSingleThreadInterrupts(const size_t trace_size)
+    void CommitToDebugLogSingleCoreInterrupts(const size_t trace_size)
     {
-        CommitToLogPtrSingleThreadInterrupts<true>(trace_debug_log, trace_size);
+        CommitToLogPtrSingleCoreInterrupts(trace_debug_log, trace_size);
     }
 
-    void DumpAllSingleThreadInterrupts()
+    void DumpAllSingleCoreInterrupts()
     {
         /* There is possibility to write out garbage at this stage but everything important is in
          * place */
-        DumpBufferSingleThread<false>(trace_log);
-        DumpBufferSingleThread<true>(trace_debug_log);
+        DumpBufferSingleCore<false>(trace_log);
+        DumpBufferSingleCore<true>(trace_debug_log);
     }
 
     // ------------------------------------
-    // Multithread env implementation
+    // Multicore env implementation
     // ------------------------------------
 
-    char *GetWorkspaceMultithreaded() { return nullptr; }
+    char *GetWorkspaceMultiCore() { return nullptr; }
 
-    void CommitToLogMultithreaded(const size_t) {}
+    void CommitToLogMultiCore(const size_t) {}
 
-    void CommitToDebugLogMultithreaded(const size_t) {}
+    void CommitToDebugLogMultiCore(const size_t) {}
 
-    void DumpAllMultithreaded() {}
+    void DumpAllMultiCore() {}
 
     // ------------------------------
     // Global fields
     // ------------------------------
 
-    TracingStage stage = TracingStage::kSingleThreadEnv;
+    TracingStage stage = TracingStage::kSingleCoreEnv;
 
     StageCallbacks stage_callbacks{
-        .get_workspace_cb       = &TraceFramework::GetWorkspaceSingleThread,
-        .commit_to_log_cb       = &TraceFramework::CommitToLogSingleThread,
-        .commit_to_debug_log_cb = &TraceFramework::CommitToDebugLogSingleThread,
-        .dump_all               = &TraceFramework::DumpAllSingleThread,
+        .get_workspace_cb       = &TraceFramework::GetWorkspaceSingleCore,
+        .commit_to_log_cb       = &TraceFramework::CommitToLogSingleCore,
+        .commit_to_debug_log_cb = &TraceFramework::CommitToDebugLogSingleCore,
+        .dump_all               = &TraceFramework::DumpAllSingleCore,
     };
 
     std::array<TraceLevel, static_cast<size_t>(TraceModule::kLast)> trace_levels = []() constexpr {
@@ -385,20 +358,20 @@ static struct TraceFramework {
     }();
 
     // ------------------------------
-    // Single thread env fields
+    // Single core env fields
     // ------------------------------
 
-    CoreTraceData single_thread_env{};
+    CoreTraceData single_core_env{};
     SmallTraceCyclicBuffer trace_log{};
     SmallTraceCyclicBuffer trace_debug_log{};
 
     // ------------------------------
-    // Multi thread env fields
+    // Multi core env fields
     // ------------------------------
 
-    MultithreadTraceCyclicBuffer dyn_trace_log{};
-    MultithreadTraceCyclicBuffer dyn_debug_trace_log{};
-    CoreTraceData *multithread_env = nullptr;
+    MultiCoreTraceCyclicBuffer dyn_trace_log{};
+    MultiCoreTraceCyclicBuffer dyn_debug_trace_log{};
+    CoreTraceData *multicore_env = nullptr;
 
 } g_TraceFramework{};
 
@@ -465,6 +438,8 @@ NODISCARD TraceLevel GetTraceLevel(TraceModule module)
     return g_TraceFramework.trace_levels[static_cast<size_t>(module)];
 }
 
-void Flush() { (g_TraceFramework.*g_TraceFramework.stage_callbacks.dump_all)(); }
-void DumpAllBuffersOnFailure() { Flush(); }
+void DumpAllBuffersOnFailure() { (g_TraceFramework.*g_TraceFramework.stage_callbacks.dump_all)(); }
+
+void TraceDumperTask() { (g_TraceFramework.*g_TraceFramework.stage_callbacks.dump_all)(); }
+
 }  // namespace trace
diff --git a/kernel/src/trace_framework.hpp b/kernel/src/trace_framework.hpp
index a8303c88..17cea331 100644
--- a/kernel/src/trace_framework.hpp
+++ b/kernel/src/trace_framework.hpp
@@ -3,11 +3,6 @@
 
 #include <defines.hpp>
 
-/* FUTURE PLANS:
- * - get rid of dumping -> introduce user space program dumping traces
- * - remove flush() function
- */
-
 namespace trace
 {
 // ------------------------------
@@ -15,9 +10,9 @@ namespace trace
 // ------------------------------
 
 enum class TracingStage {
-    kSingleThreadEnv = 0, /* Starts on this stage */
-    kSingleThreadInterruptsEnv,
-    kMultiThreadEnv, /* Should end up here */
+    kSingleCoreEnv = 0, /* Starts on this stage */
+    kSingleCoreInterruptsEnv,
+    kMultiCoreEnv, /* Should end up here */
     kLast,
 };
 
@@ -57,7 +52,7 @@ enum class TraceModule {
 void AdvanceTracingStage();
 NODISCARD TraceLevel GetTraceLevel(TraceModule module);
 void DumpAllBuffersOnFailure();
-void Flush(); /* May only be used on main execution, no interrupts allowed */
+void TraceDumperTask();
 
 /* MODULE TIME CORE PROC MSG */
 template <TraceType type, TraceModule module, TraceLevel level, class... Args>
diff --git a/kernel/test/manual_tests.cpp b/kernel/test/manual_tests.cpp
index fea73157..d014a96c 100644
--- a/kernel/test/manual_tests.cpp
+++ b/kernel/test/manual_tests.cpp
@@ -30,6 +30,7 @@ static void Task0()
 
         const auto tcb = hardware::GetCurrentTCB();
         HardwareModule::Get().GetInterrupts().BlockHardwareInterrupts();
+        trace::DumpAllBuffersOnFailure();
         hal::ContextSwitch(tcb->next);
     }
 }
@@ -50,6 +51,7 @@ static void Task1()
         const auto tcb = hardware::GetCurrentTCB();
 
         HardwareModule::Get().GetInterrupts().BlockHardwareInterrupts();
+        trace::DumpAllBuffersOnFailure();
         hal::ContextSwitch(tcb->next);
     }
 }
@@ -60,9 +62,9 @@ MTEST(KernelTaskSwitchTest)
     flags.KernelSpaceOnly = true;
     flags.PreserveFloats  = true;
 
-    auto p0 = SchedulingModule::Get().GetTaskMgr().SpawnProcess(Task0, flags);
+    auto p0 = SchedulingModule::Get().GetTaskMgr().SpawnKernelProcess("task0", flags, Task0);
     ASSERT_TRUE(static_cast<bool>(p0));
-    auto p1 = SchedulingModule::Get().GetTaskMgr().SpawnProcess(Task1, flags);
+    auto p1 = SchedulingModule::Get().GetTaskMgr().SpawnKernelProcess("task1", flags, Task1);
     ASSERT_TRUE(static_cast<bool>(p1));
 
     const auto tid0 = std::get<1>(p0.value());
diff --git a/kernel/test/test_module.cpp b/kernel/test/test_module.cpp
index a0d1281a..57219ad0 100644
--- a/kernel/test/test_module.cpp
+++ b/kernel/test/test_module.cpp
@@ -56,23 +56,23 @@ void TestModule::RunTestModule()
 
     /* read single line of input */
     char buff[kInputBufferSize];
-    arch::TerminalWriteString(
+    hal::TerminalWriteString(
         "Provide test name for framework or simply type \"exit\" to quit...\n"
     );
-    if (arch::TerminalReadLine(buff, kInputBufferSize) == kInputBufferSize) {
-        arch::TerminalWriteError("[TEST] [FAIL] Too long input message...\n");
+    if (hal::TerminalReadLine(buff, kInputBufferSize) == kInputBufferSize) {
+        hal::TerminalWriteError("[TEST] [FAIL] Too long input message...\n");
         hal::QemuShutdown();
     }
 
     if (strcmp(buff, "exit") == 0) {
-        arch::TerminalWriteString("Kernel shutdown on test...\n");
+        hal::TerminalWriteString("Kernel shutdown on test...\n");
         hal::QemuShutdown();
     }
 
     const TestSpec *test = FindTestFunction(buff);
 
     if (test == nullptr) {
-        arch::TerminalWriteError("[TEST] [FAIL] Test not found...\n");
+        hal::TerminalWriteError("[TEST] [FAIL] Test not found...\n");
         hal::QemuShutdown();
     }
 
@@ -137,18 +137,18 @@ void TestModule::RunTest_(const TestSpec *test)
         arch::TerminalWriteError(
             "[TEST] [FAIL] Test was supposed to fail but all checks passed correctly...\n"
         );
-        trace::Flush();
+        trace::DumpAllBuffersOnFailure();
         return;
     }
 
     if (g_testCheckFailed) {
         arch::TerminalWriteError("[TEST] [FAIL] Test failed on some EXPECT_* checks...\n");
-        trace::Flush();
+        trace::DumpAllBuffersOnFailure();
         return;
     }
 
     arch::TerminalWriteString("[TEST] [SUCCESS] Test passed...\n");
-    trace::Flush();
+    trace::DumpAllBuffersOnFailure();
 }
 
 void AddTest(const char *name, const test_factory_t factory)

From 5c79c0279e503fd4c58ac1e10966e597711122b4 Mon Sep 17 00:00:00 2001
From: Adam Ogieniewski <ogieniewski.dev@gmail.com>
Date: Wed, 31 Dec 2025 13:21:28 +0100
Subject: [PATCH 37/56] Enable execution of user programs (#260)

Adjust GDT selectors to correctly set RPL for user-mode segments.
Implement `ExecuteElf64` to load ELF binaries into a process's address
space and spawn an initial thread.
Enhance address space switching logic to use the VMM's `SwitchAddrSpace`
for better control during context switches and ELF loading.
Initialize VFS earlier to support ELF loading from the filesystem.
Launch a basic 'hello world' user program at boot to demonstrate
functionality.
---
 kernel/arch/x86_64/src/cpu/gdt.hpp            |  4 +-
 .../arch/x86_64/src/include/scheduling.nasm   |  4 +-
 .../arch/x86_64/src/scheduling/scheduling.cpp | 22 ++++++---
 kernel/src/init.cpp                           |  3 +-
 kernel/src/mem/virt/area.cpp                  |  3 +-
 kernel/src/mem/virt/vmm.cpp                   |  2 +
 kernel/src/scheduling/task_mgr.cpp            | 48 +++++++++++++++----
 kernel/src/sys/loader.cpp                     |  7 +++
 userspace/programs/hello_world/main.cpp       | 20 +++++---
 9 files changed, 85 insertions(+), 28 deletions(-)

diff --git a/kernel/arch/x86_64/src/cpu/gdt.hpp b/kernel/arch/x86_64/src/cpu/gdt.hpp
index 04de3730..41e91385 100644
--- a/kernel/arch/x86_64/src/cpu/gdt.hpp
+++ b/kernel/arch/x86_64/src/cpu/gdt.hpp
@@ -154,8 +154,8 @@ struct PACK Gdtr {
 struct alignas(16) PACK GDT {
     static constexpr u16 kKernelCodeSelector = 0x08;
     static constexpr u16 kKernelDataSelector = 0x10;
-    static constexpr u16 kUserCodeSelector   = 0x18;
-    static constexpr u16 kUserDataSelector   = 0x20;
+    static constexpr u16 kUserCodeSelector   = 0x1B;
+    static constexpr u16 kUserDataSelector   = 0x23;
     static constexpr u16 kTssSelector        = 0x28;
 
     GdtEntry<> null_entry;
diff --git a/kernel/arch/x86_64/src/include/scheduling.nasm b/kernel/arch/x86_64/src/include/scheduling.nasm
index 4045effb..a1d289fe 100644
--- a/kernel/arch/x86_64/src/include/scheduling.nasm
+++ b/kernel/arch/x86_64/src/include/scheduling.nasm
@@ -16,7 +16,7 @@ _ss_int_frame_offset equ _sp_int_frame_offset + 8
 
 _kernel_code_selector equ 0x08
 _kernel_data_selector equ 0x10
-_user_code_selector equ 0x18
-_user_data_selector equ 0x20
+_user_code_selector equ 0x1B
+_user_data_selector equ 0x23
 
 _jump_userspace_stack_space equ  5*8  ; sizeof(IsrStackFrame)
diff --git a/kernel/arch/x86_64/src/scheduling/scheduling.cpp b/kernel/arch/x86_64/src/scheduling/scheduling.cpp
index 099ead01..06ccbe5c 100644
--- a/kernel/arch/x86_64/src/scheduling/scheduling.cpp
+++ b/kernel/arch/x86_64/src/scheduling/scheduling.cpp
@@ -1,6 +1,7 @@
 #include "modules/scheduling.hpp"
 
 #include <cpu/control_registers.hpp>
+#include <modules/memory.hpp>
 
 #include "cpu/utils.hpp"
 #include "hal/interrupt_params.hpp"
@@ -103,15 +104,18 @@ FAST_CALL u64 GetThreadsPageTable(Sched::Thread *thread)
     return reinterpret_cast<u64>(proc.value()->address_space->PageTableRoot());
 }
 
-FAST_CALL void SwapCr3IfNeeded(Sched::Thread *tcb)
+FAST_CALL void SwapAsIfNeeded(Sched::Thread *tcb)
 {
     ASSERT_NOT_NULL(tcb);
 
-    auto cr3 = cpu::GetCR<cpu::Cr3>();
+    const auto proc = SchedulingModule::Get().GetProcesses().GetProcess(tcb->owner);
+    ASSERT_TRUE(static_cast<bool>(proc), "Threads exists -> owner MUST exist");
+
+    auto &current_as = MemoryModule::Get().GetVmm().GetCurrentAddressSpace();
+    auto thread_as   = proc.value()->address_space;
 
-    auto next_cr3 = GetThreadsPageTable(tcb);
-    if (*reinterpret_cast<u64 *>(&cr3) != next_cr3) {
-        cpu::SetCR(*reinterpret_cast<cpu::Cr3 *>(&next_cr3));
+    if (&current_as != thread_as) {
+        MemoryModule::Get().GetVmm().SwitchAddrSpace(thread_as);
     }
 }
 
@@ -141,6 +145,10 @@ extern "C" void cdecl_JumpToUserSpaceEntry(void *addr, IsrStackFrame *frame)
 
     SetThreadGs(thread);
     __asm__ volatile("swapgs" ::: "memory");
+
+    const auto proc = SchedulingModule::Get().GetProcesses().GetProcess(thread->owner);
+    ASSERT_TRUE(static_cast<bool>(proc), "Threads exists -> owner MUST exist");
+    MemoryModule::Get().GetVmm().SwitchAddrSpace(proc.value()->address_space);
 }
 
 extern "C" void cdecl_ContextSwitchEntry(
@@ -161,7 +169,7 @@ extern "C" void cdecl_ContextSwitchEntry(
     SetTssRsp0(reinterpret_cast<u64>(thread->kernel_stack_bottom));
     SwapGsIfJumpingToUserspace(thread);
     LoadFpStateIfNeeded(thread);
-    SwapCr3IfNeeded(thread);
+    SwapAsIfNeeded(thread);
 }
 
 extern "C" void cdecl_ContextSwitchOnInterrupt(Sched::Thread *thread, void *rsp)
@@ -171,7 +179,7 @@ extern "C" void cdecl_ContextSwitchOnInterrupt(Sched::Thread *thread, void *rsp)
     SwapFsIfNeeded(current_tcb, thread);
     hardware::SetCurrentTCB(thread);
     SetTssRsp0(reinterpret_cast<u64>(thread->kernel_stack_bottom));
-    SwapCr3IfNeeded(thread);
+    SwapAsIfNeeded(thread);
 }
 
 // ===========================
diff --git a/kernel/src/init.cpp b/kernel/src/init.cpp
index bae1ad25..fcf8abd7 100644
--- a/kernel/src/init.cpp
+++ b/kernel/src/init.cpp
@@ -54,11 +54,12 @@ void KernelInit(const hal::RawBootArguments &raw_args)
     /* Fully Initialize ACPI subsystem */
     // HardwareModule::Get().GetACPIController().Init();
 
+    VfsModule::Init(args);
+
     SchedulingModule::Init();
     SchedulingModule::Get().GetTaskMgr().InitializeMultitasking();
 
     HardwareModule::Get().GetCoresController().BootUpAllCores();
 
-    VfsModule::Init(args);
     VideoModule::Init(args, MemoryModule::Get().GetHeap());
 }
diff --git a/kernel/src/mem/virt/area.cpp b/kernel/src/mem/virt/area.cpp
index 4674c2f1..3c6d18f4 100644
--- a/kernel/src/mem/virt/area.cpp
+++ b/kernel/src/mem/virt/area.cpp
@@ -119,7 +119,8 @@ KernelSyncVMemArea::KernelSyncVMemArea()
     // Covers the entire upper half of the 64-bit address space
     // 0x8000000000000000 - 0xFFFFFFFFFFFFFFFF
     : VMemArea(
-          Mem::UptrToPtr<void>(kKernelSpaceStart), kKernelSpaceEndInclusive - kKernelSpaceStart,
+          Mem::UptrToPtr<void>(kKernelSpaceStart),
+          AlignDown(kKernelSpaceEndInclusive - kKernelSpaceStart, hal::kPageSizeBytes),
           // Permissions are determined by the actual kernel page table entries being copied,
           // these flags are just placeholders for the VMA object.
           VirtualMemAreaFlags{.readable = true, .writable = true, .executable = true}
diff --git a/kernel/src/mem/virt/vmm.cpp b/kernel/src/mem/virt/vmm.cpp
index d9fa292d..76471bdb 100644
--- a/kernel/src/mem/virt/vmm.cpp
+++ b/kernel/src/mem/virt/vmm.cpp
@@ -130,6 +130,8 @@ expected<VPtr<void>, MemError> Vmm::AllocAnonymous(
     RET_UNEXPECTED_IF(!vma_res, MemError::OutOfMemory);
     auto *vma = *vma_res;
 
+    UpdateAreaFlags(as, vma->GetStart(), flags);
+
     auto add_res = as->AddArea(vma);
     RET_UNEXPECTED_IF_ERR(add_res);
 
diff --git a/kernel/src/scheduling/task_mgr.cpp b/kernel/src/scheduling/task_mgr.cpp
index 0a37050d..f66f475f 100644
--- a/kernel/src/scheduling/task_mgr.cpp
+++ b/kernel/src/scheduling/task_mgr.cpp
@@ -4,7 +4,10 @@
 #include "modules/memory.hpp"
 #include "modules/scheduling.hpp"
 #include "scheduling/kworker.hpp"
+#include "sys/loader.hpp"
 #include "task_mgr.hpp"
+#include "vfs/path.hpp"
+
 #include "trace_framework.hpp"
 
 #include "hal/scheduling.hpp"
@@ -41,6 +44,10 @@ void TaskMgr::InitializeMultitasking()
     // Spawn trace dumper
     const auto result = SpawnKernelProcess("kworker-trace-dumper", {}, TraceDumperMain);
     R_ASSERT_TRUE(static_cast<bool>(result), "Failed to spawn trace dumper process...");
+
+    // Spawn hello world process
+    const auto res = ExecuteElf64("/bin/hello", {});
+    R_ASSERT_TRUE(static_cast<bool>(res), "Failed to spawn /bin/hello process...");
 }
 
 std::expected<Pid, Error> TaskMgr::SpawnEmptyProcess(const char *name, const ProcessFlags flags)
@@ -203,9 +210,37 @@ std::expected<std::tuple<Pid, Tid>, Error> TaskMgr::SpawnKernelProcess(
 
 std::expected<Pid, Error> TaskMgr::CloneProcess(Pid) { R_FAIL_ALWAYS("NOT IMPLEMENTED"); }
 
-std::expected<Tid, Error> TaskMgr::ExecuteElf64(Pid, const char *)
+std::expected<Tid, Error> TaskMgr::ExecuteElf64(Pid pid, const char *path)
 {
-    R_FAIL_ALWAYS("NOT IMPLEMENTED");
+    auto process = SchedulingModule::Get().GetProcesses().GetProcess(pid);
+    RET_UNEXPECTED_IF_ERR(process);
+
+    auto &as = process.value()->address_space;
+    ASSERT_NOT_NULL(as);
+
+    auto entry_res = System::ElfLoader::Load(vfs::Path(path), *as);
+    if (!entry_res) {
+        DEBUG_WARN_SCHEDULING(
+            "Failed to execute ELF64 for process %llu. Failed on ELF loading.", pid
+        );
+        return std::unexpected(Error::OutOfMemory);
+    }
+
+    const auto entry = reinterpret_cast<void (*)()>(entry_res.value());
+
+    auto thread = SpawnThread(pid, entry);
+    RET_UNEXPECTED_IF_ERR(thread);
+
+    HardwareModule::Get().GetInterrupts().BlockHardwareInterrupts();
+    SchedulingModule::Get().GetScheduler().AddReadyThread(thread.value());
+    HardwareModule::Get().GetInterrupts().EnableHardwareInterrupts();
+
+    DEBUG_INFO_SCHEDULING(
+        "Created userspace process with pid: %llu, name: %s and initial thread with tid: %llu", pid,
+        process.value()->name, thread.value()->tid
+    );
+
+    return thread.value()->tid;
 }
 
 std::expected<std::tuple<Pid, Tid>, Error> TaskMgr::ExecuteElf64(
@@ -213,19 +248,14 @@ std::expected<std::tuple<Pid, Tid>, Error> TaskMgr::ExecuteElf64(
 )
 {
     auto process = SpawnEmptyProcess(path, flags);
-    if (!process) {
-        return std::unexpected(process.error());
-    }
+    RET_UNEXPECTED_IF_ERR(process);
 
     template_lib::ScopeGuard process_guard([&] {
         const auto result = SchedulingModule::Get().GetProcesses().Free(process.value());
         ASSERT_TRUE(static_cast<bool>(result));
     });
-
     auto thread = ExecuteElf64(process.value(), path);
-    if (!thread) {
-        return std::unexpected(thread.error());
-    }
+    RET_UNEXPECTED_IF_ERR(thread);
 
     process_guard.dismiss();
     return std::make_tuple(process.value(), thread.value());
diff --git a/kernel/src/sys/loader.cpp b/kernel/src/sys/loader.cpp
index a26fade8..d47a6a90 100644
--- a/kernel/src/sys/loader.cpp
+++ b/kernel/src/sys/loader.cpp
@@ -109,6 +109,10 @@ expected<Mem::VPtr<void>, LoadError> ElfLoader::Load(const vfs::Path &path, Mem:
         }
     });
 
+    // Switch Address Space to load data
+    auto &prev_as = MemoryModule::Get().GetVmm().GetCurrentAddressSpace();
+    MemoryModule::Get().GetVmm().SwitchAddrSpace(&as);
+
     // 5. Load Segments
     TRACE_FREQ_INFO_GENERAL("Validating the ELF header");
     for (u16 i = 0; i < header.phnum; ++i) {
@@ -181,6 +185,9 @@ expected<Mem::VPtr<void>, LoadError> ElfLoader::Load(const vfs::Path &path, Mem:
         }
     }
 
+    // Restore previous Address Space
+    MemoryModule::Get().GetVmm().SwitchAddrSpace(&prev_as);
+
     vma_cleanup_guard.dismiss();
     u64 entry_point = header.entry;
     return Mem::UptrToPtr<void>(entry_point);
diff --git a/userspace/programs/hello_world/main.cpp b/userspace/programs/hello_world/main.cpp
index 4ec10136..2e74d8bd 100644
--- a/userspace/programs/hello_world/main.cpp
+++ b/userspace/programs/hello_world/main.cpp
@@ -7,29 +7,37 @@ void printf(const char *format, Args... args)
 {
     char buffer[256];
     snprintf(buffer, sizeof(buffer), format, args...);
-    __platform_write_console(buffer);
+    __platform_debug_write(buffer);
 }
 
 extern "C" int main()
 {
-    __platform_write_console(
+    printf(
         "\n----------------------------------\n"
         "Hello from User Space via Syscall!\n"
         "----------------------------------\n"
     );
 
-    printf("\nFormatting Test: %d + %d = %d\n\n", 2, 2, 4);
+    printf("Formatting Test: %d + %d = %d\n", 2, 2, 4);
 
     Timezone tz;
     __platform_get_timezone(&tz);
-    printf("Timezone offset (minutes): %d\n\n", tz.west_offset_minutes);
+    printf("Timezone offset (minutes): %d\n", tz.west_offset_minutes);
 
     u64 ticks = __platform_get_clock_ticks_in_second(kTimeUtc);
-    printf("Ticks per second (UTC): %llu\n\n", ticks);
+    printf("Ticks per second (UTC): %llu\n", ticks);
 
     TimeVal tv;
     __platform_get_clock_value(kTimeUtc, &tv, &tz);
-    printf("Current Timestamp: %llu\n\n", tv.seconds);
+    printf("Current Timestamp: %llu\n", tv.seconds);
+
+    while (true) {
+        static size_t kSpins = 1'000'000;
+        size_t counter       = 0;
+        for (size_t i = 0; i < kSpins; i++) {
+            ++counter;
+        }
+    }
 
     return 0;
 }

From bf749bdccb33ad7a72cd85e9e689328be1504749 Mon Sep 17 00:00:00 2001
From: Adam Ogieniewski <ogieniewski.dev@gmail.com>
Date: Fri, 2 Jan 2026 12:30:32 +0100
Subject: [PATCH 38/56] Implement file descriptor management (#261)

Establish a complete file descriptor system (FdTable, FileTable,
OpenFileTable)
and overhaul the syscall handler to support std::expected returns,
std::span
arguments, and FAST_CALL. New syscalls for file operations (open, close,
read,
write, seek) are now available.

This commit also transitions core type definitions from types.hpp to
types.h for
C-compatibility, integrates RefCounted and RefPtr for robust resource
handling,
upgrades uACPI to 3.2.0, and enhances page fault diagnostics. The new
file I/O
syscalls are connected to libc and demonstrated in userspace programs.
---
 .../x86_64/boot/lib/abi/transition_data.hpp   |   2 +-
 kernel/arch/x86_64/boot/lib/cpu/utils.hpp     |   2 +-
 kernel/arch/x86_64/boot/lib/elf/elf_64.hpp    |   2 +-
 .../arch/x86_64/boot/lib/elf/elf_dynamic.hpp  |   2 +-
 kernel/arch/x86_64/boot/lib/hw/io.hpp         |   2 +-
 kernel/arch/x86_64/boot/lib/hw/pci.hpp        |   2 +-
 .../arch/x86_64/boot/lib/hw/serial/qemu.hpp   |   2 +-
 kernel/arch/x86_64/boot/lib/hw/vga.cpp        |   2 +-
 kernel/arch/x86_64/boot/lib/hw/vga.hpp        |   2 +-
 kernel/arch/x86_64/boot/lib/mem/page_map.hpp  |   2 +-
 .../arch/x86_64/boot/lib/mem/physical_ptr.hpp |   2 +-
 kernel/arch/x86_64/boot/lib/mem/vmm.cpp       |   2 +-
 .../arch/x86_64/boot/lib/multiboot2/info.hpp  |   2 +-
 .../x86_64/boot/lib/multiboot2/memory_map.hpp |   2 +-
 .../x86_64/boot/lib/multiboot2/multiboot2.h   |   2 +-
 kernel/arch/x86_64/boot/settings/settings.hpp |   2 +-
 kernel/arch/x86_64/src/abi/boot_args.hpp      |   2 +-
 .../arch/x86_64/src/cpu/control_registers.hpp |   2 +-
 kernel/arch/x86_64/src/cpu/gdt.hpp            |   2 +-
 kernel/arch/x86_64/src/cpu/msrs.hpp           |   2 +-
 kernel/arch/x86_64/src/cpu/tss.hpp            |   2 +-
 kernel/arch/x86_64/src/cpu/utils.hpp          |   2 +-
 .../arch/x86_64/src/drivers/apic/io_apic.hpp  |   2 +-
 kernel/arch/x86_64/src/drivers/cmos/cmos.hpp  |   2 +-
 kernel/arch/x86_64/src/drivers/cmos/rtc.hpp   |   2 +-
 kernel/arch/x86_64/src/drivers/hpet/hpet.hpp  |   2 +-
 .../x86_64/src/drivers/pic8259/pic8259.cpp    |   2 +-
 .../x86_64/src/drivers/pic8259/pic8259.hpp    |   2 +-
 kernel/arch/x86_64/src/drivers/pit/pit.hpp    |   2 +-
 .../arch/x86_64/src/drivers/serial/qemu.hpp   |   2 +-
 kernel/arch/x86_64/src/drivers/tsc/tsc.hpp    |   2 +-
 kernel/arch/x86_64/src/hal/impl/constants.hpp |   2 +-
 kernel/arch/x86_64/src/hal/impl/core.hpp      |   2 -
 .../x86_64/src/hal/impl/interrupt_params.hpp  |   2 +-
 kernel/arch/x86_64/src/hal/impl/kernel.hpp    |   2 +-
 kernel/arch/x86_64/src/hal/impl/spinlock.hpp  |   6 +-
 kernel/arch/x86_64/src/hal/impl/tasks.hpp     |   2 +-
 kernel/arch/x86_64/src/hal/impl/timers.hpp    |   2 +-
 kernel/arch/x86_64/src/hal/impl/types.hpp     |   2 +-
 kernel/arch/x86_64/src/include/io.hpp         |   2 +-
 .../x86_64/src/include/models/memory_span.hpp |   2 +-
 .../src/include/multiboot2/memory_map.hpp     |   2 +-
 .../src/include/multiboot2/multiboot2.h       |   2 +-
 .../src/include/multiboot2/multiboot_info.hpp |   2 +-
 kernel/arch/x86_64/src/include/pci.hpp        |   2 +-
 kernel/arch/x86_64/src/interrupts/idt.hpp     |   2 +-
 kernel/arch/x86_64/src/interrupts/idt.nasm    |   2 +
 kernel/arch/x86_64/src/mem/page_map.hpp       |   2 +-
 .../arch/x86_64/src/scheduling/scheduling.cpp |   3 +
 kernel/src/acpi/acpi.cpp                      |   2 +-
 kernel/src/acpi/acpi_battery.hpp              |   2 +-
 kernel/src/acpi/acpi_cpu.hpp                  |   2 +-
 kernel/src/acpi/acpi_device.hpp               |   2 +-
 kernel/src/acpi/acpi_interrupt.hpp            |   2 +-
 kernel/src/acpi/acpi_power.hpp                |   2 +-
 kernel/src/acpi/acpi_thermal.hpp              |   2 +-
 kernel/src/acpi/osl.tpp                       |  11 +-
 kernel/src/constants.hpp                      |   2 +-
 kernel/src/demos/donut.hpp                    |   2 +-
 kernel/src/drivers/input/ps2_keyboard.hpp     |   2 +-
 kernel/src/drivers/serial/uart_16550.hpp      |   2 +-
 kernel/src/fs/file_descriptor.cpp             | 523 ++++++++++++++++++
 kernel/src/fs/file_descriptor.hpp             | 321 +++++++++++
 kernel/src/{ => fs}/vfs/error.hpp             |   0
 kernel/src/{ => fs}/vfs/fat/fat.hpp           |  14 +-
 kernel/src/{ => fs}/vfs/fat/fat12.hpp         |   4 +-
 kernel/src/{ => fs}/vfs/fat/fat16.hpp         |   0
 kernel/src/{ => fs}/vfs/fat/fat32.hpp         |   0
 kernel/src/{ => fs}/vfs/interface.hpp         |   2 +-
 kernel/src/{ => fs}/vfs/io/in_memory.hpp      |   3 +-
 kernel/src/{ => fs}/vfs/path.hpp              |   4 +-
 kernel/src/{ => fs}/vfs/types.hpp             |   8 +-
 kernel/src/graphics/color.hpp                 |   2 +-
 kernel/src/graphics/font/glyph.hpp            |   2 +-
 kernel/src/graphics/font/psf2_font.hpp        |   2 +-
 kernel/src/graphics/geometry.hpp              |   2 +-
 kernel/src/graphics/native_pixel.hpp          |   2 +-
 kernel/src/graphics/surface.hpp               |   2 +-
 kernel/src/hal/api/boot_args.hpp              |   2 +-
 kernel/src/hal/api/debug_terminal.hpp         |   2 +-
 kernel/src/hal/api/io.hpp                     |   2 +-
 kernel/src/hal/api/sync.hpp                   |   2 +-
 kernel/src/hal/constants.hpp                  |   2 +-
 kernel/src/hal/panic.hpp                      |   4 +
 kernel/src/hal/timers.hpp                     |   2 +-
 kernel/src/hardware/interrupt_driver.hpp      |   2 +-
 kernel/src/init.cpp                           |   4 +-
 kernel/src/kernel.cpp                         |   7 +
 kernel/src/libc_backend.cpp                   |  48 ++
 kernel/src/mem/page.hpp                       |   2 +-
 kernel/src/mem/page_meta.hpp                  |   2 +-
 kernel/src/mem/phys/mngr/buddy.hpp            |   2 +-
 kernel/src/mem/phys/ptr.hpp                   |   2 +-
 kernel/src/mem/types.hpp                      |  10 +-
 kernel/src/mem/virt/addr_space.hpp            |   2 +-
 kernel/src/mem/virt/area.hpp                  |   2 +-
 kernel/src/mem/virt/page_fault.cpp            |  78 ++-
 kernel/src/mem/virt/ptr.hpp                   |   2 +-
 kernel/src/mem/virt/vmm.hpp                   |   2 +-
 kernel/src/modules/vfs.cpp                    |  12 +-
 kernel/src/modules/vfs.hpp                    |   6 +-
 kernel/src/scheduling/kworker.cpp             |   9 +
 kernel/src/scheduling/kworker.hpp             |   1 +
 kernel/src/scheduling/process.hpp             |  17 +-
 kernel/src/scheduling/processes.cpp           |  78 +++
 kernel/src/scheduling/processes.hpp           |  10 +
 kernel/src/scheduling/task_mgr.cpp            |  10 +-
 kernel/src/scheduling/thread.hpp              |   2 +-
 kernel/src/scheduling/threads.cpp             |   1 +
 kernel/src/sys/elf/elf.hpp                    |   2 +-
 kernel/src/sys/loader.hpp                     |   2 +-
 kernel/src/sys/shell.hpp                      |   2 +-
 kernel/src/syscalls/calls/fd.hpp              |  81 +++
 kernel/src/syscalls/calls/io.hpp              |  47 ++
 kernel/src/syscalls/calls/panic.hpp           |  27 +
 kernel/src/syscalls/calls/time.hpp            |  92 +++
 kernel/src/syscalls/dispatch_table.hpp        |  35 +-
 kernel/src/syscalls/handler.hpp               | 122 +++-
 kernel/src/syscalls/syscalls.cpp              |  16 +-
 kernel/src/syscalls/syscalls.hpp              | 143 +----
 kernel/src/time/event_framework.hpp           |   2 +-
 kernel/src/time/system_time.hpp               |   4 +-
 kernel/test/bitfield_test.cpp                 |   2 +-
 kernel/test/ref_count_test.cpp                | 240 ++++++++
 kernel/test/tagged_pointer_test.cpp           | 209 ++++++-
 kernel/test/vfs/fat/fat12_test.cpp            |   6 +-
 kernel/test/vfs/path_test.cpp                 |   2 +-
 kernel/test/vfs/vfs_module_test.cpp           |   7 +-
 kernel/thirdparty/uacpi/CMakeLists.txt        |   2 +-
 libs/libc/arch/x86_64/syscall.h               |   2 +-
 libs/libc/src/abi/platform.h                  |  19 +-
 libs/libc/src/include/assert_base.hpp         |   8 +-
 libs/libc/src/include/ctype.h                 |   8 +-
 libs/libc/src/include/math.h                  |   8 +-
 libs/libc/src/include/stdio.h                 |  69 ++-
 libs/libc/src/include/sys/calls.h             |   7 +
 libs/libc/src/include/sys/calls/fd.h          |  55 ++
 libs/libc/src/include/sys/fd.h                |  24 +
 libs/libc/src/include/sys/time.h              |  20 +-
 libs/libc/src/include/types.h                 |  63 ++-
 libs/libc/src/internal/entry.hpp              |  27 +
 libs/libc/src/internal/libc_backend.cpp       |   7 +
 libs/libc/src/internal/stdio.cpp              |  62 +++
 libs/libc/src/internal/stdio.hpp              |   9 +
 libs/libc/src/internal/time_internal.cpp      |   2 +-
 libs/libc/src/io/snprintf.cpp                 |   2 +-
 libs/libc/src/math/math.cpp                   |   2 +-
 libs/libc/src/time/time_ext.cpp               |   8 +-
 .../include/data_structures/bit_array.hpp     |   2 +-
 .../include/data_structures/critbit_tree.hpp  |   2 +-
 .../include/data_structures/cyclic_buffer.hpp |   2 +-
 .../include/data_structures/ref_count.hpp     | 219 ++++++++
 .../data_structures/tagged_pointer.hpp        | 180 +++++-
 libs/libcpp/include/assert_base.hpp           |   2 +-
 libs/libcpp/include/bits_ext.hpp              |   2 +-
 libs/libcpp/include/char_traits.hpp           |   2 +-
 libs/libcpp/include/compare.hpp               |   2 +-
 libs/libcpp/include/concepts.hpp              |   3 +
 libs/libcpp/include/defines.hpp               |   2 +-
 libs/libcpp/include/internal/intervals.hpp    |   2 +-
 libs/libcpp/include/time.hpp                  |  10 +-
 libs/libcpp/include/types.hpp                 |  28 -
 .../include/template/rolled_switch.hpp        |   2 +-
 .../include/template/type_checks.hpp          |   2 +-
 .../include/template/type_list.hpp            |   2 +-
 .../include/template/type_traits.hpp          |   2 +-
 scripts/completions/generate.bash             |   8 +-
 scripts/utils/feature_flag_lib.bash           | 159 +++---
 userspace/build/linker.ld                     |   2 +-
 userspace/programs/hello_world/main.cpp       |  24 +
 170 files changed, 2939 insertions(+), 519 deletions(-)
 create mode 100644 kernel/src/fs/file_descriptor.cpp
 create mode 100644 kernel/src/fs/file_descriptor.hpp
 rename kernel/src/{ => fs}/vfs/error.hpp (100%)
 rename kernel/src/{ => fs}/vfs/fat/fat.hpp (99%)
 rename kernel/src/{ => fs}/vfs/fat/fat12.hpp (99%)
 rename kernel/src/{ => fs}/vfs/fat/fat16.hpp (100%)
 rename kernel/src/{ => fs}/vfs/fat/fat32.hpp (100%)
 rename kernel/src/{ => fs}/vfs/interface.hpp (98%)
 rename kernel/src/{ => fs}/vfs/io/in_memory.hpp (98%)
 rename kernel/src/{ => fs}/vfs/path.hpp (99%)
 rename kernel/src/{ => fs}/vfs/types.hpp (98%)
 create mode 100644 kernel/src/syscalls/calls/fd.hpp
 create mode 100644 kernel/src/syscalls/calls/io.hpp
 create mode 100644 kernel/src/syscalls/calls/panic.hpp
 create mode 100644 kernel/src/syscalls/calls/time.hpp
 create mode 100644 kernel/test/ref_count_test.cpp
 create mode 100644 libs/libc/src/include/sys/calls/fd.h
 create mode 100644 libs/libc/src/include/sys/fd.h
 create mode 100644 libs/libc/src/internal/entry.hpp
 create mode 100644 libs/libc/src/internal/stdio.cpp
 create mode 100644 libs/libc/src/internal/stdio.hpp
 create mode 100644 libs/libcontainers/include/data_structures/ref_count.hpp
 delete mode 100644 libs/libcpp/include/types.hpp

diff --git a/kernel/arch/x86_64/boot/lib/abi/transition_data.hpp b/kernel/arch/x86_64/boot/lib/abi/transition_data.hpp
index 8d9775fe..191d0072 100644
--- a/kernel/arch/x86_64/boot/lib/abi/transition_data.hpp
+++ b/kernel/arch/x86_64/boot/lib/abi/transition_data.hpp
@@ -1,8 +1,8 @@
 #ifndef KERNEL_ARCH_X86_64_BOOT_LIB_ABI_TRANSITION_DATA_HPP_
 #define KERNEL_ARCH_X86_64_BOOT_LIB_ABI_TRANSITION_DATA_HPP_
 
+#include <types.h>
 #include <defines.hpp>
-#include <types.hpp>
 
 #include "mem/pmm.hpp"
 #include "mem/vmm.hpp"
diff --git a/kernel/arch/x86_64/boot/lib/cpu/utils.hpp b/kernel/arch/x86_64/boot/lib/cpu/utils.hpp
index 163e12a7..831b0680 100644
--- a/kernel/arch/x86_64/boot/lib/cpu/utils.hpp
+++ b/kernel/arch/x86_64/boot/lib/cpu/utils.hpp
@@ -1,8 +1,8 @@
 #ifndef KERNEL_ARCH_X86_64_BOOT_LIB_CPU_UTILS_HPP_
 #define KERNEL_ARCH_X86_64_BOOT_LIB_CPU_UTILS_HPP_
 
+#include <types.h>
 #include <defines.hpp>
-#include <types.hpp>
 #include "hw/io.hpp"
 
 /**
diff --git a/kernel/arch/x86_64/boot/lib/elf/elf_64.hpp b/kernel/arch/x86_64/boot/lib/elf/elf_64.hpp
index 10a0cd02..1e9cdadf 100644
--- a/kernel/arch/x86_64/boot/lib/elf/elf_64.hpp
+++ b/kernel/arch/x86_64/boot/lib/elf/elf_64.hpp
@@ -3,9 +3,9 @@
 
 #include <stdint.h>
 
+#include <types.h>
 #include <expected.hpp>
 #include <tuple.hpp>
-#include <types.hpp>
 
 #include "elf/error.hpp"
 
diff --git a/kernel/arch/x86_64/boot/lib/elf/elf_dynamic.hpp b/kernel/arch/x86_64/boot/lib/elf/elf_dynamic.hpp
index 5f0ab2b1..67a6d52c 100644
--- a/kernel/arch/x86_64/boot/lib/elf/elf_dynamic.hpp
+++ b/kernel/arch/x86_64/boot/lib/elf/elf_dynamic.hpp
@@ -1,8 +1,8 @@
 #ifndef KERNEL_ARCH_X86_64_BOOT_LIB_ELF_ELF_DYNAMIC_HPP_
 #define KERNEL_ARCH_X86_64_BOOT_LIB_ELF_ELF_DYNAMIC_HPP_
 
+#include <types.h>
 #include <expected.hpp>
-#include <types.hpp>
 
 #include "elf/error.hpp"
 
diff --git a/kernel/arch/x86_64/boot/lib/hw/io.hpp b/kernel/arch/x86_64/boot/lib/hw/io.hpp
index 528128be..dbf2f79c 100644
--- a/kernel/arch/x86_64/boot/lib/hw/io.hpp
+++ b/kernel/arch/x86_64/boot/lib/hw/io.hpp
@@ -2,8 +2,8 @@
 #define KERNEL_ARCH_X86_64_BOOT_LIB_HW_IO_HPP_
 
 #include <assert.h>
+#include <types.h>
 #include <defines.hpp>
-#include <types.hpp>
 
 FAST_CALL byte inb(const u16 port)
 {
diff --git a/kernel/arch/x86_64/boot/lib/hw/pci.hpp b/kernel/arch/x86_64/boot/lib/hw/pci.hpp
index 2803299f..bae1f519 100644
--- a/kernel/arch/x86_64/boot/lib/hw/pci.hpp
+++ b/kernel/arch/x86_64/boot/lib/hw/pci.hpp
@@ -1,8 +1,8 @@
 #ifndef KERNEL_ARCH_X86_64_BOOT_LIB_HW_PCI_HPP_
 #define KERNEL_ARCH_X86_64_BOOT_LIB_HW_PCI_HPP_
 
+#include <types.h>
 #include <bit.hpp>
-#include <types.hpp>
 #include "hw/io.hpp"
 #include "trace_framework.hpp"
 
diff --git a/kernel/arch/x86_64/boot/lib/hw/serial/qemu.hpp b/kernel/arch/x86_64/boot/lib/hw/serial/qemu.hpp
index c611faa5..cf650ddc 100644
--- a/kernel/arch/x86_64/boot/lib/hw/serial/qemu.hpp
+++ b/kernel/arch/x86_64/boot/lib/hw/serial/qemu.hpp
@@ -1,7 +1,7 @@
 #ifndef KERNEL_ARCH_X86_64_BOOT_LIB_HW_SERIAL_QEMU_HPP_
 #define KERNEL_ARCH_X86_64_BOOT_LIB_HW_SERIAL_QEMU_HPP_
 
-#include <types.hpp>
+#include <types.h>
 
 /**
  * @file serial_qemu.hpp
diff --git a/kernel/arch/x86_64/boot/lib/hw/vga.cpp b/kernel/arch/x86_64/boot/lib/hw/vga.cpp
index 7241a9c9..b6476372 100644
--- a/kernel/arch/x86_64/boot/lib/hw/vga.cpp
+++ b/kernel/arch/x86_64/boot/lib/hw/vga.cpp
@@ -1,6 +1,6 @@
 #include <string.h>
+#include <types.h>
 #include <defines.hpp>
-#include <types.hpp>
 
 #include "hw/vga.hpp"
 
diff --git a/kernel/arch/x86_64/boot/lib/hw/vga.hpp b/kernel/arch/x86_64/boot/lib/hw/vga.hpp
index e1998662..78ce8600 100644
--- a/kernel/arch/x86_64/boot/lib/hw/vga.hpp
+++ b/kernel/arch/x86_64/boot/lib/hw/vga.hpp
@@ -1,7 +1,7 @@
 #ifndef KERNEL_ARCH_X86_64_BOOT_LIB_HW_VGA_HPP_
 #define KERNEL_ARCH_X86_64_BOOT_LIB_HW_VGA_HPP_
 
-#include <types.hpp>
+#include <types.h>
 
 /**
  * @file vga.hpp
diff --git a/kernel/arch/x86_64/boot/lib/mem/page_map.hpp b/kernel/arch/x86_64/boot/lib/mem/page_map.hpp
index 537b195a..792a39c3 100644
--- a/kernel/arch/x86_64/boot/lib/mem/page_map.hpp
+++ b/kernel/arch/x86_64/boot/lib/mem/page_map.hpp
@@ -1,9 +1,9 @@
 #ifndef KERNEL_ARCH_X86_64_BOOT_LIB_MEM_PAGE_MAP_HPP_
 #define KERNEL_ARCH_X86_64_BOOT_LIB_MEM_PAGE_MAP_HPP_
 
+#include <types.h>
 #include <bit.hpp>
 #include <defines.hpp>
-#include <types.hpp>
 
 #include "mem/physical_ptr.hpp"
 
diff --git a/kernel/arch/x86_64/boot/lib/mem/physical_ptr.hpp b/kernel/arch/x86_64/boot/lib/mem/physical_ptr.hpp
index 59a84032..bc1b9bdd 100644
--- a/kernel/arch/x86_64/boot/lib/mem/physical_ptr.hpp
+++ b/kernel/arch/x86_64/boot/lib/mem/physical_ptr.hpp
@@ -1,8 +1,8 @@
 #ifndef KERNEL_ARCH_X86_64_BOOT_LIB_MEM_PHYSICAL_PTR_HPP_
 #define KERNEL_ARCH_X86_64_BOOT_LIB_MEM_PHYSICAL_PTR_HPP_
 
+#include <types.h>
 #include <type_traits.hpp>
-#include <types.hpp>
 
 template <class T>
 class PhysicalPtr
diff --git a/kernel/arch/x86_64/boot/lib/mem/vmm.cpp b/kernel/arch/x86_64/boot/lib/mem/vmm.cpp
index 463873f3..28763507 100644
--- a/kernel/arch/x86_64/boot/lib/mem/vmm.cpp
+++ b/kernel/arch/x86_64/boot/lib/mem/vmm.cpp
@@ -1,7 +1,7 @@
+#include <types.h>
 #include <bit.hpp>
 #include <defines.hpp>
 #include <memory.hpp>
-#include <types.hpp>
 #include "debug_trace.hpp"
 
 #include "mem/error.hpp"
diff --git a/kernel/arch/x86_64/boot/lib/multiboot2/info.hpp b/kernel/arch/x86_64/boot/lib/multiboot2/info.hpp
index 86854e36..4bc30004 100644
--- a/kernel/arch/x86_64/boot/lib/multiboot2/info.hpp
+++ b/kernel/arch/x86_64/boot/lib/multiboot2/info.hpp
@@ -1,11 +1,11 @@
 #ifndef KERNEL_ARCH_X86_64_BOOT_LIB_MULTIBOOT2_INFO_HPP_
 #define KERNEL_ARCH_X86_64_BOOT_LIB_MULTIBOOT2_INFO_HPP_
 
+#include <types.h>
 #include <bit.hpp>
 #include <concepts.hpp>
 #include <defines.hpp>
 #include <expected.hpp>
-#include <types.hpp>
 
 #include "multiboot2/error.hpp"
 #include "multiboot2/multiboot2.h"
diff --git a/kernel/arch/x86_64/boot/lib/multiboot2/memory_map.hpp b/kernel/arch/x86_64/boot/lib/multiboot2/memory_map.hpp
index 2cb73d36..1ea7822f 100644
--- a/kernel/arch/x86_64/boot/lib/multiboot2/memory_map.hpp
+++ b/kernel/arch/x86_64/boot/lib/multiboot2/memory_map.hpp
@@ -1,9 +1,9 @@
 #ifndef KERNEL_ARCH_X86_64_BOOT_LIB_MULTIBOOT2_MEMORY_MAP_HPP_
 #define KERNEL_ARCH_X86_64_BOOT_LIB_MULTIBOOT2_MEMORY_MAP_HPP_
 
+#include <types.h>
 #include <bit.hpp>
 #include <expected.hpp>
-#include <types.hpp>
 
 #include "multiboot2/multiboot2.h"
 
diff --git a/kernel/arch/x86_64/boot/lib/multiboot2/multiboot2.h b/kernel/arch/x86_64/boot/lib/multiboot2/multiboot2.h
index 0e1879c2..602720a1 100644
--- a/kernel/arch/x86_64/boot/lib/multiboot2/multiboot2.h
+++ b/kernel/arch/x86_64/boot/lib/multiboot2/multiboot2.h
@@ -1,7 +1,7 @@
 #ifndef KERNEL_ARCH_X86_64_BOOT_LIB_MULTIBOOT2_MULTIBOOT2_H_
 #define KERNEL_ARCH_X86_64_BOOT_LIB_MULTIBOOT2_MULTIBOOT2_H_
 
-#include <types.hpp>
+#include <types.h>
 
 namespace Multiboot
 {
diff --git a/kernel/arch/x86_64/boot/settings/settings.hpp b/kernel/arch/x86_64/boot/settings/settings.hpp
index d9443451..e6cdd806 100644
--- a/kernel/arch/x86_64/boot/settings/settings.hpp
+++ b/kernel/arch/x86_64/boot/settings/settings.hpp
@@ -1,8 +1,8 @@
 #ifndef KERNEL_ARCH_X86_64_BOOT_SETTINGS_SETTINGS_HPP_
 #define KERNEL_ARCH_X86_64_BOOT_SETTINGS_SETTINGS_HPP_
 
+#include <types.h>
 #include <bit.hpp>
-#include <types.hpp>
 
 static constexpr u64 kKernelVirtualAddressStart = kBitMaskLeft<u64, 33>;
 static constexpr u64 kDirectMemMapAddrStart     = kBitMaskLeft<u64, 17>;
diff --git a/kernel/arch/x86_64/src/abi/boot_args.hpp b/kernel/arch/x86_64/src/abi/boot_args.hpp
index 9d769143..2d44ff2a 100644
--- a/kernel/arch/x86_64/src/abi/boot_args.hpp
+++ b/kernel/arch/x86_64/src/abi/boot_args.hpp
@@ -1,8 +1,8 @@
 #ifndef KERNEL_ARCH_X86_64_SRC_ABI_BOOT_ARGS_HPP_
 #define KERNEL_ARCH_X86_64_SRC_ABI_BOOT_ARGS_HPP_
 
+#include <types.h>
 #include <defines.hpp>
-#include <types.hpp>
 
 struct alignas(64) RawBootArguments {
 };
diff --git a/kernel/arch/x86_64/src/cpu/control_registers.hpp b/kernel/arch/x86_64/src/cpu/control_registers.hpp
index bb45d7ff..b8843205 100644
--- a/kernel/arch/x86_64/src/cpu/control_registers.hpp
+++ b/kernel/arch/x86_64/src/cpu/control_registers.hpp
@@ -1,9 +1,9 @@
 #ifndef KERNEL_ARCH_X86_64_SRC_CPU_CONTROL_REGISTERS_HPP_
 #define KERNEL_ARCH_X86_64_SRC_CPU_CONTROL_REGISTERS_HPP_
 
+#include <types.h>
 #include <concepts.hpp>
 #include <concepts_ext.hpp>
-#include <types.hpp>
 
 /**
  * @file control_registers.hpp
diff --git a/kernel/arch/x86_64/src/cpu/gdt.hpp b/kernel/arch/x86_64/src/cpu/gdt.hpp
index 41e91385..560acda9 100644
--- a/kernel/arch/x86_64/src/cpu/gdt.hpp
+++ b/kernel/arch/x86_64/src/cpu/gdt.hpp
@@ -1,9 +1,9 @@
 #ifndef KERNEL_ARCH_X86_64_SRC_CPU_GDT_HPP_
 #define KERNEL_ARCH_X86_64_SRC_CPU_GDT_HPP_
 
+#include <types.h>
 #include <defines.hpp>
 #include <type_traits.hpp>
-#include <types.hpp>
 
 #include "tss.hpp"
 
diff --git a/kernel/arch/x86_64/src/cpu/msrs.hpp b/kernel/arch/x86_64/src/cpu/msrs.hpp
index 7432dcfa..089ce15d 100644
--- a/kernel/arch/x86_64/src/cpu/msrs.hpp
+++ b/kernel/arch/x86_64/src/cpu/msrs.hpp
@@ -1,7 +1,7 @@
 #ifndef KERNEL_ARCH_X86_64_SRC_CPU_MSRS_HPP_
 #define KERNEL_ARCH_X86_64_SRC_CPU_MSRS_HPP_
 
-#include <types.hpp>
+#include <types.h>
 
 #include <trace_framework.hpp>
 
diff --git a/kernel/arch/x86_64/src/cpu/tss.hpp b/kernel/arch/x86_64/src/cpu/tss.hpp
index 7386a81b..d181ffa4 100644
--- a/kernel/arch/x86_64/src/cpu/tss.hpp
+++ b/kernel/arch/x86_64/src/cpu/tss.hpp
@@ -1,8 +1,8 @@
 #ifndef KERNEL_ARCH_X86_64_SRC_CPU_TSS_HPP_
 #define KERNEL_ARCH_X86_64_SRC_CPU_TSS_HPP_
 
+#include <types.h>
 #include <defines.hpp>
-#include <types.hpp>
 
 namespace cpu
 {
diff --git a/kernel/arch/x86_64/src/cpu/utils.hpp b/kernel/arch/x86_64/src/cpu/utils.hpp
index a5354f0a..51641361 100644
--- a/kernel/arch/x86_64/src/cpu/utils.hpp
+++ b/kernel/arch/x86_64/src/cpu/utils.hpp
@@ -1,10 +1,10 @@
 #ifndef KERNEL_ARCH_X86_64_SRC_CPU_UTILS_HPP_
 #define KERNEL_ARCH_X86_64_SRC_CPU_UTILS_HPP_
 
+#include <types.h>
 #include <bits_ext.hpp>
 #include <defines.hpp>
 #include <template/rolled_switch.hpp>
-#include <types.hpp>
 
 #include "array.hpp"
 #include "include/io.hpp"
diff --git a/kernel/arch/x86_64/src/drivers/apic/io_apic.hpp b/kernel/arch/x86_64/src/drivers/apic/io_apic.hpp
index f6f7efad..febb3b99 100644
--- a/kernel/arch/x86_64/src/drivers/apic/io_apic.hpp
+++ b/kernel/arch/x86_64/src/drivers/apic/io_apic.hpp
@@ -2,8 +2,8 @@
 #define KERNEL_ARCH_X86_64_SRC_DRIVERS_APIC_IO_APIC_HPP_
 
 #include <defines.h>
+#include <types.h>
 #include <defines.hpp>
-#include <types.hpp>
 
 #include <acpi/acpi.hpp>
 #include "include/memory_io.hpp"
diff --git a/kernel/arch/x86_64/src/drivers/cmos/cmos.hpp b/kernel/arch/x86_64/src/drivers/cmos/cmos.hpp
index f3b6a72c..1602807b 100644
--- a/kernel/arch/x86_64/src/drivers/cmos/cmos.hpp
+++ b/kernel/arch/x86_64/src/drivers/cmos/cmos.hpp
@@ -1,8 +1,8 @@
 #ifndef KERNEL_ARCH_X86_64_SRC_DRIVERS_CMOS_CMOS_HPP_
 #define KERNEL_ARCH_X86_64_SRC_DRIVERS_CMOS_CMOS_HPP_
 
+#include <types.h>
 #include <defines.hpp>
-#include <types.hpp>
 #include "include/io.hpp"
 
 static constexpr u64 kCmosAddressPort = 0x70;
diff --git a/kernel/arch/x86_64/src/drivers/cmos/rtc.hpp b/kernel/arch/x86_64/src/drivers/cmos/rtc.hpp
index 75a9c71e..0b9f48c0 100644
--- a/kernel/arch/x86_64/src/drivers/cmos/rtc.hpp
+++ b/kernel/arch/x86_64/src/drivers/cmos/rtc.hpp
@@ -2,7 +2,7 @@
 #define KERNEL_ARCH_X86_64_SRC_DRIVERS_CMOS_RTC_HPP_
 
 #include <time.h>
-#include <types.hpp>
+#include <types.h>
 
 static constexpr u16 kOsYear    = 2025;
 static constexpr u16 kOsCentury = 20;
diff --git a/kernel/arch/x86_64/src/drivers/hpet/hpet.hpp b/kernel/arch/x86_64/src/drivers/hpet/hpet.hpp
index 9253f10c..61332fdd 100644
--- a/kernel/arch/x86_64/src/drivers/hpet/hpet.hpp
+++ b/kernel/arch/x86_64/src/drivers/hpet/hpet.hpp
@@ -2,12 +2,12 @@
 #define KERNEL_ARCH_X86_64_SRC_DRIVERS_HPET_HPET_HPP_
 
 #include <stdlib.h>
+#include <types.h>
 #include <uacpi/acpi.h>
 #include <array.hpp>
 #include <data_structures/bit_array.hpp>
 #include <time.hpp>
 #include <todo.hpp>
-#include <types.hpp>
 
 #include <mem/types.hpp>
 
diff --git a/kernel/arch/x86_64/src/drivers/pic8259/pic8259.cpp b/kernel/arch/x86_64/src/drivers/pic8259/pic8259.cpp
index e8f9576f..813870d6 100644
--- a/kernel/arch/x86_64/src/drivers/pic8259/pic8259.cpp
+++ b/kernel/arch/x86_64/src/drivers/pic8259/pic8259.cpp
@@ -1,7 +1,7 @@
 
 /* internal includes */
 #include "drivers/pic8259/pic8259.hpp"
-#include <types.hpp>
+#include <types.h>
 #include "trace_framework.hpp"
 
 /**
diff --git a/kernel/arch/x86_64/src/drivers/pic8259/pic8259.hpp b/kernel/arch/x86_64/src/drivers/pic8259/pic8259.hpp
index d5235047..4e1f8773 100644
--- a/kernel/arch/x86_64/src/drivers/pic8259/pic8259.hpp
+++ b/kernel/arch/x86_64/src/drivers/pic8259/pic8259.hpp
@@ -8,7 +8,7 @@
 #include "interrupts/interrupt_types.hpp"
 #include "trace_framework.hpp"
 
-#include <types.hpp>
+#include <types.h>
 
 /**
  * @file pic8259.hpp
diff --git a/kernel/arch/x86_64/src/drivers/pit/pit.hpp b/kernel/arch/x86_64/src/drivers/pit/pit.hpp
index 67f9ea64..bc9b979e 100644
--- a/kernel/arch/x86_64/src/drivers/pit/pit.hpp
+++ b/kernel/arch/x86_64/src/drivers/pit/pit.hpp
@@ -1,8 +1,8 @@
 #ifndef KERNEL_ARCH_X86_64_SRC_DRIVERS_PIT_PIT_HPP_
 #define KERNEL_ARCH_X86_64_SRC_DRIVERS_PIT_PIT_HPP_
 
+#include <types.h>
 #include <defines.hpp>
-#include <types.hpp>
 #include "include/io.hpp"
 
 namespace pit
diff --git a/kernel/arch/x86_64/src/drivers/serial/qemu.hpp b/kernel/arch/x86_64/src/drivers/serial/qemu.hpp
index bc3f03ee..6e57849f 100644
--- a/kernel/arch/x86_64/src/drivers/serial/qemu.hpp
+++ b/kernel/arch/x86_64/src/drivers/serial/qemu.hpp
@@ -1,7 +1,7 @@
 #ifndef KERNEL_ARCH_X86_64_SRC_DRIVERS_SERIAL_QEMU_HPP_
 #define KERNEL_ARCH_X86_64_SRC_DRIVERS_SERIAL_QEMU_HPP_
 
-#include <types.hpp>
+#include <types.h>
 
 /**
  * @file serial_qemu.hpp
diff --git a/kernel/arch/x86_64/src/drivers/tsc/tsc.hpp b/kernel/arch/x86_64/src/drivers/tsc/tsc.hpp
index d4297252..4158bbcb 100644
--- a/kernel/arch/x86_64/src/drivers/tsc/tsc.hpp
+++ b/kernel/arch/x86_64/src/drivers/tsc/tsc.hpp
@@ -2,9 +2,9 @@
 #define KERNEL_ARCH_X86_64_SRC_DRIVERS_TSC_TSC_HPP_
 
 #include <cpuid.h>
+#include <types.h>
 #include <bit.hpp>
 #include <todo.hpp>
-#include <types.hpp>
 #include "cpu/control_registers.hpp"
 #include "cpu/msrs.hpp"
 #include "trace_framework.hpp"
diff --git a/kernel/arch/x86_64/src/hal/impl/constants.hpp b/kernel/arch/x86_64/src/hal/impl/constants.hpp
index bfe5ed17..fbb12769 100644
--- a/kernel/arch/x86_64/src/hal/impl/constants.hpp
+++ b/kernel/arch/x86_64/src/hal/impl/constants.hpp
@@ -1,10 +1,10 @@
 #ifndef KERNEL_ARCH_X86_64_SRC_HAL_IMPL_CONSTANTS_HPP_
 #define KERNEL_ARCH_X86_64_SRC_HAL_IMPL_CONSTANTS_HPP_
 
+#include <types.h>
 #include <bit.hpp>
 #include <data_structures/array_structures.hpp>
 #include <todo.hpp>
-#include <types.hpp>
 
 namespace arch
 {
diff --git a/kernel/arch/x86_64/src/hal/impl/core.hpp b/kernel/arch/x86_64/src/hal/impl/core.hpp
index 053840af..0611d193 100644
--- a/kernel/arch/x86_64/src/hal/impl/core.hpp
+++ b/kernel/arch/x86_64/src/hal/impl/core.hpp
@@ -4,9 +4,7 @@
 #include <hal/api/core.hpp>
 #include "cpu/gdt.hpp"
 #include "cpu/msrs.hpp"
-#include "cpu/utils.hpp"
 #include "drivers/apic/local_apic.hpp"
-#include "scheduling/thread.hpp"
 
 namespace arch
 {
diff --git a/kernel/arch/x86_64/src/hal/impl/interrupt_params.hpp b/kernel/arch/x86_64/src/hal/impl/interrupt_params.hpp
index 10efd68e..51591b7e 100644
--- a/kernel/arch/x86_64/src/hal/impl/interrupt_params.hpp
+++ b/kernel/arch/x86_64/src/hal/impl/interrupt_params.hpp
@@ -2,8 +2,8 @@
 #define KERNEL_ARCH_X86_64_SRC_HAL_IMPL_INTERRUPT_PARAMS_HPP_
 
 #include <defines.h>
+#include <types.h>
 #include <hal/api/interrupts_params.hpp>
-#include <types.hpp>
 
 struct PACK IsrRegisters {
     uint64_t rax;
diff --git a/kernel/arch/x86_64/src/hal/impl/kernel.hpp b/kernel/arch/x86_64/src/hal/impl/kernel.hpp
index bbffc51e..1a0ac8af 100644
--- a/kernel/arch/x86_64/src/hal/impl/kernel.hpp
+++ b/kernel/arch/x86_64/src/hal/impl/kernel.hpp
@@ -2,8 +2,8 @@
 #define KERNEL_ARCH_X86_64_SRC_HAL_IMPL_KERNEL_HPP_
 
 #include <defines.h>
+#include <types.h>
 #include <hal/api/boot_args.hpp>
-#include <types.hpp>
 
 namespace arch
 {
diff --git a/kernel/arch/x86_64/src/hal/impl/spinlock.hpp b/kernel/arch/x86_64/src/hal/impl/spinlock.hpp
index a160a861..a410e4a7 100644
--- a/kernel/arch/x86_64/src/hal/impl/spinlock.hpp
+++ b/kernel/arch/x86_64/src/hal/impl/spinlock.hpp
@@ -4,11 +4,9 @@
 #include <hal/api/spinlock.hpp>
 
 #include <autogen/feature_flags.h>
-#include <hal/constants.hpp>
-#include <types.hpp>
-#include "include/memory_io.hpp"
-
+#include <types.h>
 #include "hal/core.hpp"
+#include "include/memory_io.hpp"
 
 namespace arch
 {
diff --git a/kernel/arch/x86_64/src/hal/impl/tasks.hpp b/kernel/arch/x86_64/src/hal/impl/tasks.hpp
index 3a33809e..a2e37a2b 100644
--- a/kernel/arch/x86_64/src/hal/impl/tasks.hpp
+++ b/kernel/arch/x86_64/src/hal/impl/tasks.hpp
@@ -2,8 +2,8 @@
 #define KERNEL_ARCH_X86_64_SRC_HAL_IMPL_TASKS_HPP_
 
 #include <string.h>
+#include <types.h>
 #include <defines.hpp>
-#include <types.hpp>
 
 #include "hal/api/tasks.hpp"
 
diff --git a/kernel/arch/x86_64/src/hal/impl/timers.hpp b/kernel/arch/x86_64/src/hal/impl/timers.hpp
index 38eb93fe..4f759805 100644
--- a/kernel/arch/x86_64/src/hal/impl/timers.hpp
+++ b/kernel/arch/x86_64/src/hal/impl/timers.hpp
@@ -8,7 +8,7 @@
 
 namespace arch
 {
-WRAP_CALL time_t QuerySystemTime(const timezone &tz)
+WRAP_CALL time_t QuerySystemTime(const Timezone &tz)
 {
     static constexpr size_t kBuffSize = 64;
     [[maybe_unused]] char buffer[kBuffSize];
diff --git a/kernel/arch/x86_64/src/hal/impl/types.hpp b/kernel/arch/x86_64/src/hal/impl/types.hpp
index 21245078..a54ba50e 100644
--- a/kernel/arch/x86_64/src/hal/impl/types.hpp
+++ b/kernel/arch/x86_64/src/hal/impl/types.hpp
@@ -1,7 +1,7 @@
 #ifndef KERNEL_ARCH_X86_64_SRC_HAL_IMPL_TYPES_HPP_
 #define KERNEL_ARCH_X86_64_SRC_HAL_IMPL_TYPES_HPP_
 
-#include <types.hpp>
+#include <types.h>
 
 namespace arch
 {
diff --git a/kernel/arch/x86_64/src/include/io.hpp b/kernel/arch/x86_64/src/include/io.hpp
index 54c40082..ea0be15d 100644
--- a/kernel/arch/x86_64/src/include/io.hpp
+++ b/kernel/arch/x86_64/src/include/io.hpp
@@ -2,8 +2,8 @@
 #define KERNEL_ARCH_X86_64_SRC_INCLUDE_IO_HPP_
 
 #include <assert.h>
+#include <types.h>
 #include <defines.hpp>
-#include <types.hpp>
 
 FAST_CALL byte inb(const u16 port)
 {
diff --git a/kernel/arch/x86_64/src/include/models/memory_span.hpp b/kernel/arch/x86_64/src/include/models/memory_span.hpp
index 19810bb0..f36b5db0 100644
--- a/kernel/arch/x86_64/src/include/models/memory_span.hpp
+++ b/kernel/arch/x86_64/src/include/models/memory_span.hpp
@@ -1,7 +1,7 @@
 #ifndef KERNEL_ARCH_X86_64_SRC_INCLUDE_MODELS_MEMORY_SPAN_HPP_
 #define KERNEL_ARCH_X86_64_SRC_INCLUDE_MODELS_MEMORY_SPAN_HPP_
 
-#include <types.hpp>
+#include <types.h>
 class MemorySpan
 {
     public:
diff --git a/kernel/arch/x86_64/src/include/multiboot2/memory_map.hpp b/kernel/arch/x86_64/src/include/multiboot2/memory_map.hpp
index 0b8cfc39..3708d420 100644
--- a/kernel/arch/x86_64/src/include/multiboot2/memory_map.hpp
+++ b/kernel/arch/x86_64/src/include/multiboot2/memory_map.hpp
@@ -1,8 +1,8 @@
 #ifndef KERNEL_ARCH_X86_64_SRC_INCLUDE_MULTIBOOT2_MEMORY_MAP_HPP_
 #define KERNEL_ARCH_X86_64_SRC_INCLUDE_MULTIBOOT2_MEMORY_MAP_HPP_
 
+#include <types.h>
 #include <bit.hpp>
-#include <types.hpp>
 #include "include/models/memory_span.hpp"
 #include "include/multiboot2/multiboot2.h"
 
diff --git a/kernel/arch/x86_64/src/include/multiboot2/multiboot2.h b/kernel/arch/x86_64/src/include/multiboot2/multiboot2.h
index f4df0fc8..33e02c9c 100644
--- a/kernel/arch/x86_64/src/include/multiboot2/multiboot2.h
+++ b/kernel/arch/x86_64/src/include/multiboot2/multiboot2.h
@@ -1,7 +1,7 @@
 #ifndef KERNEL_ARCH_X86_64_SRC_INCLUDE_MULTIBOOT2_MULTIBOOT2_H_
 #define KERNEL_ARCH_X86_64_SRC_INCLUDE_MULTIBOOT2_MULTIBOOT2_H_
 
-#include <types.hpp>
+#include <types.h>
 
 namespace Multiboot
 {
diff --git a/kernel/arch/x86_64/src/include/multiboot2/multiboot_info.hpp b/kernel/arch/x86_64/src/include/multiboot2/multiboot_info.hpp
index 1fab02cd..832ca3e0 100644
--- a/kernel/arch/x86_64/src/include/multiboot2/multiboot_info.hpp
+++ b/kernel/arch/x86_64/src/include/multiboot2/multiboot_info.hpp
@@ -1,9 +1,9 @@
 #ifndef KERNEL_ARCH_X86_64_SRC_INCLUDE_MULTIBOOT2_MULTIBOOT_INFO_HPP_
 #define KERNEL_ARCH_X86_64_SRC_INCLUDE_MULTIBOOT2_MULTIBOOT_INFO_HPP_
 
+#include <types.h>
 #include <bit.hpp>
 #include <concepts.hpp>
-#include <types.hpp>
 
 #include <todo.hpp>
 #include "include/models/memory_span.hpp"
diff --git a/kernel/arch/x86_64/src/include/pci.hpp b/kernel/arch/x86_64/src/include/pci.hpp
index a028ff18..29dae546 100644
--- a/kernel/arch/x86_64/src/include/pci.hpp
+++ b/kernel/arch/x86_64/src/include/pci.hpp
@@ -1,8 +1,8 @@
 #ifndef KERNEL_ARCH_X86_64_SRC_INCLUDE_PCI_HPP_
 #define KERNEL_ARCH_X86_64_SRC_INCLUDE_PCI_HPP_
 
+#include <types.h>
 #include <bit.hpp>
-#include <types.hpp>
 #include "include/io.hpp"
 #include "trace_framework.hpp"
 
diff --git a/kernel/arch/x86_64/src/interrupts/idt.hpp b/kernel/arch/x86_64/src/interrupts/idt.hpp
index 7d9ef79c..6ba809a8 100644
--- a/kernel/arch/x86_64/src/interrupts/idt.hpp
+++ b/kernel/arch/x86_64/src/interrupts/idt.hpp
@@ -3,7 +3,7 @@
 
 #include <defines.hpp>
 #include "interrupts/interrupt_types.hpp"
-#include "types.hpp"
+#include "types.h"
 
 // ------------------------------
 // Crucial defines
diff --git a/kernel/arch/x86_64/src/interrupts/idt.nasm b/kernel/arch/x86_64/src/interrupts/idt.nasm
index cb5d02d0..2a94a9ce 100644
--- a/kernel/arch/x86_64/src/interrupts/idt.nasm
+++ b/kernel/arch/x86_64/src/interrupts/idt.nasm
@@ -143,9 +143,11 @@ isr_wrapper_128:  ; Syscall interrupt (128)
 
 .return:
 
+    push rax                         ; Save RAX (syscall return value).
     call cdecl_SetKernelGs
     swapgs
 
+    pop rax                          ; Restore RAX.
     pop_sysv_regs_without_rax        ; Restore registers except RAX.
     add rsp, _sysv_reg_size          ; Deallocate register save space.
     iretq                            ; Return from interrupt.
diff --git a/kernel/arch/x86_64/src/mem/page_map.hpp b/kernel/arch/x86_64/src/mem/page_map.hpp
index f0988206..6e971564 100644
--- a/kernel/arch/x86_64/src/mem/page_map.hpp
+++ b/kernel/arch/x86_64/src/mem/page_map.hpp
@@ -1,9 +1,9 @@
 #ifndef KERNEL_ARCH_X86_64_SRC_MEM_PAGE_MAP_HPP_
 #define KERNEL_ARCH_X86_64_SRC_MEM_PAGE_MAP_HPP_
 
+#include <types.h>
 #include <bit.hpp>
 #include <defines.hpp>
-#include <types.hpp>
 
 #include <mem/types.hpp>
 
diff --git a/kernel/arch/x86_64/src/scheduling/scheduling.cpp b/kernel/arch/x86_64/src/scheduling/scheduling.cpp
index 06ccbe5c..3c112f24 100644
--- a/kernel/arch/x86_64/src/scheduling/scheduling.cpp
+++ b/kernel/arch/x86_64/src/scheduling/scheduling.cpp
@@ -1,4 +1,5 @@
 #include "modules/scheduling.hpp"
+#include "modules/memory.hpp"
 
 #include <cpu/control_registers.hpp>
 #include <modules/memory.hpp>
@@ -9,6 +10,8 @@
 #include "mem/virt/addr_space.hpp"
 #include "scheduling/thread.hpp"
 
+#include <hal/debug_terminal.hpp>
+
 // ------------------------------
 // statics
 // ------------------------------
diff --git a/kernel/src/acpi/acpi.cpp b/kernel/src/acpi/acpi.cpp
index ff1a5dcf..9d0abe77 100644
--- a/kernel/src/acpi/acpi.cpp
+++ b/kernel/src/acpi/acpi.cpp
@@ -18,7 +18,7 @@ void ACPI::ACPIController::EarlyInit(const BootArguments &args)
     );
 
     RsdpAddress_ = args.rsdp;
-    DEBUG_INFO_ACPI("RSDP address: 0x%016p", RsdpAddress_);
+    DEBUG_INFO_ACPI("RSDP address: 0x%016X", RsdpAddress_);
 
     /* Load all tables, bring the event subsystem online, and enter ACPI mode */
     uacpi_status ret = uacpi_initialize(0);
diff --git a/kernel/src/acpi/acpi_battery.hpp b/kernel/src/acpi/acpi_battery.hpp
index 53e9fa9f..97b45123 100644
--- a/kernel/src/acpi/acpi_battery.hpp
+++ b/kernel/src/acpi/acpi_battery.hpp
@@ -1,9 +1,9 @@
 #ifndef KERNEL_SRC_ACPI_ACPI_BATTERY_HPP_
 #define KERNEL_SRC_ACPI_ACPI_BATTERY_HPP_
 
+#include <types.h>
 #include <uacpi/tables.h>
 #include <defines.hpp>
-#include <types.hpp>
 
 namespace ACPI
 {
diff --git a/kernel/src/acpi/acpi_cpu.hpp b/kernel/src/acpi/acpi_cpu.hpp
index 388ad43a..c06f074d 100644
--- a/kernel/src/acpi/acpi_cpu.hpp
+++ b/kernel/src/acpi/acpi_cpu.hpp
@@ -1,8 +1,8 @@
 #ifndef KERNEL_SRC_ACPI_ACPI_CPU_HPP_
 #define KERNEL_SRC_ACPI_ACPI_CPU_HPP_
 
+#include <types.h>
 #include <defines.hpp>
-#include <types.hpp>
 
 namespace ACPI
 {
diff --git a/kernel/src/acpi/acpi_device.hpp b/kernel/src/acpi/acpi_device.hpp
index 5e226ed9..609d00fe 100644
--- a/kernel/src/acpi/acpi_device.hpp
+++ b/kernel/src/acpi/acpi_device.hpp
@@ -1,8 +1,8 @@
 #ifndef KERNEL_SRC_ACPI_ACPI_DEVICE_HPP_
 #define KERNEL_SRC_ACPI_ACPI_DEVICE_HPP_
 
+#include <types.h>
 #include <defines.hpp>
-#include <types.hpp>
 
 namespace ACPI
 {
diff --git a/kernel/src/acpi/acpi_interrupt.hpp b/kernel/src/acpi/acpi_interrupt.hpp
index 3ea29acf..3e4b0a87 100644
--- a/kernel/src/acpi/acpi_interrupt.hpp
+++ b/kernel/src/acpi/acpi_interrupt.hpp
@@ -1,8 +1,8 @@
 #ifndef KERNEL_SRC_ACPI_ACPI_INTERRUPT_HPP_
 #define KERNEL_SRC_ACPI_ACPI_INTERRUPT_HPP_
 
+#include <types.h>
 #include <defines.hpp>
-#include <types.hpp>
 
 namespace ACPI
 {
diff --git a/kernel/src/acpi/acpi_power.hpp b/kernel/src/acpi/acpi_power.hpp
index bc9a3d41..d9b47f07 100644
--- a/kernel/src/acpi/acpi_power.hpp
+++ b/kernel/src/acpi/acpi_power.hpp
@@ -1,8 +1,8 @@
 #ifndef KERNEL_SRC_ACPI_ACPI_POWER_HPP_
 #define KERNEL_SRC_ACPI_ACPI_POWER_HPP_
 
+#include <types.h>
 #include <defines.hpp>
-#include <types.hpp>
 
 namespace ACPI
 {
diff --git a/kernel/src/acpi/acpi_thermal.hpp b/kernel/src/acpi/acpi_thermal.hpp
index 61edad8e..ece56f20 100644
--- a/kernel/src/acpi/acpi_thermal.hpp
+++ b/kernel/src/acpi/acpi_thermal.hpp
@@ -1,8 +1,8 @@
 #ifndef KERNEL_SRC_ACPI_ACPI_THERMAL_HPP_
 #define KERNEL_SRC_ACPI_ACPI_THERMAL_HPP_
 
+#include <types.h>
 #include <defines.hpp>
-#include <types.hpp>
 
 namespace ACPI
 {
diff --git a/kernel/src/acpi/osl.tpp b/kernel/src/acpi/osl.tpp
index 2e5174f1..e66c272d 100644
--- a/kernel/src/acpi/osl.tpp
+++ b/kernel/src/acpi/osl.tpp
@@ -8,20 +8,23 @@
 // TODO SHOULD BE THROUGH HAL
 #include <include/io.hpp>
 #include <include/pci.hpp>
+#include <mem/types.hpp>
 
 template <concepts_ext::IoT T>
 uacpi_status uacpi_kernel_pci_read(uacpi_handle device, uacpi_size offset, T *value)
 {
-    const uacpi_pci_address addr = *static_cast<uacpi_pci_address *>(device);
-    *value                       = pci::read<T>(addr.bus, addr.device, addr.function, offset);
+    using namespace Mem;
+    const VPtr<uacpi_pci_address> addr = PhysToVirt(static_cast<PPtr<uacpi_pci_address>>(device));
+    *value = pci::read<T>(addr->bus, addr->device, addr->function, offset);
     return UACPI_STATUS_OK;
 }
 
 template <concepts_ext::IoT T>
 uacpi_status uacpi_kernel_pci_write(uacpi_handle device, uacpi_size offset, T value)
 {
-    const uacpi_pci_address addr = *static_cast<uacpi_pci_address *>(device);
-    pci::write<T>(addr.bus, addr.device, addr.function, offset, value);
+    using namespace Mem;
+    const VPtr<uacpi_pci_address> addr = PhysToVirt(static_cast<PPtr<uacpi_pci_address>>(device));
+    pci::write<T>(addr->bus, addr->device, addr->function, offset, value);
     return UACPI_STATUS_OK;
 }
 
diff --git a/kernel/src/constants.hpp b/kernel/src/constants.hpp
index 6e8d82e0..aa17be7e 100644
--- a/kernel/src/constants.hpp
+++ b/kernel/src/constants.hpp
@@ -1,7 +1,7 @@
 #ifndef KERNEL_SRC_CONSTANTS_HPP_
 #define KERNEL_SRC_CONSTANTS_HPP_
 
-#include <types.hpp>
+#include "types.h"
 
 static constexpr u16 kMaxProcesses    = 4096;
 static constexpr u32 kMaxThreads      = kMaxProcesses * 2;
diff --git a/kernel/src/demos/donut.hpp b/kernel/src/demos/donut.hpp
index e2c75be7..d27b609a 100644
--- a/kernel/src/demos/donut.hpp
+++ b/kernel/src/demos/donut.hpp
@@ -2,11 +2,11 @@
 #define KERNEL_SRC_DEMOS_DONUT_HPP_
 
 #include <stdio.h>
+#include <types.h>
 #include <algorithm.hpp>
 #include <memory.hpp>
 #include <span.hpp>
 #include <string.hpp>
-#include <types.hpp>
 
 #include "graphics/color.hpp"
 #include "graphics/font/psf2_font.hpp"
diff --git a/kernel/src/drivers/input/ps2_keyboard.hpp b/kernel/src/drivers/input/ps2_keyboard.hpp
index bf9dc6fc..15806463 100644
--- a/kernel/src/drivers/input/ps2_keyboard.hpp
+++ b/kernel/src/drivers/input/ps2_keyboard.hpp
@@ -1,9 +1,9 @@
 #ifndef KERNEL_SRC_DRIVERS_INPUT_PS2_KEYBOARD_HPP_
 #define KERNEL_SRC_DRIVERS_INPUT_PS2_KEYBOARD_HPP_
 
+#include <types.h>
 #include <drivers/input/keyboard.hpp>
 #include <io/register.hpp>
-#include <types.hpp>
 
 namespace Drivers::Input
 {
diff --git a/kernel/src/drivers/serial/uart_16550.hpp b/kernel/src/drivers/serial/uart_16550.hpp
index 847a6c08..c455a896 100644
--- a/kernel/src/drivers/serial/uart_16550.hpp
+++ b/kernel/src/drivers/serial/uart_16550.hpp
@@ -1,9 +1,9 @@
 #ifndef KERNEL_SRC_DRIVERS_SERIAL_UART_16550_HPP_
 #define KERNEL_SRC_DRIVERS_SERIAL_UART_16550_HPP_
 
+#include <types.h>
 #include <io/register.hpp>
 #include <io/stream.hpp>
-#include <types.hpp>
 
 namespace Drivers::Serial
 {
diff --git a/kernel/src/fs/file_descriptor.cpp b/kernel/src/fs/file_descriptor.cpp
new file mode 100644
index 00000000..5e018b9f
--- /dev/null
+++ b/kernel/src/fs/file_descriptor.cpp
@@ -0,0 +1,523 @@
+#include "file_descriptor.hpp"
+#include "modules/scheduling.hpp"
+
+#include <mutex.hpp>
+#include <vfs.hpp>
+
+#include "scheduling/processes.hpp"
+
+namespace
+{
+
+bool IsValidFd(fd_t fd) { return fd >= 0 && static_cast<size_t>(fd) < Fs::kMaxFdsPerProcess; }
+
+}  // namespace
+
+namespace Fs
+{
+
+// ============================================================================
+// FdTable Implementation
+// ============================================================================
+
+FdResult<fd_t> FdTable::AllocateFd(OpenFileEntry *global_entry)
+{
+    ASSERT_NOT_NULL(global_entry);
+
+    std::lock_guard lock(lock_);
+
+    for (size_t i = 0; i < kMaxFdsPerProcess; ++i) {
+        if (entries_[i] == nullptr) {
+            entries_[i] = global_entry;
+            global_entry->AddRef();
+            open_count_++;
+            return static_cast<fd_t>(i);
+        }
+    }
+
+    return std::unexpected(FdError::kFdTableFull);
+}
+
+FdResult<fd_t> FdTable::AllocateFdAt(OpenFileEntry *global_entry, fd_t fd)
+{
+    ASSERT_NOT_NULL(global_entry);
+
+    RET_UNEXPECTED_IF(!IsValidFd(fd), FdError::kInvalidFd);
+
+    std::lock_guard lock(lock_);
+
+    RET_UNEXPECTED_IF(entries_[fd] != nullptr, FdError::kBadFileDescriptor);
+
+    entries_[fd] = global_entry;
+    global_entry->AddRef();
+    open_count_++;
+
+    return fd;
+}
+
+FdResult<> FdTable::FreeFd(fd_t fd)
+{
+    RET_UNEXPECTED_IF(!IsValidFd(fd), FdError::kInvalidFd);
+
+    std::lock_guard lock(lock_);
+
+    if (fd <= kStderrFd && entries_[fd] != nullptr && entries_[fd]->IsPipe()) {
+        return std::unexpected(FdError::kPermissionDenied);
+    }
+
+    RET_UNEXPECTED_IF(entries_[fd] == nullptr, FdError::kNotOpen);
+
+    entries_[fd] = nullptr;
+    open_count_--;
+
+    return {};
+}
+
+OpenFileEntry *FdTable::GetEntry(fd_t fd)
+{
+    if (!IsValidFd(fd)) {
+        return nullptr;
+    }
+    return entries_[fd];
+}
+
+const OpenFileEntry *FdTable::GetEntry(fd_t fd) const
+{
+    if (!IsValidFd(fd)) {
+        return nullptr;
+    }
+    return entries_[fd];
+}
+
+FdResult<fd_t> FdTable::DuplicateFd(fd_t fd)
+{
+    RET_UNEXPECTED_IF(!IsValidFd(fd), FdError::kInvalidFd);
+
+    std::lock_guard lock(lock_);
+
+    RET_UNEXPECTED_IF(entries_[fd] == nullptr, FdError::kBadFileDescriptor);
+
+    for (size_t i = 0; i < kMaxFdsPerProcess; ++i) {
+        if (entries_[i] == nullptr) {
+            entries_[i] = entries_[fd];
+            entries_[i]->AddRef();
+            open_count_++;
+
+            return static_cast<fd_t>(i);
+        }
+    }
+
+    return std::unexpected(FdError::kFdTableFull);
+}
+
+FdResult<fd_t> FdTable::DuplicateFdTo(fd_t old_fd, fd_t new_fd)
+{
+    RET_UNEXPECTED_IF(!IsValidFd(old_fd), FdError::kInvalidFd);
+    RET_UNEXPECTED_IF(!IsValidFd(new_fd), FdError::kInvalidFd);
+
+    std::lock_guard lock(lock_);
+
+    RET_UNEXPECTED_IF(entries_[old_fd] == nullptr, FdError::kBadFileDescriptor);
+
+    // If new_fd is already open, close it first
+    if (entries_[new_fd] != nullptr) {
+        entries_[new_fd] = nullptr;
+        open_count_--;
+    }
+
+    entries_[new_fd] = entries_[old_fd];
+    entries_[new_fd]->AddRef();
+    open_count_++;
+
+    return new_fd;
+}
+
+// ============================================================================
+// FileTable Implementation
+// ============================================================================
+
+FdResult<File *> FileTable::GetOrCreate(const vfs::Path &path)
+{
+    RET_UNEXPECTED_IF(path.IsEmpty(), FdError::kInvalidArgument);
+
+    std::lock_guard lock(lock_);
+
+    File *existing = Find(path);
+    if (existing != nullptr) {
+        return existing;
+    }
+
+    size_t idx = files_.Allocate();
+    RET_UNEXPECTED_IF(idx == std::numeric_limits<size_t>::max(), FdError::kIoError);
+
+    File *file = files_.Get(idx);
+    ASSERT_NOT_NULL(file);
+
+    new (file) File();
+
+    // TODO: Get from VFS when implemented
+    file->size = 0;
+    file->mode = 0;
+    file->path = path;
+
+    count_++;
+    return file;
+}
+
+FdResult<> FileTable::Release(File *file)
+{
+    if (file == nullptr) {
+        return std::unexpected(FdError::kInvalidArgument);
+    }
+
+    std::lock_guard lock(lock_);
+
+    if (!file->HasRefs()) {
+        return std::unexpected(FdError::kNotOpen);
+    }
+
+    u32 old_count = file->GetRefCount();
+    file->Release();
+
+    if (old_count == 1) {
+        for (size_t i = 0; i < kMaxActiveFiles; ++i) {
+            if (files_.Get(i) == file) {
+                file->~File();
+                files_.Free(i);
+                count_--;
+                return {};
+            }
+        }
+        return std::unexpected(FdError::kInvalidArgument);
+    }
+
+    return {};
+}
+
+File *FileTable::Find(const vfs::Path &path)
+{
+    for (size_t i = 0; i < kMaxActiveFiles; ++i) {
+        File *file = files_.Get(i);
+        if (file != nullptr && file->HasRefs() && file->path == path) {
+            return file;
+        }
+    }
+    return nullptr;
+}
+
+const File *FileTable::Find(const vfs::Path &path) const
+{
+    for (size_t i = 0; i < kMaxActiveFiles; ++i) {
+        const File *file = files_.Get(i);
+        if (file != nullptr && file->HasRefs() && file->path == path) {
+            return file;
+        }
+    }
+    return nullptr;
+}
+// ============================================================================
+// OpenFileTable Implementation
+// ============================================================================
+
+OpenFileTable::OpenFileTable() : open_count_(0) {}
+
+OpenFileTable::~OpenFileTable()
+{
+    std::lock_guard lock(lock_);
+
+    for (size_t i = 0; i < kMaxOpenFiles; ++i) {
+        OpenFileEntry *entry = entries_.Get(i);
+        if (entry != nullptr && entry->HasRefs()) {
+            entry->handle = {};
+            entry->~OpenFileEntry();
+            entries_.Free(i);
+        }
+    }
+}
+
+FdResult<OpenFileEntry *> OpenFileTable::OpenFile(File *file, OpenMode flags)
+{
+    if (file == nullptr) {
+        return std::unexpected(FdError::kInvalidArgument);
+    }
+
+    std::lock_guard lock(lock_);
+
+    size_t idx = entries_.Allocate();
+    if (idx == std::numeric_limits<size_t>::max()) {
+        return std::unexpected(FdError::kIoError);
+    }
+
+    OpenFileEntry *entry = entries_.Get(idx);
+    ASSERT_NOT_NULL(entry);
+
+    new (entry) OpenFileEntry();
+
+    entry->handle    = FileHandle::Wrap(file);
+    entry->flags     = static_cast<u32>(flags);
+    entry->offset    = 0;
+    entry->is_append = HasMode(flags, OpenMode::kAppend);
+
+    open_count_++;
+    return entry;
+}
+
+FdResult<OpenFileEntry *> OpenFileTable::OpenPipe(IO::Pipe<kStdioBufferSize> &pipe)
+{
+    std::lock_guard lock(lock_);
+
+    size_t idx = entries_.Allocate();
+    if (idx == std::numeric_limits<size_t>::max()) {
+        return std::unexpected(FdError::kIoError);
+    }
+
+    OpenFileEntry *entry = entries_.Get(idx);
+    ASSERT_NOT_NULL(entry);
+
+    new (entry) OpenFileEntry();
+
+    entry->handle    = FileHandle::Wrap(&pipe);
+    entry->flags     = static_cast<u32>(OpenMode::kReadWrite);
+    entry->offset    = 0;
+    entry->is_append = false;
+
+    open_count_++;
+    return entry;
+}
+
+FdResult<> OpenFileTable::CloseFile(OpenFileEntry *entry)
+{
+    if (entry == nullptr) {
+        return std::unexpected(FdError::kInvalidArgument);
+    }
+
+    std::lock_guard lock(lock_);
+
+    if (!entry->HasRefs()) {
+        return std::unexpected(FdError::kAlreadyClosed);
+    }
+
+    u32 old_count = entry->GetRefCount();
+    entry->Release();
+
+    if (old_count == 1) {
+        entry->handle = {};
+
+        for (size_t i = 0; i < kMaxOpenFiles; ++i) {
+            if (entries_.Get(i) == entry) {
+                entry->~OpenFileEntry();
+                entries_.Free(i);
+                open_count_--;
+                return {};
+            }
+        }
+        return std::unexpected(FdError::kInvalidArgument);
+    }
+
+    return {};
+}
+
+FdResult<u64> OpenFileTable::GetOffset(const OpenFileEntry *entry) const
+{
+    if (entry == nullptr) {
+        return std::unexpected(FdError::kInvalidArgument);
+    }
+
+    std::lock_guard lock(lock_);
+
+    return entry->offset;
+}
+
+FdResult<> OpenFileTable::SetOffset(OpenFileEntry *entry, u64 offset) const
+{
+    if (entry == nullptr) {
+        return std::unexpected(FdError::kInvalidArgument);
+    }
+
+    std::lock_guard lock(lock_);
+
+    entry->offset = offset;
+    return {};
+}
+
+// ============================================================================
+// FdManager Implementation
+// ============================================================================
+
+FdManager::FdManager() = default;
+
+FdManager::~FdManager() = default;
+
+FdResult<fd_t> FdManager::Open(const vfs::Path &path, OpenMode flags)
+{
+    auto file_result = file_table_.GetOrCreate(path);
+    RET_UNEXPECTED_IF_ERR(file_result);
+    File *file = *file_result;
+
+    auto open_result = open_file_table_.OpenFile(file, flags);
+    if (!open_result) {
+        return std::unexpected(open_result.error());
+    }
+    OpenFileEntry *global_entry = *open_result;
+
+    FdTable *fd_table = GetCurrentProcessFdTable();
+    if (fd_table == nullptr) {
+        open_file_table_.CloseFile(global_entry);
+        return std::unexpected(FdError::kIoError);
+    }
+
+    auto fd_result = fd_table->AllocateFd(global_entry);
+    if (!fd_result) {
+        open_file_table_.CloseFile(global_entry);
+        return std::unexpected(fd_result.error());
+    }
+
+    return *fd_result;
+}
+
+FdResult<> FdManager::Close(fd_t fd)
+{
+    FdTable *fd_table = GetCurrentProcessFdTable();
+    RET_UNEXPECTED_IF(fd_table == nullptr, FdError::kIoError);
+
+    OpenFileEntry *entry = fd_table->GetEntry(fd);
+    RET_UNEXPECTED_IF(!entry, FdError::kBadFileDescriptor);
+
+    auto close_result = open_file_table_.CloseFile(entry);
+    RET_UNEXPECTED_IF(!close_result, close_result.error());
+
+    auto free_result = fd_table->FreeFd(fd);
+    RET_UNEXPECTED_IF(!free_result, free_result.error());
+
+    return {};
+}
+
+FdResult<size_t> FdManager::Read(fd_t fd, std::span<byte> buffer)
+{
+    RET_UNEXPECTED_IF(buffer.empty(), FdError::kInvalidArgument);
+
+    FdTable *fd_table = GetCurrentProcessFdTable();
+    ASSERT_NOT_NULL(fd_table);
+
+    OpenFileEntry *entry = fd_table->GetEntry(fd);
+    RET_UNEXPECTED_IF(!entry, FdError::kBadFileDescriptor);
+
+    OpenMode mode = static_cast<OpenMode>(entry->flags);
+    RET_UNEXPECTED_IF(!HasMode(mode, OpenMode::kRead), FdError::kPermissionDenied);
+
+    if (entry->IsFile()) {
+        File *file = entry->GetFile();
+        RET_UNEXPECTED_IF(file == nullptr, FdError::kBadFileDescriptor);
+
+        auto result = vfs::ReadFile(file->path, buffer.data(), buffer.size(), entry->offset);
+        RET_UNEXPECTED_IF(!result, FdError::kIoError);
+
+        entry->offset += *result;
+        return *result;
+    } else if (entry->IsPipe()) {
+        auto *pipe = entry->GetPipe();
+        RET_UNEXPECTED_IF(pipe == nullptr, FdError::kBadFileDescriptor);
+
+        auto result = pipe->Read(buffer);
+        RET_UNEXPECTED_IF(!result, FdError::kIoError);
+        return *result;
+    }
+
+    return std::unexpected(FdError::kBadFileDescriptor);
+}
+
+FdResult<size_t> FdManager::Write(fd_t fd, std::span<const byte> buffer)
+{
+    RET_UNEXPECTED_IF(buffer.empty(), FdError::kInvalidArgument);
+
+    FdTable *fd_table = GetCurrentProcessFdTable();
+    ASSERT_NOT_NULL(fd_table);
+
+    OpenFileEntry *entry = fd_table->GetEntry(fd);
+    RET_UNEXPECTED_IF(!entry, FdError::kBadFileDescriptor);
+
+    OpenMode mode = static_cast<OpenMode>(entry->flags);
+    RET_UNEXPECTED_IF(!HasMode(mode, OpenMode::kWrite), FdError::kPermissionDenied);
+
+    if (entry->IsFile()) {
+        File *file = entry->GetFile();
+        RET_UNEXPECTED_IF(file == nullptr, FdError::kBadFileDescriptor);
+
+        if (entry->is_append) {
+            entry->offset = file->size;
+        }
+
+        auto result = vfs::WriteFile(file->path, buffer.data(), buffer.size(), entry->offset);
+        RET_UNEXPECTED_IF(!result, FdError::kIoError);
+
+        entry->offset += *result;
+        return *result;
+    } else if (entry->IsPipe()) {
+        auto *pipe = entry->GetPipe();
+        RET_UNEXPECTED_IF(pipe == nullptr, FdError::kBadFileDescriptor);
+
+        auto result = pipe->Write(buffer);
+        RET_UNEXPECTED_IF(!result, FdError::kIoError);
+        return *result;
+    }
+
+    return std::unexpected(FdError::kBadFileDescriptor);
+}
+
+FdResult<ssize_t> FdManager::Seek(fd_t fd, ssize_t offset, FdSeek whence)
+{
+    FdTable *fd_table = GetCurrentProcessFdTable();
+    ASSERT_NOT_NULL(fd_table);
+
+    OpenFileEntry *entry = fd_table->GetEntry(fd);
+    RET_UNEXPECTED_IF(!entry, FdError::kBadFileDescriptor);
+
+    RET_UNEXPECTED_IF(!entry->IsFile(), FdError::kInvalidArgument);
+
+    File *file = entry->GetFile();
+    RET_UNEXPECTED_IF(file == nullptr, FdError::kBadFileDescriptor);
+
+    ssize_t new_offset = 0;
+    switch (whence) {
+        case FdSeek::kSet:
+            new_offset = offset;
+            break;
+        case FdSeek::kCur:
+            new_offset = entry->offset + offset;
+            break;
+        case FdSeek::kEnd:
+            new_offset = file->size + offset;
+            break;
+        default:
+            return std::unexpected(FdError::kInvalidArgument);
+    }
+
+    RET_UNEXPECTED_IF(
+        new_offset > static_cast<ssize_t>(file->size) || new_offset < 0, FdError::kInvalidArgument
+    );
+
+    entry->offset = static_cast<u64>(new_offset);
+    return new_offset;
+}
+
+FdTable *FdManager::GetCurrentProcessFdTable()
+{
+    auto process = SchedulingModule::Get().GetProcesses().GetCurrentProcess();
+    if (!process) {
+        return nullptr;
+    }
+
+    return process.value()->fd_table;
+}
+
+const FdTable *FdManager::GetCurrentProcessFdTable() const
+{
+    auto process = SchedulingModule::Get().GetProcesses().GetCurrentProcess();
+    if (!process) {
+        return nullptr;
+    }
+
+    return process.value()->fd_table;
+}
+
+}  // namespace Fs
diff --git a/kernel/src/fs/file_descriptor.hpp b/kernel/src/fs/file_descriptor.hpp
new file mode 100644
index 00000000..0e8985a0
--- /dev/null
+++ b/kernel/src/fs/file_descriptor.hpp
@@ -0,0 +1,321 @@
+#ifndef KERNEL_SRC_FS_FILE_DESCRIPTOR_HPP_
+#define KERNEL_SRC_FS_FILE_DESCRIPTOR_HPP_
+
+#include <types.h>
+#include <data_structures/hash_maps.hpp>
+#include <data_structures/ref_count.hpp>
+#include <data_structures/tagged_pointer.hpp>
+#include <span.hpp>
+
+#include "hal/spinlock.hpp"
+#include "io/pipe.hpp"
+#include "io/stream.hpp"
+#include "sys/calls/fd.h"
+#include "vfs/types.hpp"
+
+namespace Fs
+{
+
+// ------------------------------
+// Forward Declarations
+// ------------------------------
+
+class OpenFileTable;
+class FileTable;
+
+// ------------------------------
+// Error Types
+// ------------------------------
+
+enum class FdError {
+    kInvalidFd,
+    kFdTableFull,
+    kBadFileDescriptor,
+    kNotOpen,
+    kAlreadyClosed,
+    kPermissionDenied,
+    kInvalidArgument,
+    kIoError
+};
+
+template <typename T = void>
+using FdResult = std::expected<T, FdError>;
+
+// ------------------------------
+// Constants
+// ------------------------------
+
+inline constexpr size_t kMaxFdsPerProcess = 128;
+inline constexpr size_t kMaxOpenFiles     = 1014;
+inline constexpr size_t kMaxActiveFiles   = 512;
+inline constexpr size_t kStdioBufferSize  = 4096;
+
+// ------------------------------
+// File Mode Flags
+// -----------------------------
+
+enum class OpenMode : u8 {
+    kRead      = 1 << 0,
+    kWrite     = 1 << 1,
+    kReadWrite = kRead | kWrite,
+    kAppend    = 1 << 2,
+    kCreate    = 1 << 3,
+    kTruncate  = 1 << 4,
+    kNonBlock  = 1 << 5,
+    kSync      = 1 << 6,
+};
+
+constexpr OpenMode operator|(OpenMode a, OpenMode b)
+{
+    return static_cast<OpenMode>(static_cast<u8>(a) | static_cast<u8>(b));
+}
+
+constexpr OpenMode operator&(OpenMode a, OpenMode b)
+{
+    return static_cast<OpenMode>(static_cast<u8>(a) & static_cast<u8>(b));
+}
+
+constexpr bool HasMode(OpenMode flags, OpenMode mode) { return (flags & mode) == mode; }
+
+// ------------------------------
+// Buffering Modes for libc FILE
+// ------------------------------
+
+enum class BufferMode : u8 {
+    kNone = kFdBufferNone,  // No buffering
+    kLine = kFdBufferLine,  // Line buffering (flush on newline)
+    kFull = kFdBufferFull,  // Full buffering (flush when buffer full)
+};
+
+// ------------------------------
+// Seek Whence Options
+// ------------------------------
+
+enum class FdSeek : u8 {
+    kSet = 0,  // Seek from beginning of file
+    kCur = 1,  // Seek from current position
+    kEnd = 2   // Seek from end of file
+};
+
+// ------------------------------
+// File Structure
+// -----------------------------
+
+/**
+ * @brief File represents a file in filesystem
+ *
+ */
+class File : public data_structures::RefCounted<File>
+{
+    public:
+    u64 size{0};
+    u32 mode{0};
+    vfs::Path path;
+
+    File()  = default;
+    ~File() = default;
+};
+
+// ------------------------------
+// File Handle (File or Pipe)
+// -----------------------------
+
+/**
+ * @brief Tagged union holding either a File or Pipe
+ *
+ * - File: Smart (ref-counted), managed by RefCounted
+ * - Pipe: NonOwned, owned by Process (for stdin/stdout/stderr)
+ */
+using FileHandle = data_structures::NonOwningTaggedPtr<File, IO::Pipe<kStdioBufferSize>>;
+
+// ------------------------------
+// Global Open File Table Entry
+// -----------------------------
+
+/**
+ * @brief Global open file table entry
+ *
+ * This is middle level in three-tier hierarchy.
+ * Multiple process file descriptors can reference same entry.
+ *
+ * Contains either:
+ * - A File (with automatic ref counting via RefCounted)
+ * - A Pipe (for stdin/stdout/stderr)
+ */
+class OpenFileEntry : public data_structures::RefCounted<OpenFileEntry>
+{
+    public:
+    FileHandle handle;
+    u32 flags{0};
+    u64 offset{0};
+    bool is_append{false};
+
+    OpenFileEntry()  = default;
+    ~OpenFileEntry() = default;
+
+    bool IsFile() const { return handle.Is<File>(); }
+    bool IsPipe() const { return handle.Is<IO::Pipe<kStdioBufferSize>>(); }
+
+    File *GetFile() { return IsFile() ? &handle.As<File>() : nullptr; }
+
+    IO::Pipe<kStdioBufferSize> *GetPipe()
+    {
+        return IsPipe() ? &handle.As<IO::Pipe<kStdioBufferSize>>() : nullptr;
+    }
+};
+
+// ------------------------------
+// Process File Descriptor Table
+// -----------------------------
+
+/**
+ * @brief Process-local file descriptor table
+ *
+ * Each process has its own table of file descriptors.
+ */
+class FdTable
+{
+    public:
+    FdTable()  = default;
+    ~FdTable() = default;
+
+    FdTable(const FdTable &)            = delete;
+    FdTable &operator=(const FdTable &) = delete;
+    FdTable(FdTable &&)                 = delete;
+    FdTable &operator=(FdTable &&)      = delete;
+
+    FdResult<fd_t> AllocateFd(OpenFileEntry *global_entry);
+    FdResult<fd_t> AllocateFdAt(OpenFileEntry *global_entry, fd_t fd);
+    FdResult<> FreeFd(fd_t fd);
+
+    OpenFileEntry *GetEntry(fd_t fd);
+    const OpenFileEntry *GetEntry(fd_t fd) const;
+
+    FdResult<fd_t> DuplicateFd(fd_t fd);
+    FdResult<fd_t> DuplicateFdTo(fd_t old_fd, fd_t new_fd);
+
+    size_t GetOpenCount() const { return open_count_; }
+
+    private:
+    OpenFileEntry *entries_[kMaxFdsPerProcess]{};
+    size_t open_count_{};
+    hal::Spinlock lock_{};
+};
+
+// ------------------------------
+// Global File Table
+// -----------------------------
+
+/**
+ * @brief Global file table
+ *
+ * Manages all active files.
+ */
+class FileTable
+{
+    public:
+    FileTable()  = default;
+    ~FileTable() = default;
+
+    FileTable(const FileTable &)            = delete;
+    FileTable &operator=(const FileTable &) = delete;
+    FileTable(FileTable &&)                 = delete;
+    FileTable &operator=(FileTable &&)      = delete;
+
+    FdResult<File *> GetOrCreate(const vfs::Path &path);
+    FdResult<> Release(File *file);
+
+    File *Find(const vfs::Path &path);
+    const File *Find(const vfs::Path &path) const;
+
+    size_t GetCount() const { return count_; }
+    const File *GetFile(size_t index) const { return files_.Get(index); }
+
+    private:
+    data_structures::PooledHashMap<File, kMaxActiveFiles> files_{};
+    size_t count_{};
+    hal::Spinlock lock_{};
+};
+
+// ------------------------------
+// Global Open File Table
+// -----------------------------
+
+/**
+ * @brief Global open file table
+ *
+ * Manages all open file entries system-wide.
+ */
+class OpenFileTable
+{
+    public:
+    OpenFileTable();
+    ~OpenFileTable();
+
+    OpenFileTable(const OpenFileTable &)            = delete;
+    OpenFileTable &operator=(const OpenFileTable &) = delete;
+    OpenFileTable(OpenFileTable &&)                 = delete;
+    OpenFileTable &operator=(OpenFileTable &&)      = delete;
+
+    FdResult<OpenFileEntry *> OpenFile(File *file, OpenMode flags);
+    FdResult<OpenFileEntry *> OpenPipe(IO::Pipe<kStdioBufferSize> &pipe);
+    FdResult<> CloseFile(OpenFileEntry *entry);
+
+    FdResult<u64> GetOffset(const OpenFileEntry *entry) const;
+    FdResult<> SetOffset(OpenFileEntry *entry, u64 offset) const;
+
+    size_t GetOpenCount() const { return open_count_; }
+    const OpenFileEntry *GetEntry(size_t index) const { return entries_.Get(index); }
+
+    private:
+    data_structures::PooledHashMap<OpenFileEntry, kMaxOpenFiles> entries_{};
+    size_t open_count_;
+    mutable arch::Spinlock lock_;
+};
+
+// ------------------------------
+// Standard File Descriptors
+// -----------------------------
+
+inline constexpr fd_t kStdinFd  = kFdStdIn;
+inline constexpr fd_t kStdoutFd = kFdStdOut;
+inline constexpr fd_t kStderrFd = kFdStdErr;
+
+// ------------------------------
+// File Descriptor Manager
+// -----------------------------
+
+class FdManager
+{
+    public:
+    FdManager();
+    ~FdManager();
+
+    FdManager(const FdManager &)            = delete;
+    FdManager &operator=(const FdManager &) = delete;
+    FdManager(FdManager &&)                 = delete;
+    FdManager &operator=(FdManager &&)      = delete;
+
+    FdResult<fd_t> Open(const vfs::Path &path, OpenMode flags);
+    FdResult<> Close(fd_t fd);
+    FdResult<size_t> Read(fd_t fd, std::span<byte> buffer);
+    FdResult<size_t> Write(fd_t fd, std::span<const byte> buffer);
+    FdResult<ssize_t> Seek(fd_t fd, ssize_t offset, FdSeek whence);
+
+    FileTable &GetFileTable() { return file_table_; }
+    const FileTable &GetFileTable() const { return file_table_; }
+
+    OpenFileTable &GetOpenFileTable() { return open_file_table_; }
+    const OpenFileTable &GetOpenFileTable() const { return open_file_table_; }
+
+    FdTable *GetCurrentProcessFdTable();
+    const FdTable *GetCurrentProcessFdTable() const;
+
+    private:
+    FileTable file_table_;
+    OpenFileTable open_file_table_;
+};
+
+}  // namespace Fs
+
+#endif  // KERNEL_SRC_FS_FILE_DESCRIPTOR_HPP_
diff --git a/kernel/src/vfs/error.hpp b/kernel/src/fs/vfs/error.hpp
similarity index 100%
rename from kernel/src/vfs/error.hpp
rename to kernel/src/fs/vfs/error.hpp
diff --git a/kernel/src/vfs/fat/fat.hpp b/kernel/src/fs/vfs/fat/fat.hpp
similarity index 99%
rename from kernel/src/vfs/fat/fat.hpp
rename to kernel/src/fs/vfs/fat/fat.hpp
index d754dd38..4f8c3375 100644
--- a/kernel/src/vfs/fat/fat.hpp
+++ b/kernel/src/fs/vfs/fat/fat.hpp
@@ -1,17 +1,17 @@
-#ifndef KERNEL_SRC_VFS_FAT_FAT_HPP_
-#define KERNEL_SRC_VFS_FAT_FAT_HPP_
+#ifndef KERNEL_SRC_FS_VFS_FAT_FAT_HPP_
+#define KERNEL_SRC_FS_VFS_FAT_FAT_HPP_
 
 #include <ctype.h>
 #include <string.h>
+#include <fs/vfs/error.hpp>
+#include <fs/vfs/interface.hpp>
+#include <fs/vfs/path.hpp>
+#include <fs/vfs/types.hpp>
 #include <internal/span.hpp>
 #include <span.hpp>
 #include <string.hpp>
 #include <template_lib.hpp>
 #include <trace_framework.hpp>
-#include <vfs.hpp>
-#include <vfs/error.hpp>
-#include <vfs/interface.hpp>
-#include <vfs/path.hpp>
 #include "macros.hpp"
 
 namespace vfs
@@ -1389,4 +1389,4 @@ class Fat
 
 }  // namespace vfs
 
-#endif  // KERNEL_SRC_VFS_FAT_FAT_HPP_
+#endif  // KERNEL_SRC_FS_VFS_FAT_FAT_HPP_
diff --git a/kernel/src/vfs/fat/fat12.hpp b/kernel/src/fs/vfs/fat/fat12.hpp
similarity index 99%
rename from kernel/src/vfs/fat/fat12.hpp
rename to kernel/src/fs/vfs/fat/fat12.hpp
index eff314c9..b60f9ea0 100644
--- a/kernel/src/vfs/fat/fat12.hpp
+++ b/kernel/src/fs/vfs/fat/fat12.hpp
@@ -2,10 +2,10 @@
 #define KERNEL_SRC_VFS_FAT_FAT12_HPP_
 
 #include <bit.hpp>
+#include <fs/vfs/fat/fat.hpp>
+#include <fs/vfs/interface.hpp>
 #include <internal/math.hpp>
 #include <internal/span.hpp>
-#include <vfs/fat/fat.hpp>
-#include <vfs/interface.hpp>
 
 namespace vfs
 {
diff --git a/kernel/src/vfs/fat/fat16.hpp b/kernel/src/fs/vfs/fat/fat16.hpp
similarity index 100%
rename from kernel/src/vfs/fat/fat16.hpp
rename to kernel/src/fs/vfs/fat/fat16.hpp
diff --git a/kernel/src/vfs/fat/fat32.hpp b/kernel/src/fs/vfs/fat/fat32.hpp
similarity index 100%
rename from kernel/src/vfs/fat/fat32.hpp
rename to kernel/src/fs/vfs/fat/fat32.hpp
diff --git a/kernel/src/vfs/interface.hpp b/kernel/src/fs/vfs/interface.hpp
similarity index 98%
rename from kernel/src/vfs/interface.hpp
rename to kernel/src/fs/vfs/interface.hpp
index def6379b..14b86007 100644
--- a/kernel/src/vfs/interface.hpp
+++ b/kernel/src/fs/vfs/interface.hpp
@@ -1,10 +1,10 @@
 #ifndef KERNEL_SRC_VFS_INTERFACE_HPP_
 #define KERNEL_SRC_VFS_INTERFACE_HPP_
 
+#include <types.h>
 #include <concepts.hpp>
 #include <defines.hpp>
 #include <span.hpp>
-#include <types.hpp>
 
 namespace vfs
 {
diff --git a/kernel/src/vfs/io/in_memory.hpp b/kernel/src/fs/vfs/io/in_memory.hpp
similarity index 98%
rename from kernel/src/vfs/io/in_memory.hpp
rename to kernel/src/fs/vfs/io/in_memory.hpp
index fd32c4d4..c4b64529 100644
--- a/kernel/src/vfs/io/in_memory.hpp
+++ b/kernel/src/fs/vfs/io/in_memory.hpp
@@ -2,10 +2,9 @@
 #define KERNEL_SRC_VFS_IO_IN_MEMORY_HPP_
 
 #include <string.h>
+#include <fs/vfs/interface.hpp>
 #include <mem/heap.hpp>
 #include <span.hpp>
-#include <todo.hpp>
-#include <vfs/interface.hpp>
 
 namespace vfs::io
 {
diff --git a/kernel/src/vfs/path.hpp b/kernel/src/fs/vfs/path.hpp
similarity index 99%
rename from kernel/src/vfs/path.hpp
rename to kernel/src/fs/vfs/path.hpp
index edd91160..cab96f87 100644
--- a/kernel/src/vfs/path.hpp
+++ b/kernel/src/fs/vfs/path.hpp
@@ -10,9 +10,9 @@ namespace vfs
 {
 
 // Constants
-inline constexpr size_t kMaxPathSize      = 4096;
+inline constexpr size_t kMaxPathSize      = 1024;
 inline constexpr size_t kMaxComponents    = 64;
-inline constexpr size_t kMaxComponentSize = 256;
+inline constexpr size_t kMaxComponentSize = 128;
 inline constexpr char kPathSeparator      = '/';
 
 // Ccncepts
diff --git a/kernel/src/vfs/types.hpp b/kernel/src/fs/vfs/types.hpp
similarity index 98%
rename from kernel/src/vfs/types.hpp
rename to kernel/src/fs/vfs/types.hpp
index 5c93b46c..d1491315 100644
--- a/kernel/src/vfs/types.hpp
+++ b/kernel/src/fs/vfs/types.hpp
@@ -1,12 +1,12 @@
 #ifndef KERNEL_SRC_VFS_TYPES_HPP_
 #define KERNEL_SRC_VFS_TYPES_HPP_
 
+#include <types.h>
 #include <data_structures/critbit_tree.hpp>
-#include <types.hpp>
 
-#include "vfs/error.hpp"
-#include "vfs/interface.hpp"
-#include "vfs/path.hpp"
+#include "fs/vfs/error.hpp"
+#include "interface.hpp"
+#include "path.hpp"
 
 namespace vfs
 {
diff --git a/kernel/src/graphics/color.hpp b/kernel/src/graphics/color.hpp
index 02189de8..1d577661 100644
--- a/kernel/src/graphics/color.hpp
+++ b/kernel/src/graphics/color.hpp
@@ -1,8 +1,8 @@
 #ifndef KERNEL_SRC_GRAPHICS_COLOR_HPP_
 #define KERNEL_SRC_GRAPHICS_COLOR_HPP_
 
+#include <types.h>
 #include <defines.hpp>
-#include <types.hpp>
 
 namespace Graphics
 {
diff --git a/kernel/src/graphics/font/glyph.hpp b/kernel/src/graphics/font/glyph.hpp
index 5a5d5b17..0207b898 100644
--- a/kernel/src/graphics/font/glyph.hpp
+++ b/kernel/src/graphics/font/glyph.hpp
@@ -1,7 +1,7 @@
 #ifndef KERNEL_SRC_GRAPHICS_FONT_GLYPH_HPP_
 #define KERNEL_SRC_GRAPHICS_FONT_GLYPH_HPP_
 
-#include <types.hpp>
+#include <types.h>
 
 namespace Graphics
 {
diff --git a/kernel/src/graphics/font/psf2_font.hpp b/kernel/src/graphics/font/psf2_font.hpp
index 13565fb9..0a6b5683 100644
--- a/kernel/src/graphics/font/psf2_font.hpp
+++ b/kernel/src/graphics/font/psf2_font.hpp
@@ -2,10 +2,10 @@
 #define KERNEL_SRC_GRAPHICS_FONT_PSF2_FONT_HPP_
 
 #include <assert.h>
+#include <types.h>
 #include <defines.hpp>
 #include <span.hpp>
 #include <string.hpp>
-#include <types.hpp>
 
 #include "graphics/font/glyph.hpp"
 #include "graphics/geometry.hpp"
diff --git a/kernel/src/graphics/geometry.hpp b/kernel/src/graphics/geometry.hpp
index cd3ec15a..aac14f39 100644
--- a/kernel/src/graphics/geometry.hpp
+++ b/kernel/src/graphics/geometry.hpp
@@ -1,8 +1,8 @@
 #ifndef KERNEL_SRC_GRAPHICS_GEOMETRY_HPP_
 #define KERNEL_SRC_GRAPHICS_GEOMETRY_HPP_
 
+#include <types.h>
 #include <string.hpp>
-#include <types.hpp>
 
 namespace Graphics
 {
diff --git a/kernel/src/graphics/native_pixel.hpp b/kernel/src/graphics/native_pixel.hpp
index 20797f52..067e21f2 100644
--- a/kernel/src/graphics/native_pixel.hpp
+++ b/kernel/src/graphics/native_pixel.hpp
@@ -1,8 +1,8 @@
 #ifndef KERNEL_SRC_GRAPHICS_NATIVE_PIXEL_HPP_
 #define KERNEL_SRC_GRAPHICS_NATIVE_PIXEL_HPP_
 
+#include <types.h>
 #include <defines.hpp>
-#include <types.hpp>
 #include "graphics/color.hpp"
 
 namespace Graphics
diff --git a/kernel/src/graphics/surface.hpp b/kernel/src/graphics/surface.hpp
index a07eaf65..daafc8ff 100644
--- a/kernel/src/graphics/surface.hpp
+++ b/kernel/src/graphics/surface.hpp
@@ -2,9 +2,9 @@
 #define KERNEL_SRC_GRAPHICS_SURFACE_HPP_
 
 #include <assert.h>
+#include <types.h>
 #include <mem/types.hpp>
 #include <span.hpp>
-#include <types.hpp>
 #include "graphics/native_pixel.hpp"
 
 namespace Graphics
diff --git a/kernel/src/hal/api/boot_args.hpp b/kernel/src/hal/api/boot_args.hpp
index 33132db1..b517a957 100644
--- a/kernel/src/hal/api/boot_args.hpp
+++ b/kernel/src/hal/api/boot_args.hpp
@@ -2,7 +2,7 @@
 #define KERNEL_SRC_HAL_API_BOOT_ARGS_HPP_
 
 #include <defines.h>
-#include <types.hpp>
+#include <types.h>
 
 namespace arch
 {
diff --git a/kernel/src/hal/api/debug_terminal.hpp b/kernel/src/hal/api/debug_terminal.hpp
index 77c03ad1..e7ced57e 100644
--- a/kernel/src/hal/api/debug_terminal.hpp
+++ b/kernel/src/hal/api/debug_terminal.hpp
@@ -3,7 +3,7 @@
 
 #include <autogen/feature_flags.h>
 #include <defines.hpp>
-#include "types.hpp"
+#include "types.h"
 
 namespace arch
 {
diff --git a/kernel/src/hal/api/io.hpp b/kernel/src/hal/api/io.hpp
index 0e8a43d0..ceaf8370 100644
--- a/kernel/src/hal/api/io.hpp
+++ b/kernel/src/hal/api/io.hpp
@@ -1,8 +1,8 @@
 #ifndef KERNEL_SRC_HAL_API_IO_HPP_
 #define KERNEL_SRC_HAL_API_IO_HPP_
 
+#include <types.h>
 #include <concepts.hpp>
-#include <types.hpp>
 
 namespace arch
 {
diff --git a/kernel/src/hal/api/sync.hpp b/kernel/src/hal/api/sync.hpp
index dad1df3b..5a759af8 100644
--- a/kernel/src/hal/api/sync.hpp
+++ b/kernel/src/hal/api/sync.hpp
@@ -1,8 +1,8 @@
 #ifndef KERNEL_SRC_HAL_API_SYNC_HPP_
 #define KERNEL_SRC_HAL_API_SYNC_HPP_
 
+#include <types.h>
 #include <type_traits.hpp>
-#include <types.hpp>
 
 namespace hal
 {
diff --git a/kernel/src/hal/constants.hpp b/kernel/src/hal/constants.hpp
index 069486a3..829e17b5 100644
--- a/kernel/src/hal/constants.hpp
+++ b/kernel/src/hal/constants.hpp
@@ -1,9 +1,9 @@
 #ifndef KERNEL_SRC_HAL_CONSTANTS_HPP_
 #define KERNEL_SRC_HAL_CONSTANTS_HPP_
 
+#include <types.h>
 #include <bits_ext.hpp>
 #include <hal/impl/constants.hpp>
-#include <types.hpp>
 
 namespace hal
 {
diff --git a/kernel/src/hal/panic.hpp b/kernel/src/hal/panic.hpp
index f515e102..1d899b4e 100644
--- a/kernel/src/hal/panic.hpp
+++ b/kernel/src/hal/panic.hpp
@@ -21,6 +21,8 @@ WRAP_CALL void KernelPanic(const char *msg)
     HardwareModule::Get().GetInterrupts().BlockHardwareInterrupts();
     HardwareModule::Get().GetCoresController().PanicAllCores();
 
+    // For some reason trace::DumpAllBuffersOnFailure() must be called before and after printing
+    trace::DumpAllBuffersOnFailure();
     TRACE_FATAL_GENERAL("[ KERNEL PANIC ]");
     TRACE_FATAL_GENERAL(msg);
     TRACE_FATAL_GENERAL("\n");
@@ -34,6 +36,8 @@ FAST_CALL NO_RET void KernelPanicFormat(const char *fmt, Args... args)
     HardwareModule::Get().GetInterrupts().BlockHardwareInterrupts();
     HardwareModule::Get().GetCoresController().PanicAllCores();
 
+    // For some reason trace::DumpAllBuffersOnFailure() must be called before and after printing
+    trace::DumpAllBuffersOnFailure();
     TRACE_FATAL_GENERAL("[ KERNEL PANIC ]");
     TRACE_FATAL_GENERAL(fmt, args...);
     arch::KernelPanic();
diff --git a/kernel/src/hal/timers.hpp b/kernel/src/hal/timers.hpp
index 9146cbe5..20aeae53 100644
--- a/kernel/src/hal/timers.hpp
+++ b/kernel/src/hal/timers.hpp
@@ -11,7 +11,7 @@ namespace hal
  * @note It will be used during the boot process and periodically to update the system time and
  *       get rid of any time drift created possibly by inaccurate timers. Returns POSIX time value.
  */
-WRAP_CALL time_t QuerySystemTime(const timezone &tz) { return arch::QuerySystemTime(tz); }
+WRAP_CALL time_t QuerySystemTime(const Timezone &tz) { return arch::QuerySystemTime(tz); }
 
 /**
  * @brief this function based on clock infra should pick the best clock source available
diff --git a/kernel/src/hardware/interrupt_driver.hpp b/kernel/src/hardware/interrupt_driver.hpp
index 0df349e4..4a53cf7e 100644
--- a/kernel/src/hardware/interrupt_driver.hpp
+++ b/kernel/src/hardware/interrupt_driver.hpp
@@ -1,7 +1,7 @@
 #ifndef KERNEL_SRC_HARDWARE_INTERRUPT_DRIVER_HPP_
 #define KERNEL_SRC_HARDWARE_INTERRUPT_DRIVER_HPP_
 
-#include <types.hpp>
+#include <types.h>
 
 namespace intr
 {
diff --git a/kernel/src/init.cpp b/kernel/src/init.cpp
index fcf8abd7..848b810a 100644
--- a/kernel/src/init.cpp
+++ b/kernel/src/init.cpp
@@ -15,6 +15,8 @@
 #include "modules/video.hpp"
 #include "trace_framework.hpp"
 
+#include "internal/stdio.hpp"
+
 /* GCC CXX provided function initializing global constructors */
 extern "C" void _init();
 
@@ -52,7 +54,7 @@ void KernelInit(const hal::RawBootArguments &raw_args)
     HardwareModule::Get().RegisterInterruptHandlers();
 
     /* Fully Initialize ACPI subsystem */
-    // HardwareModule::Get().GetACPIController().Init();
+    HardwareModule::Get().GetACPIController().Init();
 
     VfsModule::Init(args);
 
diff --git a/kernel/src/kernel.cpp b/kernel/src/kernel.cpp
index c8a23ccc..fe615af9 100644
--- a/kernel/src/kernel.cpp
+++ b/kernel/src/kernel.cpp
@@ -7,6 +7,7 @@
 /* internal includes */
 #include <hal/debug.hpp>
 #include <hal/terminal.hpp>
+#include <scheduling/kworker.hpp>
 
 #include "graphics/font/psf2_font.hpp"
 #include "graphics/fonts/drdos8x8.hpp"
@@ -26,6 +27,12 @@ extern void KernelInit(const hal::RawBootArguments &);
 static void KernelRun()
 {
     TRACE_INFO_GENERAL("Hello from AlkOS!");
+
+    auto &task_mgr = SchedulingModule::Get().GetTaskMgr();
+
+    // Spawn hello world process
+    R_ASSERT_TRUE(task_mgr.ExecuteElf64("/bin/hello", {}), "Failed to spawn /bin/hello process...");
+
     SchedulingModule::Get().GetScheduler().ConvertToScheduling();
 }
 
diff --git a/kernel/src/libc_backend.cpp b/kernel/src/libc_backend.cpp
index 4ecaa8c0..9f019f80 100644
--- a/kernel/src/libc_backend.cpp
+++ b/kernel/src/libc_backend.cpp
@@ -35,4 +35,52 @@ size_t __platform_debug_read_line(char *buffer, const size_t buffer_size)
 
 void __platform_write_console(const char *buffer) { SysWriteConsole(buffer); }
 
+fd_t __platform_open(const char *pathname, const int flags)
+{
+    auto res = SysOpen(vfs::Path(pathname), static_cast<Fs::OpenMode>(flags));
+    if (!res) {
+        return -1;
+    }
+
+    return *res;
+}
+
+int __platform_close(const fd_t fd)
+{
+    auto res = SysClose(fd);
+    if (!res) {
+        return -1;
+    }
+
+    return 0;
+}
+
+ssize_t __platform_read(const fd_t fd, void *buf, const size_t count)
+{
+    auto res = SysRead(fd, {static_cast<byte *>(buf), count});
+    if (!res) {
+        DEBUG_FATAL_VFS("Read syscall failed on fd %d: %d", fd, static_cast<int>(res.error()));
+        return -1;
+    }
+    return static_cast<ssize_t>(*res);
+}
+
+ssize_t __platform_write(const fd_t fd, const void *buf, const size_t count)
+{
+    auto res = SysWrite(fd, {static_cast<const byte *>(buf), count});
+    if (!res) {
+        return -1;
+    }
+    return static_cast<ssize_t>(*res);
+}
+
+ssize_t __platform_seek(int fd, ssize_t offset, FdSeek whence)
+{
+    auto res = SysSeek(fd, offset, static_cast<Fs::FdSeek>(whence));
+    if (!res) {
+        return -1;
+    }
+    return *res;
+}
+
 #endif
diff --git a/kernel/src/mem/page.hpp b/kernel/src/mem/page.hpp
index 321a46de..ee5de773 100644
--- a/kernel/src/mem/page.hpp
+++ b/kernel/src/mem/page.hpp
@@ -2,8 +2,8 @@
 #define KERNEL_SRC_MEM_PAGE_HPP_
 
 #include <assert.h>
+#include <types.h>
 #include <bit.hpp>
-#include <types.hpp>
 
 #include "hal/constants.hpp"
 #include "mem/types.hpp"
diff --git a/kernel/src/mem/page_meta.hpp b/kernel/src/mem/page_meta.hpp
index ddf27cfb..ae61df33 100644
--- a/kernel/src/mem/page_meta.hpp
+++ b/kernel/src/mem/page_meta.hpp
@@ -2,7 +2,7 @@
 #define KERNEL_SRC_MEM_PAGE_META_HPP_
 
 #include <defines.h>
-#include <types.hpp>
+#include <types.h>
 
 #include "mem/types.hpp"
 
diff --git a/kernel/src/mem/phys/mngr/buddy.hpp b/kernel/src/mem/phys/mngr/buddy.hpp
index 18b9ff47..b483d4a6 100644
--- a/kernel/src/mem/phys/mngr/buddy.hpp
+++ b/kernel/src/mem/phys/mngr/buddy.hpp
@@ -1,9 +1,9 @@
 #ifndef KERNEL_SRC_MEM_PHYS_MNGR_BUDDY_HPP_
 #define KERNEL_SRC_MEM_PHYS_MNGR_BUDDY_HPP_
 
+#include <types.h>
 #include <bit.hpp>
 #include <expected.hpp>
-#include <types.hpp>
 
 #include "mem/error.hpp"
 #include "mem/page.hpp"
diff --git a/kernel/src/mem/phys/ptr.hpp b/kernel/src/mem/phys/ptr.hpp
index 449bc72b..a0352c51 100644
--- a/kernel/src/mem/phys/ptr.hpp
+++ b/kernel/src/mem/phys/ptr.hpp
@@ -1,8 +1,8 @@
 #ifndef KERNEL_SRC_MEM_PHYS_PTR_HPP_
 #define KERNEL_SRC_MEM_PHYS_PTR_HPP_
 
+#include <types.h>
 #include <type_traits.hpp>
-#include <types.hpp>
 #include "hal/constants.hpp"
 
 namespace mem
diff --git a/kernel/src/mem/types.hpp b/kernel/src/mem/types.hpp
index 75e72ede..511d5cd2 100644
--- a/kernel/src/mem/types.hpp
+++ b/kernel/src/mem/types.hpp
@@ -1,9 +1,9 @@
 #ifndef KERNEL_SRC_MEM_TYPES_HPP_
 #define KERNEL_SRC_MEM_TYPES_HPP_
 
+#include <types.h>
 #include <expected.hpp>
 #include <type_traits.hpp>
-#include <types.hpp>
 #include "constants.hpp"
 #include "hal/constants.hpp"
 
@@ -23,7 +23,7 @@ template <typename T>
 using PPtr = PhysicalPtr<T>;
 
 template <typename T>
-VPtr<T> PhysToVirt(PPtr<T> physAddr)
+FORCE_INLINE_F VPtr<T> PhysToVirt(PPtr<T> physAddr)
 {
     return reinterpret_cast<VPtr<T>>(
         reinterpret_cast<uintptr_t>(physAddr) + hal::kDirectMapAddrStart
@@ -31,7 +31,7 @@ VPtr<T> PhysToVirt(PPtr<T> physAddr)
 }
 
 template <typename T>
-PPtr<T> VirtToPhys(VPtr<T> virtAddr)
+FORCE_INLINE_F PPtr<T> VirtToPhys(VPtr<T> virtAddr)
 {
     uintptr_t vaddr = reinterpret_cast<uintptr_t>(virtAddr);
     if (vaddr >= hal::kDirectMapAddrStart) {
@@ -42,13 +42,13 @@ PPtr<T> VirtToPhys(VPtr<T> virtAddr)
 }
 
 template <typename T>
-uptr PtrToUptr(T *ptr)
+FORCE_INLINE_F uptr PtrToUptr(T *ptr)
 {
     return reinterpret_cast<uptr>(ptr);
 }
 
 template <typename T>
-T *UptrToPtr(uptr uptr)
+FORCE_INLINE_F T *UptrToPtr(uptr uptr)
 {
     return reinterpret_cast<T *>(uptr);
 }
diff --git a/kernel/src/mem/virt/addr_space.hpp b/kernel/src/mem/virt/addr_space.hpp
index d9718f24..15d3d9b0 100644
--- a/kernel/src/mem/virt/addr_space.hpp
+++ b/kernel/src/mem/virt/addr_space.hpp
@@ -1,8 +1,8 @@
 #ifndef KERNEL_SRC_MEM_VIRT_ADDR_SPACE_HPP_
 #define KERNEL_SRC_MEM_VIRT_ADDR_SPACE_HPP_
 
+#include <types.h>
 #include <expected.hpp>
-#include <types.hpp>
 
 #include <data_structures/linked_list.hpp>
 #include "hal/interrupt_params.hpp"
diff --git a/kernel/src/mem/virt/area.hpp b/kernel/src/mem/virt/area.hpp
index d5937994..fb928208 100644
--- a/kernel/src/mem/virt/area.hpp
+++ b/kernel/src/mem/virt/area.hpp
@@ -1,7 +1,7 @@
 #ifndef KERNEL_SRC_MEM_VIRT_AREA_HPP_
 #define KERNEL_SRC_MEM_VIRT_AREA_HPP_
 
-#include <types.hpp>
+#include <types.h>
 #include "mem/types.hpp"
 #include "mem/virt/page_fault_data.hpp"
 
diff --git a/kernel/src/mem/virt/page_fault.cpp b/kernel/src/mem/virt/page_fault.cpp
index 1457e701..c25bbd54 100644
--- a/kernel/src/mem/virt/page_fault.cpp
+++ b/kernel/src/mem/virt/page_fault.cpp
@@ -11,6 +11,36 @@
 namespace Mem
 {
 
+namespace
+{
+constexpr const char *PresentDescription(bool present)
+{
+    return present ? "Page-protection violation" : "Page was not present";
+}
+
+constexpr const char *WriteDescription(bool write)
+{
+    return write ? "Write operation" : "Read operation";
+}
+
+constexpr const char *UserModeDescription(bool user)
+{
+    return user ? "Occurred in user mode" : "Occurred in kernel mode";
+}
+
+constexpr const char *ReservedBitsDescription(bool reserved_bits)
+{
+    return reserved_bits ? "One or more reserved bits were set in a page-table entry"
+                         : "No reserved bits issue";
+}
+
+constexpr const char *InstructionFetchDescription(bool instruction_fetch)
+{
+    return instruction_fetch ? "Fault caused by an instruction fetch"
+                             : "Fault not caused by an instruction fetch";
+}
+}  // namespace
+
 void *PageFaultHandler(intr::LitExcEntry &, hal::ExceptionData *data)
 {
     ASSERT_NOT_NULL(data);
@@ -28,7 +58,21 @@ void *PageFaultHandler(intr::LitExcEntry &, hal::ExceptionData *data)
     auto vma_res = as.FindAreaLocked(f_ptr);
 
     if (!vma_res) {
-        hal::KernelPanicFormat("Page fault in unmapped memory at %p", f_ptr);
+        hal::KernelPanicFormat(
+            "Page fault in unmapped memory\n"
+            "Faulting address: %p\n"
+            "Instruction pointer: %p\n"
+            "Error details:\n"
+            "  - %s\n"
+            "  - %s\n"
+            "  - %s\n"
+            "  - %s\n"
+            "  - %s",
+            f_ptr, data->isr_stack_frame.rip, PresentDescription(err.present),
+            WriteDescription(err.write), UserModeDescription(err.user),
+            ReservedBitsDescription(err.reserved_bits),
+            InstructionFetchDescription(err.instruction_fetch)
+        );
         return nullptr;
     }
     VMemArea *vma = *(*vma_res);
@@ -36,13 +80,41 @@ void *PageFaultHandler(intr::LitExcEntry &, hal::ExceptionData *data)
     if (err.present) {
         // Protection violation
         // TODO: CoW handling would go here via vma->HandleProtectionFault()
-        hal::KernelPanicFormat("Unhandled protection fault at %p", f_ptr);
+        hal::KernelPanicFormat(
+            "Unhandled protection fault\n"
+            "Faulting address: %p\n"
+            "Instruction pointer: %p\n"
+            "Error details:\n"
+            "  - %s\n"
+            "  - %s\n"
+            "  - %s\n"
+            "  - %s\n"
+            "  - %s",
+            f_ptr, data->isr_stack_frame.rip, PresentDescription(err.present),
+            WriteDescription(err.write), UserModeDescription(err.user),
+            ReservedBitsDescription(err.reserved_bits),
+            InstructionFetchDescription(err.instruction_fetch)
+        );
     }
 
     // Delegate to VMA
     // The VMA knows if it's anonymous, file-backed, or MMIO, and handles it accordingly.
     if (!vma->HandleFault(f_ptr, err, as)) {
-        hal::KernelPanicFormat("Failed to resolve page fault at %p", f_ptr);
+        hal::KernelPanicFormat(
+            "Failed to resolve page fault\n"
+            "Faulting address: %p\n"
+            "Instruction pointer: %p\n"
+            "Error details:\n"
+            "  - %s\n"
+            "  - %s\n"
+            "  - %s\n"
+            "  - %s\n"
+            "  - %s",
+            f_ptr, data->isr_stack_frame.rip, PresentDescription(err.present),
+            WriteDescription(err.write), UserModeDescription(err.user),
+            ReservedBitsDescription(err.reserved_bits),
+            InstructionFetchDescription(err.instruction_fetch)
+        );
     }
     return nullptr;
 }
diff --git a/kernel/src/mem/virt/ptr.hpp b/kernel/src/mem/virt/ptr.hpp
index cc5a25f1..9411fd8d 100644
--- a/kernel/src/mem/virt/ptr.hpp
+++ b/kernel/src/mem/virt/ptr.hpp
@@ -1,8 +1,8 @@
 #ifndef KERNEL_SRC_MEM_VIRT_PTR_HPP_
 #define KERNEL_SRC_MEM_VIRT_PTR_HPP_
 
+#include <types.h>
 #include <type_traits.hpp>
-#include <types.hpp>
 #include "hal/constants.hpp"
 
 namespace mem
diff --git a/kernel/src/mem/virt/vmm.hpp b/kernel/src/mem/virt/vmm.hpp
index 146b03c7..36ff9d06 100644
--- a/kernel/src/mem/virt/vmm.hpp
+++ b/kernel/src/mem/virt/vmm.hpp
@@ -1,8 +1,8 @@
 #ifndef KERNEL_SRC_MEM_VIRT_VMM_HPP_
 #define KERNEL_SRC_MEM_VIRT_VMM_HPP_
 
+#include <types.h>
 #include <expected.hpp>
-#include <types.hpp>
 
 #include "hal/mmu.hpp"
 #include "hal/tlb.hpp"
diff --git a/kernel/src/modules/vfs.cpp b/kernel/src/modules/vfs.cpp
index a0d40078..503a464b 100644
--- a/kernel/src/modules/vfs.cpp
+++ b/kernel/src/modules/vfs.cpp
@@ -2,11 +2,11 @@
 #include "../vfs.hpp"
 
 #include <autogen/feature_flags.h>
+#include <fs/vfs/fat/fat12.hpp>
+#include <fs/vfs/io/in_memory.hpp>
 #include <mem/heap.hpp>
 #include <mem/types.hpp>
 #include <trace_framework.hpp>
-#include <vfs/fat/fat12.hpp>
-#include <vfs/io/in_memory.hpp>
 #include "boot_args.hpp"
 #include "macros.hpp"
 
@@ -16,8 +16,8 @@ using namespace vfs;
 // Global ramdisk storage (must persist for the lifetime of the VFS)
 // ------------------------------
 
-static byte gRamdiskIoStorage[sizeof(io::InMemory)];
-static byte gRamdiskFsStorage[sizeof(Fat12<io::InMemory>)];
+static byte gRamdiskIoStorage[sizeof(vfs::io::InMemory)];
+static byte gRamdiskFsStorage[sizeof(Fat12<vfs::io::InMemory>)];
 
 // ------------------------------
 // Construction
@@ -31,10 +31,10 @@ internal::VfsModule::VfsModule(const BootArguments &args) noexcept
     if constexpr (FeatureEnabled<FeatureFlag::kRamdisk>) {
         if (args.ramdisk_args.start != nullptr && args.ramdisk_args.end > args.ramdisk_args.start) {
             auto *ramdisk_virt = Mem::PhysToVirt(args.ramdisk_args.start);
-            auto *io_ptr       = new (gRamdiskIoStorage) io::InMemory(ramdisk_virt);
+            auto *io_ptr       = new (gRamdiskIoStorage) vfs::io::InMemory(ramdisk_virt);
 
             // Validate and create Fat12 filesystem
-            if (Fat12<io::InMemory>::IsValid(*io_ptr)) {
+            if (Fat12<vfs::io::InMemory>::IsValid(*io_ptr)) {
                 auto *fat12_ptr = new (gRamdiskFsStorage) Fat12(*io_ptr);
                 auto fs         = fat12_ptr->GetFilesystem();
 
diff --git a/kernel/src/modules/vfs.hpp b/kernel/src/modules/vfs.hpp
index 3c476d7a..73a848fd 100644
--- a/kernel/src/modules/vfs.hpp
+++ b/kernel/src/modules/vfs.hpp
@@ -1,10 +1,11 @@
 #ifndef KERNEL_SRC_MODULES_VFS_HPP_
 #define KERNEL_SRC_MODULES_VFS_HPP_
 
-#include <template_lib.hpp>
-#include <vfs/types.hpp>
 #include "boot_args.hpp"
+#include "fs/file_descriptor.hpp"
+#include "fs/vfs/types.hpp"
 #include "modules/helpers.hpp"
+#include "template_lib.hpp"
 
 namespace internal
 {
@@ -22,6 +23,7 @@ class VfsModule : template_lib::StaticSingletonHelper
     // ------------------------------
 
     DEFINE_MODULE_FIELD(vfs, Mounts);
+    DEFINE_MODULE_FIELD(Fs, FdManager);
 
     // ------------------------------
     // Mount Point Management
diff --git a/kernel/src/scheduling/kworker.cpp b/kernel/src/scheduling/kworker.cpp
index a4c021e7..6e11a2fd 100644
--- a/kernel/src/scheduling/kworker.cpp
+++ b/kernel/src/scheduling/kworker.cpp
@@ -1,12 +1,21 @@
 #include "kworker.hpp"
+
+#include <fs/file_descriptor.hpp>
+#include <modules/memory.hpp>
+#include <modules/scheduling.hpp>
+#include <modules/vfs.hpp>
+#include <sys/loader.hpp>
+
 #include "hal/debug.hpp"
 #include "modules/hardware.hpp"
 #include "modules/scheduling.hpp"
+#include "scheduling/processes.hpp"
 #include "trace_framework.hpp"
 
 void Sched::KWorkerMain()
 {
     TRACE_INFO_SCHEDULING("Created new KWorker!");
+
     while (true) {
         static size_t kSpins = 1'000'000;
         for (size_t i = 0; i < kSpins; i++) {
diff --git a/kernel/src/scheduling/kworker.hpp b/kernel/src/scheduling/kworker.hpp
index 31abc3ac..76fd6799 100644
--- a/kernel/src/scheduling/kworker.hpp
+++ b/kernel/src/scheduling/kworker.hpp
@@ -5,6 +5,7 @@ namespace Sched
 {
 void KWorkerMain();
 void TraceDumperMain();
+void FdHierarchyDumperMain();
 }  // namespace Sched
 
 #endif  // KERNEL_SRC_SCHEDULING_KWORKER_HPP_
diff --git a/kernel/src/scheduling/process.hpp b/kernel/src/scheduling/process.hpp
index 8b7e4ccc..7f1a26fa 100644
--- a/kernel/src/scheduling/process.hpp
+++ b/kernel/src/scheduling/process.hpp
@@ -1,9 +1,10 @@
 #ifndef KERNEL_SRC_SCHEDULING_PROCESS_HPP_
 #define KERNEL_SRC_SCHEDULING_PROCESS_HPP_
 
+#include <types.h>
 #include <defines.hpp>
-#include <types.hpp>
 
+#include "fs/file_descriptor.hpp"
 #include "hal/tasks.hpp"
 #include "mem/types.hpp"
 
@@ -12,6 +13,12 @@ namespace Mem
 class AddressSpace;
 }
 
+// Forward declarations
+namespace Fs
+{
+class FdTable;
+}
+
 namespace Sched
 {
 struct PACK Pid {
@@ -35,6 +42,14 @@ struct Process : hal::Process {
 
     /* Process resources */
     Mem::VirtualPtr<Mem::AddressSpace> address_space;
+
+    /* File descriptor table */
+    Mem::VirtualPtr<Fs::FdTable> fd_table;
+
+    /* Standard I/O pipes (owned by process) */
+    IO::Pipe<Fs::kStdioBufferSize> stdin_pipe;
+    IO::Pipe<Fs::kStdioBufferSize> stdout_pipe;
+    IO::Pipe<Fs::kStdioBufferSize> stderr_pipe;
 };
 }  // namespace Sched
 
diff --git a/kernel/src/scheduling/processes.cpp b/kernel/src/scheduling/processes.cpp
index 5b3b53c1..f2d574ac 100644
--- a/kernel/src/scheduling/processes.cpp
+++ b/kernel/src/scheduling/processes.cpp
@@ -1,6 +1,11 @@
 #include "processes.hpp"
 #include "error.hpp"
 
+#include <data_structures/tagged_pointer.hpp>
+#include <template/scope_guard.hpp>
+#include "fs/file_descriptor.hpp"
+#include "modules/vfs.hpp"
+
 // ------------------------------
 // statics
 // ------------------------------
@@ -22,5 +27,78 @@ std::expected<Sched::Process *, Sched::Error> Sched::Processes::PrepareProcess()
     ASSERT_LE(idx, std::numeric_limits<u16>::max());
     process->pid = AssignNewPid(static_cast<u16>(idx));
 
+    auto fd_table = Mem::KMalloc<Fs::FdTable>();
+    RET_UNEXPECTED_IF(!fd_table, Error::OutOfMemory);
+
+    auto fd_table_ptr = new (*fd_table) Fs::FdTable();
+    process->fd_table = fd_table_ptr;
+
+    template_lib::ScopeGuard fd_table_guard([&]() {
+        fd_table_ptr->~FdTable();
+        Mem::KFree(fd_table_ptr);
+    });
+
+    // Get the global OpenFileTable
+    auto &open_file_table = VfsModule::Get().GetFdManager().GetOpenFileTable();
+
+    // Open stdin pipe in the global open file table
+    auto stdin_entry_result = open_file_table.OpenPipe(process->stdin_pipe);
+    RET_UNEXPECTED_IF(!stdin_entry_result, Error::OutOfMemory);
+    auto *stdin_entry = *stdin_entry_result;
+
+    // Allocate stdin file descriptor
+    auto stdin_fd_result = fd_table_ptr->AllocateFdAt(stdin_entry, Fs::kStdinFd);
+    if (!stdin_fd_result) {
+        open_file_table.CloseFile(stdin_entry);
+        return std::unexpected(Error::OutOfMemory);
+    }
+
+    // Open stdout pipe in the global open file table
+    auto stdout_entry_result = open_file_table.OpenPipe(process->stdout_pipe);
+    if (!stdout_entry_result) {
+        open_file_table.CloseFile(stdin_entry);
+        return std::unexpected(Error::OutOfMemory);
+    }
+    auto *stdout_entry = *stdout_entry_result;
+
+    // Allocate stdout file descriptor
+    auto stdout_fd_result = fd_table_ptr->AllocateFdAt(stdout_entry, Fs::kStdoutFd);
+    if (!stdout_fd_result) {
+        open_file_table.CloseFile(stdin_entry);
+        open_file_table.CloseFile(stdout_entry);
+        return std::unexpected(Error::OutOfMemory);
+    }
+
+    // Open stderr pipe in the global open file table
+    auto stderr_entry_result = open_file_table.OpenPipe(process->stderr_pipe);
+    if (!stderr_entry_result) {
+        open_file_table.CloseFile(stdin_entry);
+        open_file_table.CloseFile(stdout_entry);
+        return std::unexpected(Error::OutOfMemory);
+    }
+    auto *stderr_entry = *stderr_entry_result;
+
+    // Allocate stderr file descriptor
+    auto stderr_fd_result = fd_table_ptr->AllocateFdAt(stderr_entry, Fs::kStderrFd);
+    if (!stderr_fd_result) {
+        open_file_table.CloseFile(stdin_entry);
+        open_file_table.CloseFile(stdout_entry);
+        open_file_table.CloseFile(stderr_entry);
+        return std::unexpected(Error::OutOfMemory);
+    }
+
+    fd_table_guard.dismiss();
+
     return process;
 }
+
+void Sched::Processes::CleanupProcess(Process *process)
+{
+    ASSERT_NOT_NULL(process);
+
+    auto fd_table = process->fd_table;
+    ASSERT_NOT_NULL(fd_table);
+
+    fd_table->~FdTable();
+    Mem::KFree(fd_table);
+}
diff --git a/kernel/src/scheduling/processes.hpp b/kernel/src/scheduling/processes.hpp
index d62f4322..1266a5c0 100644
--- a/kernel/src/scheduling/processes.hpp
+++ b/kernel/src/scheduling/processes.hpp
@@ -10,6 +10,7 @@
 #include "scheduling/error.hpp"
 #include "scheduling/process.hpp"
 
+#include <hardware/core_local.hpp>
 #include <trace_framework.hpp>
 
 namespace Sched
@@ -30,6 +31,8 @@ class Processes
 
     NODISCARD std::expected<Process *, Error> PrepareProcess();
 
+    void CleanupProcess(Process *process);
+
     NODISCARD FORCE_INLINE_F std::expected<Process *, Error> GetProcess(const Pid pid)
     {
         const u16 id = pid.id;
@@ -42,6 +45,12 @@ class Processes
         return ptr;
     }
 
+    NODISCARD FORCE_INLINE_F std::expected<Process *, Error> GetCurrentProcess()
+    {
+        const Pid pid = hardware::GetRunningPid();
+        return GetProcess(pid);
+    }
+
     FORCE_INLINE_F std::expected<void, Error> Free(const Pid pid)
     {
         const u16 id = pid.id;
@@ -50,6 +59,7 @@ class Processes
             return std::unexpected(Error::ProcessNotFound);
         }
 
+        CleanupProcess(processes_.Get(id));
         processes_.Free(id);
         return {};
     }
diff --git a/kernel/src/scheduling/task_mgr.cpp b/kernel/src/scheduling/task_mgr.cpp
index f66f475f..29517030 100644
--- a/kernel/src/scheduling/task_mgr.cpp
+++ b/kernel/src/scheduling/task_mgr.cpp
@@ -3,10 +3,13 @@
 #include "constants.hpp"
 #include "modules/memory.hpp"
 #include "modules/scheduling.hpp"
+#include "modules/vfs.hpp"
 #include "scheduling/kworker.hpp"
 #include "sys/loader.hpp"
 #include "task_mgr.hpp"
-#include "vfs/path.hpp"
+
+#include <hal/panic.hpp>
+#include <sys/loader.hpp>
 
 #include "trace_framework.hpp"
 
@@ -44,10 +47,6 @@ void TaskMgr::InitializeMultitasking()
     // Spawn trace dumper
     const auto result = SpawnKernelProcess("kworker-trace-dumper", {}, TraceDumperMain);
     R_ASSERT_TRUE(static_cast<bool>(result), "Failed to spawn trace dumper process...");
-
-    // Spawn hello world process
-    const auto res = ExecuteElf64("/bin/hello", {});
-    R_ASSERT_TRUE(static_cast<bool>(res), "Failed to spawn /bin/hello process...");
 }
 
 std::expected<Pid, Error> TaskMgr::SpawnEmptyProcess(const char *name, const ProcessFlags flags)
@@ -247,6 +246,7 @@ std::expected<std::tuple<Pid, Tid>, Error> TaskMgr::ExecuteElf64(
     const char *path, const ProcessFlags flags
 )
 {
+    trace::TraceDumperTask();
     auto process = SpawnEmptyProcess(path, flags);
     RET_UNEXPECTED_IF_ERR(process);
 
diff --git a/kernel/src/scheduling/thread.hpp b/kernel/src/scheduling/thread.hpp
index 97beecd3..19603296 100644
--- a/kernel/src/scheduling/thread.hpp
+++ b/kernel/src/scheduling/thread.hpp
@@ -1,8 +1,8 @@
 #ifndef KERNEL_SRC_SCHEDULING_THREAD_HPP_
 #define KERNEL_SRC_SCHEDULING_THREAD_HPP_
 
+#include <types.h>
 #include <defines.hpp>
-#include <types.hpp>
 
 #include "hal/tasks.hpp"
 #include "process.hpp"
diff --git a/kernel/src/scheduling/threads.cpp b/kernel/src/scheduling/threads.cpp
index bb41e8ca..8a4e8ac9 100644
--- a/kernel/src/scheduling/threads.cpp
+++ b/kernel/src/scheduling/threads.cpp
@@ -1,5 +1,6 @@
 #include "threads.hpp"
 
+#include <hal/debug_terminal.hpp>
 #include <hal/scheduling.hpp>
 
 #include "mem/virt/addr_space.hpp"
diff --git a/kernel/src/sys/elf/elf.hpp b/kernel/src/sys/elf/elf.hpp
index 1c832d8d..65d58803 100644
--- a/kernel/src/sys/elf/elf.hpp
+++ b/kernel/src/sys/elf/elf.hpp
@@ -1,8 +1,8 @@
 #ifndef KERNEL_SRC_SYS_ELF_ELF_HPP_
 #define KERNEL_SRC_SYS_ELF_ELF_HPP_
 
+#include <types.h>
 #include <defines.hpp>
-#include <types.hpp>
 
 namespace System::Elf
 {
diff --git a/kernel/src/sys/loader.hpp b/kernel/src/sys/loader.hpp
index 6fd1ec84..f803853f 100644
--- a/kernel/src/sys/loader.hpp
+++ b/kernel/src/sys/loader.hpp
@@ -3,8 +3,8 @@
 
 #include <expected.hpp>
 
+#include "fs/vfs/path.hpp"
 #include "mem/virt/addr_space.hpp"
-#include "vfs/path.hpp"
 
 namespace System
 {
diff --git a/kernel/src/sys/shell.hpp b/kernel/src/sys/shell.hpp
index 2b5db9ae..ce9b1bca 100644
--- a/kernel/src/sys/shell.hpp
+++ b/kernel/src/sys/shell.hpp
@@ -5,9 +5,9 @@
 #include <span.hpp>
 #include <string.hpp>
 
+#include "fs/vfs/path.hpp"
 #include "io/stream.hpp"
 #include "sys/graphics_console.hpp"
-#include "vfs/path.hpp"
 
 namespace System
 {
diff --git a/kernel/src/syscalls/calls/fd.hpp b/kernel/src/syscalls/calls/fd.hpp
new file mode 100644
index 00000000..2546648a
--- /dev/null
+++ b/kernel/src/syscalls/calls/fd.hpp
@@ -0,0 +1,81 @@
+#ifndef KERNEL_SRC_SYSCALLS_CALLS_FD_HPP_
+#define KERNEL_SRC_SYSCALLS_CALLS_FD_HPP_
+
+#include <defines.h>
+
+#include "modules/vfs.hpp"
+
+namespace Syscall
+{
+// ------------------------------
+// File Descriptor Syscalls
+// ------------------------------
+
+/**
+ * @brief Open a file and return its file descriptor
+ * @param path Path to the file
+ * @param mode Open mode flags
+ * @return File descriptor on success, or error
+ */
+FORCE_INLINE_F Fs::FdResult<fd_t> SysOpen(const vfs::Path &path, const Fs::OpenMode mode)
+{
+    auto result = ::VfsModule::Get().GetFdManager().Open(path, mode);
+    RET_UNEXPECTED_IF_ERR(result);
+    return result.value();
+}
+
+/**
+ * @brief Close a file descriptor
+ * @param fd File descriptor to close
+ * @return Success or error
+ */
+FORCE_INLINE_F Fs::FdResult<> SysClose(fd_t fd)
+{
+    auto result = ::VfsModule::Get().GetFdManager().Close(fd);
+    RET_UNEXPECTED_IF_ERR(result);
+    return {};
+}
+
+/**
+ * @brief Read data from a file descriptor
+ * @param fd File descriptor to read from
+ * @param buffer Buffer to store read data
+ * @return Number of bytes read on success, or error
+ */
+FORCE_INLINE_F Fs::FdResult<size_t> SysRead(fd_t fd, std::span<byte> buffer)
+{
+    auto result = ::VfsModule::Get().GetFdManager().Read(fd, buffer);
+    RET_UNEXPECTED_IF_ERR(result);
+    return result.value();
+}
+
+/**
+ * @brief Write data to a file descriptor
+ * @param fd File descriptor to write to
+ * @param buffer Buffer containing data to write
+ * @return Number of bytes written on success, or error
+ */
+FORCE_INLINE_F Fs::FdResult<size_t> SysWrite(fd_t fd, std::span<const byte> buffer)
+{
+    auto result = ::VfsModule::Get().GetFdManager().Write(fd, buffer);
+    RET_UNEXPECTED_IF_ERR(result);
+    return result.value();
+}
+
+/**
+ * @brief Seek to a position in a file descriptor
+ * @param fd File descriptor to seek
+ * @param offset Offset to seek to
+ * @param whence Seek mode
+ * @return New offset on success, or error
+ */
+FORCE_INLINE_F Fs::FdResult<i64> SysSeek(fd_t fd, const i64 offset, const Fs::FdSeek whence)
+{
+    auto result = ::VfsModule::Get().GetFdManager().Seek(fd, offset, whence);
+    RET_UNEXPECTED_IF_ERR(result);
+    return result.value();
+}
+
+}  // namespace Syscall
+
+#endif  // KERNEL_SRC_SYSCALLS_CALLS_FD_HPP_
diff --git a/kernel/src/syscalls/calls/io.hpp b/kernel/src/syscalls/calls/io.hpp
new file mode 100644
index 00000000..b0626fff
--- /dev/null
+++ b/kernel/src/syscalls/calls/io.hpp
@@ -0,0 +1,47 @@
+#ifndef KERNEL_SRC_SYSCALLS_CALLS_IO_HPP_
+#define KERNEL_SRC_SYSCALLS_CALLS_IO_HPP_
+
+#include <defines.h>
+#include <types.h>
+
+#include "hal/debug_terminal.hpp"
+#include "sys/shell.hpp"
+#include "trace_framework.hpp"
+
+namespace Syscall
+{
+
+// ------------------------------
+// Debug IO Syscalls
+// ------------------------------
+
+/**
+ * @brief Write string to debug output
+ * @param buffer String to write (null-terminated)
+ */
+FORCE_INLINE_F void SysDebugWrite(const char *buffer) { DEBUG_INFO_GENERAL(buffer); }
+
+/**
+ * @brief Read line from debug input
+ * @param buffer Buffer to store input
+ * @param buffer_size Size of buffer
+ * @return Number of characters read
+ */
+FORCE_INLINE_F u64 SysDebugReadLine(char *buffer, size_t buffer_size)
+{
+    return hal::DebugTerminalReadLine(buffer, buffer_size);
+}
+
+// !!! TEMPORARY !!!
+FORCE_INLINE_F void SysWriteConsole(const char *buffer)
+{
+    if (System::g_active_console) {
+        System::g_active_console->Write(
+            std::span<const byte>(reinterpret_cast<const byte *>(buffer), strlen(buffer))
+        );
+    }
+}
+
+}  // namespace Syscall
+
+#endif  // KERNEL_SRC_SYSCALLS_CALLS_IO_HPP_
diff --git a/kernel/src/syscalls/calls/panic.hpp b/kernel/src/syscalls/calls/panic.hpp
new file mode 100644
index 00000000..58fddbc5
--- /dev/null
+++ b/kernel/src/syscalls/calls/panic.hpp
@@ -0,0 +1,27 @@
+#ifndef KERNEL_SRC_SYSCALLS_CALLS_PANIC_HPP_
+#define KERNEL_SRC_SYSCALLS_CALLS_PANIC_HPP_
+
+#include <defines.h>
+
+#include "hal/panic.hpp"
+
+namespace Syscall
+{
+
+// ------------------------------
+// Panic Syscall
+// ------------------------------
+
+/**
+ * @brief Trigger a kernel panic with a message
+ * @param msg Panic message
+ */
+NO_RET FORCE_INLINE_F void SysPanic(const char *msg)
+{
+    hal::KernelPanic(msg);
+    __builtin_unreachable();
+}
+
+}  // namespace Syscall
+
+#endif  // KERNEL_SRC_SYSCALLS_CALLS_PANIC_HPP_
diff --git a/kernel/src/syscalls/calls/time.hpp b/kernel/src/syscalls/calls/time.hpp
new file mode 100644
index 00000000..347fc832
--- /dev/null
+++ b/kernel/src/syscalls/calls/time.hpp
@@ -0,0 +1,92 @@
+#ifndef KERNEL_SRC_SYSCALLS_CALLS_TIME_HPP_
+#define KERNEL_SRC_SYSCALLS_CALLS_TIME_HPP_
+
+#include <defines.h>
+#include <sys/time.h>
+#include <types.h>
+
+#include "modules/timing.hpp"
+#include "modules/timing_constants.hpp"
+
+namespace Syscall
+{
+// ------------------------------
+// Time Syscalls
+// ------------------------------
+
+/**
+ * @brief Get clock value
+ * @param type Clock type to query
+ * @param time Output time value
+ * @param time_zone Output timezone
+ */
+FORCE_INLINE_F void SysGetClockValue(ClockType type, TimeVal *time, Timezone *time_zone)
+{
+    ASSERT_NOT_NULL(time);
+    ASSERT_NOT_NULL(time_zone);
+
+    if (!TimingModule::IsInited()) {
+        if (time != nullptr) {
+            time->seconds   = 0;
+            time->remainder = 0;
+        }
+        return;
+    }
+
+    if (time_zone != nullptr) {
+        __platform_get_timezone(time_zone);
+    }
+
+    if (time != nullptr) {
+        switch (type) {
+            case kTimeUtc: {
+                time->seconds   = TimingModule::Get().GetSystemTime().Read();
+                time->remainder = 0;
+            } break;
+            case kProcTime: {  // In microseconds
+                time->seconds   = 0;
+                time->remainder = timing::SystemTime::ReadLifeTimeNs() / 1000;
+            } break;
+            case kProcTimePrecise: {  // In nanoseconds
+                time->seconds   = 0;
+                time->remainder = timing::SystemTime::ReadLifeTimeNs();
+            } break;
+            default:
+                R_FAIL_ALWAYS("Provided invalid ClockType!");
+        }
+    }
+}
+
+/**
+ * @brief Get timezone information
+ * @param time_zone Output timezone
+ */
+FORCE_INLINE_F void SysGetTimezone(Timezone *time_zone)
+{
+    ASSERT_NOT_NULL(time_zone);
+
+    ASSERT_TRUE(TimingModule::IsInited(), "Timing module is not initialized");
+    *time_zone = TimingModule::Get().GetSystemTime().GetTimezone();
+}
+
+/**
+ * @brief Get clock ticks per second for a given clock type
+ * @param type Clock type
+ * @return Ticks per second
+ */
+FORCE_INLINE_F u64 SysGetClockTicksInSecond(ClockType type)
+{
+    const auto idx = static_cast<size_t>(type);
+    ASSERT(idx != 0 && idx < timing_constants::kClockTicksInSecondSize);
+
+    TODO_USERSPACE
+    //    if (idx == 0 || idx >= kResoSize) {
+    //        return 0;
+    //    }
+
+    return timing_constants::kClockTicksInSecond[idx];
+}
+
+}  // namespace Syscall
+
+#endif  // KERNEL_SRC_SYSCALLS_CALLS_TIME_HPP_
diff --git a/kernel/src/syscalls/dispatch_table.hpp b/kernel/src/syscalls/dispatch_table.hpp
index 62c654f3..b440ac36 100644
--- a/kernel/src/syscalls/dispatch_table.hpp
+++ b/kernel/src/syscalls/dispatch_table.hpp
@@ -12,11 +12,12 @@ namespace Syscall
 
 inline constexpr auto kNotImplemented = static_cast<hal::reg_t>(-1);
 
+template <size_t kSize>
 struct SyscallDispatchTable {
-    consteval SyscallDispatchTable()
+    constexpr SyscallDispatchTable()
     {
-        for (size_t i = 0; i < kSysMax; ++i) {
-            handlers_[i] = kDefaultHandler;
+        for (size_t i = 0; i < kSize; ++i) {
+            handlers_[i] = nullptr;
         }
     }
 
@@ -25,18 +26,34 @@ struct SyscallDispatchTable {
     consteval void RegisterHandler()
     {
         constexpr auto kIdx = static_cast<size_t>(num);
-        static_assert(kIdx < kSysMax, "Syscall number out of bounds");
+        static_assert(kIdx < kSize, "Syscall number out of bounds");
 
         handlers_[kIdx] = &SyscallWrapper<kHandler>::Invoke;
     }
 
+    template <auto kFun>
+    static consteval auto Create()
+    {
+        constexpr SyscallDispatchTable table = kFun();
+#ifdef NDEBUG
+        // static_assert(table.IsAllHandlersRegistered(), "Not all syscall handlers are
+        // registered");
+#endif
+        return table;
+    }
+
     private:
-    static constexpr auto kDefaultHandler = [](hal::reg_t, hal::reg_t, hal::reg_t, hal::reg_t,
-                                               hal::reg_t, hal::reg_t) -> hal::reg_t {
-        return kNotImplemented;
-    };
+    consteval bool IsAllHandlersRegistered() const
+    {
+        for (size_t i = 0; i < kSize; ++i) {
+            if (handlers_[i] == nullptr) {
+                return false;
+            }
+        }
+        return true;
+    }
 
-    SyscallHandler handlers_[kSysMax];
+    SyscallHandler handlers_[kSize];
 };
 
 }  // namespace Syscall
diff --git a/kernel/src/syscalls/handler.hpp b/kernel/src/syscalls/handler.hpp
index 7d22dec2..70bb9f57 100644
--- a/kernel/src/syscalls/handler.hpp
+++ b/kernel/src/syscalls/handler.hpp
@@ -1,8 +1,9 @@
 #ifndef KERNEL_SRC_SYSCALLS_HANDLER_HPP_
 #define KERNEL_SRC_SYSCALLS_HANDLER_HPP_
 
+#include <expected.hpp>
+#include <span.hpp>
 #include <type_traits.hpp>
-#include <types.hpp>
 #include <utility.hpp>
 
 #include "hal/types.hpp"
@@ -22,17 +23,56 @@ struct SyscallArgs {
     hal::reg_t arg0, arg1, arg2, arg3, arg4, arg5;
 };
 
+namespace internal
+{
+template <typename T>
+struct is_expected : std::false_type {
+};
+
+template <typename T, typename E>
+struct is_expected<std::expected<T, E>> : std::true_type {
+};
+
+template <typename T>
+constexpr bool is_expected_v = is_expected<T>::value;
+
+template <typename T>
+struct is_span : std::false_type {
+};
+
+template <typename T, std::size_t Extent>
+struct is_span<std::span<T, Extent>> : std::true_type {
+};
+
+template <typename T>
+constexpr bool is_span_v = is_span<T>::value;
+
+// Helper to get span element type
+template <typename T>
+struct span_element_type;
+
+template <typename T, std::size_t Extent>
+struct span_element_type<std::span<T, Extent>> {
+    using type = T;
+};
+
+template <typename T>
+using span_element_type_t = span_element_type<T>::type;
+}  // namespace internal
+
 template <typename T>
-concept SyscallRetType = std::is_integral_v<T> || std::is_pointer_v<T> || std::is_same_v<T, void>;
+concept SyscallRetType = std::is_integral_v<T> || std::is_pointer_v<T> || std::is_same_v<T, void> ||
+                         internal::is_expected_v<T>;
 
 template <typename T>
-concept SyscallArgType = std::is_integral_v<T> || std::is_pointer_v<T> || std::is_enum_v<T>;
+concept SyscallArgType = std::is_integral_v<T> || std::is_pointer_v<T> || std::is_enum_v<T> ||
+                         std::is_reference_v<T> || internal::is_span_v<T>;
 
 template <auto TargetFunc>
 class SyscallWrapper
 {
     public:
-    static hal::reg_t Invoke(
+    FAST_CALL hal::reg_t Invoke(
         hal::reg_t a0, hal::reg_t a1, hal::reg_t a2, hal::reg_t a3, hal::reg_t a4, hal::reg_t a5
     )
     {
@@ -41,25 +81,62 @@ class SyscallWrapper
     }
 
     private:
+    // Helper: Calculate how many register slots an argument type consumes
+    template <typename T>
+    FAST_CALL constexpr size_t ArgRegCount()
+    {
+        if constexpr (internal::is_span_v<T>) {
+            return 2;  // span needs pointer + size
+        } else {
+            return 1;
+        }
+    }
+
+    // Helper: Calculate register offset for argument at position Idx
+    template <size_t Idx, typename... Args>
+    FAST_CALL constexpr size_t CalcRegOffset()
+    {
+        if constexpr (Idx == 0) {
+            return 0;
+        } else {
+            // Get the tuple of argument types
+            using ArgTuple = std::tuple<Args...>;
+            using PrevArg  = std::tuple_element_t<Idx - 1, ArgTuple>;
+            return CalcRegOffset<Idx - 1, Args...>() + ArgRegCount<PrevArg>();
+        }
+    }
+
     // Argument Extraction and Conversion
     template <size_t Idx>
-    static hal::reg_t GetRawArg(const SyscallArgs &args)
+    FAST_CALL hal::reg_t GetRawArg(const SyscallArgs &args)
     {
         static constexpr hal::reg_t SyscallArgs::*members[] = {
             &SyscallArgs::arg0, &SyscallArgs::arg1, &SyscallArgs::arg2,
             &SyscallArgs::arg3, &SyscallArgs::arg4, &SyscallArgs::arg5
         };
-        static_assert(Idx < (sizeof(members) / sizeof(members[0])), "Syscall index out of bounds");
+        static_assert(
+            Idx < (sizeof(members) / sizeof(members[0])), "Too many syscall arguments requested"
+        );
         return args.*(members[Idx]);
     }
 
-    template <typename T>
-    static T ConvertArg(hal::reg_t val)
+    template <typename T, size_t RegIdx>
+    FAST_CALL T ConvertArg(const SyscallArgs &args)
     {
-        if constexpr (std::is_pointer_v<T>)
-            return reinterpret_cast<T>(val);
-        else
-            return static_cast<T>(val);
+        if constexpr (internal::is_span_v<T>) {
+            // Span needs two consecutive registers: pointer and size
+            using ElemType = internal::span_element_type_t<T>;
+            auto *ptr      = reinterpret_cast<ElemType *>(GetRawArg<RegIdx>(args));
+            auto size      = GetRawArg<RegIdx + 1>(args);
+            return T(ptr, size);
+        } else if constexpr (std::is_pointer_v<T>) {
+            return reinterpret_cast<T>(GetRawArg<RegIdx>(args));
+        } else if constexpr (std::is_reference_v<T>) {
+            using BaseType = std::remove_reference_t<T>;
+            return *reinterpret_cast<BaseType *>(GetRawArg<RegIdx>(args));
+        } else {
+            return static_cast<T>(GetRawArg<RegIdx>(args));
+        }
     }
 
     // Dispatcher
@@ -68,13 +145,24 @@ class SyscallWrapper
 
     template <typename Ret, size_t... Is, typename... Args>
     struct Dispatch<Ret, std::index_sequence<Is...>, Args...> {
-        static hal::reg_t operator()(const SyscallArgs &args)
+        FAST_CALL hal::reg_t operator()(const SyscallArgs &args)
         {
-            if constexpr (std::is_void_v<Ret>) {
-                TargetFunc(ConvertArg<Args>(GetRawArg<Is>(args))...);
+            if constexpr (internal::is_expected_v<Ret>) {
+                auto result = TargetFunc(ConvertArg<Args, CalcRegOffset<Is, Args...>()>(args)...);
+                if (result.has_value()) {
+                    if constexpr (std::is_void_v<typename Ret::value_type>) {
+                        return 0;
+                    } else {
+                        return static_cast<hal::reg_t>(result.value());
+                    }
+                } else {
+                    return static_cast<hal::reg_t>(-static_cast<long>(result.error()));
+                }
+            } else if constexpr (std::is_void_v<Ret>) {
+                TargetFunc(ConvertArg<Args, CalcRegOffset<Is, Args...>()>(args)...);
                 return 0;
             } else {
-                auto result = TargetFunc(ConvertArg<Args>(GetRawArg<Is>(args))...);
+                auto result = TargetFunc(ConvertArg<Args, CalcRegOffset<Is, Args...>()>(args)...);
 
                 if constexpr (std::is_pointer_v<Ret>)
                     return reinterpret_cast<hal::reg_t>(result);
@@ -87,7 +175,7 @@ class SyscallWrapper
     // Type Deduction Helper
     template <typename Ret, typename... Args>
         requires SyscallRetType<Ret> && (SyscallArgType<Args> && ...)
-    static hal::reg_t DeduceAndDispatch(const SyscallArgs &args, Ret (*)(Args...))
+    FAST_CALL hal::reg_t DeduceAndDispatch(const SyscallArgs &args, Ret (*)(Args...))
     {
         return Dispatch<Ret, std::index_sequence_for<Args...>, Args...>::operator()(args);
     }
diff --git a/kernel/src/syscalls/syscalls.cpp b/kernel/src/syscalls/syscalls.cpp
index 85d6ab25..c2ae2f30 100644
--- a/kernel/src/syscalls/syscalls.cpp
+++ b/kernel/src/syscalls/syscalls.cpp
@@ -1,4 +1,5 @@
 #include "syscalls.hpp"
+#include "dispatch_table.hpp"
 
 #include <sys/calls.h>
 
@@ -6,9 +7,9 @@ using namespace Syscall;
 
 BEGIN_DECL_C
 
-size_t g_syscall_count                                  = kSysMax;
-constinit SyscallDispatchTable g_syscall_dispatch_table = []() consteval {
-    SyscallDispatchTable table{};
+size_t g_syscall_count                  = kSysMax;
+constinit auto g_syscall_dispatch_table = SyscallDispatchTable<kSysMax>::Create<[] {
+    SyscallDispatchTable<kSysMax> table{};
 
     // Time related syscalls
     table.RegisterHandler<kSysGetClockValue, SysGetClockValue>();
@@ -23,7 +24,14 @@ constinit SyscallDispatchTable g_syscall_dispatch_table = []() consteval {
     // Panic syscall
     table.RegisterHandler<kSysPanic, SysPanic>();
 
+    // File Descriptor syscalls
+    table.RegisterHandler<kSysOpen, SysOpen>();
+    table.RegisterHandler<kSysClose, SysClose>();
+    table.RegisterHandler<kSysRead, SysRead>();
+    table.RegisterHandler<kSysWrite, SysWrite>();
+    table.RegisterHandler<kSysSeek, SysSeek>();
+
     return table;
-}();
+}>();
 
 END_DECL_C
diff --git a/kernel/src/syscalls/syscalls.hpp b/kernel/src/syscalls/syscalls.hpp
index 4ec0706d..35087a7d 100644
--- a/kernel/src/syscalls/syscalls.hpp
+++ b/kernel/src/syscalls/syscalls.hpp
@@ -1,144 +1,15 @@
 #ifndef KERNEL_SRC_SYSCALLS_SYSCALLS_HPP_
 #define KERNEL_SRC_SYSCALLS_SYSCALLS_HPP_
 
-#include <defines.h>
-#include <sys/time.h>
-#include <types.hpp>
-
-#include "dispatch_table.hpp"
-#include "hal/debug_terminal.hpp"
-#include "hal/panic.hpp"
-#include "modules/timing.hpp"
-#include "modules/timing_constants.hpp"
-
-#include <span.hpp>
-#include <sys/shell.hpp>
-
-namespace Syscall
-{
-
-// ------------------------------
-// Panic Syscall
-// ------------------------------
-
-/**
- * @brief Trigger a kernel panic with a message
- * @param msg Panic message
- */
-NO_RET FORCE_INLINE_F void SysPanic(const char *msg)
-{
-    hal::KernelPanic(msg);
-    __builtin_unreachable();
-}
-
-// ------------------------------
-// Time Syscalls
-// ------------------------------
-
-/**
- * @brief Get clock value
- * @param type Clock type to query
- * @param time Output time value
- * @param time_zone Output timezone
- */
-FORCE_INLINE_F void SysGetClockValue(ClockType type, TimeVal *time, Timezone *time_zone)
-{
-    ASSERT_NOT_NULL(time);
-    ASSERT_NOT_NULL(time_zone);
-
-    if (!TimingModule::IsInited()) {
-        if (time != nullptr) {
-            time->seconds   = 0;
-            time->remainder = 0;
-        }
-        return;
-    }
-
-    if (time_zone != nullptr) {
-        __platform_get_timezone(time_zone);
-    }
-
-    if (time != nullptr) {
-        switch (type) {
-            case kTimeUtc: {
-                time->seconds   = TimingModule::Get().GetSystemTime().Read();
-                time->remainder = 0;
-            } break;
-            case kProcTime: {  // In microseconds
-                time->seconds   = 0;
-                time->remainder = timing::SystemTime::ReadLifeTimeNs() / 1000;
-            } break;
-            case kProcTimePrecise: {  // In nanoseconds
-                time->seconds   = 0;
-                time->remainder = timing::SystemTime::ReadLifeTimeNs();
-            } break;
-            default:
-                R_FAIL_ALWAYS("Provided invalid ClockType!");
-        }
-    }
-}
-
 /**
- * @brief Get timezone information
- * @param time_zone Output timezone
+ * @brief This file collects all the system calls available in the kernel.
+ *
+ * Calls should be specified in other header files and then included here.
  */
-FORCE_INLINE_F void SysGetTimezone(Timezone *time_zone)
-{
-    ASSERT_NOT_NULL(time_zone);
-
-    ASSERT_TRUE(TimingModule::IsInited(), "Timing module is not initialized");
-    *time_zone = TimingModule::Get().GetSystemTime().GetTimezone();
-}
-
-/**
- * @brief Get clock ticks per second for a given clock type
- * @param type Clock type
- * @return Ticks per second
- */
-FORCE_INLINE_F u64 SysGetClockTicksInSecond(ClockType type)
-{
-    const auto idx = static_cast<size_t>(type);
-    ASSERT(idx != 0 && idx < timing_constants::kClockTicksInSecondSize);
-
-    TODO_USERSPACE
-    //    if (idx == 0 || idx >= kResoSize) {
-    //        return 0;
-    //    }
-
-    return timing_constants::kClockTicksInSecond[idx];
-}
-
-// ------------------------------
-// Debug IO Syscalls
-// ------------------------------
-
-/**
- * @brief Write string to debug output
- * @param buffer String to write (null-terminated)
- */
-FORCE_INLINE_F void SysDebugWrite(const char *buffer) { DEBUG_INFO_GENERAL(buffer); }
-
-/**
- * @brief Read line from debug input
- * @param buffer Buffer to store input
- * @param buffer_size Size of buffer
- * @return Number of characters read
- */
-FORCE_INLINE_F u64 SysDebugReadLine(char *buffer, size_t buffer_size)
-{
-    return hal::DebugTerminalReadLine(buffer, buffer_size);
-}
-
-// !!! TEMPORARY !!!
-FORCE_INLINE_F void SysWriteConsole(const char *buffer)
-{
-    if (System::g_active_console) {
-        System::g_active_console->Write(
-            std::span<const byte>(reinterpret_cast<const byte *>(buffer), strlen(buffer))
-        );
-    }
-}
 
-}  // namespace Syscall
+#include "calls/fd.hpp"
+#include "calls/io.hpp"
+#include "calls/panic.hpp"
+#include "calls/time.hpp"
 
 #endif  // KERNEL_SRC_SYSCALLS_SYSCALLS_HPP_
diff --git a/kernel/src/time/event_framework.hpp b/kernel/src/time/event_framework.hpp
index 3516b9a9..3aeceab0 100644
--- a/kernel/src/time/event_framework.hpp
+++ b/kernel/src/time/event_framework.hpp
@@ -1,8 +1,8 @@
 #ifndef KERNEL_SRC_TIME_EVENT_FRAMEWORK_HPP_
 #define KERNEL_SRC_TIME_EVENT_FRAMEWORK_HPP_
 
+#include <types.h>
 #include <defines.hpp>
-#include <types.hpp>
 
 namespace timing
 {
diff --git a/kernel/src/time/system_time.hpp b/kernel/src/time/system_time.hpp
index 85cdccd5..20a62fc9 100644
--- a/kernel/src/time/system_time.hpp
+++ b/kernel/src/time/system_time.hpp
@@ -30,7 +30,7 @@ class SystemTime
 
     void SyncWithHardware();
 
-    NODISCARD timezone GetTimezone() const { return time_zone_; }
+    NODISCARD Timezone GetTimezone() const { return time_zone_; }
 
     // ------------------------------
     // Class fields
@@ -45,7 +45,7 @@ class SystemTime
     /* Hard coded Poland */
     static constexpr uint64_t kPolandOffset = 1;
 
-    timezone time_zone_{
+    Timezone time_zone_{
         .west_offset_minutes     = kPolandOffset * kMinutesInHour,
         .dst_time_offset_minutes = 0,
         .dst_time_start_seconds  = static_cast<u16>(-1),
diff --git a/kernel/test/bitfield_test.cpp b/kernel/test/bitfield_test.cpp
index b3c21509..b0672d93 100644
--- a/kernel/test/bitfield_test.cpp
+++ b/kernel/test/bitfield_test.cpp
@@ -1,6 +1,6 @@
+#include <types.h>
 #include <data_structures/bitfield.hpp>
 #include <test_module/test.hpp>
-#include <types.hpp>
 
 class BitFieldTest : public TestGroupBase
 {
diff --git a/kernel/test/ref_count_test.cpp b/kernel/test/ref_count_test.cpp
new file mode 100644
index 00000000..1a3ab80d
--- /dev/null
+++ b/kernel/test/ref_count_test.cpp
@@ -0,0 +1,240 @@
+#include <test_module/test.hpp>
+
+#include <data_structures/ref_count.hpp>
+#include "mem/heap.hpp"
+
+using namespace data_structures;
+using namespace Mem;
+
+class RefCountTest : public TestGroupBase
+{
+};
+
+namespace
+{
+class RefCountedObject : public RefCounted<RefCountedObject, true>
+{
+    public:
+    int value;
+    bool *destroyed_flag;
+
+    RefCountedObject(int v, bool *flag) : value(v), destroyed_flag(flag) {}
+    ~RefCountedObject()
+    {
+        if (destroyed_flag) {
+            *destroyed_flag = true;
+        }
+    }
+};
+}  // namespace
+
+TEST_F(RefCountTest, BasicRefCounted)
+{
+    bool destroyed = false;
+    auto obj_res   = KNew<RefCountedObject>(42, &destroyed);
+    R_ASSERT_TRUE(obj_res);
+    auto *obj = *obj_res;
+    obj->SetDeleter([](RefCountedObject *ptr) {
+        KDelete(ptr);
+    });
+
+    R_ASSERT_FALSE(obj->HasRefs());
+    R_ASSERT_EQ(0u, obj->GetRefCount());
+
+    obj->AddRef();
+    R_ASSERT_TRUE(obj->HasRefs());
+    R_ASSERT_EQ(1u, obj->GetRefCount());
+
+    obj->AddRef();
+    R_ASSERT_EQ(2u, obj->GetRefCount());
+
+    obj->Release();
+    R_ASSERT_EQ(1u, obj->GetRefCount());
+    R_ASSERT_FALSE(destroyed);
+
+    obj->Release();
+    R_ASSERT_TRUE(destroyed);
+}
+
+TEST_F(RefCountTest, RefPtrBasic)
+{
+    bool destroyed = false;
+
+    {
+        auto obj_res = KNew<RefCountedObject>(42, &destroyed);
+        R_ASSERT_TRUE(obj_res);
+        (*obj_res)->SetDeleter([](RefCountedObject *ptr) {
+            KDelete(ptr);
+        });
+        RefPtr ptr1(*obj_res);
+        R_ASSERT_TRUE(ptr1);
+        R_ASSERT_EQ(42, ptr1->value);
+        R_ASSERT_EQ(1u, ptr1->GetRefCount());
+        R_ASSERT_FALSE(destroyed);
+
+        {
+            RefPtr<RefCountedObject> ptr2 = ptr1;
+            R_ASSERT_EQ(2u, ptr1->GetRefCount());
+            R_ASSERT_EQ(2u, ptr2->GetRefCount());
+            R_ASSERT_FALSE(destroyed);
+        }
+
+        R_ASSERT_EQ(1u, ptr1->GetRefCount());
+        R_ASSERT_FALSE(destroyed);
+    }
+
+    R_ASSERT_TRUE(destroyed);
+}
+
+TEST_F(RefCountTest, RefPtrMove)
+{
+    bool destroyed = false;
+
+    {
+        auto obj_res = KNew<RefCountedObject>(100, &destroyed);
+        R_ASSERT_TRUE(obj_res);
+        (*obj_res)->SetDeleter([](RefCountedObject *ptr) {
+            KDelete(ptr);
+        });
+        RefPtr ptr1(*obj_res);
+        R_ASSERT_EQ(1u, ptr1->GetRefCount());
+
+        RefPtr<RefCountedObject> ptr2 = std::move(ptr1);
+        R_ASSERT_FALSE(ptr1);
+        R_ASSERT_TRUE(ptr2);
+        R_ASSERT_EQ(1u, ptr2->GetRefCount());
+        R_ASSERT_FALSE(destroyed);
+    }
+
+    R_ASSERT_TRUE(destroyed);
+}
+
+TEST_F(RefCountTest, RefPtrReset)
+{
+    bool destroyed = false;
+    auto obj_res   = KNew<RefCountedObject>(42, &destroyed);
+    R_ASSERT_TRUE(obj_res);
+    (*obj_res)->SetDeleter([](RefCountedObject *ptr) {
+        KDelete(ptr);
+    });
+    RefPtr ptr(*obj_res);
+
+    R_ASSERT_TRUE(ptr);
+    R_ASSERT_FALSE(destroyed);
+
+    ptr.Reset();
+    R_ASSERT_FALSE(ptr);
+    R_ASSERT_TRUE(destroyed);
+}
+
+TEST_F(RefCountTest, MakeRefCounted)
+{
+    bool destroyed = false;
+
+    {
+        auto ptr = MakeRefCounted<RefCountedObject>(42, &destroyed);
+        R_ASSERT_TRUE(ptr);
+        R_ASSERT_EQ(42, ptr->value);
+        R_ASSERT_EQ(1u, ptr->GetRefCount());
+        R_ASSERT_FALSE(destroyed);
+    }
+
+    R_ASSERT_TRUE(destroyed);
+}
+
+TEST_F(RefCountTest, AdoptRef)
+{
+    bool destroyed = false;
+    auto obj_res   = KNew<RefCountedObject>(42, &destroyed);
+    R_ASSERT_TRUE(obj_res);
+    auto *obj = *obj_res;
+    obj->SetDeleter([](RefCountedObject *ptr) {
+        KDelete(ptr);
+    });
+
+    obj->AddRef();
+    R_ASSERT_EQ(1u, obj->GetRefCount());
+
+    {
+        auto ptr = RefPtr(obj, false);
+        R_ASSERT_EQ(1u, ptr->GetRefCount());
+        R_ASSERT_FALSE(destroyed);
+    }
+
+    R_ASSERT_TRUE(destroyed);
+}
+
+TEST_F(RefCountTest, RefPtrAssignment)
+{
+    bool destroyed1 = false;
+    bool destroyed2 = false;
+
+    auto obj1_res = KNew<RefCountedObject>(1, &destroyed1);
+    R_ASSERT_TRUE(obj1_res);
+    (*obj1_res)->SetDeleter([](RefCountedObject *ptr) {
+        KDelete(ptr);
+    });
+    RefPtr ptr1(*obj1_res);
+
+    auto obj2_res = KNew<RefCountedObject>(2, &destroyed2);
+    R_ASSERT_TRUE(obj2_res);
+    (*obj2_res)->SetDeleter([](RefCountedObject *ptr) {
+        KDelete(ptr);
+    });
+    RefPtr ptr2(*obj2_res);
+
+    R_ASSERT_EQ(1u, ptr1->GetRefCount());
+    R_ASSERT_EQ(1u, ptr2->GetRefCount());
+
+    ptr1 = ptr2;
+
+    R_ASSERT_TRUE(destroyed1);
+    R_ASSERT_FALSE(destroyed2);
+    R_ASSERT_EQ(2u, ptr2->GetRefCount());
+    R_ASSERT_EQ(ptr1.Get(), ptr2.Get());
+}
+
+TEST_F(RefCountTest, RefPtrComparison)
+{
+    auto ptr1     = MakeRefCounted<RefCountedObject>(1, nullptr);
+    auto ptr2     = ptr1;
+    auto obj3_res = KNew<RefCountedObject>(2, nullptr);
+    R_ASSERT_TRUE(obj3_res);
+    (*obj3_res)->SetDeleter([](RefCountedObject *ptr) {
+        KDelete(ptr);
+    });
+    RefPtr ptr3(*obj3_res);
+    RefPtr<RefCountedObject> ptr_null;
+
+    R_ASSERT_TRUE(ptr1 == ptr2);
+    R_ASSERT_FALSE(ptr1 != ptr2);
+    R_ASSERT_TRUE(ptr1 != ptr3);
+    R_ASSERT_FALSE(ptr1 == ptr3);
+
+    R_ASSERT_TRUE(ptr_null == nullptr);
+    R_ASSERT_FALSE(ptr_null != nullptr);
+    R_ASSERT_FALSE(ptr1 == nullptr);
+    R_ASSERT_TRUE(ptr1 != nullptr);
+}
+
+TEST_F(RefCountTest, RefPtrDetach)
+{
+    bool destroyed = false;
+    auto obj_res   = KNew<RefCountedObject>(42, &destroyed);
+    R_ASSERT_TRUE(obj_res);
+    (*obj_res)->SetDeleter([](RefCountedObject *ptr) {
+        KDelete(ptr);
+    });
+    RefPtr ptr(*obj_res);
+
+    R_ASSERT_EQ(1u, ptr->GetRefCount());
+
+    RefCountedObject *raw = ptr.Detach();
+    R_ASSERT_FALSE(ptr);
+    R_ASSERT_TRUE(raw != nullptr);
+    R_ASSERT_EQ(1u, raw->GetRefCount());
+    R_ASSERT_FALSE(destroyed);
+
+    raw->Release();
+    R_ASSERT_TRUE(destroyed);
+}
diff --git a/kernel/test/tagged_pointer_test.cpp b/kernel/test/tagged_pointer_test.cpp
index e9ff57cb..1c613648 100644
--- a/kernel/test/tagged_pointer_test.cpp
+++ b/kernel/test/tagged_pointer_test.cpp
@@ -1,8 +1,14 @@
 #include <test_module/test.hpp>
 
 #include <data_structures/tagged_pointer.hpp>
+#include "mem/heap.hpp"
 
 using namespace data_structures;
+using namespace Mem;
+
+// ============================================================================
+// TaggedPointer tests
+// ============================================================================
 
 class TaggedPointerTest : public TestGroupBase
 {
@@ -19,11 +25,10 @@ struct AlignedStruct2 {
     AlignedStruct2(long long x, long long y, long long z) : a(x), b(y), c(z) {}
 };
 
-using TagPtr = TaggedPointer<AlignedStruct1, AlignedStruct2>;
+using TagPtr = OwningTaggedPtr<AlignedStruct1, AlignedStruct2>;
 
 TEST_F(TaggedPointerTest, BasicCreateAndIs)
 {
-    // Test Create with tag dispatch - uses universal reference binding
     auto ptr1 = TagPtr::Construct<AlignedStruct1>(42);
     R_ASSERT_TRUE(ptr1.IsValid());
     R_ASSERT_TRUE(ptr1.Is<AlignedStruct1>());
@@ -55,19 +60,211 @@ TEST_F(TaggedPointerTest, MoveSemantics)
     auto ptr1 = TagPtr::Construct<AlignedStruct1>(123);
     R_ASSERT_TRUE(ptr1.IsValid());
 
-    // Move construction
     auto ptr2 = std::move(ptr1);
-    R_ASSERT_FALSE(ptr1.IsValid());  // moved-from object is invalid
+    R_ASSERT_FALSE(ptr1.IsValid());
     R_ASSERT_TRUE(ptr2.IsValid());
     R_ASSERT_EQ(123, ptr2.As<AlignedStruct1>().value);
 
-    // Move assignment
     auto ptr3 = TagPtr::Construct<AlignedStruct2>(5LL, 10LL, 15LL);
     R_ASSERT_TRUE(ptr3.IsValid());
 
     ptr3 = std::move(ptr2);
-    R_ASSERT_FALSE(ptr2.IsValid());  // moved-from object is invalid
+    R_ASSERT_FALSE(ptr2.IsValid());
     R_ASSERT_TRUE(ptr3.IsValid());
     R_ASSERT_TRUE(ptr3.Is<AlignedStruct1>());
     R_ASSERT_EQ(123, ptr3.As<AlignedStruct1>().value);
 }
+
+// ============================================================================
+// RefCountedTaggedPtr tests
+// ============================================================================
+
+class RefCountedTaggedPtrTest : public TestGroupBase
+{
+};
+
+namespace
+{
+class RefCountedObject : public RefCounted<RefCountedObject, false>
+{
+    public:
+    int value;
+    bool *destroyed_flag;
+
+    RefCountedObject(int v, bool *flag) : value(v), destroyed_flag(flag) {}
+
+    ~RefCountedObject()
+    {
+        if (destroyed_flag) {
+            *destroyed_flag = true;
+        }
+    }
+};
+
+struct TestStruct {
+    int value;
+    TestStruct(int v) : value(v) {}
+};
+}  // namespace
+
+TEST_F(RefCountedTaggedPtrTest, AutoDetectRefCounted)
+{
+    using TestPtr = NonOwningTaggedPtr<RefCountedObject, TestStruct>;
+
+    bool destroyed = false;
+    auto obj       = RefCountedObject(42, &destroyed);
+
+    R_ASSERT_EQ(0u, obj.GetRefCount());
+
+    {
+        auto ptr = TestPtr::Wrap(&obj);
+        R_ASSERT_TRUE(ptr);
+        R_ASSERT_TRUE(ptr.Is<RefCountedObject>());
+        R_ASSERT_EQ(42, ptr.As<RefCountedObject>().value);
+        R_ASSERT_EQ(1u, obj.GetRefCount());
+        R_ASSERT_FALSE(destroyed);
+    }
+
+    R_ASSERT_TRUE(destroyed);
+}
+
+TEST_F(RefCountedTaggedPtrTest, CopyIncrementsRef)
+{
+    using TestPtr = NonOwningTaggedPtr<RefCountedObject>;
+
+    bool destroyed = false;
+    auto obj       = RefCountedObject(100, &destroyed);
+
+    {
+        auto ptr1 = TestPtr::Wrap(&obj);
+        R_ASSERT_EQ(1u, obj.GetRefCount());
+
+        {
+            // Copy auto-increments ref count for RefCounted types
+            auto ptr2 = ptr1;
+            R_ASSERT_EQ(2u, obj.GetRefCount());
+            R_ASSERT_FALSE(destroyed);
+        }
+
+        // ptr2 destroyed, ref count should drop to 1
+        R_ASSERT_EQ(1u, obj.GetRefCount());
+        R_ASSERT_FALSE(destroyed);
+    }
+
+    // ptr1 destroyed, object should be deleted
+    R_ASSERT_TRUE(destroyed);
+}
+
+TEST_F(RefCountedTaggedPtrTest, MoveDoesNotChangeRef)
+{
+    using TestPtr = NonOwningTaggedPtr<RefCountedObject>;
+
+    bool destroyed = false;
+    auto obj       = RefCountedObject(200, &destroyed);
+
+    {
+        auto ptr1 = TestPtr::Wrap(&obj);
+        R_ASSERT_EQ(1u, obj.GetRefCount());
+
+        auto ptr2 = std::move(ptr1);
+        R_ASSERT_FALSE(ptr1);
+        R_ASSERT_TRUE(ptr2);
+        R_ASSERT_EQ(1u, obj.GetRefCount());
+        R_ASSERT_FALSE(destroyed);
+    }
+
+    R_ASSERT_TRUE(destroyed);
+}
+
+TEST_F(RefCountedTaggedPtrTest, MixedRefCountedAndNonRefCounted)
+{
+    using TestPtr = NonOwningTaggedPtr<RefCountedObject, TestStruct>;
+
+    bool destroyed = false;
+    auto obj       = RefCountedObject(42, &destroyed);
+    TestStruct regular_obj(99);
+
+    {
+        auto ptr1 = TestPtr::Wrap(&obj);
+        R_ASSERT_TRUE(ptr1.Is<RefCountedObject>());
+        R_ASSERT_FALSE(ptr1.Is<TestStruct>());
+        R_ASSERT_EQ(1u, obj.GetRefCount());
+
+        auto ptr2 = TestPtr::Wrap(&regular_obj);
+        R_ASSERT_FALSE(ptr2.Is<RefCountedObject>());
+        R_ASSERT_TRUE(ptr2.Is<TestStruct>());
+        R_ASSERT_EQ(99, ptr2.As<TestStruct>().value);
+
+        R_ASSERT_FALSE(destroyed);
+    }
+
+    R_ASSERT_TRUE(destroyed);
+}
+
+TEST_F(RefCountedTaggedPtrTest, AssignmentHandlesRefCounting)
+{
+    using TestPtr = NonOwningTaggedPtr<RefCountedObject>;
+
+    bool destroyed1 = false;
+    bool destroyed2 = false;
+
+    auto obj1 = RefCountedObject(1, &destroyed1);
+    auto obj2 = RefCountedObject(2, &destroyed2);
+
+    {
+        auto ptr1 = TestPtr::Wrap(&obj1);
+        auto ptr2 = TestPtr::Wrap(&obj2);
+
+        R_ASSERT_EQ(1u, obj1.GetRefCount());
+        R_ASSERT_EQ(1u, obj2.GetRefCount());
+
+        ptr1 = ptr2;
+
+        R_ASSERT_TRUE(destroyed1);   // obj1 should be destroyed
+        R_ASSERT_FALSE(destroyed2);  // obj2 still alive
+        R_ASSERT_EQ(2u, obj2.GetRefCount());
+    }
+
+    R_ASSERT_TRUE(destroyed2);
+}
+
+TEST_F(RefCountedTaggedPtrTest, NonOwnedCanCopy)
+{
+    using NonOwnedPtr = NonOwningTaggedPtr<TestStruct>;
+
+    TestStruct obj(42);
+    auto ptr1 = NonOwnedPtr::Wrap(&obj);
+
+    auto ptr2 = ptr1;
+    R_ASSERT_TRUE(ptr2);
+    R_ASSERT_EQ(42, ptr2.As<TestStruct>().value);
+
+    NonOwnedPtr ptr3;
+    ptr3 = ptr1;
+    R_ASSERT_TRUE(ptr3);
+}
+
+TEST_F(RefCountedTaggedPtrTest, MixedNonOwnedCanCopy)
+{
+    struct Obj1 {
+        int a;
+    };
+    struct Obj2 {
+        int b;
+    };
+
+    using MixedPtr = TaggedPointer<NonOwned<Obj1>, NonOwned<Obj2>>;
+
+    Obj1 o1{1};
+    Obj2 o2{2};
+
+    auto ptr1 = MixedPtr::Wrap(&o1);
+    auto ptr2 = MixedPtr::Wrap(&o2);
+
+    // Both should be copyable
+    auto ptr1_copy = ptr1;
+    auto ptr2_copy = ptr2;
+
+    R_ASSERT_TRUE(ptr1_copy.Is<Obj1>());
+    R_ASSERT_TRUE(ptr2_copy.Is<Obj2>());
+}
diff --git a/kernel/test/vfs/fat/fat12_test.cpp b/kernel/test/vfs/fat/fat12_test.cpp
index 4132fcb3..d2b1e400 100644
--- a/kernel/test/vfs/fat/fat12_test.cpp
+++ b/kernel/test/vfs/fat/fat12_test.cpp
@@ -1,9 +1,9 @@
 #include <test_module/test.hpp>
 
 #include <string.h>
-#include <vfs/fat/fat12.hpp>
-#include <vfs/io/in_memory.hpp>
-#include <vfs/path.hpp>
+#include <fs/vfs/fat/fat12.hpp>
+#include <fs/vfs/io/in_memory.hpp>
+#include <fs/vfs/path.hpp>
 
 // FAT12 disk image layout helper
 // A minimal FAT12 filesystem for testing
diff --git a/kernel/test/vfs/path_test.cpp b/kernel/test/vfs/path_test.cpp
index 162417cd..48c51a8f 100644
--- a/kernel/test/vfs/path_test.cpp
+++ b/kernel/test/vfs/path_test.cpp
@@ -1,6 +1,6 @@
 #include <test_module/test.hpp>
 
-#include <vfs/path.hpp>
+#include <fs/vfs/path.hpp>
 
 class VFSPathTest : public TestGroupBase
 {
diff --git a/kernel/test/vfs/vfs_module_test.cpp b/kernel/test/vfs/vfs_module_test.cpp
index 5a7383fa..353e686e 100644
--- a/kernel/test/vfs/vfs_module_test.cpp
+++ b/kernel/test/vfs/vfs_module_test.cpp
@@ -1,12 +1,13 @@
 #include <test_module/test.hpp>
 
 #include <string.h>
+#include <fs/vfs/fat/fat12.hpp>
+#include <fs/vfs/io/in_memory.hpp>
+#include <fs/vfs/path.hpp>
 #include <mem/heap.hpp>
 #include <memory.hpp>
 #include <modules/vfs.hpp>
-#include <vfs/fat/fat12.hpp>
-#include <vfs/io/in_memory.hpp>
-#include <vfs/path.hpp>
+#include <vfs.hpp>
 
 class VfsFat12ImageHelper
 {
diff --git a/kernel/thirdparty/uacpi/CMakeLists.txt b/kernel/thirdparty/uacpi/CMakeLists.txt
index b5728ae1..133d7598 100644
--- a/kernel/thirdparty/uacpi/CMakeLists.txt
+++ b/kernel/thirdparty/uacpi/CMakeLists.txt
@@ -7,7 +7,7 @@ message(STATUS "    -> uACPI...")
 FetchContent_Declare(
         uacpi
         GIT_REPOSITORY https://github.com/UltraOS/uACPI.git
-        GIT_TAG 2.1.0
+        GIT_TAG 3.2.0
 )
 
 FetchContent_MakeAvailable(uacpi)
diff --git a/libs/libc/arch/x86_64/syscall.h b/libs/libc/arch/x86_64/syscall.h
index 71abff3c..f8dcc51d 100644
--- a/libs/libc/arch/x86_64/syscall.h
+++ b/libs/libc/arch/x86_64/syscall.h
@@ -3,7 +3,7 @@
 
 #include "defines.h"
 #include "macro.hpp"
-#include "types.hpp"
+#include "types.h"
 
 /**
  * @file syscall.h
diff --git a/libs/libc/src/abi/platform.h b/libs/libc/src/abi/platform.h
index 3d732684..ff0afaeb 100644
--- a/libs/libc/src/abi/platform.h
+++ b/libs/libc/src/abi/platform.h
@@ -1,9 +1,11 @@
-#ifndef LIBS_LIBC_ABI_PLATFORM_H_
-#define LIBS_LIBC_ABI_PLATFORM_H_
+#ifndef LIBS_LIBC_SRC_ABI_PLATFORM_H_
+#define LIBS_LIBC_SRC_ABI_PLATFORM_H_
 
-#include <sys/time.h>
-#include <types.hpp>
 #include "defines.h"
+#include "sys/time.h"
+#include "types.h"
+
+#include <sys/fd.h>
 
 BEGIN_DECL_C
 
@@ -20,6 +22,13 @@ void __platform_debug_write(const char *buffer);
 size_t __platform_debug_read_line(char *buffer, size_t buffer_size);
 void __platform_write_console(const char *buffer);
 
+// File Descriptor Related
+int __platform_open(const char *pathname, int flags);
+int __platform_close(int fd);
+ssize_t __platform_read(int fd, void *buf, size_t count);
+ssize_t __platform_write(int fd, const void *buf, size_t count);
+ssize_t __platform_seek(int fd, ssize_t offset, FdSeek whence);
+
 END_DECL_C
 
-#endif  // LIBS_LIBC_ABI_PLATFORM_H_
+#endif  // LIBS_LIBC_SRC_ABI_PLATFORM_H_
diff --git a/libs/libc/src/include/assert_base.hpp b/libs/libc/src/include/assert_base.hpp
index f7770795..71f9a9e7 100644
--- a/libs/libc/src/include/assert_base.hpp
+++ b/libs/libc/src/include/assert_base.hpp
@@ -1,5 +1,5 @@
-#ifndef LIBS_LIBC_INCLUDE_ASSERT_BASE_HPP_
-#define LIBS_LIBC_INCLUDE_ASSERT_BASE_HPP_
+#ifndef LIBS_LIBC_SRC_INCLUDE_ASSERT_BASE_HPP_
+#define LIBS_LIBC_SRC_INCLUDE_ASSERT_BASE_HPP_
 
 #include <assert.h>
 #include <defines.h>
@@ -7,9 +7,9 @@
 #include <stdio.h>
 #include <string.h>
 #include <todo.h>
+#include <types.h>
 #include <formats.hpp>
 #include <type_traits.hpp>
-#include <types.hpp>
 #include <utility.hpp>
 
 // -------------------------------------
@@ -684,4 +684,4 @@ FAST_CALL void VerboseAssertStrNeq(
         TOSTRING(__LINE__) __VA_OPT__(, ) __VA_ARGS__           \
     )
 
-#endif  // LIBS_LIBC_INCLUDE_ASSERT_BASE_HPP_
+#endif  // LIBS_LIBC_SRC_INCLUDE_ASSERT_BASE_HPP_
diff --git a/libs/libc/src/include/ctype.h b/libs/libc/src/include/ctype.h
index 966ac367..a2ab048a 100644
--- a/libs/libc/src/include/ctype.h
+++ b/libs/libc/src/include/ctype.h
@@ -1,8 +1,8 @@
-#ifndef LIBS_LIBC_INCLUDE_CTYPE_H_
-#define LIBS_LIBC_INCLUDE_CTYPE_H_
+#ifndef LIBS_LIBC_SRC_INCLUDE_CTYPE_H_
+#define LIBS_LIBC_SRC_INCLUDE_CTYPE_H_
 
 #include <defines.h>
-#include <types.hpp>
+#include <types.h>
 
 namespace internal
 {
@@ -205,4 +205,4 @@ CONSTEXPR int toupper(int c) { return islower(c) ? c - 0x20 : c; }
 
 END_DECL_C
 
-#endif  // LIBS_LIBC_INCLUDE_CTYPE_H_
+#endif  // LIBS_LIBC_SRC_INCLUDE_CTYPE_H_
diff --git a/libs/libc/src/include/math.h b/libs/libc/src/include/math.h
index 8a75ea74..0ff46387 100644
--- a/libs/libc/src/include/math.h
+++ b/libs/libc/src/include/math.h
@@ -1,9 +1,9 @@
-#ifndef LIBS_LIBC_INCLUDE_MATH_H_
-#define LIBS_LIBC_INCLUDE_MATH_H_
+#ifndef LIBS_LIBC_SRC_INCLUDE_MATH_H_
+#define LIBS_LIBC_SRC_INCLUDE_MATH_H_
 
 #include <defines.h>
 #include <stdint.h>
-#include <types.hpp>
+#include <types.h>
 
 /**********************************************
  * Constants
@@ -40,4 +40,4 @@ union __DoubleBits {
 #include <math/checks.h>
 #include <math/operations.hpp>
 
-#endif  // LIBS_LIBC_INCLUDE_MATH_H_
+#endif  // LIBS_LIBC_SRC_INCLUDE_MATH_H_
diff --git a/libs/libc/src/include/stdio.h b/libs/libc/src/include/stdio.h
index c4d8c953..48bfecbb 100644
--- a/libs/libc/src/include/stdio.h
+++ b/libs/libc/src/include/stdio.h
@@ -1,11 +1,43 @@
-#ifndef LIBS_LIBC_INCLUDE_STDIO_H_
-#define LIBS_LIBC_INCLUDE_STDIO_H_
+#ifndef LIBS_LIBC_SRC_INCLUDE_STDIO_H_
+#define LIBS_LIBC_SRC_INCLUDE_STDIO_H_
 
-#include <defines.h>
-#include <stdarg.h>
-#include <stddef.h>
+#include "defines.h"
+#include "stdarg.h"
+#include "stdbool.h"
+#include "stddef.h"
+#include "sys/calls/fd.h"
+
+#define BUFSIZ 4096
+
+#define _IOFBF kFdBufferFull
+#define _IOLBF kFdBufferLine
+#define _IONBF kFdBufferNone
+
+typedef struct {
+    // File descriptor
+    fd_t fd;  // Underlying file descriptor
+
+    struct {
+        FdOpenFlags open_mode : 8;     // Open mode
+        FdBufferMode buffer_mode : 4;  // Buffering mode
+        bool eof : 1;                  // End-of-file flag
+        bool error : 1;                // Error flag
+        bool closed : 1;               // True if file is closed
+        bool is_buffer_owner : 1;      // True if we own the buffer memory
+    } flags;
+
+    // Buffering
+    byte *buffer;         // Buffer pointer
+    size_t buffer_size;   // Buffer size
+    size_t buffer_pos;    // Current position in buffer
+    size_t buffer_level;  // Number of valid bytes in buffer
+
+    // File position
+    u64 file_pos;  // Current file position (for unbuffered I/O)
+} FILE;
 
 BEGIN_DECL_C
+
 /**
  *  Writes formatted output to a character array (*str) up to a maximum amount of characters (size)
  */
@@ -16,6 +48,31 @@ int snprintf(char *str, size_t size, const char *format, ...);
  */
 int vsnprintf(char *str, size_t size, const char *format, va_list va);
 
+/**
+ *  Opens a file and returns a FILE pointer
+ */
+FILE *fopen(const char *pathname, const char *mode);
+
+/**
+ *  Closes a FILE pointer
+ */
+int fclose(FILE *stream);
+
+/**
+ *  Reads data from a FILE pointer into a buffer
+ */
+size_t fread(void *buf, size_t size, size_t count, FILE *stream);
+
+/**
+ *  Writes data from a buffer to a FILE pointer
+ */
+size_t fwrite(const void *buf, size_t size, size_t count, FILE *stream);
+
+// Standard file streams
+extern FILE *stdin;
+extern FILE *stdout;
+extern FILE *stderr;
+
 END_DECL_C
 
-#endif  // LIBS_LIBC_INCLUDE_STDIO_H_
+#endif  // LIBS_LIBC_SRC_INCLUDE_STDIO_H_
diff --git a/libs/libc/src/include/sys/calls.h b/libs/libc/src/include/sys/calls.h
index 88c31628..bc5aca5b 100644
--- a/libs/libc/src/include/sys/calls.h
+++ b/libs/libc/src/include/sys/calls.h
@@ -23,6 +23,13 @@ enum SyscallNumber {
     /* Panic/Program termination */
     kSysPanic,
 
+    /* File descriptor syscalls */
+    kSysOpen,
+    kSysClose,
+    kSysRead,
+    kSysWrite,
+    kSysSeek,
+
     kSysMax,
 };
 
diff --git a/libs/libc/src/include/sys/calls/fd.h b/libs/libc/src/include/sys/calls/fd.h
new file mode 100644
index 00000000..972030d6
--- /dev/null
+++ b/libs/libc/src/include/sys/calls/fd.h
@@ -0,0 +1,55 @@
+#ifndef LIBS_LIBC_SRC_INCLUDE_SYS_CALLS_FD_H_
+#define LIBS_LIBC_SRC_INCLUDE_SYS_CALLS_FD_H_
+
+#include "defines.h"
+#include "platform.h"
+#include "sys/fd.h"
+#include "types.h"
+
+BEGIN_DECL_C
+
+/**
+ * @brief Open a file
+ * @param pathname Path to the file
+ * @param flags Open mode flags
+ * @return File descriptor on success, -1 on failure
+ */
+FAST_CALL fd_t OpenFd(const char *pathname, FdOpenFlags flags)
+{
+    return __platform_open(pathname, flags);
+}
+
+/**
+ * @brief Close a file descriptor
+ * @param fd File descriptor to close
+ * @return 0 on success, -1 on failure
+ */
+FAST_CALL int CloseFd(fd_t fd) { return __platform_close(fd); }
+
+/**
+ * @brief Read from a file descriptor
+ * @param fd File descriptor to read from
+ * @param buf Buffer to store read data
+ * @param count Number of bytes to read
+ * @return Number of bytes read on success, -1 on failure
+ */
+FAST_CALL ssize_t ReadFromFd(fd_t fd, void *buf, size_t count)
+{
+    return __platform_read(fd, buf, count);
+}
+
+/**
+ * @brief Write to a file descriptor
+ * @param fd File descriptor to write to
+ * @param buf Buffer containing data to write
+ * @param count Number of bytes to write
+ * @return Number of bytes written on success, -1 on failure
+ */
+FAST_CALL ssize_t WriteToFd(fd_t fd, const void *buf, size_t count)
+{
+    return __platform_write(fd, buf, count);
+}
+
+END_DECL_C
+
+#endif  // LIBS_LIBC_SRC_INCLUDE_SYS_CALLS_FD_H_
diff --git a/libs/libc/src/include/sys/fd.h b/libs/libc/src/include/sys/fd.h
new file mode 100644
index 00000000..507a7c7d
--- /dev/null
+++ b/libs/libc/src/include/sys/fd.h
@@ -0,0 +1,24 @@
+#ifndef LIBS_LIBC_SRC_INCLUDE_SYS_FD_H_
+#define LIBS_LIBC_SRC_INCLUDE_SYS_FD_H_
+
+typedef int fd_t;
+
+typedef enum {
+    kFdFlagRead      = 0x1,
+    kFdFlagWrite     = 0x2,
+    kFdFlagReadWrite = kFdFlagRead | kFdFlagWrite,
+    kFdFlagAppend    = 0x4,
+    kFdFlagCreate    = 0x8,
+    kFdFlagTruncate  = 0x10,
+    kFdFlagNonBlock  = 0x20,
+    kFdFlagSync      = 0x40
+} FdOpenFlags;
+
+// Standard file descriptors
+enum { kFdStdIn = 0, kFdStdOut = 1, kFdStdErr = 2 };
+
+typedef enum { kFdBufferNone = 0, kFdBufferLine = 1, kFdBufferFull = 2 } FdBufferMode;
+
+typedef enum { kFdSeekSet = 0, kFdSeekCurrent = 1, kFdSeekEnd = 2 } FdSeek;
+
+#endif  // LIBS_LIBC_SRC_INCLUDE_SYS_FD_H_
diff --git a/libs/libc/src/include/sys/time.h b/libs/libc/src/include/sys/time.h
index e0e8bdd0..22b272e9 100644
--- a/libs/libc/src/include/sys/time.h
+++ b/libs/libc/src/include/sys/time.h
@@ -1,34 +1,34 @@
-#ifndef LIBS_LIBC_INCLUDE_SYS_TIME_H_
-#define LIBS_LIBC_INCLUDE_SYS_TIME_H_
+#ifndef LIBS_LIBC_SRC_INCLUDE_SYS_TIME_H_
+#define LIBS_LIBC_SRC_INCLUDE_SYS_TIME_H_
 
 #include <stdint.h>
-#include <types.hpp>
+#include <types.h>
 
 // ------------------------------
 // Known time types
 // ------------------------------
 
-enum ClockType {
+typedef enum {
     kTimeUtc = 1,
     kProcTime,
     kProcTimePrecise,
     kLastClockType,
-};
+} ClockType;
 
 // ------------------------------
 // Time structs
 // ------------------------------
 
-typedef struct Timezone {
+typedef struct {
     i16 west_offset_minutes;
     i16 dst_time_offset_minutes;
     u16 dst_time_start_seconds;
     u16 dst_time_end_seconds;
-} timezone;
+} Timezone;
 
-typedef struct TimeVal {
+typedef struct {
     u64 seconds;
     u64 remainder;
-} time_val;
+} TimeVal;
 
-#endif  // LIBS_LIBC_INCLUDE_SYS_TIME_H_
+#endif  // LIBS_LIBC_SRC_INCLUDE_SYS_TIME_H_
diff --git a/libs/libc/src/include/types.h b/libs/libc/src/include/types.h
index 9fe5b43d..ea091be9 100644
--- a/libs/libc/src/include/types.h
+++ b/libs/libc/src/include/types.h
@@ -1,41 +1,44 @@
-#ifndef LIBS_LIBC_INCLUDE_TYPES_H_
-#define LIBS_LIBC_INCLUDE_TYPES_H_
+#ifndef LIBS_LIBC_SRC_INCLUDE_TYPES_H_
+#define LIBS_LIBC_SRC_INCLUDE_TYPES_H_
 
-#include <limits.h>
+#include <stddef.h>
 #include <stdint.h>
 
 #if SIZE_MAX == UINTMAX_MAX
 typedef intmax_t ssize_t;
-#elif SIZE_MAX == ULONG_LONG_MAX
-typedef long long ssize_t;
-#elif SIZE_MAX == ULONG_MAX
-typedef long ssize_t;
-#elif SIZE_MAX == UINT_MAX
-typedef int ssize_t;
-#elif SIZE_MAX == USHRT_MAX
-typedef short ssize_t;
-#elif SIZE_MAX == UCHAR_MAX
-typedef signed char ssize_t;
+#elif SIZE_MAX == UINT64_MAX
+typedef int64_t ssize_t;
+#elif SIZE_MAX == UINT32_MAX
+typedef int32_t ssize_t;
+#elif SIZE_MAX == UINT16_MAX
+typedef int16_t ssize_t;
+#elif SIZE_MAX == UINT8_MAX
+typedef int8_t ssize_t;
 #else
 #error "Unsupported ssize_t size"
 #endif
 
-#if PTRDIFF_MAX == INTMAX_MAX
-typedef uintmax_t uptrdiff_t;
-#elif PTRDIFF_MAX == LONG_LONG_MAX
-typedef unsigned long long uptrdiff_t;
-#elif PTRDIFF_MAX == LONG_MAX
-typedef unsigned long uptrdiff_t;
-#elif PTRDIFF_MAX == INT_MAX
-typedef unsigned int uptrdiff_t;
-#elif PTRDIFF_MAX == SHRT_MAX
-typedef unsigned short uptrdiff_t;
-#elif PTRDIFF_MAX == CHAR_MAX
-typedef unsigned char uptrdiff_t;
-#else
-#error "Unsupported uptrdiff_t size"
-#endif
-
+typedef uintptr_t uptrdiff_t;
 typedef size_t rsize_t;
 
-#endif  // LIBS_LIBC_INCLUDE_TYPES_H_
+/* simplified unsigned int types */
+typedef uint8_t u8;
+typedef uint16_t u16;
+typedef uint32_t u32;
+typedef uint64_t u64;
+typedef u8 byte;
+
+/* simplified int types */
+typedef int8_t i8;
+typedef int16_t i16;
+typedef int32_t i32;
+typedef int64_t i64;
+
+/* simplified float types */
+typedef float f32;
+typedef double f64;
+
+typedef uintptr_t uptr;
+typedef intptr_t iptr;
+
+#endif  // LIBS_LIBC_SRC_INCLUDE_TYPES_H_
diff --git a/libs/libc/src/internal/entry.hpp b/libs/libc/src/internal/entry.hpp
new file mode 100644
index 00000000..a1d57323
--- /dev/null
+++ b/libs/libc/src/internal/entry.hpp
@@ -0,0 +1,27 @@
+#ifndef LIBS_LIBC_SRC_INTERNAL_ENTRY_HPP_
+#define LIBS_LIBC_SRC_INTERNAL_ENTRY_HPP_
+
+#include "defines.h"
+#include "internal/stdio.hpp"
+
+BEGIN_DECL_C
+
+extern int main();
+
+/**
+ * @brief Entry point to initialize C runtime
+ *
+ * This function initializes standard I/O streams and then calls the main function.
+ */
+void _start()
+{
+    // Initialize standard I/O streams
+    InitStdio();
+
+    // Call main function
+    main();
+}
+
+END_DECL_C
+
+#endif  // LIBS_LIBC_SRC_INTERNAL_ENTRY_HPP_
diff --git a/libs/libc/src/internal/libc_backend.cpp b/libs/libc/src/internal/libc_backend.cpp
index 63ecc380..91fad943 100644
--- a/libs/libc/src/internal/libc_backend.cpp
+++ b/libs/libc/src/internal/libc_backend.cpp
@@ -2,6 +2,7 @@
 
 #include "platform.h"
 #include "sys/calls.h"
+#include "sys/fd.h"
 
 DEFINE_SYSCALL_VOID(
     get_clock_value, kSysGetClockValue, const ClockType, type, TimeVal *, time, Timezone *,
@@ -16,4 +17,10 @@ DEFINE_SYSCALL_VOID(write_console, kSysWriteConsole, const char *, buffer)
 
 DEFINE_SYSCALL_VOID(panic, kSysPanic, const char *, msg)
 
+DEFINE_SYSCALL(open, kSysOpen, int, const char *, pathname, int, flags)
+DEFINE_SYSCALL(close, kSysClose, int, fd_t, fd)
+DEFINE_SYSCALL(read, kSysRead, ssize_t, fd_t, fd, void *, buf, size_t, count)
+DEFINE_SYSCALL(write, kSysWrite, ssize_t, fd_t, fd, const void *, buf, size_t, count)
+DEFINE_SYSCALL(seek, kSysSeek, ssize_t, fd_t, fd, ssize_t, offset, FdSeek, whence)
+
 #endif  // __ALKOS_KERNEL__
diff --git a/libs/libc/src/internal/stdio.cpp b/libs/libc/src/internal/stdio.cpp
new file mode 100644
index 00000000..fc7fd24f
--- /dev/null
+++ b/libs/libc/src/internal/stdio.cpp
@@ -0,0 +1,62 @@
+#include "stdio.hpp"
+#include "stdio.h"
+#include "string.h"
+#include "sys/calls/fd.h"
+
+// Static fixed buffers for standard streams
+static byte _stdin_buffer[BUFSIZ];
+static byte _stdout_buffer[BUFSIZ];
+static byte _stderr_buffer[BUFSIZ];
+
+static FILE _stdin;
+static FILE _stdout;
+static FILE _stderr;
+
+FILE *stdin  = &_stdin;
+FILE *stdout = &_stdout;
+FILE *stderr = &_stderr;
+
+void InitStdio()
+{
+    memset(&_stdin, 0, sizeof(FILE));
+    _stdin.fd                    = kFdStdIn;
+    _stdin.flags.open_mode       = kFdFlagRead;
+    _stdin.flags.buffer_mode     = kFdBufferLine;
+    _stdin.flags.eof             = false;
+    _stdin.flags.error           = false;
+    _stdin.flags.closed          = false;
+    _stdin.flags.is_buffer_owner = false;
+    _stdin.buffer                = _stdin_buffer;
+    _stdin.buffer_size           = sizeof(_stdin_buffer);
+    _stdin.buffer_pos            = 0;
+    _stdin.buffer_level          = 0;
+    _stdin.file_pos              = 0;
+
+    memset(&_stdout, 0, sizeof(FILE));
+    _stdout.fd                    = kFdStdOut;
+    _stdout.flags.open_mode       = kFdFlagWrite;
+    _stdout.flags.buffer_mode     = kFdBufferLine;
+    _stdout.flags.eof             = false;
+    _stdout.flags.error           = false;
+    _stdout.flags.closed          = false;
+    _stdout.flags.is_buffer_owner = false;
+    _stdout.buffer                = _stdout_buffer;
+    _stdout.buffer_size           = sizeof(_stdout_buffer);
+    _stdout.buffer_pos            = 0;
+    _stdout.buffer_level          = 0;
+    _stdout.file_pos              = 0;
+
+    memset(&_stderr, 0, sizeof(FILE));
+    _stderr.fd                    = kFdStdErr;
+    _stderr.flags.open_mode       = kFdFlagWrite;
+    _stderr.flags.buffer_mode     = kFdBufferNone;
+    _stderr.flags.eof             = false;
+    _stderr.flags.error           = false;
+    _stderr.flags.closed          = false;
+    _stderr.flags.is_buffer_owner = false;
+    _stderr.buffer                = _stderr_buffer;
+    _stderr.buffer_size           = sizeof(_stderr_buffer);
+    _stderr.buffer_pos            = 0;
+    _stderr.buffer_level          = 0;
+    _stderr.file_pos              = 0;
+}
diff --git a/libs/libc/src/internal/stdio.hpp b/libs/libc/src/internal/stdio.hpp
new file mode 100644
index 00000000..8e6406fd
--- /dev/null
+++ b/libs/libc/src/internal/stdio.hpp
@@ -0,0 +1,9 @@
+#ifndef LIBS_LIBC_SRC_INTERNAL_STDIO_HPP_
+#define LIBS_LIBC_SRC_INTERNAL_STDIO_HPP_
+
+/**
+ * @brief Initialize standard I/O streams
+ */
+void InitStdio();
+
+#endif  // LIBS_LIBC_SRC_INTERNAL_STDIO_HPP_
diff --git a/libs/libc/src/internal/time_internal.cpp b/libs/libc/src/internal/time_internal.cpp
index 5dc101e0..9c72357c 100644
--- a/libs/libc/src/internal/time_internal.cpp
+++ b/libs/libc/src/internal/time_internal.cpp
@@ -1,7 +1,7 @@
 #include <todo.h>
+#include <types.h>
 #include <time.hpp>
 #include <time_internal.hpp>
-#include <types.hpp>
 
 u64 __GetLocalTimezoneOffsetNs()
 {
diff --git a/libs/libc/src/io/snprintf.cpp b/libs/libc/src/io/snprintf.cpp
index 0722e046..104a28fd 100644
--- a/libs/libc/src/io/snprintf.cpp
+++ b/libs/libc/src/io/snprintf.cpp
@@ -2,8 +2,8 @@
 
 #include <stdarg.h>
 #include <stdint.h>
+#include <types.h>
 #include <internal/formats.hpp>
-#include <types.hpp>
 
 #include "defines.h"
 #include "math.h"
diff --git a/libs/libc/src/math/math.cpp b/libs/libc/src/math/math.cpp
index 3a0fdb72..980e7f6e 100644
--- a/libs/libc/src/math/math.cpp
+++ b/libs/libc/src/math/math.cpp
@@ -1,6 +1,6 @@
 #include <math.h>
 #include <stdint.h>
-#include <types.hpp>
+#include <types.h>
 
 double modf(double num, double *integralPart)
 {
diff --git a/libs/libc/src/time/time_ext.cpp b/libs/libc/src/time/time_ext.cpp
index 0d6cf121..e4bb5fb4 100644
--- a/libs/libc/src/time/time_ext.cpp
+++ b/libs/libc/src/time/time_ext.cpp
@@ -1,12 +1,12 @@
 #include <assert.h>
+#include <types.h>
 #include <time.hpp>
-#include <types.hpp>
 
 // ------------------------------
 // Implementations
 // ------------------------------
 
-u64 ConvertDateTimeToPosix(const tm &date_time, const timezone &time_zone)
+u64 ConvertDateTimeToPosix(const tm &date_time, const Timezone &time_zone)
 {
     const i64 is_month_negative = date_time.tm_mon < 0;
 
@@ -217,7 +217,7 @@ std::tuple<u64, u64> CalculateYears30LessWLeaps(const u64 time)
     return {years + 1, static_cast<u64>(local_time_left)};
 }
 
-u64 GetDSTOffset(u64 time, const timezone &time_zone)
+u64 GetDSTOffset(u64 time, const Timezone &time_zone)
 {
     if (time_zone.dst_time_offset_minutes == 0) {
         return 0;
@@ -242,7 +242,7 @@ u64 GetDSTOffset(u64 time, const timezone &time_zone)
     }
 }
 
-tm *ConvertFromPosixToTm(const time_t timer, tm &result, const timezone &tz)
+tm *ConvertFromPosixToTm(const time_t timer, tm &result, const Timezone &tz)
 {
     u64 time_left = timer;
 
diff --git a/libs/libcontainers/include/data_structures/bit_array.hpp b/libs/libcontainers/include/data_structures/bit_array.hpp
index 245a3b5e..90ce50bc 100644
--- a/libs/libcontainers/include/data_structures/bit_array.hpp
+++ b/libs/libcontainers/include/data_structures/bit_array.hpp
@@ -6,7 +6,7 @@
 #include "assert.h"
 #include "bit.hpp"
 #include "string.h"
-#include "types.hpp"
+#include "types.h"
 
 // TODO: Minimal changes would be required to make this
 // https://en.cppreference.com/w/cpp/utility/bitset.html
diff --git a/libs/libcontainers/include/data_structures/critbit_tree.hpp b/libs/libcontainers/include/data_structures/critbit_tree.hpp
index 02beffe6..629b0a86 100644
--- a/libs/libcontainers/include/data_structures/critbit_tree.hpp
+++ b/libs/libcontainers/include/data_structures/critbit_tree.hpp
@@ -32,7 +32,7 @@ class CritBitTree
 
     // Tag 0: ExternalNode
     // Tag 1: InternalNode
-    using NodePtr = TaggedPointer<ExternalNode, InternalNode>;
+    using NodePtr = OwningTaggedPtr<ExternalNode, InternalNode>;
 
     struct ExternalNode {
         char *key;
diff --git a/libs/libcontainers/include/data_structures/cyclic_buffer.hpp b/libs/libcontainers/include/data_structures/cyclic_buffer.hpp
index 8e3b0f10..b0d27f40 100644
--- a/libs/libcontainers/include/data_structures/cyclic_buffer.hpp
+++ b/libs/libcontainers/include/data_structures/cyclic_buffer.hpp
@@ -1,13 +1,13 @@
 #ifndef LIBS_LIBCONTAINERS_INCLUDE_DATA_STRUCTURES_CYCLIC_BUFFER_HPP_
 #define LIBS_LIBCONTAINERS_INCLUDE_DATA_STRUCTURES_CYCLIC_BUFFER_HPP_
 
+#include <types.h>
 #include <algorithm.hpp>
 #include <array.hpp>
 #include <atomic.hpp>
 #include <defines.hpp>
 #include <mutex.hpp>
 #include <span.hpp>
-#include <types.hpp>
 
 namespace data_structures
 {
diff --git a/libs/libcontainers/include/data_structures/ref_count.hpp b/libs/libcontainers/include/data_structures/ref_count.hpp
new file mode 100644
index 00000000..c193956d
--- /dev/null
+++ b/libs/libcontainers/include/data_structures/ref_count.hpp
@@ -0,0 +1,219 @@
+#ifndef LIBS_LIBCONTAINERS_INCLUDE_DATA_STRUCTURES_REF_COUNT_HPP_
+#define LIBS_LIBCONTAINERS_INCLUDE_DATA_STRUCTURES_REF_COUNT_HPP_
+
+#include "atomic.hpp"
+#include "defines.hpp"
+#include "mem/heap.hpp"
+#include "template/utils.hpp"
+#include "types.h"
+
+namespace data_structures
+{
+
+/**
+ * @brief Intrusive thread-safe reference counting base class
+ */
+template <typename T, bool kCustomDeleter = false>
+class RefCounted
+{
+    using DeleterCallback = void (*)(T *);
+    using CounterType     = u32;
+
+    public:
+    RefCounted() {}
+    ~RefCounted() = default;
+
+    RefCounted(const RefCounted &)            = delete;
+    RefCounted &operator=(const RefCounted &) = delete;
+    RefCounted(RefCounted &&)                 = delete;
+    RefCounted &operator=(RefCounted &&)      = delete;
+
+    // ========================================================================
+    // Reference counting operations
+    // ========================================================================
+
+    void AddRef() noexcept { (void)ref_count_.fetch_add(1, std::memory_order_relaxed); }
+
+    void Release() noexcept
+    {
+        CounterType old_count = ref_count_.fetch_sub(1, std::memory_order_acq_rel);
+
+        ASSERT_GT(old_count, 0, "Releasing ref_count that is already zero");
+
+        if (old_count == 1) {
+            T *ptr = static_cast<T *>(this);
+            ptr->~T();
+            if constexpr (kCustomDeleter) {
+                if (deleter_) {
+                    deleter_(ptr);
+                }
+            }
+        }
+    }
+
+    NODISCARD CounterType GetRefCount() const noexcept
+    {
+        return ref_count_.load(std::memory_order_acquire);
+    }
+
+    NODISCARD bool HasRefs() const noexcept
+    {
+        return ref_count_.load(std::memory_order_acquire) > 0;
+    }
+
+    void SetDeleter(DeleterCallback deleter) noexcept
+        requires(kCustomDeleter)
+    {
+        deleter_ = deleter;
+    }
+
+    private:
+    OPTIONAL_FIELD(kCustomDeleter, DeleterCallback) deleter_ {};
+    std::atomic<CounterType> ref_count_{0};
+};
+
+/**
+ * @brief Smart pointer for RefCounted objects
+ */
+template <typename T>
+class RefPtr
+{
+    static_assert(
+        std::derived_from<T, RefCounted<T, false>> || std::derived_from<T, RefCounted<T, true>>,
+        "T must derive from RefCountedBase<T>"
+    );
+
+    public:
+    RefPtr() noexcept : ptr_(nullptr) {}
+
+    explicit RefPtr(T *ptr, bool add_ref = true) noexcept : ptr_(ptr)
+    {
+        if (ptr_ && add_ref) {
+            ptr_->AddRef();
+        }
+    }
+
+    RefPtr(const RefPtr &other) noexcept : ptr_(other.ptr_)
+    {
+        if (ptr_) {
+            ptr_->AddRef();
+        }
+    }
+
+    RefPtr(RefPtr &&other) noexcept : ptr_(other.ptr_) { other.ptr_ = nullptr; }
+
+    ~RefPtr()
+    {
+        if (ptr_) {
+            ptr_->Release();
+        }
+    }
+
+    RefPtr &operator=(const RefPtr &other) noexcept
+    {
+        if (this != &other) {
+            T *old_ptr = ptr_;
+            ptr_       = other.ptr_;
+            if (ptr_) {
+                ptr_->AddRef();
+            }
+            if (old_ptr) {
+                old_ptr->Release();
+            }
+        }
+        return *this;
+    }
+
+    RefPtr &operator=(RefPtr &&other) noexcept
+    {
+        if (this != &other) {
+            if (ptr_) {
+                ptr_->Release();
+            }
+            ptr_       = other.ptr_;
+            other.ptr_ = nullptr;
+        }
+        return *this;
+    }
+
+    RefPtr &operator=(T *ptr) noexcept
+    {
+        if (ptr_ != ptr) {
+            T *old_ptr = ptr_;
+            ptr_       = ptr;
+            if (ptr_) {
+                ptr_->AddRef();
+            }
+            if (old_ptr) {
+                old_ptr->Release();
+            }
+        }
+        return *this;
+    }
+
+    // ========================================================================
+    // Accessors
+    // ========================================================================
+
+    NODISCARD T *Get() const noexcept { return ptr_; }
+    NODISCARD T *operator->() const noexcept { return ptr_; }
+    NODISCARD T &operator*() const noexcept { return *ptr_; }
+
+    NODISCARD explicit operator bool() const noexcept { return ptr_ != nullptr; }
+
+    void Reset() noexcept
+    {
+        if (ptr_) {
+            ptr_->Release();
+            ptr_ = nullptr;
+        }
+    }
+
+    T *Detach() noexcept
+    {
+        T *ptr = ptr_;
+        ptr_   = nullptr;
+        return ptr;
+    }
+
+    // ========================================================================
+    // Comparison operators
+    // ========================================================================
+
+    NODISCARD bool operator==(const RefPtr &other) const noexcept { return ptr_ == other.ptr_; }
+    NODISCARD bool operator!=(const RefPtr &other) const noexcept { return ptr_ != other.ptr_; }
+    NODISCARD bool operator==(T *ptr) const noexcept { return ptr_ == ptr; }
+    NODISCARD bool operator!=(T *ptr) const noexcept { return ptr_ != ptr; }
+    NODISCARD bool operator==(std::nullptr_t) const noexcept { return ptr_ == nullptr; }
+    NODISCARD bool operator!=(std::nullptr_t) const noexcept { return ptr_ != nullptr; }
+
+    private:
+    T *ptr_;
+};
+
+// ============================================================================
+// Helper functions
+// ============================================================================
+
+template <
+    typename T, typename Allocator = decltype([]<typename... Args>(Args &&...args) {
+                    return Mem::KNew<T>(std::forward<Args>(args)...).value_or(nullptr);
+                }),
+    typename Deleter = decltype([](T *ptr) {
+        Mem::KDelete(ptr);
+    }),
+    typename... Args>
+RefPtr<T> MakeRefCounted(Args &&...args)
+    requires(std::derived_from<T, RefCounted<T, true>>)
+{
+    auto res = Allocator{}(std::forward<Args>(args)...);
+    if (!res) {
+        return RefPtr<T>{};
+    }
+    res->SetDeleter(Deleter{});
+    return RefPtr<T>(res);
+}
+
+}  // namespace data_structures
+
+#endif  // LIBS_LIBCONTAINERS_INCLUDE_DATA_STRUCTURES_REF_COUNT_HPP_
diff --git a/libs/libcontainers/include/data_structures/tagged_pointer.hpp b/libs/libcontainers/include/data_structures/tagged_pointer.hpp
index 47832046..0ea83492 100644
--- a/libs/libcontainers/include/data_structures/tagged_pointer.hpp
+++ b/libs/libcontainers/include/data_structures/tagged_pointer.hpp
@@ -1,21 +1,73 @@
 #ifndef LIBS_LIBCONTAINERS_INCLUDE_DATA_STRUCTURES_TAGGED_POINTER_HPP_
 #define LIBS_LIBCONTAINERS_INCLUDE_DATA_STRUCTURES_TAGGED_POINTER_HPP_
 
-#include <algorithm.hpp>
 #include <defines.hpp>
 #include <mem/heap.hpp>
 #include <new.hpp>
 #include <type_traits.hpp>
 #include <utility.hpp>
+#include "ref_count.hpp"
 
 namespace data_structures
 {
+
+template <typename T>
+struct Owned {
+    using Type                   = T;
+    static constexpr bool kOwned = true;
+};
+
+template <typename T>
+struct NonOwned {
+    using Type                   = T;
+    static constexpr bool kOwned = false;
+};
+
+namespace internal
+{
+
+template <typename T>
+struct UnwrapType {
+    using Type = T;
+};
+
+template <typename T>
+struct UnwrapType<Owned<T>> {
+    using Type = T;
+};
+
+template <typename T>
+struct UnwrapType<NonOwned<T>> {
+    using Type = T;
+};
+
+template <typename T>
+using UnwrapType_t = typename UnwrapType<T>::Type;
+
+template <typename T>
+struct IsOwned : std::false_type {
+};
+
+template <typename T>
+struct IsOwned<Owned<T>> : std::true_type {
+};
+
+template <typename T>
+inline constexpr bool IsOwned_v = IsOwned<T>::value;
+
+template <typename T>
+inline constexpr bool IsRefCounted_v =
+    std::derived_from<T, RefCounted<T, false>> || std::derived_from<T, RefCounted<T, true>>;
+
+}  // namespace internal
+
 /**
  * @brief A tagged pointer that stores type information in unused pointer bits.
  *
  * The number of available tag bits is determined by the number of types provided.
+ * Types can be wrapped in Owned<T> or NonOwned<T> to control ownership semantics.
  *
- * @tparam TaggedTypes Variadic list of types that can be stored with this tagged pointer
+ * @tparam TaggedTypes Variadic list of types (can be Owned<T> or NonOwned<T>)
  */
 template <typename... TaggedTypes>
 class TaggedPointer
@@ -36,10 +88,48 @@ class TaggedPointer
 
     explicit TaggedPointer(BaseT tagged_ptr) : tagged_ptr_(tagged_ptr) {}
 
+    template <typename T>
+    NODISCARD static TaggedPointer Wrap(T *ptr)
+    {
+        static_assert(
+            (std::is_same_v<NonOwned<T>, TaggedTypes> || ...),
+            "Type NonOwned<T> must be in the TaggedTypes list to use Wrap"
+        );
+
+        if constexpr (internal::IsRefCounted_v<T>) {
+            if (ptr) {
+                ptr->AddRef();
+            }
+        }
+
+        return TaggedPointer(TagPtr(ptr, GetTypeIndex<NonOwned<T>>()));
+    }
+
     ~TaggedPointer() { Destroy(); }
 
-    TaggedPointer(const TaggedPointer &)            = delete;
-    TaggedPointer &operator=(const TaggedPointer &) = delete;
+    // Copy constructor - only enabled if all types are non-owned
+    TaggedPointer(const TaggedPointer &other)
+        requires(!internal::IsOwned_v<TaggedTypes> && ...)
+        : tagged_ptr_(other.tagged_ptr_)
+    {
+        if (IsValid()) {
+            AddRefIfRefCounted();
+        }
+    }
+
+    // Copy assignment - only enabled if all types are non-owned
+    TaggedPointer &operator=(const TaggedPointer &other)
+        requires(!internal::IsOwned_v<TaggedTypes> && ...)
+    {
+        if (this != &other) {
+            Destroy();
+            tagged_ptr_ = other.tagged_ptr_;
+            if (IsValid()) {
+                AddRefIfRefCounted();
+            }
+        }
+        return *this;
+    }
 
     TaggedPointer(TaggedPointer &&other) noexcept : tagged_ptr_(other.tagged_ptr_)
     {
@@ -64,7 +154,8 @@ class TaggedPointer
     NODISCARD FAST_CALL TaggedPointer Construct(Args &&...args)
     {
         static_assert(
-            (std::is_same_v<T, TaggedTypes> || ...), "Type T must be one of the TaggedTypes"
+            (std::is_same_v<Owned<T>, TaggedTypes> || ...),
+            "Type Owned<T> must be in the TaggedTypes list to use Construct"
         );
 
         auto mem = Mem::KMallocAligned(
@@ -77,16 +168,31 @@ class TaggedPointer
 
         T *ptr = new (*mem) T(std::forward<Args>(args)...);
 
-        return TaggedPointer(TagPtr(ptr, GetTypeIndex<T>()));
+        return TaggedPointer(TagPtr(ptr, GetTypeIndex<Owned<T>>()));
     }
 
     template <typename T>
     NODISCARD FORCE_INLINE_F bool Is() const
     {
+        constexpr bool has_owned     = (std::is_same_v<Owned<T>, TaggedTypes> || ...);
+        constexpr bool has_non_owned = (std::is_same_v<NonOwned<T>, TaggedTypes> || ...);
         static_assert(
-            (std::is_same_v<T, TaggedTypes> || ...), "Type T must be one of the TaggedTypes"
+            has_owned || has_non_owned, "Type T (as Owned<T> or NonOwned<T>) must be in TaggedTypes"
         );
-        return IsValid() && GetTag() == GetTypeIndex<T>();
+
+        if (!IsValid())
+            return false;
+
+        size_t tag = GetTag();
+        if constexpr (has_owned) {
+            if (tag == GetTypeIndex<Owned<T>>())
+                return true;
+        }
+        if constexpr (has_non_owned) {
+            if (tag == GetTypeIndex<NonOwned<T>>())
+                return true;
+        }
+        return false;
     }
 
     template <typename T>
@@ -111,7 +217,6 @@ class TaggedPointer
         size_t tag           = GetTag();
         size_t current_index = 0;
 
-        // Dispatch to the correct type
         return VisitImpl<Visitor, TaggedTypes...>(
             std::forward<Visitor>(visitor), tag, current_index
         );
@@ -150,7 +255,7 @@ class TaggedPointer
     }
 
     template <typename T>
-    static constexpr size_t GetTypeIndex()
+    FORCE_INLINE_F static constexpr size_t GetTypeIndex()
     {
         size_t index = 0;
         ((std::is_same_v<T, TaggedTypes> ? true : (++index, false)) || ...);
@@ -170,18 +275,54 @@ class TaggedPointer
     NODISCARD FORCE_INLINE_F size_t GetTag() const { return tagged_ptr_ & kTagMask; }
 
     template <typename T>
-    void DestroyType()
+    FORCE_INLINE_F void DestroyType()
+    {
+        using ActualType = internal::UnwrapType_t<T>;
+        ActualType *ptr  = static_cast<ActualType *>(UntagPtr());
+
+        if (!ptr)
+            return;
+
+        // If owned, destroy and free memory
+        if constexpr (internal::IsOwned_v<T>) {
+            ptr->~ActualType();
+            Mem::KFreeAligned(ptr);
+        } else if constexpr (internal::IsRefCounted_v<ActualType>) {
+            ptr->Release();
+        }
+    }
+
+    FORCE_INLINE_F void AddRefIfRefCounted()
+    {
+        if (!IsValid())
+            return;
+
+        size_t tag           = GetTag();
+        size_t current_index = 0;
+
+        (void)((current_index++ == tag ? (AddRefType<TaggedTypes>(), true) : false) || ...);
+    }
+
+    template <typename T>
+    FORCE_INLINE_F void AddRefType()
     {
-        T *ptr = static_cast<T *>(UntagPtr());
-        ptr->~T();
-        Mem::KFreeAligned(ptr);
+        using ActualType = internal::UnwrapType_t<T>;
+        ActualType *ptr  = static_cast<ActualType *>(UntagPtr());
+
+        if (!ptr)
+            return;
+
+        if constexpr (internal::IsRefCounted_v<ActualType>) {
+            ptr->AddRef();
+        }
     }
 
     template <typename Visitor, typename T, typename... Rest>
     decltype(auto) VisitImpl(Visitor &&visitor, size_t tag, size_t &current_index)
     {
         if (current_index == tag) {
-            return visitor(As<T>());
+            using ActualType = internal::UnwrapType_t<T>;
+            return visitor(*static_cast<ActualType *>(UntagPtr()));
         }
         current_index++;
         if constexpr (sizeof...(Rest) > 0) {
@@ -194,7 +335,8 @@ class TaggedPointer
     decltype(auto) VisitImpl(Visitor &&visitor, size_t tag, size_t &current_index) const
     {
         if (current_index == tag) {
-            return visitor(As<T>());
+            using ActualType = internal::UnwrapType_t<T>;
+            return visitor(*static_cast<const ActualType *>(UntagPtr()));
         }
         current_index++;
         if constexpr (sizeof...(Rest) > 0) {
@@ -209,6 +351,12 @@ class TaggedPointer
     BaseT tagged_ptr_{};
 };
 
+template <typename... TaggedTypes>
+using OwningTaggedPtr = TaggedPointer<Owned<TaggedTypes>...>;
+
+template <typename... TaggedTypes>
+using NonOwningTaggedPtr = TaggedPointer<NonOwned<TaggedTypes>...>;
+
 }  // namespace data_structures
 
 #endif  // LIBS_LIBCONTAINERS_INCLUDE_DATA_STRUCTURES_TAGGED_POINTER_HPP_
diff --git a/libs/libcpp/include/assert_base.hpp b/libs/libcpp/include/assert_base.hpp
index ff359a11..ad336a45 100644
--- a/libs/libcpp/include/assert_base.hpp
+++ b/libs/libcpp/include/assert_base.hpp
@@ -7,9 +7,9 @@
 #include <stdio.h>
 #include <string.h>
 #include <todo.h>
+#include <types.h>
 #include <formats.hpp>
 #include <type_traits.hpp>
-#include <types.hpp>
 #include <utility.hpp>
 
 // -------------------------------------
diff --git a/libs/libcpp/include/bits_ext.hpp b/libs/libcpp/include/bits_ext.hpp
index 1ab5d0bd..2a847478 100644
--- a/libs/libcpp/include/bits_ext.hpp
+++ b/libs/libcpp/include/bits_ext.hpp
@@ -6,7 +6,7 @@
 #include "concepts.hpp"
 #include "defines.hpp"
 #include "type_traits.hpp"
-#include "types.hpp"
+#include "types.h"
 
 //==============================================================================
 // Forward Declarations
diff --git a/libs/libcpp/include/char_traits.hpp b/libs/libcpp/include/char_traits.hpp
index 212edb36..447371b2 100644
--- a/libs/libcpp/include/char_traits.hpp
+++ b/libs/libcpp/include/char_traits.hpp
@@ -2,9 +2,9 @@
 #define LIBS_LIBCPP_INCLUDE_CHAR_TRAITS_HPP_
 
 #include <string.h>
+#include <types.h>
 #include <compare.hpp>
 #include <type_traits.hpp>
-#include <types.hpp>
 
 #define __need_wint_t
 #include <stddef.h>
diff --git a/libs/libcpp/include/compare.hpp b/libs/libcpp/include/compare.hpp
index 1ac7b6d0..3adccfb8 100644
--- a/libs/libcpp/include/compare.hpp
+++ b/libs/libcpp/include/compare.hpp
@@ -1,8 +1,8 @@
 #ifndef LIBS_LIBCPP_INCLUDE_COMPARE_HPP_
 #define LIBS_LIBCPP_INCLUDE_COMPARE_HPP_
 
+#include <types.h>
 #include <defines.hpp>
-#include <types.hpp>
 
 namespace std
 {
diff --git a/libs/libcpp/include/concepts.hpp b/libs/libcpp/include/concepts.hpp
index 3999ca09..46fa4a33 100644
--- a/libs/libcpp/include/concepts.hpp
+++ b/libs/libcpp/include/concepts.hpp
@@ -6,6 +6,9 @@
 
 namespace std
 {
+template <class Derived, class Base>
+concept derived_from = std::is_base_of_v<Base, Derived> &&
+                       std::is_convertible_v<const volatile Derived *, const volatile Base *>;
 
 template <class From, class To>
 concept convertible_to =
diff --git a/libs/libcpp/include/defines.hpp b/libs/libcpp/include/defines.hpp
index 7e94ceac..13eee7b8 100644
--- a/libs/libcpp/include/defines.hpp
+++ b/libs/libcpp/include/defines.hpp
@@ -3,7 +3,7 @@
 
 #include <defines.h>
 #include <stddef.h>
-#include <types.hpp>
+#include <types.h>
 
 #ifdef NDEBUG
 static constexpr bool kIsDebugBuild = false;
diff --git a/libs/libcpp/include/internal/intervals.hpp b/libs/libcpp/include/internal/intervals.hpp
index 47eee783..791baefc 100644
--- a/libs/libcpp/include/internal/intervals.hpp
+++ b/libs/libcpp/include/internal/intervals.hpp
@@ -2,7 +2,7 @@
 #define LIBS_LIBCPP_INCLUDE_INTERNAL_INTERVALS_HPP_
 
 #include "type_traits.hpp"
-#include "types.hpp"
+#include "types.h"
 
 namespace internal
 {
diff --git a/libs/libcpp/include/time.hpp b/libs/libcpp/include/time.hpp
index 13643777..7b8370c5 100644
--- a/libs/libcpp/include/time.hpp
+++ b/libs/libcpp/include/time.hpp
@@ -5,9 +5,9 @@
 #include <stdint.h>
 #include <sys/time.h>
 #include <time.h>
+#include <types.h>
 #include <defines.hpp>
 #include <tuple.hpp>
-#include <types.hpp>
 
 // ------------------------------
 // Time constants
@@ -79,7 +79,7 @@ WRAP_CALL constexpr bool IsTmYearLeap(const tm &time)
     return IsLeapYear(time.tm_year + kTmBaseYear);
 }
 
-NODISCARD u64 ConvertDateTimeToPosix(const tm &date_time, const timezone &time_zone);
+NODISCARD u64 ConvertDateTimeToPosix(const tm &date_time, const Timezone &time_zone);
 
 FAST_CALL i64 constexpr SumUpDays(const i64 year)
 {
@@ -160,11 +160,11 @@ NODISCARD i64 CalculateIsoBasedYear(const tm &time);
 /* [month, day] */
 NODISCARD std::tuple<u64, u64> CalculateMonthAndDaysFromPosix(u64 days, bool is_leap_year);
 
-NODISCARD u64 GetDSTOffset(u64 time, const timezone &tz);
+NODISCARD u64 GetDSTOffset(u64 time, const Timezone &tz);
 
-tm *ConvertFromPosixToTm(time_t timer, tm &result, const timezone &tz);
+tm *ConvertFromPosixToTm(time_t timer, tm &result, const Timezone &tz);
 
-NODISCARD FAST_CALL time_t MkTimeFromTimeZone(tm &time_ptr, const timezone &time_zone)
+NODISCARD FAST_CALL time_t MkTimeFromTimeZone(tm &time_ptr, const Timezone &time_zone)
 {
     const time_t t = ConvertDateTimeToPosix(time_ptr, time_zone);
 
diff --git a/libs/libcpp/include/types.hpp b/libs/libcpp/include/types.hpp
deleted file mode 100644
index f741c072..00000000
--- a/libs/libcpp/include/types.hpp
+++ /dev/null
@@ -1,28 +0,0 @@
-#ifndef LIBS_LIBCPP_INCLUDE_TYPES_HPP_
-#define LIBS_LIBCPP_INCLUDE_TYPES_HPP_
-
-#include <stdbool.h>
-#include <stddef.h>
-#include <stdint.h>
-
-/* simplified unsigned int types */
-typedef uint8_t u8;
-typedef uint16_t u16;
-typedef uint32_t u32;
-typedef uint64_t u64;
-typedef u8 byte;
-
-/* simplified int types */
-typedef int8_t i8;
-typedef int16_t i16;
-typedef int32_t i32;
-typedef int64_t i64;
-
-/* simplified float types */
-typedef float f32;
-typedef double f64;
-
-typedef uintptr_t uptr;
-typedef intptr_t iptr;
-
-#endif  // LIBS_LIBCPP_INCLUDE_TYPES_HPP_
diff --git a/libs/libtemplate/include/template/rolled_switch.hpp b/libs/libtemplate/include/template/rolled_switch.hpp
index f979caab..6097b6c9 100644
--- a/libs/libtemplate/include/template/rolled_switch.hpp
+++ b/libs/libtemplate/include/template/rolled_switch.hpp
@@ -2,9 +2,9 @@
 #define LIBS_LIBTEMPLATE_INCLUDE_TEMPLATE_ROLLED_SWITCH_HPP_
 
 #include <assert.h>
+#include <types.h>
 #include <concepts_ext.hpp>
 #include <defines.hpp>
-#include <types.hpp>
 #include <utility.hpp>
 
 namespace template_lib
diff --git a/libs/libtemplate/include/template/type_checks.hpp b/libs/libtemplate/include/template/type_checks.hpp
index 3c3935cf..9fcc43df 100644
--- a/libs/libtemplate/include/template/type_checks.hpp
+++ b/libs/libtemplate/include/template/type_checks.hpp
@@ -1,8 +1,8 @@
 #ifndef LIBS_LIBTEMPLATE_INCLUDE_TEMPLATE_TYPE_CHECKS_HPP_
 #define LIBS_LIBTEMPLATE_INCLUDE_TEMPLATE_TYPE_CHECKS_HPP_
 
+#include <types.h>
 #include <concepts_ext.hpp>
-#include <types.hpp>
 
 namespace template_lib
 {
diff --git a/libs/libtemplate/include/template/type_list.hpp b/libs/libtemplate/include/template/type_list.hpp
index 675b4891..a6a34ca7 100644
--- a/libs/libtemplate/include/template/type_list.hpp
+++ b/libs/libtemplate/include/template/type_list.hpp
@@ -1,9 +1,9 @@
 #ifndef LIBS_LIBTEMPLATE_INCLUDE_TEMPLATE_TYPE_LIST_HPP_
 #define LIBS_LIBTEMPLATE_INCLUDE_TEMPLATE_TYPE_LIST_HPP_
 
+#include <types.h>
 #include <internal/tuple_base.hpp>
 #include <type_traits.hpp>
-#include <types.hpp>
 #include <utility.hpp>
 
 #include "type_checks.hpp"
diff --git a/libs/libtemplate/include/template/type_traits.hpp b/libs/libtemplate/include/template/type_traits.hpp
index bdbc45cf..ec898f85 100644
--- a/libs/libtemplate/include/template/type_traits.hpp
+++ b/libs/libtemplate/include/template/type_traits.hpp
@@ -1,8 +1,8 @@
 #ifndef LIBS_LIBTEMPLATE_INCLUDE_TEMPLATE_TYPE_TRAITS_HPP_
 #define LIBS_LIBTEMPLATE_INCLUDE_TEMPLATE_TYPE_TRAITS_HPP_
 
+#include <types.h>
 #include <limits.hpp>
-#include <types.hpp>
 
 namespace template_lib
 {
diff --git a/scripts/completions/generate.bash b/scripts/completions/generate.bash
index f9eb883e..b5450d0a 100755
--- a/scripts/completions/generate.bash
+++ b/scripts/completions/generate.bash
@@ -598,12 +598,14 @@ generate_fish_completion() {
                     if [[ "$type" != "flag" ]]; then
                         completion_line="$completion_line -r"
                         if [[ -n "$choices" ]]; then
-                            completion_line="$completion_line -a '${choices//|/ }'"
+                            completion_line="$completion_line -f -a '${choices//|/ }'"
                         elif [[ "$type" == "file" ]]; then
                             completion_line="$completion_line -F"
                         elif [[ "$type" == "directory" ]]; then
-                            completion_line="$completion_line -a '(__fish_complete_directories)'"
-                        fi
+                            completion_line="$completion_line -f -a '(__fish_complete_directories)'"
+                        elif [[ "$type" == "string" || "$type" == "list" ]]; then
+                	    completion_line="$completion_line -f"
+                	fi
                     fi
 
                     echo "$completion_line"
diff --git a/scripts/utils/feature_flag_lib.bash b/scripts/utils/feature_flag_lib.bash
index c6bea850..6fe87691 100755
--- a/scripts/utils/feature_flag_lib.bash
+++ b/scripts/utils/feature_flag_lib.bash
@@ -8,11 +8,51 @@ FEATURE_FLAGS_CXX_PATH="${FEATURE_FLAGS_DIR}/../../generated/include/autogen/fea
 source "${FEATURE_FLAGS_DIR}/helpers.bash"
 
 declare -A CONFIGURE_FEATURE_FLAGS
+declare -A CONFIGURE_FEATURE_FLAGS_TYPE
+declare -A CONFIGURE_FEATURE_FLAGS_DESCRIPTION
+declare -A CONFIGURE_FEATURE_FLAGS_DEFAULT
+declare -A CONFIGURE_FEATURE_FLAGS_MIN
+declare -A CONFIGURE_FEATURE_FLAGS_MAX
+declare -a CONFIGURE_FEATURE_FLAGS_ORDER
+declare CONFIGURE_FLAGS_METADATA_LOADED=false
 
 # --------------------------------------------
 # Helper functions for YAML handling
 # --------------------------------------------
 
+load_flag_metadata() {
+  if [[ "$CONFIGURE_FLAGS_METADATA_LOADED" == true ]]; then
+    return
+  fi
+
+  # Load all metadata in one yq call - output as TSV (tab-separated)
+  local metadata_tsv
+  metadata_tsv=$(yq -r '.feature_flags[] | [.name, .type // "boolean", .description // "", .default // "false", .min // "null", .max // "null"] | @tsv' "${FEATURE_FLAGS_DEFS_PATH}" 2>/dev/null)
+
+  # Clear and repopulate the order array
+  CONFIGURE_FEATURE_FLAGS_ORDER=()
+
+  # Parse TSV and populate arrays
+  while IFS=$'\t' read -r name type description default min max; do
+    [[ -n "$name" ]] || continue  # Skip empty lines
+    CONFIGURE_FEATURE_FLAGS_ORDER+=("$name")
+    CONFIGURE_FEATURE_FLAGS_TYPE[$name]="$type"
+    CONFIGURE_FEATURE_FLAGS_DESCRIPTION[$name]="$description"
+    CONFIGURE_FEATURE_FLAGS_DEFAULT[$name]="$default"
+    CONFIGURE_FEATURE_FLAGS_MIN[$name]="$min"
+    CONFIGURE_FEATURE_FLAGS_MAX[$name]="$max"
+  done <<< "$metadata_tsv"
+
+  CONFIGURE_FLAGS_METADATA_LOADED=true
+}
+
+get_all_flag_names() {
+  if [[ "$CONFIGURE_FLAGS_METADATA_LOADED" == false ]]; then
+    load_flag_metadata
+  fi
+  printf '%s\n' "${CONFIGURE_FEATURE_FLAGS_ORDER[@]}"
+}
+
 load_feature_flags_from_yaml() {
   if [[ -f "${FEATURE_FLAGS_PATH}" ]]; then
     local flag_names
@@ -31,24 +71,21 @@ load_feature_flags_from_yaml() {
 }
 
 save_feature_flags_to_yaml() {
+  load_flag_metadata
+
   cat > "${FEATURE_FLAGS_PATH}" << 'EOF'
 # Feature flags configuration - rerun configure script to update the build system
 feature_flags:
 EOF
 
-  # Get flag names from definitions to maintain order and get descriptions
+  # Use cached flag names and descriptions
   local flag_names
-  mapfile -t flag_names < <(yq '.feature_flags[].name' "${FEATURE_FLAGS_DEFS_PATH}")
+  mapfile -t flag_names < <(get_all_flag_names)
 
   for flag in "${flag_names[@]}"; do
-    flag=$(strip_quotes "${flag}")
     if [[ -n "${CONFIGURE_FEATURE_FLAGS["$flag"]}" ]]; then
-      local description
-      description=$(yq ".feature_flags[] | select(.name == \"$flag\") | .description" "${FEATURE_FLAGS_DEFS_PATH}")
-      description=$(strip_quotes "${description}")
-
-      echo "" >> "${FEATURE_FLAGS_PATH}"
-      echo "  # ${description}" >> "${FEATURE_FLAGS_PATH}"
+      [[ "$flag" != "${flag_names[0]}" ]] && echo "" >> "${FEATURE_FLAGS_PATH}"
+      echo "  # ${CONFIGURE_FEATURE_FLAGS_DESCRIPTION[$flag]}" >> "${FEATURE_FLAGS_PATH}"
       echo "  ${flag}: ${CONFIGURE_FEATURE_FLAGS[$flag]}" >> "${FEATURE_FLAGS_PATH}"
     fi
   done
@@ -60,16 +97,8 @@ EOF
 
 get_flag_type() {
   local flag=$1
-  local type
-  type=$(yq ".feature_flags[] | select(.name == \"$flag\") | .type" "${FEATURE_FLAGS_DEFS_PATH}" 2>/dev/null)
-  type=$(strip_quotes "${type}")
-
-  # Default to boolean if type is not specified
-  if [[ -z "$type" || "$type" == "null" ]]; then
-    echo "boolean"
-  else
-    echo "$type"
-  fi
+  load_flag_metadata
+  echo "${CONFIGURE_FEATURE_FLAGS_TYPE[$flag]:-boolean}"
 }
 
 validate_flag_value() {
@@ -91,8 +120,7 @@ validate_flag_value() {
       fi
 
       # Check min constraint
-      local min
-      min=$(yq ".feature_flags[] | select(.name == \"$flag\") | .min" "${FEATURE_FLAGS_DEFS_PATH}" 2>/dev/null)
+      local min="${CONFIGURE_FEATURE_FLAGS_MIN[$flag]}"
       if [[ -n "$min" && "$min" != "null" ]]; then
         if (( value < min )); then
           dump_error "Value $value is below minimum $min for flag $flag"
@@ -101,8 +129,7 @@ validate_flag_value() {
       fi
 
       # Check max constraint
-      local max
-      max=$(yq ".feature_flags[] | select(.name == \"$flag\") | .max" "${FEATURE_FLAGS_DEFS_PATH}" 2>/dev/null)
+      local max="${CONFIGURE_FEATURE_FLAGS_MAX[$flag]}"
       if [[ -n "$max" && "$max" != "null" ]]; then
         if (( value > max )); then
           dump_error "Value $value exceeds maximum $max for flag $flag"
@@ -140,25 +167,22 @@ feature_flags_generate_cxx_files_header() {
 }
 
 feature_flags_generate_cxx_files_c_macros() {
+  load_flag_metadata
+
   # C code macros
   echo "// Macros for feature flags in C code" >> "${FEATURE_FLAGS_CXX_PATH}"
   echo "" >> "${FEATURE_FLAGS_CXX_PATH}"
 
   local flag_names
-  mapfile -t flag_names < <(yq '.feature_flags[].name' "${FEATURE_FLAGS_DEFS_PATH}")
+  mapfile -t flag_names < <(get_all_flag_names)
 
   for flag in "${flag_names[@]}"; do
-    default=$(yq ".feature_flags[] | select(.name == $flag) | .default" "${FEATURE_FLAGS_DEFS_PATH}")
-    description=$(yq ".feature_flags[] | select(.name == $flag) | .description" "${FEATURE_FLAGS_DEFS_PATH}")
+    echo "// ${flag} - ${CONFIGURE_FEATURE_FLAGS_DESCRIPTION[$flag]}" >> "${FEATURE_FLAGS_CXX_PATH}"
 
-    echo "// ${flag} - ${description}" >> "${FEATURE_FLAGS_CXX_PATH}"
-
-    # make uppercase and strip quotes
-    flag=$(strip_quotes "${flag}")
     flag_upper=$(convert_to_upper_case "${flag}")
 
     local type
-    type=$(get_flag_type "$flag")
+    type="${CONFIGURE_FEATURE_FLAGS_TYPE[$flag]}"
 
     if [[ "$type" == "boolean" ]]; then
       if [[ ${CONFIGURE_FEATURE_FLAGS[$flag]} == true ]]; then
@@ -180,13 +204,14 @@ feature_flags_generate_cxx_files_c_macros() {
 }
 
 feature_flags_generate_cxx_files_enums() {
+  load_flag_metadata
+
   local flag_names
-  mapfile -t flag_names < <(yq '.feature_flags[].name' "${FEATURE_FLAGS_DEFS_PATH}")
+  mapfile -t flag_names < <(get_all_flag_names)
 
   # Prepare enum for C++ code
   echo "enum class FeatureFlag {" >> "${FEATURE_FLAGS_CXX_PATH}"
   for flag in "${flag_names[@]}"; do
-    flag=$(strip_quotes "${flag}")
     local flag_pascal
     flag_pascal=$(snake_case_to_pascal_case "${flag}")
 
@@ -198,17 +223,17 @@ feature_flags_generate_cxx_files_enums() {
 }
 
 feature_flags_generate_cxx_files_cxx_vars() {
+  load_flag_metadata
+
   local flag_names
-  mapfile -t flag_names < <(yq '.feature_flags[].name' "${FEATURE_FLAGS_DEFS_PATH}")
+  mapfile -t flag_names < <(get_all_flag_names)
 
   # Separate boolean and integer flags
   local bool_flags=()
   local int_flags=()
 
   for flag in "${flag_names[@]}"; do
-    flag=$(strip_quotes "${flag}")
-    local type
-    type=$(get_flag_type "$flag")
+    local type="${CONFIGURE_FEATURE_FLAGS_TYPE[$flag]}"
 
     if [[ "$type" == "boolean" ]]; then
       bool_flags+=("$flag")
@@ -225,10 +250,7 @@ feature_flags_generate_cxx_files_cxx_vars() {
     echo "" >> "${FEATURE_FLAGS_CXX_PATH}"
 
     for flag in "${bool_flags[@]}"; do
-      default=$(yq ".feature_flags[] | select(.name == \"$flag\") | .default" "${FEATURE_FLAGS_DEFS_PATH}")
-      description=$(yq ".feature_flags[] | select(.name == \"$flag\") | .description" "${FEATURE_FLAGS_DEFS_PATH}")
-
-      echo "// ${flag} - ${description}" >> "${FEATURE_FLAGS_CXX_PATH}"
+      echo "// ${flag} - ${CONFIGURE_FEATURE_FLAGS_DESCRIPTION[$flag]}" >> "${FEATURE_FLAGS_CXX_PATH}"
 
       local flag_pascal
       flag_pascal=$(snake_case_to_pascal_case "${flag}")
@@ -251,10 +273,7 @@ feature_flags_generate_cxx_files_cxx_vars() {
     echo "" >> "${FEATURE_FLAGS_CXX_PATH}"
 
     for flag in "${int_flags[@]}"; do
-      default=$(yq ".feature_flags[] | select(.name == \"$flag\") | .default" "${FEATURE_FLAGS_DEFS_PATH}")
-      description=$(yq ".feature_flags[] | select(.name == \"$flag\") | .description" "${FEATURE_FLAGS_DEFS_PATH}")
-
-      echo "// ${flag} - ${description}" >> "${FEATURE_FLAGS_CXX_PATH}"
+      echo "// ${flag} - ${CONFIGURE_FEATURE_FLAGS_DESCRIPTION[$flag]}" >> "${FEATURE_FLAGS_CXX_PATH}"
 
       local flag_pascal
       flag_pascal=$(snake_case_to_pascal_case "${flag}")
@@ -300,6 +319,7 @@ feature_flags_process() {
   fi
 
   load_feature_flags_from_yaml
+  load_flag_metadata
 
   # Check if YAML file has correct structure
   if ! yq -e '.feature_flags' "${FEATURE_FLAGS_PATH}" >/dev/null 2>&1; then
@@ -308,18 +328,13 @@ feature_flags_process() {
   fi
 
   local flag_names
-  mapfile -t flag_names < <(yq '.feature_flags[].name' "${FEATURE_FLAGS_DEFS_PATH}")
+  mapfile -t flag_names < <(get_all_flag_names)
   local flags_updated=false
 
   # Add each missing flag to the feature flags
   for flag in ${flag_names[@]}; do
-    flag=$(strip_quotes "${flag}")
-
     if [[ -z "${CONFIGURE_FEATURE_FLAGS[$flag]}" ]]; then
-      default=$(yq ".feature_flags[] | select(.name == \"$flag\") | .default" "${FEATURE_FLAGS_DEFS_PATH}")
-      description=$(yq ".feature_flags[] | select(.name == \"$flag\") | .description" "${FEATURE_FLAGS_DEFS_PATH}")
-
-      CONFIGURE_FEATURE_FLAGS["$flag"]="$default"
+      CONFIGURE_FEATURE_FLAGS["$flag"]="${CONFIGURE_FEATURE_FLAGS_DEFAULT[$flag]}"
       flags_updated=true
     fi
   done
@@ -329,7 +344,6 @@ feature_flags_process() {
     # Check if flag from file is in definitions
     local flag_exists=false
     for def_flag in "${flag_names[@]}"; do
-      def_flag=$(strip_quotes "${def_flag}")
       if [[ "$flag" == "$def_flag" ]]; then
         flag_exists=true
         break
@@ -343,8 +357,7 @@ feature_flags_process() {
     # Validate flag value based on type
     if ! validate_flag_value "$flag" "${CONFIGURE_FEATURE_FLAGS[$flag]}"; then
       pretty_warn "Feature flag ${flag} has invalid value ${CONFIGURE_FEATURE_FLAGS[$flag]}."
-      default=$(yq ".feature_flags[] | select(.name == \"$flag\") | .default" "${FEATURE_FLAGS_DEFS_PATH}")
-      CONFIGURE_FEATURE_FLAGS[$flag]="$default"
+      CONFIGURE_FEATURE_FLAGS[$flag]="${CONFIGURE_FEATURE_FLAGS_DEFAULT[$flag]}"
       flags_updated=true
     fi
   done
@@ -355,35 +368,32 @@ feature_flags_process() {
 }
 
 feature_flags_reset_to_defaults() {
+  load_flag_metadata
+
   local flag_names
-  mapfile -t flag_names < <(yq '.feature_flags[].name' "${FEATURE_FLAGS_DEFS_PATH}")
+  mapfile -t flag_names < <(get_all_flag_names)
 
   for flag in "${flag_names[@]}"; do
-    flag=$(strip_quotes "${flag}")
-    default=$(yq ".feature_flags[] | select(.name == \"$flag\") | .default" "${FEATURE_FLAGS_DEFS_PATH}")
-    CONFIGURE_FEATURE_FLAGS[$flag]="$default"
+    CONFIGURE_FEATURE_FLAGS[$flag]="${CONFIGURE_FEATURE_FLAGS_DEFAULT[$flag]}"
   done
 
   save_feature_flags_to_yaml
 }
 
 feature_flags_generate_cmake() {
-  load_feature_flags_from_yaml
+  load_flag_metadata
 
   local conf_cmake="${FEATURE_FLAGS_DIR}/../../config/conf.generated.cmake"
 
   local flag_names
-  mapfile -t flag_names < <(yq '.feature_flags[].name' "${FEATURE_FLAGS_DEFS_PATH}")
+  mapfile -t flag_names < <(get_all_flag_names)
 
   echo "" >> "$conf_cmake"
   echo "# FEATURE FLAGS: " >> "$conf_cmake"
   for flag in "${flag_names[@]}"; do
-    # make first letter uppercase and replace underscores with big letters
-    flag=$(echo "${flag}" | tr -d '"')
     flag_upper=$(convert_to_upper_case "${flag}")
 
-    local type
-    type=$(get_flag_type "$flag")
+    local type="${CONFIGURE_FEATURE_FLAGS_TYPE[$flag]}"
 
     if [[ "$type" == "boolean" ]]; then
       if [[ ${CONFIGURE_FEATURE_FLAGS[$flag]} == true ]]; then
@@ -455,7 +465,24 @@ feature_flags_apply_preset() {
     # Split flag into name and value
     IFS='=' read -r flag_name flag_value <<< "$flag"
 
-    feature_flags_set $flag_name $flag_value
+    # Validate the flag and value
+    if [[ -z "${CONFIGURE_FEATURE_FLAGS[$flag_name]}" ]]; then
+      dump_error "Feature flag '${flag_name}' is not defined."
+      return 1
+    fi
+
+    if ! validate_flag_value "$flag_name" "$flag_value"; then
+      local type
+      type=$(get_flag_type "$flag_name")
+      if [[ "$type" == "boolean" ]]; then
+        dump_error "Invalid value for feature flag '${flag_name}'. Use 'true' or 'false'."
+      else
+        dump_error "Invalid value for feature flag '${flag_name}'."
+      fi
+      return 1
+    fi
+
+    CONFIGURE_FEATURE_FLAGS[$flag_name]="$flag_value"
   done
 
   save_feature_flags_to_yaml
diff --git a/userspace/build/linker.ld b/userspace/build/linker.ld
index 04e633e2..ae5a1d6c 100644
--- a/userspace/build/linker.ld
+++ b/userspace/build/linker.ld
@@ -1,4 +1,4 @@
-ENTRY(main)
+ENTRY(_start)
 
 SECTIONS
 {
diff --git a/userspace/programs/hello_world/main.cpp b/userspace/programs/hello_world/main.cpp
index 2e74d8bd..69934102 100644
--- a/userspace/programs/hello_world/main.cpp
+++ b/userspace/programs/hello_world/main.cpp
@@ -31,6 +31,30 @@ extern "C" int main()
     __platform_get_clock_value(kTimeUtc, &tv, &tz);
     printf("Current Timestamp: %llu\n", tv.seconds);
 
+    char buffer[64]{};
+    fd_t fd = __platform_open("/docs/greet.txt", kFdFlagReadWrite);
+    if (fd < 3) {
+        printf("KWorker failed to open /docs/greet.txt for reading!");
+    }
+
+    int len         = snprintf(buffer, sizeof(buffer), "Hello AlkOS from User Space!");
+    ssize_t written = __platform_write(fd, buffer, len);
+    if (written == -1) {
+        printf("KWorker failed to write to /docs/greet.txt!");
+    }
+
+    ssize_t pos = __platform_seek(fd, 0, kFdSeekSet);
+    if (pos == -1) {
+        printf("KWorker failed to seek to start of /docs/greet.txt!");
+    }
+
+    ssize_t read = __platform_read(fd, buffer, 64);
+    if (read == -1) {
+        printf("KWorker failed to read from /docs/greet.txt!");
+    }
+
+    printf("KWorker: '%.*s'", static_cast<int>(written), buffer);
+
     while (true) {
         static size_t kSpins = 1'000'000;
         size_t counter       = 0;

From 73f897f9b58269ed145e3fc0d5e9798a54371c85 Mon Sep 17 00:00:00 2001
From: Jakub Lisowski <115403674+Jlisowskyy@users.noreply.github.com>
Date: Fri, 2 Jan 2026 18:16:53 +0100
Subject: [PATCH 39/56] Jlisowskyy/scheduler imprv 0 (#262)

Things done in PR:
- Added time accounting to scheduler
- Fixed some minor bugs
- Improved core local data access
---
 .../arch/x86_64/boot/lib/hw/serial/qemu.cpp   |   2 -
 .../arch/x86_64/src/drivers/serial/qemu.cpp   |   2 -
 kernel/arch/x86_64/src/hal/impl/core.cpp      |   3 +-
 kernel/arch/x86_64/src/hal/impl/core.hpp      |  48 +++++++-
 .../x86_64/src/hal/impl/interrupt_params.hpp  |   6 +
 .../arch/x86_64/src/hal/impl/scheduling.cpp   |  43 +++++--
 .../arch/x86_64/src/hal/impl/scheduling.hpp   |   3 +-
 kernel/arch/x86_64/src/hal/impl/tasks.hpp     |   7 --
 kernel/arch/x86_64/src/include/thread.nasm    |   4 +
 kernel/arch/x86_64/src/interrupts/idt.cpp     |   6 +-
 kernel/arch/x86_64/src/interrupts/idt.hpp     |   6 +-
 kernel/arch/x86_64/src/interrupts/idt.nasm    | 116 +++++++++---------
 kernel/arch/x86_64/src/kernel/init.cpp        |  22 ++--
 .../arch/x86_64/src/scheduling/scheduling.cpp |  85 +++++--------
 .../x86_64/src/tests/interrupts_tests.cpp     |   4 +-
 kernel/src/acpi/osl.cpp                       |   2 +-
 kernel/src/fs/costants.hpp                    |  12 ++
 kernel/src/fs/file_descriptor.hpp             |  10 +-
 kernel/src/hal/api/tasks.hpp                  |   1 -
 kernel/src/hal/core.hpp                       |  11 +-
 kernel/src/hal/interrupt_params.hpp           |   6 +
 kernel/src/hal/panic.hpp                      |  14 ++-
 kernel/src/hal/scheduling.hpp                 |   8 +-
 kernel/src/hardware/core_local.hpp            |  32 +++--
 kernel/src/interrupts/interrupt_types.hpp     |   7 +-
 kernel/src/interrupts/interrupts.cpp          |  10 +-
 .../interrupts/logical_interrupt_table.hpp    |  21 ++--
 kernel/src/io/pipe.hpp                        |   1 -
 kernel/src/kernel.cpp                         |   1 -
 kernel/src/mem/virt/addr_space.hpp            |   2 +-
 kernel/src/mem/virt/page_fault.cpp            |   2 +-
 kernel/src/mem/virt/page_fault.hpp            |   2 +-
 kernel/src/modules/hardware.cpp               |   2 +-
 kernel/src/scheduling/error.hpp               |   3 +
 kernel/src/scheduling/kworker.cpp             |   2 +-
 kernel/src/scheduling/process.hpp             |   6 +-
 kernel/src/scheduling/scheduler.cpp           |   2 +-
 kernel/src/scheduling/task_mgr.cpp            |  66 ++++------
 kernel/src/scheduling/task_mgr.hpp            |   8 +-
 kernel/src/scheduling/thread.hpp              |  14 +++
 kernel/src/scheduling/threads.cpp             |  82 +++++++++++--
 kernel/src/scheduling/threads.hpp             |  31 ++++-
 kernel/src/sys/loader.cpp                     |   9 +-
 kernel/src/time/event_framework.cpp           |   2 +-
 kernel/src/trace.cpp                          |  18 +--
 kernel/test/manual_tests.cpp                  |  12 +-
 .../include/data_structures/hash_maps.hpp     |   2 +-
 47 files changed, 456 insertions(+), 302 deletions(-)
 create mode 100644 kernel/src/fs/costants.hpp

diff --git a/kernel/arch/x86_64/boot/lib/hw/serial/qemu.cpp b/kernel/arch/x86_64/boot/lib/hw/serial/qemu.cpp
index 3aa4466b..db6a7974 100644
--- a/kernel/arch/x86_64/boot/lib/hw/serial/qemu.cpp
+++ b/kernel/arch/x86_64/boot/lib/hw/serial/qemu.cpp
@@ -142,8 +142,6 @@ void QemuTerminalInit()
 
     /* Switch to normal operation mode with final modem configuration */
     outb(kModemControlReg, kModemConfFlags);
-
-    TRACE_SUCCESS("QemuTerminalInit() returned with success");
 }
 
 /**
diff --git a/kernel/arch/x86_64/src/drivers/serial/qemu.cpp b/kernel/arch/x86_64/src/drivers/serial/qemu.cpp
index f2af64d6..f2f24af6 100644
--- a/kernel/arch/x86_64/src/drivers/serial/qemu.cpp
+++ b/kernel/arch/x86_64/src/drivers/serial/qemu.cpp
@@ -142,8 +142,6 @@ void QemuTerminalInit()
 
     /* Switch to normal operation mode with final modem configuration */
     outb(kModemControlReg, kModemConfFlags);
-
-    DEBUG_INFO_GENERAL("QemuTerminalInit() returned with success");
 }
 
 /**
diff --git a/kernel/arch/x86_64/src/hal/impl/core.cpp b/kernel/arch/x86_64/src/hal/impl/core.cpp
index 3158143e..17b30e45 100644
--- a/kernel/arch/x86_64/src/hal/impl/core.cpp
+++ b/kernel/arch/x86_64/src/hal/impl/core.cpp
@@ -15,7 +15,8 @@ void Core::EnableCore()
 
 void InitializeCoreLocal()
 {
-    auto *core_local = static_cast<hardware::CoreLocal *>(GetCoreLocalData());
+    auto *core_local = static_cast<hardware::CoreLocal *>(hardware::GetCoreLocalSelf());
+    ASSERT_NOT_NULL(core_local);
 
     cpu::DefaultGdtInit(core_local->gdt, reinterpret_cast<u64>(&core_local->tss));
     core_local->gdtr.limit = sizeof(cpu::GDT) - 1;
diff --git a/kernel/arch/x86_64/src/hal/impl/core.hpp b/kernel/arch/x86_64/src/hal/impl/core.hpp
index 0611d193..a8c11456 100644
--- a/kernel/arch/x86_64/src/hal/impl/core.hpp
+++ b/kernel/arch/x86_64/src/hal/impl/core.hpp
@@ -78,6 +78,7 @@ class CoreController : public CoreControllerAPI
 // ------------------------------
 
 struct CoreLocal {
+    void *self;
     cpu::GDT gdt;
     cpu::Gdtr gdtr;
     cpu::TSS tss;
@@ -95,7 +96,52 @@ FAST_CALL void SetCoreLocalData(void *data)
     cpu::SetMSR(kIa32GsBase, reinterpret_cast<u64>(data));
 }
 
-FAST_CALL void *GetCoreLocalData() { return reinterpret_cast<void *>(cpu::GetMSR(kIa32GsBase)); }
+template <typename T, size_t kOffset>
+NODISCARD FAST_CALL T GetCoreLocalField()
+{
+    T value;
+    static_assert(sizeof(T) <= 8, "Unsupported size for GetCoreLocalField");
+
+    if constexpr (sizeof(T) == 8) {
+        __asm__ volatile("movq %%gs:%1, %q0"
+                         : "=r"(value)
+                         : "m"(*reinterpret_cast<T *>(kOffset))
+                         : "memory");
+    } else if constexpr (sizeof(T) == 4) {
+        __asm__ volatile("movl %%gs:%1, %k0"
+                         : "=r"(value)
+                         : "m"(*reinterpret_cast<T *>(kOffset))
+                         : "memory");
+    } else if constexpr (sizeof(T) == 2) {
+        __asm__ volatile("movw %%gs:%1, %w0"
+                         : "=r"(value)
+                         : "m"(*reinterpret_cast<T *>(kOffset))
+                         : "memory");
+    } else if constexpr (sizeof(T) == 1) {
+        __asm__ volatile("movb %%gs:%1, %b0"
+                         : "=r"(value)
+                         : "m"(*reinterpret_cast<T *>(kOffset))
+                         : "memory");
+    }
+    return value;
+}
+
+template <typename T, size_t Offset>
+FAST_CALL void SetCoreLocalField(T value)
+{
+    static_assert(std::is_trivially_copyable_v<T>);
+    static_assert(sizeof(T) <= 8);
+
+    if constexpr (sizeof(T) == 8) {
+        __asm__ volatile("movq %q0, %%gs:%P1" : : "r"(value), "n"(Offset) : "memory");
+    } else if constexpr (sizeof(T) == 4) {
+        __asm__ volatile("movl %k0, %%gs:%P1" : : "r"(value), "n"(Offset) : "memory");
+    } else if constexpr (sizeof(T) == 2) {
+        __asm__ volatile("movw %w0, %%gs:%P1" : : "r"(value), "n"(Offset) : "memory");
+    } else if constexpr (sizeof(T) == 1) {
+        __asm__ volatile("movb %b0, %%gs:%P1" : : "r"(value), "n"(Offset) : "memory");
+    }
+}
 
 void InitializeCoreLocal();
 
diff --git a/kernel/arch/x86_64/src/hal/impl/interrupt_params.hpp b/kernel/arch/x86_64/src/hal/impl/interrupt_params.hpp
index 51591b7e..18ee8c0f 100644
--- a/kernel/arch/x86_64/src/hal/impl/interrupt_params.hpp
+++ b/kernel/arch/x86_64/src/hal/impl/interrupt_params.hpp
@@ -4,6 +4,7 @@
 #include <defines.h>
 #include <types.h>
 #include <hal/api/interrupts_params.hpp>
+#include "cpu/gdt.hpp"
 
 struct PACK IsrRegisters {
     uint64_t rax;
@@ -48,6 +49,11 @@ static constexpr size_t kNumX86_64Irqs          = 16;
 struct ExceptionData : IsrErrorStackFrame {
 };
 
+NODISCARD FAST_CALL bool IsInterruptFromUserSpace(const ExceptionData &data)
+{
+    return (data.isr_stack_frame.cs & 3) != 0;
+}
+
 /* Mapping params */
 static constexpr u16 kTimerHwLirq      = 0;
 static constexpr u16 kPageFaultExcLirq = 14;
diff --git a/kernel/arch/x86_64/src/hal/impl/scheduling.cpp b/kernel/arch/x86_64/src/hal/impl/scheduling.cpp
index ffa8c1ed..43b0ddfa 100644
--- a/kernel/arch/x86_64/src/hal/impl/scheduling.cpp
+++ b/kernel/arch/x86_64/src/hal/impl/scheduling.cpp
@@ -7,33 +7,50 @@
 #include <string.h>
 #include <bits_ext.hpp>
 
-template <bool kIsKernelTask = true>
-FAST_CALL void InitializeStack(void **stack, void (*f)())
+namespace arch
+{
+void InitializeThreadStack(void **stack, const Sched::Task &task)
 {
     /* NOTE: Thread entry always starts in Kernel Code */
-    static constexpr auto kFunc =
-        kIsKernelTask ? Sched::KThreadEntrypoint : Sched::UserThreadEntrypoint;
-
     auto stack_top = static_cast<byte *>(*stack) - sizeof(IsrErrorStackFrame);
     auto frame     = reinterpret_cast<IsrErrorStackFrame *>(stack_top);
 
     memset(stack_top, 0, sizeof(IsrErrorStackFrame));
 
-    frame->registers.rdi          = reinterpret_cast<u64>(f);
-    frame->isr_stack_frame.rip    = reinterpret_cast<u64>(kFunc);
+    /* Initialize IsrErrorStackFrame */
+    frame->isr_stack_frame.rip    = reinterpret_cast<u64>(task.func);
     frame->error_code             = 0;
     frame->isr_stack_frame.cs     = static_cast<u64>(cpu::GDT::kKernelCodeSelector);
     frame->isr_stack_frame.rflags = kInitialRFlags;
     frame->isr_stack_frame.rsp    = reinterpret_cast<u64>(*stack);
     frame->isr_stack_frame.ss     = static_cast<u64>(cpu::GDT::kKernelDataSelector);
 
-    *stack = reinterpret_cast<void *>(stack_top);
-}
+    /* Initialize function arguments */
+    if (task.args_count > 0) {
+        frame->registers.rdi = task.args[0];
+    }
 
-namespace arch
-{
-void InitializeStackKThread(void **stack, void (*f)()) { InitializeStack<true>(stack, f); }
+    if (task.args_count > 1) {
+        frame->registers.rsi = task.args[1];
+    }
+
+    if (task.args_count > 2) {
+        frame->registers.rdx = task.args[2];
+    }
+
+    if (task.args_count > 3) {
+        frame->registers.rcx = task.args[3];
+    }
 
-void InitializeStackUserThread(void **stack, void (*f)()) { InitializeStack<false>(stack, f); }
+    if (task.args_count > 4) {
+        frame->registers.r8 = task.args[4];
+    }
 
+    if (task.args_count > 5) {
+        frame->registers.r9 = task.args[5];
+    }
+
+    /* Save adjusted stack address */
+    *stack = reinterpret_cast<void *>(stack_top);
+}
 }  // namespace arch
diff --git a/kernel/arch/x86_64/src/hal/impl/scheduling.hpp b/kernel/arch/x86_64/src/hal/impl/scheduling.hpp
index 9d243e71..c7c73790 100644
--- a/kernel/arch/x86_64/src/hal/impl/scheduling.hpp
+++ b/kernel/arch/x86_64/src/hal/impl/scheduling.hpp
@@ -14,8 +14,7 @@ namespace arch
 using ::ContextSwitch;
 using ::ConvertContext;
 using ::JumpToUserSpace;
-void InitializeStackKThread(void **stack, void (*f)());
-void InitializeStackUserThread(void **stack, void (*f)());
+void InitializeThreadStack(void **stack, const Sched::Task &task);
 }  // namespace arch
 
 #endif  // KERNEL_ARCH_X86_64_SRC_HAL_IMPL_SCHEDULING_HPP_
diff --git a/kernel/arch/x86_64/src/hal/impl/tasks.hpp b/kernel/arch/x86_64/src/hal/impl/tasks.hpp
index a2e37a2b..d0b4b8fd 100644
--- a/kernel/arch/x86_64/src/hal/impl/tasks.hpp
+++ b/kernel/arch/x86_64/src/hal/impl/tasks.hpp
@@ -15,13 +15,6 @@ struct Thread : ThreadAPI {
 
     u64 fs_base;
     u64 gs_base;
-
-    FORCE_INLINE_F void InitMem()
-    {
-        fs_base = 0;
-        gs_base = 0;
-        memset(fp_state, 0, sizeof(fp_state));
-    }
 };
 struct Process {
 };
diff --git a/kernel/arch/x86_64/src/include/thread.nasm b/kernel/arch/x86_64/src/include/thread.nasm
index 1baa7ad1..a71e69af 100644
--- a/kernel/arch/x86_64/src/include/thread.nasm
+++ b/kernel/arch/x86_64/src/include/thread.nasm
@@ -13,4 +13,8 @@ struc Thread
     .kernel_stack_bottom: resq 1
     .user_stack:   resq 1
     .user_stack_bottom:   resq 1
+
+    .kernel_time_ns resq 1
+    .user_time_ns   resq 1
+    .timestamp      resq 1
 endstruc
diff --git a/kernel/arch/x86_64/src/interrupts/idt.cpp b/kernel/arch/x86_64/src/interrupts/idt.cpp
index 9d383c75..7cb6a5fc 100644
--- a/kernel/arch/x86_64/src/interrupts/idt.cpp
+++ b/kernel/arch/x86_64/src/interrupts/idt.cpp
@@ -55,7 +55,7 @@ extern "C" void *IsrWrapperTable[];
  *
  * @param idt_idx index of interrupt triggered.
  */
-NO_RET void *DefaultInterruptHandler(const u8 idt_idx)
+NO_RET Sched::Thread *DefaultInterruptHandler(const u8 idt_idx)
 {
     hal::KernelPanicFormat("Received unsupported interrupt with code: %hhu\n", idt_idx);
     return nullptr;
@@ -117,7 +117,7 @@ NO_RET FAST_CALL void DefaultExceptionHandler(
     );
 }
 
-void *DefaultExceptionHandler(intr::LitExcEntry &entry, hal::ExceptionData *data)
+Sched::Thread *DefaultExceptionHandler(intr::LitExcEntry &entry, hal::ExceptionData *data)
 {
     DefaultExceptionHandler(data, entry.hardware_irq);
     return nullptr;
@@ -128,7 +128,7 @@ FAST_CALL void LogIrqReceived(const u16 idt_idx, const u16 lirq)
     TRACE_FREQ_INFO_INTERRUPTS("Received interrupt with idt idx: %hu and lirq: %hu", idt_idx, lirq);
 }
 
-void *SimpleIrqHandler(intr::LitHwEntry &entry)
+Sched::Thread *SimpleIrqHandler(intr::LitHwEntry &entry)
 {
     LogIrqReceived(entry.hardware_irq, entry.logical_irq);
     return nullptr;
diff --git a/kernel/arch/x86_64/src/interrupts/idt.hpp b/kernel/arch/x86_64/src/interrupts/idt.hpp
index 6ba809a8..05c1f37c 100644
--- a/kernel/arch/x86_64/src/interrupts/idt.hpp
+++ b/kernel/arch/x86_64/src/interrupts/idt.hpp
@@ -121,8 +121,8 @@ struct Idt {
 // ------------------------------
 
 const char *GetExceptionMsg(u8 idx);
-void *DefaultInterruptHandler(u8 idt_idx);
-void *DefaultExceptionHandler(intr::LitExcEntry &entry, hal::ExceptionData *data);
-void *SimpleIrqHandler(intr::LitHwEntry &entry);
+Sched::Thread *DefaultInterruptHandler(u8 idt_idx);
+Sched::Thread *DefaultExceptionHandler(intr::LitExcEntry &entry, hal::ExceptionData *data);
+Sched::Thread *SimpleIrqHandler(intr::LitHwEntry &entry);
 
 #endif  // KERNEL_ARCH_X86_64_SRC_INTERRUPTS_IDT_HPP_
diff --git a/kernel/arch/x86_64/src/interrupts/idt.nasm b/kernel/arch/x86_64/src/interrupts/idt.nasm
index 2a94a9ce..01d6800c 100644
--- a/kernel/arch/x86_64/src/interrupts/idt.nasm
+++ b/kernel/arch/x86_64/src/interrupts/idt.nasm
@@ -6,14 +6,15 @@
 
 extern cdecl_SetKernelGs
 extern cdecl_ContextSwitchOnInterrupt
-extern HandleException
-extern HandleHardwareInterrupt
-extern HandleSoftwareInterrupt
+extern cdecl_HandleException
+extern cdecl_HandleHardwareInterrupt
+extern cdecl_HandleSoftwareInterrupt
+extern cdecl_UpdateTcbOnSyscallEntry
+extern cdecl_UpdateTcbOnSyscallExit
 
 %macro load_user_gs_if_needed 0
-    mov r12, [rsp + _cs_int_frame_offset]
-    cmp qword r12, _kernel_code_selector
-    je .skip_user_gs_swap
+    test qword [rsp + _cs_int_frame_offset], 3
+    jz .skip_user_gs_swap
     call cdecl_SetKernelGs
     swapgs
 .skip_user_gs_swap:
@@ -41,16 +42,15 @@ extern HandleSoftwareInterrupt
 %endmacro
 
 %macro load_kernel_gs_if_needed 0
-    mov r12, [rsp + _cs_int_frame_offset]
-    cmp qword r12, _kernel_code_selector
-    je .skip_kernel_gs_swap
+    test qword [rsp + _cs_int_frame_offset], 3
+    jz .skip_kernel_gs_swap
     swapgs
 .skip_kernel_gs_swap:
 %endmacro
 
 ; Macro for CPU exceptions that DO NOT push an error code.
 ; A dummy error code is pushed to create a consistent stack frame.
-; Calls 'HandleException(u16 lirq, ExceptionData* data)'.
+; Calls 'cdecl_HandleException(u16 lirq, ExceptionData* data)'.
 %macro exception_wrapper 1
 isr_wrapper_%+%1:
     push 0                      ; Push a dummy error code for alignment.
@@ -62,13 +62,13 @@ isr_wrapper_%+%1:
     cld                         ; Clear direction flag.
     mov rdi, %1                 ; Arg1: interrupt number.
     mov rsi, rsp                ; Arg2: pointer to stack frame.
-    call HandleException
+    call cdecl_HandleException
 
     context_switch_if_needed
 %endmacro
 
 ; Macro for CPU exceptions that DO push an error code.
-; Calls 'HandleException(u16 lirq, ExceptionData* data)'.
+; Calls 'cdecl_HandleException(u16 lirq, ExceptionData* data)'.
 %macro exception_error_wrapper 1
 isr_wrapper_%+%1:
     sub rsp, _all_reg_size          ; Allocate space for saving registers.
@@ -79,7 +79,7 @@ isr_wrapper_%+%1:
     cld                         ; Clear direction flag.
     mov rdi, %1                 ; Arg1: interrupt number.
     mov rsi, rsp                ; Arg2: pointer to stack frame.
-    call HandleException
+    call cdecl_HandleException
 
     context_switch_if_needed
 %endmacro
@@ -96,6 +96,7 @@ isr_wrapper_%+%2:
 
     cld                         ; Clear direction flag for string operations.
     mov rdi, %1                 ; Pass the mapped IRQ number as the first argument.
+    mov rsi, rsp                ; Arg2: pointer to stack frame.
     call %3                     ; Call the specific ISR handler.
 
     context_switch_if_needed
@@ -122,7 +123,7 @@ extern g_syscall_count
 ; - Return value: RAX
 isr_wrapper_128:  ; Syscall interrupt (128)
     sub rsp, _sysv_reg_size          ; Allocate space for saving registers.
-    push_sysv_regs_without_rax       ; Save registers except RAX.
+    push_sysv_regs       ; Save registers
     cld                              ; Clear direction flag for string operations.
 
     ; Syscall to Sys V ABI conversion
@@ -133,22 +134,25 @@ isr_wrapper_128:  ; Syscall interrupt (128)
     jae .invalid_syscall
 
     swapgs
+;    call cdecl_UpdateTcbOnSyscallEntry
 
     ; Get pointer to syscall_dispatch_table and dispatch
+    mov qword rax, [rsp + _rax]
     call qword [rel g_syscall_dispatch_table + rax*8]
+    mov qword [rsp + _rax], rax
     jmp .return
 
 .invalid_syscall:
-    mov rax, -1                      ; Set error return value
+    mov qword [rsp + _rax], -1                      ; Set error return value
 
 .return:
 
-    push rax                         ; Save RAX (syscall return value).
+;    call cdecl_UpdateTcbOnSyscallExit
+
     call cdecl_SetKernelGs
     swapgs
 
-    pop rax                          ; Restore RAX.
-    pop_sysv_regs_without_rax        ; Restore registers except RAX.
+    pop_sysv_regs        ; Restore registers
     add rsp, _sysv_reg_size          ; Deallocate register save space.
     iretq                            ; Return from interrupt.
 
@@ -156,7 +160,7 @@ isr_wrapper_128:  ; Syscall interrupt (128)
 ; ISR wrappers definitions
 ; ------------------------------
 
-; Intel-defined interrupts (0-31) -> HandleException
+; Intel-defined interrupts (0-31) -> cdecl_HandleException
 exception_wrapper 0  ; Division Error: Divide by zero error
 exception_wrapper 1  ; Debug: Reserved for debugging exceptions
 exception_wrapper 2  ; Non-Maskable Interrupt: Non-maskable interrupt detected
@@ -190,50 +194,50 @@ exception_error_wrapper 29 ; VMM Communication Exception
 exception_error_wrapper 30 ; Security Exception: Security-related error
 exception_wrapper 31 ; Reserved: Reserved by Intel
 
-; IRQs for PICs (32–47) -> HandleHardwareInterrupt
-interrupt_wrapper 0, 32, HandleHardwareInterrupt ; IRQ0: System timer
-interrupt_wrapper 1, 33, HandleHardwareInterrupt ; IRQ1: Keyboard
-interrupt_wrapper 2, 34, HandleHardwareInterrupt ; IRQ2: Cascade
-interrupt_wrapper 3, 35, HandleHardwareInterrupt ; IRQ3: Serial port 2
-interrupt_wrapper 4, 36, HandleHardwareInterrupt ; IRQ4: Serial port 1
-interrupt_wrapper 5, 37, HandleHardwareInterrupt ; IRQ5: Parallel port 2 / sound card
-interrupt_wrapper 6, 38, HandleHardwareInterrupt ; IRQ6: Floppy controller
-interrupt_wrapper 7, 39, HandleHardwareInterrupt ; IRQ7: Parallel port 1
-interrupt_wrapper 8, 40, HandleHardwareInterrupt ; IRQ8: Real-time clock
-interrupt_wrapper 9, 41, HandleHardwareInterrupt ; IRQ9: Free for peripherals
-interrupt_wrapper 10, 42, HandleHardwareInterrupt ; IRQ10: Free for peripherals
-interrupt_wrapper 11, 43, HandleHardwareInterrupt ; IRQ11: Free for peripherals
-interrupt_wrapper 12, 44, HandleHardwareInterrupt ; IRQ12: Mouse
-interrupt_wrapper 13, 45, HandleHardwareInterrupt ; IRQ13: FPU (legacy)
-interrupt_wrapper 14, 46, HandleHardwareInterrupt ; IRQ14: Primary ATA channel
-interrupt_wrapper 15, 47, HandleHardwareInterrupt ; IRQ15: Secondary ATA channel
-
-; IRQs for APICs and other devices (48–127) -> HandleHardwareInterrupt
+; IRQs for PICs (32–47) -> cdecl_HandleHardwareInterrupt
+interrupt_wrapper 0, 32, cdecl_HandleHardwareInterrupt ; IRQ0: System timer
+interrupt_wrapper 1, 33, cdecl_HandleHardwareInterrupt ; IRQ1: Keyboard
+interrupt_wrapper 2, 34, cdecl_HandleHardwareInterrupt ; IRQ2: Cascade
+interrupt_wrapper 3, 35, cdecl_HandleHardwareInterrupt ; IRQ3: Serial port 2
+interrupt_wrapper 4, 36, cdecl_HandleHardwareInterrupt ; IRQ4: Serial port 1
+interrupt_wrapper 5, 37, cdecl_HandleHardwareInterrupt ; IRQ5: Parallel port 2 / sound card
+interrupt_wrapper 6, 38, cdecl_HandleHardwareInterrupt ; IRQ6: Floppy controller
+interrupt_wrapper 7, 39, cdecl_HandleHardwareInterrupt ; IRQ7: Parallel port 1
+interrupt_wrapper 8, 40, cdecl_HandleHardwareInterrupt ; IRQ8: Real-time clock
+interrupt_wrapper 9, 41, cdecl_HandleHardwareInterrupt ; IRQ9: Free for peripherals
+interrupt_wrapper 10, 42, cdecl_HandleHardwareInterrupt ; IRQ10: Free for peripherals
+interrupt_wrapper 11, 43, cdecl_HandleHardwareInterrupt ; IRQ11: Free for peripherals
+interrupt_wrapper 12, 44, cdecl_HandleHardwareInterrupt ; IRQ12: Mouse
+interrupt_wrapper 13, 45, cdecl_HandleHardwareInterrupt ; IRQ13: FPU (legacy)
+interrupt_wrapper 14, 46, cdecl_HandleHardwareInterrupt ; IRQ14: Primary ATA channel
+interrupt_wrapper 15, 47, cdecl_HandleHardwareInterrupt ; IRQ15: Secondary ATA channel
+
+; IRQs for APICs and other devices (48–127) -> cdecl_HandleHardwareInterrupt
 %assign idt_num 48
 %assign irq_num 16
 %rep 127-48+1
-    interrupt_wrapper irq_num, idt_num, HandleHardwareInterrupt
+    interrupt_wrapper irq_num, idt_num, cdecl_HandleHardwareInterrupt
 %assign idt_num idt_num + 1
 %assign irq_num irq_num + 1
 %endrep
 
-; Software interrupts (128–143) -> HandleSoftwareInterrupt
-; interrupt_wrapper 0, 128, HandleSoftwareInterrupt ; Syscall handled separately above
-interrupt_wrapper 0, 129, HandleSoftwareInterrupt
-interrupt_wrapper 1, 130, HandleSoftwareInterrupt
-interrupt_wrapper 2, 131, HandleSoftwareInterrupt
-interrupt_wrapper 3, 132, HandleSoftwareInterrupt
-interrupt_wrapper 4, 133, HandleSoftwareInterrupt
-interrupt_wrapper 5, 134, HandleSoftwareInterrupt
-interrupt_wrapper 6, 135, HandleSoftwareInterrupt
-interrupt_wrapper 7, 136, HandleSoftwareInterrupt
-interrupt_wrapper 8, 137, HandleSoftwareInterrupt
-interrupt_wrapper 9, 138, HandleSoftwareInterrupt
-interrupt_wrapper 10, 139, HandleSoftwareInterrupt
-interrupt_wrapper 11, 140, HandleSoftwareInterrupt
-interrupt_wrapper 12, 141, HandleSoftwareInterrupt
-interrupt_wrapper 13, 142, HandleSoftwareInterrupt
-interrupt_wrapper 14, 143, HandleSoftwareInterrupt
+; Software interrupts (128–143) -> cdecl_HandleSoftwareInterrupt
+; interrupt_wrapper 0, 128, cdecl_HandleSoftwareInterrupt ; Syscall handled separately above
+interrupt_wrapper 0, 129, cdecl_HandleSoftwareInterrupt
+interrupt_wrapper 1, 130, cdecl_HandleSoftwareInterrupt
+interrupt_wrapper 2, 131, cdecl_HandleSoftwareInterrupt
+interrupt_wrapper 3, 132, cdecl_HandleSoftwareInterrupt
+interrupt_wrapper 4, 133, cdecl_HandleSoftwareInterrupt
+interrupt_wrapper 5, 134, cdecl_HandleSoftwareInterrupt
+interrupt_wrapper 6, 135, cdecl_HandleSoftwareInterrupt
+interrupt_wrapper 7, 136, cdecl_HandleSoftwareInterrupt
+interrupt_wrapper 8, 137, cdecl_HandleSoftwareInterrupt
+interrupt_wrapper 9, 138, cdecl_HandleSoftwareInterrupt
+interrupt_wrapper 10, 139, cdecl_HandleSoftwareInterrupt
+interrupt_wrapper 11, 140, cdecl_HandleSoftwareInterrupt
+interrupt_wrapper 12, 141, cdecl_HandleSoftwareInterrupt
+interrupt_wrapper 13, 142, cdecl_HandleSoftwareInterrupt
+interrupt_wrapper 14, 143, cdecl_HandleSoftwareInterrupt
 
 
 ; Total number of ISRs.
diff --git a/kernel/arch/x86_64/src/kernel/init.cpp b/kernel/arch/x86_64/src/kernel/init.cpp
index 796b4ec8..3cebda92 100644
--- a/kernel/arch/x86_64/src/kernel/init.cpp
+++ b/kernel/arch/x86_64/src/kernel/init.cpp
@@ -61,29 +61,27 @@ namespace arch
 {
 void ArchInit(const RawBootArguments &)
 {
-    hal::SetCoreLocalData(nullptr);
-
-    DEBUG_INFO_BOOT("In ArchInit...");
-    DEBUG_INFO_BOOT("CPU Model: %d / %08X", GetCpuModel(), GetCpuModel());
-
-    DEBUG_INFO_BOOT("Setting up CPU features...");
     BlockHardwareInterrupts();
 
+    /* Zero mem core local as no global constructors available yet */
+    memset(&g_CoreLocal, 0, sizeof(hardware::CoreLocal));
+    g_CoreLocal.self = &g_CoreLocal;
+    cpu::SetMSR(kIa32GsBase, reinterpret_cast<u64>(&g_CoreLocal));
+    cpu::SetMSR(kIa32GsKernelBase, reinterpret_cast<u64>(&g_CoreLocal));
+    InitializeCoreLocal();
+
     /* NOTE: sequence is important */
     EnableOSXSave();
     EnableSSE();
     EnableAVX();
     EnableNXE();
 
+    DEBUG_INFO_BOOT("In ArchInit...");
+    DEBUG_INFO_BOOT("CPU Model: %d / %08X", GetCpuModel(), GetCpuModel());
+
     HardwareModule::Init();
     HardwareModule::Get().GetInterrupts().FirstStageInit();
 
-    /* Zero mem core local as no global constructors available yet */
-    memset(&g_CoreLocal, 0, sizeof(hardware::CoreLocal));
-    cpu::SetMSR(kIa32GsBase, reinterpret_cast<u64>(&g_CoreLocal));
-    cpu::SetMSR(kIa32GsKernelBase, reinterpret_cast<u64>(&g_CoreLocal));
-    InitializeCoreLocal();
-
     trace::AdvanceTracingStage();
 
     EnableHardwareInterrupts();
diff --git a/kernel/arch/x86_64/src/scheduling/scheduling.cpp b/kernel/arch/x86_64/src/scheduling/scheduling.cpp
index 3c112f24..02e20bad 100644
--- a/kernel/arch/x86_64/src/scheduling/scheduling.cpp
+++ b/kernel/arch/x86_64/src/scheduling/scheduling.cpp
@@ -1,13 +1,11 @@
 #include "modules/scheduling.hpp"
-#include "modules/memory.hpp"
-
-#include <cpu/control_registers.hpp>
-#include <modules/memory.hpp>
-
+#include "cpu/control_registers.hpp"
 #include "cpu/utils.hpp"
 #include "hal/interrupt_params.hpp"
 #include "hardware/core_local.hpp"
 #include "mem/virt/addr_space.hpp"
+#include "modules/memory.hpp"
+#include "modules/timing.hpp"
 #include "scheduling/thread.hpp"
 
 #include <hal/debug_terminal.hpp>
@@ -51,7 +49,7 @@ FAST_CALL void LoadFpStateIfNeeded(Sched::Thread *thread)
     }
 }
 
-FAST_CALL void SetTssRsp0(const u64 rsp0) { hardware::GetCoreLocalData().tss.rsp0 = rsp0; }
+FAST_CALL void SetTssRsp0(const u64 rsp0) { hardware::GetCoreLocalSelf()->tss.rsp0 = rsp0; }
 
 FAST_CALL void SetNextThreadFs(Sched::Thread *thread)
 {
@@ -97,16 +95,6 @@ FAST_CALL void SwapFsIfNeeded(Sched::Thread *current_tcb, Sched::Thread *next_tc
     }
 }
 
-FAST_CALL u64 GetThreadsPageTable(Sched::Thread *thread)
-{
-    ASSERT_NOT_NULL(thread);
-
-    const auto proc = SchedulingModule::Get().GetProcesses().GetProcess(thread->owner);
-    ASSERT_TRUE(static_cast<bool>(proc), "Threads exists -> owner MUST exist");
-
-    return reinterpret_cast<u64>(proc.value()->address_space->PageTableRoot());
-}
-
 FAST_CALL void SwapAsIfNeeded(Sched::Thread *tcb)
 {
     ASSERT_NOT_NULL(tcb);
@@ -114,10 +102,10 @@ FAST_CALL void SwapAsIfNeeded(Sched::Thread *tcb)
     const auto proc = SchedulingModule::Get().GetProcesses().GetProcess(tcb->owner);
     ASSERT_TRUE(static_cast<bool>(proc), "Threads exists -> owner MUST exist");
 
-    auto &current_as = MemoryModule::Get().GetVmm().GetCurrentAddressSpace();
-    auto thread_as   = proc.value()->address_space;
+    const auto current_as = &MemoryModule::Get().GetVmm().GetCurrentAddressSpace();
+    const auto thread_as  = proc.value()->address_space;
 
-    if (&current_as != thread_as) {
+    if (current_as != thread_as) {
         MemoryModule::Get().GetVmm().SwitchAddrSpace(thread_as);
     }
 }
@@ -130,14 +118,16 @@ extern "C" void cdecl_ConvertContextEntry(Sched::Thread *thread)
 {
     SetNextThreadFs(thread);
     LoadFpStateIfNeeded(thread);
-    hardware::SetCurrentTCB(thread);
+    hardware::SetCoreLocalTcb(thread);
     SetTssRsp0(reinterpret_cast<u64>(thread->kernel_stack_bottom));
+    // thread->timestamp = TimingModule::Get().GetSystemTime().ReadLifeTimeNs();
+    SwapAsIfNeeded(thread);
     SwapGsIfJumpingToUserspace(thread);
 }
 
 extern "C" void cdecl_JumpToUserSpaceEntry(void *addr, IsrStackFrame *frame)
 {
-    auto thread          = hardware::GetCurrentTCB();
+    auto thread          = hardware::GetCoreLocalTcb();
     thread->kernel_stack = thread->kernel_stack_bottom;
 
     frame->rip    = reinterpret_cast<u64>(addr);
@@ -146,18 +136,21 @@ extern "C" void cdecl_JumpToUserSpaceEntry(void *addr, IsrStackFrame *frame)
     frame->rsp    = reinterpret_cast<u64>(thread->user_stack_bottom);
     frame->ss     = static_cast<u64>(cpu::GDT::kUserDataSelector);
 
+    const u64 t            = TimingModule::Get().GetSystemTime().ReadLifeTimeNs();
+    thread->kernel_time_ns = t - thread->timestamp;
+    thread->timestamp      = t;
+
     SetThreadGs(thread);
     __asm__ volatile("swapgs" ::: "memory");
-
-    const auto proc = SchedulingModule::Get().GetProcesses().GetProcess(thread->owner);
-    ASSERT_TRUE(static_cast<bool>(proc), "Threads exists -> owner MUST exist");
-    MemoryModule::Get().GetVmm().SwitchAddrSpace(proc.value()->address_space);
 }
 
 extern "C" void cdecl_ContextSwitchEntry(
     Sched::Thread *thread, IsrErrorStackFrame *mem, const u64 rip
 )
 {
+    const auto current_tcb = hardware::GetCoreLocalTcb();
+    DumpFpStateIfNeeded(current_tcb);
+
     mem->error_code             = 0;
     mem->isr_stack_frame.rip    = rip;
     mem->isr_stack_frame.cs     = static_cast<u64>(cpu::GDT::kKernelCodeSelector);
@@ -165,46 +158,30 @@ extern "C" void cdecl_ContextSwitchEntry(
     mem->isr_stack_frame.rsp    = reinterpret_cast<u64>(mem) + sizeof(IsrErrorStackFrame);
     mem->isr_stack_frame.ss     = static_cast<u64>(cpu::GDT::kKernelDataSelector);
 
-    auto current_tcb = hardware::GetCurrentTCB();
     SwapFsIfNeeded(current_tcb, thread);
     current_tcb->kernel_stack = reinterpret_cast<void *>(mem);
-    hardware::SetCurrentTCB(thread);
+    hardware::SetCoreLocalTcb(thread);
     SetTssRsp0(reinterpret_cast<u64>(thread->kernel_stack_bottom));
-    SwapGsIfJumpingToUserspace(thread);
+
+    const u64 t                 = TimingModule::Get().GetSystemTime().ReadLifeTimeNs();
+    current_tcb->kernel_time_ns = t - current_tcb->timestamp;
+    thread->timestamp           = t;
+
     LoadFpStateIfNeeded(thread);
     SwapAsIfNeeded(thread);
+    SwapGsIfJumpingToUserspace(thread);
 }
 
 extern "C" void cdecl_ContextSwitchOnInterrupt(Sched::Thread *thread, void *rsp)
 {
-    auto current_tcb          = hardware::GetCurrentTCB();
+    const auto current_tcb = hardware::GetCoreLocalTcb();
+    DumpFpStateIfNeeded(current_tcb);
+
     current_tcb->kernel_stack = rsp;
     SwapFsIfNeeded(current_tcb, thread);
-    hardware::SetCurrentTCB(thread);
+    hardware::SetCoreLocalTcb(thread);
     SetTssRsp0(reinterpret_cast<u64>(thread->kernel_stack_bottom));
-    SwapAsIfNeeded(thread);
-}
-
-// ===========================
-
-extern "C" void cdecl_SetTssRsp0(const u64 rsp0) { SetTssRsp0(rsp0); }
-
-extern "C" void cdecl_SwapFsIfNeeded(Sched::Thread *thread)
-{
-    SwapFsIfNeeded(hardware::GetCurrentTCB(), thread);
-}
-
-extern "C" void cdecl_SetNextThreadFs(Sched::Thread *thread) { SetNextThreadFs(thread); }
-
-extern "C" void cdecl_DumpFpStateIfNeeded(Sched::Thread *thread) { DumpFpStateIfNeeded(thread); }
-
-extern "C" void cdecl_LoadFpStateIfNeeded(Sched::Thread *thread) { LoadFpStateIfNeeded(thread); }
-
-extern "C" Sched::Thread *cdecl_GetCurrentTCB() { return hardware::GetCurrentTCB(); }
 
-extern "C" void cdecl_SetCurrentTCB(Sched::Thread *tcb) { hardware::SetCurrentTCB(tcb); }
-
-extern "C" u64 cdecl_GetThreadsPageTable(Sched::Thread *thread)
-{
-    return GetThreadsPageTable(thread);
+    LoadFpStateIfNeeded(thread);
+    SwapAsIfNeeded(thread);
 }
diff --git a/kernel/arch/x86_64/src/tests/interrupts_tests.cpp b/kernel/arch/x86_64/src/tests/interrupts_tests.cpp
index f5ec3650..2b005248 100644
--- a/kernel/arch/x86_64/src/tests/interrupts_tests.cpp
+++ b/kernel/arch/x86_64/src/tests/interrupts_tests.cpp
@@ -6,7 +6,7 @@
 // Preserve cpu state test
 // ------------------------------
 
-static void *PolluteAllRegistersSw(intr::LitSwEntry &)
+static Sched::Thread *PolluteAllRegistersSw(intr::LitSwEntry &)
 {
     /* pollute all registers possible */
     __asm__ volatile("movq $-1, %%rax" : : : "rax");
@@ -29,7 +29,7 @@ static void *PolluteAllRegistersSw(intr::LitSwEntry &)
 
 static DumpedRegisters g_DumpedRegisters{};
 
-static void *DivZeroExceptionHandler(intr::LitExcEntry &, hal::ExceptionData *data)
+static Sched::Thread *DivZeroExceptionHandler(intr::LitExcEntry &, hal::ExceptionData *data)
 {
     g_DumpedRegisters.rax = data->registers.rax;
     g_DumpedRegisters.rbx = data->registers.rbx;
diff --git a/kernel/src/acpi/osl.cpp b/kernel/src/acpi/osl.cpp
index f9f6cc27..41446144 100644
--- a/kernel/src/acpi/osl.cpp
+++ b/kernel/src/acpi/osl.cpp
@@ -193,7 +193,7 @@ struct UacpiInterrupt {
     uacpi_handle ctx;
 };
 
-static void *UacpiHander(intr::LitHwEntry &handler)
+static Sched::Thread *UacpiHander(intr::LitHwEntry &handler)
 {
     auto *uacpi_interrupt = static_cast<UacpiInterrupt *>(handler.handler_data.data);
     uacpi_interrupt->uacpi_handler(uacpi_interrupt->ctx);
diff --git a/kernel/src/fs/costants.hpp b/kernel/src/fs/costants.hpp
new file mode 100644
index 00000000..8240cf13
--- /dev/null
+++ b/kernel/src/fs/costants.hpp
@@ -0,0 +1,12 @@
+#ifndef KERNEL_SRC_FS_COSTANTS_HPP_
+#define KERNEL_SRC_FS_COSTANTS_HPP_
+
+namespace Fs
+{
+inline constexpr size_t kMaxFdsPerProcess = 128;
+inline constexpr size_t kMaxOpenFiles     = 1014;
+inline constexpr size_t kMaxActiveFiles   = 512;
+inline constexpr size_t kStdioBufferSize  = 4096;
+}  // namespace Fs
+
+#endif  // KERNEL_SRC_FS_COSTANTS_HPP_
diff --git a/kernel/src/fs/file_descriptor.hpp b/kernel/src/fs/file_descriptor.hpp
index 0e8985a0..22e82f2f 100644
--- a/kernel/src/fs/file_descriptor.hpp
+++ b/kernel/src/fs/file_descriptor.hpp
@@ -7,6 +7,7 @@
 #include <data_structures/tagged_pointer.hpp>
 #include <span.hpp>
 
+#include "fs/costants.hpp"
 #include "hal/spinlock.hpp"
 #include "io/pipe.hpp"
 #include "io/stream.hpp"
@@ -41,15 +42,6 @@ enum class FdError {
 template <typename T = void>
 using FdResult = std::expected<T, FdError>;
 
-// ------------------------------
-// Constants
-// ------------------------------
-
-inline constexpr size_t kMaxFdsPerProcess = 128;
-inline constexpr size_t kMaxOpenFiles     = 1014;
-inline constexpr size_t kMaxActiveFiles   = 512;
-inline constexpr size_t kStdioBufferSize  = 4096;
-
 // ------------------------------
 // File Mode Flags
 // -----------------------------
diff --git a/kernel/src/hal/api/tasks.hpp b/kernel/src/hal/api/tasks.hpp
index 7af22ac0..a7e446aa 100644
--- a/kernel/src/hal/api/tasks.hpp
+++ b/kernel/src/hal/api/tasks.hpp
@@ -4,7 +4,6 @@
 namespace arch
 {
 struct ThreadAPI {
-    FORCE_INLINE_F void InitMem() {}
 };
 }  // namespace arch
 
diff --git a/kernel/src/hal/core.hpp b/kernel/src/hal/core.hpp
index c9b9c4d8..be79de5f 100644
--- a/kernel/src/hal/core.hpp
+++ b/kernel/src/hal/core.hpp
@@ -12,7 +12,16 @@ using arch::CoreLocal;
 
 NODISCARD WRAP_CALL u32 GetCurrentCoreId() { return arch::GetCurrentCoreId(); }
 WRAP_CALL void SetCoreLocalData(void *data) { arch::SetCoreLocalData(data); }
-NODISCARD WRAP_CALL void *GetCoreLocalData() { return arch::GetCoreLocalData(); }
+template <typename T, size_t kOffset>
+NODISCARD FAST_CALL T GetCoreLocalField()
+{
+    return arch::GetCoreLocalField<T, kOffset>();
+}
+template <typename T, size_t Offset>
+FAST_CALL void SetCoreLocalField(T value)
+{
+    arch::SetCoreLocalField<T, Offset>(value);
+}
 }  // namespace hal
 
 #endif  // KERNEL_SRC_HAL_CORE_HPP_
diff --git a/kernel/src/hal/interrupt_params.hpp b/kernel/src/hal/interrupt_params.hpp
index 48b020ca..42ea20cb 100644
--- a/kernel/src/hal/interrupt_params.hpp
+++ b/kernel/src/hal/interrupt_params.hpp
@@ -1,6 +1,7 @@
 #ifndef KERNEL_SRC_HAL_INTERRUPT_PARAMS_HPP_
 #define KERNEL_SRC_HAL_INTERRUPT_PARAMS_HPP_
 
+#include <defines.hpp>
 #include <hal/impl/interrupt_params.hpp>
 
 namespace hal
@@ -15,6 +16,11 @@ static constexpr size_t kNumSoftwareInterrupts = arch::kNumSoftwareInterrupts;
 static constexpr u16 kTimerHwLirq      = arch::kTimerHwLirq;
 static constexpr u16 kPageFaultExcLirq = arch::kPageFaultExcLirq;
 
+NODISCARD FAST_CALL bool IsInterruptFromUserSpace(const ExceptionData &data)
+{
+    return arch::IsInterruptFromUserSpace(data);
+}
+
 }  // namespace hal
 
 #endif  // KERNEL_SRC_HAL_INTERRUPT_PARAMS_HPP_
diff --git a/kernel/src/hal/panic.hpp b/kernel/src/hal/panic.hpp
index 1d899b4e..d0875801 100644
--- a/kernel/src/hal/panic.hpp
+++ b/kernel/src/hal/panic.hpp
@@ -18,14 +18,16 @@ namespace hal
  */
 WRAP_CALL void KernelPanic(const char *msg)
 {
-    HardwareModule::Get().GetInterrupts().BlockHardwareInterrupts();
-    HardwareModule::Get().GetCoresController().PanicAllCores();
+    if (HardwareModule::IsInited()) {
+        HardwareModule::Get().GetInterrupts().BlockHardwareInterrupts();
+        HardwareModule::Get().GetCoresController().PanicAllCores();
+    }
 
     // For some reason trace::DumpAllBuffersOnFailure() must be called before and after printing
-    trace::DumpAllBuffersOnFailure();
-    TRACE_FATAL_GENERAL("[ KERNEL PANIC ]");
-    TRACE_FATAL_GENERAL(msg);
-    TRACE_FATAL_GENERAL("\n");
+    // BYPASS TRACE FRAMEWORK AS this function is used inside of it
+    TerminalWriteString("[ KERNEL PANIC ]");
+    TerminalWriteString(msg);
+    TerminalWriteString("\n");
 
     arch::KernelPanic();
 }
diff --git a/kernel/src/hal/scheduling.hpp b/kernel/src/hal/scheduling.hpp
index b844a936..c6c98775 100644
--- a/kernel/src/hal/scheduling.hpp
+++ b/kernel/src/hal/scheduling.hpp
@@ -11,13 +11,9 @@ namespace hal
 WRAP_CALL void JumpToUserSpace(void (*f)()) { arch::JumpToUserSpace(f); }
 WRAP_CALL void ContextSwitch(Sched::Thread *thread) { arch::ContextSwitch(thread); }
 WRAP_CALL void ConvertContext(Sched::Thread *thread) { arch::ConvertContext(thread); }
-WRAP_CALL void InitializeStackKThread(void **stack, void (*f)())
+WRAP_CALL void InitializeThreadStack(void **stack, const Sched::Task &task)
 {
-    arch::InitializeStackKThread(stack, f);
-}
-WRAP_CALL void InitializeStackUserThread(void **stack, void (*f)())
-{
-    arch::InitializeStackUserThread(stack, f);
+    arch::InitializeThreadStack(stack, task);
 }
 }  // namespace hal
 
diff --git a/kernel/src/hardware/core_local.hpp b/kernel/src/hardware/core_local.hpp
index 8c8193c9..9e8a31d7 100644
--- a/kernel/src/hardware/core_local.hpp
+++ b/kernel/src/hardware/core_local.hpp
@@ -14,19 +14,25 @@ struct alignas(hal::kCacheLineSizeBytes) CoreLocal : hal::CoreLocal {
     Sched::Thread *thread_control_block;
 };
 
-FAST_CALL CoreLocal &GetCoreLocalData()
-{
-    return *static_cast<CoreLocal *>(hal::GetCoreLocalData());
-}
-
-NODISCARD FAST_CALL Sched::Thread *GetCurrentTCB()
-{
-    return GetCoreLocalData().thread_control_block;
-}
-
-FAST_CALL void SetCurrentTCB(Sched::Thread *tcb) { GetCoreLocalData().thread_control_block = tcb; }
-
-NODISCARD FAST_CALL Sched::Pid GetRunningPid() { return GetCurrentTCB()->owner; }
+#define PREPARE_CORE_LOCAL_ACCESS(name, rv, field)                       \
+    FAST_CALL void SetCoreLocal##name(rv value)                          \
+    {                                                                    \
+        hal::SetCoreLocalField<rv, offsetof(CoreLocal, field)>(value);   \
+    }                                                                    \
+    NODISCARD FAST_CALL rv GetCoreLocal##name()                          \
+    {                                                                    \
+        return hal::GetCoreLocalField<rv, offsetof(CoreLocal, field)>(); \
+    }
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Winvalid-offsetof"
+PREPARE_CORE_LOCAL_ACCESS(NestedInterrupts, u8, nested_interrupts);
+PREPARE_CORE_LOCAL_ACCESS(Lid, u16, lid);
+PREPARE_CORE_LOCAL_ACCESS(Tcb, Sched::Thread *, thread_control_block);
+PREPARE_CORE_LOCAL_ACCESS(Self, CoreLocal *, self);
+#pragma GCC diagnostic pop
+
+NODISCARD FAST_CALL Sched::Pid GetRunningPid() { return GetCoreLocalTcb()->owner; }
 
 }  // namespace hardware
 
diff --git a/kernel/src/interrupts/interrupt_types.hpp b/kernel/src/interrupts/interrupt_types.hpp
index 96f5f248..ce133eda 100644
--- a/kernel/src/interrupts/interrupt_types.hpp
+++ b/kernel/src/interrupts/interrupt_types.hpp
@@ -3,6 +3,7 @@
 
 #include <template_lib.hpp>
 #include "hal/interrupt_params.hpp"
+#include "scheduling/thread.hpp"
 
 namespace intr
 {
@@ -15,9 +16,9 @@ enum class InterruptType : uint8_t {
 template <InterruptType kInterruptType>
 struct InterruptHandlerEntry {
     /* Interrupt handler */
-    using InterruptHandler          = void *(*)(InterruptHandlerEntry & entry);
-    using InterruptHandlerException = void *(*)(InterruptHandlerEntry & entry,
-                                                hal::ExceptionData *data);
+    using InterruptHandler          = Sched::Thread *(*)(InterruptHandlerEntry & entry);
+    using InterruptHandlerException = Sched::Thread *(*)(InterruptHandlerEntry & entry,
+                                                         hal::ExceptionData *data);
     using HandlerType               = std::conditional_t<
                       kInterruptType == InterruptType::kException, InterruptHandlerException, InterruptHandler>;
 
diff --git a/kernel/src/interrupts/interrupts.cpp b/kernel/src/interrupts/interrupts.cpp
index 18ea3f8d..932bfad8 100644
--- a/kernel/src/interrupts/interrupts.cpp
+++ b/kernel/src/interrupts/interrupts.cpp
@@ -3,25 +3,25 @@
 // Assembly interface
 // ------------------------------
 
-extern "C" void *HandleException(const u16 lirq, hal::ExceptionData *data)
+extern "C" void *cdecl_HandleException(const u16 lirq, hal::ExceptionData *data)
 {
     return HardwareModule::Get().GetInterrupts().GetLit().HandleInterrupt(lirq, data);
 }
 
-extern "C" void *HandleHardwareInterrupt(const u16 lirq)
+extern "C" void *cdecl_HandleHardwareInterrupt(const u16 lirq, hal::ExceptionData *data)
 {
     return HardwareModule::Get()
         .GetInterrupts()
         .GetLit()
-        .HandleInterrupt<intr::InterruptType::kHardwareInterrupt>(lirq);
+        .HandleInterrupt<intr::InterruptType::kHardwareInterrupt>(lirq, data);
 }
 
-extern "C" void *HandleSoftwareInterrupt(const u16 lirq)
+extern "C" void *cdecl_HandleSoftwareInterrupt(const u16 lirq, hal::ExceptionData *data)
 {
     return HardwareModule::Get()
         .GetInterrupts()
         .GetLit()
-        .HandleInterrupt<intr::InterruptType::kSoftwareInterrupt>(lirq);
+        .HandleInterrupt<intr::InterruptType::kSoftwareInterrupt>(lirq, data);
 }
 
 // ------------------------------
diff --git a/kernel/src/interrupts/logical_interrupt_table.hpp b/kernel/src/interrupts/logical_interrupt_table.hpp
index 557ed2af..5f0bee4b 100644
--- a/kernel/src/interrupts/logical_interrupt_table.hpp
+++ b/kernel/src/interrupts/logical_interrupt_table.hpp
@@ -4,7 +4,9 @@
 #include <assert.h>
 #include <bit.hpp>
 #include <cstddef.hpp>
+#include <scheduling/threads.hpp>
 #include <type_traits.hpp>
+
 #include "hal/sync.hpp"
 #include "hardware/core_local.hpp"
 #include "interrupts/interrupt_types.hpp"
@@ -42,34 +44,38 @@ class LogicalInterruptTable
 
     FORCE_INLINE_F void *HandleInterrupt(const u16 lirq, hal::ExceptionData *data)
     {
-        hardware::GetCoreLocalData().nested_interrupts++;
+        hardware::SetCoreLocalNestedInterrupts(hardware::GetCoreLocalNestedInterrupts() + 1);
         hal::FullMemFence();
+        Sched::UpdateTcbOnInterruptEntry(data);
 
         ASSERT_LT(lirq, GetTableSize_<InterruptType::kException>());
         ASSERT_FALSE(IsUnmapped_<InterruptType::kException>(lirq));
         auto &entry = GetTable_<InterruptType::kException>()[lirq];
 
         /* Exception MUST be handled */
-        void *rv = (*entry.handler_data.handler)(entry, data);
+        Sched::Thread *rv = (*entry.handler_data.handler)(entry, data);
 
-        hardware::GetCoreLocalData().nested_interrupts--;
+        hardware::SetCoreLocalNestedInterrupts(hardware::GetCoreLocalNestedInterrupts() - 1);
         hal::FullMemFence();
 
+        Sched::UpdateTcbOnInterruptExit(rv);
+
         return rv;
     }
 
     template <InterruptType kInterruptType>
         requires(kInterruptType != InterruptType::kException)
-    FORCE_INLINE_F void *HandleInterrupt(const u16 lirq)
+    FORCE_INLINE_F void *HandleInterrupt(const u16 lirq, hal::ExceptionData *data)
     {
-        hardware::GetCoreLocalData().nested_interrupts++;
+        hardware::SetCoreLocalNestedInterrupts(hardware::GetCoreLocalNestedInterrupts() + 1);
         hal::FullMemFence();
+        Sched::UpdateTcbOnInterruptEntry(data);
 
         ASSERT_LT(lirq, GetTableSize_<kInterruptType>());
         ASSERT_FALSE(IsUnmapped_<kInterruptType>(lirq));
         auto &entry = GetTable_<kInterruptType>()[lirq];
 
-        void *rv = nullptr;
+        Sched::Thread *rv = nullptr;
         if (entry.handler_data.handler) {
             rv = (*entry.handler_data.handler)(entry);
         }
@@ -79,9 +85,10 @@ class LogicalInterruptTable
             entry.driver->cbs.ack(entry);
         }
 
-        hardware::GetCoreLocalData().nested_interrupts--;
+        hardware::SetCoreLocalNestedInterrupts(hardware::GetCoreLocalNestedInterrupts() - 1);
         hal::FullMemFence();
 
+        Sched::UpdateTcbOnInterruptExit(rv);
         return rv;
     }
 
diff --git a/kernel/src/io/pipe.hpp b/kernel/src/io/pipe.hpp
index b573aa40..84d9c5f3 100644
--- a/kernel/src/io/pipe.hpp
+++ b/kernel/src/io/pipe.hpp
@@ -2,7 +2,6 @@
 #define KERNEL_SRC_IO_PIPE_HPP_
 
 #include <data_structures/atomic_cyclic_buffer.hpp>
-#include <hal/spinlock.hpp>
 
 #include "io/stream.hpp"
 #include "macros.hpp"
diff --git a/kernel/src/kernel.cpp b/kernel/src/kernel.cpp
index fe615af9..dc778b73 100644
--- a/kernel/src/kernel.cpp
+++ b/kernel/src/kernel.cpp
@@ -39,7 +39,6 @@ static void KernelRun()
 extern "C" void KernelMain(const Mem::PPtr<hal::RawBootArguments> raw_args)
 {
     ASSERT_NOT_NULL(raw_args, "Raw boot arguments are null");
-    TRACE_INFO_GENERAL("Running kernel initialization...");
 
     KernelInit(*Mem::PhysToVirt(raw_args));
 
diff --git a/kernel/src/mem/virt/addr_space.hpp b/kernel/src/mem/virt/addr_space.hpp
index 15d3d9b0..5252882b 100644
--- a/kernel/src/mem/virt/addr_space.hpp
+++ b/kernel/src/mem/virt/addr_space.hpp
@@ -105,7 +105,7 @@ class AddressSpace
 
     // Friends
     friend class VirtualMemoryManager;
-    friend void *PageFaultHandler(intr::LitExcEntry &entry, hal::ExceptionData *data);
+    friend Sched::Thread *PageFaultHandler(intr::LitExcEntry &entry, hal::ExceptionData *data);
 
     public:
 };
diff --git a/kernel/src/mem/virt/page_fault.cpp b/kernel/src/mem/virt/page_fault.cpp
index c25bbd54..3aaea985 100644
--- a/kernel/src/mem/virt/page_fault.cpp
+++ b/kernel/src/mem/virt/page_fault.cpp
@@ -41,7 +41,7 @@ constexpr const char *InstructionFetchDescription(bool instruction_fetch)
 }
 }  // namespace
 
-void *PageFaultHandler(intr::LitExcEntry &, hal::ExceptionData *data)
+Sched::Thread *PageFaultHandler(intr::LitExcEntry &, hal::ExceptionData *data)
 {
     ASSERT_NOT_NULL(data);
 
diff --git a/kernel/src/mem/virt/page_fault.hpp b/kernel/src/mem/virt/page_fault.hpp
index 250ba368..a8e1b7ea 100644
--- a/kernel/src/mem/virt/page_fault.hpp
+++ b/kernel/src/mem/virt/page_fault.hpp
@@ -7,7 +7,7 @@
 namespace Mem
 {
 
-void *PageFaultHandler(intr::LitExcEntry &entry, hal::ExceptionData *data);
+Sched::Thread *PageFaultHandler(intr::LitExcEntry &entry, hal::ExceptionData *data);
 
 }  // namespace Mem
 
diff --git a/kernel/src/modules/hardware.cpp b/kernel/src/modules/hardware.cpp
index 21c20f2e..4cbbeacb 100644
--- a/kernel/src/modules/hardware.cpp
+++ b/kernel/src/modules/hardware.cpp
@@ -3,7 +3,7 @@
 
 #include "trace_framework.hpp"
 
-static void *Ps2KeyboardHandler(intr::LitHwEntry &)
+static Sched::Thread *Ps2KeyboardHandler(intr::LitHwEntry &)
 {
     HardwareModule::Get().GetPs2Keyboard().OnInterrupt();
     return nullptr;
diff --git a/kernel/src/scheduling/error.hpp b/kernel/src/scheduling/error.hpp
index e6b43dfd..bd146a54 100644
--- a/kernel/src/scheduling/error.hpp
+++ b/kernel/src/scheduling/error.hpp
@@ -12,6 +12,7 @@ enum class Error {
     ProcessNotFound,
     ThreadNotFound,
     ProcessNameTooLong,
+    ExecPathNotFound,
 };
 
 }  // namespace Sched
@@ -29,6 +30,8 @@ static constexpr const char *to_string(const Sched::Error &error)
             return "ThreadNotFound";
         case Sched::Error::ProcessNameTooLong:
             return "ProcessNameTooLong";
+        case Sched::Error::ExecPathNotFound:
+            return "ExecPathNotFound";
     }
 
     return "unknown error";
diff --git a/kernel/src/scheduling/kworker.cpp b/kernel/src/scheduling/kworker.cpp
index 6e11a2fd..607ee287 100644
--- a/kernel/src/scheduling/kworker.cpp
+++ b/kernel/src/scheduling/kworker.cpp
@@ -17,7 +17,7 @@ void Sched::KWorkerMain()
     TRACE_INFO_SCHEDULING("Created new KWorker!");
 
     while (true) {
-        static size_t kSpins = 1'000'000;
+        static size_t kSpins = 1'000;
         for (size_t i = 0; i < kSpins; i++) {
             hal::Noop();
             hal::Noop();
diff --git a/kernel/src/scheduling/process.hpp b/kernel/src/scheduling/process.hpp
index 7f1a26fa..071ee6b6 100644
--- a/kernel/src/scheduling/process.hpp
+++ b/kernel/src/scheduling/process.hpp
@@ -4,8 +4,10 @@
 #include <types.h>
 #include <defines.hpp>
 
-#include "fs/file_descriptor.hpp"
+#include "fs/costants.hpp"
+#include "fs/vfs/path.hpp"
 #include "hal/tasks.hpp"
+#include "io/pipe.hpp"
 #include "mem/types.hpp"
 
 namespace Mem
@@ -33,7 +35,7 @@ struct PACK ProcessFlags {
 static_assert(sizeof(ProcessFlags) == 1);
 
 struct Process : hal::Process {
-    static constexpr size_t kMaxNameLength = 128;
+    static constexpr size_t kMaxNameLength = vfs::kMaxComponentSize;
 
     /* Management */
     char name[kMaxNameLength];
diff --git a/kernel/src/scheduling/scheduler.cpp b/kernel/src/scheduling/scheduler.cpp
index 3165109d..a45954c8 100644
--- a/kernel/src/scheduling/scheduler.cpp
+++ b/kernel/src/scheduling/scheduler.cpp
@@ -35,7 +35,7 @@ Thread *Scheduler::Schedule()
     auto owner = SchedulingModule::Get().GetProcesses().GetProcess(thread->owner);
     ASSERT_TRUE(static_cast<bool>(owner));
 
-    if (thread == hardware::GetCurrentTCB()) {
+    if (thread == hardware::GetCoreLocalTcb()) {
         return nullptr;
     }
 
diff --git a/kernel/src/scheduling/task_mgr.cpp b/kernel/src/scheduling/task_mgr.cpp
index 29517030..d21cb23c 100644
--- a/kernel/src/scheduling/task_mgr.cpp
+++ b/kernel/src/scheduling/task_mgr.cpp
@@ -5,7 +5,6 @@
 #include "modules/scheduling.hpp"
 #include "modules/vfs.hpp"
 #include "scheduling/kworker.hpp"
-#include "sys/loader.hpp"
 #include "task_mgr.hpp"
 
 #include <hal/panic.hpp>
@@ -27,13 +26,19 @@ namespace Sched
 {
 void TaskMgr::InitializeMultitasking()
 {
+    // Spawn trace dumper
+    const auto result =
+        SpawnKernelProcess("kworker-trace-dumper", {}, PrepareKThreadTask(TraceDumperMain));
+    R_ASSERT_TRUE(static_cast<bool>(result), "Failed to spawn trace dumper process...");
+
     // Spawn 3 Kernel Workers
     static constexpr size_t kNumKWorkers = 3;
     for (size_t i = 0; i < kNumKWorkers; ++i) {
         char name[] = "kworker-0";
 
         name[sizeof(name) - 2] = static_cast<char>('0' + i);
-        auto result            = SpawnKernelProcess(name, {}, KWorkerMain);
+
+        auto result = SpawnKernelProcess(name, {}, PrepareKThreadTask(KWorkerMain));
         R_ASSERT_TRUE(
             static_cast<bool>(result),
             "Failed to spawn kernel workers. Not enough resources for the system"
@@ -43,10 +48,6 @@ void TaskMgr::InitializeMultitasking()
             "Created initial Kernel Worker process with Pid: %llu", result.value().get<0>()
         );
     }
-
-    // Spawn trace dumper
-    const auto result = SpawnKernelProcess("kworker-trace-dumper", {}, TraceDumperMain);
-    R_ASSERT_TRUE(static_cast<bool>(result), "Failed to spawn trace dumper process...");
 }
 
 std::expected<Pid, Error> TaskMgr::SpawnEmptyProcess(const char *name, const ProcessFlags flags)
@@ -95,19 +96,13 @@ std::expected<Pid, Error> TaskMgr::SpawnEmptyProcess(const char *name, const Pro
     return process.value()->pid;
 }
 
-std::expected<Thread *, Error> TaskMgr::SpawnThread(const Pid pid, void (*f)())
+std::expected<Thread *, Error> TaskMgr::SpawnThread(const Pid pid, const Task &task)
 {
     bool dismiss = false;
 
     const auto process = SchedulingModule::Get().GetProcesses().GetProcess(pid);
     ASSERT_TRUE(static_cast<bool>(process));
 
-    if (process.value()->flags.KernelSpaceOnly) {
-        ASSERT_TRUE(IsKernelSpace(reinterpret_cast<void *>(f)));
-    } else {
-        ASSERT_FALSE(IsKernelSpace(reinterpret_cast<void *>(f)));
-    }
-
     // 1. Prepare internal structure for execution unit - thread:
     auto thread = SchedulingModule::Get().GetThreads().PrepareThread();
     if (!thread) {
@@ -162,22 +157,16 @@ std::expected<Thread *, Error> TaskMgr::SpawnThread(const Pid pid, void (*f)())
         thread.value()->user_stack_bottom = nullptr;
     }
 
-    if (process.value()->flags.KernelSpaceOnly) {
-        hal::InitializeStackKThread(&thread.value()->kernel_stack, f);
-    } else {
-        hal::InitializeStackUserThread(&thread.value()->kernel_stack, f);
-    }
-
+    hal::InitializeThreadStack(&thread.value()->kernel_stack, task);
     dismiss = true;
     return thread.value();
 }
 
 std::expected<std::tuple<Pid, Tid>, Error> TaskMgr::SpawnKernelProcess(
-    const char *name, ProcessFlags flags, void (*f)()
+    const char *name, ProcessFlags flags, const Task &task
 )
 {
     flags.KernelSpaceOnly = true;
-    ASSERT_TRUE(IsKernelSpace(reinterpret_cast<void *>(f)));
 
     auto process = SpawnEmptyProcess(name, flags);
     if (!process) {
@@ -189,7 +178,7 @@ std::expected<std::tuple<Pid, Tid>, Error> TaskMgr::SpawnKernelProcess(
         ASSERT_TRUE(static_cast<bool>(result));
     });
 
-    const auto thread = SpawnThread(process.value(), f);
+    const auto thread = SpawnThread(process.value(), task);
     if (!thread) {
         return std::unexpected(thread.error());
     }
@@ -209,25 +198,14 @@ std::expected<std::tuple<Pid, Tid>, Error> TaskMgr::SpawnKernelProcess(
 
 std::expected<Pid, Error> TaskMgr::CloneProcess(Pid) { R_FAIL_ALWAYS("NOT IMPLEMENTED"); }
 
-std::expected<Tid, Error> TaskMgr::ExecuteElf64(Pid pid, const char *path)
+std::expected<Tid, Error> TaskMgr::ExecuteElf64(const Pid pid, const char *path)
 {
     auto process = SchedulingModule::Get().GetProcesses().GetProcess(pid);
     RET_UNEXPECTED_IF_ERR(process);
 
-    auto &as = process.value()->address_space;
-    ASSERT_NOT_NULL(as);
+    // TODO: KILL ALL EXISTING THREADS FROM THIS PROCESS
 
-    auto entry_res = System::ElfLoader::Load(vfs::Path(path), *as);
-    if (!entry_res) {
-        DEBUG_WARN_SCHEDULING(
-            "Failed to execute ELF64 for process %llu. Failed on ELF loading.", pid
-        );
-        return std::unexpected(Error::OutOfMemory);
-    }
-
-    const auto entry = reinterpret_cast<void (*)()>(entry_res.value());
-
-    auto thread = SpawnThread(pid, entry);
+    auto thread = SpawnThread(pid, PrepareElf64LoaderTask(pid, path));
     RET_UNEXPECTED_IF_ERR(thread);
 
     HardwareModule::Get().GetInterrupts().BlockHardwareInterrupts();
@@ -235,8 +213,8 @@ std::expected<Tid, Error> TaskMgr::ExecuteElf64(Pid pid, const char *path)
     HardwareModule::Get().GetInterrupts().EnableHardwareInterrupts();
 
     DEBUG_INFO_SCHEDULING(
-        "Created userspace process with pid: %llu, name: %s and initial thread with tid: %llu", pid,
-        process.value()->name, thread.value()->tid
+        "Created userspace process with pid: %llu and initial thread with tid: %llu", pid,
+        thread.value()->tid
     );
 
     return thread.value()->tid;
@@ -246,8 +224,12 @@ std::expected<std::tuple<Pid, Tid>, Error> TaskMgr::ExecuteElf64(
     const char *path, const ProcessFlags flags
 )
 {
-    trace::TraceDumperTask();
-    auto process = SpawnEmptyProcess(path, flags);
+    const auto exists_res = VfsModule::Get().FileExists(vfs::Path(path));
+    if (!exists_res.has_value() || !exists_res.value()) {
+        return std::unexpected(Error::ExecPathNotFound);
+    }
+
+    auto process = SpawnEmptyProcess(vfs::Path(path).GetFilename().data(), flags);
     RET_UNEXPECTED_IF_ERR(process);
 
     template_lib::ScopeGuard process_guard([&] {
@@ -261,7 +243,9 @@ std::expected<std::tuple<Pid, Tid>, Error> TaskMgr::ExecuteElf64(
     return std::make_tuple(process.value(), thread.value());
 }
 
-std::expected<void, Error> TaskMgr::KillProcess(Pid pid) { R_FAIL_ALWAYS("NOT IMPLEMENTED"); }
+std::expected<void, Error> TaskMgr::CommitMurder(Pid pid) { R_FAIL_ALWAYS("NOT IMPLEMENTED"); }
+
+void TaskMgr::CommitSuicide(Pid pid) { R_FAIL_ALWAYS("NOT IMPLEMENTED"); }
 
 std::expected<void, Error> TaskMgr::ExitProcess(Pid pid) { R_FAIL_ALWAYS("NOT IMPLEMENTED"); }
 
diff --git a/kernel/src/scheduling/task_mgr.hpp b/kernel/src/scheduling/task_mgr.hpp
index bb592ad9..a57dd612 100644
--- a/kernel/src/scheduling/task_mgr.hpp
+++ b/kernel/src/scheduling/task_mgr.hpp
@@ -26,10 +26,10 @@ class TaskMgr
 
     NODISCARD std::expected<Pid, Error> SpawnEmptyProcess(const char *name, ProcessFlags flags);
 
-    NODISCARD std::expected<Thread *, Error> SpawnThread(Pid pid, void (*f)());
+    NODISCARD std::expected<Thread *, Error> SpawnThread(Pid pid, const Task &task);
 
     NODISCARD std::expected<std::tuple<Pid, Tid>, Error> SpawnKernelProcess(
-        const char *name, ProcessFlags flags, void (*f)()
+        const char *name, ProcessFlags flags, const Task &task
     );
 
     NODISCARD std::expected<Pid, Error> CloneProcess(Pid pid);
@@ -40,7 +40,9 @@ class TaskMgr
         const char *path, ProcessFlags flags
     );
 
-    NODISCARD std::expected<void, Error> KillProcess(Pid pid);
+    NODISCARD std::expected<void, Error> CommitMurder(Pid pid);
+
+    void CommitSuicide(Pid pid);
 
     NODISCARD std::expected<void, Error> ExitProcess(Pid pid);
 
diff --git a/kernel/src/scheduling/thread.hpp b/kernel/src/scheduling/thread.hpp
index 19603296..84138705 100644
--- a/kernel/src/scheduling/thread.hpp
+++ b/kernel/src/scheduling/thread.hpp
@@ -2,6 +2,7 @@
 #define KERNEL_SRC_SCHEDULING_THREAD_HPP_
 
 #include <types.h>
+#include <array.hpp>
 #include <defines.hpp>
 
 #include "hal/tasks.hpp"
@@ -15,6 +16,14 @@ struct PACK Tid {
     u64 count : 48;
 };
 
+struct Task {
+    static constexpr size_t kMaxArgs = 6;
+
+    void *func;
+    std::array<u64, kMaxArgs> args;
+    size_t args_count;
+};
+
 struct Thread : hal::Thread {
     /* Management */
     Tid tid;
@@ -28,6 +37,11 @@ struct Thread : hal::Thread {
     void *kernel_stack_bottom;
     void *user_stack;
     void *user_stack_bottom;
+
+    /* Timing */
+    u64 kernel_time_ns;
+    u64 user_time_ns;
+    u64 timestamp;
 };
 }  // namespace Sched
 
diff --git a/kernel/src/scheduling/threads.cpp b/kernel/src/scheduling/threads.cpp
index 8a4e8ac9..c63fd720 100644
--- a/kernel/src/scheduling/threads.cpp
+++ b/kernel/src/scheduling/threads.cpp
@@ -3,8 +3,12 @@
 #include <hal/debug_terminal.hpp>
 #include <hal/scheduling.hpp>
 
+#include "fs/vfs/path.hpp"
+#include "hardware/core_local.hpp"
 #include "mem/virt/addr_space.hpp"
 #include "modules/scheduling.hpp"
+#include "modules/timing.hpp"
+#include "sys/loader.hpp"
 
 namespace Sched
 {
@@ -17,8 +21,6 @@ std::expected<Thread *, Error> Threads::PrepareThread()
     }
 
     Thread *thread = threads_.Get(idx);
-    thread->InitMem();
-
     ASSERT_LE(idx, std::numeric_limits<u16>::max());
     thread->tid = AssignNewTid(static_cast<u16>(idx));
 
@@ -31,17 +33,81 @@ void KThreadEntrypoint(void (*f)())
     OnKThreadExit();
 }
 
-void UserThreadEntrypoint(void (*f)())
+void OnKThreadExit()
 {
-    OnUserThreadEntry();
-    hal::JumpToUserSpace(f);
+    R_FAIL_ALWAYS("Not implemented. KThread should never return at this stage...");
 }
 
-void OnUserThreadEntry() {}
+void Elf64EntryPoint(const Pid pid, const char *path)
+{
+    const auto process = SchedulingModule::Get().GetProcesses().GetProcess(pid);
+    ASSERT_TRUE(static_cast<bool>(process));  // TODO: CAN IT BE MISSING HERE????
+
+    auto &as = process.value()->address_space;
+    ASSERT_NOT_NULL(as);
 
-void OnKThreadExit()
+    const auto entry_res = System::ElfLoader::Load(vfs::Path(path), *as);
+    if (!entry_res) {
+        DEBUG_WARN_SCHEDULING(
+            "Failed to execute ELF64 for process %llu. Failed on ELF loading.", pid
+        );
+        SchedulingModule::Get().GetTaskMgr().CommitSuicide(pid);
+    }
+
+    const auto entry = reinterpret_cast<void (*)()>(entry_res.value());
+    hal::JumpToUserSpace(entry);
+}
+
+void UpdateTcbOnInterruptEntry(hal::ExceptionData *data)
 {
-    R_FAIL_ALWAYS("Not implemented. KThread should never return at this stage...");
+    ASSERT_NOT_NULL(data);
+    const auto thread = hardware::GetCoreLocalTcb();
+
+    if (!thread) {
+        return;
+    }
+
+    const u64 t = TimingModule::Get().GetSystemTime().ReadLifeTimeNs();
+    if (hal::IsInterruptFromUserSpace(*data)) {
+        thread->user_time_ns += t - thread->timestamp;
+    } else {
+        thread->kernel_time_ns += t - thread->timestamp;
+    }
+
+    thread->timestamp = t;
+}
+
+void UpdateTcbOnInterruptExit(Thread *thread)
+{
+    const auto current_thread = hardware::GetCoreLocalTcb();
+
+    if (!current_thread) {
+        return;
+    }
+
+    const u64 t = TimingModule::Get().GetSystemTime().ReadLifeTimeNs();
+    current_thread->kernel_time_ns += t - current_thread->timestamp;
+    current_thread->timestamp = t;
+
+    if (thread) {
+        thread->timestamp = t;
+    }
 }
 
 }  // namespace Sched
+
+void cdecl_UpdateTcbOnSyscallEntry()
+{
+    const auto thread = hardware::GetCoreLocalTcb();
+    const u64 t       = TimingModule::Get().GetSystemTime().ReadLifeTimeNs();
+    thread->user_time_ns += t - thread->timestamp;
+    thread->timestamp = t;
+}
+
+void cdecl_UpdateTcbOnSyscallExit()
+{
+    const auto thread = hardware::GetCoreLocalTcb();
+    const u64 t       = TimingModule::Get().GetSystemTime().ReadLifeTimeNs();
+    thread->kernel_time_ns += t - thread->timestamp;
+    thread->timestamp = t;
+}
diff --git a/kernel/src/scheduling/threads.hpp b/kernel/src/scheduling/threads.hpp
index 788cf3c9..323e0b9a 100644
--- a/kernel/src/scheduling/threads.hpp
+++ b/kernel/src/scheduling/threads.hpp
@@ -4,6 +4,7 @@
 #include <data_structures/hash_maps.hpp>
 #include <defines.hpp>
 #include <expected.hpp>
+#include <hal/interrupt_params.hpp>
 #include <hal/sync.hpp>
 
 #include "constants.hpp"
@@ -75,10 +76,36 @@ class Threads
 };
 
 void KThreadEntrypoint(void (*f)());
-void UserThreadEntrypoint(void (*f)());
-void OnUserThreadEntry();
 void OnKThreadExit();
 
+void Elf64EntryPoint(Pid pid, const char *path);
+
+void UpdateTcbOnInterruptEntry(hal::ExceptionData *data);
+void UpdateTcbOnInterruptExit(Thread *thread);
+
+NODISCARD FAST_CALL Task PrepareKThreadTask(void (*f)())
+{
+    Task task{};
+    task.func       = reinterpret_cast<void *>(KThreadEntrypoint);
+    task.args_count = 1;
+    task.args       = {reinterpret_cast<u64>(f)};
+
+    return task;
+}
+
+NODISCARD FAST_CALL Task PrepareElf64LoaderTask(Pid pid, const char *path)
+{
+    Task task{};
+    task.func       = reinterpret_cast<void *>(Elf64EntryPoint);
+    task.args_count = 2;
+    task.args       = {*reinterpret_cast<u64 *>(&pid), reinterpret_cast<u64>(path)};
+
+    return task;
+}
+
 }  // namespace Sched
 
+extern "C" void cdecl_UpdateTcbOnSyscallEntry();
+extern "C" void cdecl_UpdateTcbOnSyscallExit();
+
 #endif  // KERNEL_SRC_SCHEDULING_THREADS_HPP_
diff --git a/kernel/src/sys/loader.cpp b/kernel/src/sys/loader.cpp
index d47a6a90..e7ecb5a5 100644
--- a/kernel/src/sys/loader.cpp
+++ b/kernel/src/sys/loader.cpp
@@ -40,7 +40,7 @@ bool ValidateElfHeader(const Elf::Header &header)
 }
 }  // namespace
 
-expected<Mem::VPtr<void>, LoadError> ElfLoader::Load(const vfs::Path &path, Mem::AddressSpace &as)
+expected<Mem::VPtr<void>, LoadError> ElfLoader::Load(const vfs::Path &path, AddressSpace &as)
 {
     TRACE_INFO_GENERAL("ElfLoader::Load()");
     auto &vfs = VfsModule::Get();
@@ -109,10 +109,6 @@ expected<Mem::VPtr<void>, LoadError> ElfLoader::Load(const vfs::Path &path, Mem:
         }
     });
 
-    // Switch Address Space to load data
-    auto &prev_as = MemoryModule::Get().GetVmm().GetCurrentAddressSpace();
-    MemoryModule::Get().GetVmm().SwitchAddrSpace(&as);
-
     // 5. Load Segments
     TRACE_FREQ_INFO_GENERAL("Validating the ELF header");
     for (u16 i = 0; i < header.phnum; ++i) {
@@ -185,9 +181,6 @@ expected<Mem::VPtr<void>, LoadError> ElfLoader::Load(const vfs::Path &path, Mem:
         }
     }
 
-    // Restore previous Address Space
-    MemoryModule::Get().GetVmm().SwitchAddrSpace(&prev_as);
-
     vma_cleanup_guard.dismiss();
     u64 entry_point = header.entry;
     return Mem::UptrToPtr<void>(entry_point);
diff --git a/kernel/src/time/event_framework.cpp b/kernel/src/time/event_framework.cpp
index 07c588a7..28d7bb39 100644
--- a/kernel/src/time/event_framework.cpp
+++ b/kernel/src/time/event_framework.cpp
@@ -6,7 +6,7 @@
 // statics
 // ------------------------------
 
-static void *TimerHandler(intr::LitHwEntry &)
+static Sched::Thread *TimerHandler(intr::LitHwEntry &)
 {
     return SchedulingModule::Get().GetScheduler().Schedule();
 }
diff --git a/kernel/src/trace.cpp b/kernel/src/trace.cpp
index a0154e97..8633cfd5 100644
--- a/kernel/src/trace.cpp
+++ b/kernel/src/trace.cpp
@@ -11,16 +11,6 @@
 
 using namespace trace;
 
-// ------------------------------
-// Helper static functions
-// ------------------------------
-
-FAST_CALL void HardenFullString(const char *str)
-{
-    TODO_BY_THE_END_OF_MILESTONE0
-    hal::TerminalWriteString(str);
-}
-
 // ------------------------------------
 // Trace framework implementation
 // ------------------------------------
@@ -58,7 +48,7 @@ static struct TraceFramework {
 
     struct SmallTraceCyclicBuffer {
         static constexpr size_t kSize      = FeatureValue<FeatureFlag::kTraceBufferSize>;
-        static constexpr size_t kBatchSize = 256;
+        static constexpr size_t kBatchSize = 512;
 
         hal::Atomic32 bytes_left{.value = kSize};
         hal::Atomic32 head{};
@@ -266,7 +256,7 @@ static struct TraceFramework {
         SmallTraceCyclicBuffer &buffer, const size_t trace_size
     )
     {
-        const u8 nested_intrs = hardware::GetCoreLocalData().nested_interrupts;
+        const u8 nested_intrs = hardware::GetCoreLocalNestedInterrupts();
         const char *src       = nested_intrs == 0 ? single_core_env.main_execution_workspace
                                                   : single_core_env.interrupt_workspace[nested_intrs - 1];
 
@@ -275,7 +265,7 @@ static struct TraceFramework {
 
     char *GetWorkspaceSingleCoreInterrupts()
     {
-        const u8 nested_intrs = hardware::GetCoreLocalData().nested_interrupts;
+        const u8 nested_intrs = hardware::GetCoreLocalNestedInterrupts();
 
         if (nested_intrs == 0) {
             return single_core_env.main_execution_workspace;
@@ -412,7 +402,7 @@ int WriteTraceData(char *dst, TraceModule module, const TraceType type)
     }
 
     Sched::Pid pid{};
-    if (hal::GetCoreLocalData() != nullptr && hardware::GetCurrentTCB() != nullptr) {
+    if (hardware::GetCoreLocalTcb() != nullptr) {
         pid = hardware::GetRunningPid();
     }
 
diff --git a/kernel/test/manual_tests.cpp b/kernel/test/manual_tests.cpp
index d014a96c..9ca6f0ae 100644
--- a/kernel/test/manual_tests.cpp
+++ b/kernel/test/manual_tests.cpp
@@ -28,7 +28,7 @@ static void Task0()
             hal::Noop();
         }
 
-        const auto tcb = hardware::GetCurrentTCB();
+        const auto tcb = hardware::GetCoreLocalTcb();
         HardwareModule::Get().GetInterrupts().BlockHardwareInterrupts();
         trace::DumpAllBuffersOnFailure();
         hal::ContextSwitch(tcb->next);
@@ -48,7 +48,7 @@ static void Task1()
             hal::Noop();
         }
 
-        const auto tcb = hardware::GetCurrentTCB();
+        const auto tcb = hardware::GetCoreLocalTcb();
 
         HardwareModule::Get().GetInterrupts().BlockHardwareInterrupts();
         trace::DumpAllBuffersOnFailure();
@@ -62,9 +62,13 @@ MTEST(KernelTaskSwitchTest)
     flags.KernelSpaceOnly = true;
     flags.PreserveFloats  = true;
 
-    auto p0 = SchedulingModule::Get().GetTaskMgr().SpawnKernelProcess("task0", flags, Task0);
+    auto p0 = SchedulingModule::Get().GetTaskMgr().SpawnKernelProcess(
+        "task0", flags, Sched::PrepareKThreadTask(Task0)
+    );
     ASSERT_TRUE(static_cast<bool>(p0));
-    auto p1 = SchedulingModule::Get().GetTaskMgr().SpawnKernelProcess("task1", flags, Task1);
+    auto p1 = SchedulingModule::Get().GetTaskMgr().SpawnKernelProcess(
+        "task1", flags, Sched::PrepareKThreadTask(Task1)
+    );
     ASSERT_TRUE(static_cast<bool>(p1));
 
     const auto tid0 = std::get<1>(p0.value());
diff --git a/libs/libcontainers/include/data_structures/hash_maps.hpp b/libs/libcontainers/include/data_structures/hash_maps.hpp
index 24c3caf7..1d40f310 100644
--- a/libs/libcontainers/include/data_structures/hash_maps.hpp
+++ b/libs/libcontainers/include/data_structures/hash_maps.hpp
@@ -399,7 +399,7 @@ class PooledHashMap
 
         auto mem = Mem::KMallocAligned({.size = sizeof(T), .alignment = alignof(T)});
         R_ASSERT_TRUE(static_cast<bool>(mem));
-        map_[idx] = static_cast<T *>(mem.value());
+        map_[idx] = new (mem.value()) T();
 
         return idx;
     }

From 6e7eecf6775a9c496b8a45437b4c78ce4894f071 Mon Sep 17 00:00:00 2001
From: Jakub Lisowski <115403674+Jlisowskyy@users.noreply.github.com>
Date: Fri, 2 Jan 2026 20:17:34 +0100
Subject: [PATCH 40/56] Jlisowskyy/scheduler imprv 1 (#263)

---
 kernel/arch/x86_64/src/include/thread.nasm    |  1 +
 .../arch/x86_64/src/scheduling/scheduling.cpp |  2 +-
 kernel/src/fs/file_descriptor.hpp             |  2 +-
 kernel/src/modules/timing_constants.hpp       |  2 +-
 kernel/src/scheduling/kworker.cpp             |  1 +
 kernel/src/scheduling/task_mgr.cpp            |  1 -
 kernel/src/scheduling/thread.hpp              |  7 +++
 kernel/src/syscalls/calls/proc.hpp            | 12 +++++
 kernel/src/syscalls/calls/thread.hpp          | 18 +++++++
 kernel/src/syscalls/calls/time.hpp            |  2 +-
 kernel/src/syscalls/dispatch_table.hpp        |  2 +-
 kernel/src/syscalls/syscalls.cpp              | 10 +++-
 kernel/src/syscalls/syscalls.hpp              |  2 +
 kernel/src/time/system_time.hpp               |  2 +-
 libs/libc/src/abi/platform.h                  | 49 +++++++++++--------
 libs/libc/src/include/alkos/calls.h           | 15 ++++++
 libs/libc/src/include/{sys => alkos}/fd.h     |  0
 libs/libc/src/include/alkos/proc.h            |  6 +++
 libs/libc/src/include/alkos/structs.h         |  9 ++++
 .../src/include/{sys/calls => alkos/sys}/fd.h |  2 +-
 libs/libc/src/include/alkos/sys/proc.h        | 19 +++++++
 libs/libc/src/include/alkos/sys/thread.h      | 28 +++++++++++
 .../include/{sys/calls => alkos/sys}/time.h   |  2 +-
 .../include/{sys/calls.h => alkos/syscall.h}  | 33 +++++++------
 libs/libc/src/include/alkos/thread.h          | 20 ++++++++
 libs/libc/src/include/{sys => alkos}/time.h   |  0
 libs/libc/src/include/stdio.h                 |  2 +-
 libs/libc/src/include/time.h                  |  8 +--
 libs/libc/src/internal/libc_backend.cpp       | 12 ++++-
 libs/libc/src/internal/stdio.cpp              |  2 +-
 libs/libc/src/time/localtime.cpp              |  2 +-
 libs/libc/src/time/mktime.cpp                 |  2 +-
 libs/libc/src/time/strftime.cpp               |  2 +-
 libs/libc/src/time/time.cpp                   |  4 +-
 libs/libcpp/include/time.hpp                  |  2 +-
 userspace/programs/hello_world/main.cpp       |  2 +-
 36 files changed, 225 insertions(+), 60 deletions(-)
 create mode 100644 kernel/src/syscalls/calls/proc.hpp
 create mode 100644 kernel/src/syscalls/calls/thread.hpp
 create mode 100644 libs/libc/src/include/alkos/calls.h
 rename libs/libc/src/include/{sys => alkos}/fd.h (100%)
 create mode 100644 libs/libc/src/include/alkos/proc.h
 create mode 100644 libs/libc/src/include/alkos/structs.h
 rename libs/libc/src/include/{sys/calls => alkos/sys}/fd.h (98%)
 create mode 100644 libs/libc/src/include/alkos/sys/proc.h
 create mode 100644 libs/libc/src/include/alkos/sys/thread.h
 rename libs/libc/src/include/{sys/calls => alkos/sys}/time.h (98%)
 rename libs/libc/src/include/{sys/calls.h => alkos/syscall.h} (65%)
 create mode 100644 libs/libc/src/include/alkos/thread.h
 rename libs/libc/src/include/{sys => alkos}/time.h (100%)

diff --git a/kernel/arch/x86_64/src/include/thread.nasm b/kernel/arch/x86_64/src/include/thread.nasm
index a71e69af..4e0ce435 100644
--- a/kernel/arch/x86_64/src/include/thread.nasm
+++ b/kernel/arch/x86_64/src/include/thread.nasm
@@ -8,6 +8,7 @@ struc Thread
     .gs_base       resq 1
     .tid:          resq 1
     .owner:        resq 1
+    .flags         resq 1
     .next:         resq 1
     .kernel_stack: resq 1
     .kernel_stack_bottom: resq 1
diff --git a/kernel/arch/x86_64/src/scheduling/scheduling.cpp b/kernel/arch/x86_64/src/scheduling/scheduling.cpp
index 02e20bad..f2735a17 100644
--- a/kernel/arch/x86_64/src/scheduling/scheduling.cpp
+++ b/kernel/arch/x86_64/src/scheduling/scheduling.cpp
@@ -120,7 +120,7 @@ extern "C" void cdecl_ConvertContextEntry(Sched::Thread *thread)
     LoadFpStateIfNeeded(thread);
     hardware::SetCoreLocalTcb(thread);
     SetTssRsp0(reinterpret_cast<u64>(thread->kernel_stack_bottom));
-    // thread->timestamp = TimingModule::Get().GetSystemTime().ReadLifeTimeNs();
+    thread->timestamp = TimingModule::Get().GetSystemTime().ReadLifeTimeNs();
     SwapAsIfNeeded(thread);
     SwapGsIfJumpingToUserspace(thread);
 }
diff --git a/kernel/src/fs/file_descriptor.hpp b/kernel/src/fs/file_descriptor.hpp
index 22e82f2f..1abf35f1 100644
--- a/kernel/src/fs/file_descriptor.hpp
+++ b/kernel/src/fs/file_descriptor.hpp
@@ -7,11 +7,11 @@
 #include <data_structures/tagged_pointer.hpp>
 #include <span.hpp>
 
+#include "alkos/sys/fd.h"
 #include "fs/costants.hpp"
 #include "hal/spinlock.hpp"
 #include "io/pipe.hpp"
 #include "io/stream.hpp"
-#include "sys/calls/fd.h"
 #include "vfs/types.hpp"
 
 namespace Fs
diff --git a/kernel/src/modules/timing_constants.hpp b/kernel/src/modules/timing_constants.hpp
index a3c75fc4..234a4989 100644
--- a/kernel/src/modules/timing_constants.hpp
+++ b/kernel/src/modules/timing_constants.hpp
@@ -1,7 +1,7 @@
 #ifndef KERNEL_SRC_MODULES_TIMING_CONSTANTS_HPP_
 #define KERNEL_SRC_MODULES_TIMING_CONSTANTS_HPP_
 
-#include <sys/time.h>
+#include <alkos/time.h>
 
 namespace timing_constants
 {
diff --git a/kernel/src/scheduling/kworker.cpp b/kernel/src/scheduling/kworker.cpp
index 607ee287..a6ae1d57 100644
--- a/kernel/src/scheduling/kworker.cpp
+++ b/kernel/src/scheduling/kworker.cpp
@@ -30,6 +30,7 @@ void Sched::KWorkerMain()
 void Sched::TraceDumperMain()
 {
     TRACE_INFO_SCHEDULING("Created new TraceDumper!");
+
     while (true) {
         trace::TraceDumperTask();
 
diff --git a/kernel/src/scheduling/task_mgr.cpp b/kernel/src/scheduling/task_mgr.cpp
index d21cb23c..8a31e7c6 100644
--- a/kernel/src/scheduling/task_mgr.cpp
+++ b/kernel/src/scheduling/task_mgr.cpp
@@ -8,7 +8,6 @@
 #include "task_mgr.hpp"
 
 #include <hal/panic.hpp>
-#include <sys/loader.hpp>
 
 #include "trace_framework.hpp"
 
diff --git a/kernel/src/scheduling/thread.hpp b/kernel/src/scheduling/thread.hpp
index 84138705..1a2b3fc4 100644
--- a/kernel/src/scheduling/thread.hpp
+++ b/kernel/src/scheduling/thread.hpp
@@ -16,6 +16,12 @@ struct PACK Tid {
     u64 count : 48;
 };
 
+struct PACK ThreadFlags {
+    bool PreserveFloats : 1;
+    u64 padding : 63;
+};
+static_assert(sizeof(ThreadFlags) == 8);
+
 struct Task {
     static constexpr size_t kMaxArgs = 6;
 
@@ -28,6 +34,7 @@ struct Thread : hal::Thread {
     /* Management */
     Tid tid;
     Pid owner;
+    ThreadFlags flags;
 
     /* Scheduler data */
     Thread *next;
diff --git a/kernel/src/syscalls/calls/proc.hpp b/kernel/src/syscalls/calls/proc.hpp
new file mode 100644
index 00000000..60f4f602
--- /dev/null
+++ b/kernel/src/syscalls/calls/proc.hpp
@@ -0,0 +1,12 @@
+#ifndef KERNEL_SRC_SYSCALLS_CALLS_PROC_HPP_
+#define KERNEL_SRC_SYSCALLS_CALLS_PROC_HPP_
+
+#include <defines.hpp>
+
+namespace Syscall
+{
+FAST_CALL void SysExit(int status) {}
+FAST_CALL void SysAbort() {}
+}  // namespace Syscall
+
+#endif  // KERNEL_SRC_SYSCALLS_CALLS_PROC_HPP_
diff --git a/kernel/src/syscalls/calls/thread.hpp b/kernel/src/syscalls/calls/thread.hpp
new file mode 100644
index 00000000..08979b31
--- /dev/null
+++ b/kernel/src/syscalls/calls/thread.hpp
@@ -0,0 +1,18 @@
+#ifndef KERNEL_SRC_SYSCALLS_CALLS_THREAD_HPP_
+#define KERNEL_SRC_SYSCALLS_CALLS_THREAD_HPP_
+
+#include <alkos/structs.h>
+#include <defines.hpp>
+
+namespace Syscall
+{
+FAST_CALL int SysThreadCreate(Thread *thread, thread_func_t f, void *arg) { return 0; }
+
+FAST_CALL int SysThreadJoin(Thread *thread) { return 0; }
+
+FAST_CALL int SysThreadDetach(Thread *thread) { return 0; }
+
+FAST_CALL void SysThreadExit(void *retval) {}
+}  // namespace Syscall
+
+#endif  // KERNEL_SRC_SYSCALLS_CALLS_THREAD_HPP_
diff --git a/kernel/src/syscalls/calls/time.hpp b/kernel/src/syscalls/calls/time.hpp
index 347fc832..45e98353 100644
--- a/kernel/src/syscalls/calls/time.hpp
+++ b/kernel/src/syscalls/calls/time.hpp
@@ -1,8 +1,8 @@
 #ifndef KERNEL_SRC_SYSCALLS_CALLS_TIME_HPP_
 #define KERNEL_SRC_SYSCALLS_CALLS_TIME_HPP_
 
+#include <alkos/time.h>
 #include <defines.h>
-#include <sys/time.h>
 #include <types.h>
 
 #include "modules/timing.hpp"
diff --git a/kernel/src/syscalls/dispatch_table.hpp b/kernel/src/syscalls/dispatch_table.hpp
index b440ac36..a6e41d7a 100644
--- a/kernel/src/syscalls/dispatch_table.hpp
+++ b/kernel/src/syscalls/dispatch_table.hpp
@@ -1,7 +1,7 @@
 #ifndef KERNEL_SRC_SYSCALLS_DISPATCH_TABLE_HPP_
 #define KERNEL_SRC_SYSCALLS_DISPATCH_TABLE_HPP_
 
-#include <sys/calls.h>
+#include <alkos/calls.h>
 #include <defines.hpp>
 
 #include "hal/types.hpp"
diff --git a/kernel/src/syscalls/syscalls.cpp b/kernel/src/syscalls/syscalls.cpp
index c2ae2f30..b4efbe65 100644
--- a/kernel/src/syscalls/syscalls.cpp
+++ b/kernel/src/syscalls/syscalls.cpp
@@ -1,7 +1,7 @@
 #include "syscalls.hpp"
 #include "dispatch_table.hpp"
 
-#include <sys/calls.h>
+#include <alkos/syscall.h>
 
 using namespace Syscall;
 
@@ -31,6 +31,14 @@ constinit auto g_syscall_dispatch_table = SyscallDispatchTable<kSysMax>::Create<
     table.RegisterHandler<kSysWrite, SysWrite>();
     table.RegisterHandler<kSysSeek, SysSeek>();
 
+    /* Thread, processes */
+    table.RegisterHandler<kProcAbort, SysAbort>();
+    table.RegisterHandler<kProcExit, SysExit>();
+    table.RegisterHandler<kThreadCreate, SysThreadCreate>();
+    table.RegisterHandler<kThreadExit, SysThreadExit>();
+    table.RegisterHandler<kThreadJoin, SysThreadJoin>();
+    table.RegisterHandler<kThreadDetach, SysThreadDetach>();
+
     return table;
 }>();
 
diff --git a/kernel/src/syscalls/syscalls.hpp b/kernel/src/syscalls/syscalls.hpp
index 35087a7d..2d975ef8 100644
--- a/kernel/src/syscalls/syscalls.hpp
+++ b/kernel/src/syscalls/syscalls.hpp
@@ -10,6 +10,8 @@
 #include "calls/fd.hpp"
 #include "calls/io.hpp"
 #include "calls/panic.hpp"
+#include "calls/proc.hpp"
+#include "calls/thread.hpp"
 #include "calls/time.hpp"
 
 #endif  // KERNEL_SRC_SYSCALLS_SYSCALLS_HPP_
diff --git a/kernel/src/time/system_time.hpp b/kernel/src/time/system_time.hpp
index 20a62fc9..ac5fb5c5 100644
--- a/kernel/src/time/system_time.hpp
+++ b/kernel/src/time/system_time.hpp
@@ -1,7 +1,7 @@
 #ifndef KERNEL_SRC_TIME_SYSTEM_TIME_HPP_
 #define KERNEL_SRC_TIME_SYSTEM_TIME_HPP_
 
-#include <sys/time.h>
+#include <alkos/time.h>
 #include <time.h>
 #include <time.hpp>
 
diff --git a/libs/libc/src/abi/platform.h b/libs/libc/src/abi/platform.h
index ff0afaeb..36044637 100644
--- a/libs/libc/src/abi/platform.h
+++ b/libs/libc/src/abi/platform.h
@@ -2,32 +2,39 @@
 #define LIBS_LIBC_SRC_ABI_PLATFORM_H_
 
 #include "defines.h"
-#include "sys/time.h"
 #include "types.h"
 
-#include <sys/fd.h>
+#include "alkos/structs.h"
+#include "alkos/syscall.h"
 
 BEGIN_DECL_C
 
-// Panic
-NO_RET void __platform_panic(const char *msg);
-
-// Time Related
-void __platform_get_clock_value(ClockType type, TimeVal *time, Timezone *time_zone);
-u64 __platform_get_clock_ticks_in_second(ClockType type);
-void __platform_get_timezone(Timezone *time_zone);
-
-// Debug IO
-void __platform_debug_write(const char *buffer);
-size_t __platform_debug_read_line(char *buffer, size_t buffer_size);
-void __platform_write_console(const char *buffer);
-
-// File Descriptor Related
-int __platform_open(const char *pathname, int flags);
-int __platform_close(int fd);
-ssize_t __platform_read(int fd, void *buf, size_t count);
-ssize_t __platform_write(int fd, const void *buf, size_t count);
-ssize_t __platform_seek(int fd, ssize_t offset, FdSeek whence);
+SYSCALL_VOID_NAME(
+    get_clock_value, kSysGetClockValue, const ClockType, type, TimeVal *, time, Timezone *,
+    time_zone
+);
+SYSCALL_NAME(get_clock_ticks_in_second, kSysGetClockTicksInSecond, u64, const ClockType, type);
+SYSCALL_VOID_NAME(get_timezone, kSysGetTimezone, Timezone *, time_zone);
+
+SYSCALL_VOID_NAME(debug_write, kSysDebugWrite, const char *, buffer);
+SYSCALL_NAME(debug_read_line, kSysDebugReadLine, size_t, char *, buff, size_t, size);
+SYSCALL_VOID_NAME(write_console, kSysWriteConsole, const char *, buffer);
+
+SYSCALL_VOID_NAME(panic, kSysPanic, const char *, msg);
+
+SYSCALL_NAME(open, kSysOpen, int, const char *, pathname, int, flags);
+SYSCALL_NAME(close, kSysClose, int, fd_t, fd);
+SYSCALL_NAME(read, kSysRead, ssize_t, fd_t, fd, void *, buf, size_t, count);
+SYSCALL_NAME(write, kSysWrite, ssize_t, fd_t, fd, const void *, buf, size_t, count);
+SYSCALL_NAME(seek, kSysSeek, ssize_t, fd_t, fd, ssize_t, offset, FdSeek, whence);
+
+/* Thread, processes */
+SYSCALL_NAME(thread_create, kThreadCreate, int, Thread *, thread, thread_func_t, f, void *, arg);
+SYSCALL_VOID_NAME(thread_exit, kThreadExit, void *, retval);
+SYSCALL_NAME(thread_join, kThreadJoin, int, Thread *, thread);
+SYSCALL_NAME(thread_detach, kThreadDetach, int, Thread *, thread);
+SYSCALL_VOID_NAME(proc_exit, kProcExit, int, status);
+SYSCALL_VOID_NAME(proc_abort, kProcAbort);
 
 END_DECL_C
 
diff --git a/libs/libc/src/include/alkos/calls.h b/libs/libc/src/include/alkos/calls.h
new file mode 100644
index 00000000..ccf006f0
--- /dev/null
+++ b/libs/libc/src/include/alkos/calls.h
@@ -0,0 +1,15 @@
+#ifndef LIBS_LIBC_SRC_INCLUDE_ALKOS_CALLS_H_
+#define LIBS_LIBC_SRC_INCLUDE_ALKOS_CALLS_H_
+
+/**
+ * @brief This file collects all the system calls that are used by the libc.
+ *
+ * Calls should be specified in other header files and then included here.
+ */
+
+#include <alkos/sys/fd.h>
+#include <alkos/sys/proc.h>
+#include <alkos/sys/thread.h>
+#include <alkos/sys/time.h>
+
+#endif  // LIBS_LIBC_SRC_INCLUDE_ALKOS_CALLS_H_
diff --git a/libs/libc/src/include/sys/fd.h b/libs/libc/src/include/alkos/fd.h
similarity index 100%
rename from libs/libc/src/include/sys/fd.h
rename to libs/libc/src/include/alkos/fd.h
diff --git a/libs/libc/src/include/alkos/proc.h b/libs/libc/src/include/alkos/proc.h
new file mode 100644
index 00000000..8555645f
--- /dev/null
+++ b/libs/libc/src/include/alkos/proc.h
@@ -0,0 +1,6 @@
+#ifndef LIBS_LIBC_SRC_INCLUDE_SYS_PROC_H_
+#define LIBS_LIBC_SRC_INCLUDE_SYS_PROC_H_
+
+#include "thread.h"
+
+#endif  // LIBS_LIBC_SRC_INCLUDE_SYS_PROC_H_
diff --git a/libs/libc/src/include/alkos/structs.h b/libs/libc/src/include/alkos/structs.h
new file mode 100644
index 00000000..adbad9de
--- /dev/null
+++ b/libs/libc/src/include/alkos/structs.h
@@ -0,0 +1,9 @@
+#ifndef LIBS_LIBC_SRC_INCLUDE_SYS_ALKOS_STRUCTS_H_
+#define LIBS_LIBC_SRC_INCLUDE_SYS_ALKOS_STRUCTS_H_
+
+#include "alkos/thread.h"
+#include "alkos/proc.h"
+#include "alkos/fd.h"
+#include "alkos/time.h"
+
+#endif  // LIBS_LIBC_SRC_INCLUDE_SYS_ALKOS_STRUCTS_H_
diff --git a/libs/libc/src/include/sys/calls/fd.h b/libs/libc/src/include/alkos/sys/fd.h
similarity index 98%
rename from libs/libc/src/include/sys/calls/fd.h
rename to libs/libc/src/include/alkos/sys/fd.h
index 972030d6..d6c8a289 100644
--- a/libs/libc/src/include/sys/calls/fd.h
+++ b/libs/libc/src/include/alkos/sys/fd.h
@@ -3,7 +3,7 @@
 
 #include "defines.h"
 #include "platform.h"
-#include "sys/fd.h"
+#include "alkos/fd.h"
 #include "types.h"
 
 BEGIN_DECL_C
diff --git a/libs/libc/src/include/alkos/sys/proc.h b/libs/libc/src/include/alkos/sys/proc.h
new file mode 100644
index 00000000..97266beb
--- /dev/null
+++ b/libs/libc/src/include/alkos/sys/proc.h
@@ -0,0 +1,19 @@
+#ifndef LIBS_LIBC_SRC_INCLUDE_ALKOS_SYS_PROC_H_
+#define LIBS_LIBC_SRC_INCLUDE_ALKOS_SYS_PROC_H_
+
+#include "defines.h"
+#include "platform.h"
+
+// ------------------------------
+// System calls
+// ------------------------------
+
+BEGIN_DECL_C
+
+FAST_CALL void Exit(int status) { __platform_proc_exit(status); }
+
+FAST_CALL void Abort() { __platform_proc_abort(); }
+
+END_DECL_C
+
+#endif  // LIBS_LIBC_SRC_INCLUDE_ALKOS_SYS_PROC_H_
diff --git a/libs/libc/src/include/alkos/sys/thread.h b/libs/libc/src/include/alkos/sys/thread.h
new file mode 100644
index 00000000..10eb045b
--- /dev/null
+++ b/libs/libc/src/include/alkos/sys/thread.h
@@ -0,0 +1,28 @@
+#ifndef LIBS_LIBC_SRC_INCLUDE_ALKOS_SYS_THREAD_H_
+#define LIBS_LIBC_SRC_INCLUDE_ALKOS_SYS_THREAD_H_
+
+#include "alkos/thread.h"
+#include "defines.h"
+#include "platform.h"
+
+// ------------------------------
+// System calls
+// ------------------------------
+
+BEGIN_DECL_C
+
+FAST_CALL int ThreadCreate(Thread *thread, ThreadFlags flags, thread_func_t f, void *arg)
+{
+    thread->flags = flags;
+    return __platform_thread_create(thread, f, arg);
+}
+
+FAST_CALL int ThreadJoin(Thread *thread) { return __platform_thread_join(thread); }
+
+FAST_CALL int ThreadDetach(Thread *thread) { return __platform_thread_detach(thread); }
+
+FAST_CALL void ThreadExit(void *retval) { __platform_thread_exit(retval); }
+
+END_DECL_C
+
+#endif  // LIBS_LIBC_SRC_INCLUDE_ALKOS_SYS_THREAD_H_
diff --git a/libs/libc/src/include/sys/calls/time.h b/libs/libc/src/include/alkos/sys/time.h
similarity index 98%
rename from libs/libc/src/include/sys/calls/time.h
rename to libs/libc/src/include/alkos/sys/time.h
index 20b7d5a6..830203ee 100644
--- a/libs/libc/src/include/sys/calls/time.h
+++ b/libs/libc/src/include/alkos/sys/time.h
@@ -3,7 +3,7 @@
 
 #include "defines.h"
 #include "platform.h"
-#include "sys/time.h"
+#include "alkos/time.h"
 
 // ------------------------------
 // System calls
diff --git a/libs/libc/src/include/sys/calls.h b/libs/libc/src/include/alkos/syscall.h
similarity index 65%
rename from libs/libc/src/include/sys/calls.h
rename to libs/libc/src/include/alkos/syscall.h
index bc5aca5b..e169fcbd 100644
--- a/libs/libc/src/include/sys/calls.h
+++ b/libs/libc/src/include/alkos/syscall.h
@@ -1,8 +1,8 @@
-#ifndef LIBS_LIBC_SRC_INCLUDE_SYS_CALLS_H_
-#define LIBS_LIBC_SRC_INCLUDE_SYS_CALLS_H_
+#ifndef LIBS_LIBC_SRC_INCLUDE_ALKOS_SYSCALL_H_
+#define LIBS_LIBC_SRC_INCLUDE_ALKOS_SYSCALL_H_
 
+#include <syscall.h>
 #include "macro.hpp"
-#include "syscall.h"
 
 /**
  * @brief Syscall numbers
@@ -30,27 +30,32 @@ enum SyscallNumber {
     kSysWrite,
     kSysSeek,
 
+    /* Threads, processes */
+    kThreadCreate,
+    kThreadExit,
+    kThreadJoin,
+    kThreadDetach,
+    kProcExit,
+    kProcAbort,
+
     kSysMax,
 };
 
+#define SYSCALL_NAME(name, num, ret_type, ...) \
+    ret_type __platform_##name(FOR_EACH_PAIR(MERGE, __VA_ARGS__))
+
+#define SYSCALL_VOID_NAME(name, num, ...) void __platform_##name(FOR_EACH_PAIR(MERGE, __VA_ARGS__))
+
 #define DEFINE_SYSCALL(name, num, ret_type, ...)                                             \
-    ret_type __platform_##name(FOR_EACH_PAIR(MERGE, __VA_ARGS__))                            \
+    SYSCALL_NAME(name, num, ret_type __VA_OPT__(, ) __VA_ARGS__)                             \
     {                                                                                        \
         return (ret_type)_SYSCALL_DISPATCH(num, FOR_EACH_PAIR(GET_SECOND_ARG, __VA_ARGS__)); \
     }
 
 #define DEFINE_SYSCALL_VOID(name, num, ...)                                       \
-    void __platform_##name(FOR_EACH_PAIR(MERGE, __VA_ARGS__))                     \
+    SYSCALL_VOID_NAME(name, num __VA_OPT__(, ) __VA_ARGS__)                       \
     {                                                                             \
         (void)_SYSCALL_DISPATCH(num, FOR_EACH_PAIR(GET_SECOND_ARG, __VA_ARGS__)); \
     }
 
-/**
- * @brief This file collects all the system calls that are used by the libc.
- *
- * Calls should be specified in other header files and then included here.
- */
-
-#include <sys/calls/time.h>
-
-#endif  // LIBS_LIBC_SRC_INCLUDE_SYS_CALLS_H_
+#endif  // LIBS_LIBC_SRC_INCLUDE_ALKOS_SYSCALL_H_
diff --git a/libs/libc/src/include/alkos/thread.h b/libs/libc/src/include/alkos/thread.h
new file mode 100644
index 00000000..9dc09491
--- /dev/null
+++ b/libs/libc/src/include/alkos/thread.h
@@ -0,0 +1,20 @@
+#ifndef LIBS_LIBC_SRC_INCLUDE_SYS_THREAD_H_
+#define LIBS_LIBC_SRC_INCLUDE_SYS_THREAD_H_
+
+#include <defines.h>
+#include <stdbool.h>
+#include <types.h>
+
+typedef void (*thread_func_t)(void *);
+
+typedef struct PACK {
+    bool PreserveFloats : 1;
+    u32 padding : 31;
+} ThreadFlags;
+
+typedef struct {
+    u64 tid;
+    ThreadFlags flags;
+} Thread;
+
+#endif  // LIBS_LIBC_SRC_INCLUDE_SYS_THREAD_H_
diff --git a/libs/libc/src/include/sys/time.h b/libs/libc/src/include/alkos/time.h
similarity index 100%
rename from libs/libc/src/include/sys/time.h
rename to libs/libc/src/include/alkos/time.h
diff --git a/libs/libc/src/include/stdio.h b/libs/libc/src/include/stdio.h
index 48bfecbb..a959b9ef 100644
--- a/libs/libc/src/include/stdio.h
+++ b/libs/libc/src/include/stdio.h
@@ -1,11 +1,11 @@
 #ifndef LIBS_LIBC_SRC_INCLUDE_STDIO_H_
 #define LIBS_LIBC_SRC_INCLUDE_STDIO_H_
 
+#include "alkos/sys/fd.h"
 #include "defines.h"
 #include "stdarg.h"
 #include "stdbool.h"
 #include "stddef.h"
-#include "sys/calls/fd.h"
 
 #define BUFSIZ 4096
 
diff --git a/libs/libc/src/include/time.h b/libs/libc/src/include/time.h
index 342603a0..9aca2fb6 100644
--- a/libs/libc/src/include/time.h
+++ b/libs/libc/src/include/time.h
@@ -1,10 +1,10 @@
-#ifndef LIBS_LIBC_INCLUDE_TIME_H_
-#define LIBS_LIBC_INCLUDE_TIME_H_
+#ifndef LIBS_LIBC_SRC_INCLUDE_TIME_H_
+#define LIBS_LIBC_SRC_INCLUDE_TIME_H_
 
 /* external includes */
+#include <alkos/time.h>
 #include <errno.h>
 #include <stddef.h>
-#include <sys/time.h>
 #include <types.h>
 
 // ------------------------------
@@ -94,4 +94,4 @@ time_t mktime(struct tm *time_ptr);
 
 END_DECL_C
 
-#endif  // LIBS_LIBC_INCLUDE_TIME_H_
+#endif  // LIBS_LIBC_SRC_INCLUDE_TIME_H_
diff --git a/libs/libc/src/internal/libc_backend.cpp b/libs/libc/src/internal/libc_backend.cpp
index 91fad943..cd6ec8e1 100644
--- a/libs/libc/src/internal/libc_backend.cpp
+++ b/libs/libc/src/internal/libc_backend.cpp
@@ -1,8 +1,8 @@
 #ifndef __ALKOS_KERNEL__
 
+#include "alkos/calls.h"
+#include "alkos/structs.h"
 #include "platform.h"
-#include "sys/calls.h"
-#include "sys/fd.h"
 
 DEFINE_SYSCALL_VOID(
     get_clock_value, kSysGetClockValue, const ClockType, type, TimeVal *, time, Timezone *,
@@ -23,4 +23,12 @@ DEFINE_SYSCALL(read, kSysRead, ssize_t, fd_t, fd, void *, buf, size_t, count)
 DEFINE_SYSCALL(write, kSysWrite, ssize_t, fd_t, fd, const void *, buf, size_t, count)
 DEFINE_SYSCALL(seek, kSysSeek, ssize_t, fd_t, fd, ssize_t, offset, FdSeek, whence)
 
+/* Thread, processes */
+DEFINE_SYSCALL(thread_create, kThreadCreate, int, Thread *, thread, thread_func_t, f, void *, arg)
+DEFINE_SYSCALL_VOID(thread_exit, kThreadExit, void *, retval)
+DEFINE_SYSCALL(thread_join, kThreadJoin, int, Thread *, thread)
+DEFINE_SYSCALL(thread_detach, kThreadDetach, int, Thread *, thread)
+DEFINE_SYSCALL_VOID(proc_exit, kProcExit, int, status)
+DEFINE_SYSCALL_VOID(proc_abort, kProcAbort)
+
 #endif  // __ALKOS_KERNEL__
diff --git a/libs/libc/src/internal/stdio.cpp b/libs/libc/src/internal/stdio.cpp
index fc7fd24f..157fee0c 100644
--- a/libs/libc/src/internal/stdio.cpp
+++ b/libs/libc/src/internal/stdio.cpp
@@ -1,7 +1,7 @@
 #include "stdio.hpp"
+#include "alkos/sys/fd.h"
 #include "stdio.h"
 #include "string.h"
-#include "sys/calls/fd.h"
 
 // Static fixed buffers for standard streams
 static byte _stdin_buffer[BUFSIZ];
diff --git a/libs/libc/src/time/localtime.cpp b/libs/libc/src/time/localtime.cpp
index c9526482..af8c7204 100644
--- a/libs/libc/src/time/localtime.cpp
+++ b/libs/libc/src/time/localtime.cpp
@@ -1,4 +1,4 @@
-#include <sys/calls.h>
+#include <alkos/calls.h>
 #include <time.h>
 #include <time.hpp>
 // ------------------------------
diff --git a/libs/libc/src/time/mktime.cpp b/libs/libc/src/time/mktime.cpp
index 57928e4d..c5e7d251 100644
--- a/libs/libc/src/time/mktime.cpp
+++ b/libs/libc/src/time/mktime.cpp
@@ -1,4 +1,4 @@
-#include <sys/calls.h>
+#include <alkos/calls.h>
 #include <time.h>
 #include <time.hpp>
 
diff --git a/libs/libc/src/time/strftime.cpp b/libs/libc/src/time/strftime.cpp
index 6f179fab..80a80c50 100644
--- a/libs/libc/src/time/strftime.cpp
+++ b/libs/libc/src/time/strftime.cpp
@@ -1,7 +1,7 @@
 #include <assert.h>
 #include <time.h>
 
-#include <sys/calls.h>
+#include <alkos/calls.h>
 
 #include <internal/formats.hpp>
 #include <time.hpp>
diff --git a/libs/libc/src/time/time.cpp b/libs/libc/src/time/time.cpp
index 80ac7792..fd77f926 100644
--- a/libs/libc/src/time/time.cpp
+++ b/libs/libc/src/time/time.cpp
@@ -2,8 +2,8 @@
 #include <assert.h>
 #include <time.h>
 
-#include <sys/calls.h>
-#include <sys/time.h>
+#include <alkos/calls.h>
+#include <alkos/time.h>
 
 static constexpr u64 kNSecInSec = 1'000'000'000;
 
diff --git a/libs/libcpp/include/time.hpp b/libs/libcpp/include/time.hpp
index 7b8370c5..6d42fd0a 100644
--- a/libs/libcpp/include/time.hpp
+++ b/libs/libcpp/include/time.hpp
@@ -1,9 +1,9 @@
 #ifndef LIBS_LIBCPP_INCLUDE_TIME_HPP_
 #define LIBS_LIBCPP_INCLUDE_TIME_HPP_
 
+#include <alkos/time.h>
 #include <assert.h>
 #include <stdint.h>
-#include <sys/time.h>
 #include <time.h>
 #include <types.h>
 #include <defines.hpp>
diff --git a/userspace/programs/hello_world/main.cpp b/userspace/programs/hello_world/main.cpp
index 69934102..8cc0e175 100644
--- a/userspace/programs/hello_world/main.cpp
+++ b/userspace/programs/hello_world/main.cpp
@@ -1,6 +1,6 @@
+#include <alkos/calls.h>
 #include <platform.h>
 #include <stdio.h>
-#include <sys/calls.h>
 
 template <typename... Args>
 void printf(const char *format, Args... args)

From 6dc093f7b6049cd3804c0a6e23487859b40699c1 Mon Sep 17 00:00:00 2001
From: Adam Ogieniewski <ogieniewski.dev@gmail.com>
Date: Sat, 3 Jan 2026 11:02:57 +0100
Subject: [PATCH 41/56] Standard C I/O support (#265)

Refactors the file descriptor management system to use `RefPtr` for
resource tracking. Implements `sys_dup` and `sys_dup2` syscalls,
along with `crt0` startup code and a `stdio` library for userspace.
Also adds a `stdout-tracer` kernel worker to monitor process output.
---
 kernel/arch/x86_64/boot/lib/debug_trace.hpp   |   1 -
 kernel/arch/x86_64/src/cpu/utils.hpp          |   2 -
 kernel/arch/x86_64/src/hal/impl/spinlock.hpp  |   3 -
 kernel/arch/x86_64/src/include/regs.nasm      |  24 -
 kernel/src/fs/file_descriptor.cpp             | 233 +++-----
 kernel/src/fs/file_descriptor.hpp             | 200 ++++---
 kernel/src/fs/vfs/error.hpp                   |   6 +-
 kernel/src/fs/vfs/fat/fat12.hpp               |   6 +-
 kernel/src/fs/vfs/fat/fat16.hpp               |   6 +-
 kernel/src/fs/vfs/fat/fat32.hpp               |   6 +-
 kernel/src/fs/vfs/interface.hpp               |   6 +-
 kernel/src/fs/vfs/io/in_memory.hpp            |   6 +-
 kernel/src/fs/vfs/path.hpp                    |   6 +-
 kernel/src/fs/vfs/types.hpp                   |   6 +-
 kernel/src/hal/api/spinlock.hpp               |   2 +
 kernel/src/kernel.cpp                         |  33 +-
 kernel/src/libc_backend.cpp                   |  52 +-
 kernel/src/mem/cyclic_allocator.hpp           |   2 +-
 kernel/src/mem/phys/mngr/buddy.hpp            |   2 +-
 kernel/src/mem/phys/mngr/slab.hpp             |   2 +-
 kernel/src/mem/virt/addr_space.hpp            |   2 +-
 kernel/src/modules/global_state.hpp           |   2 +-
 kernel/src/scheduling/kworker.cpp             |  31 ++
 kernel/src/scheduling/kworker.hpp             |   3 +
 kernel/src/scheduling/process.hpp             |   4 +-
 kernel/src/scheduling/processes.cpp           |  72 +--
 kernel/src/sync/{kernel => }/spinlock.hpp     |   9 +-
 kernel/src/syscalls/calls/fd.hpp              |  42 +-
 kernel/src/syscalls/dispatch_table.hpp        |   7 +-
 kernel/src/syscalls/handler.hpp               |  32 +-
 kernel/src/syscalls/syscalls.cpp              |   2 +
 kernel/test/cxx_mutex.cpp                     |   2 +-
 kernel/test/spinlock.cpp                      |   3 +-
 libs/libc/CMakeLists.txt                      |   1 +
 libs/libc/src/abi/platform.h                  |   2 +
 libs/libc/src/include/alkos/fd.h              |   6 +-
 libs/libc/src/include/alkos/proc.h            |   6 +-
 libs/libc/src/include/alkos/structs.h         |  10 +-
 libs/libc/src/include/alkos/sys/fd.h          |  35 +-
 libs/libc/src/include/alkos/sys/time.h        |   8 +-
 libs/libc/src/include/alkos/syscall.h         |   2 +
 libs/libc/src/include/alkos/thread.h          |   6 +-
 libs/libc/src/include/alkos/time.h            |   6 +-
 libs/libc/src/include/assert.h                |   6 +-
 libs/libc/src/include/defines.h               |  12 +-
 libs/libc/src/include/errno.h                 |   6 +-
 libs/libc/src/include/libssp.h                |   6 +-
 libs/libc/src/include/math/checks.h           |   6 +-
 libs/libc/src/include/math/operations.hpp     |   6 +-
 libs/libc/src/include/stdio.h                 |  58 +-
 libs/libc/src/include/stdlib.h                |   6 +-
 libs/libc/src/include/string.h                |   6 +-
 libs/libc/src/include/todo.h                  |   7 +-
 libs/libc/src/internal/crt0.cpp               |  31 ++
 libs/libc/src/internal/debug.hpp              |   6 +-
 libs/libc/src/internal/entry.hpp              |  27 -
 libs/libc/src/internal/libc_backend.cpp       |   5 +-
 libs/libc/src/internal/macro.hpp              |  22 +-
 libs/libc/src/internal/stdio.cpp              | 124 +++--
 libs/libc/src/internal/stdio.hpp              |  82 ++-
 libs/libc/src/internal/time_internal.hpp      |   6 +-
 libs/libc/src/io/stdio.cpp                    | 496 ++++++++++++++++++
 .../include/data_structures/ref_count.hpp     |   2 -
 libs/libcpp/include/concepts_ext.hpp          |   1 +
 toolchains/x86_64-conf.cmake                  |   2 +
 userspace/CMakeLists.txt                      |  35 +-
 userspace/build/linker.ld                     |  12 +
 userspace/programs/hello_world/main.cpp       |  67 +--
 68 files changed, 1261 insertions(+), 673 deletions(-)
 rename kernel/src/sync/{kernel => }/spinlock.hpp (53%)
 create mode 100644 libs/libc/src/internal/crt0.cpp
 delete mode 100644 libs/libc/src/internal/entry.hpp
 create mode 100644 libs/libc/src/io/stdio.cpp

diff --git a/kernel/arch/x86_64/boot/lib/debug_trace.hpp b/kernel/arch/x86_64/boot/lib/debug_trace.hpp
index de2a1fc6..6e8dd5ab 100644
--- a/kernel/arch/x86_64/boot/lib/debug_trace.hpp
+++ b/kernel/arch/x86_64/boot/lib/debug_trace.hpp
@@ -2,7 +2,6 @@
 #define KERNEL_ARCH_X86_64_BOOT_LIB_DEBUG_TRACE_HPP_
 
 #include <autogen/feature_flags.h>
-#include <todo.hpp>
 
 #include "platform.h"
 
diff --git a/kernel/arch/x86_64/src/cpu/utils.hpp b/kernel/arch/x86_64/src/cpu/utils.hpp
index 51641361..0876f984 100644
--- a/kernel/arch/x86_64/src/cpu/utils.hpp
+++ b/kernel/arch/x86_64/src/cpu/utils.hpp
@@ -3,11 +3,9 @@
 
 #include <types.h>
 #include <bits_ext.hpp>
-#include <defines.hpp>
 #include <template/rolled_switch.hpp>
 
 #include "array.hpp"
-#include "include/io.hpp"
 
 /**
  * @file arch_utils.hpp
diff --git a/kernel/arch/x86_64/src/hal/impl/spinlock.hpp b/kernel/arch/x86_64/src/hal/impl/spinlock.hpp
index a410e4a7..1d061b94 100644
--- a/kernel/arch/x86_64/src/hal/impl/spinlock.hpp
+++ b/kernel/arch/x86_64/src/hal/impl/spinlock.hpp
@@ -33,9 +33,6 @@ class alignas(kCacheLineSizeBytes) Spinlock : public SpinlockAPI
     // ABI implementations
     // ------------------------------
 
-    FORCE_INLINE_F void lock() { Lock(); }
-    FORCE_INLINE_F void unlock() { Unlock(); }
-
     FORCE_INLINE_F void Lock()
     {
         if constexpr (FeatureEnabled<FeatureFlag::kDebugSpinlock>) {
diff --git a/kernel/arch/x86_64/src/include/regs.nasm b/kernel/arch/x86_64/src/include/regs.nasm
index 9b015279..a0fca28a 100644
--- a/kernel/arch/x86_64/src/include/regs.nasm
+++ b/kernel/arch/x86_64/src/include/regs.nasm
@@ -36,18 +36,6 @@ _sysv_reg_size equ 8*10
     mov qword [rsp + _rbp], rbp
 %endmacro
 
-%macro push_sysv_regs_without_rax 0
-    mov qword [rsp + _rcx], rcx
-    mov qword [rsp + _rdx], rdx
-    mov qword [rsp + _rsi], rsi
-    mov qword [rsp + _rdi], rdi
-    mov qword [rsp + _r8], r8
-    mov qword [rsp + _r9], r9
-    mov qword [rsp + _r10], r10
-    mov qword [rsp + _r11], r11
-    mov qword [rsp + _rbp], rbp
-%endmacro
-
 ; Macro to restore all volatile registers (SysV ABI) from the stack.
 %macro pop_sysv_regs 0
     mov rax, qword [rsp + _rax]
@@ -62,18 +50,6 @@ _sysv_reg_size equ 8*10
     mov rbp, qword [rsp + _rbp]
 %endmacro
 
-%macro pop_sysv_regs_without_rax 0
-    mov rcx, qword [rsp + _rcx]
-    mov rdx, qword [rsp + _rdx]
-    mov rsi, qword [rsp + _rsi]
-    mov rdi, qword [rsp + _rdi]
-    mov r8, qword [rsp + _r8]
-    mov r9, qword [rsp + _r9]
-    mov r10, qword [rsp + _r10]
-    mov r11, qword [rsp + _r11]
-    mov rbp, qword [rsp + _rbp]
-%endmacro
-
 ; Size needed to save the registers on the stack
 _all_reg_size equ 8*15
 
diff --git a/kernel/src/fs/file_descriptor.cpp b/kernel/src/fs/file_descriptor.cpp
index 5e018b9f..7d416aeb 100644
--- a/kernel/src/fs/file_descriptor.cpp
+++ b/kernel/src/fs/file_descriptor.cpp
@@ -1,10 +1,9 @@
 #include "file_descriptor.hpp"
-#include "modules/scheduling.hpp"
-
-#include <mutex.hpp>
-#include <vfs.hpp>
 
+#include "modules/scheduling.hpp"
+#include "mutex.hpp"
 #include "scheduling/processes.hpp"
+#include "vfs.hpp"
 
 namespace
 {
@@ -20,17 +19,17 @@ namespace Fs
 // FdTable Implementation
 // ============================================================================
 
-FdResult<fd_t> FdTable::AllocateFd(OpenFileEntry *global_entry)
+FdResult<fd_t> FdTable::Allocate(data_structures::RefPtr<OpenFileEntry> global_entry)
 {
-    ASSERT_NOT_NULL(global_entry);
+    ASSERT_NOT_NULL(global_entry.Get());
 
     std::lock_guard lock(lock_);
 
     for (size_t i = 0; i < kMaxFdsPerProcess; ++i) {
         if (entries_[i] == nullptr) {
-            entries_[i] = global_entry;
-            global_entry->AddRef();
-            open_count_++;
+            entries_[i] = std::move(global_entry);
+            ++count_;
+
             return static_cast<fd_t>(i);
         }
     }
@@ -38,9 +37,9 @@ FdResult<fd_t> FdTable::AllocateFd(OpenFileEntry *global_entry)
     return std::unexpected(FdError::kFdTableFull);
 }
 
-FdResult<fd_t> FdTable::AllocateFdAt(OpenFileEntry *global_entry, fd_t fd)
+FdResult<fd_t> FdTable::AllocateAt(data_structures::RefPtr<OpenFileEntry> global_entry, fd_t fd)
 {
-    ASSERT_NOT_NULL(global_entry);
+    ASSERT_NOT_NULL(global_entry.Get());
 
     RET_UNEXPECTED_IF(!IsValidFd(fd), FdError::kInvalidFd);
 
@@ -48,14 +47,13 @@ FdResult<fd_t> FdTable::AllocateFdAt(OpenFileEntry *global_entry, fd_t fd)
 
     RET_UNEXPECTED_IF(entries_[fd] != nullptr, FdError::kBadFileDescriptor);
 
-    entries_[fd] = global_entry;
-    global_entry->AddRef();
-    open_count_++;
+    entries_[fd] = std::move(global_entry);
+    ++count_;
 
     return fd;
 }
 
-FdResult<> FdTable::FreeFd(fd_t fd)
+FdResult<> FdTable::Free(fd_t fd)
 {
     RET_UNEXPECTED_IF(!IsValidFd(fd), FdError::kInvalidFd);
 
@@ -67,26 +65,26 @@ FdResult<> FdTable::FreeFd(fd_t fd)
 
     RET_UNEXPECTED_IF(entries_[fd] == nullptr, FdError::kNotOpen);
 
-    entries_[fd] = nullptr;
-    open_count_--;
+    entries_[fd].Reset();
+    --count_;
 
     return {};
 }
 
-OpenFileEntry *FdTable::GetEntry(fd_t fd)
+OpenFileEntry *FdTable::Get(fd_t fd)
 {
     if (!IsValidFd(fd)) {
         return nullptr;
     }
-    return entries_[fd];
+    return entries_[fd].Get();
 }
 
-const OpenFileEntry *FdTable::GetEntry(fd_t fd) const
+const OpenFileEntry *FdTable::Get(fd_t fd) const
 {
     if (!IsValidFd(fd)) {
         return nullptr;
     }
-    return entries_[fd];
+    return entries_[fd].Get();
 }
 
 FdResult<fd_t> FdTable::DuplicateFd(fd_t fd)
@@ -100,8 +98,7 @@ FdResult<fd_t> FdTable::DuplicateFd(fd_t fd)
     for (size_t i = 0; i < kMaxFdsPerProcess; ++i) {
         if (entries_[i] == nullptr) {
             entries_[i] = entries_[fd];
-            entries_[i]->AddRef();
-            open_count_++;
+            ++count_;
 
             return static_cast<fd_t>(i);
         }
@@ -121,13 +118,11 @@ FdResult<fd_t> FdTable::DuplicateFdTo(fd_t old_fd, fd_t new_fd)
 
     // If new_fd is already open, close it first
     if (entries_[new_fd] != nullptr) {
-        entries_[new_fd] = nullptr;
-        open_count_--;
+        entries_[new_fd].Reset();
     }
 
     entries_[new_fd] = entries_[old_fd];
-    entries_[new_fd]->AddRef();
-    open_count_++;
+    ++count_;
 
     return new_fd;
 }
@@ -136,62 +131,37 @@ FdResult<fd_t> FdTable::DuplicateFdTo(fd_t old_fd, fd_t new_fd)
 // FileTable Implementation
 // ============================================================================
 
-FdResult<File *> FileTable::GetOrCreate(const vfs::Path &path)
+File::~File()
 {
-    RET_UNEXPECTED_IF(path.IsEmpty(), FdError::kInvalidArgument);
+    auto &ft = ::VfsModule::Get().GetFdManager().GetFileTable();
+    ft.files_.Free(pool_idx_);
+    --ft.count_;
+}
 
-    std::lock_guard lock(lock_);
+FdResult<data_structures::RefPtr<File>> FileTable::GetOrCreate(const vfs::Path &path)
+{
+    RET_UNEXPECTED_IF(path.IsEmpty(), FdError::kInvalidArgument);
 
     File *existing = Find(path);
     if (existing != nullptr) {
-        return existing;
+        return data_structures::RefPtr(existing, false);
     }
 
-    size_t idx = files_.Allocate();
+    const size_t idx = files_.Allocate();
     RET_UNEXPECTED_IF(idx == std::numeric_limits<size_t>::max(), FdError::kIoError);
 
     File *file = files_.Get(idx);
     ASSERT_NOT_NULL(file);
 
     new (file) File();
+    file->pool_idx_ = idx;
 
-    // TODO: Get from VFS when implemented
     file->size = 0;
     file->mode = 0;
     file->path = path;
+    ++count_;
 
-    count_++;
-    return file;
-}
-
-FdResult<> FileTable::Release(File *file)
-{
-    if (file == nullptr) {
-        return std::unexpected(FdError::kInvalidArgument);
-    }
-
-    std::lock_guard lock(lock_);
-
-    if (!file->HasRefs()) {
-        return std::unexpected(FdError::kNotOpen);
-    }
-
-    u32 old_count = file->GetRefCount();
-    file->Release();
-
-    if (old_count == 1) {
-        for (size_t i = 0; i < kMaxActiveFiles; ++i) {
-            if (files_.Get(i) == file) {
-                file->~File();
-                files_.Free(i);
-                count_--;
-                return {};
-            }
-        }
-        return std::unexpected(FdError::kInvalidArgument);
-    }
-
-    return {};
+    return data_structures::RefPtr(file);
 }
 
 File *FileTable::Find(const vfs::Path &path)
@@ -205,37 +175,20 @@ File *FileTable::Find(const vfs::Path &path)
     return nullptr;
 }
 
-const File *FileTable::Find(const vfs::Path &path) const
-{
-    for (size_t i = 0; i < kMaxActiveFiles; ++i) {
-        const File *file = files_.Get(i);
-        if (file != nullptr && file->HasRefs() && file->path == path) {
-            return file;
-        }
-    }
-    return nullptr;
-}
 // ============================================================================
 // OpenFileTable Implementation
 // ============================================================================
 
-OpenFileTable::OpenFileTable() : open_count_(0) {}
-
-OpenFileTable::~OpenFileTable()
+OpenFileEntry::~OpenFileEntry()
 {
-    std::lock_guard lock(lock_);
-
-    for (size_t i = 0; i < kMaxOpenFiles; ++i) {
-        OpenFileEntry *entry = entries_.Get(i);
-        if (entry != nullptr && entry->HasRefs()) {
-            entry->handle = {};
-            entry->~OpenFileEntry();
-            entries_.Free(i);
-        }
-    }
+    auto &oft = ::VfsModule::Get().GetFdManager().GetOpenFileTable();
+    oft.entries_.Free(pool_idx_);
+    --oft.count_;
 }
 
-FdResult<OpenFileEntry *> OpenFileTable::OpenFile(File *file, OpenMode flags)
+OpenFileTable::~OpenFileTable() { FAIL_ALWAYS("Should never be called"); }
+
+FdResult<data_structures::RefPtr<OpenFileEntry>> OpenFileTable::OpenFile(File *file, OpenMode flags)
 {
     if (file == nullptr) {
         return std::unexpected(FdError::kInvalidArgument);
@@ -243,7 +196,7 @@ FdResult<OpenFileEntry *> OpenFileTable::OpenFile(File *file, OpenMode flags)
 
     std::lock_guard lock(lock_);
 
-    size_t idx = entries_.Allocate();
+    const size_t idx = entries_.Allocate();
     if (idx == std::numeric_limits<size_t>::max()) {
         return std::unexpected(FdError::kIoError);
     }
@@ -252,21 +205,24 @@ FdResult<OpenFileEntry *> OpenFileTable::OpenFile(File *file, OpenMode flags)
     ASSERT_NOT_NULL(entry);
 
     new (entry) OpenFileEntry();
+    entry->pool_idx_ = idx;
 
     entry->handle    = FileHandle::Wrap(file);
     entry->flags     = static_cast<u32>(flags);
     entry->offset    = 0;
     entry->is_append = HasMode(flags, OpenMode::kAppend);
+    ++count_;
 
-    open_count_++;
-    return entry;
+    return data_structures::RefPtr(entry);
 }
 
-FdResult<OpenFileEntry *> OpenFileTable::OpenPipe(IO::Pipe<kStdioBufferSize> &pipe)
+FdResult<data_structures::RefPtr<OpenFileEntry>> OpenFileTable::OpenPipe(
+    IO::Pipe<kStdioBufferSize> &pipe
+)
 {
     std::lock_guard lock(lock_);
 
-    size_t idx = entries_.Allocate();
+    const size_t idx = entries_.Allocate();
     if (idx == std::numeric_limits<size_t>::max()) {
         return std::unexpected(FdError::kIoError);
     }
@@ -275,46 +231,15 @@ FdResult<OpenFileEntry *> OpenFileTable::OpenPipe(IO::Pipe<kStdioBufferSize> &pi
     ASSERT_NOT_NULL(entry);
 
     new (entry) OpenFileEntry();
+    entry->pool_idx_ = idx;
 
     entry->handle    = FileHandle::Wrap(&pipe);
     entry->flags     = static_cast<u32>(OpenMode::kReadWrite);
     entry->offset    = 0;
     entry->is_append = false;
+    ++count_;
 
-    open_count_++;
-    return entry;
-}
-
-FdResult<> OpenFileTable::CloseFile(OpenFileEntry *entry)
-{
-    if (entry == nullptr) {
-        return std::unexpected(FdError::kInvalidArgument);
-    }
-
-    std::lock_guard lock(lock_);
-
-    if (!entry->HasRefs()) {
-        return std::unexpected(FdError::kAlreadyClosed);
-    }
-
-    u32 old_count = entry->GetRefCount();
-    entry->Release();
-
-    if (old_count == 1) {
-        entry->handle = {};
-
-        for (size_t i = 0; i < kMaxOpenFiles; ++i) {
-            if (entries_.Get(i) == entry) {
-                entry->~OpenFileEntry();
-                entries_.Free(i);
-                open_count_--;
-                return {};
-            }
-        }
-        return std::unexpected(FdError::kInvalidArgument);
-    }
-
-    return {};
+    return data_structures::RefPtr(entry);
 }
 
 FdResult<u64> OpenFileTable::GetOffset(const OpenFileEntry *entry) const
@@ -344,31 +269,23 @@ FdResult<> OpenFileTable::SetOffset(OpenFileEntry *entry, u64 offset) const
 // FdManager Implementation
 // ============================================================================
 
-FdManager::FdManager() = default;
-
-FdManager::~FdManager() = default;
-
 FdResult<fd_t> FdManager::Open(const vfs::Path &path, OpenMode flags)
 {
     auto file_result = file_table_.GetOrCreate(path);
     RET_UNEXPECTED_IF_ERR(file_result);
-    File *file = *file_result;
 
-    auto open_result = open_file_table_.OpenFile(file, flags);
+    auto open_result = open_file_table_.OpenFile(file_result->Get(), flags);
     if (!open_result) {
         return std::unexpected(open_result.error());
     }
-    OpenFileEntry *global_entry = *open_result;
 
     FdTable *fd_table = GetCurrentProcessFdTable();
     if (fd_table == nullptr) {
-        open_file_table_.CloseFile(global_entry);
         return std::unexpected(FdError::kIoError);
     }
 
-    auto fd_result = fd_table->AllocateFd(global_entry);
+    auto fd_result = fd_table->Allocate(std::move(*open_result));
     if (!fd_result) {
-        open_file_table_.CloseFile(global_entry);
         return std::unexpected(fd_result.error());
     }
 
@@ -380,13 +297,7 @@ FdResult<> FdManager::Close(fd_t fd)
     FdTable *fd_table = GetCurrentProcessFdTable();
     RET_UNEXPECTED_IF(fd_table == nullptr, FdError::kIoError);
 
-    OpenFileEntry *entry = fd_table->GetEntry(fd);
-    RET_UNEXPECTED_IF(!entry, FdError::kBadFileDescriptor);
-
-    auto close_result = open_file_table_.CloseFile(entry);
-    RET_UNEXPECTED_IF(!close_result, close_result.error());
-
-    auto free_result = fd_table->FreeFd(fd);
+    auto free_result = fd_table->Free(fd);
     RET_UNEXPECTED_IF(!free_result, free_result.error());
 
     return {};
@@ -399,7 +310,7 @@ FdResult<size_t> FdManager::Read(fd_t fd, std::span<byte> buffer)
     FdTable *fd_table = GetCurrentProcessFdTable();
     ASSERT_NOT_NULL(fd_table);
 
-    OpenFileEntry *entry = fd_table->GetEntry(fd);
+    OpenFileEntry *entry = fd_table->Get(fd);
     RET_UNEXPECTED_IF(!entry, FdError::kBadFileDescriptor);
 
     OpenMode mode = static_cast<OpenMode>(entry->flags);
@@ -433,7 +344,7 @@ FdResult<size_t> FdManager::Write(fd_t fd, std::span<const byte> buffer)
     FdTable *fd_table = GetCurrentProcessFdTable();
     ASSERT_NOT_NULL(fd_table);
 
-    OpenFileEntry *entry = fd_table->GetEntry(fd);
+    OpenFileEntry *entry = fd_table->Get(fd);
     RET_UNEXPECTED_IF(!entry, FdError::kBadFileDescriptor);
 
     OpenMode mode = static_cast<OpenMode>(entry->flags);
@@ -469,7 +380,7 @@ FdResult<ssize_t> FdManager::Seek(fd_t fd, ssize_t offset, FdSeek whence)
     FdTable *fd_table = GetCurrentProcessFdTable();
     ASSERT_NOT_NULL(fd_table);
 
-    OpenFileEntry *entry = fd_table->GetEntry(fd);
+    OpenFileEntry *entry = fd_table->Get(fd);
     RET_UNEXPECTED_IF(!entry, FdError::kBadFileDescriptor);
 
     RET_UNEXPECTED_IF(!entry->IsFile(), FdError::kInvalidArgument);
@@ -500,17 +411,29 @@ FdResult<ssize_t> FdManager::Seek(fd_t fd, ssize_t offset, FdSeek whence)
     return new_offset;
 }
 
-FdTable *FdManager::GetCurrentProcessFdTable()
+FdResult<fd_t> FdManager::Duplicate(fd_t fd)
 {
-    auto process = SchedulingModule::Get().GetProcesses().GetCurrentProcess();
-    if (!process) {
-        return nullptr;
-    }
+    FdTable *fd_table = GetCurrentProcessFdTable();
+    RET_UNEXPECTED_IF(fd_table == nullptr, FdError::kIoError);
 
-    return process.value()->fd_table;
+    auto dup_result = fd_table->DuplicateFd(fd);
+    RET_UNEXPECTED_IF(!dup_result, dup_result.error());
+
+    return *dup_result;
 }
 
-const FdTable *FdManager::GetCurrentProcessFdTable() const
+FdResult<fd_t> FdManager::Duplicate(fd_t old_fd, fd_t new_fd)
+{
+    FdTable *fd_table = GetCurrentProcessFdTable();
+    RET_UNEXPECTED_IF(fd_table == nullptr, FdError::kIoError);
+
+    auto dup_result = fd_table->DuplicateFdTo(old_fd, new_fd);
+    RET_UNEXPECTED_IF(!dup_result, dup_result.error());
+
+    return *dup_result;
+}
+
+FdTable *FdManager::GetCurrentProcessFdTable()
 {
     auto process = SchedulingModule::Get().GetProcesses().GetCurrentProcess();
     if (!process) {
diff --git a/kernel/src/fs/file_descriptor.hpp b/kernel/src/fs/file_descriptor.hpp
index 1abf35f1..ca58f7ba 100644
--- a/kernel/src/fs/file_descriptor.hpp
+++ b/kernel/src/fs/file_descriptor.hpp
@@ -9,9 +9,9 @@
 
 #include "alkos/sys/fd.h"
 #include "fs/costants.hpp"
-#include "hal/spinlock.hpp"
 #include "io/pipe.hpp"
 #include "io/stream.hpp"
+#include "sync/spinlock.hpp"
 #include "vfs/types.hpp"
 
 namespace Fs
@@ -29,7 +29,7 @@ class FileTable;
 // ------------------------------
 
 enum class FdError {
-    kInvalidFd,
+    kInvalidFd = 1,
     kFdTableFull,
     kBadFileDescriptor,
     kNotOpen,
@@ -89,6 +89,14 @@ enum class FdSeek : u8 {
     kEnd = 2   // Seek from end of file
 };
 
+// ------------------------------
+// Standard File Descriptors
+// -----------------------------
+
+inline constexpr fd_t kStdinFd  = kFdStdIn;
+inline constexpr fd_t kStdoutFd = kFdStdOut;
+inline constexpr fd_t kStderrFd = kFdStdErr;
+
 // ------------------------------
 // File Structure
 // -----------------------------
@@ -99,21 +107,55 @@ enum class FdSeek : u8 {
  */
 class File : public data_structures::RefCounted<File>
 {
+    friend class FileTable;
+
     public:
     u64 size{0};
     u32 mode{0};
     vfs::Path path;
 
-    File()  = default;
-    ~File() = default;
+    File() = default;
+    ~File();
+
+    private:
+    size_t pool_idx_{std::numeric_limits<size_t>::max()};
 };
 
 // ------------------------------
-// File Handle (File or Pipe)
+// Global File Table
 // -----------------------------
 
 /**
- * @brief Tagged union holding either a File or Pipe
+ * @brief Global file table
+ *
+ * Manages all active files.
+ */
+class FileTable
+{
+    friend class File;
+
+    public:
+    FileTable()  = default;
+    ~FileTable() = default;
+
+    FileTable(const FileTable &)            = delete;
+    FileTable &operator=(const FileTable &) = delete;
+    FileTable(FileTable &&)                 = delete;
+    FileTable &operator=(FileTable &&)      = delete;
+
+    FdResult<data_structures::RefPtr<File>> GetOrCreate(const vfs::Path &path);
+    File *Find(const vfs::Path &path);
+    size_t GetCount() const { return count_; }
+    const File *GetFile(size_t index) const { return files_.Get(index); }
+
+    private:
+    data_structures::PooledHashMap<File, kMaxActiveFiles> files_{};
+    std::atomic_size_t count_{0};
+    mutable Spinlock lock_;
+};
+
+/**
+ * @brief Tagged union ptr holding either a File* or Pipe*
  *
  * - File: Smart (ref-counted), managed by RefCounted
  * - Pipe: NonOwned, owned by Process (for stdin/stdout/stderr)
@@ -129,21 +171,19 @@ using FileHandle = data_structures::NonOwningTaggedPtr<File, IO::Pipe<kStdioBuff
  *
  * This is middle level in three-tier hierarchy.
  * Multiple process file descriptors can reference same entry.
- *
- * Contains either:
- * - A File (with automatic ref counting via RefCounted)
- * - A Pipe (for stdin/stdout/stderr)
  */
 class OpenFileEntry : public data_structures::RefCounted<OpenFileEntry>
 {
+    friend class OpenFileTable;
+
     public:
     FileHandle handle;
     u32 flags{0};
     u64 offset{0};
     bool is_append{false};
 
-    OpenFileEntry()  = default;
-    ~OpenFileEntry() = default;
+    OpenFileEntry() = default;
+    ~OpenFileEntry();
 
     bool IsFile() const { return handle.Is<File>(); }
     bool IsPipe() const { return handle.Is<IO::Pipe<kStdioBufferSize>>(); }
@@ -154,79 +194,9 @@ class OpenFileEntry : public data_structures::RefCounted<OpenFileEntry>
     {
         return IsPipe() ? &handle.As<IO::Pipe<kStdioBufferSize>>() : nullptr;
     }
-};
-
-// ------------------------------
-// Process File Descriptor Table
-// -----------------------------
-
-/**
- * @brief Process-local file descriptor table
- *
- * Each process has its own table of file descriptors.
- */
-class FdTable
-{
-    public:
-    FdTable()  = default;
-    ~FdTable() = default;
-
-    FdTable(const FdTable &)            = delete;
-    FdTable &operator=(const FdTable &) = delete;
-    FdTable(FdTable &&)                 = delete;
-    FdTable &operator=(FdTable &&)      = delete;
-
-    FdResult<fd_t> AllocateFd(OpenFileEntry *global_entry);
-    FdResult<fd_t> AllocateFdAt(OpenFileEntry *global_entry, fd_t fd);
-    FdResult<> FreeFd(fd_t fd);
-
-    OpenFileEntry *GetEntry(fd_t fd);
-    const OpenFileEntry *GetEntry(fd_t fd) const;
-
-    FdResult<fd_t> DuplicateFd(fd_t fd);
-    FdResult<fd_t> DuplicateFdTo(fd_t old_fd, fd_t new_fd);
-
-    size_t GetOpenCount() const { return open_count_; }
-
-    private:
-    OpenFileEntry *entries_[kMaxFdsPerProcess]{};
-    size_t open_count_{};
-    hal::Spinlock lock_{};
-};
-
-// ------------------------------
-// Global File Table
-// -----------------------------
-
-/**
- * @brief Global file table
- *
- * Manages all active files.
- */
-class FileTable
-{
-    public:
-    FileTable()  = default;
-    ~FileTable() = default;
-
-    FileTable(const FileTable &)            = delete;
-    FileTable &operator=(const FileTable &) = delete;
-    FileTable(FileTable &&)                 = delete;
-    FileTable &operator=(FileTable &&)      = delete;
-
-    FdResult<File *> GetOrCreate(const vfs::Path &path);
-    FdResult<> Release(File *file);
-
-    File *Find(const vfs::Path &path);
-    const File *Find(const vfs::Path &path) const;
-
-    size_t GetCount() const { return count_; }
-    const File *GetFile(size_t index) const { return files_.Get(index); }
 
     private:
-    data_structures::PooledHashMap<File, kMaxActiveFiles> files_{};
-    size_t count_{};
-    hal::Spinlock lock_{};
+    size_t pool_idx_{std::numeric_limits<size_t>::max()};
 };
 
 // ------------------------------
@@ -240,8 +210,10 @@ class FileTable
  */
 class OpenFileTable
 {
+    friend class OpenFileEntry;
+
     public:
-    OpenFileTable();
+    OpenFileTable() = default;
     ~OpenFileTable();
 
     OpenFileTable(const OpenFileTable &)            = delete;
@@ -249,29 +221,58 @@ class OpenFileTable
     OpenFileTable(OpenFileTable &&)                 = delete;
     OpenFileTable &operator=(OpenFileTable &&)      = delete;
 
-    FdResult<OpenFileEntry *> OpenFile(File *file, OpenMode flags);
-    FdResult<OpenFileEntry *> OpenPipe(IO::Pipe<kStdioBufferSize> &pipe);
-    FdResult<> CloseFile(OpenFileEntry *entry);
+    FdResult<data_structures::RefPtr<OpenFileEntry>> OpenFile(File *file, OpenMode flags);
+    FdResult<data_structures::RefPtr<OpenFileEntry>> OpenPipe(IO::Pipe<kStdioBufferSize> &pipe);
 
     FdResult<u64> GetOffset(const OpenFileEntry *entry) const;
     FdResult<> SetOffset(OpenFileEntry *entry, u64 offset) const;
 
-    size_t GetOpenCount() const { return open_count_; }
+    size_t GetOpenCount() const { return count_; }
     const OpenFileEntry *GetEntry(size_t index) const { return entries_.Get(index); }
 
     private:
     data_structures::PooledHashMap<OpenFileEntry, kMaxOpenFiles> entries_{};
-    size_t open_count_;
-    mutable arch::Spinlock lock_;
+    std::atomic_size_t count_{0};
+    mutable Spinlock lock_;
 };
 
 // ------------------------------
-// Standard File Descriptors
+// Process File Descriptor Table
 // -----------------------------
 
-inline constexpr fd_t kStdinFd  = kFdStdIn;
-inline constexpr fd_t kStdoutFd = kFdStdOut;
-inline constexpr fd_t kStderrFd = kFdStdErr;
+/**
+ * @brief Process-local file descriptor table
+ *
+ * Each process has its own table of file descriptors.
+ */
+class FdTable
+{
+    public:
+    FdTable()  = default;
+    ~FdTable() = default;
+
+    FdTable(const FdTable &)            = delete;
+    FdTable &operator=(const FdTable &) = delete;
+    FdTable(FdTable &&)                 = delete;
+    FdTable &operator=(FdTable &&)      = delete;
+
+    FdResult<fd_t> Allocate(data_structures::RefPtr<OpenFileEntry> global_entry);
+    FdResult<fd_t> AllocateAt(data_structures::RefPtr<OpenFileEntry> global_entry, fd_t fd);
+    FdResult<> Free(fd_t fd);
+
+    OpenFileEntry *Get(fd_t fd);
+    const OpenFileEntry *Get(fd_t fd) const;
+
+    FdResult<fd_t> DuplicateFd(fd_t fd);
+    FdResult<fd_t> DuplicateFdTo(fd_t old_fd, fd_t new_fd);
+
+    size_t GetOpenCount() const { return count_; }
+
+    private:
+    data_structures::RefPtr<OpenFileEntry> entries_[kMaxFdsPerProcess]{};
+    std::atomic_size_t count_{0};
+    mutable Spinlock lock_;
+};
 
 // ------------------------------
 // File Descriptor Manager
@@ -280,8 +281,8 @@ inline constexpr fd_t kStderrFd = kFdStdErr;
 class FdManager
 {
     public:
-    FdManager();
-    ~FdManager();
+    FdManager()  = default;
+    ~FdManager() = default;
 
     FdManager(const FdManager &)            = delete;
     FdManager &operator=(const FdManager &) = delete;
@@ -293,15 +294,12 @@ class FdManager
     FdResult<size_t> Read(fd_t fd, std::span<byte> buffer);
     FdResult<size_t> Write(fd_t fd, std::span<const byte> buffer);
     FdResult<ssize_t> Seek(fd_t fd, ssize_t offset, FdSeek whence);
+    FdResult<fd_t> Duplicate(fd_t fd);
+    FdResult<fd_t> Duplicate(fd_t old_fd, fd_t new_fd);
 
     FileTable &GetFileTable() { return file_table_; }
-    const FileTable &GetFileTable() const { return file_table_; }
-
     OpenFileTable &GetOpenFileTable() { return open_file_table_; }
-    const OpenFileTable &GetOpenFileTable() const { return open_file_table_; }
-
     FdTable *GetCurrentProcessFdTable();
-    const FdTable *GetCurrentProcessFdTable() const;
 
     private:
     FileTable file_table_;
diff --git a/kernel/src/fs/vfs/error.hpp b/kernel/src/fs/vfs/error.hpp
index 0b765b19..28c97842 100644
--- a/kernel/src/fs/vfs/error.hpp
+++ b/kernel/src/fs/vfs/error.hpp
@@ -1,5 +1,5 @@
-#ifndef KERNEL_SRC_VFS_ERROR_HPP_
-#define KERNEL_SRC_VFS_ERROR_HPP_
+#ifndef KERNEL_SRC_FS_VFS_ERROR_HPP_
+#define KERNEL_SRC_FS_VFS_ERROR_HPP_
 
 #include <expected.hpp>
 
@@ -30,4 +30,4 @@ using Result = std::expected<T, VfsError>;
 
 }  // namespace vfs
 
-#endif  // KERNEL_SRC_VFS_ERROR_HPP_
+#endif  // KERNEL_SRC_FS_VFS_ERROR_HPP_
diff --git a/kernel/src/fs/vfs/fat/fat12.hpp b/kernel/src/fs/vfs/fat/fat12.hpp
index b60f9ea0..dc0ccb8e 100644
--- a/kernel/src/fs/vfs/fat/fat12.hpp
+++ b/kernel/src/fs/vfs/fat/fat12.hpp
@@ -1,5 +1,5 @@
-#ifndef KERNEL_SRC_VFS_FAT_FAT12_HPP_
-#define KERNEL_SRC_VFS_FAT_FAT12_HPP_
+#ifndef KERNEL_SRC_FS_VFS_FAT_FAT12_HPP_
+#define KERNEL_SRC_FS_VFS_FAT_FAT12_HPP_
 
 #include <bit.hpp>
 #include <fs/vfs/fat/fat.hpp>
@@ -178,4 +178,4 @@ struct FatTraits<Fat12, IO> {
 
 }  // namespace vfs
 
-#endif  // KERNEL_SRC_VFS_FAT_FAT12_HPP_
+#endif  // KERNEL_SRC_FS_VFS_FAT_FAT12_HPP_
diff --git a/kernel/src/fs/vfs/fat/fat16.hpp b/kernel/src/fs/vfs/fat/fat16.hpp
index efe4a235..3948ec7b 100644
--- a/kernel/src/fs/vfs/fat/fat16.hpp
+++ b/kernel/src/fs/vfs/fat/fat16.hpp
@@ -1,5 +1,5 @@
-#ifndef KERNEL_SRC_VFS_FAT_FAT16_HPP_
-#define KERNEL_SRC_VFS_FAT_FAT16_HPP_
+#ifndef KERNEL_SRC_FS_VFS_FAT_FAT16_HPP_
+#define KERNEL_SRC_FS_VFS_FAT_FAT16_HPP_
 
 #include <bit.hpp>
 #include <internal/math.hpp>
@@ -132,4 +132,4 @@ struct FatTraits<Fat16, IO> {
 
 }  // namespace vfs
 
-#endif  // KERNEL_SRC_VFS_FAT_FAT16_HPP_
+#endif  // KERNEL_SRC_FS_VFS_FAT_FAT16_HPP_
diff --git a/kernel/src/fs/vfs/fat/fat32.hpp b/kernel/src/fs/vfs/fat/fat32.hpp
index 3043a649..02d70adf 100644
--- a/kernel/src/fs/vfs/fat/fat32.hpp
+++ b/kernel/src/fs/vfs/fat/fat32.hpp
@@ -1,5 +1,5 @@
-#ifndef KERNEL_SRC_VFS_FAT_FAT32_HPP_
-#define KERNEL_SRC_VFS_FAT_FAT32_HPP_
+#ifndef KERNEL_SRC_FS_VFS_FAT_FAT32_HPP_
+#define KERNEL_SRC_FS_VFS_FAT_FAT32_HPP_
 
 #include <bit.hpp>
 #include <internal/math.hpp>
@@ -159,4 +159,4 @@ struct FatTraits<Fat32, IO> {
 
 }  // namespace vfs
 
-#endif  // KERNEL_SRC_VFS_FAT_FAT32_HPP_
+#endif  // KERNEL_SRC_FS_VFS_FAT_FAT32_HPP_
diff --git a/kernel/src/fs/vfs/interface.hpp b/kernel/src/fs/vfs/interface.hpp
index 14b86007..a4c7b8e8 100644
--- a/kernel/src/fs/vfs/interface.hpp
+++ b/kernel/src/fs/vfs/interface.hpp
@@ -1,5 +1,5 @@
-#ifndef KERNEL_SRC_VFS_INTERFACE_HPP_
-#define KERNEL_SRC_VFS_INTERFACE_HPP_
+#ifndef KERNEL_SRC_FS_VFS_INTERFACE_HPP_
+#define KERNEL_SRC_FS_VFS_INTERFACE_HPP_
 
 #include <types.h>
 #include <concepts.hpp>
@@ -56,4 +56,4 @@ concept VFSInterface = VFSIO<IO> and requires(T<IO> fs, IO io) {
 
 }  // namespace vfs
 
-#endif  // KERNEL_SRC_VFS_INTERFACE_HPP_
+#endif  // KERNEL_SRC_FS_VFS_INTERFACE_HPP_
diff --git a/kernel/src/fs/vfs/io/in_memory.hpp b/kernel/src/fs/vfs/io/in_memory.hpp
index c4b64529..aaef20ba 100644
--- a/kernel/src/fs/vfs/io/in_memory.hpp
+++ b/kernel/src/fs/vfs/io/in_memory.hpp
@@ -1,5 +1,5 @@
-#ifndef KERNEL_SRC_VFS_IO_IN_MEMORY_HPP_
-#define KERNEL_SRC_VFS_IO_IN_MEMORY_HPP_
+#ifndef KERNEL_SRC_FS_VFS_IO_IN_MEMORY_HPP_
+#define KERNEL_SRC_FS_VFS_IO_IN_MEMORY_HPP_
 
 #include <string.h>
 #include <fs/vfs/interface.hpp>
@@ -101,4 +101,4 @@ static_assert(VFSIO<InMemory>, "InMemory does not implement VFSIO");
 
 }  // namespace vfs::io
 
-#endif  // KERNEL_SRC_VFS_IO_IN_MEMORY_HPP_
+#endif  // KERNEL_SRC_FS_VFS_IO_IN_MEMORY_HPP_
diff --git a/kernel/src/fs/vfs/path.hpp b/kernel/src/fs/vfs/path.hpp
index cab96f87..93006285 100644
--- a/kernel/src/fs/vfs/path.hpp
+++ b/kernel/src/fs/vfs/path.hpp
@@ -1,5 +1,5 @@
-#ifndef KERNEL_SRC_VFS_PATH_HPP_
-#define KERNEL_SRC_VFS_PATH_HPP_
+#ifndef KERNEL_SRC_FS_VFS_PATH_HPP_
+#define KERNEL_SRC_FS_VFS_PATH_HPP_
 
 #include <array.hpp>
 #include <concepts.hpp>
@@ -429,4 +429,4 @@ inline const Path Path::kRoot       = Path(std::string_view(&kPathSeparator, 1))
 
 }  // namespace vfs
 
-#endif  // KERNEL_SRC_VFS_PATH_HPP_
+#endif  // KERNEL_SRC_FS_VFS_PATH_HPP_
diff --git a/kernel/src/fs/vfs/types.hpp b/kernel/src/fs/vfs/types.hpp
index d1491315..8ddee776 100644
--- a/kernel/src/fs/vfs/types.hpp
+++ b/kernel/src/fs/vfs/types.hpp
@@ -1,5 +1,5 @@
-#ifndef KERNEL_SRC_VFS_TYPES_HPP_
-#define KERNEL_SRC_VFS_TYPES_HPP_
+#ifndef KERNEL_SRC_FS_VFS_TYPES_HPP_
+#define KERNEL_SRC_FS_VFS_TYPES_HPP_
 
 #include <types.h>
 #include <data_structures/critbit_tree.hpp>
@@ -183,4 +183,4 @@ using Mounts = data_structures::CritBitTree<MountPoint>;
 
 }  // namespace vfs
 
-#endif  // KERNEL_SRC_VFS_TYPES_HPP_
+#endif  // KERNEL_SRC_FS_VFS_TYPES_HPP_
diff --git a/kernel/src/hal/api/spinlock.hpp b/kernel/src/hal/api/spinlock.hpp
index 397f8bf7..a03d625b 100644
--- a/kernel/src/hal/api/spinlock.hpp
+++ b/kernel/src/hal/api/spinlock.hpp
@@ -1,6 +1,8 @@
 #ifndef KERNEL_SRC_HAL_API_SPINLOCK_HPP_
 #define KERNEL_SRC_HAL_API_SPINLOCK_HPP_
 
+#include <defines.hpp>
+
 namespace arch
 {
 class Spinlock;
diff --git a/kernel/src/kernel.cpp b/kernel/src/kernel.cpp
index dc778b73..36de20ce 100644
--- a/kernel/src/kernel.cpp
+++ b/kernel/src/kernel.cpp
@@ -1,26 +1,13 @@
 #include <assert.h>
 #include <autogen/feature_flags.h>
-#include <string.hpp>
 #include <test_module/test_module.hpp>
-#include "trace_framework.hpp"
 
 /* internal includes */
-#include <hal/debug.hpp>
-#include <hal/terminal.hpp>
-#include <scheduling/kworker.hpp>
-
-#include "graphics/font/psf2_font.hpp"
-#include "graphics/fonts/drdos8x8.hpp"
-#include "graphics/painter.hpp"
-#include "modules/hardware.hpp"
-#include "modules/video.hpp"
-#include "sys/shell.hpp"
-
-#include "drivers/apic/local_apic.hpp"
 #include "hal/boot_args.hpp"
 #include "modules/hardware.hpp"
 #include "modules/scheduling.hpp"
-#include "todo.hpp"
+#include "scheduling/kworker.hpp"
+#include "trace_framework.hpp"
 
 extern void KernelInit(const hal::RawBootArguments &);
 
@@ -30,8 +17,20 @@ static void KernelRun()
 
     auto &task_mgr = SchedulingModule::Get().GetTaskMgr();
 
-    // Spawn hello world process
-    R_ASSERT_TRUE(task_mgr.ExecuteElf64("/bin/hello", {}), "Failed to spawn /bin/hello process...");
+    auto res = task_mgr.ExecuteElf64("/bin/hello", {});
+    R_ASSERT_TRUE(res, "Failed to spawn /bin/hello process...");
+    auto [pid, _] = res.value();
+
+    Sched::Task tracer_task;
+    tracer_task.func       = reinterpret_cast<void *>(Sched::StdoutTracerMain);
+    tracer_task.args_count = 1;
+    tracer_task.args       = {*reinterpret_cast<u64 *>(&pid)};
+
+    // Spawn StdoutTracer KWorker to monitor hello_world's stdout
+    R_ASSERT_TRUE(
+        task_mgr.SpawnKernelProcess("stdout-tracer", {}, tracer_task),
+        "Failed to spawn stdout tracer process..."
+    );
 
     SchedulingModule::Get().GetScheduler().ConvertToScheduling();
 }
diff --git a/kernel/src/libc_backend.cpp b/kernel/src/libc_backend.cpp
index 9f019f80..32aee743 100644
--- a/kernel/src/libc_backend.cpp
+++ b/kernel/src/libc_backend.cpp
@@ -1,12 +1,10 @@
 /// This file provides the kernel's implementation of the libc platform ABI.
 #ifdef __ALKOS_KERNEL__
+
 #include <assert.h>
 #include <platform.h>
 
-#include "hal/debug_terminal.hpp"
 #include "hal/panic.hpp"
-#include "hal/spinlock.hpp"
-#include "modules/timing.hpp"
 #include "modules/timing_constants.hpp"
 #include "syscalls/syscalls.hpp"
 
@@ -35,52 +33,4 @@ size_t __platform_debug_read_line(char *buffer, const size_t buffer_size)
 
 void __platform_write_console(const char *buffer) { SysWriteConsole(buffer); }
 
-fd_t __platform_open(const char *pathname, const int flags)
-{
-    auto res = SysOpen(vfs::Path(pathname), static_cast<Fs::OpenMode>(flags));
-    if (!res) {
-        return -1;
-    }
-
-    return *res;
-}
-
-int __platform_close(const fd_t fd)
-{
-    auto res = SysClose(fd);
-    if (!res) {
-        return -1;
-    }
-
-    return 0;
-}
-
-ssize_t __platform_read(const fd_t fd, void *buf, const size_t count)
-{
-    auto res = SysRead(fd, {static_cast<byte *>(buf), count});
-    if (!res) {
-        DEBUG_FATAL_VFS("Read syscall failed on fd %d: %d", fd, static_cast<int>(res.error()));
-        return -1;
-    }
-    return static_cast<ssize_t>(*res);
-}
-
-ssize_t __platform_write(const fd_t fd, const void *buf, const size_t count)
-{
-    auto res = SysWrite(fd, {static_cast<const byte *>(buf), count});
-    if (!res) {
-        return -1;
-    }
-    return static_cast<ssize_t>(*res);
-}
-
-ssize_t __platform_seek(int fd, ssize_t offset, FdSeek whence)
-{
-    auto res = SysSeek(fd, offset, static_cast<Fs::FdSeek>(whence));
-    if (!res) {
-        return -1;
-    }
-    return *res;
-}
-
 #endif
diff --git a/kernel/src/mem/cyclic_allocator.hpp b/kernel/src/mem/cyclic_allocator.hpp
index 1d3eafad..62f26952 100644
--- a/kernel/src/mem/cyclic_allocator.hpp
+++ b/kernel/src/mem/cyclic_allocator.hpp
@@ -6,7 +6,7 @@
 #include <data_structures/bit_array.hpp>
 #include <new.hpp>
 #include <todo.hpp>
-#include "sync/kernel/spinlock.hpp"
+#include "sync/spinlock.hpp"
 
 TODO_WHEN_VMEM_WORKS
 /* TODO: STATIC MEMORY ALLOCATOR!!! */
diff --git a/kernel/src/mem/phys/mngr/buddy.hpp b/kernel/src/mem/phys/mngr/buddy.hpp
index b483d4a6..047caf58 100644
--- a/kernel/src/mem/phys/mngr/buddy.hpp
+++ b/kernel/src/mem/phys/mngr/buddy.hpp
@@ -5,12 +5,12 @@
 #include <bit.hpp>
 #include <expected.hpp>
 
+#include "../../../sync/spinlock.hpp"
 #include "mem/error.hpp"
 #include "mem/page.hpp"
 #include "mem/page_meta.hpp"
 #include "mem/page_meta_table.hpp"
 #include "mem/types.hpp"
-#include "sync/kernel/spinlock.hpp"
 
 // Forward declaration for test access (test class is in global namespace)
 class BuddyPmmTest;
diff --git a/kernel/src/mem/phys/mngr/slab.hpp b/kernel/src/mem/phys/mngr/slab.hpp
index 03560690..290f47d7 100644
--- a/kernel/src/mem/phys/mngr/slab.hpp
+++ b/kernel/src/mem/phys/mngr/slab.hpp
@@ -6,11 +6,11 @@
 #include <limits.hpp>
 #include <span.hpp>
 
+#include "../../../sync/spinlock.hpp"
 #include "hal/constants.hpp"
 #include "mem/page_meta.hpp"
 #include "mem/phys/mngr/buddy.hpp"
 #include "mem/types.hpp"
-#include "sync/kernel/spinlock.hpp"
 
 namespace Mem
 {
diff --git a/kernel/src/mem/virt/addr_space.hpp b/kernel/src/mem/virt/addr_space.hpp
index 5252882b..4ea7922a 100644
--- a/kernel/src/mem/virt/addr_space.hpp
+++ b/kernel/src/mem/virt/addr_space.hpp
@@ -97,7 +97,7 @@ class AddressSpace
     /// @brief Sorted list of pointers to VMA objects. We own these objects.
     /// @note The list is sorted by the start address of the VMA objects.
     data_structures::DoubleLinkedList<VMemArea *> area_list_;
-    hal::Spinlock area_list_lock_;
+    Spinlock area_list_lock_;
 
     // Dependencies
     KernelMmuContext *ctx_;
diff --git a/kernel/src/modules/global_state.hpp b/kernel/src/modules/global_state.hpp
index 033f60d6..52f028ac 100644
--- a/kernel/src/modules/global_state.hpp
+++ b/kernel/src/modules/global_state.hpp
@@ -8,7 +8,7 @@
 #include "mem/virt/addr_space.hpp"
 #include "modules/global_state_constants.hpp"
 #include "modules/helpers.hpp"
-#include "sync/kernel/spinlock.hpp"
+#include "sync/spinlock.hpp"
 
 // ------------------------------
 // Module
diff --git a/kernel/src/scheduling/kworker.cpp b/kernel/src/scheduling/kworker.cpp
index a6ae1d57..676bf4aa 100644
--- a/kernel/src/scheduling/kworker.cpp
+++ b/kernel/src/scheduling/kworker.cpp
@@ -39,3 +39,34 @@ void Sched::TraceDumperMain()
         HardwareModule::Get().GetInterrupts().EnableHardwareInterrupts();
     }
 }
+
+void Sched::StdoutTracerMain(Pid pid)
+{
+    TRACE_INFO_SCHEDULING("Created new StdoutTracer!");
+
+    // Get hello process
+    auto &processes = SchedulingModule::Get().GetProcesses();
+    auto res        = processes.GetProcess(pid);
+    R_ASSERT_TRUE(static_cast<bool>(res), "Failed to find hello_world process for tracing...");
+    auto *hello_process = res.value();
+
+    // Read from the stdout pipe and write to terminal
+    byte buffer[256];
+    while (true) {
+        auto result = hello_process->stdout_pipe.Read(std::span<byte>(buffer, sizeof(buffer)));
+
+        if (result.has_value()) {
+            size_t bytes_read = result.value();
+            if (bytes_read > 0) {
+                size_t safe_size =
+                    bytes_read < sizeof(buffer) - 1 ? bytes_read : sizeof(buffer) - 1;
+                buffer[safe_size] = '\0';
+                hal::TerminalWriteString(reinterpret_cast<const char *>(buffer));
+            }
+        }
+
+        HardwareModule::Get().GetInterrupts().BlockHardwareInterrupts();
+        SchedulingModule::Get().GetScheduler().Yield();
+        HardwareModule::Get().GetInterrupts().EnableHardwareInterrupts();
+    }
+}
diff --git a/kernel/src/scheduling/kworker.hpp b/kernel/src/scheduling/kworker.hpp
index 76fd6799..425b7c14 100644
--- a/kernel/src/scheduling/kworker.hpp
+++ b/kernel/src/scheduling/kworker.hpp
@@ -3,9 +3,12 @@
 
 namespace Sched
 {
+struct Pid;
+
 void KWorkerMain();
 void TraceDumperMain();
 void FdHierarchyDumperMain();
+void StdoutTracerMain(Pid pid);
 }  // namespace Sched
 
 #endif  // KERNEL_SRC_SCHEDULING_KWORKER_HPP_
diff --git a/kernel/src/scheduling/process.hpp b/kernel/src/scheduling/process.hpp
index 071ee6b6..bdb0430f 100644
--- a/kernel/src/scheduling/process.hpp
+++ b/kernel/src/scheduling/process.hpp
@@ -43,10 +43,10 @@ struct Process : hal::Process {
     ProcessFlags flags;
 
     /* Process resources */
-    Mem::VirtualPtr<Mem::AddressSpace> address_space;
+    Mem::VPtr<Mem::AddressSpace> address_space;
 
     /* File descriptor table */
-    Mem::VirtualPtr<Fs::FdTable> fd_table;
+    Mem::VPtr<Fs::FdTable> fd_table;
 
     /* Standard I/O pipes (owned by process) */
     IO::Pipe<Fs::kStdioBufferSize> stdin_pipe;
diff --git a/kernel/src/scheduling/processes.cpp b/kernel/src/scheduling/processes.cpp
index f2d574ac..6cfd334f 100644
--- a/kernel/src/scheduling/processes.cpp
+++ b/kernel/src/scheduling/processes.cpp
@@ -16,8 +16,14 @@
 
 std::expected<Sched::Process *, Sched::Error> Sched::Processes::PrepareProcess()
 {
+    bool dismiss = false;
+
     const size_t idx = processes_.Allocate();
 
+    template_lib::BatchedScopeGuard process_guard(dismiss, [&]() {
+        processes_.Free(idx);
+    });
+
     if (idx == std::numeric_limits<size_t>::max()) {
         return std::unexpected(Error::ExceededMaxAllowedInstances);
     }
@@ -27,15 +33,17 @@ std::expected<Sched::Process *, Sched::Error> Sched::Processes::PrepareProcess()
     ASSERT_LE(idx, std::numeric_limits<u16>::max());
     process->pid = AssignNewPid(static_cast<u16>(idx));
 
-    auto fd_table = Mem::KMalloc<Fs::FdTable>();
-    RET_UNEXPECTED_IF(!fd_table, Error::OutOfMemory);
+    // ----------------------------------------------------------
+    // Initialize standard I/O pipes
+    // ----------------------------------------------------------
 
-    auto fd_table_ptr = new (*fd_table) Fs::FdTable();
-    process->fd_table = fd_table_ptr;
+    // Create the process's file descriptor table
+    auto fd_table_ptr = Mem::KNew<Fs::FdTable>();
+    RET_UNEXPECTED_IF(!fd_table_ptr, Error::OutOfMemory);
 
-    template_lib::ScopeGuard fd_table_guard([&]() {
-        fd_table_ptr->~FdTable();
-        Mem::KFree(fd_table_ptr);
+    auto *fd_table = process->fd_table = *fd_table_ptr;
+    template_lib::BatchedScopeGuard fd_table_guard(dismiss, [&]() {
+        Mem::KDelete(fd_table);
     });
 
     // Get the global OpenFileTable
@@ -44,50 +52,25 @@ std::expected<Sched::Process *, Sched::Error> Sched::Processes::PrepareProcess()
     // Open stdin pipe in the global open file table
     auto stdin_entry_result = open_file_table.OpenPipe(process->stdin_pipe);
     RET_UNEXPECTED_IF(!stdin_entry_result, Error::OutOfMemory);
-    auto *stdin_entry = *stdin_entry_result;
 
-    // Allocate stdin file descriptor
-    auto stdin_fd_result = fd_table_ptr->AllocateFdAt(stdin_entry, Fs::kStdinFd);
-    if (!stdin_fd_result) {
-        open_file_table.CloseFile(stdin_entry);
-        return std::unexpected(Error::OutOfMemory);
-    }
+    auto stdin_fd_result = fd_table->AllocateAt(std::move(*stdin_entry_result), Fs::kStdinFd);
+    RET_UNEXPECTED_IF(!stdin_fd_result, Error::OutOfMemory);
 
     // Open stdout pipe in the global open file table
     auto stdout_entry_result = open_file_table.OpenPipe(process->stdout_pipe);
-    if (!stdout_entry_result) {
-        open_file_table.CloseFile(stdin_entry);
-        return std::unexpected(Error::OutOfMemory);
-    }
-    auto *stdout_entry = *stdout_entry_result;
-
-    // Allocate stdout file descriptor
-    auto stdout_fd_result = fd_table_ptr->AllocateFdAt(stdout_entry, Fs::kStdoutFd);
-    if (!stdout_fd_result) {
-        open_file_table.CloseFile(stdin_entry);
-        open_file_table.CloseFile(stdout_entry);
-        return std::unexpected(Error::OutOfMemory);
-    }
+    RET_UNEXPECTED_IF(!stdout_entry_result, Error::OutOfMemory);
+
+    auto stdout_fd_result = fd_table->AllocateAt(std::move(*stdout_entry_result), Fs::kStdoutFd);
+    RET_UNEXPECTED_IF(!stdout_fd_result, Error::OutOfMemory);
 
     // Open stderr pipe in the global open file table
     auto stderr_entry_result = open_file_table.OpenPipe(process->stderr_pipe);
-    if (!stderr_entry_result) {
-        open_file_table.CloseFile(stdin_entry);
-        open_file_table.CloseFile(stdout_entry);
-        return std::unexpected(Error::OutOfMemory);
-    }
-    auto *stderr_entry = *stderr_entry_result;
-
-    // Allocate stderr file descriptor
-    auto stderr_fd_result = fd_table_ptr->AllocateFdAt(stderr_entry, Fs::kStderrFd);
-    if (!stderr_fd_result) {
-        open_file_table.CloseFile(stdin_entry);
-        open_file_table.CloseFile(stdout_entry);
-        open_file_table.CloseFile(stderr_entry);
-        return std::unexpected(Error::OutOfMemory);
-    }
+    RET_UNEXPECTED_IF(!stderr_entry_result, Error::OutOfMemory);
+
+    auto stderr_fd_result = fd_table->AllocateAt(std::move(*stderr_entry_result), Fs::kStderrFd);
+    RET_UNEXPECTED_IF(!stderr_fd_result, Error::OutOfMemory);
 
-    fd_table_guard.dismiss();
+    dismiss = true;
 
     return process;
 }
@@ -99,6 +82,5 @@ void Sched::Processes::CleanupProcess(Process *process)
     auto fd_table = process->fd_table;
     ASSERT_NOT_NULL(fd_table);
 
-    fd_table->~FdTable();
-    Mem::KFree(fd_table);
+    Mem::KDelete(fd_table);
 }
diff --git a/kernel/src/sync/kernel/spinlock.hpp b/kernel/src/sync/spinlock.hpp
similarity index 53%
rename from kernel/src/sync/kernel/spinlock.hpp
rename to kernel/src/sync/spinlock.hpp
index 45018259..9640db2f 100644
--- a/kernel/src/sync/kernel/spinlock.hpp
+++ b/kernel/src/sync/spinlock.hpp
@@ -1,15 +1,16 @@
-#ifndef KERNEL_SRC_SYNC_KERNEL_SPINLOCK_HPP_
-#define KERNEL_SRC_SYNC_KERNEL_SPINLOCK_HPP_
+#ifndef KERNEL_SRC_SYNC_SPINLOCK_HPP_
+#define KERNEL_SRC_SYNC_SPINLOCK_HPP_
 
 #include <hal/spinlock.hpp>
 
-struct Spinlock : arch::Spinlock {
+struct Spinlock : hal::Spinlock {
     // ------------------------------
     // Binding for CXX lib
     // ------------------------------
 
     FORCE_INLINE_F void lock() { hal::Spinlock::Lock(); }
     FORCE_INLINE_F void unlock() { hal::Spinlock::Unlock(); }
+    FORCE_INLINE_F bool try_lock() { return hal::Spinlock::TryLock(); }
 };
 
-#endif  // KERNEL_SRC_SYNC_KERNEL_SPINLOCK_HPP_
+#endif  // KERNEL_SRC_SYNC_SPINLOCK_HPP_
diff --git a/kernel/src/syscalls/calls/fd.hpp b/kernel/src/syscalls/calls/fd.hpp
index 2546648a..2f903d28 100644
--- a/kernel/src/syscalls/calls/fd.hpp
+++ b/kernel/src/syscalls/calls/fd.hpp
@@ -2,7 +2,6 @@
 #define KERNEL_SRC_SYSCALLS_CALLS_FD_HPP_
 
 #include <defines.h>
-
 #include "modules/vfs.hpp"
 
 namespace Syscall
@@ -19,9 +18,7 @@ namespace Syscall
  */
 FORCE_INLINE_F Fs::FdResult<fd_t> SysOpen(const vfs::Path &path, const Fs::OpenMode mode)
 {
-    auto result = ::VfsModule::Get().GetFdManager().Open(path, mode);
-    RET_UNEXPECTED_IF_ERR(result);
-    return result.value();
+    return ::VfsModule::Get().GetFdManager().Open(path, mode);
 }
 
 /**
@@ -31,9 +28,7 @@ FORCE_INLINE_F Fs::FdResult<fd_t> SysOpen(const vfs::Path &path, const Fs::OpenM
  */
 FORCE_INLINE_F Fs::FdResult<> SysClose(fd_t fd)
 {
-    auto result = ::VfsModule::Get().GetFdManager().Close(fd);
-    RET_UNEXPECTED_IF_ERR(result);
-    return {};
+    return ::VfsModule::Get().GetFdManager().Close(fd);
 }
 
 /**
@@ -44,9 +39,7 @@ FORCE_INLINE_F Fs::FdResult<> SysClose(fd_t fd)
  */
 FORCE_INLINE_F Fs::FdResult<size_t> SysRead(fd_t fd, std::span<byte> buffer)
 {
-    auto result = ::VfsModule::Get().GetFdManager().Read(fd, buffer);
-    RET_UNEXPECTED_IF_ERR(result);
-    return result.value();
+    return ::VfsModule::Get().GetFdManager().Read(fd, buffer);
 }
 
 /**
@@ -57,9 +50,7 @@ FORCE_INLINE_F Fs::FdResult<size_t> SysRead(fd_t fd, std::span<byte> buffer)
  */
 FORCE_INLINE_F Fs::FdResult<size_t> SysWrite(fd_t fd, std::span<const byte> buffer)
 {
-    auto result = ::VfsModule::Get().GetFdManager().Write(fd, buffer);
-    RET_UNEXPECTED_IF_ERR(result);
-    return result.value();
+    return ::VfsModule::Get().GetFdManager().Write(fd, buffer);
 }
 
 /**
@@ -71,9 +62,28 @@ FORCE_INLINE_F Fs::FdResult<size_t> SysWrite(fd_t fd, std::span<const byte> buff
  */
 FORCE_INLINE_F Fs::FdResult<i64> SysSeek(fd_t fd, const i64 offset, const Fs::FdSeek whence)
 {
-    auto result = ::VfsModule::Get().GetFdManager().Seek(fd, offset, whence);
-    RET_UNEXPECTED_IF_ERR(result);
-    return result.value();
+    return ::VfsModule::Get().GetFdManager().Seek(fd, offset, whence);
+}
+
+/**
+ * @brief Duplicate a file descriptor
+ * @param fd File descriptor to duplicate
+ * @return New file descriptor on success, or error
+ */
+FORCE_INLINE_F Fs::FdResult<fd_t> SysDup(fd_t fd)
+{
+    return ::VfsModule::Get().GetFdManager().Duplicate(fd);
+}
+
+/**
+ * @brief Duplicate a file descriptor to a specific new descriptor
+ * @param old_fd File descriptor to duplicate
+ * @param new_fd New file descriptor
+ * @return New file descriptor on success, or error
+ */
+FORCE_INLINE_F Fs::FdResult<fd_t> SysDupTo(fd_t old_fd, fd_t new_fd)
+{
+    return ::VfsModule::Get().GetFdManager().Duplicate(old_fd, new_fd);
 }
 
 }  // namespace Syscall
diff --git a/kernel/src/syscalls/dispatch_table.hpp b/kernel/src/syscalls/dispatch_table.hpp
index a6e41d7a..da6fae3c 100644
--- a/kernel/src/syscalls/dispatch_table.hpp
+++ b/kernel/src/syscalls/dispatch_table.hpp
@@ -35,10 +35,9 @@ struct SyscallDispatchTable {
     static consteval auto Create()
     {
         constexpr SyscallDispatchTable table = kFun();
-#ifdef NDEBUG
-        // static_assert(table.IsAllHandlersRegistered(), "Not all syscall handlers are
-        // registered");
-#endif
+#ifndef NDEBUG
+        static_assert(table.IsAllHandlersRegistered(), "Not all syscall handlers are registered");
+#endif  // NDEBUG
         return table;
     }
 
diff --git a/kernel/src/syscalls/handler.hpp b/kernel/src/syscalls/handler.hpp
index 70bb9f57..445c641a 100644
--- a/kernel/src/syscalls/handler.hpp
+++ b/kernel/src/syscalls/handler.hpp
@@ -58,6 +58,12 @@ struct span_element_type<std::span<T, Extent>> {
 
 template <typename T>
 using span_element_type_t = span_element_type<T>::type;
+
+template <typename T>
+concept ConstructibleFromCString = requires(const char *str) {
+    { T(str) };
+};
+
 }  // namespace internal
 
 template <typename T>
@@ -65,8 +71,9 @@ concept SyscallRetType = std::is_integral_v<T> || std::is_pointer_v<T> || std::i
                          internal::is_expected_v<T>;
 
 template <typename T>
-concept SyscallArgType = std::is_integral_v<T> || std::is_pointer_v<T> || std::is_enum_v<T> ||
-                         std::is_reference_v<T> || internal::is_span_v<T>;
+concept SyscallArgType =
+    std::is_integral_v<T> || std::is_pointer_v<T> || std::is_enum_v<T> || std::is_reference_v<T> ||
+    internal::is_span_v<T> || internal::ConstructibleFromCString<std::remove_cvref_t<T>>;
 
 template <auto TargetFunc>
 class SyscallWrapper
@@ -126,14 +133,29 @@ class SyscallWrapper
         if constexpr (internal::is_span_v<T>) {
             // Span needs two consecutive registers: pointer and size
             using ElemType = internal::span_element_type_t<T>;
-            auto *ptr      = reinterpret_cast<ElemType *>(GetRawArg<RegIdx>(args));
-            auto size      = GetRawArg<RegIdx + 1>(args);
+
+            auto *ptr = reinterpret_cast<ElemType *>(GetRawArg<RegIdx>(args));
+            auto size = GetRawArg<RegIdx + 1>(args);
+
             return T(ptr, size);
         } else if constexpr (std::is_pointer_v<T>) {
             return reinterpret_cast<T>(GetRawArg<RegIdx>(args));
         } else if constexpr (std::is_reference_v<T>) {
             using BaseType = std::remove_reference_t<T>;
-            return *reinterpret_cast<BaseType *>(GetRawArg<RegIdx>(args));
+
+            if constexpr (internal::ConstructibleFromCString<BaseType>) {
+                // TODO: Fix for multithreading scenarios
+                // Special case: reference to type constructible from const char*
+                auto str                 = reinterpret_cast<const char *>(GetRawArg<RegIdx>(args));
+                static BaseType temp_obj = BaseType(str);
+                return temp_obj;
+            } else {
+                return *reinterpret_cast<BaseType *>(GetRawArg<RegIdx>(args));
+            }
+        } else if constexpr (internal::ConstructibleFromCString<T>) {
+            // Direct construction from const char* (e.g., vfs::Path from const char*)
+            auto str = reinterpret_cast<const char *>(GetRawArg<RegIdx>(args));
+            return T(str);
         } else {
             return static_cast<T>(GetRawArg<RegIdx>(args));
         }
diff --git a/kernel/src/syscalls/syscalls.cpp b/kernel/src/syscalls/syscalls.cpp
index b4efbe65..a087ef18 100644
--- a/kernel/src/syscalls/syscalls.cpp
+++ b/kernel/src/syscalls/syscalls.cpp
@@ -30,6 +30,8 @@ constinit auto g_syscall_dispatch_table = SyscallDispatchTable<kSysMax>::Create<
     table.RegisterHandler<kSysRead, SysRead>();
     table.RegisterHandler<kSysWrite, SysWrite>();
     table.RegisterHandler<kSysSeek, SysSeek>();
+    table.RegisterHandler<kSysDup, SysDup>();
+    table.RegisterHandler<kSysDupTo, SysDupTo>();
 
     /* Thread, processes */
     table.RegisterHandler<kProcAbort, SysAbort>();
diff --git a/kernel/test/cxx_mutex.cpp b/kernel/test/cxx_mutex.cpp
index 1e404f77..e6f20e58 100644
--- a/kernel/test/cxx_mutex.cpp
+++ b/kernel/test/cxx_mutex.cpp
@@ -1,5 +1,5 @@
 #include <mutex.hpp>
-#include <sync/kernel/spinlock.hpp>
+#include <sync/spinlock.hpp>
 #include <test_module/test.hpp>
 
 class MutexTest : public TestGroupBase
diff --git a/kernel/test/spinlock.cpp b/kernel/test/spinlock.cpp
index 91af516b..37677876 100644
--- a/kernel/test/spinlock.cpp
+++ b/kernel/test/spinlock.cpp
@@ -1,8 +1,7 @@
 /* internal includes */
 
 #include <assert.h>
-#include <mutex.hpp>
-#include <sync/kernel/spinlock.hpp>
+#include <sync/spinlock.hpp>
 #include <test_module/test.hpp>
 
 class SpinlockTest : public TestGroupBase
diff --git a/libs/libc/CMakeLists.txt b/libs/libc/CMakeLists.txt
index 0cc81232..cc88784d 100644
--- a/libs/libc/CMakeLists.txt
+++ b/libs/libc/CMakeLists.txt
@@ -13,6 +13,7 @@
 message(STATUS "Configuring LibC interface...")
 
 alkos_find_sources(ALKOS_LIBC_SOURCES)
+list(FILTER ALKOS_LIBC_SOURCES EXCLUDE REGEX "crt0\\.cpp$")
 set(ALKOS_LIBC_SOURCES ${ALKOS_LIBC_SOURCES} CACHE INTERNAL "Source files for libc")
 
 add_library(alkos.libc.interface INTERFACE)
diff --git a/libs/libc/src/abi/platform.h b/libs/libc/src/abi/platform.h
index 36044637..eadac7db 100644
--- a/libs/libc/src/abi/platform.h
+++ b/libs/libc/src/abi/platform.h
@@ -27,6 +27,8 @@ SYSCALL_NAME(close, kSysClose, int, fd_t, fd);
 SYSCALL_NAME(read, kSysRead, ssize_t, fd_t, fd, void *, buf, size_t, count);
 SYSCALL_NAME(write, kSysWrite, ssize_t, fd_t, fd, const void *, buf, size_t, count);
 SYSCALL_NAME(seek, kSysSeek, ssize_t, fd_t, fd, ssize_t, offset, FdSeek, whence);
+SYSCALL_NAME(dup, kSysDup, fd_t, fd_t, fd);
+SYSCALL_NAME(dup_to, kSysDupTo, fd_t, fd_t, old_fd, fd_t, new_fd);
 
 /* Thread, processes */
 SYSCALL_NAME(thread_create, kThreadCreate, int, Thread *, thread, thread_func_t, f, void *, arg);
diff --git a/libs/libc/src/include/alkos/fd.h b/libs/libc/src/include/alkos/fd.h
index 507a7c7d..53370974 100644
--- a/libs/libc/src/include/alkos/fd.h
+++ b/libs/libc/src/include/alkos/fd.h
@@ -1,5 +1,5 @@
-#ifndef LIBS_LIBC_SRC_INCLUDE_SYS_FD_H_
-#define LIBS_LIBC_SRC_INCLUDE_SYS_FD_H_
+#ifndef LIBS_LIBC_SRC_INCLUDE_ALKOS_FD_H_
+#define LIBS_LIBC_SRC_INCLUDE_ALKOS_FD_H_
 
 typedef int fd_t;
 
@@ -21,4 +21,4 @@ typedef enum { kFdBufferNone = 0, kFdBufferLine = 1, kFdBufferFull = 2 } FdBuffe
 
 typedef enum { kFdSeekSet = 0, kFdSeekCurrent = 1, kFdSeekEnd = 2 } FdSeek;
 
-#endif  // LIBS_LIBC_SRC_INCLUDE_SYS_FD_H_
+#endif  // LIBS_LIBC_SRC_INCLUDE_ALKOS_FD_H_
diff --git a/libs/libc/src/include/alkos/proc.h b/libs/libc/src/include/alkos/proc.h
index 8555645f..462e8b2e 100644
--- a/libs/libc/src/include/alkos/proc.h
+++ b/libs/libc/src/include/alkos/proc.h
@@ -1,6 +1,6 @@
-#ifndef LIBS_LIBC_SRC_INCLUDE_SYS_PROC_H_
-#define LIBS_LIBC_SRC_INCLUDE_SYS_PROC_H_
+#ifndef LIBS_LIBC_SRC_INCLUDE_ALKOS_PROC_H_
+#define LIBS_LIBC_SRC_INCLUDE_ALKOS_PROC_H_
 
 #include "thread.h"
 
-#endif  // LIBS_LIBC_SRC_INCLUDE_SYS_PROC_H_
+#endif  // LIBS_LIBC_SRC_INCLUDE_ALKOS_PROC_H_
diff --git a/libs/libc/src/include/alkos/structs.h b/libs/libc/src/include/alkos/structs.h
index adbad9de..9b8c3a1d 100644
--- a/libs/libc/src/include/alkos/structs.h
+++ b/libs/libc/src/include/alkos/structs.h
@@ -1,9 +1,9 @@
-#ifndef LIBS_LIBC_SRC_INCLUDE_SYS_ALKOS_STRUCTS_H_
-#define LIBS_LIBC_SRC_INCLUDE_SYS_ALKOS_STRUCTS_H_
+#ifndef LIBS_LIBC_SRC_INCLUDE_ALKOS_STRUCTS_H_
+#define LIBS_LIBC_SRC_INCLUDE_ALKOS_STRUCTS_H_
 
-#include "alkos/thread.h"
-#include "alkos/proc.h"
 #include "alkos/fd.h"
+#include "alkos/proc.h"
+#include "alkos/thread.h"
 #include "alkos/time.h"
 
-#endif  // LIBS_LIBC_SRC_INCLUDE_SYS_ALKOS_STRUCTS_H_
+#endif  // LIBS_LIBC_SRC_INCLUDE_ALKOS_STRUCTS_H_
diff --git a/libs/libc/src/include/alkos/sys/fd.h b/libs/libc/src/include/alkos/sys/fd.h
index d6c8a289..7b05433e 100644
--- a/libs/libc/src/include/alkos/sys/fd.h
+++ b/libs/libc/src/include/alkos/sys/fd.h
@@ -1,9 +1,9 @@
-#ifndef LIBS_LIBC_SRC_INCLUDE_SYS_CALLS_FD_H_
-#define LIBS_LIBC_SRC_INCLUDE_SYS_CALLS_FD_H_
+#ifndef LIBS_LIBC_SRC_INCLUDE_ALKOS_SYS_FD_H_
+#define LIBS_LIBC_SRC_INCLUDE_ALKOS_SYS_FD_H_
 
+#include "alkos/fd.h"
 #include "defines.h"
 #include "platform.h"
-#include "alkos/fd.h"
 #include "types.h"
 
 BEGIN_DECL_C
@@ -50,6 +50,33 @@ FAST_CALL ssize_t WriteToFd(fd_t fd, const void *buf, size_t count)
     return __platform_write(fd, buf, count);
 }
 
+/**
+ * @brief Seek to a position in a file descriptor
+ * @param fd File descriptor to seek
+ * @param offset Offset to seek to
+ * @param whence Reference point for offset
+ * @return New offset on success, -1 on failure
+ */
+FAST_CALL ssize_t SeekFd(fd_t fd, ssize_t offset, FdSeek whence)
+{
+    return __platform_seek(fd, offset, whence);
+}
+
+/**
+ * @brief Duplicate a file descriptor
+ * @param fd File descriptor to duplicate
+ * @return New file descriptor on success, -1 on failure
+ */
+FAST_CALL fd_t DuplicateFd(fd_t fd) { return __platform_dup(fd); }
+
+/**
+ * @brief Duplicate a file descriptor to a specific value
+ * @param old_fd File descriptor to duplicate
+ * @param new_fd Desired new file descriptor value
+ * @return New file descriptor on success, -1 on failure
+ */
+FAST_CALL fd_t DuplicateFdTo(fd_t old_fd, fd_t new_fd) { return __platform_dup_to(old_fd, new_fd); }
+
 END_DECL_C
 
-#endif  // LIBS_LIBC_SRC_INCLUDE_SYS_CALLS_FD_H_
+#endif  // LIBS_LIBC_SRC_INCLUDE_ALKOS_SYS_FD_H_
diff --git a/libs/libc/src/include/alkos/sys/time.h b/libs/libc/src/include/alkos/sys/time.h
index 830203ee..5bc08195 100644
--- a/libs/libc/src/include/alkos/sys/time.h
+++ b/libs/libc/src/include/alkos/sys/time.h
@@ -1,9 +1,9 @@
-#ifndef LIBS_LIBC_INCLUDE_SYS_CALLS_TIME_H_
-#define LIBS_LIBC_INCLUDE_SYS_CALLS_TIME_H_
+#ifndef LIBS_LIBC_SRC_INCLUDE_ALKOS_SYS_TIME_H_
+#define LIBS_LIBC_SRC_INCLUDE_ALKOS_SYS_TIME_H_
 
+#include "alkos/time.h"
 #include "defines.h"
 #include "platform.h"
-#include "alkos/time.h"
 
 // ------------------------------
 // System calls
@@ -58,4 +58,4 @@ WRAP_CALL std::tuple<TimeVal, Timezone> GetClockValueTimezoneSysCall(const Clock
 
 #endif  // __cplusplus
 
-#endif  // LIBS_LIBC_INCLUDE_SYS_CALLS_TIME_H_
+#endif  // LIBS_LIBC_SRC_INCLUDE_ALKOS_SYS_TIME_H_
diff --git a/libs/libc/src/include/alkos/syscall.h b/libs/libc/src/include/alkos/syscall.h
index e169fcbd..4eb26c3a 100644
--- a/libs/libc/src/include/alkos/syscall.h
+++ b/libs/libc/src/include/alkos/syscall.h
@@ -29,6 +29,8 @@ enum SyscallNumber {
     kSysRead,
     kSysWrite,
     kSysSeek,
+    kSysDup,
+    kSysDupTo,
 
     /* Threads, processes */
     kThreadCreate,
diff --git a/libs/libc/src/include/alkos/thread.h b/libs/libc/src/include/alkos/thread.h
index 9dc09491..84594bd7 100644
--- a/libs/libc/src/include/alkos/thread.h
+++ b/libs/libc/src/include/alkos/thread.h
@@ -1,5 +1,5 @@
-#ifndef LIBS_LIBC_SRC_INCLUDE_SYS_THREAD_H_
-#define LIBS_LIBC_SRC_INCLUDE_SYS_THREAD_H_
+#ifndef LIBS_LIBC_SRC_INCLUDE_ALKOS_THREAD_H_
+#define LIBS_LIBC_SRC_INCLUDE_ALKOS_THREAD_H_
 
 #include <defines.h>
 #include <stdbool.h>
@@ -17,4 +17,4 @@ typedef struct {
     ThreadFlags flags;
 } Thread;
 
-#endif  // LIBS_LIBC_SRC_INCLUDE_SYS_THREAD_H_
+#endif  // LIBS_LIBC_SRC_INCLUDE_ALKOS_THREAD_H_
diff --git a/libs/libc/src/include/alkos/time.h b/libs/libc/src/include/alkos/time.h
index 22b272e9..a3d3c202 100644
--- a/libs/libc/src/include/alkos/time.h
+++ b/libs/libc/src/include/alkos/time.h
@@ -1,5 +1,5 @@
-#ifndef LIBS_LIBC_SRC_INCLUDE_SYS_TIME_H_
-#define LIBS_LIBC_SRC_INCLUDE_SYS_TIME_H_
+#ifndef LIBS_LIBC_SRC_INCLUDE_ALKOS_TIME_H_
+#define LIBS_LIBC_SRC_INCLUDE_ALKOS_TIME_H_
 
 #include <stdint.h>
 #include <types.h>
@@ -31,4 +31,4 @@ typedef struct {
     u64 remainder;
 } TimeVal;
 
-#endif  // LIBS_LIBC_SRC_INCLUDE_SYS_TIME_H_
+#endif  // LIBS_LIBC_SRC_INCLUDE_ALKOS_TIME_H_
diff --git a/libs/libc/src/include/assert.h b/libs/libc/src/include/assert.h
index 36a75b8e..e75f440e 100644
--- a/libs/libc/src/include/assert.h
+++ b/libs/libc/src/include/assert.h
@@ -1,5 +1,5 @@
-#ifndef LIBS_LIBC_INCLUDE_ASSERT_H_
-#define LIBS_LIBC_INCLUDE_ASSERT_H_
+#ifndef LIBS_LIBC_SRC_INCLUDE_ASSERT_H_
+#define LIBS_LIBC_SRC_INCLUDE_ASSERT_H_
 
 #include "platform.h"
 #include "todo.h"
@@ -103,4 +103,4 @@
 
 #endif  // __cplusplus
 
-#endif  // LIBS_LIBC_INCLUDE_ASSERT_H_
+#endif  // LIBS_LIBC_SRC_INCLUDE_ASSERT_H_
diff --git a/libs/libc/src/include/defines.h b/libs/libc/src/include/defines.h
index 5521ff28..2c0549b8 100644
--- a/libs/libc/src/include/defines.h
+++ b/libs/libc/src/include/defines.h
@@ -1,5 +1,5 @@
-#ifndef LIBS_LIBC_INCLUDE_DEFINES_H_
-#define LIBS_LIBC_INCLUDE_DEFINES_H_
+#ifndef LIBS_LIBC_SRC_INCLUDE_DEFINES_H_
+#define LIBS_LIBC_SRC_INCLUDE_DEFINES_H_
 
 // ------------------------------
 // C++ defines
@@ -45,9 +45,15 @@ static constexpr bool kIsKernel = false;
 /* Marks a function or variable as unused */
 #define UNUSED __attribute__((unused))
 
+/* Marks a function or variable as used (prevents removal) */
+#define USED __attribute__((used))
+
 /* Marks a function as naked (no prologue/epilogue) */
 #define NAKED __attribute__((naked))
 
+/* Marks a variable or function to be placed in a specific section */
+#define SECTION(name) __attribute__((section(#name)))
+
 // ------------------------------
 // Useful macros
 // ------------------------------
@@ -90,4 +96,4 @@ static constexpr bool kIsKernel = false;
 #define CONSTEXPR static inline
 #endif  // __cplusplus
 
-#endif  // LIBS_LIBC_INCLUDE_DEFINES_H_
+#endif  // LIBS_LIBC_SRC_INCLUDE_DEFINES_H_
diff --git a/libs/libc/src/include/errno.h b/libs/libc/src/include/errno.h
index eb2a7e03..26a3ec4f 100644
--- a/libs/libc/src/include/errno.h
+++ b/libs/libc/src/include/errno.h
@@ -1,5 +1,5 @@
-#ifndef LIBS_LIBC_INCLUDE_ERRNO_H_
-#define LIBS_LIBC_INCLUDE_ERRNO_H_
+#ifndef LIBS_LIBC_SRC_INCLUDE_ERRNO_H_
+#define LIBS_LIBC_SRC_INCLUDE_ERRNO_H_
 
 #include <defines.h>
 #include <todo.h>
@@ -120,4 +120,4 @@ END_DECL_C
 #define EWOULDBLOCK     EAGAIN        /* Operation would block */
 #define EXDEV           __cast_er(79) /* Cross-device link */
 
-#endif  // LIBS_LIBC_INCLUDE_ERRNO_H_
+#endif  // LIBS_LIBC_SRC_INCLUDE_ERRNO_H_
diff --git a/libs/libc/src/include/libssp.h b/libs/libc/src/include/libssp.h
index 85d77c49..554bb375 100644
--- a/libs/libc/src/include/libssp.h
+++ b/libs/libc/src/include/libssp.h
@@ -1,5 +1,5 @@
-#ifndef LIBS_LIBC_INCLUDE_LIBSSP_H_
-#define LIBS_LIBC_INCLUDE_LIBSSP_H_
+#ifndef LIBS_LIBC_SRC_INCLUDE_LIBSSP_H_
+#define LIBS_LIBC_SRC_INCLUDE_LIBSSP_H_
 
 #include <defines.h>
 
@@ -7,4 +7,4 @@ BEGIN_DECL_C
 void __stack_chk_init();
 END_DECL_C
 
-#endif  // LIBS_LIBC_INCLUDE_LIBSSP_H_
+#endif  // LIBS_LIBC_SRC_INCLUDE_LIBSSP_H_
diff --git a/libs/libc/src/include/math/checks.h b/libs/libc/src/include/math/checks.h
index 061c8840..f021686e 100644
--- a/libs/libc/src/include/math/checks.h
+++ b/libs/libc/src/include/math/checks.h
@@ -1,5 +1,5 @@
-#ifndef LIBS_LIBC_INCLUDE_MATH_CHECKS_H_
-#define LIBS_LIBC_INCLUDE_MATH_CHECKS_H_
+#ifndef LIBS_LIBC_SRC_INCLUDE_MATH_CHECKS_H_
+#define LIBS_LIBC_SRC_INCLUDE_MATH_CHECKS_H_
 
 #include <defines.h>
 #include <stdint.h>
@@ -20,4 +20,4 @@ CONSTEXPR int isinf(const double num)
 
 END_DECL_C
 
-#endif  // LIBS_LIBC_INCLUDE_MATH_CHECKS_H_
+#endif  // LIBS_LIBC_SRC_INCLUDE_MATH_CHECKS_H_
diff --git a/libs/libc/src/include/math/operations.hpp b/libs/libc/src/include/math/operations.hpp
index 41172b80..498cce3f 100644
--- a/libs/libc/src/include/math/operations.hpp
+++ b/libs/libc/src/include/math/operations.hpp
@@ -1,5 +1,5 @@
-#ifndef LIBS_LIBC_INCLUDE_MATH_OPERATIONS_HPP_
-#define LIBS_LIBC_INCLUDE_MATH_OPERATIONS_HPP_
+#ifndef LIBS_LIBC_SRC_INCLUDE_MATH_OPERATIONS_HPP_
+#define LIBS_LIBC_SRC_INCLUDE_MATH_OPERATIONS_HPP_
 
 #include <defines.h>
 #include <stdint.h>
@@ -16,4 +16,4 @@ CONSTEXPR double fabs(const double num)
 
 END_DECL_C
 
-#endif  // LIBS_LIBC_INCLUDE_MATH_OPERATIONS_HPP_
+#endif  // LIBS_LIBC_SRC_INCLUDE_MATH_OPERATIONS_HPP_
diff --git a/libs/libc/src/include/stdio.h b/libs/libc/src/include/stdio.h
index a959b9ef..f6a5dd6f 100644
--- a/libs/libc/src/include/stdio.h
+++ b/libs/libc/src/include/stdio.h
@@ -8,11 +8,16 @@
 #include "stddef.h"
 
 #define BUFSIZ 4096
+#define EOF    (-1)
 
 #define _IOFBF kFdBufferFull
 #define _IOLBF kFdBufferLine
 #define _IONBF kFdBufferNone
 
+#define SEEK_SET kFdSeekSet
+#define SEEK_CUR kFdSeekCurrent
+#define SEEK_END kFdSeekEnd
+
 typedef struct {
     // File descriptor
     fd_t fd;  // Underlying file descriptor
@@ -42,11 +47,19 @@ BEGIN_DECL_C
  *  Writes formatted output to a character array (*str) up to a maximum amount of characters (size)
  */
 int snprintf(char *str, size_t size, const char *format, ...);
+int vsnprintf(char *str, size_t size, const char *format, va_list va);
 
 /**
- *  Writes formatted data from a variable argument list (va) to a sized buffer (str, size)
+ *  Writes formatted output to a FILE pointer (stream)
  */
-int vsnprintf(char *str, size_t size, const char *format, va_list va);
+int fprintf(FILE *stream, const char *format, ...);
+int vfprintf(FILE *stream, const char *format, va_list va);
+
+/**
+ *  Writes formatted output to standard output (stdout)
+ */
+int printf(const char *format, ...);
+int vprintf(const char *format, va_list va);
 
 /**
  *  Opens a file and returns a FILE pointer
@@ -68,10 +81,43 @@ size_t fread(void *buf, size_t size, size_t count, FILE *stream);
  */
 size_t fwrite(const void *buf, size_t size, size_t count, FILE *stream);
 
-// Standard file streams
-extern FILE *stdin;
-extern FILE *stdout;
-extern FILE *stderr;
+/**
+ *  Flushes the output buffer of a FILE pointer
+ */
+int fflush(FILE *stream);
+
+/**
+ *  Sets the buffering mode for a FILE pointer
+ */
+int setvbuf(FILE *stream, char *buf, int mode, size_t size);
+
+/**
+ *  Sets the position of the FILE pointer
+ */
+int fseek(FILE *stream, long offset, int whence);
+
+/**
+ *  Tests the error indicator for the given stream
+ */
+int ferror(FILE *stream);
+
+/**
+ *  Tests the end-of-file indicator for the given stream
+ */
+int feof(FILE *stream);
+
+/**
+ *  Clears the end-of-file and error indicators for the given stream
+ */
+void clearerr(FILE *stream);
+
+// Standard streams
+extern FILE _stdin;
+extern FILE _stdout;
+extern FILE _stderr;
+#define stdin  (&_stdin)
+#define stdout (&_stdout)
+#define stderr (&_stderr)
 
 END_DECL_C
 
diff --git a/libs/libc/src/include/stdlib.h b/libs/libc/src/include/stdlib.h
index 484675fb..bfe8866d 100644
--- a/libs/libc/src/include/stdlib.h
+++ b/libs/libc/src/include/stdlib.h
@@ -1,5 +1,5 @@
-#ifndef LIBS_LIBC_INCLUDE_STDLIB_H_
-#define LIBS_LIBC_INCLUDE_STDLIB_H_
+#ifndef LIBS_LIBC_SRC_INCLUDE_STDLIB_H_
+#define LIBS_LIBC_SRC_INCLUDE_STDLIB_H_
 
 #include <defines.h>
 #include <stddef.h>
@@ -16,4 +16,4 @@ CONSTEXPR intmax_t imaxabs(const intmax_t n) { return n < 0 ? -n : n; }
 
 END_DECL_C
 
-#endif  // LIBS_LIBC_INCLUDE_STDLIB_H_
+#endif  // LIBS_LIBC_SRC_INCLUDE_STDLIB_H_
diff --git a/libs/libc/src/include/string.h b/libs/libc/src/include/string.h
index 07ff09b9..86986ff7 100644
--- a/libs/libc/src/include/string.h
+++ b/libs/libc/src/include/string.h
@@ -1,5 +1,5 @@
-#ifndef LIBS_LIBC_INCLUDE_STRING_H_
-#define LIBS_LIBC_INCLUDE_STRING_H_
+#ifndef LIBS_LIBC_SRC_INCLUDE_STRING_H_
+#define LIBS_LIBC_SRC_INCLUDE_STRING_H_
 
 #include <defines.h>
 #include <stddef.h>
@@ -110,4 +110,4 @@ int memcmp(const void *s1, const void *s2, size_t n);
 
 END_DECL_C
 
-#endif  // LIBS_LIBC_INCLUDE_STRING_H_
+#endif  // LIBS_LIBC_SRC_INCLUDE_STRING_H_
diff --git a/libs/libc/src/include/todo.h b/libs/libc/src/include/todo.h
index 4a1bd829..d773b90a 100644
--- a/libs/libc/src/include/todo.h
+++ b/libs/libc/src/include/todo.h
@@ -1,8 +1,9 @@
-#ifndef LIBS_LIBC_INCLUDE_TODO_H_
-#define LIBS_LIBC_INCLUDE_TODO_H_
+#ifndef LIBS_LIBC_SRC_INCLUDE_TODO_H_
+#define LIBS_LIBC_SRC_INCLUDE_TODO_H_
 
 /* Should be adjusted when userspace version of libc is implemented */
 #define TODO_USERSPACE
+#define TODO_USERSPACE_MEMORY_MANAGEMENT
 
 /* should be changed when kernel allows querying clocks */
 #define TODO_CLOCKS
@@ -33,4 +34,4 @@
 
 #define TODO_RANDOM
 
-#endif  // LIBS_LIBC_INCLUDE_TODO_H_
+#endif  // LIBS_LIBC_SRC_INCLUDE_TODO_H_
diff --git a/libs/libc/src/internal/crt0.cpp b/libs/libc/src/internal/crt0.cpp
new file mode 100644
index 00000000..b8a05e16
--- /dev/null
+++ b/libs/libc/src/internal/crt0.cpp
@@ -0,0 +1,31 @@
+/**
+ * @file crt0.cpp
+ * @brief C Runtime Startup (CRT0) for userspace programs
+ */
+
+#include "defines.h"
+#include "internal/stdio.hpp"
+
+BEGIN_DECL_C
+
+extern int main();
+
+/**
+ * @brief Program entry point
+ */
+USED NO_RET SECTION(.text.start) void _start()
+{
+    InitStdio();             // Initialize standard I/O streams
+    const int res = main();  // Call the user program's main function
+
+    // TODO : Handle program exit properly
+    __platform_proc_exit(res);  // Not implemented
+    while (true) {
+        size_t i = 0;
+        for (i = 0; i < 1'000'000;) {
+            ++i;
+        }
+    }
+}
+
+END_DECL_C
diff --git a/libs/libc/src/internal/debug.hpp b/libs/libc/src/internal/debug.hpp
index 66354601..cd2088c7 100644
--- a/libs/libc/src/internal/debug.hpp
+++ b/libs/libc/src/internal/debug.hpp
@@ -1,5 +1,5 @@
-#ifndef LIBS_LIBC_INTERNAL_DEBUG_HPP_
-#define LIBS_LIBC_INTERNAL_DEBUG_HPP_
+#ifndef LIBS_LIBC_SRC_INTERNAL_DEBUG_HPP_
+#define LIBS_LIBC_SRC_INTERNAL_DEBUG_HPP_
 
 #include <autogen/feature_flags.h>
 #include <todo.hpp>
@@ -57,4 +57,4 @@ void FormatTrace(const char *format, Args... args)
 #define TRACE_SUCCESS(message, ...) \
     TRACE(TRACE_FORMAT_SUCCESS(message), 0ull __VA_OPT__(, ) __VA_ARGS__)
 
-#endif  // LIBS_LIBC_INTERNAL_DEBUG_HPP_
+#endif  // LIBS_LIBC_SRC_INTERNAL_DEBUG_HPP_
diff --git a/libs/libc/src/internal/entry.hpp b/libs/libc/src/internal/entry.hpp
deleted file mode 100644
index a1d57323..00000000
--- a/libs/libc/src/internal/entry.hpp
+++ /dev/null
@@ -1,27 +0,0 @@
-#ifndef LIBS_LIBC_SRC_INTERNAL_ENTRY_HPP_
-#define LIBS_LIBC_SRC_INTERNAL_ENTRY_HPP_
-
-#include "defines.h"
-#include "internal/stdio.hpp"
-
-BEGIN_DECL_C
-
-extern int main();
-
-/**
- * @brief Entry point to initialize C runtime
- *
- * This function initializes standard I/O streams and then calls the main function.
- */
-void _start()
-{
-    // Initialize standard I/O streams
-    InitStdio();
-
-    // Call main function
-    main();
-}
-
-END_DECL_C
-
-#endif  // LIBS_LIBC_SRC_INTERNAL_ENTRY_HPP_
diff --git a/libs/libc/src/internal/libc_backend.cpp b/libs/libc/src/internal/libc_backend.cpp
index cd6ec8e1..1988e3de 100644
--- a/libs/libc/src/internal/libc_backend.cpp
+++ b/libs/libc/src/internal/libc_backend.cpp
@@ -1,6 +1,5 @@
 #ifndef __ALKOS_KERNEL__
 
-#include "alkos/calls.h"
 #include "alkos/structs.h"
 #include "platform.h"
 
@@ -17,11 +16,13 @@ DEFINE_SYSCALL_VOID(write_console, kSysWriteConsole, const char *, buffer)
 
 DEFINE_SYSCALL_VOID(panic, kSysPanic, const char *, msg)
 
-DEFINE_SYSCALL(open, kSysOpen, int, const char *, pathname, int, flags)
+DEFINE_SYSCALL(open, kSysOpen, fd_t, const char *, pathname, int, flags)
 DEFINE_SYSCALL(close, kSysClose, int, fd_t, fd)
 DEFINE_SYSCALL(read, kSysRead, ssize_t, fd_t, fd, void *, buf, size_t, count)
 DEFINE_SYSCALL(write, kSysWrite, ssize_t, fd_t, fd, const void *, buf, size_t, count)
 DEFINE_SYSCALL(seek, kSysSeek, ssize_t, fd_t, fd, ssize_t, offset, FdSeek, whence)
+DEFINE_SYSCALL(dup, kSysDup, fd_t, fd_t, fd)
+DEFINE_SYSCALL(dup_to, kSysDupTo, fd_t, fd_t, old_fd, fd_t, new_fd)
 
 /* Thread, processes */
 DEFINE_SYSCALL(thread_create, kThreadCreate, int, Thread *, thread, thread_func_t, f, void *, arg)
diff --git a/libs/libc/src/internal/macro.hpp b/libs/libc/src/internal/macro.hpp
index 86abb687..a7a16b32 100644
--- a/libs/libc/src/internal/macro.hpp
+++ b/libs/libc/src/internal/macro.hpp
@@ -1,5 +1,5 @@
-#ifndef LIBS_LIBC_INTERNAL_MACRO_HPP_
-#define LIBS_LIBC_INTERNAL_MACRO_HPP_
+#ifndef LIBS_LIBC_SRC_INTERNAL_MACRO_HPP_
+#define LIBS_LIBC_SRC_INTERNAL_MACRO_HPP_
 
 // https://www.scs.stanford.edu/~dm/blog/va-opt.html
 #define PARENS      ()
@@ -14,28 +14,28 @@
 
 #define FOR_EACH(macro, ...) __VA_OPT__(EXPAND(FOR_EACH_HELPER(macro, __VA_ARGS__)))
 #define FOR_EACH_HELPER(macro, a1, ...) \
-macro(a1) __VA_OPT__(, FOR_EACH_AGAIN PARENS(macro, __VA_ARGS__))
+    macro(a1) __VA_OPT__(, FOR_EACH_AGAIN PARENS(macro, __VA_ARGS__))
 #define FOR_EACH_AGAIN() FOR_EACH_HELPER
 
 #define FOR_EACH_PAIR_SEP(sep, macro, ...) \
-__VA_OPT__(EXPAND(FOR_EACH_PAIR_SEP_HELPER(sep, macro, __VA_ARGS__)))
+    __VA_OPT__(EXPAND(FOR_EACH_PAIR_SEP_HELPER(sep, macro, __VA_ARGS__)))
 #define FOR_EACH_PAIR_SEP_HELPER(sep, macro, a1, a2, ...) \
-macro(a1, a2) __VA_OPT__(sep PARENS FOR_EACH_PAIR_SEP_AGAIN PARENS(sep, macro, __VA_ARGS__))
+    macro(a1, a2) __VA_OPT__(sep PARENS FOR_EACH_PAIR_SEP_AGAIN PARENS(sep, macro, __VA_ARGS__))
 #define FOR_EACH_PAIR_SEP_AGAIN() FOR_EACH_PAIR_SEP_HELPER
 
 #define FOR_EACH_PAIR(macro, ...) FOR_EACH_PAIR_SEP(COMMA, macro, __VA_ARGS__)
 
 #define FOR_EACH_PAIR_CTX_SEP(sep, macro, ctx, ...) \
-__VA_OPT__(EXPAND(FOR_EACH_PAIR_CTX_SEP_HELPER(sep, macro, ctx, __VA_ARGS__)))
+    __VA_OPT__(EXPAND(FOR_EACH_PAIR_CTX_SEP_HELPER(sep, macro, ctx, __VA_ARGS__)))
 #define FOR_EACH_PAIR_CTX_SEP_HELPER(sep, macro, ctx, a1, a2, ...) \
-macro(ctx, a1, a2)                                             \
-__VA_OPT__(sep PARENS FOR_EACH_PAIR_CTX_SEP_AGAIN PARENS(sep, macro, ctx, __VA_ARGS__))
+    macro(ctx, a1, a2)                                             \
+        __VA_OPT__(sep PARENS FOR_EACH_PAIR_CTX_SEP_AGAIN PARENS(sep, macro, ctx, __VA_ARGS__))
 #define FOR_EACH_PAIR_CTX_SEP_AGAIN() FOR_EACH_PAIR_CTX_SEP_HELPER
 
 #define FOR_EACH_PAIR_CTX(macro, ctx, ...) FOR_EACH_PAIR_CTX_SEP(COMMA, macro, ctx, __VA_ARGS__)
 
-#define MERGE(x, y) x y
-#define GET_FIRST_ARG(x, y) x
+#define MERGE(x, y)          x y
+#define GET_FIRST_ARG(x, y)  x
 #define GET_SECOND_ARG(x, y) y
 
-#endif  // LIBS_LIBC_INTERNAL_MACRO_HPP_
+#endif  // LIBS_LIBC_SRC_INTERNAL_MACRO_HPP_
diff --git a/libs/libc/src/internal/stdio.cpp b/libs/libc/src/internal/stdio.cpp
index 157fee0c..e0bba428 100644
--- a/libs/libc/src/internal/stdio.cpp
+++ b/libs/libc/src/internal/stdio.cpp
@@ -1,62 +1,76 @@
 #include "stdio.hpp"
-#include "alkos/sys/fd.h"
-#include "stdio.h"
-#include "string.h"
 
-// Static fixed buffers for standard streams
-static byte _stdin_buffer[BUFSIZ];
-static byte _stdout_buffer[BUFSIZ];
-static byte _stderr_buffer[BUFSIZ];
+// Fixed buffers for standard streams
+byte _stdin_buffer[BUFSIZ];
+byte _stdout_buffer[BUFSIZ];
+byte _stderr_buffer[BUFSIZ];
 
-static FILE _stdin;
-static FILE _stdout;
-static FILE _stderr;
+FILE _stdin;
+FILE _stdout;
+FILE _stderr;
 
-FILE *stdin  = &_stdin;
-FILE *stdout = &_stdout;
-FILE *stderr = &_stderr;
+// FILE allocator pool
+static FileNode file_pool[FILE_POOL_SIZE];
+static FileNode *free_list        = nullptr;
+static bool allocator_initialized = false;
 
-void InitStdio()
+/**
+ * @brief Initialize the FILE allocator
+ */
+static void InitFileAllocator()
 {
-    memset(&_stdin, 0, sizeof(FILE));
-    _stdin.fd                    = kFdStdIn;
-    _stdin.flags.open_mode       = kFdFlagRead;
-    _stdin.flags.buffer_mode     = kFdBufferLine;
-    _stdin.flags.eof             = false;
-    _stdin.flags.error           = false;
-    _stdin.flags.closed          = false;
-    _stdin.flags.is_buffer_owner = false;
-    _stdin.buffer                = _stdin_buffer;
-    _stdin.buffer_size           = sizeof(_stdin_buffer);
-    _stdin.buffer_pos            = 0;
-    _stdin.buffer_level          = 0;
-    _stdin.file_pos              = 0;
-
-    memset(&_stdout, 0, sizeof(FILE));
-    _stdout.fd                    = kFdStdOut;
-    _stdout.flags.open_mode       = kFdFlagWrite;
-    _stdout.flags.buffer_mode     = kFdBufferLine;
-    _stdout.flags.eof             = false;
-    _stdout.flags.error           = false;
-    _stdout.flags.closed          = false;
-    _stdout.flags.is_buffer_owner = false;
-    _stdout.buffer                = _stdout_buffer;
-    _stdout.buffer_size           = sizeof(_stdout_buffer);
-    _stdout.buffer_pos            = 0;
-    _stdout.buffer_level          = 0;
-    _stdout.file_pos              = 0;
-
-    memset(&_stderr, 0, sizeof(FILE));
-    _stderr.fd                    = kFdStdErr;
-    _stderr.flags.open_mode       = kFdFlagWrite;
-    _stderr.flags.buffer_mode     = kFdBufferNone;
-    _stderr.flags.eof             = false;
-    _stderr.flags.error           = false;
-    _stderr.flags.closed          = false;
-    _stderr.flags.is_buffer_owner = false;
-    _stderr.buffer                = _stderr_buffer;
-    _stderr.buffer_size           = sizeof(_stderr_buffer);
-    _stderr.buffer_pos            = 0;
-    _stderr.buffer_level          = 0;
-    _stderr.file_pos              = 0;
+    if (allocator_initialized) {
+        return;
+    }
+
+    // Build the free list
+    for (size_t i = 0; i < FILE_POOL_SIZE - 1; i++) {
+        file_pool[i].next = &file_pool[i + 1];
+    }
+    file_pool[FILE_POOL_SIZE - 1].next = nullptr;
+
+    free_list             = &file_pool[0];
+    allocator_initialized = true;
+}
+
+FILE *AllocFile()
+{
+    if (!allocator_initialized) {
+        InitFileAllocator();
+    }
+
+    if (free_list == nullptr) {
+        // Pool exhausted
+        return nullptr;
+    }
+
+    // Pop from free list
+    FileNode *node = free_list;
+    free_list      = node->next;
+
+    // Clear the FILE structure
+    memset(&node->file, 0, sizeof(FILE));
+
+    return &node->file;
+}
+
+void FreeFile(FILE *file)
+{
+    if (file == nullptr) {
+        return;
+    }
+
+    // Ensure we only free files from our pool
+    if (file < &file_pool[0].file || file > &file_pool[FILE_POOL_SIZE - 1].file) {
+        // Not from our pool (might be stdin/stdout/stderr or invalid)
+        return;
+    }
+
+    // Find the containing FileNode
+    // Since FILE is the first member of FileNode, we can cast directly
+    FileNode *node = reinterpret_cast<FileNode *>(file);
+
+    // Push back to free list
+    node->next = free_list;
+    free_list  = node;
 }
diff --git a/libs/libc/src/internal/stdio.hpp b/libs/libc/src/internal/stdio.hpp
index 8e6406fd..56bdd2b5 100644
--- a/libs/libc/src/internal/stdio.hpp
+++ b/libs/libc/src/internal/stdio.hpp
@@ -1,9 +1,89 @@
 #ifndef LIBS_LIBC_SRC_INTERNAL_STDIO_HPP_
 #define LIBS_LIBC_SRC_INTERNAL_STDIO_HPP_
 
+#include "stdio.h"
+#include "string.h"
+#include "todo.h"
+
+// Forward declarations
+extern byte _stdin_buffer[BUFSIZ];
+extern byte _stdout_buffer[BUFSIZ];
+extern byte _stderr_buffer[BUFSIZ];
+
+extern FILE _stdin;
+extern FILE _stdout;
+extern FILE _stderr;
+
+TODO_USERSPACE_MEMORY_MANAGEMENT
+// FILE allocator constants
+#define FILE_POOL_SIZE 32  // Maximum number of simultaneously open files
+
+/**
+ * @brief Node for FILE free list
+ */
+struct FileNode {
+    FILE file;
+    FileNode *next;
+};
+
+/**
+ * @brief Allocate a FILE structure from the internal pool
+ * @return Pointer to FILE structure, or nullptr if pool is exhausted
+ */
+FILE *AllocFile();
+
+/**
+ * @brief Free a FILE structure back to the internal pool
+ * @param file Pointer to FILE structure to free
+ */
+void FreeFile(FILE *file);
+
 /**
  * @brief Initialize standard I/O streams
  */
-void InitStdio();
+FORCE_INLINE_F void InitStdio()
+{
+    memset(&_stdin, 0, sizeof(FILE));
+    _stdin.fd                    = kFdStdIn;
+    _stdin.flags.open_mode       = kFdFlagRead;
+    _stdin.flags.buffer_mode     = kFdBufferLine;
+    _stdin.flags.eof             = false;
+    _stdin.flags.error           = false;
+    _stdin.flags.closed          = false;
+    _stdin.flags.is_buffer_owner = false;
+    _stdin.buffer                = _stdin_buffer;
+    _stdin.buffer_size           = sizeof(_stdin_buffer);
+    _stdin.buffer_pos            = 0;
+    _stdin.buffer_level          = 0;
+    _stdin.file_pos              = 0;
+
+    memset(&_stdout, 0, sizeof(FILE));
+    _stdout.fd                    = kFdStdOut;
+    _stdout.flags.open_mode       = kFdFlagWrite;
+    _stdout.flags.buffer_mode     = kFdBufferLine;
+    _stdout.flags.eof             = false;
+    _stdout.flags.error           = false;
+    _stdout.flags.closed          = false;
+    _stdout.flags.is_buffer_owner = false;
+    _stdout.buffer                = _stdout_buffer;
+    _stdout.buffer_size           = sizeof(_stdout_buffer);
+    _stdout.buffer_pos            = 0;
+    _stdout.buffer_level          = 0;
+    _stdout.file_pos              = 0;
+
+    memset(&_stderr, 0, sizeof(FILE));
+    _stderr.fd                    = kFdStdErr;
+    _stderr.flags.open_mode       = kFdFlagWrite;
+    _stderr.flags.buffer_mode     = kFdBufferNone;
+    _stderr.flags.eof             = false;
+    _stderr.flags.error           = false;
+    _stderr.flags.closed          = false;
+    _stderr.flags.is_buffer_owner = false;
+    _stderr.buffer                = _stderr_buffer;
+    _stderr.buffer_size           = sizeof(_stderr_buffer);
+    _stderr.buffer_pos            = 0;
+    _stderr.buffer_level          = 0;
+    _stderr.file_pos              = 0;
+}
 
 #endif  // LIBS_LIBC_SRC_INTERNAL_STDIO_HPP_
diff --git a/libs/libc/src/internal/time_internal.hpp b/libs/libc/src/internal/time_internal.hpp
index 9d4d9d70..56d5e2a4 100644
--- a/libs/libc/src/internal/time_internal.hpp
+++ b/libs/libc/src/internal/time_internal.hpp
@@ -1,5 +1,5 @@
-#ifndef LIBS_LIBC_INTERNAL_TIME_INTERNAL_HPP_
-#define LIBS_LIBC_INTERNAL_TIME_INTERNAL_HPP_
+#ifndef LIBS_LIBC_SRC_INTERNAL_TIME_INTERNAL_HPP_
+#define LIBS_LIBC_SRC_INTERNAL_TIME_INTERNAL_HPP_
 
 #include <stdint.h>
 
@@ -7,4 +7,4 @@
 
 [[nodiscard]] uint64_t __GetDstTimezoneOffsetNs();
 
-#endif  // LIBS_LIBC_INTERNAL_TIME_INTERNAL_HPP_
+#endif  // LIBS_LIBC_SRC_INTERNAL_TIME_INTERNAL_HPP_
diff --git a/libs/libc/src/io/stdio.cpp b/libs/libc/src/io/stdio.cpp
new file mode 100644
index 00000000..f86d7c8d
--- /dev/null
+++ b/libs/libc/src/io/stdio.cpp
@@ -0,0 +1,496 @@
+#include "stdio.h"
+#include "internal/stdio.hpp"
+
+#include <assert.h>
+#include <algorithm.hpp>
+
+#include "platform.h"
+#include "string.h"
+
+// ============================================================================
+// Helper Functions
+// ============================================================================
+
+/**
+ * @brief Flush the internal buffer of a FILE stream
+ * @param stream The FILE stream to flush
+ * @return 0 on success, EOF on error
+ */
+static int FlushBuffer(FILE *stream)
+{
+    if (stream == nullptr) {
+        return EOF;
+    }
+
+    // If buffer is empty or stream is not writable, nothing to do
+    if (stream->buffer_pos == 0) {
+        return 0;
+    }
+
+    if (!(stream->flags.open_mode & kFdFlagWrite)) {
+        return 0;
+    }
+
+    // Write the buffered data
+    ssize_t written = WriteToFd(stream->fd, stream->buffer, stream->buffer_pos);
+    if (written < 0) {
+        stream->flags.error = true;
+        return EOF;
+    }
+
+    // Update file position and reset buffer
+    stream->file_pos += written;
+    stream->buffer_pos = 0;
+
+    return 0;
+}
+
+/**
+ * @brief Parse file open mode string
+ * @param mode Mode string (e.g., "r", "w", "a", "r+", etc.)
+ * @param flags Output parameter for open flags
+ * @return true if mode is valid, false otherwise
+ */
+static bool ParseMode(const char *mode, FdOpenFlags *flags)
+{
+    if (mode == nullptr || flags == nullptr) {
+        return false;
+    }
+
+    *flags = static_cast<FdOpenFlags>(0);
+
+    switch (mode[0]) {
+        case 'r':
+            *flags = kFdFlagRead;
+            if (mode[1] == '+') {
+                *flags = kFdFlagReadWrite;
+            }
+            break;
+        case 'w':
+            *flags = static_cast<FdOpenFlags>(kFdFlagWrite | kFdFlagCreate | kFdFlagTruncate);
+            if (mode[1] == '+') {
+                *flags =
+                    static_cast<FdOpenFlags>(kFdFlagReadWrite | kFdFlagCreate | kFdFlagTruncate);
+            }
+            break;
+        case 'a':
+            *flags = static_cast<FdOpenFlags>(kFdFlagWrite | kFdFlagCreate | kFdFlagAppend);
+            if (mode[1] == '+') {
+                *flags = static_cast<FdOpenFlags>(kFdFlagReadWrite | kFdFlagCreate | kFdFlagAppend);
+            }
+            break;
+        default:
+            return false;
+    }
+
+    return true;
+}
+
+// ============================================================================
+// Formatted Output Functions
+// ============================================================================
+
+int fprintf(FILE *stream, const char *format, ...)
+{
+    if (stream == nullptr || format == nullptr) {
+        return -1;
+    }
+
+    va_list args;
+    va_start(args, format);
+    int result = vfprintf(stream, format, args);
+    va_end(args);
+
+    return result;
+}
+
+int vfprintf(FILE *stream, const char *format, va_list va)
+{
+    if (stream == nullptr || format == nullptr) {
+        return -1;
+    }
+
+    // Format the string into a buffer
+    static constexpr size_t kTempBufferSize = 2048;
+    char buffer[kTempBufferSize];
+    const int len = vsnprintf(buffer, sizeof(buffer), format, va);
+    if (len < 0) {
+        return len;
+    }
+
+    // Write the formatted string to the stream
+    const size_t written =
+        fwrite(buffer, 1, std::min(static_cast<size_t>(len), kTempBufferSize), stream);
+    return static_cast<int>(written);
+}
+
+int printf(const char *format, ...)
+{
+    if (format == nullptr) {
+        return -1;
+    }
+
+    va_list args;
+    va_start(args, format);
+    int result = vprintf(format, args);
+    va_end(args);
+
+    return result;
+}
+
+int vprintf(const char *format, va_list va) { return vfprintf(stdout, format, va); }
+
+// ============================================================================
+// File Operations
+// ============================================================================
+
+FILE *fopen(const char *pathname, const char *mode)
+{
+    if (pathname == nullptr || mode == nullptr) {
+        return nullptr;
+    }
+
+    // Parse the mode string
+    FdOpenFlags flags;
+    if (!ParseMode(mode, &flags)) {
+        return nullptr;
+    }
+
+    // Allocate a FILE structure
+    FILE *file = AllocFile();
+    if (file == nullptr) {
+        return nullptr;
+    }
+
+    // Open the file
+    fd_t fd = OpenFd(pathname, flags);
+    if (fd < 0) {
+        return nullptr;
+    }
+
+    // Initialize the FILE structure
+    file->fd                    = fd;
+    file->flags.open_mode       = flags;
+    file->flags.buffer_mode     = kFdBufferNone;  // TODO: Add buffering support
+    file->flags.eof             = false;
+    file->flags.error           = false;
+    file->flags.closed          = false;
+    file->flags.is_buffer_owner = false;
+    file->file_pos              = 0;
+
+    // Note: Buffer allocation is handled by the caller via setvbuf if needed
+    // Default to unbuffered for now
+    TODO_USERSPACE_MEMORY_MANAGEMENT
+    file->buffer       = nullptr;
+    file->buffer_size  = 0;
+    file->buffer_pos   = 0;
+    file->buffer_level = 0;
+
+    return file;
+}
+
+int fclose(FILE *stream)
+{
+    if (stream == nullptr) {
+        return EOF;
+    }
+
+    // Don't close standard streams
+    if (stream == stdin || stream == stdout || stream == stderr) {
+        return EOF;
+    }
+
+    if (stream->flags.closed) {
+        return EOF;
+    }
+
+    // Flush any buffered data
+    if (stream->flags.open_mode & kFdFlagWrite) {
+        if (FlushBuffer(stream) != 0) {
+            stream->flags.error = true;
+        }
+    }
+
+    // Close the file descriptor
+    int result = CloseFd(stream->fd);
+    if (result < 0) {
+        stream->flags.error = true;
+    }
+
+    // Note: Buffer management is left to the caller
+    // We don't free buffers here since we don't own them
+
+    // Mark as closed
+    stream->flags.closed = true;
+
+    // Free the FILE structure
+    FreeFile(stream);
+
+    return (stream->flags.error) ? EOF : 0;
+}
+
+// ============================================================================
+// Read/Write Operations
+// ============================================================================
+
+size_t fread(void *buf, size_t size, size_t count, FILE *stream)
+{
+    if (buf == nullptr || stream == nullptr || size == 0 || count == 0) {
+        return 0;
+    }
+
+    if (stream->flags.closed || stream->flags.eof) {
+        return 0;
+    }
+
+    if (!(stream->flags.open_mode & kFdFlagRead)) {
+        stream->flags.error = true;
+        return 0;
+    }
+
+    size_t total_bytes = size * count;
+    size_t bytes_read  = 0;
+    byte *dest         = static_cast<byte *>(buf);
+
+    // If unbuffered, read directly
+    if (stream->flags.buffer_mode == kFdBufferNone || stream->buffer == nullptr) {
+        ssize_t result = ReadFromFd(stream->fd, dest, total_bytes);
+        if (result < 0) {
+            stream->flags.error = true;
+            return 0;
+        }
+        if (result == 0) {
+            stream->flags.eof = true;
+        }
+        stream->file_pos += result;
+        return result / size;
+    }
+
+    // Buffered read
+    while (bytes_read < total_bytes) {
+        // If buffer has data, copy it
+        if (stream->buffer_level > 0) {
+            size_t available = stream->buffer_level;
+            size_t to_copy =
+                (total_bytes - bytes_read < available) ? (total_bytes - bytes_read) : available;
+            memcpy(dest + bytes_read, stream->buffer + stream->buffer_pos, to_copy);
+            stream->buffer_pos += to_copy;
+            stream->buffer_level -= to_copy;
+            bytes_read += to_copy;
+        } else {
+            // Buffer is empty, refill it
+            ssize_t result = ReadFromFd(stream->fd, stream->buffer, stream->buffer_size);
+            if (result < 0) {
+                stream->flags.error = true;
+                break;
+            }
+            if (result == 0) {
+                stream->flags.eof = true;
+                break;
+            }
+            stream->buffer_pos   = 0;
+            stream->buffer_level = result;
+            stream->file_pos += result;
+        }
+    }
+
+    return bytes_read / size;
+}
+
+size_t fwrite(const void *buf, size_t size, size_t count, FILE *stream)
+{
+    if (buf == nullptr || stream == nullptr || size == 0 || count == 0) {
+        return 0;
+    }
+
+    if (stream->flags.closed) {
+        return 0;
+    }
+
+    if (!(stream->flags.open_mode & kFdFlagWrite)) {
+        stream->flags.error = true;
+        return 0;
+    }
+
+    size_t total_bytes   = size * count;
+    size_t bytes_written = 0;
+    const byte *src      = static_cast<const byte *>(buf);
+
+    // If unbuffered, write directly
+    if (stream->flags.buffer_mode == kFdBufferNone || stream->buffer == nullptr) {
+        ssize_t result = WriteToFd(stream->fd, src, total_bytes);
+        if (result < 0) {
+            stream->flags.error = true;
+            return 0;
+        }
+        stream->file_pos += result;
+        return result / size;
+    }
+
+    // Buffered write
+    while (bytes_written < total_bytes) {
+        size_t remaining    = total_bytes - bytes_written;
+        size_t buffer_space = stream->buffer_size - stream->buffer_pos;
+
+        if (buffer_space > 0) {
+            size_t to_copy = (remaining < buffer_space) ? remaining : buffer_space;
+            memcpy(stream->buffer + stream->buffer_pos, src + bytes_written, to_copy);
+            stream->buffer_pos += to_copy;
+            bytes_written += to_copy;
+
+            // Check for line buffering - flush on newline
+            if (stream->flags.buffer_mode == kFdBufferLine) {
+                for (size_t i = 0; i < to_copy; i++) {
+                    if (src[bytes_written - to_copy + i] == '\n') {
+                        if (FlushBuffer(stream) != 0) {
+                            stream->flags.error = true;
+                            return bytes_written / size;
+                        }
+                        break;
+                    }
+                }
+            }
+        }
+
+        // If buffer is full, flush it
+        if (stream->buffer_pos >= stream->buffer_size) {
+            if (FlushBuffer(stream) != 0) {
+                stream->flags.error = true;
+                break;
+            }
+        }
+    }
+
+    // For full buffering, let the buffer fill naturally
+    // For line buffering, flushing is already handled above
+    // For no buffering, we wrote directly
+
+    return bytes_written / size;
+}
+
+int fflush(FILE *stream)
+{
+    // If stream is NULL, flush all open streams
+    if (stream == nullptr) {
+        // Flush stdout and stderr
+        int result = 0;
+        if (FlushBuffer(stdout) != 0) {
+            result = EOF;
+        }
+        if (FlushBuffer(stderr) != 0) {
+            result = EOF;
+        }
+        return result;
+    }
+
+    return FlushBuffer(stream);
+}
+
+// ============================================================================
+// Buffer Control
+// ============================================================================
+
+int setvbuf(FILE *stream, char *buf, int mode, size_t size)
+{
+    if (stream == nullptr) {
+        return -1;
+    }
+
+    if (mode != _IOFBF && mode != _IOLBF && mode != _IONBF) {
+        return -1;
+    }
+
+    // Flush existing buffer
+    if (stream->flags.open_mode & kFdFlagWrite) {
+        FlushBuffer(stream);
+    }
+
+    // Reset buffer state
+    stream->buffer_pos   = 0;
+    stream->buffer_level = 0;
+
+    // Set up new buffer
+    stream->flags.buffer_mode = static_cast<FdBufferMode>(mode);
+    if (mode == _IONBF) {
+        // No buffering
+        stream->buffer                = nullptr;
+        stream->buffer_size           = 0;
+        stream->flags.is_buffer_owner = false;
+    } else if (buf != nullptr) {
+        // User-provided buffer
+        stream->buffer                = reinterpret_cast<byte *>(buf);
+        stream->buffer_size           = size;
+        stream->flags.is_buffer_owner = false;
+    } else {
+        TODO_USERSPACE_MEMORY_MANAGEMENT
+        R_FAIL_ALWAYS("NOT IMPLEMENTED!");
+    }
+
+    return 0;
+}
+
+// ============================================================================
+// File Positioning
+// ============================================================================
+
+int fseek(FILE *stream, long offset, int whence)
+{
+    if (stream == nullptr) {
+        return -1;
+    }
+
+    if (stream->flags.closed) {
+        return -1;
+    }
+
+    if (whence != kFdSeekSet && whence != kFdSeekCurrent && whence != kFdSeekEnd) {
+        return -1;
+    }
+
+    // Flush write buffer before seeking
+    if (stream->flags.open_mode & kFdFlagWrite) {
+        if (FlushBuffer(stream) != 0) {
+            return -1;
+        }
+    }
+
+    // Invalidate read buffer
+    stream->buffer_pos   = 0;
+    stream->buffer_level = 0;
+
+    ssize_t result = __platform_seek(stream->fd, offset, static_cast<FdSeek>(whence));
+    if (result < 0) {
+        stream->flags.error = true;
+        return -1;
+    }
+
+    stream->file_pos  = result;
+    stream->flags.eof = false;
+
+    return 0;
+}
+
+int ferror(FILE *stream)
+{
+    if (stream == nullptr) {
+        return 0;
+    }
+    return stream->flags.error ? 1 : 0;
+}
+
+int feof(FILE *stream)
+{
+    if (stream == nullptr) {
+        return 0;
+    }
+    return stream->flags.eof ? 1 : 0;
+}
+
+void clearerr(FILE *stream)
+{
+    if (stream == nullptr) {
+        return;
+    }
+    stream->flags.error = false;
+    stream->flags.eof   = false;
+}
diff --git a/libs/libcontainers/include/data_structures/ref_count.hpp b/libs/libcontainers/include/data_structures/ref_count.hpp
index c193956d..470385fa 100644
--- a/libs/libcontainers/include/data_structures/ref_count.hpp
+++ b/libs/libcontainers/include/data_structures/ref_count.hpp
@@ -184,8 +184,6 @@ class RefPtr
     NODISCARD bool operator!=(const RefPtr &other) const noexcept { return ptr_ != other.ptr_; }
     NODISCARD bool operator==(T *ptr) const noexcept { return ptr_ == ptr; }
     NODISCARD bool operator!=(T *ptr) const noexcept { return ptr_ != ptr; }
-    NODISCARD bool operator==(std::nullptr_t) const noexcept { return ptr_ == nullptr; }
-    NODISCARD bool operator!=(std::nullptr_t) const noexcept { return ptr_ != nullptr; }
 
     private:
     T *ptr_;
diff --git a/libs/libcpp/include/concepts_ext.hpp b/libs/libcpp/include/concepts_ext.hpp
index 3e5974b7..2387c8fd 100644
--- a/libs/libcpp/include/concepts_ext.hpp
+++ b/libs/libcpp/include/concepts_ext.hpp
@@ -30,6 +30,7 @@ template <class T>
 concept LibCxxCompatibleMutex = requires(T m) {
     { m.lock() } -> std::same_as<void>;
     { m.unlock() } -> std::same_as<void>;
+    { m.try_lock() } -> std::same_as<bool>;
 };
 }  // namespace concepts_ext
 
diff --git a/toolchains/x86_64-conf.cmake b/toolchains/x86_64-conf.cmake
index 6903b780..c5aa40b0 100644
--- a/toolchains/x86_64-conf.cmake
+++ b/toolchains/x86_64-conf.cmake
@@ -32,6 +32,8 @@ elseif (CMAKE_BUILD_TYPE STREQUAL "Release" OR CMAKE_BUILD_TYPE STREQUAL "RELEAS
 
     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${RELEASE_FLAGS}")
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${RELEASE_FLAGS}")
+
+    add_definitions(-DNDEBUG)
 else ()
     message(FATAL_ERROR "UNKNOWN BUILD TYPE: ${CMAKE_BUILD_TYPE}")
 endif ()
diff --git a/userspace/CMakeLists.txt b/userspace/CMakeLists.txt
index 6e74cca4..cc36f1f5 100644
--- a/userspace/CMakeLists.txt
+++ b/userspace/CMakeLists.txt
@@ -6,10 +6,34 @@ alkos_add_to_bash_config("CONF_USERSPACE_BIN_DIR" "${USERSPACE_BIN_DIR}")
 
 set(USER_LINKER_SCRIPT "${CMAKE_CURRENT_SOURCE_DIR}/build/linker.ld")
 
-# Create the Userspace Standard Library (libc)
+################################################################################
+# CRT0 - C Runtime Startup Object Library
+################################################################################
+#
+# The CRT0 (C Runtime 0) contains the _start entry point for userspace programs.
+# It MUST be compiled as a separate OBJECT library and linked FIRST to ensure
+# that _start is placed at the program's base address.
+#
+add_library(crt0.userspace OBJECT
+    "${CMAKE_SOURCE_DIR}/libs/libc/src/internal/crt0.cpp"
+)
+target_link_libraries(crt0.userspace PUBLIC alkos.libc.interface)
+target_compile_options(crt0.userspace PRIVATE
+    $<$<COMPILE_LANGUAGE:CXX>:
+        -fno-builtin
+        -fno-rtti
+        -fno-exceptions
+        -fno-stack-protector
+        -mcmodel=small
+        -mno-red-zone
+    >
+)
+
+################################################################################
+# Userspace Standard Library (libc)
+################################################################################
 add_library(c.userspace STATIC ${ALKOS_LIBC_SOURCES})
 target_link_libraries(c.userspace PUBLIC alkos.libc.interface gcc)
-
 target_compile_options(c.userspace PRIVATE
     $<$<COMPILE_LANGUAGE:CXX>:
         -fno-builtin
@@ -45,8 +69,11 @@ function(alkos_register_userspace_app PROG_NAME SRC_FILES)
         -z max-page-size=0x1000
         -static
     )
-
-    target_link_libraries(${PROG_NAME} PRIVATE c.userspace)
+    
+    target_link_libraries(${PROG_NAME} PRIVATE
+        crt0.userspace
+        c.userspace
+    )
 
     add_custom_command(TARGET ${PROG_NAME} POST_BUILD
         COMMAND ${CMAKE_COMMAND} -E copy $<TARGET_FILE:${PROG_NAME}> ${USERSPACE_BIN_DIR}/${PROG_NAME}
diff --git a/userspace/build/linker.ld b/userspace/build/linker.ld
index ae5a1d6c..087429f1 100644
--- a/userspace/build/linker.ld
+++ b/userspace/build/linker.ld
@@ -1,3 +1,10 @@
+/**
+ * Userspace Program Linker Script
+ *
+ * This linker script defines the memory layout for AlkOS userspace programs.
+ * The entry point (_start from crt0.o) is guaranteed to be at address 0x400000.
+ */
+
 ENTRY(_start)
 
 SECTIONS
@@ -6,19 +13,24 @@ SECTIONS
     . = 0x400000;
 
     .text : ALIGN(4K) {
+        KEEP(*(.text._start))
         *(.text)
+        *(.text.*)
     }
 
     .rodata : ALIGN(4K) {
         *(.rodata)
+        *(.rodata.*)
     }
 
     .data : ALIGN(4K) {
         *(.data)
+        *(.data.*)
     }
 
     .bss : ALIGN(4K) {
         *(COMMON)
         *(.bss)
+        *(.bss.*)
     }
 }
diff --git a/userspace/programs/hello_world/main.cpp b/userspace/programs/hello_world/main.cpp
index 8cc0e175..91f0150a 100644
--- a/userspace/programs/hello_world/main.cpp
+++ b/userspace/programs/hello_world/main.cpp
@@ -1,15 +1,5 @@
-#include <alkos/calls.h>
-#include <platform.h>
 #include <stdio.h>
 
-template <typename... Args>
-void printf(const char *format, Args... args)
-{
-    char buffer[256];
-    snprintf(buffer, sizeof(buffer), format, args...);
-    __platform_debug_write(buffer);
-}
-
 extern "C" int main()
 {
     printf(
@@ -18,50 +8,37 @@ extern "C" int main()
         "----------------------------------\n"
     );
 
-    printf("Formatting Test: %d + %d = %d\n", 2, 2, 4);
-
-    Timezone tz;
-    __platform_get_timezone(&tz);
-    printf("Timezone offset (minutes): %d\n", tz.west_offset_minutes);
-
-    u64 ticks = __platform_get_clock_ticks_in_second(kTimeUtc);
-    printf("Ticks per second (UTC): %llu\n", ticks);
-
-    TimeVal tv;
-    __platform_get_clock_value(kTimeUtc, &tv, &tz);
-    printf("Current Timestamp: %llu\n", tv.seconds);
-
-    char buffer[64]{};
-    fd_t fd = __platform_open("/docs/greet.txt", kFdFlagReadWrite);
-    if (fd < 3) {
-        printf("KWorker failed to open /docs/greet.txt for reading!");
+    FILE *fp = fopen("/docs/greet.txt", "r+");
+    if (!fp) {
+        printf("Failed to open /docs/greet.txt for reading!\n");
+        return 1;
     }
 
-    int len         = snprintf(buffer, sizeof(buffer), "Hello AlkOS from User Space!");
-    ssize_t written = __platform_write(fd, buffer, len);
-    if (written == -1) {
-        printf("KWorker failed to write to /docs/greet.txt!");
+    int written = fprintf(fp, "Hello AlkOS from User Space!");
+    if (written < 0) {
+        printf("Failed to write to /docs/greet.txt!\n");
+        fclose(fp);
+        return 1;
     }
 
-    ssize_t pos = __platform_seek(fd, 0, kFdSeekSet);
-    if (pos == -1) {
-        printf("KWorker failed to seek to start of /docs/greet.txt!");
+    if (fseek(fp, 0, SEEK_SET) != 0) {
+        printf("Failed to seek to start of /docs/greet.txt!\n");
+        fclose(fp);
+        return 1;
     }
 
-    ssize_t read = __platform_read(fd, buffer, 64);
-    if (read == -1) {
-        printf("KWorker failed to read from /docs/greet.txt!");
+    char buffer[128];
+    size_t bytes_read = fread(buffer, 1, sizeof(buffer) - 1, fp);
+    if (bytes_read == 0 && ferror(fp)) {
+        printf("Failed to read from /docs/greet.txt!\n");
+        fclose(fp);
+        return 1;
     }
+    buffer[bytes_read] = '\0';
 
-    printf("KWorker: '%.*s'", static_cast<int>(written), buffer);
+    printf("Read from file: '%s'\n", buffer);
 
-    while (true) {
-        static size_t kSpins = 1'000'000;
-        size_t counter       = 0;
-        for (size_t i = 0; i < kSpins; i++) {
-            ++counter;
-        }
-    }
+    fclose(fp);
 
     return 0;
 }

From 5bea91cdf175f8b60622ed64906f54c5a49e0ab2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C5=81ukasz=20Kryczka?=
 <60490378+kryczkal@users.noreply.github.com>
Date: Sat, 3 Jan 2026 18:09:28 +0100
Subject: [PATCH 42/56] Kryczkal/window manager (#264)

---
 kernel/src/drivers/input/ps2_keyboard.cpp  |   5 +
 kernel/src/drivers/input/ps2_keyboard.hpp  |   1 +
 kernel/src/drivers/video/framebuffer.cpp   |  33 ++--
 kernel/src/drivers/video/framebuffer.hpp   |  25 ++-
 kernel/src/mem/virt/vmm.cpp                |  29 ++++
 kernel/src/mem/virt/vmm.hpp                |   4 +
 kernel/src/modules/video.cpp               |   7 +-
 kernel/src/modules/video.hpp               |  12 +-
 kernel/src/scheduling/process.hpp          |   2 +
 kernel/src/scheduling/task_mgr.cpp         |  11 +-
 kernel/src/syscalls/calls/video.hpp        |  68 +++++++++
 kernel/src/syscalls/syscalls.cpp           |   4 +
 kernel/src/syscalls/syscalls.hpp           |  22 ++-
 kernel/src/video/window_manager.cpp        | 167 +++++++++++++++++++++
 kernel/src/video/window_manager.hpp        |  67 +++++++++
 libs/libc/src/abi/platform.h               |   5 +
 libs/libc/src/include/alkos/syscall.h      |   4 +
 libs/libc/src/include/alkos/video.h        |  30 ++++
 libs/libc/src/internal/libc_backend.cpp    |   4 +
 tests/libcpp_mocks/defines.hpp             |   2 +-
 userspace/programs/gui_test/CMakeLists.txt |   3 +
 userspace/programs/gui_test/main.cpp       |  59 ++++++++
 22 files changed, 512 insertions(+), 52 deletions(-)
 create mode 100644 kernel/src/syscalls/calls/video.hpp
 create mode 100644 kernel/src/video/window_manager.cpp
 create mode 100644 kernel/src/video/window_manager.hpp
 create mode 100644 libs/libc/src/include/alkos/video.h
 create mode 100644 userspace/programs/gui_test/CMakeLists.txt
 create mode 100644 userspace/programs/gui_test/main.cpp

diff --git a/kernel/src/drivers/input/ps2_keyboard.cpp b/kernel/src/drivers/input/ps2_keyboard.cpp
index 0ad891da..2647deac 100644
--- a/kernel/src/drivers/input/ps2_keyboard.cpp
+++ b/kernel/src/drivers/input/ps2_keyboard.cpp
@@ -1,4 +1,5 @@
 #include "drivers/input/ps2_keyboard.hpp"
+#include "modules/video.hpp"
 #include "trace_framework.hpp"
 
 namespace Drivers::Input
@@ -128,6 +129,10 @@ void Ps2Keyboard::OnInterrupt()
             return;
         }
 
+        if (scancode == kScanCodeTab) {
+            VideoModule::Get().GetWindowManager().SwitchToNextSession();
+        }
+
         // Handle Make Code (Key Press)
         if (scancode == kScancodeLeftShift || scancode == kScancodeRightShift) {
             shift_pressed_ = true;
diff --git a/kernel/src/drivers/input/ps2_keyboard.hpp b/kernel/src/drivers/input/ps2_keyboard.hpp
index 15806463..e611f948 100644
--- a/kernel/src/drivers/input/ps2_keyboard.hpp
+++ b/kernel/src/drivers/input/ps2_keyboard.hpp
@@ -48,6 +48,7 @@ class Ps2Keyboard final : public Keyboard
     static constexpr u8 kScancodeLeftShift      = 0x2A;
     static constexpr u8 kScancodeRightShift     = 0x36;
     static constexpr u8 kScancodeCapsLock       = 0x3A;
+    static constexpr u8 kScanCodeTab            = 0x0F;
 
     static constexpr int kResetTimeout = 1000000;
 
diff --git a/kernel/src/drivers/video/framebuffer.cpp b/kernel/src/drivers/video/framebuffer.cpp
index ce9f8a95..2d9789a0 100644
--- a/kernel/src/drivers/video/framebuffer.cpp
+++ b/kernel/src/drivers/video/framebuffer.cpp
@@ -1,35 +1,28 @@
 #include "drivers/video/framebuffer.hpp"
 #include "defines.hpp"
 #include "graphics/native_pixel.hpp"
-#include "mem/heap.hpp"
 #include "trace_framework.hpp"
 
 using namespace Drivers::Video;
 
-void Framebuffer::Init(Graphics::Surface s, Graphics::PixelFormat pf, Mem::Heap &hp)
+void Framebuffer::Init(Graphics::Surface s, Graphics::PixelFormat pf)
 {
     front_surface_ = s;
     format_        = pf;
+}
 
-    // Backbuffer allocation
-    size_t width       = front_surface_.GetWidth();
-    size_t height      = front_surface_.GetHeight();
-    size_t buffer_size = width * height * sizeof(Graphics::NativePixel);
-
-    auto alloc_res = hp.Malloc(buffer_size);
-    if (!alloc_res) {
-        TRACE_WARN_VIDEO("Backbuffer allocation failed, running in single-buffer mode");
-        return;
-    }
-
-    backbuffer_mem_ = static_cast<Mem::VPtr<Graphics::NativePixel>>(*alloc_res);
-    back_surface_ =
-        Graphics::Surface(backbuffer_mem_, width, height, width * sizeof(Graphics::NativePixel));
+FramebufferInfo Framebuffer::GetInfo() const
+{
+    return FramebufferInfo{
+        .width  = front_surface_.GetWidth(),
+        .height = front_surface_.GetHeight(),
+        .pitch  = front_surface_.GetPitch(),
+        .format = format_
+    };
 }
 
-void Framebuffer::Flush()
+size_t Framebuffer::CalculateSize() const
 {
-    if (back_surface_.IsValid()) {
-        front_surface_.CopyFrom(back_surface_);
-    }
+    // Return size matching the framebuffer layout (including pitch)
+    return static_cast<size_t>(front_surface_.GetPitch()) * front_surface_.GetHeight();
 }
diff --git a/kernel/src/drivers/video/framebuffer.hpp b/kernel/src/drivers/video/framebuffer.hpp
index 6456e650..b60a7255 100644
--- a/kernel/src/drivers/video/framebuffer.hpp
+++ b/kernel/src/drivers/video/framebuffer.hpp
@@ -10,31 +10,30 @@
 namespace Drivers::Video
 {
 
+struct FramebufferInfo {
+    size_t width;
+    size_t height;
+    size_t pitch;
+    Graphics::PixelFormat format;
+};
+
 class Framebuffer
 {
     public:
     Framebuffer() = default;
 
-    void Init(Graphics::Surface s, Graphics::PixelFormat pf, Mem::Heap &hp);
-
-    // Swap the backbuffer to the front (physical) buffer
-    void Flush();
+    void Init(Graphics::Surface s, Graphics::PixelFormat pf);
 
     // Accessors
-    NODISCARD Graphics::Surface &GetSurface()
-    {
-        return back_surface_.IsValid() ? back_surface_ : front_surface_;
-    }
-    NODISCARD Graphics::Surface &GetFrontSurface() { return front_surface_; }
+    NODISCARD Graphics::Surface &GetSurface() { return front_surface_; }
     NODISCARD const Graphics::PixelFormat &GetFormat() const { return format_; }
 
+    NODISCARD FramebufferInfo GetInfo() const;
+    NODISCARD size_t CalculateSize() const;
+
     private:
     Graphics::Surface front_surface_{};  // Physical VRAM
-    Graphics::Surface back_surface_{};   // RAM Buffer
     Graphics::PixelFormat format_{};
-
-    // We own the backbuffer memory
-    Mem::VPtr<Graphics::NativePixel> backbuffer_mem_{nullptr};
 };
 
 }  // namespace Drivers::Video
diff --git a/kernel/src/mem/virt/vmm.cpp b/kernel/src/mem/virt/vmm.cpp
index 76471bdb..a175b4ae 100644
--- a/kernel/src/mem/virt/vmm.cpp
+++ b/kernel/src/mem/virt/vmm.cpp
@@ -170,4 +170,33 @@ expected<VPtr<void>, MemError> Vmm::AllocKernelHeap(size_t size)
     return AllocAnonymous(&kernel_as_, size, flags, kernel_start, nullptr);
 }
 
+expected<VPtr<void>, MemError> Vmm::MapUserBackbuffer(
+    VPtr<AddressSpace> as, PPtr<void> buffer, size_t size_bytes
+)
+{
+    R_ASSERT_TRUE(IsAligned(buffer, hal::kPageSizeBytes));
+    size_t al_size = AlignUp(size_bytes, hal::kPageSizeBytes);
+
+    auto gap_res = as->FindGap(
+        al_size, UptrToPtr<void>(kUserSpaceStart), UptrToPtr<void>(kUserSpaceEndExclusive)
+    );
+    RET_UNEXPECTED_IF_ERR(gap_res);
+
+    VMemAreaFlags flags{.readable = true, .writable = true, .executable = true};
+    auto vma_res = KNew<DirectMappingVMemArea>(gap_res->start, gap_res->size, flags, buffer);
+    RET_UNEXPECTED_IF(!vma_res, MemError::OutOfMemory);
+    auto *vma = *vma_res;
+
+    template_lib::ScopeGuard vma_guard([&]() {
+        KDelete(vma);
+    });
+
+    auto add_res = as->AddArea(vma);
+    RET_UNEXPECTED_IF_ERR(add_res);
+
+    vma_guard.dismiss();
+
+    return gap_res->start;
+}
+
 }  // namespace Mem
diff --git a/kernel/src/mem/virt/vmm.hpp b/kernel/src/mem/virt/vmm.hpp
index 36ff9d06..58c0d451 100644
--- a/kernel/src/mem/virt/vmm.hpp
+++ b/kernel/src/mem/virt/vmm.hpp
@@ -66,6 +66,10 @@ class VirtualMemoryManager
 
     expected<VPtr<void>, MemError> AllocKernelHeap(size_t size);
 
+    expected<VPtr<void>, MemError> MapUserBackbuffer(
+        VPtr<AddressSpace> as, PPtr<void> buffer, size_t size_bytes
+    );
+
     private:
     // ------------------------------
     // Class fields
diff --git a/kernel/src/modules/video.cpp b/kernel/src/modules/video.cpp
index 56d646b3..98411f60 100644
--- a/kernel/src/modules/video.cpp
+++ b/kernel/src/modules/video.cpp
@@ -27,11 +27,12 @@ internal::VideoModule::VideoModule(const BootArguments &args, Heap &hp) noexcept
         .blue_mask_size  = fb_args.blue_mask_size,
     };
 
-    Framebuffer_.Init(s, pf, hp);
-    Graphics::Surface &screen = GetScreen();
+    Framebuffer_.Init(s, pf);
+    Graphics::Surface &screen = Framebuffer_.GetSurface();
     R_ASSERT_TRUE(screen.IsValid());
 
     Graphics::Painter p(screen, Framebuffer_.GetFormat());
     p.Clear(Graphics::Color::Black());
-    Flush();
+
+    WindowManager_.Init(Framebuffer_);
 }
diff --git a/kernel/src/modules/video.hpp b/kernel/src/modules/video.hpp
index cdfa5639..37c25c37 100644
--- a/kernel/src/modules/video.hpp
+++ b/kernel/src/modules/video.hpp
@@ -6,6 +6,7 @@
 #include "boot_args.hpp"
 #include "drivers/video/framebuffer.hpp"
 #include "modules/helpers.hpp"
+#include "video/window_manager.hpp"
 
 namespace internal
 {
@@ -15,16 +16,9 @@ class VideoModule : template_lib::StaticSingletonHelper
     protected:
     explicit VideoModule(const BootArguments &args, Mem::Heap &hp) noexcept;
 
-    DEFINE_MODULE_FIELD(Drivers::Video, Framebuffer);
-
     public:
-    /// Returns the Surface for the physical screen
-    Graphics::Surface &GetScreen() { return Framebuffer_.GetSurface(); }
-
-    /// Returns the format required by the hardware (used to init Painters)
-    const Graphics::PixelFormat &GetFormat() const { return Framebuffer_.GetFormat(); }
-
-    void Flush() { Framebuffer_.Flush(); }
+    DEFINE_MODULE_FIELD(Drivers::Video, Framebuffer);
+    DEFINE_MODULE_FIELD(Video, WindowManager);
 };
 
 }  // namespace internal
diff --git a/kernel/src/scheduling/process.hpp b/kernel/src/scheduling/process.hpp
index bdb0430f..4d6f4dc5 100644
--- a/kernel/src/scheduling/process.hpp
+++ b/kernel/src/scheduling/process.hpp
@@ -26,6 +26,8 @@ namespace Sched
 struct PACK Pid {
     u16 id;
     u64 count : 48;
+
+    bool operator==(const Pid &other) const = default;
 };
 
 struct PACK ProcessFlags {
diff --git a/kernel/src/scheduling/task_mgr.cpp b/kernel/src/scheduling/task_mgr.cpp
index 8a31e7c6..96fd9e7d 100644
--- a/kernel/src/scheduling/task_mgr.cpp
+++ b/kernel/src/scheduling/task_mgr.cpp
@@ -31,7 +31,7 @@ void TaskMgr::InitializeMultitasking()
     R_ASSERT_TRUE(static_cast<bool>(result), "Failed to spawn trace dumper process...");
 
     // Spawn 3 Kernel Workers
-    static constexpr size_t kNumKWorkers = 3;
+    static constexpr size_t kNumKWorkers = 0;
     for (size_t i = 0; i < kNumKWorkers; ++i) {
         char name[] = "kworker-0";
 
@@ -47,6 +47,15 @@ void TaskMgr::InitializeMultitasking()
             "Created initial Kernel Worker process with Pid: %llu", result.value().get<0>()
         );
     }
+
+    const auto res1 = ExecuteElf64("/bin/gui_test", {});
+    R_ASSERT_TRUE(static_cast<bool>(res1), "Failed to spawn /bin/hello process...");
+
+    for (volatile size_t i = 0; i < 1'000'000; i = i + 1) {
+    }
+
+    const auto res2 = ExecuteElf64("/bin/gui_test", {});
+    R_ASSERT_TRUE(static_cast<bool>(res2), "Failed to spawn /bin/hello process...");
 }
 
 std::expected<Pid, Error> TaskMgr::SpawnEmptyProcess(const char *name, const ProcessFlags flags)
diff --git a/kernel/src/syscalls/calls/video.hpp b/kernel/src/syscalls/calls/video.hpp
new file mode 100644
index 00000000..c10093b5
--- /dev/null
+++ b/kernel/src/syscalls/calls/video.hpp
@@ -0,0 +1,68 @@
+#ifndef KERNEL_SRC_SYSCALLS_CALLS_VIDEO_HPP_
+#define KERNEL_SRC_SYSCALLS_CALLS_VIDEO_HPP_
+
+#include <alkos/video.h>
+#include <defines.h>
+#include "hardware/core_local.hpp"
+#include "modules/video.hpp"
+#include "trace_framework.hpp"
+
+namespace Syscall
+{
+
+// ------------------------------
+// Video Syscalls
+// ------------------------------
+
+/**
+ * @brief Registers the current process as a graphics app, allocates a buffer,
+ * maps it to userspace, and fills the info struct.
+ */
+FORCE_INLINE_F void SysCreateGraphicSession(GuiBufferInfo *user_info)
+{
+    if (user_info == nullptr) {
+        return;
+    }
+
+    auto &wm = VideoModule::Get().GetWindowManager();
+    auto &fb = VideoModule::Get().GetFramebuffer();
+
+    // Create Session (Allocates PMM, Maps to VMM)
+    auto result = wm.CreateSession();
+
+    if (result) {
+        // Fill userspace struct
+        user_info->buffer_ptr = *result;
+
+        const auto fb_info = fb.GetInfo();
+        user_info->width   = fb_info.width;
+        user_info->height  = fb_info.height;
+        user_info->pitch   = fb_info.pitch;
+        user_info->bpp     = 32;
+
+        user_info->format.red_pos         = fb_info.format.red_pos;
+        user_info->format.red_mask_size   = fb_info.format.red_mask_size;
+        user_info->format.green_pos       = fb_info.format.green_pos;
+        user_info->format.green_mask_size = fb_info.format.green_mask_size;
+        user_info->format.blue_pos        = fb_info.format.blue_pos;
+        user_info->format.blue_mask_size  = fb_info.format.blue_mask_size;
+    } else {
+        user_info->buffer_ptr = nullptr;
+    }
+}
+
+/**
+ * @brief Copies the current process's backbuffer to the physical screen
+ */
+FORCE_INLINE_F void SysBlit()
+{
+    auto &wm = VideoModule::Get().GetWindowManager();
+    auto pid = hardware::GetRunningPid();
+
+    DEBUG_INFO_GENERAL("SysBlit called by PID: %llu", pid);
+    wm.Blit(pid);
+}
+
+}  // namespace Syscall
+
+#endif  // KERNEL_SRC_SYSCALLS_CALLS_VIDEO_HPP_
diff --git a/kernel/src/syscalls/syscalls.cpp b/kernel/src/syscalls/syscalls.cpp
index a087ef18..d65bca85 100644
--- a/kernel/src/syscalls/syscalls.cpp
+++ b/kernel/src/syscalls/syscalls.cpp
@@ -24,6 +24,10 @@ constinit auto g_syscall_dispatch_table = SyscallDispatchTable<kSysMax>::Create<
     // Panic syscall
     table.RegisterHandler<kSysPanic, SysPanic>();
 
+    // Video
+    table.RegisterHandler<kSysCreateGraphicSession, SysCreateGraphicSession>();
+    table.RegisterHandler<kSysBlit, SysBlit>();
+
     // File Descriptor syscalls
     table.RegisterHandler<kSysOpen, SysOpen>();
     table.RegisterHandler<kSysClose, SysClose>();
diff --git a/kernel/src/syscalls/syscalls.hpp b/kernel/src/syscalls/syscalls.hpp
index 2d975ef8..db91a4e1 100644
--- a/kernel/src/syscalls/syscalls.hpp
+++ b/kernel/src/syscalls/syscalls.hpp
@@ -1,11 +1,22 @@
 #ifndef KERNEL_SRC_SYSCALLS_SYSCALLS_HPP_
 #define KERNEL_SRC_SYSCALLS_SYSCALLS_HPP_
 
-/**
- * @brief This file collects all the system calls available in the kernel.
- *
- * Calls should be specified in other header files and then included here.
- */
+#include <defines.h>
+#include <types.h>
+
+#include "dispatch_table.hpp"
+#include "hal/debug_terminal.hpp"
+#include "hal/panic.hpp"
+#include "modules/timing.hpp"
+#include "modules/timing_constants.hpp"
+#include "trace_framework.hpp"
+
+#include "hardware/core_local.hpp"
+
+#include <span.hpp>
+#include <sys/shell.hpp>
+
+/* Syscalls */
 
 #include "calls/fd.hpp"
 #include "calls/io.hpp"
@@ -13,5 +24,6 @@
 #include "calls/proc.hpp"
 #include "calls/thread.hpp"
 #include "calls/time.hpp"
+#include "calls/video.hpp"
 
 #endif  // KERNEL_SRC_SYSCALLS_SYSCALLS_HPP_
diff --git a/kernel/src/video/window_manager.cpp b/kernel/src/video/window_manager.cpp
new file mode 100644
index 00000000..3ff8cb87
--- /dev/null
+++ b/kernel/src/video/window_manager.cpp
@@ -0,0 +1,167 @@
+#include "video/window_manager.hpp"
+
+#include <string.h>
+#include <template/scope_guard.hpp>
+
+#include "hardware/core_local.hpp"
+#include "modules/memory.hpp"
+#include "modules/scheduling.hpp"
+#include "trace_framework.hpp"
+
+namespace Video
+{
+
+using namespace Mem;
+
+void WindowManager::Init(Framebuffer &fb)
+{
+    framebuffer_ = &fb;
+    DEBUG_INFO_GENERAL("WindowManager Initialized.");
+}
+
+std::expected<void *, Mem::MemError> WindowManager::CreateSession()
+{
+    auto &vmm = ::MemoryModule::Get().GetVmm();
+    auto &pmm = ::MemoryModule::Get().GetBuddyPmm();
+    auto pid  = hardware::GetRunningPid();
+
+    // Alloc the user buffer
+    auto buffer_res = AllocUserBuffer();
+    RET_UNEXPECTED_IF_ERR(buffer_res);
+    BufferInfo buffer = *buffer_res;
+
+    template_lib::ScopeGuard page_guard([&]() {
+        pmm.Free(buffer.phys_buffer);
+    });
+
+    memset(Mem::PhysToVirt(buffer.phys_buffer), 0, buffer.size_bytes);
+
+    // Map into User Space of the calling process
+    auto proc_res = ::SchedulingModule::Get().GetProcesses().GetProcess(pid);
+    RET_UNEXPECTED_IF(!proc_res, MemError::NotFound);
+    auto *proc = *proc_res;
+
+    auto virt_res =
+        vmm.MapUserBackbuffer(proc->address_space, buffer.phys_buffer, buffer.size_bytes);
+    RET_UNEXPECTED_IF_ERR(virt_res);
+    VPtr<void> virt = *virt_res;
+
+    // Store Session Metadata
+    size_t session_id = RegisterGraphicsSession(pid, buffer);
+
+    // Switch focus to new app immediately
+    SwitchSession(session_id);
+    DEBUG_INFO_GENERAL(
+        "CreateSession: Switched to session %zu. Active is now %zu", session_id, active_session_idx_
+    );
+
+    page_guard.dismiss();
+    return virt;
+}
+
+void WindowManager::SwitchSession(size_t index)
+{
+    if (index >= sessions_.Size()) {
+        return;
+    }
+
+    if (active_session_idx_ == index) {
+        return;
+    }
+
+    DEBUG_INFO_GENERAL(
+        "Switching Session: Old %zu -> New %zu (PID %llu)", active_session_idx_, index,
+        sessions_[index].owner_pid
+    );
+    active_session_idx_ = index;
+    RefreshScreen();
+}
+
+void WindowManager::SwitchToNextSession()
+{
+    size_t new_index = (active_session_idx_ + 1) % sessions_.Size();
+    SwitchSession(new_index);
+}
+
+void WindowManager::RefreshScreen()
+{
+    if (active_session_idx_ == kInvalidSession || active_session_idx_ >= sessions_.Size()) {
+        return;
+    }
+
+    // Restore User App
+    GraphicSession &session = sessions_[active_session_idx_];
+    BlitSession(session);
+}
+
+void WindowManager::Blit(Sched::Pid pid)
+{
+    // Find if this PID owns a session
+    auto [session, target_idx] = FindSession(pid);
+
+    if (!session) {
+        DEBUG_INFO_GENERAL("Blit skipped: No session for PID %llu", pid);
+        return;
+    }
+
+    if (active_session_idx_ != target_idx) {
+        DEBUG_INFO_GENERAL(
+            "Blit skipped: Target %zu != Active %zu", target_idx, active_session_idx_
+        );
+        // If not active, the data is safely sitting in the session.phys_buffer (RAM),
+        // ready to be restored when the user switches back.
+        return;
+    }
+
+    BlitSession(*session);
+}
+
+std::expected<BufferInfo, Mem::MemError> WindowManager::AllocUserBuffer()
+{
+    auto &pmm = ::MemoryModule::Get().GetBuddyPmm();
+
+    ASSERT_NOT_NULL(framebuffer_);
+    size_t buffer_size = framebuffer_->CalculateSize();
+
+    u8 order      = Mem::BuddyPmm::SizeToPageOrder(buffer_size);
+    auto phys_res = pmm.Alloc({.order = order});
+    RET_UNEXPECTED_IF_ERR(phys_res);
+
+    return BufferInfo{.phys_buffer = *phys_res, .size_bytes = buffer_size};
+}
+
+size_t WindowManager::RegisterGraphicsSession(Sched::Pid pid, BufferInfo buffer)
+{
+    GraphicSession session;
+    session.owner_pid   = pid;
+    session.buffer_info = buffer;
+    session.is_active   = false;
+
+    sessions_.Push(session);
+    size_t session_id = sessions_.Size() - 1;
+
+    DEBUG_INFO_GENERAL("Created Graphic Session %zu for PID %llu", session_id, pid);
+    return session_id;
+}
+
+void WindowManager::BlitSession(const GraphicSession &session)
+{
+    ASSERT_NOT_NULL(framebuffer_);
+    auto &screen = framebuffer_->GetSurface();
+
+    VPtr<void> vram_dst             = screen.GetRawBuffer();
+    const VPtr<void> backbuffer_src = Mem::PhysToVirt(session.buffer_info.phys_buffer);
+    memcpy(vram_dst, backbuffer_src, session.buffer_info.size_bytes);
+}
+
+std::tuple<GraphicSession *, size_t> WindowManager::FindSession(Sched::Pid pid)
+{
+    for (size_t i = 0; i < sessions_.Size(); ++i) {
+        if (sessions_[i].owner_pid == pid) {
+            return {&sessions_[i], i};
+        }
+    }
+    return {nullptr, kInvalidSession};
+}
+
+}  // namespace Video
diff --git a/kernel/src/video/window_manager.hpp b/kernel/src/video/window_manager.hpp
new file mode 100644
index 00000000..99554ce6
--- /dev/null
+++ b/kernel/src/video/window_manager.hpp
@@ -0,0 +1,67 @@
+#ifndef KERNEL_SRC_VIDEO_WINDOW_MANAGER_HPP_
+#define KERNEL_SRC_VIDEO_WINDOW_MANAGER_HPP_
+
+#include <types.h>
+#include <data_structures/array_structures.hpp>
+#include <expected.hpp>
+#include <tuple.hpp>
+
+#include "drivers/video/framebuffer.hpp"
+#include "mem/page.hpp"
+#include "mem/types.hpp"
+#include "scheduling/process.hpp"
+
+namespace Video
+{
+
+using Drivers::Video::Framebuffer;
+
+struct BufferInfo {
+    Mem::PPtr<Mem::Page> phys_buffer;
+    size_t size_bytes;
+};
+
+struct GraphicSession {
+    Sched::Pid owner_pid;
+    bool is_active = false;
+
+    /// The backing store (Physical RAM)
+    /// Kernel accesses this via Mem::PhysToVirt to copy to VRAM
+    BufferInfo buffer_info;
+};
+
+class WindowManager
+{
+    public:
+    WindowManager() = default;
+
+    void Init(Framebuffer &fb);
+
+    /// Called by Syscall: Allocates a buffer, maps it to user, registers session
+    std::expected<void *, Mem::MemError> CreateSession();
+
+    /// Called by Syscall: If the caller is the active session, copy buffer to VRAM
+    void Blit(Sched::Pid pid);
+
+    /// Switches screen to a specific session
+    void SwitchSession(size_t index);
+    void SwitchToNextSession();
+
+    private:
+    std::expected<BufferInfo, Mem::MemError> AllocUserBuffer();
+    size_t RegisterGraphicsSession(Sched::Pid pid, BufferInfo buffer);
+    void BlitSession(const GraphicSession &session);
+    std::tuple<GraphicSession *, size_t> FindSession(Sched::Pid pid);
+    void RefreshScreen();
+
+    static constexpr size_t kMaxSessions    = 12;
+    static constexpr size_t kInvalidSession = size_t(-1);
+    data_structures::StaticVector<GraphicSession, kMaxSessions> sessions_;
+
+    size_t active_session_idx_{kInvalidSession};
+    Framebuffer *framebuffer_{nullptr};
+};
+
+}  // namespace Video
+
+#endif  // KERNEL_SRC_VIDEO_WINDOW_MANAGER_HPP_
diff --git a/libs/libc/src/abi/platform.h b/libs/libc/src/abi/platform.h
index eadac7db..cceab4c0 100644
--- a/libs/libc/src/abi/platform.h
+++ b/libs/libc/src/abi/platform.h
@@ -38,6 +38,11 @@ SYSCALL_NAME(thread_detach, kThreadDetach, int, Thread *, thread);
 SYSCALL_VOID_NAME(proc_exit, kProcExit, int, status);
 SYSCALL_VOID_NAME(proc_abort, kProcAbort);
 
+// Video
+struct GuiBufferInfo;
+void __platform_create_graphic_session(struct GuiBufferInfo *info);
+void __platform_blit(void);
+
 END_DECL_C
 
 #endif  // LIBS_LIBC_SRC_ABI_PLATFORM_H_
diff --git a/libs/libc/src/include/alkos/syscall.h b/libs/libc/src/include/alkos/syscall.h
index 4eb26c3a..160e8214 100644
--- a/libs/libc/src/include/alkos/syscall.h
+++ b/libs/libc/src/include/alkos/syscall.h
@@ -23,6 +23,10 @@ enum SyscallNumber {
     /* Panic/Program termination */
     kSysPanic,
 
+    /* Video Syscalls */
+    kSysCreateGraphicSession,
+    kSysBlit,
+
     /* File descriptor syscalls */
     kSysOpen,
     kSysClose,
diff --git a/libs/libc/src/include/alkos/video.h b/libs/libc/src/include/alkos/video.h
new file mode 100644
index 00000000..ca01f72f
--- /dev/null
+++ b/libs/libc/src/include/alkos/video.h
@@ -0,0 +1,30 @@
+#ifndef LIBS_LIBC_SRC_INCLUDE_SYS_VIDEO_H_
+#define LIBS_LIBC_SRC_INCLUDE_SYS_VIDEO_H_
+
+#include <defines.h>
+#include <stddef.h>
+#include <stdint.h>
+
+BEGIN_DECL_C
+
+struct GuiPixelFormat {
+    uint8_t red_pos;
+    uint8_t red_mask_size;
+    uint8_t green_pos;
+    uint8_t green_mask_size;
+    uint8_t blue_pos;
+    uint8_t blue_mask_size;
+};
+
+struct GuiBufferInfo {
+    void *buffer_ptr;  // Virtual address in userspace where buffer is mapped
+    size_t width;
+    size_t height;
+    size_t pitch;  // Bytes per row
+    size_t bpp;    // Bits per pixel (usually 32)
+    struct GuiPixelFormat format;
+};
+
+END_DECL_C
+
+#endif  // LIBS_LIBC_SRC_INCLUDE_SYS_VIDEO_H_
diff --git a/libs/libc/src/internal/libc_backend.cpp b/libs/libc/src/internal/libc_backend.cpp
index 1988e3de..cd0afc19 100644
--- a/libs/libc/src/internal/libc_backend.cpp
+++ b/libs/libc/src/internal/libc_backend.cpp
@@ -1,6 +1,7 @@
 #ifndef __ALKOS_KERNEL__
 
 #include "alkos/structs.h"
+#include "alkos/video.h"
 #include "platform.h"
 
 DEFINE_SYSCALL_VOID(
@@ -16,6 +17,9 @@ DEFINE_SYSCALL_VOID(write_console, kSysWriteConsole, const char *, buffer)
 
 DEFINE_SYSCALL_VOID(panic, kSysPanic, const char *, msg)
 
+DEFINE_SYSCALL_VOID(create_graphic_session, kSysCreateGraphicSession, GuiBufferInfo *, info)
+DEFINE_SYSCALL_VOID(blit, kSysBlit)
+
 DEFINE_SYSCALL(open, kSysOpen, fd_t, const char *, pathname, int, flags)
 DEFINE_SYSCALL(close, kSysClose, int, fd_t, fd)
 DEFINE_SYSCALL(read, kSysRead, ssize_t, fd_t, fd, void *, buf, size_t, count)
diff --git a/tests/libcpp_mocks/defines.hpp b/tests/libcpp_mocks/defines.hpp
index 2a4c40ef..d769b399 100644
--- a/tests/libcpp_mocks/defines.hpp
+++ b/tests/libcpp_mocks/defines.hpp
@@ -8,7 +8,7 @@
 #include <type_traits>
 #include <utility>
 
-#include "types.hpp"
+#include "types.h"
 
 // ------------------------------
 // Environment checks
diff --git a/userspace/programs/gui_test/CMakeLists.txt b/userspace/programs/gui_test/CMakeLists.txt
new file mode 100644
index 00000000..f37614c1
--- /dev/null
+++ b/userspace/programs/gui_test/CMakeLists.txt
@@ -0,0 +1,3 @@
+message(STATUS "  -> gui_test")
+alkos_find_sources(GUI_TEST_SOURCES)
+alkos_register_userspace_app(gui_test "${GUI_TEST_SOURCES}")
diff --git a/userspace/programs/gui_test/main.cpp b/userspace/programs/gui_test/main.cpp
new file mode 100644
index 00000000..09fc99f4
--- /dev/null
+++ b/userspace/programs/gui_test/main.cpp
@@ -0,0 +1,59 @@
+#include <alkos/video.h>
+#include <platform.h>
+#include <stdio.h>
+#include <time.h>
+#include <types.h>
+
+extern "C" int main()
+{
+    __platform_debug_write("Starting GUI Test...\n");
+
+    GuiBufferInfo info = {};
+    __platform_create_graphic_session(&info);
+
+    if (info.buffer_ptr == nullptr) {
+        __platform_debug_write("Failed to create graphics session!\n");
+        return 1;
+    }
+
+    u32 *fb = static_cast<u32 *>(info.buffer_ptr);
+
+    u32 t = static_cast<u32>(time(NULL));
+
+    t ^= t >> 16;
+    t *= 0x85ebca6b;
+    t ^= t >> 13;
+    t *= 0xc2b2ae35;
+    t ^= t >> 16;
+
+    int color_offset = static_cast<int>(t);
+
+    const auto &fmt = info.format;
+
+    while (true) {
+        for (size_t y = 0; y < info.height; ++y) {
+            for (size_t x = 0; x < info.width; ++x) {
+                size_t index = (y * (info.pitch / 4)) + x;
+
+                u8 r = (x + color_offset) & 0xFF;
+                u8 g = (y + color_offset) & 0xFF;
+                u8 b = (x + y) & 0xFF;
+
+                // Construct pixel using format info
+                u32 pixel = 0;
+                pixel |= (static_cast<u32>(r) & ((1 << fmt.red_mask_size) - 1)) << fmt.red_pos;
+                pixel |= (static_cast<u32>(g) & ((1 << fmt.green_mask_size) - 1)) << fmt.green_pos;
+                pixel |= (static_cast<u32>(b) & ((1 << fmt.blue_mask_size) - 1)) << fmt.blue_pos;
+
+                fb[index] = pixel;
+            }
+        }
+
+        // Blit to screen
+        __platform_blit();
+
+        color_offset += 1;
+    }
+
+    return 0;
+}

From aecd675ea5d1b28889dfa5e0c0037cb086cdd221 Mon Sep 17 00:00:00 2001
From: Jakub Lisowski <115403674+Jlisowskyy@users.noreply.github.com>
Date: Sat, 3 Jan 2026 19:06:43 +0100
Subject: [PATCH 43/56] Jlisowskyy/scheduler imprv 2 (#266)

Things done in this PR:
- added policies to scheduler
- added better statistics collection during scheduling
- added thread states
- added instrusive lists
- added bitmap priority queue
---
 kernel/arch/x86_64/src/hal/impl/panic.cpp     |   2 +-
 kernel/arch/x86_64/src/hal/impl/tasks.hpp     |   8 +-
 kernel/arch/x86_64/src/include/thread.nasm    |  36 +--
 kernel/arch/x86_64/src/interrupts/idt.nasm    |   6 +-
 kernel/arch/x86_64/src/kernel/init.cpp        |   2 +-
 .../arch/x86_64/src/scheduling/scheduling.cpp |  36 +--
 kernel/src/hal/api/tasks.hpp                  |  10 -
 kernel/src/scheduling/kworker.cpp             |   5 -
 .../policies/priority_queue_policy.hpp        |  54 +++++
 .../policies/round_robin_policy.hpp           |  50 ++++
 kernel/src/scheduling/policy.hpp              |  78 ++++++
 kernel/src/scheduling/scheduler.cpp           |  80 +++---
 kernel/src/scheduling/scheduler.hpp           |  27 ++-
 kernel/src/scheduling/task_mgr.cpp            |  49 +++-
 kernel/src/scheduling/task_mgr.hpp            |   8 +
 kernel/src/scheduling/thread.hpp              |  50 +++-
 kernel/src/scheduling/threads.cpp             |  11 +
 kernel/src/syscalls/calls/thread.hpp          |   8 +-
 kernel/src/time/event_framework.cpp           |   7 +-
 libs/libc/src/include/assert.h                |   2 +-
 .../include/data_structures/bit_array.hpp     |  48 ++++
 .../data_structures/intrusive_linked_list.hpp | 229 ++++++++++++++++++
 .../priority_queues/bitmap_pq.hpp             | 105 ++++++++
 .../include/data_structures/ref_count.hpp     |   2 +-
 24 files changed, 786 insertions(+), 127 deletions(-)
 delete mode 100644 kernel/src/hal/api/tasks.hpp
 create mode 100644 kernel/src/scheduling/policies/priority_queue_policy.hpp
 create mode 100644 kernel/src/scheduling/policies/round_robin_policy.hpp
 create mode 100644 kernel/src/scheduling/policy.hpp
 create mode 100644 libs/libcontainers/include/data_structures/intrusive_linked_list.hpp
 create mode 100644 libs/libcontainers/include/data_structures/priority_queues/bitmap_pq.hpp

diff --git a/kernel/arch/x86_64/src/hal/impl/panic.cpp b/kernel/arch/x86_64/src/hal/impl/panic.cpp
index d2e8e517..40d5be92 100644
--- a/kernel/arch/x86_64/src/hal/impl/panic.cpp
+++ b/kernel/arch/x86_64/src/hal/impl/panic.cpp
@@ -15,7 +15,7 @@ extern "C" void NO_RET KernelPanic()
         test::OnKernelPanic();
     } else {
         trace::DumpAllBuffersOnFailure();
-        OsHang();
+        OsHangNoInterrupts();
     }
 }
 
diff --git a/kernel/arch/x86_64/src/hal/impl/tasks.hpp b/kernel/arch/x86_64/src/hal/impl/tasks.hpp
index d0b4b8fd..8cd1c9e8 100644
--- a/kernel/arch/x86_64/src/hal/impl/tasks.hpp
+++ b/kernel/arch/x86_64/src/hal/impl/tasks.hpp
@@ -5,16 +5,14 @@
 #include <types.h>
 #include <defines.hpp>
 
-#include "hal/api/tasks.hpp"
-
 namespace arch
 {
 
-struct Thread : ThreadAPI {
-    alignas(64) byte fp_state[4096];
-
+struct Thread {
     u64 fs_base;
     u64 gs_base;
+
+    alignas(64) byte fp_state[4096];
 };
 struct Process {
 };
diff --git a/kernel/arch/x86_64/src/include/thread.nasm b/kernel/arch/x86_64/src/include/thread.nasm
index 4e0ce435..b8f82e76 100644
--- a/kernel/arch/x86_64/src/include/thread.nasm
+++ b/kernel/arch/x86_64/src/include/thread.nasm
@@ -3,19 +3,27 @@
 ; ------------------------------------------------------------
 
 struc Thread
-    .fp_state      resb 4096
-    .fs_base       resq 1
-    .gs_base       resq 1
-    .tid:          resq 1
-    .owner:        resq 1
-    .flags         resq 1
-    .next:         resq 1
-    .kernel_stack: resq 1
-    .kernel_stack_bottom: resq 1
-    .user_stack:   resq 1
-    .user_stack_bottom:   resq 1
+    .next:                  resq 1
 
-    .kernel_time_ns resq 1
-    .user_time_ns   resq 1
-    .timestamp      resq 1
+    .tid:                   resq 1
+    .owner:                 resq 1
+    .flags                  resq 1
+    .state                  resq 1
+    .kernel_stack:          resq 1
+    .kernel_stack_bottom:   resq 1
+    .user_stack:            resq 1
+    .user_stack_bottom:     resq 1
+
+    .kernel_time_ns         resq 1
+    .user_time_ns           resq 1
+    .timestamp              resq 1
+    .num_interrupts         resq 1
+    .num_syscalls           resq 1
+    .num_context_switches   resq 1
+    .padding0               resb 8
+
+    .fs_base                resq 1
+    .gs_base                resq 1
+    .padding1               resb 48
+    .fp_state               resb 4096
 endstruc
diff --git a/kernel/arch/x86_64/src/interrupts/idt.nasm b/kernel/arch/x86_64/src/interrupts/idt.nasm
index 01d6800c..bbae3b29 100644
--- a/kernel/arch/x86_64/src/interrupts/idt.nasm
+++ b/kernel/arch/x86_64/src/interrupts/idt.nasm
@@ -134,10 +134,10 @@ isr_wrapper_128:  ; Syscall interrupt (128)
     jae .invalid_syscall
 
     swapgs
-;    call cdecl_UpdateTcbOnSyscallEntry
+    call cdecl_UpdateTcbOnSyscallEntry
 
     ; Get pointer to syscall_dispatch_table and dispatch
-    mov qword rax, [rsp + _rax]
+    pop_sysv_regs
     call qword [rel g_syscall_dispatch_table + rax*8]
     mov qword [rsp + _rax], rax
     jmp .return
@@ -147,7 +147,7 @@ isr_wrapper_128:  ; Syscall interrupt (128)
 
 .return:
 
-;    call cdecl_UpdateTcbOnSyscallExit
+    call cdecl_UpdateTcbOnSyscallExit
 
     call cdecl_SetKernelGs
     swapgs
diff --git a/kernel/arch/x86_64/src/kernel/init.cpp b/kernel/arch/x86_64/src/kernel/init.cpp
index 3cebda92..b024d71a 100644
--- a/kernel/arch/x86_64/src/kernel/init.cpp
+++ b/kernel/arch/x86_64/src/kernel/init.cpp
@@ -54,7 +54,7 @@ TODO_WHEN_MULTICORE
 // TODO: replace when core
 extern "C" void cdecl_SetKernelGs()
 {
-    cpu::SetMSR(arch::kIa32GsKernelBase, g_CoreLocal.thread_control_block->gs_base);
+    cpu::SetMSR(arch::kIa32GsKernelBase, g_CoreLocal.thread_control_block->arch_data.gs_base);
 }
 
 namespace arch
diff --git a/kernel/arch/x86_64/src/scheduling/scheduling.cpp b/kernel/arch/x86_64/src/scheduling/scheduling.cpp
index f2735a17..a567371a 100644
--- a/kernel/arch/x86_64/src/scheduling/scheduling.cpp
+++ b/kernel/arch/x86_64/src/scheduling/scheduling.cpp
@@ -8,8 +8,6 @@
 #include "modules/timing.hpp"
 #include "scheduling/thread.hpp"
 
-#include <hal/debug_terminal.hpp>
-
 // ------------------------------
 // statics
 // ------------------------------
@@ -18,18 +16,15 @@ FAST_CALL void SetThreadGs(Sched::Thread *thread)
 {
     ASSERT_NOT_NULL(thread);
 
-    cpu::SetMSR(arch::kIa32GsKernelBase, thread->gs_base);
+    cpu::SetMSR(arch::kIa32GsKernelBase, thread->arch_data.gs_base);
 }
 
 FAST_CALL void DumpFpStateIfNeeded(Sched::Thread *thread)
 {
     ASSERT_NOT_NULL(thread);
 
-    auto proc = SchedulingModule::Get().GetProcesses().GetProcess(thread->owner);
-    ASSERT_TRUE(static_cast<bool>(proc));
-
-    if (proc.value()->flags.PreserveFloats) {
-        u8 *mem = thread->fp_state;
+    if (thread->flags.PreserveFloats) {
+        u8 *mem = thread->arch_data.fp_state;
 
         __asm__ volatile("xsave64 %0" : "=m"(*mem) : "a"(0xFFFFFFFF), "d"(0xFFFFFFFF) : "memory");
     }
@@ -39,11 +34,8 @@ FAST_CALL void LoadFpStateIfNeeded(Sched::Thread *thread)
 {
     ASSERT_NOT_NULL(thread);
 
-    auto proc = SchedulingModule::Get().GetProcesses().GetProcess(thread->owner);
-    ASSERT_TRUE(static_cast<bool>(proc));
-
-    if (proc.value()->flags.PreserveFloats) {
-        u8 *mem = thread->fp_state;
+    if (thread->flags.PreserveFloats) {
+        u8 *mem = thread->arch_data.fp_state;
 
         __asm__ volatile("xrstor64 %0" : : "m"(*mem), "a"(0xFFFFFFFF), "d"(0xFFFFFFFF) : "memory");
     }
@@ -55,7 +47,7 @@ FAST_CALL void SetNextThreadFs(Sched::Thread *thread)
 {
     ASSERT_NOT_NULL(thread);
 
-    cpu::SetMSR(arch::kIa32FsBase, thread->fs_base);
+    cpu::SetMSR(arch::kIa32FsBase, thread->arch_data.fs_base);
 }
 
 FAST_CALL void SwapGsIfJumpingToUserspace(Sched::Thread *thread)
@@ -90,8 +82,8 @@ FAST_CALL void SwapFsIfNeeded(Sched::Thread *current_tcb, Sched::Thread *next_tc
     ASSERT_NOT_NULL(current_tcb);
     ASSERT_NOT_NULL(next_tcb);
 
-    if (current_tcb->fs_base != next_tcb->fs_base) {
-        cpu::SetMSR(arch::kIa32FsBase, next_tcb->fs_base);
+    if (current_tcb->arch_data.fs_base != next_tcb->arch_data.fs_base) {
+        cpu::SetMSR(arch::kIa32FsBase, next_tcb->arch_data.fs_base);
     }
 }
 
@@ -116,6 +108,9 @@ FAST_CALL void SwapAsIfNeeded(Sched::Thread *tcb)
 
 extern "C" void cdecl_ConvertContextEntry(Sched::Thread *thread)
 {
+    ASSERT_NOT_NULL(thread);
+    ASSERT_EQ(thread->state, Sched::ThreadState::kRunning);
+
     SetNextThreadFs(thread);
     LoadFpStateIfNeeded(thread);
     hardware::SetCoreLocalTcb(thread);
@@ -148,6 +143,9 @@ extern "C" void cdecl_ContextSwitchEntry(
     Sched::Thread *thread, IsrErrorStackFrame *mem, const u64 rip
 )
 {
+    ASSERT_EQ(thread->state, Sched::ThreadState::kRunning);
+    ASSERT_EQ(hardware::GetCoreLocalTcb()->state, Sched::ThreadState::kReady);
+
     const auto current_tcb = hardware::GetCoreLocalTcb();
     DumpFpStateIfNeeded(current_tcb);
 
@@ -165,7 +163,8 @@ extern "C" void cdecl_ContextSwitchEntry(
 
     const u64 t                 = TimingModule::Get().GetSystemTime().ReadLifeTimeNs();
     current_tcb->kernel_time_ns = t - current_tcb->timestamp;
-    thread->timestamp           = t;
+    current_tcb->num_context_switches++;
+    thread->timestamp = t;
 
     LoadFpStateIfNeeded(thread);
     SwapAsIfNeeded(thread);
@@ -174,6 +173,9 @@ extern "C" void cdecl_ContextSwitchEntry(
 
 extern "C" void cdecl_ContextSwitchOnInterrupt(Sched::Thread *thread, void *rsp)
 {
+    ASSERT_EQ(thread->state, Sched::ThreadState::kRunning);
+    ASSERT_EQ(hardware::GetCoreLocalTcb()->state, Sched::ThreadState::kReady);
+
     const auto current_tcb = hardware::GetCoreLocalTcb();
     DumpFpStateIfNeeded(current_tcb);
 
diff --git a/kernel/src/hal/api/tasks.hpp b/kernel/src/hal/api/tasks.hpp
deleted file mode 100644
index a7e446aa..00000000
--- a/kernel/src/hal/api/tasks.hpp
+++ /dev/null
@@ -1,10 +0,0 @@
-#ifndef KERNEL_SRC_HAL_API_TASKS_HPP_
-#define KERNEL_SRC_HAL_API_TASKS_HPP_
-
-namespace arch
-{
-struct ThreadAPI {
-};
-}  // namespace arch
-
-#endif  // KERNEL_SRC_HAL_API_TASKS_HPP_
diff --git a/kernel/src/scheduling/kworker.cpp b/kernel/src/scheduling/kworker.cpp
index 676bf4aa..e6843bd1 100644
--- a/kernel/src/scheduling/kworker.cpp
+++ b/kernel/src/scheduling/kworker.cpp
@@ -33,10 +33,7 @@ void Sched::TraceDumperMain()
 
     while (true) {
         trace::TraceDumperTask();
-
-        HardwareModule::Get().GetInterrupts().BlockHardwareInterrupts();
         SchedulingModule::Get().GetScheduler().Yield();
-        HardwareModule::Get().GetInterrupts().EnableHardwareInterrupts();
     }
 }
 
@@ -65,8 +62,6 @@ void Sched::StdoutTracerMain(Pid pid)
             }
         }
 
-        HardwareModule::Get().GetInterrupts().BlockHardwareInterrupts();
         SchedulingModule::Get().GetScheduler().Yield();
-        HardwareModule::Get().GetInterrupts().EnableHardwareInterrupts();
     }
 }
diff --git a/kernel/src/scheduling/policies/priority_queue_policy.hpp b/kernel/src/scheduling/policies/priority_queue_policy.hpp
new file mode 100644
index 00000000..f825ddaa
--- /dev/null
+++ b/kernel/src/scheduling/policies/priority_queue_policy.hpp
@@ -0,0 +1,54 @@
+#ifndef KERNEL_SRC_SCHEDULING_POLICIES_PRIORITY_QUEUE_POLICY_HPP_
+#define KERNEL_SRC_SCHEDULING_POLICIES_PRIORITY_QUEUE_POLICY_HPP_
+
+#include "array.hpp"
+#include "scheduling/policy.hpp"
+#include "scheduling/thread.hpp"
+
+#include <data_structures/priority_queues/bitmap_pq.hpp>
+
+namespace Sched
+{
+
+class PriorityQueuePolicy : public PolicyImpl
+{
+    public:
+    static constexpr u8 kMaxPriority = 64;
+
+    // ------------------------------
+    // Class creation
+    // ------------------------------
+
+    PriorityQueuePolicy()  = default;
+    ~PriorityQueuePolicy() = default;
+
+    // ------------------------------
+    // Class interaction
+    // ------------------------------
+
+    NODISCARD FORCE_INLINE_F Thread *PickNextTask() { return priority_queue_.DeleteMin(); }
+
+    FORCE_INLINE_F void AddTask(Thread *thread)
+    {
+        ASSERT_NOT_NULL(thread);
+        ASSERT_EQ(thread->state, ThreadState::kReady);
+        ASSERT_LT(thread->flags.priority, kMaxPriority);
+
+        priority_queue_.Insert(thread, thread->flags.priority);
+    }
+
+    // ------------------------------
+    // Private methods
+    // ------------------------------
+
+    private:
+    // ------------------------------
+    // Class fields
+    // ------------------------------
+
+    data_structures::BitmapPriorityQueue<Thread, kMaxPriority> priority_queue_{};
+};
+
+}  // namespace Sched
+
+#endif  // KERNEL_SRC_SCHEDULING_POLICIES_PRIORITY_QUEUE_POLICY_HPP_
diff --git a/kernel/src/scheduling/policies/round_robin_policy.hpp b/kernel/src/scheduling/policies/round_robin_policy.hpp
new file mode 100644
index 00000000..8de0c254
--- /dev/null
+++ b/kernel/src/scheduling/policies/round_robin_policy.hpp
@@ -0,0 +1,50 @@
+#ifndef KERNEL_SRC_SCHEDULING_POLICIES_ROUND_ROBIN_POLICY_HPP_
+#define KERNEL_SRC_SCHEDULING_POLICIES_ROUND_ROBIN_POLICY_HPP_
+
+#include <assert.h>
+#include <data_structures/intrusive_linked_list.hpp>
+#include <defines.hpp>
+
+#include "scheduling/policy.hpp"
+#include "scheduling/thread.hpp"
+
+namespace Sched
+{
+
+class RoundRobinPolicy : public PolicyImpl
+{
+    public:
+    // ------------------------------
+    // Class creation
+    // ------------------------------
+
+    RoundRobinPolicy()  = default;
+    ~RoundRobinPolicy() = default;
+
+    // ------------------------------
+    // Class interaction
+    // ------------------------------
+
+    NODISCARD FORCE_INLINE_F Thread *PickNextTask() { return threads_.PopFront(); }
+
+    FORCE_INLINE_F void AddTask(Thread *thread)
+    {
+        ASSERT_EQ(thread->state, ThreadState::kReady);
+        threads_.PushBack(thread);
+    }
+
+    // ------------------------------
+    // Private methods
+    // ------------------------------
+
+    private:
+    // ------------------------------
+    // Class fields
+    // ------------------------------
+
+    data_structures::IntrusiveList<Thread> threads_{};
+};
+
+}  // namespace Sched
+
+#endif  // KERNEL_SRC_SCHEDULING_POLICIES_ROUND_ROBIN_POLICY_HPP_
diff --git a/kernel/src/scheduling/policy.hpp b/kernel/src/scheduling/policy.hpp
new file mode 100644
index 00000000..ca6b57ec
--- /dev/null
+++ b/kernel/src/scheduling/policy.hpp
@@ -0,0 +1,78 @@
+#ifndef KERNEL_SRC_SCHEDULING_POLICY_HPP_
+#define KERNEL_SRC_SCHEDULING_POLICY_HPP_
+
+#include <assert.h>
+#include <types.h>
+#include <concepts.hpp>
+#include <defines.hpp>
+
+namespace Sched
+{
+struct Thread;
+
+// ------------------------------
+// SchedulingPolicy
+// ------------------------------
+
+enum class SchedulingPolicy : u8 {
+    kUberTask_PQ_P0 = 0,
+    kDrivers_PQ_P1,
+    kUrgentTasks_PQ_P2,
+    kNormalTasks_RR_P3,
+    kBackgroundTasks_RR_P4,
+    kLast,
+};
+
+// ------------------------------
+// Policy
+// ------------------------------
+
+struct Policy {
+    struct {
+        Thread *(*pick_next_task)(void *);
+        void (*add_task)(void *, Thread *);
+    } cbs;
+    void *self;
+};
+
+// ------------------------------
+// Helpers
+// ------------------------------
+
+struct PolicyImpl {
+    NODISCARD Thread *PickNextTask() { R_FAIL_ALWAYS("NOT_IMPLEMENTED"); }
+    void AddTask(Thread *) { R_FAIL_ALWAYS("NOT_IMPLEMENTED"); }
+};
+
+template <class T>
+    requires std::derived_from<T, PolicyImpl>
+Thread *PickNextTaskImpl(void *self)
+{
+    const auto rr = static_cast<T *>(self);
+    return rr->PickNextTask();
+}
+
+template <class T>
+    requires std::derived_from<T, PolicyImpl>
+void AddTaskImpl(void *self, Thread *thread)
+{
+    const auto rr = static_cast<T *>(self);
+    rr->AddTask(thread);
+}
+
+template <class T>
+    requires std::derived_from<T, PolicyImpl>
+NODISCARD FAST_CALL Policy PreparePolicy(T *self)
+{
+    Policy policy{};
+
+    policy.self               = self;
+    policy.cbs.pick_next_task = PickNextTaskImpl<T>;
+    policy.cbs.add_task       = AddTaskImpl<T>;
+
+    return policy;
+}
+
+}  // namespace Sched
+
+#endif  // KERNEL_SRC_SCHEDULING_POLICY_HPP_
diff --git a/kernel/src/scheduling/scheduler.cpp b/kernel/src/scheduling/scheduler.cpp
index a45954c8..b8a13079 100644
--- a/kernel/src/scheduling/scheduler.cpp
+++ b/kernel/src/scheduling/scheduler.cpp
@@ -1,24 +1,35 @@
 #include "scheduling/scheduler.hpp"
 
 #include "autogen/feature_flags.h"
-#include "hal/scheduling.hpp"
 #include "modules/hardware.hpp"
 #include "modules/scheduling.hpp"
 #include "modules/timing.hpp"
 
 namespace Sched
 {
+Scheduler::Scheduler()
+{
+    policies_[static_cast<size_t>(SchedulingPolicy::kUberTask_PQ_P0)] =
+        PreparePolicy<PriorityQueuePolicy>(&policy0_);
+    policies_[static_cast<size_t>(SchedulingPolicy::kDrivers_PQ_P1)] =
+        PreparePolicy<PriorityQueuePolicy>(&policy1_);
+    policies_[static_cast<size_t>(SchedulingPolicy::kUrgentTasks_PQ_P2)] =
+        PreparePolicy<PriorityQueuePolicy>(&policy2_);
+    policies_[static_cast<size_t>(SchedulingPolicy::kNormalTasks_RR_P3)] =
+        PreparePolicy<RoundRobinPolicy>(&policy3_);
+    policies_[static_cast<size_t>(SchedulingPolicy::kBackgroundTasks_RR_P4)] =
+        PreparePolicy<RoundRobinPolicy>(&policy4_);
+}
+
 void Scheduler::AddReadyThread(Thread *thread)
 {
-    if (threads_ == nullptr) {
-        threads_     = thread;
-        thread->next = thread;
-        return;
-    }
+    ASSERT_EQ(thread->state, ThreadState::kReady);
+
+    const auto idx = static_cast<size_t>(thread->flags.policy);
+    ASSERT_LT(idx, static_cast<size_t>(SchedulingPolicy::kLast));
 
-    thread->next   = threads_->next;
-    threads_->next = thread;
-    threads_       = thread;
+    const auto policy = policies_[idx];
+    policy.cbs.add_task(policy.self, thread);
 }
 
 Thread *Scheduler::Schedule()
@@ -27,27 +38,35 @@ Thread *Scheduler::Schedule()
         return nullptr;
     }
 
-    ASSERT_NOT_NULL(threads_);
+    for (const auto &policy : policies_) {
+        if (const auto thread = policy.cbs.pick_next_task(policy.self)) {
+            return thread;
+        }
+    }
 
-    auto thread = GetNext_();
-    ASSERT_NOT_NULL(thread);
+    // TODO: IDLE
+    return nullptr;
+}
 
-    auto owner = SchedulingModule::Get().GetProcesses().GetProcess(thread->owner);
-    ASSERT_TRUE(static_cast<bool>(owner));
+Thread *Scheduler::ScheduleAndUpdateThreads()
+{
+    const auto thread = Schedule();
+    ASSERT_EQ(thread->state, ThreadState::kReady);
+    thread->state = ThreadState::kRunning;
 
-    if (thread == hardware::GetCoreLocalTcb()) {
-        return nullptr;
-    }
+    ASSERT_NOT_NULL(hardware::GetCoreLocalTcb());
+    ASSERT_EQ(hardware::GetCoreLocalTcb()->state, ThreadState::kRunning);
+    hardware::GetCoreLocalTcb()->state = ThreadState::kReady;
+    AddReadyThread(hardware::GetCoreLocalTcb());
 
     return thread;
 }
+
 void Scheduler::Yield()
 {
-    auto thread = Schedule();
-
-    if (thread != nullptr) {
-        hal::ContextSwitch(thread);
-    }
+    HardwareModule::Get().GetInterrupts().BlockHardwareInterrupts();
+    YieldUnguarded();
+    HardwareModule::Get().GetInterrupts().EnableHardwareInterrupts();
 }
 
 void Scheduler::ConvertToScheduling()
@@ -57,21 +76,10 @@ void Scheduler::ConvertToScheduling()
     static constexpr u64 kPeriodicTime1Ms = kNanosInSecond / 1'000;
     TimingModule::Get().GetEventFramework().SetupPeriodic(kPeriodicTime1Ms);
 
-    ASSERT_NOT_NULL(threads_);
-
-    auto thread = GetNext_();
-    ASSERT_NOT_NULL(thread);
-
-    auto owner = SchedulingModule::Get().GetProcesses().GetProcess(thread->owner);
-    ASSERT_TRUE(static_cast<bool>(owner));
+    const auto thread = Schedule();
+    ASSERT_EQ(thread->state, ThreadState::kReady);
+    thread->state = ThreadState::kRunning;
 
     hal::ConvertContext(thread);
 }
-
-Thread *Scheduler::GetNext_()
-{
-    Thread *thread = threads_;
-    threads_       = threads_->next;
-    return thread;
-}
 }  // namespace Sched
diff --git a/kernel/src/scheduling/scheduler.hpp b/kernel/src/scheduling/scheduler.hpp
index 86894167..059e7a70 100644
--- a/kernel/src/scheduling/scheduler.hpp
+++ b/kernel/src/scheduling/scheduler.hpp
@@ -1,9 +1,18 @@
 #ifndef KERNEL_SRC_SCHEDULING_SCHEDULER_HPP_
 #define KERNEL_SRC_SCHEDULING_SCHEDULER_HPP_
 
+#include <array.hpp>
 #include <defines.hpp>
+#include <hardware/core_mask.hpp>
+
+#include "policy.hpp"
 #include "thread.hpp"
 
+#include "hal/scheduling.hpp"
+#include "hardware/core_local.hpp"
+#include "policies/priority_queue_policy.hpp"
+#include "policies/round_robin_policy.hpp"
+
 namespace Sched
 {
 
@@ -14,7 +23,7 @@ class Scheduler
     // Class creation
     // ------------------------------
 
-    Scheduler()  = default;
+    Scheduler();
     ~Scheduler() = default;
 
     // ------------------------------
@@ -25,8 +34,12 @@ class Scheduler
 
     Thread *Schedule();
 
+    Thread *ScheduleAndUpdateThreads();
+
     void Yield();
 
+    FORCE_INLINE_F void YieldUnguarded() { hal::ContextSwitch(ScheduleAndUpdateThreads()); }
+
     void ConvertToScheduling();
 
     // ------------------------------
@@ -34,13 +47,19 @@ class Scheduler
     // ------------------------------
 
     protected:
-    NODISCARD FORCE_INLINE_F Thread *GetNext_();
-
     // ------------------------------
     // Class fields
     // ------------------------------
 
-    Thread *threads_{};
+    // Policies
+    PriorityQueuePolicy policy0_{};  // kUberTask_PQ_P0
+    PriorityQueuePolicy policy1_{};  // kDrivers_PQ_P1
+    PriorityQueuePolicy policy2_{};  // kUrgentTasks_PQ_P2
+    RoundRobinPolicy policy3_{};     // kNormalTasks_RR_P3
+    RoundRobinPolicy policy4_{};     // kBackgroundTasks_RR_P4
+
+    // Abstraction
+    std::array<Policy, static_cast<size_t>(SchedulingPolicy::kLast)> policies_{};
 };
 }  // namespace Sched
 
diff --git a/kernel/src/scheduling/task_mgr.cpp b/kernel/src/scheduling/task_mgr.cpp
index 96fd9e7d..bbadc500 100644
--- a/kernel/src/scheduling/task_mgr.cpp
+++ b/kernel/src/scheduling/task_mgr.cpp
@@ -106,16 +106,39 @@ std::expected<Pid, Error> TaskMgr::SpawnEmptyProcess(const char *name, const Pro
 
 std::expected<Thread *, Error> TaskMgr::SpawnThread(const Pid pid, const Task &task)
 {
-    bool dismiss = false;
+    const auto process = SchedulingModule::Get().GetProcesses().GetProcess(pid);
+    ASSERT_TRUE(static_cast<bool>(process));
+
+    ThreadFlags flags{};
 
+    flags.PreserveFloats = process.value()->flags.PreserveFloats;
+    flags.policy         = SchedulingPolicy::kNormalTasks_RR_P3;
+    flags.priority       = 0;
+
+    return SpawnThread(process.value(), flags, task);
+}
+
+std::expected<Thread *, Error> TaskMgr::SpawnThread(
+    const Pid pid, const ThreadFlags flags, const Task &task
+)
+{
     const auto process = SchedulingModule::Get().GetProcesses().GetProcess(pid);
     ASSERT_TRUE(static_cast<bool>(process));
 
+    return SpawnThread(process.value(), flags, task);
+}
+
+std::expected<Thread *, Error> TaskMgr::SpawnThread(
+    const Process *process, const ThreadFlags flags, const Task &task
+)
+{
+    bool dismiss = false;
+
     // 1. Prepare internal structure for execution unit - thread:
     auto thread = SchedulingModule::Get().GetThreads().PrepareThread();
     if (!thread) {
         DEBUG_WARN_SCHEDULING(
-            "Failed to create thread for %llu. Failed on struct allocation: %s", pid,
+            "Failed to create thread for %llu. Failed on struct allocation: %s", process->pid,
             to_string(thread.error())
         );
 
@@ -128,13 +151,15 @@ std::expected<Thread *, Error> TaskMgr::SpawnThread(const Pid pid, const Task &t
     });
 
     // 2. Allocate process resources and prepare the struct
-    thread.value()->owner = pid;
+    thread.value()->owner = process->pid;
+    thread.value()->flags = flags;
+    thread.value()->state = ThreadState::kReady;
 
     // 2.1 Kernel Stack
     const auto kernel_stack = Mem::KMallocAligned({kKernelStackSize, kStackAlignment});
     if (!kernel_stack) {
         DEBUG_WARN_SCHEDULING(
-            "Failed to create thread for %llu. Failed on kernel stack allocation: %s", pid,
+            "Failed to create thread for %llu. Failed on kernel stack allocation: %s", process->pid,
             to_string(kernel_stack.error())
         );
 
@@ -147,13 +172,13 @@ std::expected<Thread *, Error> TaskMgr::SpawnThread(const Pid pid, const Task &t
     thread.value()->kernel_stack_bottom = kernel_stack.value();
 
     // 2.2 Thread Stack
-    if (!process.value()->flags.KernelSpaceOnly) {
+    if (!process->flags.KernelSpaceOnly) {
         const auto thread_stack =
-            MemoryModule::Get().GetVmm().AllocUserStack(process.value()->address_space, kStackSize);
+            MemoryModule::Get().GetVmm().AllocUserStack(process->address_space, kStackSize);
         if (!thread_stack) {
             DEBUG_WARN_SCHEDULING(
-                "Failed to create thread for %llu. Failed on thread stack allocation: %s", pid,
-                to_string(thread_stack.error())
+                "Failed to create thread for %llu. Failed on thread stack allocation: %s",
+                process->pid, to_string(thread_stack.error())
             );
 
             return std::unexpected(Error::OutOfMemory);
@@ -251,12 +276,12 @@ std::expected<std::tuple<Pid, Tid>, Error> TaskMgr::ExecuteElf64(
     return std::make_tuple(process.value(), thread.value());
 }
 
-std::expected<void, Error> TaskMgr::CommitMurder(Pid pid) { R_FAIL_ALWAYS("NOT IMPLEMENTED"); }
+std::expected<void, Error> TaskMgr::CommitMurder(Pid) { R_FAIL_ALWAYS("NOT IMPLEMENTED"); }
 
-void TaskMgr::CommitSuicide(Pid pid) { R_FAIL_ALWAYS("NOT IMPLEMENTED"); }
+void TaskMgr::CommitSuicide(Pid) { R_FAIL_ALWAYS("NOT IMPLEMENTED"); }
 
-std::expected<void, Error> TaskMgr::ExitProcess(Pid pid) { R_FAIL_ALWAYS("NOT IMPLEMENTED"); }
+std::expected<void, Error> TaskMgr::ExitProcess(Pid) { R_FAIL_ALWAYS("NOT IMPLEMENTED"); }
 
-std::expected<void, Error> TaskMgr::ExitThread(Tid tid) { R_FAIL_ALWAYS("NOT IMPLEMENTED"); }
+std::expected<void, Error> TaskMgr::ExitThread(Tid) { R_FAIL_ALWAYS("NOT IMPLEMENTED"); }
 
 }  // namespace Sched
diff --git a/kernel/src/scheduling/task_mgr.hpp b/kernel/src/scheduling/task_mgr.hpp
index a57dd612..cce115e9 100644
--- a/kernel/src/scheduling/task_mgr.hpp
+++ b/kernel/src/scheduling/task_mgr.hpp
@@ -28,6 +28,14 @@ class TaskMgr
 
     NODISCARD std::expected<Thread *, Error> SpawnThread(Pid pid, const Task &task);
 
+    NODISCARD std::expected<Thread *, Error> SpawnThread(
+        Pid pid, ThreadFlags flags, const Task &task
+    );
+
+    NODISCARD std::expected<Thread *, Error> SpawnThread(
+        const Process *process, ThreadFlags flags, const Task &task
+    );
+
     NODISCARD std::expected<std::tuple<Pid, Tid>, Error> SpawnKernelProcess(
         const char *name, ProcessFlags flags, const Task &task
     );
diff --git a/kernel/src/scheduling/thread.hpp b/kernel/src/scheduling/thread.hpp
index 1a2b3fc4..c4e8c459 100644
--- a/kernel/src/scheduling/thread.hpp
+++ b/kernel/src/scheduling/thread.hpp
@@ -3,13 +3,30 @@
 
 #include <types.h>
 #include <array.hpp>
+#include <data_structures/intrusive_linked_list.hpp>
 #include <defines.hpp>
 
 #include "hal/tasks.hpp"
+#include "policy.hpp"
 #include "process.hpp"
 
 namespace Sched
 {
+// ------------------------------
+// Task
+// ------------------------------
+
+struct Task {
+    static constexpr size_t kMaxArgs = 6;
+
+    void *func;
+    std::array<u64, kMaxArgs> args;
+    size_t args_count;
+};
+
+// ------------------------------
+// Thread
+// ------------------------------
 
 struct PACK Tid {
     u16 id;
@@ -17,27 +34,28 @@ struct PACK Tid {
 };
 
 struct PACK ThreadFlags {
+    SchedulingPolicy policy : 8;
+    u8 priority : 8;
     bool PreserveFloats : 1;
-    u64 padding : 63;
+    u64 padding : 47;
 };
 static_assert(sizeof(ThreadFlags) == 8);
 
-struct Task {
-    static constexpr size_t kMaxArgs = 6;
-
-    void *func;
-    std::array<u64, kMaxArgs> args;
-    size_t args_count;
+enum class ThreadState : u64 {
+    kReady = 0,
+    kRunning,
+    kBlocked,
+    kTerminated,
+    kLast,
 };
+static_assert(sizeof(ThreadState) == sizeof(u64));
 
-struct Thread : hal::Thread {
+struct Thread : data_structures::IntrusiveListNode<Thread> {
     /* Management */
     Tid tid;
     Pid owner;
     ThreadFlags flags;
-
-    /* Scheduler data */
-    Thread *next;
+    ThreadState state;
 
     /* Thread resources */
     void *kernel_stack;
@@ -45,11 +63,19 @@ struct Thread : hal::Thread {
     void *user_stack;
     void *user_stack_bottom;
 
-    /* Timing */
+    /* Statistics */
     u64 kernel_time_ns;
     u64 user_time_ns;
     u64 timestamp;
+    u64 num_interrupts;
+    u64 num_syscalls;
+    u64 num_context_switches;
+    u64 padding0;
+
+    /* Arch */
+    hal::Thread arch_data;
 };
+static_assert(sizeof(Thread) == (128 + sizeof(hal::Thread)));
 }  // namespace Sched
 
 #endif  // KERNEL_SRC_SCHEDULING_THREAD_HPP_
diff --git a/kernel/src/scheduling/threads.cpp b/kernel/src/scheduling/threads.cpp
index c63fd720..4b92de9b 100644
--- a/kernel/src/scheduling/threads.cpp
+++ b/kernel/src/scheduling/threads.cpp
@@ -75,6 +75,7 @@ void UpdateTcbOnInterruptEntry(hal::ExceptionData *data)
     }
 
     thread->timestamp = t;
+    thread->num_interrupts++;
 }
 
 void UpdateTcbOnInterruptExit(Thread *thread)
@@ -82,15 +83,24 @@ void UpdateTcbOnInterruptExit(Thread *thread)
     const auto current_thread = hardware::GetCoreLocalTcb();
 
     if (!current_thread) {
+        ASSERT_NULL(thread);
         return;
     }
 
     const u64 t = TimingModule::Get().GetSystemTime().ReadLifeTimeNs();
     current_thread->kernel_time_ns += t - current_thread->timestamp;
     current_thread->timestamp = t;
+    current_thread->num_context_switches++;
 
     if (thread) {
+        /* Context Switch occurs */
         thread->timestamp = t;
+
+        ASSERT_EQ(current_thread->state, ThreadState::kReady);
+        ASSERT_EQ(thread->state, ThreadState::kRunning);
+    } else {
+        /* No context switch occurred */
+        ASSERT_EQ(current_thread->state, ThreadState::kRunning);
     }
 }
 
@@ -102,6 +112,7 @@ void cdecl_UpdateTcbOnSyscallEntry()
     const u64 t       = TimingModule::Get().GetSystemTime().ReadLifeTimeNs();
     thread->user_time_ns += t - thread->timestamp;
     thread->timestamp = t;
+    thread->num_syscalls++;
 }
 
 void cdecl_UpdateTcbOnSyscallExit()
diff --git a/kernel/src/syscalls/calls/thread.hpp b/kernel/src/syscalls/calls/thread.hpp
index 08979b31..2892b73a 100644
--- a/kernel/src/syscalls/calls/thread.hpp
+++ b/kernel/src/syscalls/calls/thread.hpp
@@ -6,13 +6,13 @@
 
 namespace Syscall
 {
-FAST_CALL int SysThreadCreate(Thread *thread, thread_func_t f, void *arg) { return 0; }
+FAST_CALL int SysThreadCreate(Thread *, thread_func_t, void *) { return 0; }
 
-FAST_CALL int SysThreadJoin(Thread *thread) { return 0; }
+FAST_CALL int SysThreadJoin(Thread *) { return 0; }
 
-FAST_CALL int SysThreadDetach(Thread *thread) { return 0; }
+FAST_CALL int SysThreadDetach(Thread *) { return 0; }
 
-FAST_CALL void SysThreadExit(void *retval) {}
+FAST_CALL void SysThreadExit(void *) {}
 }  // namespace Syscall
 
 #endif  // KERNEL_SRC_SYSCALLS_CALLS_THREAD_HPP_
diff --git a/kernel/src/time/event_framework.cpp b/kernel/src/time/event_framework.cpp
index 28d7bb39..d651a5ac 100644
--- a/kernel/src/time/event_framework.cpp
+++ b/kernel/src/time/event_framework.cpp
@@ -8,7 +8,12 @@
 
 static Sched::Thread *TimerHandler(intr::LitHwEntry &)
 {
-    return SchedulingModule::Get().GetScheduler().Schedule();
+    if (hardware::GetCoreLocalTcb() == nullptr) {
+        // Not yet converted to scheduling
+        return nullptr;
+    }
+
+    return SchedulingModule::Get().GetScheduler().ScheduleAndUpdateThreads();
 }
 
 // ------------------------------
diff --git a/libs/libc/src/include/assert.h b/libs/libc/src/include/assert.h
index e75f440e..df67750c 100644
--- a/libs/libc/src/include/assert.h
+++ b/libs/libc/src/include/assert.h
@@ -28,7 +28,7 @@
     if (!(expr)) [[unlikely]] { \
         __ASSERT_FAIL(expr);    \
     }
-#define R_FAIL_ALWAYS(msg) __ASSERT_FAIL(false && msg)
+#define R_FAIL_ALWAYS(msg) __ASSERT_FAIL(false && msg) __builtin_unreachable();
 
 #define assert(expr) ASSERT(expr)
 
diff --git a/libs/libcontainers/include/data_structures/bit_array.hpp b/libs/libcontainers/include/data_structures/bit_array.hpp
index 90ce50bc..579903bf 100644
--- a/libs/libcontainers/include/data_structures/bit_array.hpp
+++ b/libs/libcontainers/include/data_structures/bit_array.hpp
@@ -261,6 +261,54 @@ class PACK BitArray final
         return FindFirst<false>();
     }
 
+    // std::numeric_limits<size_t>::max() for failure
+    template <bool value = false>
+    NODISCARD FORCE_INLINE_F size_t FindLast()
+    {
+        const StorageT empty_unit =
+            value ? std::numeric_limits<StorageT>::min() : std::numeric_limits<StorageT>::max();
+
+        for (auto i = static_cast<ssize_t>(kNumStorage - 1); i < static_cast<ssize_t>(kNumStorage);
+             --i) {
+            if (storage_[i] == empty_unit) {
+                continue;
+            }
+
+            const size_t start = static_cast<size_t>(i) * kStorageBits;
+            const size_t local_offset =
+                value ? std::countl_zero(storage_[i]) : std::countl_one(storage_[i]);
+            return start + local_offset;
+        }
+
+        return std::numeric_limits<size_t>::max();
+    }
+
+    NODISCARD FORCE_INLINE_F size_t FindLast(const bool value = false)
+    {
+        if (value) {
+            return FindLast<true>();
+        }
+        return FindLast<false>();
+    }
+
+    template <bool value = false>
+    NODISCARD FORCE_INLINE_F bool IsAllSet()
+    {
+        return FindFirst<!value>() == std::numeric_limits<size_t>::max();
+    }
+
+    NODISCARD FORCE_INLINE_F bool IsAllSet(const bool value = false)
+    {
+        if (value) {
+            return IsAllSet<true>();
+        }
+        return IsAllSet<false>();
+    }
+
+    NODISCARD FORCE_INLINE_F bool IsAllTrue() { return IsAllSet<true>(); }
+
+    NODISCARD FORCE_INLINE_F bool IsAllFalse() { return IsAllSet<false>(); }
+
     // ------------------------------
     // Class fields
     // ------------------------------
diff --git a/libs/libcontainers/include/data_structures/intrusive_linked_list.hpp b/libs/libcontainers/include/data_structures/intrusive_linked_list.hpp
new file mode 100644
index 00000000..cb4884e7
--- /dev/null
+++ b/libs/libcontainers/include/data_structures/intrusive_linked_list.hpp
@@ -0,0 +1,229 @@
+#ifndef LIBS_LIBCONTAINERS_INCLUDE_DATA_STRUCTURES_INTRUSIVE_LINKED_LIST_HPP_
+#define LIBS_LIBCONTAINERS_INCLUDE_DATA_STRUCTURES_INTRUSIVE_LINKED_LIST_HPP_
+
+#include <concepts.hpp>
+#include <defines.hpp>
+#include <template/special_members.hpp>
+
+namespace data_structures
+{
+template <class T>
+struct IntrusiveListNode {
+    T *next;
+};
+
+template <class T>
+struct IntrusiveDoubleListNode {
+    T *next;
+    T *prev;
+};
+
+template <class T>
+    requires std::derived_from<T, IntrusiveListNode<T>>
+class IntrusiveList : template_lib::NoCopy
+{
+    public:
+    // ------------------------------
+    // Class creation
+    // ------------------------------
+
+    IntrusiveList()  = default;
+    ~IntrusiveList() = default;
+
+    // ------------------------------
+    // Class interaction
+    // ------------------------------
+
+    NODISCARD FORCE_INLINE_F bool IsEmpty() const { return head_ == nullptr; }
+
+    FORCE_INLINE_F void PushBack(T *item)
+    {
+        ASSERT_NOT_NULL(item);
+
+        if (IsEmpty()) {
+            InitList_(item);
+            return;
+        }
+
+        tail_->next = item;
+        item->next  = nullptr;
+        tail_       = item;
+    }
+
+    FORCE_INLINE_F void PushFront(T *item)
+    {
+        ASSERT_NOT_NULL(item);
+
+        if (IsEmpty()) {
+            InitList_(item);
+            return;
+        }
+
+        item->next = head_;
+        head_      = item;
+    }
+
+    NODISCARD FORCE_INLINE_F T *PopFront()
+    {
+        if (IsEmpty()) {
+            return nullptr;
+        }
+
+        T *item    = head_;
+        head_      = item->next;
+        item->next = nullptr;
+
+        // Not Needed due to IsEmpty() checks
+        // if (head_ == nullptr) {
+        //     tail_ = nullptr;
+        // }
+
+        return item;
+    }
+
+    NODISCARD FORCE_INLINE_F T *Front() { return head_; }
+
+    NODISCARD FORCE_INLINE_F T *Back()
+    {
+        if (IsEmpty()) {
+            return nullptr;
+        }
+        return tail_;
+    }
+
+    // ------------------------------
+    // Private methods
+    // ------------------------------
+
+    private:
+    FORCE_INLINE_F void InitList_(T *item)
+    {
+        head_      = item;
+        tail_      = item;
+        item->next = nullptr;
+    }
+
+    // ------------------------------
+    // Class fields
+    // ------------------------------
+
+    T *head_{};
+    T *tail_{};
+};
+
+template <class T>
+    requires std::derived_from<T, IntrusiveDoubleListNode<T>>
+class IntrusiveDoubleList : template_lib::NoCopy
+{
+    public:
+    // ------------------------------
+    // Class creation
+    // ------------------------------
+
+    IntrusiveDoubleList()  = default;
+    ~IntrusiveDoubleList() = default;
+
+    // ------------------------------
+    // Class interaction
+    // ------------------------------
+
+    NODISCARD FORCE_INLINE_F bool IsEmpty() const { return head_ == nullptr; }
+
+    FORCE_INLINE_F void PushBack(T *item)
+    {
+        ASSERT_NOT_NULL(item);
+
+        if (IsEmpty()) {
+            InitList_(item);
+            return;
+        }
+
+        tail_->next = item;
+        item->next  = nullptr;
+        item->prev  = tail_;
+        tail_       = item;
+    }
+
+    FORCE_INLINE_F void PushFront(T *item)
+    {
+        ASSERT_NOT_NULL(item);
+
+        if (IsEmpty()) {
+            InitList_(item);
+            return;
+        }
+
+        item->next  = head_;
+        item->prev  = nullptr;
+        head_->prev = item;
+        head_       = item;
+    }
+
+    NODISCARD FORCE_INLINE_F T *PopFront()
+    {
+        if (IsEmpty()) {
+            return nullptr;
+        }
+
+        T *item = head_;
+        head_   = item->next;
+
+        if (head_) {
+            head_->prev = nullptr;
+        } else {
+            tail_ = nullptr;
+        }
+
+        item->next = nullptr;
+        item->prev = nullptr;
+        return item;
+    }
+
+    NODISCARD FORCE_INLINE_F T *PopBack()
+    {
+        if (IsEmpty()) {
+            return nullptr;
+        }
+
+        T *item = tail_;
+        tail_   = item->prev;
+
+        if (tail_) {
+            tail_->next = nullptr;
+        } else {
+            head_ = nullptr;
+        }
+
+        item->prev = nullptr;
+        item->next = nullptr;
+        return item;
+    }
+
+    NODISCARD FORCE_INLINE_F T *Front() { return head_; }
+
+    NODISCARD FORCE_INLINE_F T *Back() { return tail_; }
+
+    // ------------------------------
+    // Private methods
+    // ------------------------------
+
+    private:
+    FORCE_INLINE_F void InitList_(T *item)
+    {
+        head_      = item;
+        tail_      = item;
+        item->next = nullptr;
+        item->prev = nullptr;
+    }
+
+    // ------------------------------
+    // Class fields
+    // ------------------------------
+
+    T *head_{};
+    T *tail_{};
+};
+
+}  // namespace data_structures
+
+#endif  // LIBS_LIBCONTAINERS_INCLUDE_DATA_STRUCTURES_INTRUSIVE_LINKED_LIST_HPP_
diff --git a/libs/libcontainers/include/data_structures/priority_queues/bitmap_pq.hpp b/libs/libcontainers/include/data_structures/priority_queues/bitmap_pq.hpp
new file mode 100644
index 00000000..81da5a50
--- /dev/null
+++ b/libs/libcontainers/include/data_structures/priority_queues/bitmap_pq.hpp
@@ -0,0 +1,105 @@
+#ifndef LIBS_LIBCONTAINERS_INCLUDE_DATA_STRUCTURES_PRIORITY_QUEUES_BITMAP_PQ_HPP_
+#define LIBS_LIBCONTAINERS_INCLUDE_DATA_STRUCTURES_PRIORITY_QUEUES_BITMAP_PQ_HPP_
+
+#include <array.hpp>
+#include <concepts.hpp>
+
+#include "data_structures/bit_array.hpp"
+#include "data_structures/intrusive_linked_list.hpp"
+
+namespace data_structures
+{
+template <class T, size_t kSize>
+    requires std::derived_from<T, IntrusiveListNode<T>>
+class BitmapPriorityQueue
+{
+    public:
+    // ------------------------------
+    // Class creation
+    // ------------------------------
+
+    BitmapPriorityQueue()  = default;
+    ~BitmapPriorityQueue() = default;
+
+    // ------------------------------
+    // Class interaction
+    // ------------------------------
+
+    NODISCARD FORCE_INLINE_F T *FindMin() const
+    {
+        const size_t idx = bits_.template FindFirst<true>();
+        if (idx == std::numeric_limits<size_t>::max()) {
+            return nullptr;
+        }
+
+        ASSERT_NOT_NULL(queues_[idx].Front());
+        return queues_[idx].Front();
+    }
+
+    NODISCARD FORCE_INLINE_F T *FindMax() const
+    {
+        const size_t idx = bits_.template FindLast<true>();
+        if (idx == std::numeric_limits<size_t>::max()) {
+            return nullptr;
+        }
+
+        ASSERT_NOT_NULL(queues_[idx].Front());
+        return queues_[idx].Front();
+    }
+
+    NODISCARD FORCE_INLINE_F T *DeleteMin()
+    {
+        const size_t idx = bits_.template FindFirst<true>();
+        if (idx == std::numeric_limits<size_t>::max()) {
+            return nullptr;
+        }
+
+        T *min = queues_[idx].PopFront();
+
+        if (queues_[idx].IsEmpty()) {
+            bits_.SetFalse(idx);
+        }
+
+        return min;
+    }
+
+    NODISCARD FORCE_INLINE_F T *DeleteMax()
+    {
+        const size_t idx = bits_.template FindLast<true>();
+        if (idx == std::numeric_limits<size_t>::max()) {
+            return nullptr;
+        }
+
+        T *min = queues_[idx].PopFront();
+
+        if (queues_[idx].IsEmpty()) {
+            bits_.SetFalse(idx);
+        }
+
+        return min;
+    }
+
+    FORCE_INLINE_F void Insert(T *item, const size_t priority)
+    {
+        ASSERT_LT(priority, kSize);
+        queues_[priority].PushBack(item);
+    }
+
+    NODISCARD FORCE_INLINE_F bool IsEmpty() const { return bits_.IsAllFalse(); }
+
+    // ------------------------------
+    // Private methods
+    // ------------------------------
+
+    private:
+    // ------------------------------
+    // Class fields
+    // ------------------------------
+
+    BitArray<kSize> bits_{};
+    IntrusiveList<T> queues_[kSize]{};
+};
+
+}  // namespace data_structures
+
+#endif  // LIBS_LIBCONTAINERS_INCLUDE_DATA_STRUCTURES_PRIORITY_QUEUES_BITMAP_PQ_HPP_
diff --git a/libs/libcontainers/include/data_structures/ref_count.hpp b/libs/libcontainers/include/data_structures/ref_count.hpp
index 470385fa..3b315d7a 100644
--- a/libs/libcontainers/include/data_structures/ref_count.hpp
+++ b/libs/libcontainers/include/data_structures/ref_count.hpp
@@ -38,7 +38,7 @@ class RefCounted
     {
         CounterType old_count = ref_count_.fetch_sub(1, std::memory_order_acq_rel);
 
-        ASSERT_GT(old_count, 0, "Releasing ref_count that is already zero");
+        ASSERT_GT(old_count, 0u, "Releasing ref_count that is already zero");
 
         if (old_count == 1) {
             T *ptr = static_cast<T *>(this);

From aefc3bdd89ee03edeb0cfae4e34b1d8d06829240 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C5=81ukasz=20Kryczka?=
 <60490378+kryczkal@users.noreply.github.com>
Date: Sat, 3 Jan 2026 22:40:45 +0100
Subject: [PATCH 44/56] Kryczkal/input manager (#267)

---
 kernel/src/drivers/input/ps2_keyboard.cpp | 11 +++++-
 kernel/src/hardware/core_local.hpp        | 10 ++++-
 kernel/src/init.cpp                       |  2 +
 kernel/src/kernel.cpp                     |  9 +++++
 kernel/src/modules/input.hpp              | 45 +++++++++++++++++++++++
 kernel/src/scheduling/processes.cpp       |  3 ++
 kernel/src/scheduling/task_mgr.cpp        |  7 ++++
 kernel/src/syscalls/calls/proc.hpp        |  8 ++++
 kernel/src/video/window_manager.cpp       | 37 +++++++++++++++++++
 kernel/src/video/window_manager.hpp       |  5 +++
 10 files changed, 134 insertions(+), 3 deletions(-)
 create mode 100644 kernel/src/modules/input.hpp

diff --git a/kernel/src/drivers/input/ps2_keyboard.cpp b/kernel/src/drivers/input/ps2_keyboard.cpp
index 2647deac..fe229b22 100644
--- a/kernel/src/drivers/input/ps2_keyboard.cpp
+++ b/kernel/src/drivers/input/ps2_keyboard.cpp
@@ -1,4 +1,5 @@
 #include "drivers/input/ps2_keyboard.hpp"
+#include "modules/input.hpp"
 #include "modules/video.hpp"
 #include "trace_framework.hpp"
 
@@ -130,7 +131,10 @@ void Ps2Keyboard::OnInterrupt()
         }
 
         if (scancode == kScanCodeTab) {
-            VideoModule::Get().GetWindowManager().SwitchToNextSession();
+            if (VideoModule::IsInited()) {
+                VideoModule::Get().GetWindowManager().SwitchToNextSession();
+            }
+            return;
         }
 
         // Handle Make Code (Key Press)
@@ -142,7 +146,10 @@ void Ps2Keyboard::OnInterrupt()
             // Translate and push regular characters
             const char c = TranslateScancode(scancode);
             if (c != 0) {
-                PushKey(c);
+                // Route to the central input module
+                if (InputModule::IsInited()) {
+                    InputModule::Get().RouteKey(c);
+                }
             }
         }
 
diff --git a/kernel/src/hardware/core_local.hpp b/kernel/src/hardware/core_local.hpp
index 9e8a31d7..2727c28b 100644
--- a/kernel/src/hardware/core_local.hpp
+++ b/kernel/src/hardware/core_local.hpp
@@ -32,7 +32,15 @@ PREPARE_CORE_LOCAL_ACCESS(Tcb, Sched::Thread *, thread_control_block);
 PREPARE_CORE_LOCAL_ACCESS(Self, CoreLocal *, self);
 #pragma GCC diagnostic pop
 
-NODISCARD FAST_CALL Sched::Pid GetRunningPid() { return GetCoreLocalTcb()->owner; }
+NODISCARD FAST_CALL Sched::Pid GetRunningPid()
+{
+    // During boot, TCB is null. Return {0,0} (Kernel PID) in that case.
+    auto *tcb = GetCoreLocalTcb();
+    if (tcb == nullptr) {
+        return {0, 0};
+    }
+    return GetCoreLocalTcb()->owner;
+}
 
 }  // namespace hardware
 
diff --git a/kernel/src/init.cpp b/kernel/src/init.cpp
index 848b810a..699a43cd 100644
--- a/kernel/src/init.cpp
+++ b/kernel/src/init.cpp
@@ -8,6 +8,7 @@
 #include "hal/terminal.hpp"
 #include "modules/global_state.hpp"
 #include "modules/hardware.hpp"
+#include "modules/input.hpp"
 #include "modules/memory.hpp"
 #include "modules/scheduling.hpp"
 #include "modules/timing.hpp"
@@ -64,4 +65,5 @@ void KernelInit(const hal::RawBootArguments &raw_args)
     HardwareModule::Get().GetCoresController().BootUpAllCores();
 
     VideoModule::Init(args, MemoryModule::Get().GetHeap());
+    InputModule::Init();
 }
diff --git a/kernel/src/kernel.cpp b/kernel/src/kernel.cpp
index 36de20ce..e440d271 100644
--- a/kernel/src/kernel.cpp
+++ b/kernel/src/kernel.cpp
@@ -32,6 +32,15 @@ static void KernelRun()
         "Failed to spawn stdout tracer process..."
     );
 
+    const auto res1 = task_mgr.ExecuteElf64("/bin/gui_test", {});
+    R_ASSERT_TRUE(static_cast<bool>(res1), "Failed to spawn /bin/gui process...");
+
+    for (volatile size_t i = 0; i < 1'000'000; i = i + 1) {
+    }
+
+    const auto res2 = task_mgr.ExecuteElf64("/bin/gui_test", {});
+    R_ASSERT_TRUE(static_cast<bool>(res2), "Failed to spawn /bin/gui process...");
+
     SchedulingModule::Get().GetScheduler().ConvertToScheduling();
 }
 
diff --git a/kernel/src/modules/input.hpp b/kernel/src/modules/input.hpp
new file mode 100644
index 00000000..6f3af043
--- /dev/null
+++ b/kernel/src/modules/input.hpp
@@ -0,0 +1,45 @@
+#ifndef KERNEL_SRC_MODULES_INPUT_HPP_
+#define KERNEL_SRC_MODULES_INPUT_HPP_
+
+#include <template_lib.hpp>
+#include "modules/hardware.hpp"
+#include "modules/scheduling.hpp"
+#include "modules/video.hpp"
+#include "trace_framework.hpp"
+
+namespace internal
+{
+
+class InputModule : public template_lib::StaticSingletonHelper
+{
+    protected:
+    InputModule() noexcept = default;
+
+    public:
+    void RouteKey(char c)
+    {
+        auto &wm              = ::VideoModule::Get().GetWindowManager();
+        Sched::Pid target_pid = wm.GetActiveSessionFocusedPid();
+
+        if (target_pid.id == 0) {
+            return;  // No focus
+        }
+
+        auto proc_res = ::SchedulingModule::Get().GetProcesses().GetProcess(target_pid);
+        if (!proc_res) {
+            DEBUG_WARN_GENERAL("InputModule: Failed to find process for PID %llu", target_pid.id);
+            return;
+        }
+
+        auto *proc = *proc_res;
+
+        byte b = static_cast<byte>(c);
+        (void)proc->stdin_pipe.Write(std::span<const byte>(&b, 1));
+    }
+};
+
+}  // namespace internal
+
+using InputModule = template_lib::StaticSingleton<internal::InputModule>;
+
+#endif  // KERNEL_SRC_MODULES_INPUT_HPP_
diff --git a/kernel/src/scheduling/processes.cpp b/kernel/src/scheduling/processes.cpp
index 6cfd334f..74dbedcf 100644
--- a/kernel/src/scheduling/processes.cpp
+++ b/kernel/src/scheduling/processes.cpp
@@ -5,6 +5,7 @@
 #include <template/scope_guard.hpp>
 #include "fs/file_descriptor.hpp"
 #include "modules/vfs.hpp"
+#include "modules/video.hpp"
 
 // ------------------------------
 // statics
@@ -79,6 +80,8 @@ void Sched::Processes::CleanupProcess(Process *process)
 {
     ASSERT_NOT_NULL(process);
 
+    VideoModule::Get().GetWindowManager().ReleaseFocus(process->pid);
+
     auto fd_table = process->fd_table;
     ASSERT_NOT_NULL(fd_table);
 
diff --git a/kernel/src/scheduling/task_mgr.cpp b/kernel/src/scheduling/task_mgr.cpp
index bbadc500..50364d32 100644
--- a/kernel/src/scheduling/task_mgr.cpp
+++ b/kernel/src/scheduling/task_mgr.cpp
@@ -4,6 +4,7 @@
 #include "modules/memory.hpp"
 #include "modules/scheduling.hpp"
 #include "modules/vfs.hpp"
+#include "modules/video.hpp"
 #include "scheduling/kworker.hpp"
 #include "task_mgr.hpp"
 
@@ -48,6 +49,10 @@ void TaskMgr::InitializeMultitasking()
         );
     }
 
+    if constexpr (FeatureEnabled<FeatureFlag::kRunTestMode>) {
+        return;
+    }
+
     const auto res1 = ExecuteElf64("/bin/gui_test", {});
     R_ASSERT_TRUE(static_cast<bool>(res1), "Failed to spawn /bin/hello process...");
 
@@ -272,6 +277,8 @@ std::expected<std::tuple<Pid, Tid>, Error> TaskMgr::ExecuteElf64(
     auto thread = ExecuteElf64(process.value(), path);
     RET_UNEXPECTED_IF_ERR(thread);
 
+    VideoModule::Get().GetWindowManager().SetFocus(process.value());
+
     process_guard.dismiss();
     return std::make_tuple(process.value(), thread.value());
 }
diff --git a/kernel/src/syscalls/calls/proc.hpp b/kernel/src/syscalls/calls/proc.hpp
index 60f4f602..5b25b265 100644
--- a/kernel/src/syscalls/calls/proc.hpp
+++ b/kernel/src/syscalls/calls/proc.hpp
@@ -2,11 +2,19 @@
 #define KERNEL_SRC_SYSCALLS_CALLS_PROC_HPP_
 
 #include <defines.hpp>
+#include "hardware/core_local.hpp"
+#include "modules/video.hpp"
 
 namespace Syscall
 {
 FAST_CALL void SysExit(int status) {}
 FAST_CALL void SysAbort() {}
+
+FORCE_INLINE_F void SysFocusTransfer(Sched::Pid target_child)
+{
+    auto &wm = VideoModule::Get().GetWindowManager();
+    wm.SetFocus(target_child);
+}
 }  // namespace Syscall
 
 #endif  // KERNEL_SRC_SYSCALLS_CALLS_PROC_HPP_
diff --git a/kernel/src/video/window_manager.cpp b/kernel/src/video/window_manager.cpp
index 3ff8cb87..d327b7c7 100644
--- a/kernel/src/video/window_manager.cpp
+++ b/kernel/src/video/window_manager.cpp
@@ -83,6 +83,42 @@ void WindowManager::SwitchToNextSession()
     SwitchSession(new_index);
 }
 
+void WindowManager::SetFocus(Sched::Pid pid)
+{
+    auto caller = hardware::GetRunningPid();
+    for (size_t i = 0; i < sessions_.Size(); ++i) {
+        if (sessions_[i].owner_pid == caller || sessions_[i].focused_pid == caller) {
+            sessions_[i].focused_pid = pid;
+            DEBUG_INFO_GENERAL(
+                "WindowManager: Transferred focus in session %zu to PID %llu", i, pid
+            );
+            return;
+        }
+    }
+}
+
+Sched::Pid WindowManager::GetActiveSessionFocusedPid()
+{
+    if (active_session_idx_ == kInvalidSession) {
+        return {0, 0};
+    }
+    return sessions_[active_session_idx_].focused_pid;
+}
+
+void WindowManager::ReleaseFocus(Sched::Pid pid)
+{
+    for (size_t i = 0; i < sessions_.Size(); ++i) {
+        if (sessions_[i].focused_pid == pid) {
+            sessions_[i].focused_pid = sessions_[i].owner_pid;
+            DEBUG_INFO_GENERAL(
+                "WindowManager: Returned focus in session %zu to owner PID %llu", i,
+                sessions_[i].owner_pid
+            );
+            return;
+        }
+    }
+}
+
 void WindowManager::RefreshScreen()
 {
     if (active_session_idx_ == kInvalidSession || active_session_idx_ >= sessions_.Size()) {
@@ -134,6 +170,7 @@ size_t WindowManager::RegisterGraphicsSession(Sched::Pid pid, BufferInfo buffer)
 {
     GraphicSession session;
     session.owner_pid   = pid;
+    session.focused_pid = pid;
     session.buffer_info = buffer;
     session.is_active   = false;
 
diff --git a/kernel/src/video/window_manager.hpp b/kernel/src/video/window_manager.hpp
index 99554ce6..35e77c2a 100644
--- a/kernel/src/video/window_manager.hpp
+++ b/kernel/src/video/window_manager.hpp
@@ -23,6 +23,7 @@ struct BufferInfo {
 
 struct GraphicSession {
     Sched::Pid owner_pid;
+    Sched::Pid focused_pid;
     bool is_active = false;
 
     /// The backing store (Physical RAM)
@@ -47,6 +48,10 @@ class WindowManager
     void SwitchSession(size_t index);
     void SwitchToNextSession();
 
+    void SetFocus(Sched::Pid pid);
+    void ReleaseFocus(Sched::Pid pid);
+    Sched::Pid GetActiveSessionFocusedPid();
+
     private:
     std::expected<BufferInfo, Mem::MemError> AllocUserBuffer();
     size_t RegisterGraphicsSession(Sched::Pid pid, BufferInfo buffer);

From 888a22f3dfb5921eef3cdd7d2074bc23d1de8f35 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C5=81ukasz=20Kryczka?= <lukasz.kryczka000@gmail.com>
Date: Sun, 4 Jan 2026 00:11:30 +0100
Subject: [PATCH 45/56] refactor: Remove test mode execution code from task
 manager initialization

---
 kernel/src/scheduling/task_mgr.cpp | 13 -------------
 1 file changed, 13 deletions(-)

diff --git a/kernel/src/scheduling/task_mgr.cpp b/kernel/src/scheduling/task_mgr.cpp
index 50364d32..5aeae00d 100644
--- a/kernel/src/scheduling/task_mgr.cpp
+++ b/kernel/src/scheduling/task_mgr.cpp
@@ -48,19 +48,6 @@ void TaskMgr::InitializeMultitasking()
             "Created initial Kernel Worker process with Pid: %llu", result.value().get<0>()
         );
     }
-
-    if constexpr (FeatureEnabled<FeatureFlag::kRunTestMode>) {
-        return;
-    }
-
-    const auto res1 = ExecuteElf64("/bin/gui_test", {});
-    R_ASSERT_TRUE(static_cast<bool>(res1), "Failed to spawn /bin/hello process...");
-
-    for (volatile size_t i = 0; i < 1'000'000; i = i + 1) {
-    }
-
-    const auto res2 = ExecuteElf64("/bin/gui_test", {});
-    R_ASSERT_TRUE(static_cast<bool>(res2), "Failed to spawn /bin/hello process...");
 }
 
 std::expected<Pid, Error> TaskMgr::SpawnEmptyProcess(const char *name, const ProcessFlags flags)

From c84a62cd7f112088323557fb85e487aa9507901d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C5=81ukasz=20Kryczka?=
 <60490378+kryczkal@users.noreply.github.com>
Date: Sun, 4 Jan 2026 00:43:21 +0100
Subject: [PATCH 46/56] Implemented userspace panic syscall (empty stub for
 suicide func - todo) (#269)

---
 kernel/arch/x86_64/src/interrupts/idt.cpp | 24 ++++--
 kernel/src/libc_backend.cpp               |  2 +-
 kernel/src/mem/virt/page_fault.cpp        | 94 ++++++++++++-----------
 kernel/src/syscalls/calls/panic.hpp       | 15 +++-
 4 files changed, 83 insertions(+), 52 deletions(-)

diff --git a/kernel/arch/x86_64/src/interrupts/idt.cpp b/kernel/arch/x86_64/src/interrupts/idt.cpp
index 7cb6a5fc..87fb5c10 100644
--- a/kernel/arch/x86_64/src/interrupts/idt.cpp
+++ b/kernel/arch/x86_64/src/interrupts/idt.cpp
@@ -14,6 +14,7 @@
 #include <bit.hpp>
 #include <hal/terminal.hpp>
 
+#include "modules/scheduling.hpp"
 #include "trace_framework.hpp"
 
 static constexpr u32 kStubTableSize = 144;
@@ -94,9 +95,7 @@ static void FormatIsrRegisters(
     }
 }
 
-NO_RET FAST_CALL void DefaultExceptionHandler(
-    const IsrErrorStackFrame *stack_frame, const u8 idt_idx
-)
+NO_RET FAST_CALL void KernelExceptionPanic(const IsrErrorStackFrame *stack_frame, const u8 idt_idx)
 {
     static constexpr size_t kStateMsgSize = 1024;
 
@@ -119,8 +118,23 @@ NO_RET FAST_CALL void DefaultExceptionHandler(
 
 Sched::Thread *DefaultExceptionHandler(intr::LitExcEntry &entry, hal::ExceptionData *data)
 {
-    DefaultExceptionHandler(data, entry.hardware_irq);
-    return nullptr;
+    if (hal::IsInterruptFromUserSpace(*data)) {
+        // Userspace Crash
+        auto pid                  = hardware::GetRunningPid();
+        const char *exception_msg = GetExceptionMsg(entry.hardware_irq);
+
+        TRACE_FATAL_GENERAL(
+            "Process %llu crashed: Exception %u (%s) at RIP=0x%016llx", pid.id, entry.hardware_irq,
+            exception_msg ? exception_msg : "Unknown", data->isr_stack_frame.rip
+        );
+
+        SchedulingModule::Get().GetTaskMgr().CommitSuicide(pid);
+        return nullptr;
+    } else {
+        // Kernel Panic
+        KernelExceptionPanic(data, entry.hardware_irq);
+        return nullptr;
+    }
 }
 
 FAST_CALL void LogIrqReceived(const u16 idt_idx, const u16 lirq)
diff --git a/kernel/src/libc_backend.cpp b/kernel/src/libc_backend.cpp
index 32aee743..881faab7 100644
--- a/kernel/src/libc_backend.cpp
+++ b/kernel/src/libc_backend.cpp
@@ -10,7 +10,7 @@
 
 using namespace Syscall;
 
-void __platform_panic(const char *msg) { SysPanic(msg); }
+void __platform_panic(const char *msg) { hal::KernelPanic(msg); }
 
 void __platform_get_clock_value(const ClockType type, TimeVal *time, Timezone *time_zone)
 {
diff --git a/kernel/src/mem/virt/page_fault.cpp b/kernel/src/mem/virt/page_fault.cpp
index 3aaea985..f54d63fd 100644
--- a/kernel/src/mem/virt/page_fault.cpp
+++ b/kernel/src/mem/virt/page_fault.cpp
@@ -6,6 +6,7 @@
 #include "hal/panic.hpp"
 #include "mem/virt/addr_space.hpp"
 #include "modules/memory.hpp"
+#include "modules/scheduling.hpp"
 #include "trace_framework.hpp"
 
 namespace Mem
@@ -39,6 +40,50 @@ constexpr const char *InstructionFetchDescription(bool instruction_fetch)
     return instruction_fetch ? "Fault caused by an instruction fetch"
                              : "Fault not caused by an instruction fetch";
 }
+
+NO_RET void PanicPageFault(const PageFaultData &pfd, const hal::ExceptionData &data)
+{
+    const auto &f_ptr = pfd.faulting_ptr;
+    const auto &err   = pfd.error;
+
+    hal::KernelPanicFormat(
+        "Unresolvable Page Fault\n"
+        "Faulting address: %p\n"
+        "Instruction pointer: %p\n"
+        "Error details:\n"
+        "  - %s\n"
+        "  - %s\n"
+        "  - %s\n"
+        "  - %s\n"
+        "  - %s",
+        f_ptr, data.isr_stack_frame.rip, PresentDescription(err.present),
+        WriteDescription(err.write), UserModeDescription(err.user),
+        ReservedBitsDescription(err.reserved_bits),
+        InstructionFetchDescription(err.instruction_fetch)
+    );
+}
+
+void HandleUnresolvableFault(const PageFaultData &pfd, const hal::ExceptionData &data)
+{
+    if (hal::IsInterruptFromUserSpace(data)) {
+        auto pid = hardware::GetRunningPid();
+        TRACE_FATAL_GENERAL(
+            "Process %llu Segmentation Fault at %p (RIP=%p)", pid.id, pfd.faulting_ptr,
+            data.isr_stack_frame.rip
+        );
+
+        if (pfd.error.present) {
+            TRACE_FATAL_GENERAL("Reason: Page protection violation");
+        } else {
+            TRACE_FATAL_GENERAL("Reason: Page not present");
+        }
+
+        SchedulingModule::Get().GetTaskMgr().CommitSuicide(pid);
+    } else {
+        PanicPageFault(pfd, data);
+    }
+}
+
 }  // namespace
 
 Sched::Thread *PageFaultHandler(intr::LitExcEntry &, hal::ExceptionData *data)
@@ -58,21 +103,7 @@ Sched::Thread *PageFaultHandler(intr::LitExcEntry &, hal::ExceptionData *data)
     auto vma_res = as.FindAreaLocked(f_ptr);
 
     if (!vma_res) {
-        hal::KernelPanicFormat(
-            "Page fault in unmapped memory\n"
-            "Faulting address: %p\n"
-            "Instruction pointer: %p\n"
-            "Error details:\n"
-            "  - %s\n"
-            "  - %s\n"
-            "  - %s\n"
-            "  - %s\n"
-            "  - %s",
-            f_ptr, data->isr_stack_frame.rip, PresentDescription(err.present),
-            WriteDescription(err.write), UserModeDescription(err.user),
-            ReservedBitsDescription(err.reserved_bits),
-            InstructionFetchDescription(err.instruction_fetch)
-        );
+        HandleUnresolvableFault(pfd, *data);
         return nullptr;
     }
     VMemArea *vma = *(*vma_res);
@@ -80,41 +111,14 @@ Sched::Thread *PageFaultHandler(intr::LitExcEntry &, hal::ExceptionData *data)
     if (err.present) {
         // Protection violation
         // TODO: CoW handling would go here via vma->HandleProtectionFault()
-        hal::KernelPanicFormat(
-            "Unhandled protection fault\n"
-            "Faulting address: %p\n"
-            "Instruction pointer: %p\n"
-            "Error details:\n"
-            "  - %s\n"
-            "  - %s\n"
-            "  - %s\n"
-            "  - %s\n"
-            "  - %s",
-            f_ptr, data->isr_stack_frame.rip, PresentDescription(err.present),
-            WriteDescription(err.write), UserModeDescription(err.user),
-            ReservedBitsDescription(err.reserved_bits),
-            InstructionFetchDescription(err.instruction_fetch)
-        );
+        HandleUnresolvableFault(pfd, *data);
+        return nullptr;
     }
 
     // Delegate to VMA
     // The VMA knows if it's anonymous, file-backed, or MMIO, and handles it accordingly.
     if (!vma->HandleFault(f_ptr, err, as)) {
-        hal::KernelPanicFormat(
-            "Failed to resolve page fault\n"
-            "Faulting address: %p\n"
-            "Instruction pointer: %p\n"
-            "Error details:\n"
-            "  - %s\n"
-            "  - %s\n"
-            "  - %s\n"
-            "  - %s\n"
-            "  - %s",
-            f_ptr, data->isr_stack_frame.rip, PresentDescription(err.present),
-            WriteDescription(err.write), UserModeDescription(err.user),
-            ReservedBitsDescription(err.reserved_bits),
-            InstructionFetchDescription(err.instruction_fetch)
-        );
+        HandleUnresolvableFault(pfd, *data);
     }
     return nullptr;
 }
diff --git a/kernel/src/syscalls/calls/panic.hpp b/kernel/src/syscalls/calls/panic.hpp
index 58fddbc5..ee0c0afb 100644
--- a/kernel/src/syscalls/calls/panic.hpp
+++ b/kernel/src/syscalls/calls/panic.hpp
@@ -4,6 +4,10 @@
 #include <defines.h>
 
 #include "hal/panic.hpp"
+#include "hardware/core_local.hpp"
+#include "modules/hardware.hpp"
+#include "modules/scheduling.hpp"
+#include "trace_framework.hpp"
 
 namespace Syscall
 {
@@ -18,7 +22,16 @@ namespace Syscall
  */
 NO_RET FORCE_INLINE_F void SysPanic(const char *msg)
 {
-    hal::KernelPanic(msg);
+    auto pid = hardware::GetRunningPid();
+
+    if (msg == nullptr || *msg == '\0') {
+        TRACE_WARN_GENERAL("User Panic in PID %llu: No message provided", pid.id);
+    } else {
+        TRACE_WARN_GENERAL("User Panic in PID %llu: %s", pid.id, msg);
+    }
+
+    SchedulingModule::Get().GetTaskMgr().CommitSuicide(pid);
+
     __builtin_unreachable();
 }
 

From d6116df9d9064c1cd268433e9343bd4b5541e921 Mon Sep 17 00:00:00 2001
From: Adam Ogieniewski <ogieniewski.dev@gmail.com>
Date: Sun, 4 Jan 2026 04:58:53 +0100
Subject: [PATCH 47/56] Port shell to userspace (#270)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Relocates shell from kernel to userspace.
- Adds syscalls for directory listing, file info, and power management.
- Refactors graphics code into a standalone `libgraphics` library.
- Updates CRT0 and build system to support C++ global constructors.
- Fixes x86_64 syscall argument passing for SysV ABI compatibility.

---------

Co-authored-by: Łukasz Kryczka <lukasz.kryczka000@gmail.com>
---
 CMakeLists.txt                                |   3 +-
 cmake/MiscHelpers.cmake                       |  15 +-
 kernel/CMakeLists.txt                         |  12 +
 kernel/arch/x86_64/CMakeLists.txt             |   2 +-
 kernel/arch/x86_64/build/kernel.ld            |  16 +-
 kernel/arch/x86_64/src/hal/impl/mmu.cpp       |   2 +-
 kernel/arch/x86_64/src/hal/impl/mmu.tpp       |   2 +-
 kernel/arch/x86_64/src/interrupts/idt.nasm    |   9 +-
 kernel/src/constants.hpp                      |   3 +-
 kernel/src/drivers/video/framebuffer.cpp      |   5 +-
 kernel/src/drivers/video/framebuffer.hpp      |   7 +-
 kernel/src/fs/file_descriptor.hpp             |   3 +-
 kernel/src/fs/vfs/fat/fat.hpp                 |  13 +-
 kernel/src/fs/vfs/path.hpp                    |   2 +-
 kernel/src/hal/mmu.hpp                        |   2 +-
 kernel/src/io/pipe.hpp                        |   2 +-
 kernel/src/io/stream.hpp                      |   2 +-
 kernel/src/kernel.cpp                         |   4 +-
 kernel/src/libc_backend.cpp                   |   2 -
 kernel/src/mem/allocators.hpp                 |   2 +-
 kernel/src/mem/heap.cpp                       |   2 +-
 kernel/src/mem/mmu/contexts.hpp               |   6 +-
 kernel/src/mem/phys/mngr/bitmap.cpp           |   2 +-
 kernel/src/mem/phys/mngr/buddy.cpp            |   2 +-
 kernel/src/mem/phys/mngr/slab.cpp             |   2 +-
 kernel/src/mem/types.hpp                      |   3 +-
 kernel/src/mem/virt/addr_space.cpp            |   2 +-
 kernel/src/mem/virt/vmm.cpp                   |   2 +-
 kernel/src/modules/vfs.cpp                    |   2 +-
 kernel/src/modules/video.cpp                  |   9 +-
 kernel/src/modules/video.hpp                  |   1 +
 kernel/src/syscalls/calls/fd.hpp              |  86 ++++
 kernel/src/syscalls/calls/io.hpp              |  11 -
 kernel/src/syscalls/calls/power.hpp           |  26 ++
 kernel/src/syscalls/syscalls.cpp              |  14 +-
 kernel/src/syscalls/syscalls.hpp              |  18 +-
 kernel/src/video/window_manager.hpp           |   3 +-
 libs/CMakeLists.txt                           |   4 -
 libs/libc/CMakeLists.txt                      |  33 +-
 libs/libc/arch/x86_64/CMakeLists.txt          |  16 +
 libs/libc/arch/x86_64/cxx/crti.nasm           |  13 +
 libs/libc/arch/x86_64/cxx/crtn.nasm           |  11 +
 libs/libc/src/abi/platform.h                  |  14 +-
 libs/libc/src/include/alkos/fd.h              |  19 +
 libs/libc/src/include/alkos/power.h           |   9 +
 libs/libc/src/include/alkos/structs.h         |   2 +
 libs/libc/src/include/alkos/sys/fd.h          |  26 ++
 libs/libc/src/include/alkos/sys/power.h       |  12 +
 libs/libc/src/include/alkos/sys/video.h       |  43 ++
 libs/libc/src/include/alkos/syscall.h         |  16 +-
 libs/libc/src/include/alkos/video.h           |  36 +-
 libs/libc/src/include/defines.h               |   3 +
 libs/libc/src/internal/crt0.cpp               |  41 +-
 libs/libc/src/internal/libc_backend.cpp       |  15 +-
 libs/libc/src/internal/stdio.hpp              |   3 -
 .../data_structures/array_structures.hpp      |   1 +
 .../libcpp/include/internal}/macros.hpp       |   8 +-
 {kernel/src => libs/libcpp/include}/todo.hpp  |   6 +-
 libs/libgraphics/CMakeLists.txt               |  14 +
 .../libgraphics/include}/color.hpp            |   6 +-
 .../libgraphics/include}/font/glyph.hpp       |   6 +-
 .../libgraphics/include}/font/psf2_font.hpp   |  10 +-
 .../libgraphics/include}/fonts/drdos8x8.hpp   |   6 +-
 .../libgraphics/include}/geometry.hpp         |   6 +-
 .../libgraphics/include}/native_pixel.hpp     |   9 +-
 .../libgraphics/include}/painter.hpp          |  20 +-
 .../libgraphics/include}/painter.tpp          |   0
 .../libgraphics/include}/surface.hpp          |  24 +-
 .../libgraphics/src}/painter.cpp              |   3 +-
 userspace/CMakeLists.txt                      |  75 ++-
 userspace/build/linker.ld                     |  36 --
 userspace/build/x86_64/linker.ld              |  74 +++
 userspace/programs/gui_test/CMakeLists.txt    |  23 +-
 userspace/programs/hello_world/CMakeLists.txt |   2 +-
 userspace/programs/shell/CMakeLists.txt       |  25 +
 .../programs/shell}/graphics_console.cpp      |   3 +-
 .../programs/shell}/graphics_console.hpp      |  16 +-
 userspace/programs/shell/main.cpp             |  31 ++
 userspace/programs/shell/path.hpp             | 427 ++++++++++++++++++
 .../programs/shell}/shell.cpp                 | 154 +++----
 .../programs/shell}/shell.hpp                 |  21 +-
 userspace/programs/shell/stream.hpp           |  58 +++
 82 files changed, 1308 insertions(+), 371 deletions(-)
 create mode 100644 kernel/src/syscalls/calls/power.hpp
 delete mode 100644 libs/CMakeLists.txt
 create mode 100644 libs/libc/arch/x86_64/cxx/crti.nasm
 create mode 100644 libs/libc/arch/x86_64/cxx/crtn.nasm
 create mode 100644 libs/libc/src/include/alkos/power.h
 create mode 100644 libs/libc/src/include/alkos/sys/power.h
 create mode 100644 libs/libc/src/include/alkos/sys/video.h
 rename {kernel/src => libs/libcpp/include/internal}/macros.hpp (60%)
 rename {kernel/src => libs/libcpp/include}/todo.hpp (90%)
 create mode 100644 libs/libgraphics/CMakeLists.txt
 rename {kernel/src/graphics => libs/libgraphics/include}/color.hpp (83%)
 rename {kernel/src/graphics => libs/libgraphics/include}/font/glyph.hpp (78%)
 rename {kernel/src/graphics => libs/libgraphics/include}/font/psf2_font.hpp (94%)
 rename {kernel/src/graphics => libs/libgraphics/include}/fonts/drdos8x8.hpp (99%)
 rename {kernel/src/graphics => libs/libgraphics/include}/geometry.hpp (73%)
 rename {kernel/src/graphics => libs/libgraphics/include}/native_pixel.hpp (87%)
 rename {kernel/src/graphics => libs/libgraphics/include}/painter.hpp (82%)
 rename {kernel/src/graphics => libs/libgraphics/include}/painter.tpp (100%)
 rename {kernel/src/graphics => libs/libgraphics/include}/surface.hpp (79%)
 rename {kernel/src/graphics => libs/libgraphics/src}/painter.cpp (98%)
 delete mode 100644 userspace/build/linker.ld
 create mode 100644 userspace/build/x86_64/linker.ld
 create mode 100644 userspace/programs/shell/CMakeLists.txt
 rename {kernel/src/sys => userspace/programs/shell}/graphics_console.cpp (98%)
 rename {kernel/src/sys => userspace/programs/shell}/graphics_console.hpp (85%)
 create mode 100644 userspace/programs/shell/main.cpp
 create mode 100644 userspace/programs/shell/path.hpp
 rename {kernel/src/sys => userspace/programs/shell}/shell.cpp (70%)
 rename {kernel/src/sys => userspace/programs/shell}/shell.hpp (81%)
 create mode 100644 userspace/programs/shell/stream.hpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 26a6a4db..44774d73 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -22,6 +22,7 @@ include(ValidationHelpers)
 include(SourceHelpers)
 include(RuntimeHelpers)
 include(BashConfigHelpers)
+include(MiscHelpers)
 
 add_library(alkos.target.properties.interface INTERFACE) # Populated by the toolchain file
 
@@ -94,7 +95,7 @@ file(MAKE_DIRECTORY ${CMAKE_SYSROOT}/boot/grub)
 
 set(SYSTEM_LIB_TYPE k)
 
-add_subdirectory(libs)
+alkos_add_subdirs(libs)
 add_subdirectory(generated)
 add_subdirectory(kernel)
 add_subdirectory(userspace)
diff --git a/cmake/MiscHelpers.cmake b/cmake/MiscHelpers.cmake
index 60f91541..c6ff61bc 100644
--- a/cmake/MiscHelpers.cmake
+++ b/cmake/MiscHelpers.cmake
@@ -9,13 +9,20 @@
 ## Parameters:
 #   BASE_DIR          The base directory to search for subdirectories.
 ## Example:
+#   alkos_add_subdirs(modules)
 #   alkos_add_subdirs(${CMAKE_CURRENT_SOURCE_DIR}/modules)
 #
 function(alkos_add_subdirs BASE_DIR)
-    file(GLOB directories RELATIVE "${BASE_DIR}" "${BASE_DIR}/*")
-    foreach(dir ${directories})
-        if(IS_DIRECTORY "${BASE_DIR}/${dir}")
-            add_subdirectory("${BASE_DIR}/${dir}")
+    if(IS_ABSOLUTE "${BASE_DIR}")
+        set(base_dir "${BASE_DIR}")
+    else()
+        set(base_dir "${CMAKE_CURRENT_SOURCE_DIR}/${BASE_DIR}")
+    endif()
+
+    file(GLOB subdirs RELATIVE "${base_dir}" "${base_dir}/*")
+    foreach(subdir ${subdirs})
+        if(IS_DIRECTORY "${base_dir}/${subdir}")
+            add_subdirectory("${base_dir}/${subdir}")
         endif()
     endforeach()
 endfunction()
diff --git a/kernel/CMakeLists.txt b/kernel/CMakeLists.txt
index f2bca76b..95eb5ce3 100644
--- a/kernel/CMakeLists.txt
+++ b/kernel/CMakeLists.txt
@@ -68,6 +68,17 @@ target_link_libraries(cpp PUBLIC
 target_compile_definitions(c PRIVATE __ALKOS_KERNEL_LIBC__)
 target_compile_definitions(cpp PRIVATE __ALKOS_KERNEL_LIBCPP__)
 
+########################### Graphics Library #################################
+
+add_library(kernel.libgraphics STATIC ${LIBGRAPHICS_SOURCES})
+
+target_link_libraries(kernel.libgraphics PUBLIC
+    alkos.libgraphics.interface
+    alkos.target.properties.interface
+)
+
+target_compile_definitions(kernel.libgraphics PRIVATE __ALKOS_KERNEL_LIBGRAPHICS__)
+
 ########################## Configure for given Arch ##########################
 
 add_subdirectory(arch/${ARCH})
@@ -89,6 +100,7 @@ target_link_libraries(alkos.kernel PRIVATE
     alkos.autogen.interface
     c
     cpp
+    kernel.libgraphics
 )
 
 ############## Linker Configuration for CXX Global Constructors ##############
diff --git a/kernel/arch/x86_64/CMakeLists.txt b/kernel/arch/x86_64/CMakeLists.txt
index ec7f105b..7d5271f0 100644
--- a/kernel/arch/x86_64/CMakeLists.txt
+++ b/kernel/arch/x86_64/CMakeLists.txt
@@ -58,7 +58,7 @@ alkos_register_runtime_environment(
     QEMU_COMMAND
         "qemu-system-x86_64"
     QEMU_NORMAL_FLAGS
-        "-serial stdio -enable-kvm -cpu max,+invtsc,migratable=off -machine type=q35,accel=kvm -display default,show-cursor=on -k en-us -m 4G -smp sockets=1,cores=4,threads=1  -no-reboot"
+        "-serial stdio -enable-kvm -cpu max,+invtsc,migratable=off -machine type=q35,accel=kvm -display default,show-cursor=on -k en-us -m 4G -smp sockets=1,cores=4,threads=1 -no-reboot"
     QEMU_TEST_FLAGS
         "-serial stdio -enable-kvm -cpu max,+invtsc,migratable=off -machine type=q35,accel=kvm -display none -m 4G -smp sockets=1,cores=4,threads=1 -no-reboot"
     MODULES
diff --git a/kernel/arch/x86_64/build/kernel.ld b/kernel/arch/x86_64/build/kernel.ld
index ed6d5668..ff19bbdf 100644
--- a/kernel/arch/x86_64/build/kernel.ld
+++ b/kernel/arch/x86_64/build/kernel.ld
@@ -8,14 +8,14 @@ SECTIONS
 	. = kKernelBase;
 
 	.init BLOCK(4K) : ALIGN(4K)
-          {
-                    *(.init)
-          }
-
-          .fini BLOCK(4K) : ALIGN(4K)
-          {
-                    *(.fini)
-          }
+    {
+        *(.init)
+    }
+
+    .fini BLOCK(4K) : ALIGN(4K)
+    {
+        *(.fini)
+    }
 
 	.text BLOCK(4K) : ALIGN(4K)
 	{
diff --git a/kernel/arch/x86_64/src/hal/impl/mmu.cpp b/kernel/arch/x86_64/src/hal/impl/mmu.cpp
index 1e81c6d2..09eb1a92 100644
--- a/kernel/arch/x86_64/src/hal/impl/mmu.cpp
+++ b/kernel/arch/x86_64/src/hal/impl/mmu.cpp
@@ -1,7 +1,7 @@
 #include "hal/impl/mmu.hpp"
 
 #include <string.h>
-#include <macros.hpp>
+#include <internal/macros.hpp>
 
 #include "cpu/control_registers.hpp"
 #include "mem/page_map.hpp"
diff --git a/kernel/arch/x86_64/src/hal/impl/mmu.tpp b/kernel/arch/x86_64/src/hal/impl/mmu.tpp
index 120f753b..88de597e 100644
--- a/kernel/arch/x86_64/src/hal/impl/mmu.tpp
+++ b/kernel/arch/x86_64/src/hal/impl/mmu.tpp
@@ -2,7 +2,7 @@
 #define KERNEL_ARCH_X86_64_SRC_HAL_IMPL_MMU_TPP_
 
 #include "hal/impl/mmu.hpp"
-#include "macros.hpp"
+#include "internal/macros.hpp"
 #include "mem/page_map.hpp"
 
 #include <string.h>
diff --git a/kernel/arch/x86_64/src/interrupts/idt.nasm b/kernel/arch/x86_64/src/interrupts/idt.nasm
index bbae3b29..87638957 100644
--- a/kernel/arch/x86_64/src/interrupts/idt.nasm
+++ b/kernel/arch/x86_64/src/interrupts/idt.nasm
@@ -126,9 +126,6 @@ isr_wrapper_128:  ; Syscall interrupt (128)
     push_sysv_regs       ; Save registers
     cld                              ; Clear direction flag for string operations.
 
-    ; Syscall to Sys V ABI conversion
-    mov rcx, r10
-
     ; Check syscall number bounds
     cmp rax, [rel g_syscall_count]
     jae .invalid_syscall
@@ -138,6 +135,10 @@ isr_wrapper_128:  ; Syscall interrupt (128)
 
     ; Get pointer to syscall_dispatch_table and dispatch
     pop_sysv_regs
+
+    ; Syscall to Sys V ABI conversion
+    xchg r10, rcx                    ; arg3
+
     call qword [rel g_syscall_dispatch_table + rax*8]
     mov qword [rsp + _rax], rax
     jmp .return
@@ -152,7 +153,7 @@ isr_wrapper_128:  ; Syscall interrupt (128)
     call cdecl_SetKernelGs
     swapgs
 
-    pop_sysv_regs        ; Restore registers
+    pop_sysv_regs                    ; Restore registers.
     add rsp, _sysv_reg_size          ; Deallocate register save space.
     iretq                            ; Return from interrupt.
 
diff --git a/kernel/src/constants.hpp b/kernel/src/constants.hpp
index aa17be7e..65c96f52 100644
--- a/kernel/src/constants.hpp
+++ b/kernel/src/constants.hpp
@@ -1,7 +1,8 @@
 #ifndef KERNEL_SRC_CONSTANTS_HPP_
 #define KERNEL_SRC_CONSTANTS_HPP_
 
-#include "types.h"
+#include <types.h>
+#include <defines.hpp>
 
 static constexpr u16 kMaxProcesses    = 4096;
 static constexpr u32 kMaxThreads      = kMaxProcesses * 2;
diff --git a/kernel/src/drivers/video/framebuffer.cpp b/kernel/src/drivers/video/framebuffer.cpp
index 2d9789a0..d5963f1d 100644
--- a/kernel/src/drivers/video/framebuffer.cpp
+++ b/kernel/src/drivers/video/framebuffer.cpp
@@ -1,7 +1,6 @@
 #include "drivers/video/framebuffer.hpp"
-#include "defines.hpp"
-#include "graphics/native_pixel.hpp"
-#include "trace_framework.hpp"
+
+#include "native_pixel.hpp"
 
 using namespace Drivers::Video;
 
diff --git a/kernel/src/drivers/video/framebuffer.hpp b/kernel/src/drivers/video/framebuffer.hpp
index b60a7255..938ee6e9 100644
--- a/kernel/src/drivers/video/framebuffer.hpp
+++ b/kernel/src/drivers/video/framebuffer.hpp
@@ -1,11 +1,10 @@
 #ifndef KERNEL_SRC_DRIVERS_VIDEO_FRAMEBUFFER_HPP_
 #define KERNEL_SRC_DRIVERS_VIDEO_FRAMEBUFFER_HPP_
 
+#include <color.hpp>
+#include <surface.hpp>
+
 #include <expected.hpp>
-#include "graphics/color.hpp"
-#include "graphics/native_pixel.hpp"
-#include "graphics/surface.hpp"
-#include "mem/heap.hpp"
 
 namespace Drivers::Video
 {
diff --git a/kernel/src/fs/file_descriptor.hpp b/kernel/src/fs/file_descriptor.hpp
index ca58f7ba..165a0983 100644
--- a/kernel/src/fs/file_descriptor.hpp
+++ b/kernel/src/fs/file_descriptor.hpp
@@ -33,10 +33,11 @@ enum class FdError {
     kFdTableFull,
     kBadFileDescriptor,
     kNotOpen,
+    kNotFound,
     kAlreadyClosed,
     kPermissionDenied,
     kInvalidArgument,
-    kIoError
+    kIoError,
 };
 
 template <typename T = void>
diff --git a/kernel/src/fs/vfs/fat/fat.hpp b/kernel/src/fs/vfs/fat/fat.hpp
index 4f8c3375..5cf206cd 100644
--- a/kernel/src/fs/vfs/fat/fat.hpp
+++ b/kernel/src/fs/vfs/fat/fat.hpp
@@ -3,16 +3,17 @@
 
 #include <ctype.h>
 #include <string.h>
-#include <fs/vfs/error.hpp>
-#include <fs/vfs/interface.hpp>
-#include <fs/vfs/path.hpp>
-#include <fs/vfs/types.hpp>
+#include <internal/macros.hpp>
 #include <internal/span.hpp>
 #include <span.hpp>
 #include <string.hpp>
 #include <template_lib.hpp>
-#include <trace_framework.hpp>
-#include "macros.hpp"
+
+#include "fs/vfs/error.hpp"
+#include "fs/vfs/interface.hpp"
+#include "fs/vfs/path.hpp"
+#include "fs/vfs/types.hpp"
+#include "trace_framework.hpp"
 
 namespace vfs
 {
diff --git a/kernel/src/fs/vfs/path.hpp b/kernel/src/fs/vfs/path.hpp
index 93006285..40b1b11d 100644
--- a/kernel/src/fs/vfs/path.hpp
+++ b/kernel/src/fs/vfs/path.hpp
@@ -15,7 +15,7 @@ inline constexpr size_t kMaxComponents    = 64;
 inline constexpr size_t kMaxComponentSize = 128;
 inline constexpr char kPathSeparator      = '/';
 
-// Ccncepts
+// Concepts
 template <typename T>
 concept PathStringLike = std::convertible_to<T, std::string_view>;
 
diff --git a/kernel/src/hal/mmu.hpp b/kernel/src/hal/mmu.hpp
index e07edc88..1cf2f55d 100644
--- a/kernel/src/hal/mmu.hpp
+++ b/kernel/src/hal/mmu.hpp
@@ -2,7 +2,7 @@
 #define KERNEL_SRC_HAL_MMU_HPP_
 
 #include <hal/impl/mmu.hpp>
-#include <macros.hpp>
+#include <internal/macros.hpp>
 
 #include "hal/constants.hpp"
 #include "mem/mmu/contexts.hpp"
diff --git a/kernel/src/io/pipe.hpp b/kernel/src/io/pipe.hpp
index 84d9c5f3..2cbdfec4 100644
--- a/kernel/src/io/pipe.hpp
+++ b/kernel/src/io/pipe.hpp
@@ -3,8 +3,8 @@
 
 #include <data_structures/atomic_cyclic_buffer.hpp>
 
+#include "internal/macros.hpp"
 #include "io/stream.hpp"
-#include "macros.hpp"
 
 namespace IO
 {
diff --git a/kernel/src/io/stream.hpp b/kernel/src/io/stream.hpp
index 9ab2bded..bdde1d08 100644
--- a/kernel/src/io/stream.hpp
+++ b/kernel/src/io/stream.hpp
@@ -4,7 +4,7 @@
 #include <expected.hpp>
 #include <span.hpp>
 
-#include "macros.hpp"
+#include "internal/macros.hpp"
 
 #include "io/error.hpp"
 #include "mem/types.hpp"
diff --git a/kernel/src/kernel.cpp b/kernel/src/kernel.cpp
index e440d271..5461e77a 100644
--- a/kernel/src/kernel.cpp
+++ b/kernel/src/kernel.cpp
@@ -38,8 +38,8 @@ static void KernelRun()
     for (volatile size_t i = 0; i < 1'000'000; i = i + 1) {
     }
 
-    const auto res2 = task_mgr.ExecuteElf64("/bin/gui_test", {});
-    R_ASSERT_TRUE(static_cast<bool>(res2), "Failed to spawn /bin/gui process...");
+    const auto res2 = task_mgr.ExecuteElf64("/bin/shell", {});
+    R_ASSERT_TRUE(static_cast<bool>(res2), "Failed to spawn /bin/shell process...");
 
     SchedulingModule::Get().GetScheduler().ConvertToScheduling();
 }
diff --git a/kernel/src/libc_backend.cpp b/kernel/src/libc_backend.cpp
index 881faab7..774a7def 100644
--- a/kernel/src/libc_backend.cpp
+++ b/kernel/src/libc_backend.cpp
@@ -31,6 +31,4 @@ size_t __platform_debug_read_line(char *buffer, const size_t buffer_size)
     return SysDebugReadLine(buffer, buffer_size);
 }
 
-void __platform_write_console(const char *buffer) { SysWriteConsole(buffer); }
-
 #endif
diff --git a/kernel/src/mem/allocators.hpp b/kernel/src/mem/allocators.hpp
index ffa1d4ef..ab745479 100644
--- a/kernel/src/mem/allocators.hpp
+++ b/kernel/src/mem/allocators.hpp
@@ -1,7 +1,7 @@
 #ifndef KERNEL_SRC_MEM_ALLOCATORS_HPP_
 #define KERNEL_SRC_MEM_ALLOCATORS_HPP_
 
-#include <macros.hpp>
+#include <internal/macros.hpp>
 #include "bits_ext.hpp"
 #include "mem/heap.hpp"
 
diff --git a/kernel/src/mem/heap.cpp b/kernel/src/mem/heap.cpp
index 1d85e120..7914b09d 100644
--- a/kernel/src/mem/heap.cpp
+++ b/kernel/src/mem/heap.cpp
@@ -1,6 +1,6 @@
 #include "mem/heap.hpp"
 
-#include <macros.hpp>
+#include <internal/macros.hpp>
 
 #include "hal/constants.hpp"
 #include "mem/page_meta_table.hpp"
diff --git a/kernel/src/mem/mmu/contexts.hpp b/kernel/src/mem/mmu/contexts.hpp
index be352d03..f16314de 100644
--- a/kernel/src/mem/mmu/contexts.hpp
+++ b/kernel/src/mem/mmu/contexts.hpp
@@ -2,8 +2,7 @@
 #define KERNEL_SRC_MEM_MMU_CONTEXTS_HPP_
 
 #include <expected.hpp>
-#include <hal/api/mmu.hpp>
-#include <macros.hpp>
+#include <internal/macros.hpp>
 
 #include "hal/constants.hpp"
 #include "mem/page_meta_table.hpp"
@@ -32,8 +31,7 @@ class KernelMmuContext
     std::expected<Mem::PPtr<void>, Mem::MemError> AllocateTable(uint8_t level)
     {
         auto res = pmm_->Alloc({.order = 0});
-        if (!res)
-            return std::unexpected(res.error());
+        RET_UNEXPECTED_IF_ERR(res);
         auto ptr = *res;
         memset(Mem::PhysToVirt(ptr), 0, hal::kPageSizeBytes);
 
diff --git a/kernel/src/mem/phys/mngr/bitmap.cpp b/kernel/src/mem/phys/mngr/bitmap.cpp
index 34a833d2..64c7c315 100644
--- a/kernel/src/mem/phys/mngr/bitmap.cpp
+++ b/kernel/src/mem/phys/mngr/bitmap.cpp
@@ -2,7 +2,7 @@
 
 #include <data_structures/bit_array.hpp>
 #include <expected.hpp>
-#include <macros.hpp>
+#include <internal/macros.hpp>
 #include "hal/constants.hpp"
 #include "mem/page_meta.hpp"
 #include "mem/types.hpp"
diff --git a/kernel/src/mem/phys/mngr/buddy.cpp b/kernel/src/mem/phys/mngr/buddy.cpp
index d2793126..5cc84533 100644
--- a/kernel/src/mem/phys/mngr/buddy.cpp
+++ b/kernel/src/mem/phys/mngr/buddy.cpp
@@ -1,7 +1,7 @@
 #include "mem/phys/mngr/buddy.hpp"
 
 #include <algorithm.hpp>
-#include <macros.hpp>
+#include <internal/macros.hpp>
 #include <mutex.hpp>
 
 #include "mem/page_meta_table.hpp"
diff --git a/kernel/src/mem/phys/mngr/slab.cpp b/kernel/src/mem/phys/mngr/slab.cpp
index dca6384c..4b1a1d09 100644
--- a/kernel/src/mem/phys/mngr/slab.cpp
+++ b/kernel/src/mem/phys/mngr/slab.cpp
@@ -1,7 +1,7 @@
 #include "mem/phys/mngr/slab.hpp"
 
+#include <internal/macros.hpp>
 #include <limits.hpp>
-#include <macros.hpp>
 #include <mutex.hpp>
 
 #include "mem/page_meta_table.hpp"
diff --git a/kernel/src/mem/types.hpp b/kernel/src/mem/types.hpp
index 511d5cd2..a5d5da87 100644
--- a/kernel/src/mem/types.hpp
+++ b/kernel/src/mem/types.hpp
@@ -2,8 +2,7 @@
 #define KERNEL_SRC_MEM_TYPES_HPP_
 
 #include <types.h>
-#include <expected.hpp>
-#include <type_traits.hpp>
+
 #include "constants.hpp"
 #include "hal/constants.hpp"
 
diff --git a/kernel/src/mem/virt/addr_space.cpp b/kernel/src/mem/virt/addr_space.cpp
index 2e85196a..0dc20237 100644
--- a/kernel/src/mem/virt/addr_space.cpp
+++ b/kernel/src/mem/virt/addr_space.cpp
@@ -1,6 +1,6 @@
 #include "mem/virt/addr_space.hpp"
 
-#include <macros.hpp>
+#include <internal/macros.hpp>
 #include <mutex.hpp>
 
 #include <template/scope_guard.hpp>
diff --git a/kernel/src/mem/virt/vmm.cpp b/kernel/src/mem/virt/vmm.cpp
index a175b4ae..85c4828e 100644
--- a/kernel/src/mem/virt/vmm.cpp
+++ b/kernel/src/mem/virt/vmm.cpp
@@ -1,7 +1,7 @@
 #include "mem/virt/vmm.hpp"
 
 #include <bits_ext.hpp>
-#include <macros.hpp>
+#include <internal/macros.hpp>
 #include <template/scope_guard.hpp>
 
 #include "constants.hpp"
diff --git a/kernel/src/modules/vfs.cpp b/kernel/src/modules/vfs.cpp
index 503a464b..8bc6cef4 100644
--- a/kernel/src/modules/vfs.cpp
+++ b/kernel/src/modules/vfs.cpp
@@ -8,7 +8,7 @@
 #include <mem/types.hpp>
 #include <trace_framework.hpp>
 #include "boot_args.hpp"
-#include "macros.hpp"
+#include "internal/macros.hpp"
 
 using namespace vfs;
 
diff --git a/kernel/src/modules/video.cpp b/kernel/src/modules/video.cpp
index 98411f60..ce6c3953 100644
--- a/kernel/src/modules/video.cpp
+++ b/kernel/src/modules/video.cpp
@@ -1,9 +1,10 @@
 #include "modules/video.hpp"
-#include "graphics/native_pixel.hpp"
-#include "graphics/painter.hpp"
 #include "mem/types.hpp"
 #include "trace_framework.hpp"
 
+#include <native_pixel.hpp>
+#include <painter.hpp>
+
 using namespace Graphics;
 using namespace Drivers;
 using namespace Mem;
@@ -13,11 +14,11 @@ internal::VideoModule::VideoModule(const BootArguments &args, Heap &hp) noexcept
     DEBUG_INFO_GENERAL("VideoModule::VideoModule()");
 
     const auto &fb_args = args.fb_args;
-    auto *fb_pptr       = static_cast<PPtr<Graphics::NativePixel>>(fb_args.base_address);
+    auto *fb_pptr       = static_cast<PPtr<NativePixel>>(fb_args.base_address);
 
     R_ASSERT_NOT_NULL(fb_pptr, "VideoModule: Framebuffer is null");
 
-    auto s  = Surface(Mem::PhysToVirt(fb_pptr), fb_args.width, fb_args.height, fb_args.pitch);
+    auto s  = Surface(PhysToVirt(fb_pptr), fb_args.width, fb_args.height, fb_args.pitch);
     auto pf = PixelFormat{
         .red_pos         = fb_args.red_pos,
         .red_mask_size   = fb_args.red_mask_size,
diff --git a/kernel/src/modules/video.hpp b/kernel/src/modules/video.hpp
index 37c25c37..c8d85590 100644
--- a/kernel/src/modules/video.hpp
+++ b/kernel/src/modules/video.hpp
@@ -5,6 +5,7 @@
 
 #include "boot_args.hpp"
 #include "drivers/video/framebuffer.hpp"
+#include "mem/heap.hpp"
 #include "modules/helpers.hpp"
 #include "video/window_manager.hpp"
 
diff --git a/kernel/src/syscalls/calls/fd.hpp b/kernel/src/syscalls/calls/fd.hpp
index 2f903d28..6bcf022e 100644
--- a/kernel/src/syscalls/calls/fd.hpp
+++ b/kernel/src/syscalls/calls/fd.hpp
@@ -86,6 +86,92 @@ FORCE_INLINE_F Fs::FdResult<fd_t> SysDupTo(fd_t old_fd, fd_t new_fd)
     return ::VfsModule::Get().GetFdManager().Duplicate(old_fd, new_fd);
 }
 
+/**
+ * @brief Read directory entries
+ * @param path Path to the directory
+ * @param entries Buffer to store directory entries
+ * @param num_entries Output: actual number of entries read
+ * @return Success or error
+ */
+FORCE_INLINE_F Fs::FdResult<void> SysReadDirectory(
+    const vfs::Path &path, std::span<DirEntry> entries, size_t *num_entries
+)
+{
+    auto &vfs = ::VfsModule::Get();
+
+    // Check if directory exists
+    auto exists_result = vfs.DirectoryExists(path);
+    if (!exists_result.has_value() || !exists_result.value()) {
+        return std::unexpected(Fs::FdError::kNotFound);
+    }
+
+    size_t count = 0;
+
+    // List directory and populate entries
+    vfs.ListDirectory(path, [&](const char *name, bool is_dir) {
+        if (count >= entries.size()) {
+            return;  // No more space
+        }
+
+        auto &entry = entries[count];
+
+        // Copy name
+        strncpy(entry.name, name, sizeof(entry.name) - 1);
+        entry.name[sizeof(entry.name) - 1] = '\0';
+
+        // Set type
+        entry.type = is_dir ? kFileTypeDirectory : kFileTypeRegular;
+
+        count++;
+    });
+
+    if (num_entries != nullptr) {
+        *num_entries = count;
+    }
+
+    return {};
+}
+
+/**
+ * @brief Get file information
+ * @param path Path to the file
+ * @param info Output: file information structure
+ * @return Success or error
+ */
+FORCE_INLINE_F Fs::FdResult<void> SysFileInfo(const vfs::Path &path, FileInfo *info)
+{
+    if (info == nullptr) {
+        return std::unexpected(Fs::FdError::kInvalidArgument);
+    }
+
+    auto &vfs = ::VfsModule::Get();
+
+    // Check if path exists
+    auto exists_result = vfs.Exists(path);
+    if (!exists_result.has_value() || !exists_result.value()) {
+        return std::unexpected(Fs::FdError::kNotFound);
+    }
+
+    // Determine if it's a file or directory
+    auto is_dir_result = vfs.DirectoryExists(path);
+    if (is_dir_result.has_value() && is_dir_result.value()) {
+        info->type = kFileTypeDirectory;
+        info->size = 0;
+    } else {
+        info->type = kFileTypeRegular;
+
+        // Get file size
+        auto size_result = vfs.GetFileSize(path);
+        if (size_result.has_value()) {
+            info->size = size_result.value();
+        } else {
+            info->size = 0;
+        }
+    }
+
+    return {};
+}
+
 }  // namespace Syscall
 
 #endif  // KERNEL_SRC_SYSCALLS_CALLS_FD_HPP_
diff --git a/kernel/src/syscalls/calls/io.hpp b/kernel/src/syscalls/calls/io.hpp
index b0626fff..fa3f9ed7 100644
--- a/kernel/src/syscalls/calls/io.hpp
+++ b/kernel/src/syscalls/calls/io.hpp
@@ -5,7 +5,6 @@
 #include <types.h>
 
 #include "hal/debug_terminal.hpp"
-#include "sys/shell.hpp"
 #include "trace_framework.hpp"
 
 namespace Syscall
@@ -32,16 +31,6 @@ FORCE_INLINE_F u64 SysDebugReadLine(char *buffer, size_t buffer_size)
     return hal::DebugTerminalReadLine(buffer, buffer_size);
 }
 
-// !!! TEMPORARY !!!
-FORCE_INLINE_F void SysWriteConsole(const char *buffer)
-{
-    if (System::g_active_console) {
-        System::g_active_console->Write(
-            std::span<const byte>(reinterpret_cast<const byte *>(buffer), strlen(buffer))
-        );
-    }
-}
-
 }  // namespace Syscall
 
 #endif  // KERNEL_SRC_SYSCALLS_CALLS_IO_HPP_
diff --git a/kernel/src/syscalls/calls/power.hpp b/kernel/src/syscalls/calls/power.hpp
new file mode 100644
index 00000000..3e409fab
--- /dev/null
+++ b/kernel/src/syscalls/calls/power.hpp
@@ -0,0 +1,26 @@
+#ifndef KERNEL_SRC_SYSCALLS_CALLS_POWER_HPP_
+#define KERNEL_SRC_SYSCALLS_CALLS_POWER_HPP_
+
+#include "acpi/acpi_power.hpp"
+#include "alkos/power.h"
+
+#include <defines.h>
+
+namespace Syscall
+{
+
+FORCE_INLINE_F void SysPower(PowerAction action)
+{
+    switch (action) {
+        case kShutdown:
+            ACPI::SystemShutdown();
+            break;
+        case kReboot:
+            ACPI::SystemReboot();
+            break;
+    }
+}
+
+}  // namespace Syscall
+
+#endif  // KERNEL_SRC_SYSCALLS_CALLS_POWER_HPP_
diff --git a/kernel/src/syscalls/syscalls.cpp b/kernel/src/syscalls/syscalls.cpp
index d65bca85..e1046cc5 100644
--- a/kernel/src/syscalls/syscalls.cpp
+++ b/kernel/src/syscalls/syscalls.cpp
@@ -19,15 +19,10 @@ constinit auto g_syscall_dispatch_table = SyscallDispatchTable<kSysMax>::Create<
     // Debug IO syscalls
     table.RegisterHandler<kSysDebugWrite, SysDebugWrite>();
     table.RegisterHandler<kSysDebugReadLine, SysDebugReadLine>();
-    table.RegisterHandler<kSysWriteConsole, SysWriteConsole>();
 
     // Panic syscall
     table.RegisterHandler<kSysPanic, SysPanic>();
 
-    // Video
-    table.RegisterHandler<kSysCreateGraphicSession, SysCreateGraphicSession>();
-    table.RegisterHandler<kSysBlit, SysBlit>();
-
     // File Descriptor syscalls
     table.RegisterHandler<kSysOpen, SysOpen>();
     table.RegisterHandler<kSysClose, SysClose>();
@@ -36,6 +31,8 @@ constinit auto g_syscall_dispatch_table = SyscallDispatchTable<kSysMax>::Create<
     table.RegisterHandler<kSysSeek, SysSeek>();
     table.RegisterHandler<kSysDup, SysDup>();
     table.RegisterHandler<kSysDupTo, SysDupTo>();
+    table.RegisterHandler<kSysReadDirectory, SysReadDirectory>();
+    table.RegisterHandler<kSysFileInfo, SysFileInfo>();
 
     /* Thread, processes */
     table.RegisterHandler<kProcAbort, SysAbort>();
@@ -45,6 +42,13 @@ constinit auto g_syscall_dispatch_table = SyscallDispatchTable<kSysMax>::Create<
     table.RegisterHandler<kThreadJoin, SysThreadJoin>();
     table.RegisterHandler<kThreadDetach, SysThreadDetach>();
 
+    // Video
+    table.RegisterHandler<kSysCreateGraphicSession, SysCreateGraphicSession>();
+    table.RegisterHandler<kSysBlit, SysBlit>();
+
+    // Power Management
+    table.RegisterHandler<kSysPower, SysPower>();
+
     return table;
 }>();
 
diff --git a/kernel/src/syscalls/syscalls.hpp b/kernel/src/syscalls/syscalls.hpp
index db91a4e1..f1c20883 100644
--- a/kernel/src/syscalls/syscalls.hpp
+++ b/kernel/src/syscalls/syscalls.hpp
@@ -1,26 +1,10 @@
 #ifndef KERNEL_SRC_SYSCALLS_SYSCALLS_HPP_
 #define KERNEL_SRC_SYSCALLS_SYSCALLS_HPP_
 
-#include <defines.h>
-#include <types.h>
-
-#include "dispatch_table.hpp"
-#include "hal/debug_terminal.hpp"
-#include "hal/panic.hpp"
-#include "modules/timing.hpp"
-#include "modules/timing_constants.hpp"
-#include "trace_framework.hpp"
-
-#include "hardware/core_local.hpp"
-
-#include <span.hpp>
-#include <sys/shell.hpp>
-
-/* Syscalls */
-
 #include "calls/fd.hpp"
 #include "calls/io.hpp"
 #include "calls/panic.hpp"
+#include "calls/power.hpp"
 #include "calls/proc.hpp"
 #include "calls/thread.hpp"
 #include "calls/time.hpp"
diff --git a/kernel/src/video/window_manager.hpp b/kernel/src/video/window_manager.hpp
index 35e77c2a..5100acea 100644
--- a/kernel/src/video/window_manager.hpp
+++ b/kernel/src/video/window_manager.hpp
@@ -7,6 +7,7 @@
 #include <tuple.hpp>
 
 #include "drivers/video/framebuffer.hpp"
+#include "mem/error.hpp"
 #include "mem/page.hpp"
 #include "mem/types.hpp"
 #include "scheduling/process.hpp"
@@ -60,7 +61,7 @@ class WindowManager
     void RefreshScreen();
 
     static constexpr size_t kMaxSessions    = 12;
-    static constexpr size_t kInvalidSession = size_t(-1);
+    static constexpr size_t kInvalidSession = static_cast<size_t>(-1);
     data_structures::StaticVector<GraphicSession, kMaxSessions> sessions_;
 
     size_t active_session_idx_{kInvalidSession};
diff --git a/libs/CMakeLists.txt b/libs/CMakeLists.txt
deleted file mode 100644
index 004c1ebb..00000000
--- a/libs/CMakeLists.txt
+++ /dev/null
@@ -1,4 +0,0 @@
-add_subdirectory(libc)
-add_subdirectory(libtemplate)
-add_subdirectory(libcpp)
-add_subdirectory(libcontainers)
diff --git a/libs/libc/CMakeLists.txt b/libs/libc/CMakeLists.txt
index cc88784d..7b93c256 100644
--- a/libs/libc/CMakeLists.txt
+++ b/libs/libc/CMakeLists.txt
@@ -12,8 +12,12 @@
 
 message(STATUS "Configuring LibC interface...")
 
-alkos_find_sources(ALKOS_LIBC_SOURCES)
-list(FILTER ALKOS_LIBC_SOURCES EXCLUDE REGEX "crt0\\.cpp$")
+# TODO: This currently works as interface to attach crti and crtn object files
+# And should probably be kept that way and renamed
+add_library(alkos.libc.config INTERFACE)
+
+set(exclude_patterns ".*/(arch/.*|crt0\\.cpp)$")
+alkos_find_sources(ALKOS_LIBC_SOURCES EXCLUDE ${exclude_patterns})
 set(ALKOS_LIBC_SOURCES ${ALKOS_LIBC_SOURCES} CACHE INTERNAL "Source files for libc")
 
 add_library(alkos.libc.interface INTERFACE)
@@ -21,19 +25,36 @@ add_library(alkos.libc.interface INTERFACE)
 target_include_directories(alkos.libc.interface INTERFACE
     "${CMAKE_CURRENT_SOURCE_DIR}/src/include"
     "${CMAKE_CURRENT_SOURCE_DIR}/src/abi"
+    "${CMAKE_CURRENT_SOURCE_DIR}/src/internal"
 
     # At the time of their making, both libc and libcpp were in the same directory
     # Decoupling them now brings too little benefit and too much complexity to justify the effort
     "${CMAKE_CURRENT_SOURCE_DIR}/../libcpp/include"
 )
 
-target_include_directories(alkos.libc.interface INTERFACE
-    "${CMAKE_CURRENT_SOURCE_DIR}/src/internal"
-)
-
 target_link_libraries(alkos.libc.interface INTERFACE
     alkos.libcpp.interface
     alkos.autogen.interface
 )
 
+################################################################################
+# CRT0 - C Runtime Startup Object Library
+################################################################################
+#
+# The CRT0 (C Runtime 0) contains the _start entry point for userspace programs
+# and is responsible for setting up the runtime environment before transferring
+# control to the main() function.
+#
+add_library(alkos.libc.crt0 OBJECT
+    src/internal/crt0.cpp
+)
+target_link_libraries(alkos.libc.crt0 PUBLIC alkos.libc.interface)
+
+set(CRT0_OBJ_PATH
+    "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/alkos.libc.crt0.dir/src/internal/crt0.cpp.o"
+)
+set_property(TARGET alkos.libc.config PROPERTY CRT0_OBJ "${CRT0_OBJ_PATH}")
+
+####################### Architecture-Specific Code ########################
+
 add_subdirectory(arch/${ARCH})
diff --git a/libs/libc/arch/x86_64/CMakeLists.txt b/libs/libc/arch/x86_64/CMakeLists.txt
index 7ccf4a72..be828d06 100644
--- a/libs/libc/arch/x86_64/CMakeLists.txt
+++ b/libs/libc/arch/x86_64/CMakeLists.txt
@@ -2,13 +2,29 @@ message(STATUS "  -> Configuring for x86_64")
 
 ############################### Adding Sources ###############################
 
+set(exclude_patterns ".*/(crti\\.nasm|crtn\\.nasm)$")
 alkos_target_sources(alkos.libc.interface
   SOURCES
     "${CMAKE_CURRENT_SOURCE_DIR}/*.c"
     "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/*.nasm"
+  EXCLUDE ${exclude_patterns}
 )
 
 target_include_directories(alkos.libc.interface INTERFACE
     ${CMAKE_CURRENT_SOURCE_DIR}
 )
+
+########################## CXX Global Constructors ###########################
+
+add_library(alkos.libc.crti OBJECT
+        cxx/crti.nasm
+)
+add_library(alkos.libc.crtn OBJECT
+        cxx/crtn.nasm
+)
+
+set(CRTI_OBJ_FILE_PATH "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/alkos.libc.crti.dir/cxx/crti.nasm.o")
+set(CRTN_OBJ_FILE_PATH "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/alkos.libc.crtn.dir/cxx/crtn.nasm.o")
+set_property(TARGET alkos.libc.config PROPERTY CRTI_OBJ "${CRTI_OBJ_FILE_PATH}")
+set_property(TARGET alkos.libc.config PROPERTY CRTN_OBJ "${CRTN_OBJ_FILE_PATH}")
diff --git a/libs/libc/arch/x86_64/cxx/crti.nasm b/libs/libc/arch/x86_64/cxx/crti.nasm
new file mode 100644
index 00000000..e0f82528
--- /dev/null
+++ b/libs/libc/arch/x86_64/cxx/crti.nasm
@@ -0,0 +1,13 @@
+section .init
+global _init
+_init:
+    push rbp
+    mov rbp, rsp
+    ; gcc will nicely put the contents of crtbegin.o's .init section here.
+
+section .fini
+global _fini
+_fini:
+    push rbp
+    mov rbp, rsp
+    ; gcc will nicely put the contents of crtbegin.o's .fini section here.
diff --git a/libs/libc/arch/x86_64/cxx/crtn.nasm b/libs/libc/arch/x86_64/cxx/crtn.nasm
new file mode 100644
index 00000000..ed8625c1
--- /dev/null
+++ b/libs/libc/arch/x86_64/cxx/crtn.nasm
@@ -0,0 +1,11 @@
+section .init
+
+    ; gcc will nicely put the contents of crtend.o's .init section here.
+    pop rbp
+    ret
+
+section .fini
+
+    ; gcc will nicely put the contents of crtend.o's .fini section here.
+    pop rbp
+    ret
diff --git a/libs/libc/src/abi/platform.h b/libs/libc/src/abi/platform.h
index cceab4c0..819559da 100644
--- a/libs/libc/src/abi/platform.h
+++ b/libs/libc/src/abi/platform.h
@@ -18,7 +18,6 @@ SYSCALL_VOID_NAME(get_timezone, kSysGetTimezone, Timezone *, time_zone);
 
 SYSCALL_VOID_NAME(debug_write, kSysDebugWrite, const char *, buffer);
 SYSCALL_NAME(debug_read_line, kSysDebugReadLine, size_t, char *, buff, size_t, size);
-SYSCALL_VOID_NAME(write_console, kSysWriteConsole, const char *, buffer);
 
 SYSCALL_VOID_NAME(panic, kSysPanic, const char *, msg);
 
@@ -29,6 +28,11 @@ SYSCALL_NAME(write, kSysWrite, ssize_t, fd_t, fd, const void *, buf, size_t, cou
 SYSCALL_NAME(seek, kSysSeek, ssize_t, fd_t, fd, ssize_t, offset, FdSeek, whence);
 SYSCALL_NAME(dup, kSysDup, fd_t, fd_t, fd);
 SYSCALL_NAME(dup_to, kSysDupTo, fd_t, fd_t, old_fd, fd_t, new_fd);
+SYSCALL_NAME(
+    read_directory, kSysReadDirectory, int, const char *, path, DirEntry *, entries, size_t,
+    max_entries, size_t *, num_entries
+);
+SYSCALL_NAME(file_info, kSysFileInfo, int, const char *, path, FileInfo *, info);
 
 /* Thread, processes */
 SYSCALL_NAME(thread_create, kThreadCreate, int, Thread *, thread, thread_func_t, f, void *, arg);
@@ -39,9 +43,11 @@ SYSCALL_VOID_NAME(proc_exit, kProcExit, int, status);
 SYSCALL_VOID_NAME(proc_abort, kProcAbort);
 
 // Video
-struct GuiBufferInfo;
-void __platform_create_graphic_session(struct GuiBufferInfo *info);
-void __platform_blit(void);
+SYSCALL_VOID_NAME(create_graphic_session, kSysCreateGraphicSession, GuiBufferInfo *, info);
+SYSCALL_VOID_NAME(blit, kSysBlit);
+
+// Power Management
+SYSCALL_VOID_NAME(power, kSysPower, PowerAction, action);
 
 END_DECL_C
 
diff --git a/libs/libc/src/include/alkos/fd.h b/libs/libc/src/include/alkos/fd.h
index 53370974..c474473a 100644
--- a/libs/libc/src/include/alkos/fd.h
+++ b/libs/libc/src/include/alkos/fd.h
@@ -1,8 +1,12 @@
 #ifndef LIBS_LIBC_SRC_INCLUDE_ALKOS_FD_H_
 #define LIBS_LIBC_SRC_INCLUDE_ALKOS_FD_H_
 
+#include <types.h>
+
 typedef int fd_t;
 
+#define ALK_MAX_NAME_LEN 128
+
 typedef enum {
     kFdFlagRead      = 0x1,
     kFdFlagWrite     = 0x2,
@@ -21,4 +25,19 @@ typedef enum { kFdBufferNone = 0, kFdBufferLine = 1, kFdBufferFull = 2 } FdBuffe
 
 typedef enum { kFdSeekSet = 0, kFdSeekCurrent = 1, kFdSeekEnd = 2 } FdSeek;
 
+typedef enum {
+    kFileTypeRegular,
+    kFileTypeDirectory,
+} FileType;
+
+typedef struct {
+    char name[ALK_MAX_NAME_LEN];
+    FileType type;
+} DirEntry;
+
+typedef struct {
+    u64 size;       // File size in bytes
+    FileType type;  // File type
+} FileInfo;
+
 #endif  // LIBS_LIBC_SRC_INCLUDE_ALKOS_FD_H_
diff --git a/libs/libc/src/include/alkos/power.h b/libs/libc/src/include/alkos/power.h
new file mode 100644
index 00000000..60d48a83
--- /dev/null
+++ b/libs/libc/src/include/alkos/power.h
@@ -0,0 +1,9 @@
+#ifndef LIBS_LIBC_SRC_INCLUDE_ALKOS_POWER_H_
+#define LIBS_LIBC_SRC_INCLUDE_ALKOS_POWER_H_
+
+typedef enum {
+    kShutdown,
+    kReboot,
+} PowerAction;
+
+#endif  // LIBS_LIBC_SRC_INCLUDE_ALKOS_POWER_H_
diff --git a/libs/libc/src/include/alkos/structs.h b/libs/libc/src/include/alkos/structs.h
index 9b8c3a1d..965c12db 100644
--- a/libs/libc/src/include/alkos/structs.h
+++ b/libs/libc/src/include/alkos/structs.h
@@ -2,8 +2,10 @@
 #define LIBS_LIBC_SRC_INCLUDE_ALKOS_STRUCTS_H_
 
 #include "alkos/fd.h"
+#include "alkos/power.h"
 #include "alkos/proc.h"
 #include "alkos/thread.h"
 #include "alkos/time.h"
+#include "alkos/video.h"
 
 #endif  // LIBS_LIBC_SRC_INCLUDE_ALKOS_STRUCTS_H_
diff --git a/libs/libc/src/include/alkos/sys/fd.h b/libs/libc/src/include/alkos/sys/fd.h
index 7b05433e..b4ab65e4 100644
--- a/libs/libc/src/include/alkos/sys/fd.h
+++ b/libs/libc/src/include/alkos/sys/fd.h
@@ -77,6 +77,32 @@ FAST_CALL fd_t DuplicateFd(fd_t fd) { return __platform_dup(fd); }
  */
 FAST_CALL fd_t DuplicateFdTo(fd_t old_fd, fd_t new_fd) { return __platform_dup_to(old_fd, new_fd); }
 
+/**
+ * @brief Read directory entries
+ * @param path Path to the directory
+ * @param entries Buffer to store directory entries
+ * @param max_entries Maximum number of entries to read
+ * @param num_entries Output: actual number of entries read
+ * @return 0 on success, -1 on failure
+ */
+FAST_CALL int ReadDirectory(
+    const char *path, DirEntry *entries, size_t max_entries, size_t *num_entries
+)
+{
+    return __platform_read_directory(path, entries, max_entries, num_entries);
+}
+
+/**
+ * @brief Get file information
+ * @param path Path to the file
+ * @param info Output: file information structure
+ * @return 0 on success, -1 on failure
+ */
+FAST_CALL int GetFileInfo(const char *path, FileInfo *info)
+{
+    return __platform_file_info(path, info);
+}
+
 END_DECL_C
 
 #endif  // LIBS_LIBC_SRC_INCLUDE_ALKOS_SYS_FD_H_
diff --git a/libs/libc/src/include/alkos/sys/power.h b/libs/libc/src/include/alkos/sys/power.h
new file mode 100644
index 00000000..feb27ea5
--- /dev/null
+++ b/libs/libc/src/include/alkos/sys/power.h
@@ -0,0 +1,12 @@
+#ifndef LIBS_LIBC_SRC_INCLUDE_ALKOS_SYS_POWER_H_
+#define LIBS_LIBC_SRC_INCLUDE_ALKOS_SYS_POWER_H_
+
+#include "alkos/power.h"
+#include "defines.h"
+#include "platform.h"
+
+FORCE_INLINE_F void Shutdown() { __platform_power(kShutdown); }
+
+FORCE_INLINE_F void Reboot() { __platform_power(kReboot); }
+
+#endif  // LIBS_LIBC_SRC_INCLUDE_ALKOS_SYS_POWER_H_
diff --git a/libs/libc/src/include/alkos/sys/video.h b/libs/libc/src/include/alkos/sys/video.h
new file mode 100644
index 00000000..19597b13
--- /dev/null
+++ b/libs/libc/src/include/alkos/sys/video.h
@@ -0,0 +1,43 @@
+#ifndef LIBS_LIBC_SRC_INCLUDE_ALKOS_SYS_VIDEO_H_
+#define LIBS_LIBC_SRC_INCLUDE_ALKOS_SYS_VIDEO_H_
+
+#include "alkos/video.h"
+#include "defines.h"
+#include "platform.h"
+#include "types.h"
+
+BEGIN_DECL_C
+
+FORCE_INLINE_F void Blit() { __platform_blit(); }
+
+FORCE_INLINE_F GuiBufferInfo GetVideoBufferInfo()
+{
+    GuiBufferInfo info;
+    __platform_create_graphic_session(&info);
+    return info;
+}
+
+END_DECL_C
+
+#ifdef __cplusplus
+
+#include <tuple.hpp>
+
+FORCE_INLINE_F std::tuple<Graphics::Surface, Graphics::PixelFormat> GetVideoContext()
+{
+    GuiBufferInfo info = GetVideoBufferInfo();
+
+    auto surface = Graphics::Surface(
+        static_cast<Graphics::NativePixel *>(info.buffer_ptr), info.width, info.height, info.pitch
+    );
+
+    Graphics::PixelFormat format{info.format.red_pos,   info.format.red_mask_size,
+                                 info.format.green_pos, info.format.green_mask_size,
+                                 info.format.blue_pos,  info.format.blue_mask_size};
+
+    return {surface, format};
+}
+
+#endif  // __cplusplus
+
+#endif  // LIBS_LIBC_SRC_INCLUDE_ALKOS_SYS_VIDEO_H_
diff --git a/libs/libc/src/include/alkos/syscall.h b/libs/libc/src/include/alkos/syscall.h
index 160e8214..f362e716 100644
--- a/libs/libc/src/include/alkos/syscall.h
+++ b/libs/libc/src/include/alkos/syscall.h
@@ -2,7 +2,7 @@
 #define LIBS_LIBC_SRC_INCLUDE_ALKOS_SYSCALL_H_
 
 #include <syscall.h>
-#include "macro.hpp"
+#include "internal/macro.hpp"
 
 /**
  * @brief Syscall numbers
@@ -18,15 +18,10 @@ enum SyscallNumber {
     /* Debug IO */
     kSysDebugWrite,
     kSysDebugReadLine,
-    kSysWriteConsole,
 
     /* Panic/Program termination */
     kSysPanic,
 
-    /* Video Syscalls */
-    kSysCreateGraphicSession,
-    kSysBlit,
-
     /* File descriptor syscalls */
     kSysOpen,
     kSysClose,
@@ -35,6 +30,8 @@ enum SyscallNumber {
     kSysSeek,
     kSysDup,
     kSysDupTo,
+    kSysReadDirectory,
+    kSysFileInfo,
 
     /* Threads, processes */
     kThreadCreate,
@@ -44,6 +41,13 @@ enum SyscallNumber {
     kProcExit,
     kProcAbort,
 
+    /* Video Syscalls */
+    kSysCreateGraphicSession,
+    kSysBlit,
+
+    /* Power Management Syscalls */
+    kSysPower,
+
     kSysMax,
 };
 
diff --git a/libs/libc/src/include/alkos/video.h b/libs/libc/src/include/alkos/video.h
index ca01f72f..f233ecaf 100644
--- a/libs/libc/src/include/alkos/video.h
+++ b/libs/libc/src/include/alkos/video.h
@@ -1,30 +1,24 @@
-#ifndef LIBS_LIBC_SRC_INCLUDE_SYS_VIDEO_H_
-#define LIBS_LIBC_SRC_INCLUDE_SYS_VIDEO_H_
+#ifndef LIBS_LIBC_SRC_INCLUDE_ALKOS_VIDEO_H_
+#define LIBS_LIBC_SRC_INCLUDE_ALKOS_VIDEO_H_
 
-#include <defines.h>
-#include <stddef.h>
-#include <stdint.h>
+#include <types.h>
 
-BEGIN_DECL_C
+typedef struct {
+    u8 red_pos;
+    u8 red_mask_size;
+    u8 green_pos;
+    u8 green_mask_size;
+    u8 blue_pos;
+    u8 blue_mask_size;
+} GuiPixelFormat;
 
-struct GuiPixelFormat {
-    uint8_t red_pos;
-    uint8_t red_mask_size;
-    uint8_t green_pos;
-    uint8_t green_mask_size;
-    uint8_t blue_pos;
-    uint8_t blue_mask_size;
-};
-
-struct GuiBufferInfo {
+typedef struct {
     void *buffer_ptr;  // Virtual address in userspace where buffer is mapped
     size_t width;
     size_t height;
     size_t pitch;  // Bytes per row
     size_t bpp;    // Bits per pixel (usually 32)
-    struct GuiPixelFormat format;
-};
-
-END_DECL_C
+    GuiPixelFormat format;
+} GuiBufferInfo;
 
-#endif  // LIBS_LIBC_SRC_INCLUDE_SYS_VIDEO_H_
+#endif  // LIBS_LIBC_SRC_INCLUDE_ALKOS_VIDEO_H_
diff --git a/libs/libc/src/include/defines.h b/libs/libc/src/include/defines.h
index 2c0549b8..71da0307 100644
--- a/libs/libc/src/include/defines.h
+++ b/libs/libc/src/include/defines.h
@@ -54,6 +54,9 @@ static constexpr bool kIsKernel = false;
 /* Marks a variable or function to be placed in a specific section */
 #define SECTION(name) __attribute__((section(#name)))
 
+/* Marks a variable or function as weakly linked */
+#define WEAK __attribute__((weak))
+
 // ------------------------------
 // Useful macros
 // ------------------------------
diff --git a/libs/libc/src/internal/crt0.cpp b/libs/libc/src/internal/crt0.cpp
index b8a05e16..25e176a2 100644
--- a/libs/libc/src/internal/crt0.cpp
+++ b/libs/libc/src/internal/crt0.cpp
@@ -8,7 +8,43 @@
 
 BEGIN_DECL_C
 
-extern int main();
+extern void (*__preinit_array_start[])(void) WEAK;
+extern void (*__preinit_array_end[])(void) WEAK;
+extern void (*__init_array_start[])(void) WEAK;
+extern void (*__init_array_end[])(void) WEAK;
+extern void (*__fini_array_start[])(void) WEAK;
+extern void (*__fini_array_end[])(void) WEAK;
+
+void _init(void);
+void _fini(void);
+int main();
+
+FORCE_INLINE_F void InitializeRuntime()
+{
+    // Call pre-initialization functions
+    for (size_t i = 0; i < static_cast<size_t>(__preinit_array_end - __preinit_array_start); ++i) {
+        __preinit_array_start[i]();
+    }
+
+    // Call the main initialization function
+    _init();
+
+    // Call initialization functions
+    for (size_t i = 0; i < static_cast<size_t>(__init_array_end - __init_array_start); ++i) {
+        __init_array_start[i]();
+    }
+}
+
+FORCE_INLINE_F void FinalizeRuntime()
+{
+    // Call finalization functions in reverse order
+    for (size_t i = static_cast<size_t>(__fini_array_end - __fini_array_start); i > 0; --i) {
+        __fini_array_start[i - 1]();
+    }
+
+    // Call the main finalization function
+    _fini();
+}
 
 /**
  * @brief Program entry point
@@ -16,7 +52,9 @@ extern int main();
 USED NO_RET SECTION(.text.start) void _start()
 {
     InitStdio();             // Initialize standard I/O streams
+    InitializeRuntime();     // Initialize runtime and global constructors
     const int res = main();  // Call the user program's main function
+    FinalizeRuntime();       // Finalize runtime and global destructors
 
     // TODO : Handle program exit properly
     __platform_proc_exit(res);  // Not implemented
@@ -26,6 +64,7 @@ USED NO_RET SECTION(.text.start) void _start()
             ++i;
         }
     }
+    __builtin_unreachable();
 }
 
 END_DECL_C
diff --git a/libs/libc/src/internal/libc_backend.cpp b/libs/libc/src/internal/libc_backend.cpp
index cd0afc19..2459a90a 100644
--- a/libs/libc/src/internal/libc_backend.cpp
+++ b/libs/libc/src/internal/libc_backend.cpp
@@ -1,7 +1,6 @@
 #ifndef __ALKOS_KERNEL__
 
 #include "alkos/structs.h"
-#include "alkos/video.h"
 #include "platform.h"
 
 DEFINE_SYSCALL_VOID(
@@ -13,13 +12,9 @@ DEFINE_SYSCALL_VOID(get_timezone, kSysGetTimezone, Timezone *, time_zone)
 
 DEFINE_SYSCALL_VOID(debug_write, kSysDebugWrite, const char *, buffer)
 DEFINE_SYSCALL(debug_read_line, kSysDebugReadLine, size_t, char *, buff, size_t, size)
-DEFINE_SYSCALL_VOID(write_console, kSysWriteConsole, const char *, buffer)
 
 DEFINE_SYSCALL_VOID(panic, kSysPanic, const char *, msg)
 
-DEFINE_SYSCALL_VOID(create_graphic_session, kSysCreateGraphicSession, GuiBufferInfo *, info)
-DEFINE_SYSCALL_VOID(blit, kSysBlit)
-
 DEFINE_SYSCALL(open, kSysOpen, fd_t, const char *, pathname, int, flags)
 DEFINE_SYSCALL(close, kSysClose, int, fd_t, fd)
 DEFINE_SYSCALL(read, kSysRead, ssize_t, fd_t, fd, void *, buf, size_t, count)
@@ -27,6 +22,11 @@ DEFINE_SYSCALL(write, kSysWrite, ssize_t, fd_t, fd, const void *, buf, size_t, c
 DEFINE_SYSCALL(seek, kSysSeek, ssize_t, fd_t, fd, ssize_t, offset, FdSeek, whence)
 DEFINE_SYSCALL(dup, kSysDup, fd_t, fd_t, fd)
 DEFINE_SYSCALL(dup_to, kSysDupTo, fd_t, fd_t, old_fd, fd_t, new_fd)
+DEFINE_SYSCALL(
+    read_directory, kSysReadDirectory, int, const char *, path, DirEntry *, entries, size_t,
+    max_entries, size_t *, num_entries
+)
+DEFINE_SYSCALL(file_info, kSysFileInfo, int, const char *, path, FileInfo *, info)
 
 /* Thread, processes */
 DEFINE_SYSCALL(thread_create, kThreadCreate, int, Thread *, thread, thread_func_t, f, void *, arg)
@@ -36,4 +36,9 @@ DEFINE_SYSCALL(thread_detach, kThreadDetach, int, Thread *, thread)
 DEFINE_SYSCALL_VOID(proc_exit, kProcExit, int, status)
 DEFINE_SYSCALL_VOID(proc_abort, kProcAbort)
 
+DEFINE_SYSCALL_VOID(create_graphic_session, kSysCreateGraphicSession, GuiBufferInfo *, info)
+DEFINE_SYSCALL_VOID(blit, kSysBlit)
+
+DEFINE_SYSCALL_VOID(power, kSysPower, PowerAction, action)
+
 #endif  // __ALKOS_KERNEL__
diff --git a/libs/libc/src/internal/stdio.hpp b/libs/libc/src/internal/stdio.hpp
index 56bdd2b5..cf9ea7dc 100644
--- a/libs/libc/src/internal/stdio.hpp
+++ b/libs/libc/src/internal/stdio.hpp
@@ -43,7 +43,6 @@ void FreeFile(FILE *file);
  */
 FORCE_INLINE_F void InitStdio()
 {
-    memset(&_stdin, 0, sizeof(FILE));
     _stdin.fd                    = kFdStdIn;
     _stdin.flags.open_mode       = kFdFlagRead;
     _stdin.flags.buffer_mode     = kFdBufferLine;
@@ -57,7 +56,6 @@ FORCE_INLINE_F void InitStdio()
     _stdin.buffer_level          = 0;
     _stdin.file_pos              = 0;
 
-    memset(&_stdout, 0, sizeof(FILE));
     _stdout.fd                    = kFdStdOut;
     _stdout.flags.open_mode       = kFdFlagWrite;
     _stdout.flags.buffer_mode     = kFdBufferLine;
@@ -71,7 +69,6 @@ FORCE_INLINE_F void InitStdio()
     _stdout.buffer_level          = 0;
     _stdout.file_pos              = 0;
 
-    memset(&_stderr, 0, sizeof(FILE));
     _stderr.fd                    = kFdStdErr;
     _stderr.flags.open_mode       = kFdFlagWrite;
     _stderr.flags.buffer_mode     = kFdBufferNone;
diff --git a/libs/libcontainers/include/data_structures/array_structures.hpp b/libs/libcontainers/include/data_structures/array_structures.hpp
index 99ae1506..f565f494 100644
--- a/libs/libcontainers/include/data_structures/array_structures.hpp
+++ b/libs/libcontainers/include/data_structures/array_structures.hpp
@@ -5,6 +5,7 @@
 #include <array.hpp>
 #include <bits_ext.hpp>
 #include <concepts.hpp>
+#include <new.hpp>
 #include <string.hpp>
 
 namespace data_structures
diff --git a/kernel/src/macros.hpp b/libs/libcpp/include/internal/macros.hpp
similarity index 60%
rename from kernel/src/macros.hpp
rename to libs/libcpp/include/internal/macros.hpp
index a7e7a60c..c4d3cc8a 100644
--- a/kernel/src/macros.hpp
+++ b/libs/libcpp/include/internal/macros.hpp
@@ -1,7 +1,5 @@
-#ifndef KERNEL_SRC_MACROS_HPP_
-#define KERNEL_SRC_MACROS_HPP_
-
-#include <expected.hpp>
+#ifndef LIBS_LIBCPP_INCLUDE_INTERNAL_MACROS_HPP_
+#define LIBS_LIBCPP_INCLUDE_INTERNAL_MACROS_HPP_
 
 #define RET_UNEXPECTED_IF_ERR(res) \
     if (!res)                      \
@@ -11,4 +9,4 @@
     if (cond)                        \
     return std::unexpected(err)
 
-#endif  // KERNEL_SRC_MACROS_HPP_
+#endif  // LIBS_LIBCPP_INCLUDE_INTERNAL_MACROS_HPP_
diff --git a/kernel/src/todo.hpp b/libs/libcpp/include/todo.hpp
similarity index 90%
rename from kernel/src/todo.hpp
rename to libs/libcpp/include/todo.hpp
index c2bdc155..40a3b277 100644
--- a/kernel/src/todo.hpp
+++ b/libs/libcpp/include/todo.hpp
@@ -1,5 +1,5 @@
-#ifndef KERNEL_SRC_TODO_HPP_
-#define KERNEL_SRC_TODO_HPP_
+#ifndef LIBS_LIBCPP_INCLUDE_TODO_HPP_
+#define LIBS_LIBCPP_INCLUDE_TODO_HPP_
 
 /**
  * @brief This file's purpose is to define a set of macros used as placeholders
@@ -34,4 +34,4 @@
 
 #define TODO_WHEN_MULTICORE
 
-#endif  // KERNEL_SRC_TODO_HPP_
+#endif  // LIBS_LIBCPP_INCLUDE_TODO_HPP_
diff --git a/libs/libgraphics/CMakeLists.txt b/libs/libgraphics/CMakeLists.txt
new file mode 100644
index 00000000..799f4e3e
--- /dev/null
+++ b/libs/libgraphics/CMakeLists.txt
@@ -0,0 +1,14 @@
+message(STATUS "Configuring Graphics Library...")
+
+alkos_find_sources(LIBGRAPHICS_SOURCES)
+set(LIBGRAPHICS_SOURCES ${LIBGRAPHICS_SOURCES} CACHE INTERNAL "Source files for libgraphics")
+
+add_library(alkos.libgraphics.interface INTERFACE)
+
+target_include_directories(alkos.libgraphics.interface INTERFACE
+    "include"
+)
+
+target_link_libraries(alkos.libgraphics.interface INTERFACE
+    alkos.libcpp.interface
+)
diff --git a/kernel/src/graphics/color.hpp b/libs/libgraphics/include/color.hpp
similarity index 83%
rename from kernel/src/graphics/color.hpp
rename to libs/libgraphics/include/color.hpp
index 1d577661..2f45a5e6 100644
--- a/kernel/src/graphics/color.hpp
+++ b/libs/libgraphics/include/color.hpp
@@ -1,5 +1,5 @@
-#ifndef KERNEL_SRC_GRAPHICS_COLOR_HPP_
-#define KERNEL_SRC_GRAPHICS_COLOR_HPP_
+#ifndef LIBS_LIBGRAPHICS_INCLUDE_COLOR_HPP_
+#define LIBS_LIBGRAPHICS_INCLUDE_COLOR_HPP_
 
 #include <types.h>
 #include <defines.hpp>
@@ -32,4 +32,4 @@ struct PixelFormat {
 
 }  // namespace Graphics
 
-#endif  // KERNEL_SRC_GRAPHICS_COLOR_HPP_
+#endif  // LIBS_LIBGRAPHICS_INCLUDE_COLOR_HPP_
diff --git a/kernel/src/graphics/font/glyph.hpp b/libs/libgraphics/include/font/glyph.hpp
similarity index 78%
rename from kernel/src/graphics/font/glyph.hpp
rename to libs/libgraphics/include/font/glyph.hpp
index 0207b898..0305c40d 100644
--- a/kernel/src/graphics/font/glyph.hpp
+++ b/libs/libgraphics/include/font/glyph.hpp
@@ -1,5 +1,5 @@
-#ifndef KERNEL_SRC_GRAPHICS_FONT_GLYPH_HPP_
-#define KERNEL_SRC_GRAPHICS_FONT_GLYPH_HPP_
+#ifndef LIBS_LIBGRAPHICS_INCLUDE_FONT_GLYPH_HPP_
+#define LIBS_LIBGRAPHICS_INCLUDE_FONT_GLYPH_HPP_
 
 #include <types.h>
 
@@ -20,4 +20,4 @@ struct Glyph {
 
 }  // namespace Graphics
 
-#endif  // KERNEL_SRC_GRAPHICS_FONT_GLYPH_HPP_
+#endif  // LIBS_LIBGRAPHICS_INCLUDE_FONT_GLYPH_HPP_
diff --git a/kernel/src/graphics/font/psf2_font.hpp b/libs/libgraphics/include/font/psf2_font.hpp
similarity index 94%
rename from kernel/src/graphics/font/psf2_font.hpp
rename to libs/libgraphics/include/font/psf2_font.hpp
index 0a6b5683..571e3b58 100644
--- a/kernel/src/graphics/font/psf2_font.hpp
+++ b/libs/libgraphics/include/font/psf2_font.hpp
@@ -1,5 +1,5 @@
-#ifndef KERNEL_SRC_GRAPHICS_FONT_PSF2_FONT_HPP_
-#define KERNEL_SRC_GRAPHICS_FONT_PSF2_FONT_HPP_
+#ifndef LIBS_LIBGRAPHICS_INCLUDE_FONT_PSF2_FONT_HPP_
+#define LIBS_LIBGRAPHICS_INCLUDE_FONT_PSF2_FONT_HPP_
 
 #include <assert.h>
 #include <types.h>
@@ -7,8 +7,8 @@
 #include <span.hpp>
 #include <string.hpp>
 
-#include "graphics/font/glyph.hpp"
-#include "graphics/geometry.hpp"
+#include "font/glyph.hpp"
+#include "geometry.hpp"
 
 namespace Graphics
 {
@@ -131,4 +131,4 @@ class Psf2Font
 
 }  // namespace Graphics
 
-#endif  // KERNEL_SRC_GRAPHICS_FONT_PSF2_FONT_HPP_
+#endif  // LIBS_LIBGRAPHICS_INCLUDE_FONT_PSF2_FONT_HPP_
diff --git a/kernel/src/graphics/fonts/drdos8x8.hpp b/libs/libgraphics/include/fonts/drdos8x8.hpp
similarity index 99%
rename from kernel/src/graphics/fonts/drdos8x8.hpp
rename to libs/libgraphics/include/fonts/drdos8x8.hpp
index ebd73fed..c4458698 100644
--- a/kernel/src/graphics/fonts/drdos8x8.hpp
+++ b/libs/libgraphics/include/fonts/drdos8x8.hpp
@@ -1,5 +1,5 @@
-#ifndef KERNEL_SRC_GRAPHICS_FONTS_DRDOS8X8_HPP_
-#define KERNEL_SRC_GRAPHICS_FONTS_DRDOS8X8_HPP_
+#ifndef LIBS_LIBGRAPHICS_INCLUDE_FONTS_DRDOS8X8_HPP_
+#define LIBS_LIBGRAPHICS_INCLUDE_FONTS_DRDOS8X8_HPP_
 
 // Converted via `xxd -i`
 static constexpr unsigned char drdos8x8_psfu[] = {
@@ -318,4 +318,4 @@ static constexpr unsigned char drdos8x8_psfu[] = {
 };
 static constexpr unsigned int drdos8x8_psfu_len = 4983;
 
-#endif  // KERNEL_SRC_GRAPHICS_FONTS_DRDOS8X8_HPP_
+#endif  // LIBS_LIBGRAPHICS_INCLUDE_FONTS_DRDOS8X8_HPP_
diff --git a/kernel/src/graphics/geometry.hpp b/libs/libgraphics/include/geometry.hpp
similarity index 73%
rename from kernel/src/graphics/geometry.hpp
rename to libs/libgraphics/include/geometry.hpp
index aac14f39..9e68288a 100644
--- a/kernel/src/graphics/geometry.hpp
+++ b/libs/libgraphics/include/geometry.hpp
@@ -1,5 +1,5 @@
-#ifndef KERNEL_SRC_GRAPHICS_GEOMETRY_HPP_
-#define KERNEL_SRC_GRAPHICS_GEOMETRY_HPP_
+#ifndef LIBS_LIBGRAPHICS_INCLUDE_GEOMETRY_HPP_
+#define LIBS_LIBGRAPHICS_INCLUDE_GEOMETRY_HPP_
 
 #include <types.h>
 #include <string.hpp>
@@ -40,4 +40,4 @@ struct Size {
 
 }  // namespace Graphics
 
-#endif  // KERNEL_SRC_GRAPHICS_GEOMETRY_HPP_
+#endif  // LIBS_LIBGRAPHICS_INCLUDE_GEOMETRY_HPP_
diff --git a/kernel/src/graphics/native_pixel.hpp b/libs/libgraphics/include/native_pixel.hpp
similarity index 87%
rename from kernel/src/graphics/native_pixel.hpp
rename to libs/libgraphics/include/native_pixel.hpp
index 067e21f2..abcca917 100644
--- a/kernel/src/graphics/native_pixel.hpp
+++ b/libs/libgraphics/include/native_pixel.hpp
@@ -1,9 +1,10 @@
-#ifndef KERNEL_SRC_GRAPHICS_NATIVE_PIXEL_HPP_
-#define KERNEL_SRC_GRAPHICS_NATIVE_PIXEL_HPP_
+#ifndef LIBS_LIBGRAPHICS_INCLUDE_NATIVE_PIXEL_HPP_
+#define LIBS_LIBGRAPHICS_INCLUDE_NATIVE_PIXEL_HPP_
 
 #include <types.h>
 #include <defines.hpp>
-#include "graphics/color.hpp"
+
+#include "color.hpp"
 
 namespace Graphics
 {
@@ -44,4 +45,4 @@ static_assert(sizeof(NativePixel) == sizeof(u32), "NativePixel must be 32-bit");
 
 }  // namespace Graphics
 
-#endif  // KERNEL_SRC_GRAPHICS_NATIVE_PIXEL_HPP_
+#endif  // LIBS_LIBGRAPHICS_INCLUDE_NATIVE_PIXEL_HPP_
diff --git a/kernel/src/graphics/painter.hpp b/libs/libgraphics/include/painter.hpp
similarity index 82%
rename from kernel/src/graphics/painter.hpp
rename to libs/libgraphics/include/painter.hpp
index 22044062..0e6e7688 100644
--- a/kernel/src/graphics/painter.hpp
+++ b/libs/libgraphics/include/painter.hpp
@@ -1,14 +1,14 @@
-#ifndef KERNEL_SRC_GRAPHICS_PAINTER_HPP_
-#define KERNEL_SRC_GRAPHICS_PAINTER_HPP_
+#ifndef LIBS_LIBGRAPHICS_INCLUDE_PAINTER_HPP_
+#define LIBS_LIBGRAPHICS_INCLUDE_PAINTER_HPP_
 
 #include <concepts.hpp>
 #include <span.hpp>
-#include <string.hpp>
-#include "graphics/color.hpp"
-#include "graphics/font/glyph.hpp"
-#include "graphics/geometry.hpp"
-#include "graphics/native_pixel.hpp"
-#include "graphics/surface.hpp"
+
+#include "color.hpp"
+#include "font/glyph.hpp"
+#include "geometry.hpp"
+#include "native_pixel.hpp"
+#include "surface.hpp"
 
 namespace Graphics
 {
@@ -66,6 +66,6 @@ class Painter
 
 }  // namespace Graphics
 
-#include "graphics/painter.tpp"
+#include "painter.tpp"
 
-#endif  // KERNEL_SRC_GRAPHICS_PAINTER_HPP_
+#endif  // LIBS_LIBGRAPHICS_INCLUDE_PAINTER_HPP_
diff --git a/kernel/src/graphics/painter.tpp b/libs/libgraphics/include/painter.tpp
similarity index 100%
rename from kernel/src/graphics/painter.tpp
rename to libs/libgraphics/include/painter.tpp
diff --git a/kernel/src/graphics/surface.hpp b/libs/libgraphics/include/surface.hpp
similarity index 79%
rename from kernel/src/graphics/surface.hpp
rename to libs/libgraphics/include/surface.hpp
index daafc8ff..3536e03a 100644
--- a/kernel/src/graphics/surface.hpp
+++ b/libs/libgraphics/include/surface.hpp
@@ -1,11 +1,11 @@
-#ifndef KERNEL_SRC_GRAPHICS_SURFACE_HPP_
-#define KERNEL_SRC_GRAPHICS_SURFACE_HPP_
+#ifndef LIBS_LIBGRAPHICS_INCLUDE_SURFACE_HPP_
+#define LIBS_LIBGRAPHICS_INCLUDE_SURFACE_HPP_
 
 #include <assert.h>
 #include <types.h>
-#include <mem/types.hpp>
 #include <span.hpp>
-#include "graphics/native_pixel.hpp"
+
+#include "native_pixel.hpp"
 
 namespace Graphics
 {
@@ -19,7 +19,7 @@ class Surface
     public:
     Surface() = default;
 
-    Surface(Mem::VPtr<NativePixel> buffer, u32 width, u32 height, u32 pitch_bytes)
+    Surface(NativePixel *buffer, u32 width, u32 height, u32 pitch_bytes)
         : buffer_(buffer), width_(width), height_(height), pitch_bytes_(pitch_bytes)
     {
         R_ASSERT_NOT_NULL(buffer_);
@@ -56,16 +56,16 @@ class Surface
     {
         ASSERT_LT(y, height_);
         // Pointer arithmetic on byte level for pitch
-        uptr addr = Mem::PtrToUptr(buffer_) + (static_cast<size_t>(y) * pitch_bytes_);
-        Mem::VPtr<NativePixel> ptr = Mem::UptrToPtr<NativePixel>(addr);
+        uptr addr = reinterpret_cast<uptr>(buffer_) + (static_cast<size_t>(y) * pitch_bytes_);
+        NativePixel *ptr = reinterpret_cast<NativePixel *>(addr);
         return std::span<NativePixel>(ptr, width_);
     }
 
     NODISCARD FORCE_INLINE_F std::span<const NativePixel> GetScanline(u32 y) const
     {
         ASSERT_LT(y, height_);
-        uptr addr = Mem::PtrToUptr(buffer_) + (static_cast<size_t>(y) * pitch_bytes_);
-        Mem::VPtr<NativePixel> ptr = Mem::UptrToPtr<NativePixel>(addr);
+        uptr addr = reinterpret_cast<uptr>(buffer_) + (static_cast<size_t>(y) * pitch_bytes_);
+        NativePixel *ptr = reinterpret_cast<NativePixel *>(addr);
         return std::span<const NativePixel>(ptr, width_);
     }
 
@@ -79,7 +79,7 @@ class Surface
      * @brief Gets the unsafe raw buffer pointer.
      * @warning Use only for high-performance code where bounds are checked manually.
      */
-    NODISCARD FORCE_INLINE_F Mem::VPtr<NativePixel> GetRawBuffer() { return buffer_; }
+    NODISCARD FORCE_INLINE_F NativePixel *GetRawBuffer() { return buffer_; }
 
     // -------------------------------------------------------------------------
     // Properties
@@ -91,7 +91,7 @@ class Surface
     NODISCARD FORCE_INLINE_F bool IsValid() const { return buffer_ != nullptr; }
 
     private:
-    Mem::VPtr<NativePixel> buffer_{nullptr};
+    NativePixel *buffer_{nullptr};
     u32 width_{0};
     u32 height_{0};
     u32 pitch_bytes_{0};  // Stride in bytes
@@ -99,4 +99,4 @@ class Surface
 
 }  // namespace Graphics
 
-#endif  // KERNEL_SRC_GRAPHICS_SURFACE_HPP_
+#endif  // LIBS_LIBGRAPHICS_INCLUDE_SURFACE_HPP_
diff --git a/kernel/src/graphics/painter.cpp b/libs/libgraphics/src/painter.cpp
similarity index 98%
rename from kernel/src/graphics/painter.cpp
rename to libs/libgraphics/src/painter.cpp
index 6b2ebb6b..3012a8d3 100644
--- a/kernel/src/graphics/painter.cpp
+++ b/libs/libgraphics/src/painter.cpp
@@ -1,4 +1,5 @@
-#include "graphics/painter.hpp"
+#include "painter.hpp"
+
 #include <string.h>
 #include <algorithm.hpp>
 
diff --git a/userspace/CMakeLists.txt b/userspace/CMakeLists.txt
index cc36f1f5..816381e6 100644
--- a/userspace/CMakeLists.txt
+++ b/userspace/CMakeLists.txt
@@ -1,24 +1,58 @@
-message(STATUS "Configuring Userspace programs...")
+message(STATUS "Configuring Userspace...")
 
 # Directory where we collect user binaries
 set(USERSPACE_BIN_DIR "${CMAKE_CURRENT_BINARY_DIR}/bin")
 alkos_add_to_bash_config("CONF_USERSPACE_BIN_DIR" "${USERSPACE_BIN_DIR}")
 
-set(USER_LINKER_SCRIPT "${CMAKE_CURRENT_SOURCE_DIR}/build/linker.ld")
+################################ Linker Script #################################
+
+set(USER_LINKER_SCRIPT "${CMAKE_CURRENT_SOURCE_DIR}/build/${ARCH}/linker.ld")
 
 ################################################################################
-# CRT0 - C Runtime Startup Object Library
+# CRT Object Files for C++ Global Constructors
 ################################################################################
-#
-# The CRT0 (C Runtime 0) contains the _start entry point for userspace programs.
-# It MUST be compiled as a separate OBJECT library and linked FIRST to ensure
-# that _start is placed at the program's base address.
-#
-add_library(crt0.userspace OBJECT
-    "${CMAKE_SOURCE_DIR}/libs/libc/src/internal/crt0.cpp"
+
+# Get the architecture-specific CRTI/CRTN objects from the libc configuration
+get_property(CRT0_OBJ_PATH TARGET alkos.libc.config PROPERTY CRT0_OBJ)
+get_property(CRTI_OBJ_PATH TARGET alkos.libc.config PROPERTY CRTI_OBJ)
+get_property(CRTN_OBJ_PATH TARGET alkos.libc.config PROPERTY CRTN_OBJ)
+alkos_ensure_defined(
+    VARS CRT0_OBJ_PATH CRTI_OBJ_PATH CRTN_OBJ_PATH
+    MESSAGE "CRT0_OBJ/CRTI_OBJ/CRTN_OBJ properties were not set by the libc architecture-specific CMake file."
+)
+
+# Find the compiler's CRT object files at configure-time.
+execute_process(
+    COMMAND ${CMAKE_C_COMPILER} -print-file-name=crtbegin.o
+    OUTPUT_VARIABLE CRTBEGIN_OBJ_PATH
+    ERROR_VARIABLE CRTBEGIN_ERROR
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+)
+execute_process(
+    COMMAND ${CMAKE_C_COMPILER} -print-file-name=crtend.o
+    OUTPUT_VARIABLE CRTEND_OBJ_PATH
+    ERROR_VARIABLE CRTEND_ERROR
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+)
+
+alkos_ensure_defined(
+    VARS CRTBEGIN_OBJ_PATH CRTEND_OBJ_PATH
+    MESSAGE "Could not find compiler's crtbegin.o/crtend.o files."
+)
+
+# Configure the linker rule for userspace executables to properly support
+# C++ global constructors by linking CRT objects in the correct order:
+# crt0 -> crti -> crtbegin -> <program objects> -> crtend -> crtn
+set(CMAKE_CXX_LINK_EXECUTABLE
+    "${CMAKE_CXX_COMPILER} <FLAGS> <CMAKE_CXX_LINK_FLAGS> <LINK_FLAGS> ${CRT0_OBJ_PATH} ${CRTI_OBJ_PATH} ${CRTBEGIN_OBJ_PATH} <OBJECTS> ${CRTEND_OBJ_PATH} ${CRTN_OBJ_PATH} -o <TARGET> <LINK_LIBRARIES>"
 )
-target_link_libraries(crt0.userspace PUBLIC alkos.libc.interface)
-target_compile_options(crt0.userspace PRIVATE
+
+################################################################################
+# Userspace Standard Library
+################################################################################
+add_library(c.userspace STATIC ${ALKOS_LIBC_SOURCES})
+target_link_libraries(c.userspace PUBLIC alkos.libc.interface gcc)
+target_compile_options(c.userspace PRIVATE
     $<$<COMPILE_LANGUAGE:CXX>:
         -fno-builtin
         -fno-rtti
@@ -29,12 +63,9 @@ target_compile_options(crt0.userspace PRIVATE
     >
 )
 
-################################################################################
-# Userspace Standard Library (libc)
-################################################################################
-add_library(c.userspace STATIC ${ALKOS_LIBC_SOURCES})
-target_link_libraries(c.userspace PUBLIC alkos.libc.interface gcc)
-target_compile_options(c.userspace PRIVATE
+add_library(cpp.userspace STATIC ${ALKOS_LIBCPP_SOURCES})
+target_link_libraries(cpp.userspace PUBLIC alkos.libcpp.interface gcc)
+target_compile_options(cpp.userspace PRIVATE
     $<$<COMPILE_LANGUAGE:CXX>:
         -fno-builtin
         -fno-rtti
@@ -71,17 +102,21 @@ function(alkos_register_userspace_app PROG_NAME SRC_FILES)
     )
     
     target_link_libraries(${PROG_NAME} PRIVATE
-        crt0.userspace
         c.userspace
+        cpp.userspace
     )
 
     add_custom_command(TARGET ${PROG_NAME} POST_BUILD
         COMMAND ${CMAKE_COMMAND} -E copy $<TARGET_FILE:${PROG_NAME}> ${USERSPACE_BIN_DIR}/${PROG_NAME}
         COMMENT "Installing ${PROG_NAME} to ${USERSPACE_BIN_DIR}"
     )
-    
+
+    add_dependencies(${PROG_NAME} alkos.libc.crt0 alkos.libc.crti alkos.libc.crtn)
     add_dependencies(userspace_apps ${PROG_NAME})
 endfunction()
 
+#################################### Programs ##################################
+
 # Register all user programs
+message(STATUS "  -> Configuring Programs...")
 alkos_add_subdirs(${CMAKE_CURRENT_SOURCE_DIR}/programs)
diff --git a/userspace/build/linker.ld b/userspace/build/linker.ld
deleted file mode 100644
index 087429f1..00000000
--- a/userspace/build/linker.ld
+++ /dev/null
@@ -1,36 +0,0 @@
-/**
- * Userspace Program Linker Script
- *
- * This linker script defines the memory layout for AlkOS userspace programs.
- * The entry point (_start from crt0.o) is guaranteed to be at address 0x400000.
- */
-
-ENTRY(_start)
-
-SECTIONS
-{
-    /* Standard User Space Entry Point */
-    . = 0x400000;
-
-    .text : ALIGN(4K) {
-        KEEP(*(.text._start))
-        *(.text)
-        *(.text.*)
-    }
-
-    .rodata : ALIGN(4K) {
-        *(.rodata)
-        *(.rodata.*)
-    }
-
-    .data : ALIGN(4K) {
-        *(.data)
-        *(.data.*)
-    }
-
-    .bss : ALIGN(4K) {
-        *(COMMON)
-        *(.bss)
-        *(.bss.*)
-    }
-}
diff --git a/userspace/build/x86_64/linker.ld b/userspace/build/x86_64/linker.ld
new file mode 100644
index 00000000..9d81fa37
--- /dev/null
+++ b/userspace/build/x86_64/linker.ld
@@ -0,0 +1,74 @@
+/**
+ * Userspace Program Linker Script
+ *
+ * This linker script defines the memory layout for AlkOS userspace programs.
+ * The entry point (_start from crt0.o) is guaranteed to be at address 0x400000.
+ */
+OUTPUT_FORMAT("elf64-x86-64")
+ENTRY(_start)
+
+/* Standard User Space Entry Point */
+kUserSpaceBase = 0x400000;
+
+SECTIONS
+{
+    . = kUserSpaceBase;
+
+    .init BLOCK(4K) : ALIGN(4K)
+    {
+        *(.init)
+    }
+
+    .fini BLOCK(4K) : ALIGN(4K)
+    {
+        *(.fini)
+    }
+
+    .text : ALIGN(4K) {
+        KEEP(*(.text._start))
+        *(.text)
+        *(.text.*)
+    }
+
+    .rodata : ALIGN(4K) {
+        *(.rodata)
+        *(.rodata.*)
+    }
+
+    .preinit_array : {
+        . = ALIGN(8);
+        PROVIDE_HIDDEN (__preinit_array_start = .);
+        KEEP (*(.preinit_array*))
+        PROVIDE_HIDDEN (__preinit_array_end = .);
+        . = ALIGN(8);
+    }
+
+    .init_array : {
+        . = ALIGN(8);
+        PROVIDE_HIDDEN (__init_array_start = .);
+        KEEP (*(SORT(.init_array.*)))
+        KEEP (*(.init_array*))
+        PROVIDE_HIDDEN (__init_array_end = .);
+        . = ALIGN(8);
+    }
+
+    .fini_array : {
+        . = ALIGN(8);
+        PROVIDE_HIDDEN (__fini_array_start = .);
+        KEEP (*(SORT(.fini_array.*)))
+        KEEP (*(.fini_array*))
+        PROVIDE_HIDDEN (__fini_array_end = .);
+        . = ALIGN(8);
+    }
+
+    .data : ALIGN(4K) {
+        *(.data)
+        *(.data.*)
+    }
+
+    .bss : ALIGN(4K) {
+        *(COMMON)
+        *(.bss)
+        *(.bss.*)
+    }
+}
diff --git a/userspace/programs/gui_test/CMakeLists.txt b/userspace/programs/gui_test/CMakeLists.txt
index f37614c1..9140cf38 100644
--- a/userspace/programs/gui_test/CMakeLists.txt
+++ b/userspace/programs/gui_test/CMakeLists.txt
@@ -1,3 +1,24 @@
-message(STATUS "  -> gui_test")
+message(STATUS "    -> gui_test")
 alkos_find_sources(GUI_TEST_SOURCES)
 alkos_register_userspace_app(gui_test "${GUI_TEST_SOURCES}")
+
+add_library(gui_test.libgraphics STATIC ${LIBGRAPHICS_SOURCES})
+target_link_libraries(gui_test.libgraphics PUBLIC
+    alkos.libgraphics.interface
+    alkos.libc.interface
+)
+
+target_compile_options(gui_test.libgraphics PRIVATE
+    $<$<COMPILE_LANGUAGE:CXX>:
+        -fno-builtin
+        -fno-rtti
+        -fno-exceptions
+        -fno-stack-protector
+        -mcmodel=small
+        -mno-red-zone
+    >
+)
+
+target_link_libraries(gui_test PRIVATE
+    gui_test.libgraphics
+)
diff --git a/userspace/programs/hello_world/CMakeLists.txt b/userspace/programs/hello_world/CMakeLists.txt
index f328b930..bc0f6d05 100644
--- a/userspace/programs/hello_world/CMakeLists.txt
+++ b/userspace/programs/hello_world/CMakeLists.txt
@@ -1,3 +1,3 @@
-message(STATUS "  -> hello")
+message(STATUS "    -> hello")
 alkos_find_sources(HELLO_WORLD_SOURCES)
 alkos_register_userspace_app(hello "${HELLO_WORLD_SOURCES}")
diff --git a/userspace/programs/shell/CMakeLists.txt b/userspace/programs/shell/CMakeLists.txt
new file mode 100644
index 00000000..5968f34f
--- /dev/null
+++ b/userspace/programs/shell/CMakeLists.txt
@@ -0,0 +1,25 @@
+message(STATUS "    -> shell")
+alkos_find_sources(SHELL_SOURCES)
+alkos_register_userspace_app(shell "${SHELL_SOURCES}")
+
+add_library(shell.libgraphics STATIC ${LIBGRAPHICS_SOURCES})
+target_link_libraries(shell.libgraphics PUBLIC
+    alkos.libgraphics.interface
+    alkos.libc.interface
+)
+
+target_compile_options(shell.libgraphics PRIVATE
+    $<$<COMPILE_LANGUAGE:CXX>:
+        -fno-builtin
+        -fno-rtti
+        -fno-exceptions
+        -fno-stack-protector
+        -mcmodel=small
+        -mno-red-zone
+    >
+)
+
+target_link_libraries(shell PUBLIC
+    alkos.libcontainers.interface
+    shell.libgraphics
+)
diff --git a/kernel/src/sys/graphics_console.cpp b/userspace/programs/shell/graphics_console.cpp
similarity index 98%
rename from kernel/src/sys/graphics_console.cpp
rename to userspace/programs/shell/graphics_console.cpp
index 9e44e021..eb2a80ff 100644
--- a/kernel/src/sys/graphics_console.cpp
+++ b/userspace/programs/shell/graphics_console.cpp
@@ -1,6 +1,7 @@
-#include "sys/graphics_console.hpp"
+#include "graphics_console.hpp"
 
 #include <string.h>
+#include <types.h>
 #include <algorithm.hpp>
 
 namespace System
diff --git a/kernel/src/sys/graphics_console.hpp b/userspace/programs/shell/graphics_console.hpp
similarity index 85%
rename from kernel/src/sys/graphics_console.hpp
rename to userspace/programs/shell/graphics_console.hpp
index 3a18a058..f3d9ad60 100644
--- a/kernel/src/sys/graphics_console.hpp
+++ b/userspace/programs/shell/graphics_console.hpp
@@ -1,10 +1,12 @@
-#ifndef KERNEL_SRC_SYS_GRAPHICS_CONSOLE_HPP_
-#define KERNEL_SRC_SYS_GRAPHICS_CONSOLE_HPP_
+#ifndef USERSPACE_PROGRAMS_SHELL_GRAPHICS_CONSOLE_HPP_
+#define USERSPACE_PROGRAMS_SHELL_GRAPHICS_CONSOLE_HPP_
 
-#include <graphics/color.hpp>
-#include <graphics/font/psf2_font.hpp>
-#include <graphics/painter.hpp>
-#include <io/stream.hpp>
+#include <color.hpp>
+#include <font/psf2_font.hpp>
+#include <span.hpp>
+
+#include "painter.hpp"
+#include "stream.hpp"
 
 namespace System
 {
@@ -65,4 +67,4 @@ class GraphicsConsole : public IO::IWriter
 
 }  // namespace System
 
-#endif  // KERNEL_SRC_SYS_GRAPHICS_CONSOLE_HPP_
+#endif  // USERSPACE_PROGRAMS_SHELL_GRAPHICS_CONSOLE_HPP_
diff --git a/userspace/programs/shell/main.cpp b/userspace/programs/shell/main.cpp
new file mode 100644
index 00000000..b8e010a9
--- /dev/null
+++ b/userspace/programs/shell/main.cpp
@@ -0,0 +1,31 @@
+#include "fonts/drdos8x8.hpp"
+#include "shell.hpp"
+
+#include <alkos/sys/video.h>
+
+extern "C" int main()
+{
+    Graphics::Psf2Font font(drdos8x8_psfu);
+    if (!font.IsValid()) {
+        __platform_debug_write("Invalid font");
+    }
+
+    auto [screen, format] = GetVideoContext();
+    Graphics::Painter painter(screen, format);
+    System::GraphicsConsole console(painter, font);
+    System::Shell shell(console);
+
+    shell.Init();
+    Blit();
+
+    while (true) {
+        shell.Update();
+        Blit();
+
+        // TODO: Replace with CpuHalt or smth like scheduler sleep.
+        for (volatile i32 i = 0; i < 10000; ++i) {
+        }
+    }
+
+    return 0;
+}
diff --git a/userspace/programs/shell/path.hpp b/userspace/programs/shell/path.hpp
new file mode 100644
index 00000000..8726ddbf
--- /dev/null
+++ b/userspace/programs/shell/path.hpp
@@ -0,0 +1,427 @@
+#ifndef USERSPACE_PROGRAMS_SHELL_PATH_HPP_
+#define USERSPACE_PROGRAMS_SHELL_PATH_HPP_
+
+#include <array.hpp>
+#include <concepts.hpp>
+#include <string.hpp>
+#include <type_traits.hpp>
+
+// Constants
+inline constexpr size_t kMaxPathSize      = 1024;
+inline constexpr size_t kMaxComponents    = 64;
+inline constexpr size_t kMaxComponentSize = 128;
+inline constexpr char kPathSeparator      = '/';
+
+// Concepts
+template <typename T>
+concept PathStringLike = std::convertible_to<T, std::string_view>;
+
+template <typename Callback>
+concept PathComponentCallback = requires(Callback cb, std::string_view sv) {
+    { cb(sv) } -> std::same_as<void>;
+};
+
+// Path component const iterator
+class PathIterator
+{
+    public:
+    using value_type      = std::string_view;
+    using difference_type = std::ptrdiff_t;
+    using pointer         = const std::string_view *;
+    using reference       = const std::string_view &;
+
+    PathIterator() = delete;
+    PathIterator(const std::array<std::string_view, kMaxComponents> &components, size_t index)
+        : components_(components), index_(index)
+    {
+    }
+
+    reference operator*() const { return components_[index_]; }
+    pointer operator->() const { return &components_[index_]; }
+
+    PathIterator &operator++()
+    {
+        ++index_;
+        return *this;
+    }
+    PathIterator operator++(int)
+    {
+        auto tmp = *this;
+        ++(*this);
+        return tmp;
+    }
+
+    bool operator==(const PathIterator &other) const
+    {
+        return components_ == other.components_ && index_ == other.index_;
+    }
+
+    private:
+    const std::array<std::string_view, kMaxComponents> &components_;
+    size_t index_ = 0;
+};
+
+class Path
+{
+    public:
+    static const Path kCurrentDir;
+    static const Path kParentDir;
+    static const Path kRoot;
+
+    Path() = default;
+
+    template <PathStringLike T>
+    explicit Path(T &&path_str)
+    {
+        std::string_view sv(std::forward<T>(path_str));
+        path_len_ = std::min(sv.length(), kMaxPathSize - 1);
+        strncpy(raw_path_.data(), sv.data(), path_len_);
+        raw_path_[path_len_] = '\0';
+        Parse();
+    }
+
+    Path(const Path &other)
+    {
+        raw_path_ = other.raw_path_;
+        path_len_ = other.path_len_;
+        Parse();
+    }
+
+    Path &operator=(const Path &other)
+    {
+        if (this != &other) {
+            raw_path_ = other.raw_path_;
+            path_len_ = other.path_len_;
+            Parse();
+        }
+        return *this;
+    }
+
+    Path(Path &&other) noexcept
+    {
+        raw_path_ = other.raw_path_;
+        path_len_ = other.path_len_;
+        Parse();
+    }
+
+    Path &operator=(Path &&other) noexcept
+    {
+        if (this != &other) {
+            raw_path_ = other.raw_path_;
+            path_len_ = other.path_len_;
+            Parse();
+        }
+        return *this;
+    }
+
+    // Basic properties
+    bool IsEmpty() const noexcept { return path_len_ == 0; }
+    bool IsAbsolute() const noexcept { return is_absolute_; }
+    bool IsRelative() const noexcept { return !is_absolute_; }
+    bool IsRoot() const noexcept { return is_absolute_ && num_components_ == 0; }
+
+    const char *CString() const noexcept { return raw_path_.data(); }
+    std::string_view StringView() const noexcept
+    {
+        return std::string_view(raw_path_.data(), path_len_);
+    }
+
+    // Component access
+    size_t ComponentCount() const noexcept { return num_components_; }
+    bool HasComponents() const noexcept { return num_components_ > 0; }
+
+    std::string_view operator[](size_t index) const noexcept
+    {
+        return index < num_components_ ? components_[index] : std::string_view{};
+    }
+
+    std::string_view GetComponent(size_t index) const noexcept { return (*this)[index]; }
+
+    std::string_view GetFilename() const noexcept
+    {
+        return num_components_ == 0 ? std::string_view{} : components_[num_components_ - 1];
+    }
+
+    std::string_view GetStem() const noexcept
+    {
+        auto filename = GetFilename();
+        if (filename.empty())
+            return {};
+        auto dot_pos = filename.find_last_of('.');
+        return (dot_pos == std::string_view::npos || dot_pos == 0) ? filename
+                                                                   : filename.substr(0, dot_pos);
+    }
+
+    std::string_view GetExtension() const noexcept
+    {
+        auto filename = GetFilename();
+        if (filename.empty())
+            return {};
+        auto dot_pos = filename.find_last_of('.');
+        return (dot_pos == std::string_view::npos || dot_pos == 0) ? std::string_view{}
+                                                                   : filename.substr(dot_pos);
+    }
+
+    Path GetParent() const
+    {
+        if (IsRoot() || num_components_ == 0) {
+            return IsAbsolute() ? kRoot : kCurrentDir;
+        }
+
+        // If this is a relative path with only one component, parent is current dir
+        if (IsRelative() && num_components_ == 1) {
+            return kCurrentDir;
+        }
+
+        Path parent;
+        parent.is_absolute_    = is_absolute_;
+        parent.num_components_ = num_components_ - 1;
+        strncpy(parent.raw_path_.data(), raw_path_.data(), std::min(path_len_, kMaxPathSize - 1));
+        for (size_t i = 0; i < parent.num_components_; ++i) {
+            parent.components_[i] = components_[i];
+        }
+        parent.RebuildPath();
+        return parent;
+    }
+
+    // Iterator interface
+    using iterator       = PathIterator;
+    using const_iterator = PathIterator;
+
+    iterator begin() { return PathIterator(components_, 0); }
+    iterator end() { return PathIterator(components_, num_components_); }
+    const_iterator begin() const { return PathIterator(components_, 0); }
+    const_iterator end() const { return PathIterator(components_, num_components_); }
+    const_iterator cbegin() const { return begin(); }
+    const_iterator cend() const { return end(); }
+
+    // Path manipulation
+    Path operator/(const Path &other) const
+    {
+        if (other.IsAbsolute())
+            return other;
+
+        Path result = *this;
+        // Check for component overflow before appending
+        if (result.num_components_ + other.num_components_ <= kMaxComponents) {
+            for (size_t i = 0; i < other.num_components_; ++i) {
+                result.components_[result.num_components_ + i] = other.components_[i];
+            }
+            result.num_components_ += other.num_components_;
+            result.RebuildPath();
+        }
+        return result;
+    }
+
+    template <PathStringLike T>
+    Path operator/(T &&component) const
+    {
+        return *this / Path(std::forward<T>(component));
+    }
+
+    Path &operator/=(const Path &other)
+    {
+        *this = *this / other;
+        return *this;
+    }
+
+    template <PathStringLike T>
+    Path &operator/=(T &&component)
+    {
+        return *this /= Path(std::forward<T>(component));
+    }
+
+    // Canonical path operations
+    Path GetWeaklyCanonical() const
+    {
+        Path canonical;
+        canonical.is_absolute_ = is_absolute_;
+
+        for (size_t i = 0; i < num_components_; ++i) {
+            const auto &component = components_[i];
+
+            if (component == kCurrentDir.StringView()) {
+                continue;  // Skip "."
+            }
+
+            if (component == kParentDir.StringView()) {
+                if (canonical.num_components_ > 0 &&
+                    canonical.components_[canonical.num_components_ - 1] !=
+                        kParentDir.StringView()) {
+                    canonical.num_components_--;  // Pop back
+                } else if (canonical.IsRelative()) {
+                    if (canonical.num_components_ < kMaxComponents) {
+                        canonical.components_[canonical.num_components_++] = component;
+                    }
+                }
+            } else {
+                if (canonical.num_components_ < kMaxComponents) {
+                    canonical.components_[canonical.num_components_++] = component;
+                }
+            }
+        }
+
+        canonical.RebuildPath();
+        return canonical;
+    }
+
+    Path GetNormalized() const { return GetWeaklyCanonical(); }
+
+    // Callback-based iteration
+    template <PathComponentCallback Callback>
+    void ForEachComponent(Callback &&callback) const
+    {
+        for (size_t i = 0; i < num_components_; ++i) {
+            if constexpr (std::same_as<std::invoke_result_t<Callback, std::string_view>, bool>) {
+                if (!callback(components_[i]))
+                    break;
+            } else {
+                callback(components_[i]);
+            }
+        }
+    }
+
+    template <PathComponentCallback Callback>
+    void ForEachComponentReverse(Callback &&callback) const
+    {
+        if (num_components_ == 0)
+            return;
+        for (size_t i = num_components_; i-- > 0;) {
+            if constexpr (std::same_as<std::invoke_result_t<Callback, std::string_view>, bool>) {
+                if (!callback(components_[i]))
+                    break;
+            } else {
+                callback(components_[i]);
+            }
+        }
+    }
+
+    // Comparison operators
+    bool operator==(const Path &other) const noexcept
+    {
+        if (is_absolute_ != other.is_absolute_ || num_components_ != other.num_components_) {
+            return false;
+        }
+
+        for (size_t i = 0; i < num_components_; ++i) {
+            if (components_[i] != other.components_[i]) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    bool operator!=(const Path &other) const noexcept { return !(*this == other); }
+
+    bool operator<(const Path &other) const noexcept
+    {
+        if (is_absolute_ != other.is_absolute_) {
+            return !is_absolute_;  // Relative paths are less than absolute
+        }
+
+        size_t min_components = std::min(num_components_, other.num_components_);
+        for (size_t i = 0; i < min_components; ++i) {
+            if (components_[i] < other.components_[i]) {
+                return true;
+            } else if (components_[i] > other.components_[i]) {
+                return false;
+            }
+        }
+        // If all common components are equal, shorter path is less
+        return num_components_ < other.num_components_;
+    }
+
+    // Static utility methods
+
+    template <PathStringLike... Args>
+    static Path Join(Args &&...args)
+    {
+        Path result;
+        ((result /= Path(std::forward<Args>(args))), ...);
+        return result;
+    }
+
+    private:
+    void Parse()
+    {
+        num_components_ = 0;
+        std::string_view full_path(raw_path_.data(), path_len_);
+
+        if (full_path.empty()) {
+            is_absolute_ = false;
+            return;
+        }
+
+        is_absolute_ = (full_path[0] == kPathSeparator);
+
+        size_t start = is_absolute_ ? 1 : 0;
+        size_t pos   = start;
+
+        while (pos < full_path.size() && num_components_ < kMaxComponents) {
+            size_t next_sep = full_path.find(kPathSeparator, pos);
+            if (next_sep == std::string_view::npos) {
+                next_sep = full_path.size();
+            }
+
+            if (next_sep > pos) {  // Non-empty component
+                components_[num_components_++] = full_path.substr(pos, next_sep - pos);
+            }
+
+            pos = next_sep + 1;
+        }
+    }
+
+    void RebuildPath()
+    {
+        char *current         = raw_path_.data();
+        const char *const end = raw_path_.data() + kMaxPathSize;
+
+        if (is_absolute_) {
+            if (current < end) {
+                *current++ = kPathSeparator;
+            }
+        }
+
+        for (size_t i = 0; i < num_components_; ++i) {
+            if (i > 0) {
+                if (current < end) {
+                    *current++ = kPathSeparator;
+                }
+            }
+            // Ensure we don't write past the end of the buffer
+            size_t copy_len = std::min(components_[i].length(), static_cast<size_t>(end - current));
+            strncpy(current, components_[i].data(), copy_len);
+            current += copy_len;
+        }
+
+        path_len_ = current - raw_path_.data();
+        if (path_len_ < kMaxPathSize) {
+            raw_path_[path_len_] = '\0';
+        }
+
+        // Re-point all string_views to our internal buffer
+        is_absolute_          = (path_len_ > 0 && raw_path_[0] == kPathSeparator);
+        size_t current_offset = is_absolute_ ? 1 : 0;
+        for (size_t i = 0; i < num_components_; ++i) {
+            size_t component_len = components_[i].length();
+            components_[i] = std::string_view(raw_path_.data() + current_offset, component_len);
+            current_offset += component_len + 1;  // +1 for the separator
+        }
+    }
+
+    // Member variables
+    std::array<char, kMaxPathSize> raw_path_{};
+    size_t path_len_ = 0;
+
+    std::array<std::string_view, kMaxComponents> components_{};
+    size_t num_components_ = 0;
+
+    bool is_absolute_ = false;
+};
+
+inline const Path Path::kCurrentDir = Path(".");
+inline const Path Path::kParentDir  = Path("..");
+inline const Path Path::kRoot       = Path(std::string_view(&kPathSeparator, 1));
+
+#endif  // USERSPACE_PROGRAMS_SHELL_PATH_HPP_
diff --git a/kernel/src/sys/shell.cpp b/userspace/programs/shell/shell.cpp
similarity index 70%
rename from kernel/src/sys/shell.cpp
rename to userspace/programs/shell/shell.cpp
index ef3eaf52..ede8a040 100644
--- a/kernel/src/sys/shell.cpp
+++ b/userspace/programs/shell/shell.cpp
@@ -1,25 +1,16 @@
-#include "sys/shell.hpp"
+#include "shell.hpp"
 
+#include <stdio.h>
 #include <string.h>
 #include <string.hpp>
 
-#include "acpi/acpi_power.hpp"
-#include "modules/memory.hpp"
-#include "modules/vfs.hpp"
-#include "sys/loader.hpp"
+#include "alkos/sys/fd.h"
+#include "alkos/sys/power.h"
 
 namespace System
 {
 
-GraphicsConsole *g_active_console = nullptr;
-
-Shell::Shell(GraphicsConsole &console, IO::IReader &input_reader)
-    : console_(console), input_reader_(input_reader)
-{
-    // !!! TEMPORARY !!!
-    g_active_console = &console_;
-    // !!! TEMPORARY !!!
-}
+Shell::Shell(GraphicsConsole &console) : console_(console) {}
 
 void Shell::Init()
 {
@@ -39,10 +30,12 @@ void Shell::PrintPrompt()
 
 void Shell::Update()
 {
-    auto result = input_reader_.GetChar();
-    if (result.has_value()) {
-        OnInput(result.value());
+    char c;
+    auto read = fread(&c, 1, 1, stdin);
+    if (read != 1) {
+        return;  // No input
     }
+    OnInput(c);
 }
 
 void Shell::OnInput(char c)
@@ -103,9 +96,9 @@ void Shell::ProcessCommand()
     } else if (cmd == "exec") {
         CmdExec(args);
     } else if (cmd == "shutdown") {
-        ACPI::SystemShutdown();
+        Shutdown();
     } else if (cmd == "reboot") {
-        ACPI::SystemReboot();
+        Reboot();
     } else {
         console_.Write(
             std::span<const byte>(reinterpret_cast<const byte *>("Unknown command: "), 17)
@@ -143,13 +136,13 @@ void Shell::CmdEcho(std::string_view args)
     console_.PutChar('\n');
 }
 
-vfs::Path Shell::ResolvePath(std::string_view path_str)
+Path Shell::ResolvePath(std::string_view path_str)
 {
     if (path_str.empty()) {
         return current_dir_;
     }
 
-    vfs::Path path(path_str);
+    Path path(path_str);
     if (path.IsAbsolute()) {
         return path.GetNormalized();
     }
@@ -177,17 +170,17 @@ void Shell::CmdCd(std::string_view args)
 
     if (args.empty()) {
         // cd with no args goes to root
-        current_dir_ = vfs::Path::kRoot;
+        current_dir_ = Path::kRoot;
         return;
     }
 
-    vfs::Path new_path = ResolvePath(args);
+    Path new_path = ResolvePath(args);
 
     // Check if path exists and is a directory
-    auto &vfs         = VfsModule::Get();
-    auto exists_check = vfs.DirectoryExists(new_path);
+    FileInfo info;
+    int result = GetFileInfo(new_path.CString(), &info);
 
-    if (!exists_check.has_value()) {
+    if (result != 0) {
         const char *err = "cd: path not found: ";
         console_.Write(std::span<const byte>(reinterpret_cast<const byte *>(err), strlen(err)));
         console_.Write(
@@ -197,7 +190,7 @@ void Shell::CmdCd(std::string_view args)
         return;
     }
 
-    if (!exists_check.value()) {
+    if (info.type != kFileTypeDirectory) {
         const char *err = "cd: not a directory: ";
         console_.Write(std::span<const byte>(reinterpret_cast<const byte *>(err), strlen(err)));
         console_.Write(
@@ -220,13 +213,17 @@ void Shell::CmdLs(std::string_view args)
         args.remove_suffix(1);
     }
 
-    vfs::Path path = args.empty() ? current_dir_ : ResolvePath(args);
+    Path path = args.empty() ? current_dir_ : ResolvePath(args);
 
-    auto &vfs = VfsModule::Get();
+    // Allocate buffer for directory entries
+    static constexpr size_t kMaxEntries = 128;
+    DirEntry entries[kMaxEntries];
+    size_t num_entries = 0;
 
-    // Check if the path exists
-    auto exists_check = vfs.DirectoryExists(path);
-    if (!exists_check.has_value() || !exists_check.value()) {
+    // Call ReadDirectory syscall
+    int result = ReadDirectory(path.CString(), entries, kMaxEntries, &num_entries);
+
+    if (result != 0) {
         const char *err = "ls: cannot access '";
         console_.Write(std::span<const byte>(reinterpret_cast<const byte *>(err), strlen(err)));
         const char *p = path.CString();
@@ -236,18 +233,26 @@ void Shell::CmdLs(std::string_view args)
         return;
     }
 
-    // List directory contents
-    vfs.ListDirectory(path, [this](const char *name, bool is_dir) {
-        if (is_dir) {
+    // Display entries
+    for (size_t i = 0; i < num_entries; i++) {
+        const auto &entry = entries[i];
+
+        // Color directories blue
+        if (entry.type == kFileTypeDirectory) {
             console_.SetColors(Graphics::Color::Blue(), Graphics::Color::Black());
         }
-        console_.Write(std::span<const byte>(reinterpret_cast<const byte *>(name), strlen(name)));
-        if (is_dir) {
+
+        console_.Write(
+            std::span<const byte>(reinterpret_cast<const byte *>(entry.name), strlen(entry.name))
+        );
+
+        if (entry.type == kFileTypeDirectory) {
             console_.PutChar('/');
             console_.SetColors(Graphics::Color::White(), Graphics::Color::Black());
         }
+
         console_.PutChar('\n');
-    });
+    }
 }
 
 void Shell::CmdCat(std::string_view args)
@@ -266,13 +271,11 @@ void Shell::CmdCat(std::string_view args)
         return;
     }
 
-    vfs::Path path = ResolvePath(args);
+    Path path = ResolvePath(args);
 
-    auto &vfs = VfsModule::Get();
-
-    // Check if file exists
-    auto exists_check = vfs.FileExists(path);
-    if (!exists_check.has_value() || !exists_check.value()) {
+    // Open file for reading
+    FILE *file = fopen(path.CString(), "r");
+    if (!file) {
         const char *err = "cat: ";
         console_.Write(std::span<const byte>(reinterpret_cast<const byte *>(err), strlen(err)));
         console_.Write(
@@ -283,43 +286,27 @@ void Shell::CmdCat(std::string_view args)
         return;
     }
 
-    // Get file size
-    auto size_result = vfs.GetFileSize(path);
-    if (!size_result.has_value()) {
-        const char *err = "cat: cannot read file size\n";
-        console_.Write(std::span<const byte>(reinterpret_cast<const byte *>(err), strlen(err)));
-        return;
-    }
-
-    size_t file_size = size_result.value();
-    if (file_size == 0) {
-        return;  // Empty file, nothing to print
-    }
-
     // Read and display file contents in chunks
     static constexpr size_t kBufferSize = 512;
     char buffer[kBufferSize];
-    size_t offset = 0;
-
-    while (offset < file_size) {
-        size_t to_read   = (file_size - offset) < kBufferSize ? (file_size - offset) : kBufferSize;
-        auto read_result = vfs.ReadFile(path, buffer, to_read, offset);
 
-        if (!read_result.has_value()) {
-            const char *err = "\ncat: error reading file\n";
-            console_.Write(std::span<const byte>(reinterpret_cast<const byte *>(err), strlen(err)));
-            return;
-        }
-
-        size_t bytes_read = read_result.value();
+    while (true) {
+        size_t bytes_read = fread(buffer, 1, kBufferSize, file);
         if (bytes_read == 0) {
+            if (ferror(file)) {
+                const char *err = "\ncat: error reading file\n";
+                console_.Write(
+                    std::span<const byte>(reinterpret_cast<const byte *>(err), strlen(err))
+                );
+            }
             break;
         }
 
         console_.Write(std::span<const byte>(reinterpret_cast<const byte *>(buffer), bytes_read));
-        offset += bytes_read;
     }
 
+    fclose(file);
+
     // Ensure we end with a newline
     console_.PutChar('\n');
 }
@@ -340,32 +327,9 @@ void Shell::CmdExec(std::string_view args)
         return;
     }
 
-    vfs::Path programPath = ResolvePath(args);
+    Path programPath = ResolvePath(args);
 
-    auto &as       = MemoryModule::Get().GetKernelAddressSpace();
-    auto entry_res = ElfLoader::Load(programPath, as);
-
-    if (entry_res) {
-        Mem::VPtr<void> entry_addr = entry_res.value();
-        auto user_main             = reinterpret_cast<void (*)()>(entry_addr);
-
-        console_.Write(
-            std::span<const byte>(reinterpret_cast<const byte *>("Executing user program...\n"), 26)
-        );
-
-        // Execute the program
-        user_main();
-
-        console_.Write(
-            std::span<const byte>(reinterpret_cast<const byte *>("User program returned.\n"), 23)
-        );
-    } else {
-        console_.Write(
-            std::span<const byte>(
-                reinterpret_cast<const byte *>("Failed to load executable.\n"), 27
-            )
-        );
-    }
+    // TODO: Implement program execution
 }
 
 }  // namespace System
diff --git a/kernel/src/sys/shell.hpp b/userspace/programs/shell/shell.hpp
similarity index 81%
rename from kernel/src/sys/shell.hpp
rename to userspace/programs/shell/shell.hpp
index ce9b1bca..14c2404b 100644
--- a/kernel/src/sys/shell.hpp
+++ b/userspace/programs/shell/shell.hpp
@@ -1,19 +1,16 @@
-#ifndef KERNEL_SRC_SYS_SHELL_HPP_
-#define KERNEL_SRC_SYS_SHELL_HPP_
+#ifndef USERSPACE_PROGRAMS_SHELL_SHELL_HPP_
+#define USERSPACE_PROGRAMS_SHELL_SHELL_HPP_
 
 #include <data_structures/array_structures.hpp>
 #include <span.hpp>
 #include <string.hpp>
 
-#include "fs/vfs/path.hpp"
-#include "io/stream.hpp"
-#include "sys/graphics_console.hpp"
+#include "graphics_console.hpp"
+#include "path.hpp"
 
 namespace System
 {
 
-extern GraphicsConsole *g_active_console;
-
 // --------------------------------------------------------------------------------
 // Shell
 // --------------------------------------------------------------------------------
@@ -21,7 +18,7 @@ extern GraphicsConsole *g_active_console;
 class Shell
 {
     public:
-    explicit Shell(GraphicsConsole &console, IO::IReader &input_reader);
+    explicit Shell(GraphicsConsole &console);
 
     // -------------------------------------------------------------------------
     // Public Interface
@@ -50,7 +47,6 @@ class Shell
     void CmdHelp();
     void CmdClear();
     void CmdEcho(std::string_view args);
-    void CmdMem();
     void CmdCd(std::string_view args);
     void CmdLs(std::string_view args);
     void CmdCat(std::string_view args);
@@ -61,7 +57,7 @@ class Shell
     // Path utilities
     // -------------------------------------------------------------------------
 
-    vfs::Path ResolvePath(std::string_view path_str);
+    Path ResolvePath(std::string_view path_str);
 
     // -------------------------------------------------------------------------
     // Internal Helpers
@@ -71,8 +67,7 @@ class Shell
 
     // Data
     GraphicsConsole &console_;
-    IO::IReader &input_reader_;
-    vfs::Path current_dir_{vfs::Path::kRoot};
+    Path current_dir_{Path::kRoot};
 
     static constexpr size_t kMaxInput = 128;
     data_structures::StaticVector<char, kMaxInput> input_buffer_;
@@ -80,4 +75,4 @@ class Shell
 
 }  // namespace System
 
-#endif  // KERNEL_SRC_SYS_SHELL_HPP_
+#endif  // USERSPACE_PROGRAMS_SHELL_SHELL_HPP_
diff --git a/userspace/programs/shell/stream.hpp b/userspace/programs/shell/stream.hpp
new file mode 100644
index 00000000..809c112e
--- /dev/null
+++ b/userspace/programs/shell/stream.hpp
@@ -0,0 +1,58 @@
+#ifndef USERSPACE_PROGRAMS_SHELL_STREAM_HPP_
+#define USERSPACE_PROGRAMS_SHELL_STREAM_HPP_
+
+#include <expected.hpp>
+#include <span.hpp>
+
+#include "internal/macros.hpp"
+
+namespace IO
+{
+
+enum class Error {
+    None,
+    Retry,        // Resource busy/buffer full (Non-blocking)
+    EndOfFile,    // Connection closed
+    DeviceError,  // Hardware fault
+    InvalidInput
+};
+
+using std::expected;
+using std::unexpected;
+
+using IoResult = expected<size_t, Error>;
+
+/**
+ * @brief Abstract interface for writing bytes.
+ */
+class IWriter
+{
+    public:
+    virtual ~IWriter() = default;
+
+    // Write bytes from the provided buffer.
+    // Returns the actual number of bytes written.
+    virtual IoResult Write(std::span<const byte> buffer) = 0;
+
+    // Helper for single char
+    virtual IoResult PutChar(char c)
+    {
+        const byte b = static_cast<byte>(c);
+        return Write(std::span<const byte>(&b, 1));
+    }
+
+    // Helper for strings
+    virtual IoResult WriteString(const char *str)
+    {
+        size_t len    = 0;
+        const char *s = str;
+        while (*s++ != 0) {
+            len++;
+        }
+        return Write(std::span<const byte>(reinterpret_cast<const byte *>(str), len));
+    }
+};
+
+}  // namespace IO
+
+#endif  // USERSPACE_PROGRAMS_SHELL_STREAM_HPP_

From b663bdf41302f8a99fd4c971fc76701ee38d141d Mon Sep 17 00:00:00 2001
From: Jakub Lisowski <115403674+Jlisowskyy@users.noreply.github.com>
Date: Sun, 4 Jan 2026 12:51:28 +0100
Subject: [PATCH 48/56] Jlisowskyy/scheduler imprv 3 (#268)

Things done in this PR:
- intrusive front list added
- simple random gen for tests added
- added intrusive rb tree
- added sleep syscalls
- added sleep support to scheduler
- added better timing event to scheduler
---
 kernel/arch/x86_64/src/cpu/utils.hpp          |   2 +-
 .../x86_64/src/drivers/apic/local_apic.cpp    |   9 +-
 kernel/arch/x86_64/src/hal/impl/panic.cpp     |   1 -
 kernel/arch/x86_64/src/include/thread.nasm    |   2 +-
 kernel/arch/x86_64/src/tests/manual_tests.cpp |  35 ++
 kernel/src/hal/panic.hpp                      |   5 +-
 kernel/src/modules/timing.hpp                 |   2 -
 kernel/src/scheduling/kworker.cpp             |   4 +
 .../policies/priority_queue_policy.hpp        |  22 +
 .../policies/round_robin_policy.hpp           |  16 +
 kernel/src/scheduling/policy.hpp              |  28 +-
 kernel/src/scheduling/scheduler.cpp           | 163 +++++-
 kernel/src/scheduling/scheduler.hpp           |  64 ++-
 kernel/src/scheduling/scheduler_lock.hpp      |  18 +
 kernel/src/scheduling/task_mgr.cpp            |   4 +-
 kernel/src/scheduling/thread.cpp              |  15 +
 kernel/src/scheduling/thread.hpp              |   9 +-
 kernel/src/syscalls/calls/proc.hpp            |   2 +-
 kernel/src/syscalls/calls/thread.hpp          |  16 +
 kernel/src/syscalls/syscalls.cpp              |   2 +
 kernel/src/time/event_framework.cpp           |  43 --
 kernel/src/time/event_framework.hpp           |  40 --
 kernel/src/timing.cpp                         |   3 -
 kernel/test/rb_test.cpp                       | 286 ++++++++++
 kernel/test/tests.cpp                         |  28 +
 libs/libc/src/abi/platform.h                  |   2 +
 libs/libc/src/include/alkos/sys/thread.h      |   4 +
 libs/libc/src/include/alkos/syscall.h         |   2 +
 libs/libc/src/internal/libc_backend.cpp       |   2 +
 .../data_structures/intrusive_linked_list.hpp |  56 ++
 .../maps/intrusive_rb_tree.hpp                | 503 ++++++++++++++++++
 libs/libcpp/include/random.hpp                |  22 +
 32 files changed, 1291 insertions(+), 119 deletions(-)
 create mode 100644 kernel/src/scheduling/scheduler_lock.hpp
 create mode 100644 kernel/src/scheduling/thread.cpp
 delete mode 100644 kernel/src/time/event_framework.cpp
 delete mode 100644 kernel/src/time/event_framework.hpp
 create mode 100644 kernel/test/rb_test.cpp
 create mode 100644 libs/libcontainers/include/data_structures/maps/intrusive_rb_tree.hpp
 create mode 100644 libs/libcpp/include/random.hpp

diff --git a/kernel/arch/x86_64/src/cpu/utils.hpp b/kernel/arch/x86_64/src/cpu/utils.hpp
index 0876f984..4a658e9d 100644
--- a/kernel/arch/x86_64/src/cpu/utils.hpp
+++ b/kernel/arch/x86_64/src/cpu/utils.hpp
@@ -58,7 +58,7 @@ FAST_CALL NO_RET void OsHang()
  * Disables interrupts and enters an infinite halt loop.
  * System cannot be woken up from this state.
  */
-FAST_CALL void OsHangNoInterrupts()
+FAST_CALL NO_RET void OsHangNoInterrupts()
 {
     BlockHardwareInterrupts();
     OsHang();
diff --git a/kernel/arch/x86_64/src/drivers/apic/local_apic.cpp b/kernel/arch/x86_64/src/drivers/apic/local_apic.cpp
index a0f542ea..96c9260a 100644
--- a/kernel/arch/x86_64/src/drivers/apic/local_apic.cpp
+++ b/kernel/arch/x86_64/src/drivers/apic/local_apic.cpp
@@ -69,9 +69,7 @@ static u32 NextEventCb(hardware::EventClockRegistryEntry *entry, const u64 time_
     const u64 divided_freq = lapic_freq / kTimerDivider;
 
     LocalApic::DisableTimer();
-
     LocalApic::SetTimerDivider(kTimerDivider);
-    LocalApic::SetTimerCounter((time_ns * kNanosInSecond) / divided_freq);
 
     LocalApic::LocalVectorTableTimerRegister reg{};
     reg.mask       = LocalApic::LocalVectorTableTimerRegister::Mask::kEnabled;
@@ -81,6 +79,13 @@ static u32 NextEventCb(hardware::EventClockRegistryEntry *entry, const u64 time_
     reg.vector     = arch::kTimerHwInt;
 
     LocalApic::WriteRegister(LocalApic::kLvtTimerRegRW, reg);
+
+    u64 ticks = (time_ns * divided_freq) / kNanosInSecond;
+    if (ticks == 0)
+        ticks = 1;
+
+    LocalApic::SetTimerCounter(static_cast<u32>(ticks));
+
     return 0;
 }
 
diff --git a/kernel/arch/x86_64/src/hal/impl/panic.cpp b/kernel/arch/x86_64/src/hal/impl/panic.cpp
index 40d5be92..75548486 100644
--- a/kernel/arch/x86_64/src/hal/impl/panic.cpp
+++ b/kernel/arch/x86_64/src/hal/impl/panic.cpp
@@ -14,7 +14,6 @@ extern "C" void NO_RET KernelPanic()
     if constexpr (FeatureEnabled<FeatureFlag::kRunTestMode>) {
         test::OnKernelPanic();
     } else {
-        trace::DumpAllBuffersOnFailure();
         OsHangNoInterrupts();
     }
 }
diff --git a/kernel/arch/x86_64/src/include/thread.nasm b/kernel/arch/x86_64/src/include/thread.nasm
index b8f82e76..e6273816 100644
--- a/kernel/arch/x86_64/src/include/thread.nasm
+++ b/kernel/arch/x86_64/src/include/thread.nasm
@@ -3,7 +3,7 @@
 ; ------------------------------------------------------------
 
 struc Thread
-    .next:                  resq 1
+    .intrusive_data         resb 48
 
     .tid:                   resq 1
     .owner:                 resq 1
diff --git a/kernel/arch/x86_64/src/tests/manual_tests.cpp b/kernel/arch/x86_64/src/tests/manual_tests.cpp
index 2f134dc2..10376cec 100644
--- a/kernel/arch/x86_64/src/tests/manual_tests.cpp
+++ b/kernel/arch/x86_64/src/tests/manual_tests.cpp
@@ -1,6 +1,8 @@
 #include <test_module/test.hpp>
 #include "cpu/utils.hpp"
 
+#include "modules/hardware.hpp"
+
 /**
  * Simply prints the default exception message.
  */
@@ -11,3 +13,36 @@ MTEST(VerifyDefaultExceptionMsg)
     [[maybe_unused]] volatile int a = 9 / 0;
 #pragma GCC diagnostic pop
 }
+
+static constexpr u64 kTimerInterval = 5'000'000;  // 5ms
+static Sched::Thread *TimerHandler(intr::LitHwEntry &)
+{
+    TRACE_FATAL_ACPI("ACK FROM HANDLER!");
+    trace::DumpAllBuffersOnFailure();
+
+    auto &event_clock = HardwareModule::Get().GetEventClockRegistry().GetSelected();
+    const u32 result  = event_clock.cbs.next_event(&event_clock, kTimerInterval);
+    ASSERT_ZERO(result);
+
+    return nullptr;
+}
+
+MTEST(LAPIC)
+{
+    HardwareModule::Get()
+        .GetInterrupts()
+        .GetLit()
+        .InstallInterruptHandler<intr::InterruptType::kHardwareInterrupt>(
+            hal::kTimerHwLirq, intr::HwHandler{.handler = TimerHandler}
+        );
+
+    auto &event_clock = HardwareModule::Get().GetEventClockRegistry().GetSelected();
+    ASSERT_TRUE(event_clock.flags.IsCoreLocal, "Scheduler supports only core local event clocks");
+    event_clock.cbs.set_oneshot(&event_clock);
+
+    event_clock.cbs.next_event(&event_clock, kTimerInterval);
+
+    for (size_t i = 0; i < 10; ++i) {
+        HaltCpu();
+    }
+}
diff --git a/kernel/src/hal/panic.hpp b/kernel/src/hal/panic.hpp
index d0875801..3c8a9a35 100644
--- a/kernel/src/hal/panic.hpp
+++ b/kernel/src/hal/panic.hpp
@@ -16,14 +16,15 @@ namespace hal
  *       to help diagnose the issue.
  * @param msg A message providing additional information about the panic.
  */
-WRAP_CALL void KernelPanic(const char *msg)
+FAST_CALL void KernelPanic(const char *msg)
 {
     if (HardwareModule::IsInited()) {
         HardwareModule::Get().GetInterrupts().BlockHardwareInterrupts();
         HardwareModule::Get().GetCoresController().PanicAllCores();
     }
 
-    // For some reason trace::DumpAllBuffersOnFailure() must be called before and after printing
+    trace::DumpAllBuffersOnFailure();
+
     // BYPASS TRACE FRAMEWORK AS this function is used inside of it
     TerminalWriteString("[ KERNEL PANIC ]");
     TerminalWriteString(msg);
diff --git a/kernel/src/modules/timing.hpp b/kernel/src/modules/timing.hpp
index f1f2c6c7..1c79f6f4 100644
--- a/kernel/src/modules/timing.hpp
+++ b/kernel/src/modules/timing.hpp
@@ -5,7 +5,6 @@
 
 #include "modules/helpers.hpp"
 #include "modules/timing_constants.hpp"
-#include "time/event_framework.hpp"
 #include "time/system_time.hpp"
 
 namespace internal
@@ -29,7 +28,6 @@ class TimingModule : template_lib::StaticSingletonHelper
     // ------------------------------
 
     DEFINE_MODULE_FIELD(timing, SystemTime)
-    DEFINE_MODULE_FIELD(timing, EventFramework)
 };
 }  // namespace internal
 
diff --git a/kernel/src/scheduling/kworker.cpp b/kernel/src/scheduling/kworker.cpp
index e6843bd1..60a8d3a5 100644
--- a/kernel/src/scheduling/kworker.cpp
+++ b/kernel/src/scheduling/kworker.cpp
@@ -24,6 +24,10 @@ void Sched::KWorkerMain()
             hal::Noop();
             hal::Noop();
         }
+
+        SchedulingModule::Get().GetScheduler().Yield();
+        // const auto pid = hardware::GetRunningPid();
+        // TRACE_INFO_SCHEDULING("ACK FROM PID: %llu", pid);
     }
 }
 
diff --git a/kernel/src/scheduling/policies/priority_queue_policy.hpp b/kernel/src/scheduling/policies/priority_queue_policy.hpp
index f825ddaa..c12ccb51 100644
--- a/kernel/src/scheduling/policies/priority_queue_policy.hpp
+++ b/kernel/src/scheduling/policies/priority_queue_policy.hpp
@@ -37,6 +37,28 @@ class PriorityQueuePolicy : public PolicyImpl
         priority_queue_.Insert(thread, thread->flags.priority);
     }
 
+    NODISCARD FORCE_INLINE_F u64 GetPreemptTime(Thread *thread)
+    {
+        static constexpr u64 kPreemptTimeNs = 5'000'000;  // 5ms
+
+        ASSERT_NOT_NULL(thread);
+
+        if (thread->state != ThreadState::kRunning) {
+            return kPreemptTimeNs;
+        }
+
+        const u64 cpu_time_ns = thread->CalculateCpuTime();
+        return cpu_time_ns < kPreemptTimeNs ? kPreemptTimeNs - cpu_time_ns : 0;
+    }
+
+    NODISCARD FORCE_INLINE_F bool IsFirstHigherPriority(Thread *first, Thread *second)
+    {
+        ASSERT_NOT_NULL(first);
+        ASSERT_NOT_NULL(second);
+
+        return first->flags.priority > second->flags.priority;
+    }
+
     // ------------------------------
     // Private methods
     // ------------------------------
diff --git a/kernel/src/scheduling/policies/round_robin_policy.hpp b/kernel/src/scheduling/policies/round_robin_policy.hpp
index 8de0c254..de065a5b 100644
--- a/kernel/src/scheduling/policies/round_robin_policy.hpp
+++ b/kernel/src/scheduling/policies/round_robin_policy.hpp
@@ -33,6 +33,22 @@ class RoundRobinPolicy : public PolicyImpl
         threads_.PushBack(thread);
     }
 
+    NODISCARD FORCE_INLINE_F u64 GetPreemptTime(Thread *thread)
+    {
+        static constexpr u64 kPreemptTimeNs = 20'000'000;  // 20ms
+
+        ASSERT_NOT_NULL(thread);
+
+        if (thread->state != ThreadState::kRunning) {
+            return kPreemptTimeNs;
+        }
+
+        const u64 cpu_time_ns = thread->CalculateCpuTime();
+        return cpu_time_ns < kPreemptTimeNs ? kPreemptTimeNs - cpu_time_ns : 0;
+    }
+
+    NODISCARD FORCE_INLINE_F bool IsFirstHigherPriority(Thread *, Thread *) { return false; }
+
     // ------------------------------
     // Private methods
     // ------------------------------
diff --git a/kernel/src/scheduling/policy.hpp b/kernel/src/scheduling/policy.hpp
index ca6b57ec..aea7fefc 100644
--- a/kernel/src/scheduling/policy.hpp
+++ b/kernel/src/scheduling/policy.hpp
@@ -31,6 +31,8 @@ struct Policy {
     struct {
         Thread *(*pick_next_task)(void *);
         void (*add_task)(void *, Thread *);
+        u64 (*get_preempt_time)(void *, Thread *);
+        bool (*is_first_higher_priority)(void *, Thread *, Thread *);
     } cbs;
     void *self;
 };
@@ -42,6 +44,8 @@ struct Policy {
 struct PolicyImpl {
     NODISCARD Thread *PickNextTask() { R_FAIL_ALWAYS("NOT_IMPLEMENTED"); }
     void AddTask(Thread *) { R_FAIL_ALWAYS("NOT_IMPLEMENTED"); }
+    NODISCARD u64 GetPreemptTime(Thread *) { R_FAIL_ALWAYS("NOT_IMPLEMENTED"); }
+    NODISCARD bool IsFirstHigherPriority(Thread *, Thread *) { R_FAIL_ALWAYS("NOT_IMPLEMENTED"); }
 };
 
 template <class T>
@@ -60,15 +64,33 @@ void AddTaskImpl(void *self, Thread *thread)
     rr->AddTask(thread);
 }
 
+template <class T>
+    requires std::derived_from<T, PolicyImpl>
+u64 GetPreemptTimeImpl(void *self, Thread *thread)
+{
+    const auto rr = static_cast<T *>(self);
+    return rr->GetPreemptTime(thread);
+}
+
+template <class T>
+    requires std::derived_from<T, PolicyImpl>
+bool IsFirstHigherPriorityImpl(void *self, Thread *first, Thread *second)
+{
+    const auto rr = static_cast<T *>(self);
+    return rr->IsFirstHigherPriority(first, second);
+}
+
 template <class T>
     requires std::derived_from<T, PolicyImpl>
 NODISCARD FAST_CALL Policy PreparePolicy(T *self)
 {
     Policy policy{};
 
-    policy.self               = self;
-    policy.cbs.pick_next_task = PickNextTaskImpl<T>;
-    policy.cbs.add_task       = AddTaskImpl<T>;
+    policy.self                         = self;
+    policy.cbs.pick_next_task           = PickNextTaskImpl<T>;
+    policy.cbs.add_task                 = AddTaskImpl<T>;
+    policy.cbs.get_preempt_time         = GetPreemptTimeImpl<T>;
+    policy.cbs.is_first_higher_priority = IsFirstHigherPriorityImpl<T>;
 
     return policy;
 }
diff --git a/kernel/src/scheduling/scheduler.cpp b/kernel/src/scheduling/scheduler.cpp
index b8a13079..7a1b5bc7 100644
--- a/kernel/src/scheduling/scheduler.cpp
+++ b/kernel/src/scheduling/scheduler.cpp
@@ -4,6 +4,20 @@
 #include "modules/hardware.hpp"
 #include "modules/scheduling.hpp"
 #include "modules/timing.hpp"
+#include "scheduling/scheduler_lock.hpp"
+
+// ------------------------------
+// statics
+// ------------------------------
+
+static Sched::Thread *TimerHandler(intr::LitHwEntry &)
+{
+    return SchedulingModule::Get().GetScheduler().TimerRoutine();
+}
+
+// ------------------------------
+// Implementations
+// ------------------------------
 
 namespace Sched
 {
@@ -21,6 +35,16 @@ Scheduler::Scheduler()
         PreparePolicy<RoundRobinPolicy>(&policy4_);
 }
 
+void Scheduler::InstallInterruptHandler()
+{
+    HardwareModule::Get()
+        .GetInterrupts()
+        .GetLit()
+        .InstallInterruptHandler<intr::InterruptType::kHardwareInterrupt>(
+            hal::kTimerHwLirq, intr::HwHandler{.handler = TimerHandler}
+        );
+}
+
 void Scheduler::AddReadyThread(Thread *thread)
 {
     ASSERT_EQ(thread->state, ThreadState::kReady);
@@ -48,38 +72,151 @@ Thread *Scheduler::Schedule()
     return nullptr;
 }
 
-Thread *Scheduler::ScheduleAndUpdateThreads()
+Thread *Scheduler::ScheduleAndUpdateThreads(const bool preempt, const ThreadState thread_state)
 {
-    const auto thread = Schedule();
-    ASSERT_EQ(thread->state, ThreadState::kReady);
-    thread->state = ThreadState::kRunning;
+    u64 min_time_ns = std::numeric_limits<u64>::max();
+
+    // 1. Wake up all tasks
+    const bool force_preempt = WakeUpTasks();
 
-    ASSERT_NOT_NULL(hardware::GetCoreLocalTcb());
-    ASSERT_EQ(hardware::GetCoreLocalTcb()->state, ThreadState::kRunning);
-    hardware::GetCoreLocalTcb()->state = ThreadState::kReady;
-    AddReadyThread(hardware::GetCoreLocalTcb());
+    // 2. Check for sleepers time
+    const u64 time = TimingModule::Get().GetSystemTime().ReadLifeTimeNs();
+    if (!sleep_queue_.IsEmpty()) {
+        min_time_ns = sleep_queue_.Min()->key - time;
+    }
+
+    // 3. Scheduling new thread if needed and update structs
+    Thread *thread{};
+    u64 preempt_time_ns = GetPreemptTime_(hardware::GetCoreLocalTcb());
+    if (preempt || force_preempt || ShouldPreempt_(preempt_time_ns)) {
+        const auto next_thread = Schedule();
+        ASSERT_EQ(next_thread->state, ThreadState::kReady);
+        preempt_time_ns    = GetPreemptTime_(next_thread);
+        next_thread->state = ThreadState::kRunning;
+
+        ASSERT_NOT_NULL(hardware::GetCoreLocalTcb());
+        ASSERT_EQ(hardware::GetCoreLocalTcb()->state, ThreadState::kRunning);
+        hardware::GetCoreLocalTcb()->state = thread_state;
+
+        if (thread_state == ThreadState::kReady) {
+            AddReadyThread(hardware::GetCoreLocalTcb());
+        }
+
+        thread = next_thread;
+    }
+
+    // 4. Check with preempt time
+    ASSERT_GT(preempt_time_ns, kMinDelta);
+    min_time_ns = std::min(preempt_time_ns, min_time_ns);
+
+    // 5. Schedule next timer
+    ASSERT_GT(min_time_ns, kMinDelta);
+    SetupNextTimeEvent_(min_time_ns);
 
     return thread;
 }
 
 void Scheduler::Yield()
 {
-    HardwareModule::Get().GetInterrupts().BlockHardwareInterrupts();
-    YieldUnguarded();
-    HardwareModule::Get().GetInterrupts().EnableHardwareInterrupts();
+    SchedulerLock lock{};
+    hal::ContextSwitch(ScheduleAndUpdateThreads(true, ThreadState::kReady));
 }
 
 void Scheduler::ConvertToScheduling()
 {
+    TRACE_INFO_SCHEDULING("Converting to scheduling!");
+
     HardwareModule::Get().GetInterrupts().BlockHardwareInterrupts();
 
-    static constexpr u64 kPeriodicTime1Ms = kNanosInSecond / 1'000;
-    TimingModule::Get().GetEventFramework().SetupPeriodic(kPeriodicTime1Ms);
+    ASSERT_TRUE(HardwareModule::Get().GetEventClockRegistry().IsSelectedPicked());
+
+    auto &event_clock = HardwareModule::Get().GetEventClockRegistry().GetSelected();
+    ASSERT_TRUE(event_clock.flags.IsCoreLocal, "Scheduler supports only core local event clocks");
+    event_clock.cbs.set_oneshot(&event_clock);
 
     const auto thread = Schedule();
     ASSERT_EQ(thread->state, ThreadState::kReady);
+
+    const u64 preempt_time_ns = GetPreemptTime_(thread);
+    ASSERT_GT(preempt_time_ns, kMinDelta);
+
     thread->state = ThreadState::kRunning;
+    SetupNextTimeEvent_(preempt_time_ns);
 
+    TRACE_INFO_SCHEDULING("Converting to thread: %llu!", thread->tid);
     hal::ConvertContext(thread);
 }
+
+void Scheduler::NanoSleepUntil(const u64 systime_ns)
+{
+    u64 time;
+    {
+        SchedulerLock lock{};
+        time = TimingModule::Get().GetSystemTime().ReadLifeTimeNs();
+        if (systime_ns < time) {
+            return;
+        }
+    }
+
+    if (systime_ns - time < kMinDelta) {
+        /* Do busy wait if window to scheduler irq is too small */
+        while (systime_ns - TimingModule::Get().GetSystemTime().ReadLifeTimeNs() < kMinDelta) {
+        }
+        return;
+    }
+
+    {
+        SchedulerLock lock{};
+
+        hardware::GetCoreLocalTcb()->key = systime_ns;
+        sleep_queue_.Insert(hardware::GetCoreLocalTcb());
+
+        hal::ContextSwitch(ScheduleAndUpdateThreads(true, ThreadState::kSleeping));
+    }
+}
+
+void Scheduler::SetupNextTimeEvent_(const u64 time_ns)
+{
+    ASSERT_TRUE(HardwareModule::Get().GetEventClockRegistry().IsSelectedPicked());
+
+    auto &event_clock = HardwareModule::Get().GetEventClockRegistry().GetSelected();
+    ASSERT_TRUE(event_clock.flags.IsCoreLocal, "Scheduler supports only core local event clocks");
+
+    event_clock.cbs.next_event(&event_clock, time_ns);
+}
+
+bool Scheduler::WakeUpTasks()
+{
+    bool should_preempt = false;
+    while (!sleep_queue_.IsEmpty()) {
+        const u64 time       = TimingModule::Get().GetSystemTime().ReadLifeTimeNs();
+        const u64 sleep_time = sleep_queue_.Min()->key;
+
+        if (sleep_time > time && sleep_time - time > kMinDelta) {
+            break;
+        }
+
+        const auto thread = sleep_queue_.Min();
+        should_preempt |= IsFirstHigherPriority_(thread, hardware::GetCoreLocalTcb());
+
+        sleep_queue_.Delete(thread);
+        ASSERT_EQ(thread->state, ThreadState::kSleeping);
+
+        thread->state = ThreadState::kReady;
+        AddReadyThread(thread);
+    }
+
+    return should_preempt;
+}
+
+Thread *Scheduler::TimerRoutine()
+{
+    if (hardware::GetCoreLocalTcb() == nullptr) {
+        // Not yet converted to scheduling
+        return nullptr;
+    }
+
+    // TODO: Idle
+    return ScheduleAndUpdateThreads(false, ThreadState::kReady);
+}
 }  // namespace Sched
diff --git a/kernel/src/scheduling/scheduler.hpp b/kernel/src/scheduling/scheduler.hpp
index 059e7a70..477c75d3 100644
--- a/kernel/src/scheduling/scheduler.hpp
+++ b/kernel/src/scheduling/scheduler.hpp
@@ -8,7 +8,9 @@
 #include "policy.hpp"
 #include "thread.hpp"
 
+#include "data_structures/maps/intrusive_rb_tree.hpp"
 #include "hal/scheduling.hpp"
+#include "hal/spinlock.hpp"
 #include "hardware/core_local.hpp"
 #include "policies/priority_queue_policy.hpp"
 #include "policies/round_robin_policy.hpp"
@@ -18,6 +20,8 @@ namespace Sched
 
 class Scheduler
 {
+    static constexpr u64 kMinDelta = 2'000;
+
     public:
     // ------------------------------
     // Class creation
@@ -30,27 +34,81 @@ class Scheduler
     // Class interaction
     // ------------------------------
 
+    void InstallInterruptHandler();
+
     void AddReadyThread(Thread *thread);
 
     Thread *Schedule();
 
-    Thread *ScheduleAndUpdateThreads();
+    Thread *ScheduleAndUpdateThreads(bool preempt, ThreadState thread_state);
 
     void Yield();
 
-    FORCE_INLINE_F void YieldUnguarded() { hal::ContextSwitch(ScheduleAndUpdateThreads()); }
-
     void ConvertToScheduling();
 
+    /* Should only be called inside syscall code or kernel thread code */
+    void NanoSleepUntil(u64 systime_ns);
+
+    // True if should preempt
+    NODISCARD bool WakeUpTasks();
+
+    NODISCARD Thread *TimerRoutine();
+
     // ------------------------------
     // Private methods
     // ------------------------------
 
     protected:
+    void PrepareNextTimerInterruptBeforeSwitchUnguarded_(Thread *next_thread);
+
+    NODISCARD FORCE_INLINE_F const Policy &GetPolicy_(Thread *thread) const
+    {
+        ASSERT_NOT_NULL(thread);
+        ASSERT_LT(
+            static_cast<size_t>(thread->flags.policy), static_cast<size_t>(SchedulingPolicy::kLast)
+        );
+
+        return policies_[static_cast<size_t>(thread->flags.policy)];
+    }
+
+    NODISCARD FORCE_INLINE_F u64 GetPreemptTime_(Thread *thread) const
+    {
+        const auto &policy = GetPolicy_(thread);
+        return policy.cbs.get_preempt_time(policy.self, thread);
+    }
+
+    void SetupNextTimeEvent_(u64 time_ns);
+
+    NODISCARD FORCE_INLINE_F bool ShouldPreempt_(Thread *thread) const
+    {
+        return ShouldPreempt_(GetPreemptTime_(thread));
+    }
+
+    NODISCARD FORCE_INLINE_F bool IsFirstHigherPriority_(Thread *first, Thread *second) const
+    {
+        if (first->flags.policy == second->flags.policy) {
+            const auto policy = GetPolicy_(first);
+            return policy.cbs.is_first_higher_priority(policy.self, first, second);
+        }
+
+        return first->flags.policy > second->flags.policy;
+    }
+
+    NODISCARD FAST_CALL bool ShouldPreempt_(const u64 preempt_time_ns)
+    {
+        return preempt_time_ns == 0 || preempt_time_ns < kMinDelta;
+    }
+
     // ------------------------------
     // Class fields
     // ------------------------------
 
+    // Sleeping queue
+    data_structures::IntrusiveRBTree<Thread, u64> sleep_queue_{};
+
+    // Locking
+    hal::Spinlock spinlock_{};
+
     // Policies
     PriorityQueuePolicy policy0_{};  // kUberTask_PQ_P0
     PriorityQueuePolicy policy1_{};  // kDrivers_PQ_P1
diff --git a/kernel/src/scheduling/scheduler_lock.hpp b/kernel/src/scheduling/scheduler_lock.hpp
new file mode 100644
index 00000000..f125b83b
--- /dev/null
+++ b/kernel/src/scheduling/scheduler_lock.hpp
@@ -0,0 +1,18 @@
+#ifndef KERNEL_SRC_SCHEDULING_SCHEDULER_LOCK_HPP_
+#define KERNEL_SRC_SCHEDULING_SCHEDULER_LOCK_HPP_
+
+#include <defines.hpp>
+
+#include "modules/hardware.hpp"
+
+class SchedulerLock
+{
+    public:
+    FORCE_INLINE_F SchedulerLock()
+    {
+        HardwareModule::Get().GetInterrupts().BlockHardwareInterrupts();
+    }
+    ~SchedulerLock() { HardwareModule::Get().GetInterrupts().EnableHardwareInterrupts(); }
+};
+
+#endif  // KERNEL_SRC_SCHEDULING_SCHEDULER_LOCK_HPP_
diff --git a/kernel/src/scheduling/task_mgr.cpp b/kernel/src/scheduling/task_mgr.cpp
index 5aeae00d..92e16819 100644
--- a/kernel/src/scheduling/task_mgr.cpp
+++ b/kernel/src/scheduling/task_mgr.cpp
@@ -26,13 +26,15 @@ namespace Sched
 {
 void TaskMgr::InitializeMultitasking()
 {
+    SchedulingModule::Get().GetScheduler().InstallInterruptHandler();
+
     // Spawn trace dumper
     const auto result =
         SpawnKernelProcess("kworker-trace-dumper", {}, PrepareKThreadTask(TraceDumperMain));
     R_ASSERT_TRUE(static_cast<bool>(result), "Failed to spawn trace dumper process...");
 
     // Spawn 3 Kernel Workers
-    static constexpr size_t kNumKWorkers = 0;
+    static constexpr size_t kNumKWorkers = 3;
     for (size_t i = 0; i < kNumKWorkers; ++i) {
         char name[] = "kworker-0";
 
diff --git a/kernel/src/scheduling/thread.cpp b/kernel/src/scheduling/thread.cpp
new file mode 100644
index 00000000..e150dbea
--- /dev/null
+++ b/kernel/src/scheduling/thread.cpp
@@ -0,0 +1,15 @@
+#include "thread.hpp"
+
+#include "modules/timing.hpp"
+#include "trace_framework.hpp"
+
+namespace Sched
+{
+u64 Thread::CalculateCpuTime()
+{
+    const u64 time = TimingModule::Get().GetSystemTime().ReadLifeTimeNs();
+    kernel_time_ns += (time - timestamp);
+
+    return kernel_time_ns + user_time_ns;
+}
+}  // namespace Sched
diff --git a/kernel/src/scheduling/thread.hpp b/kernel/src/scheduling/thread.hpp
index c4e8c459..c35a6b02 100644
--- a/kernel/src/scheduling/thread.hpp
+++ b/kernel/src/scheduling/thread.hpp
@@ -4,6 +4,7 @@
 #include <types.h>
 #include <array.hpp>
 #include <data_structures/intrusive_linked_list.hpp>
+#include <data_structures/maps/intrusive_rb_tree.hpp>
 #include <defines.hpp>
 
 #include "hal/tasks.hpp"
@@ -44,13 +45,14 @@ static_assert(sizeof(ThreadFlags) == 8);
 enum class ThreadState : u64 {
     kReady = 0,
     kRunning,
-    kBlocked,
+    kSleeping,
     kTerminated,
     kLast,
 };
 static_assert(sizeof(ThreadState) == sizeof(u64));
 
-struct Thread : data_structures::IntrusiveListNode<Thread> {
+struct Thread : data_structures::IntrusiveRbNode<Thread, u64>,
+                data_structures::IntrusiveListNode<Thread> {
     /* Management */
     Tid tid;
     Pid owner;
@@ -74,8 +76,9 @@ struct Thread : data_structures::IntrusiveListNode<Thread> {
 
     /* Arch */
     hal::Thread arch_data;
+
+    NODISCARD u64 CalculateCpuTime();
 };
-static_assert(sizeof(Thread) == (128 + sizeof(hal::Thread)));
 }  // namespace Sched
 
 #endif  // KERNEL_SRC_SCHEDULING_THREAD_HPP_
diff --git a/kernel/src/syscalls/calls/proc.hpp b/kernel/src/syscalls/calls/proc.hpp
index 5b25b265..46086bf8 100644
--- a/kernel/src/syscalls/calls/proc.hpp
+++ b/kernel/src/syscalls/calls/proc.hpp
@@ -7,7 +7,7 @@
 
 namespace Syscall
 {
-FAST_CALL void SysExit(int status) {}
+FAST_CALL void SysExit(int) {}
 FAST_CALL void SysAbort() {}
 
 FORCE_INLINE_F void SysFocusTransfer(Sched::Pid target_child)
diff --git a/kernel/src/syscalls/calls/thread.hpp b/kernel/src/syscalls/calls/thread.hpp
index 2892b73a..fdcd130c 100644
--- a/kernel/src/syscalls/calls/thread.hpp
+++ b/kernel/src/syscalls/calls/thread.hpp
@@ -4,6 +4,9 @@
 #include <alkos/structs.h>
 #include <defines.hpp>
 
+#include "modules/scheduling.hpp"
+#include "modules/timing.hpp"
+
 namespace Syscall
 {
 FAST_CALL int SysThreadCreate(Thread *, thread_func_t, void *) { return 0; }
@@ -13,6 +16,19 @@ FAST_CALL int SysThreadJoin(Thread *) { return 0; }
 FAST_CALL int SysThreadDetach(Thread *) { return 0; }
 
 FAST_CALL void SysThreadExit(void *) {}
+
+FAST_CALL void SysNanoSleepUntil(const u64 systime_ns)
+{
+    SchedulingModule::Get().GetScheduler().NanoSleepUntil(systime_ns);
+}
+
+FAST_CALL void SysNanoSleep(const u64 time_ns)
+{
+    static constexpr u64 kSyscallCorrection = 200;
+    SysNanoSleepUntil(
+        TimingModule::Get().GetSystemTime().ReadLifeTimeNs() + time_ns - kSyscallCorrection
+    );
+}
 }  // namespace Syscall
 
 #endif  // KERNEL_SRC_SYSCALLS_CALLS_THREAD_HPP_
diff --git a/kernel/src/syscalls/syscalls.cpp b/kernel/src/syscalls/syscalls.cpp
index e1046cc5..7b79a7b5 100644
--- a/kernel/src/syscalls/syscalls.cpp
+++ b/kernel/src/syscalls/syscalls.cpp
@@ -41,6 +41,8 @@ constinit auto g_syscall_dispatch_table = SyscallDispatchTable<kSysMax>::Create<
     table.RegisterHandler<kThreadExit, SysThreadExit>();
     table.RegisterHandler<kThreadJoin, SysThreadJoin>();
     table.RegisterHandler<kThreadDetach, SysThreadDetach>();
+    table.RegisterHandler<kNanoSleep, SysNanoSleep>();
+    table.RegisterHandler<kNanoSleepUntil, SysNanoSleepUntil>();
 
     // Video
     table.RegisterHandler<kSysCreateGraphicSession, SysCreateGraphicSession>();
diff --git a/kernel/src/time/event_framework.cpp b/kernel/src/time/event_framework.cpp
deleted file mode 100644
index d651a5ac..00000000
--- a/kernel/src/time/event_framework.cpp
+++ /dev/null
@@ -1,43 +0,0 @@
-#include "event_framework.hpp"
-#include "modules/hardware.hpp"
-#include "modules/scheduling.hpp"
-
-// ------------------------------
-// statics
-// ------------------------------
-
-static Sched::Thread *TimerHandler(intr::LitHwEntry &)
-{
-    if (hardware::GetCoreLocalTcb() == nullptr) {
-        // Not yet converted to scheduling
-        return nullptr;
-    }
-
-    return SchedulingModule::Get().GetScheduler().ScheduleAndUpdateThreads();
-}
-
-// ------------------------------
-// Implementations
-// ------------------------------
-
-namespace timing
-{
-void EventFramework::InstallInterruptHandler()
-{
-    HardwareModule::Get()
-        .GetInterrupts()
-        .GetLit()
-        .InstallInterruptHandler<intr::InterruptType::kHardwareInterrupt>(
-            hal::kTimerHwLirq, intr::HwHandler{.handler = TimerHandler}
-        );
-}
-
-void EventFramework::SetupPeriodic(const u64 time_ns)
-{
-    ASSERT_TRUE(HardwareModule::Get().GetEventClockRegistry().IsSelectedPicked());
-
-    auto event_clock = HardwareModule::Get().GetEventClockRegistry().GetSelected();
-    event_clock.cbs.set_periodic(&event_clock);
-    event_clock.cbs.next_event(&event_clock, time_ns);
-}
-}  // namespace timing
diff --git a/kernel/src/time/event_framework.hpp b/kernel/src/time/event_framework.hpp
deleted file mode 100644
index 3aeceab0..00000000
--- a/kernel/src/time/event_framework.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-#ifndef KERNEL_SRC_TIME_EVENT_FRAMEWORK_HPP_
-#define KERNEL_SRC_TIME_EVENT_FRAMEWORK_HPP_
-
-#include <types.h>
-#include <defines.hpp>
-
-namespace timing
-{
-
-class EventFramework
-{
-    public:
-    // ------------------------------
-    // Class creation
-    // ------------------------------
-
-    EventFramework()  = default;
-    ~EventFramework() = default;
-
-    // ------------------------------
-    // Class interaction
-    // ------------------------------
-
-    void InstallInterruptHandler();
-
-    void SetupPeriodic(u64 time_ns);
-
-    // ------------------------------
-    // Private methods
-    // ------------------------------
-
-    protected:
-    // ------------------------------
-    // Class fields
-    // ------------------------------
-};
-
-}  // namespace timing
-
-#endif  // KERNEL_SRC_TIME_EVENT_FRAMEWORK_HPP_
diff --git a/kernel/src/timing.cpp b/kernel/src/timing.cpp
index 789dfc2c..e16aaa64 100644
--- a/kernel/src/timing.cpp
+++ b/kernel/src/timing.cpp
@@ -25,9 +25,6 @@ internal::TimingModule::TimingModule() noexcept
     // 2. Prepare system event clock source
     hal::PickSystemEventClockSource();
 
-    // 3. Register Timer Handler
-    GetEventFramework().InstallInterruptHandler();
-
     ::HardwareModule::Get().GetInterrupts().EnableHardwareInterrupts();
 
     DEBUG_INFO_TIME("TimingModule::TimingModule()");
diff --git a/kernel/test/rb_test.cpp b/kernel/test/rb_test.cpp
new file mode 100644
index 00000000..8219c599
--- /dev/null
+++ b/kernel/test/rb_test.cpp
@@ -0,0 +1,286 @@
+#include <data_structures/linked_list.hpp>
+#include <data_structures/maps/intrusive_rb_tree.hpp>
+#include <mem/heap.hpp>
+#include <random.hpp>
+#include <test_module/test.hpp>
+#include <trace_framework.hpp>
+
+namespace data_structures::test
+{
+
+struct TestNode : IntrusiveRbNode<TestNode, int>, IntrusiveListNode<TestNode> {
+    TestNode *tracking_next = nullptr;
+    TestNode *tracking_prev = nullptr;
+
+    int payload = 0;
+
+    TestNode(int k, int v) : payload(v)
+    {
+        this->key    = k;
+        this->color  = Color::kBlack;
+        this->left   = nullptr;
+        this->right  = nullptr;
+        this->parent = nullptr;
+        this->next   = nullptr;
+    }
+};
+
+// ------------------------------
+// Test Fixture with Manual Memory Management
+// ------------------------------
+
+class IntrusiveRBTreeTest : public TestGroupBase
+{
+    public:
+    using TreeType = IntrusiveRBTree<TestNode, int>;
+
+    TreeType tree{};
+    TestNode *tracking_head = nullptr;
+    size_t allocated_count  = 0;
+
+    void Setup_() override
+    {
+        tracking_head   = nullptr;
+        allocated_count = 0;
+    }
+
+    void TearDown_() override
+    {
+        TestNode *current = tracking_head;
+        while (current) {
+            TestNode *next = current->tracking_next;
+            delete current;
+            current = next;
+        }
+        tracking_head = nullptr;
+    }
+
+    TestNode *NewNode(int key, int val = 0)
+    {
+        auto mem   = Mem::KMalloc(sizeof(TestNode)).value();
+        auto *node = new (mem) TestNode(key, val);
+
+        node->tracking_next = tracking_head;
+        if (tracking_head) {
+            tracking_head->tracking_prev = node;
+        }
+        tracking_head = node;
+        allocated_count++;
+
+        return node;
+    }
+
+    int ValidateRBProperties(TestNode *node)
+    {
+        if (!node)
+            return 1;
+
+        if (node->color == TestNode::Color::kRed) {
+            if (node->left && node->left->color == TestNode::Color::kRed) {
+                R_ASSERT(false && "Red violation: Left child is Red");
+                return -1;
+            }
+            if (node->right && node->right->color == TestNode::Color::kRed) {
+                R_ASSERT(false && "Red violation: Right child is Red");
+                return -1;
+            }
+        }
+
+        if (node->left && node->left->key > node->key)
+            return -1;
+        if (node->right && node->right->key < node->key)
+            return -1;
+
+        int lh = ValidateRBProperties(node->left);
+        int rh = ValidateRBProperties(node->right);
+
+        if (lh == -1 || rh == -1 || lh != rh) {
+            R_ASSERT(false && "Black height violation");
+            return -1;
+        }
+
+        return lh + (node->color == TestNode::Color::kBlack ? 1 : 0);
+    }
+};
+
+TEST_F(IntrusiveRBTreeTest, LargeSequentialInsert)
+{
+    constexpr int kCount = 5000;
+
+    for (int i = 0; i < kCount; ++i) {
+        tree.Insert(NewNode(i, i));
+    }
+
+    EXPECT_EQ(0, tree.Min()->key);
+    EXPECT_EQ(kCount - 1, tree.Max()->key);
+
+    EXPECT_EQ(2500, tree.Find(2500)->payload);
+    EXPECT_EQ(4999, tree.Find(4999)->payload);
+    ValidateRBProperties(tree.Root());
+}
+
+TEST_F(IntrusiveRBTreeTest, LargeReverseInsert)
+{
+    constexpr int kCount = 5000;
+    for (int i = kCount - 1; i >= 0; --i) {
+        tree.Insert(NewNode(i, i));
+    }
+
+    EXPECT_EQ(0, tree.Min()->key);
+    EXPECT_EQ(kCount - 1, tree.Max()->key);
+    ValidateRBProperties(tree.Root());
+}
+
+TEST_F(IntrusiveRBTreeTest, RandomizedTorture)
+{
+    SimpleRandom rng(12345);
+    constexpr int kOperations = 10000;
+    constexpr int kKeySpace   = 2000;
+
+    bool exists[kKeySpace]     = {false};
+    TestNode *nodes[kKeySpace] = {nullptr};
+
+    for (int i = 0; i < kOperations; ++i) {
+        int key = rng.next() % kKeySpace;
+        int op  = rng.next() % 100;
+
+        if (op < 60) {
+            if (!exists[key]) {
+                TestNode *n = NewNode(key, i);
+                tree.Insert(n);
+                nodes[key]  = n;
+                exists[key] = true;
+            }
+        } else if (op < 90) {
+            if (exists[key]) {
+                tree.Delete(nodes[key]);
+                nodes[key]  = nullptr;
+                exists[key] = false;
+            }
+        } else {
+            TestNode *found = tree.Find(key);
+            if (exists[key]) {
+                EXPECT_NEQ(nullptr, found);
+                if (found) {
+                    EXPECT_EQ(key, found->key);
+                }
+            } else {
+                EXPECT_EQ(nullptr, found);
+            }
+        }
+
+        ValidateRBProperties(tree.Root());
+    }
+
+    for (int i = 0; i < kKeySpace; ++i) {
+        TestNode *found = tree.Find(i);
+        if (exists[i]) {
+            EXPECT_NEQ(nullptr, found);
+        } else {
+            EXPECT_EQ(nullptr, found);
+        }
+    }
+
+    ValidateRBProperties(tree.Root());
+}
+
+TEST_F(IntrusiveRBTreeTest, HeavyBucketUsage)
+{
+    constexpr int kKeys        = 10;
+    constexpr int kItemsPerKey = 100;
+
+    for (int k = 0; k < kKeys; ++k) {
+        TestNode *head = NewNode(k, 0);
+        tree.Insert(head);
+
+        TestNode *current_tail = head;
+        for (int i = 1; i < kItemsPerKey; ++i) {
+            TestNode *item = NewNode(k, i);
+
+            current_tail->next = item;
+            item->next         = nullptr;
+
+            current_tail = item;
+        }
+    }
+
+    for (int k = 0; k < kKeys; ++k) {
+        TestNode *head = tree.Find(k);
+        ASSERT(head != nullptr);
+        EXPECT_EQ(k, head->key);
+        EXPECT_EQ(0, head->payload);
+
+        int count      = 1;
+        TestNode *curr = head->next;
+        while (curr) {
+            EXPECT_EQ(k, curr->key);
+            EXPECT_EQ(count, curr->payload);
+            count++;
+            curr = curr->next;
+        }
+        EXPECT_EQ(kItemsPerKey, count);
+    }
+
+    TestNode *head5 = tree.Find(5);
+    tree.Delete(5);
+    EXPECT_EQ(nullptr, tree.Find(5));
+
+    int count5 = 0;
+    while (head5) {
+        count5++;
+        head5 = head5->next;
+    }
+    EXPECT_EQ(kItemsPerKey, count5);
+
+    ValidateRBProperties(tree.Root());
+}
+
+TEST_F(IntrusiveRBTreeTest, DeleteMinMaxRepeatedly)
+{
+    constexpr int kCount = 1000;
+    for (int i = 0; i < kCount; ++i) tree.Insert(NewNode(i));
+    ValidateRBProperties(tree.Root());
+
+    int deleted_count = 0;
+    while (tree.Min()) {
+        TestNode *min = tree.Min();
+        EXPECT_EQ(deleted_count, min->key);
+        tree.Delete(min);
+        deleted_count++;
+    }
+    EXPECT_EQ(kCount, deleted_count);
+    EXPECT_TRUE(tree.Min() == nullptr);
+
+    for (int i = 0; i < kCount; ++i) tree.Insert(NewNode(i));
+    ValidateRBProperties(tree.Root());
+
+    deleted_count = 0;
+    while (tree.Max()) {
+        TestNode *max = tree.Max();
+        EXPECT_EQ(kCount - 1 - deleted_count, max->key);
+        tree.Delete(max);
+        deleted_count++;
+    }
+    EXPECT_EQ(kCount, deleted_count);
+}
+
+TEST_F(IntrusiveRBTreeTest, NodeMoveScenario)
+{
+    TestNode *n = NewNode(10, 123);
+    tree.Insert(n);
+    EXPECT_NEQ(nullptr, tree.Find(10));
+
+    tree.Delete(n);
+    EXPECT_EQ(nullptr, tree.Find(10));
+
+    n->key = 20;
+
+    tree.Insert(n);
+    EXPECT_EQ(nullptr, tree.Find(10));
+    EXPECT_NEQ(nullptr, tree.Find(20));
+    EXPECT_EQ(123, tree.Find(20)->payload);
+
+    ValidateRBProperties(tree.Root());
+}
+
+}  // namespace data_structures::test
diff --git a/kernel/test/tests.cpp b/kernel/test/tests.cpp
index a440da7a..d2118c4d 100644
--- a/kernel/test/tests.cpp
+++ b/kernel/test/tests.cpp
@@ -2,6 +2,9 @@
 #include <test_module/test.hpp>
 #include <trace_framework.hpp>
 
+#include <array.hpp>
+#include <random.hpp>
+
 // ------------------------------
 // Test Framework Test
 // ------------------------------
@@ -90,3 +93,28 @@ extern void FloatExtensionTest();
  * @note This test is architecture dependent, simply invokes floating point instructions
  */
 TEST(FloatOperationsTest) { FloatExtensionTest(); }
+
+// ------------------------------
+// Test random gen
+// ------------------------------
+
+std::array<u32, 32768> gRandomStats{};
+TEST(SimpleRandomGen)
+{
+    static constexpr size_t kNumRetriesPerValue = 100;
+    static constexpr size_t kMaxDeriv           = 50;
+    static constexpr size_t kNumSamples         = 32768 * kNumRetriesPerValue;
+
+    gRandomStats.fill(0);
+    SimpleRandom random(32);
+
+    for (size_t i = 0; i < kNumSamples; i++) {
+        u32 sample = random.next();
+        gRandomStats[sample]++;
+    }
+
+    for (size_t i = 0; i < 32768; ++i) {
+        EXPECT_LT(gRandomStats[i], kNumRetriesPerValue + kMaxDeriv);
+        EXPECT_GT(gRandomStats[i], kNumRetriesPerValue - kMaxDeriv);
+    }
+}
diff --git a/libs/libc/src/abi/platform.h b/libs/libc/src/abi/platform.h
index 819559da..ac45b899 100644
--- a/libs/libc/src/abi/platform.h
+++ b/libs/libc/src/abi/platform.h
@@ -41,6 +41,8 @@ SYSCALL_NAME(thread_join, kThreadJoin, int, Thread *, thread);
 SYSCALL_NAME(thread_detach, kThreadDetach, int, Thread *, thread);
 SYSCALL_VOID_NAME(proc_exit, kProcExit, int, status);
 SYSCALL_VOID_NAME(proc_abort, kProcAbort);
+SYSCALL_VOID_NAME(nanosleep, kNanoSleep, u64, time_ns);
+SYSCALL_VOID_NAME(nanosleep_until, kNanoSleepUntil, u64, systime_ns);
 
 // Video
 SYSCALL_VOID_NAME(create_graphic_session, kSysCreateGraphicSession, GuiBufferInfo *, info);
diff --git a/libs/libc/src/include/alkos/sys/thread.h b/libs/libc/src/include/alkos/sys/thread.h
index 10eb045b..3a944fe7 100644
--- a/libs/libc/src/include/alkos/sys/thread.h
+++ b/libs/libc/src/include/alkos/sys/thread.h
@@ -23,6 +23,10 @@ FAST_CALL int ThreadDetach(Thread *thread) { return __platform_thread_detach(thr
 
 FAST_CALL void ThreadExit(void *retval) { __platform_thread_exit(retval); }
 
+FAST_CALL void NanoSleepUntil(u64 systime_ns) { __platform_nanosleep_until(systime_ns); }
+
+FAST_CALL void NanoSleep(u64 time_ns) { __platform_nanosleep(time_ns); }
+
 END_DECL_C
 
 #endif  // LIBS_LIBC_SRC_INCLUDE_ALKOS_SYS_THREAD_H_
diff --git a/libs/libc/src/include/alkos/syscall.h b/libs/libc/src/include/alkos/syscall.h
index f362e716..e4135967 100644
--- a/libs/libc/src/include/alkos/syscall.h
+++ b/libs/libc/src/include/alkos/syscall.h
@@ -40,6 +40,8 @@ enum SyscallNumber {
     kThreadDetach,
     kProcExit,
     kProcAbort,
+    kNanoSleep,
+    kNanoSleepUntil,
 
     /* Video Syscalls */
     kSysCreateGraphicSession,
diff --git a/libs/libc/src/internal/libc_backend.cpp b/libs/libc/src/internal/libc_backend.cpp
index 2459a90a..01f24578 100644
--- a/libs/libc/src/internal/libc_backend.cpp
+++ b/libs/libc/src/internal/libc_backend.cpp
@@ -35,6 +35,8 @@ DEFINE_SYSCALL(thread_join, kThreadJoin, int, Thread *, thread)
 DEFINE_SYSCALL(thread_detach, kThreadDetach, int, Thread *, thread)
 DEFINE_SYSCALL_VOID(proc_exit, kProcExit, int, status)
 DEFINE_SYSCALL_VOID(proc_abort, kProcAbort)
+DEFINE_SYSCALL_VOID(nanosleep, kNanoSleep, u64, time_ns);
+DEFINE_SYSCALL_VOID(nanosleep_until, kNanoSleepUntil, u64, systime_ns);
 
 DEFINE_SYSCALL_VOID(create_graphic_session, kSysCreateGraphicSession, GuiBufferInfo *, info)
 DEFINE_SYSCALL_VOID(blit, kSysBlit)
diff --git a/libs/libcontainers/include/data_structures/intrusive_linked_list.hpp b/libs/libcontainers/include/data_structures/intrusive_linked_list.hpp
index cb4884e7..bdecbd13 100644
--- a/libs/libcontainers/include/data_structures/intrusive_linked_list.hpp
+++ b/libs/libcontainers/include/data_structures/intrusive_linked_list.hpp
@@ -18,6 +18,62 @@ struct IntrusiveDoubleListNode {
     T *prev;
 };
 
+template <class T>
+    requires std::derived_from<T, IntrusiveListNode<T>>
+class FrontIntrusiveList : template_lib::NoCopy
+{
+    public:
+    // ------------------------------
+    // Class creation
+    // ------------------------------
+
+    FrontIntrusiveList() = default;
+    explicit FrontIntrusiveList(T *item) : head_(item) {}
+    ~FrontIntrusiveList() = default;
+
+    // ------------------------------
+    // Class interaction
+    // ------------------------------
+
+    NODISCARD FORCE_INLINE_F bool IsEmpty() const { return head_ == nullptr; }
+
+    FORCE_INLINE_F void PushFront(T *item)
+    {
+        ASSERT_NOT_NULL(item);
+
+        if (IsEmpty()) {
+            head_      = item;
+            item->next = nullptr;
+            return;
+        }
+
+        item->next = head_;
+        head_      = item;
+    }
+
+    NODISCARD FORCE_INLINE_F T *PopFront()
+    {
+        if (IsEmpty()) {
+            return nullptr;
+        }
+
+        T *item    = head_;
+        head_      = item->next;
+        item->next = nullptr;
+
+        return item;
+    }
+
+    NODISCARD FORCE_INLINE_F T *Front() { return head_; }
+
+    // ------------------------------
+    // Class fields
+    // ------------------------------
+
+    private:
+    T *head_{};
+};
+
 template <class T>
     requires std::derived_from<T, IntrusiveListNode<T>>
 class IntrusiveList : template_lib::NoCopy
diff --git a/libs/libcontainers/include/data_structures/maps/intrusive_rb_tree.hpp b/libs/libcontainers/include/data_structures/maps/intrusive_rb_tree.hpp
new file mode 100644
index 00000000..ee2e21eb
--- /dev/null
+++ b/libs/libcontainers/include/data_structures/maps/intrusive_rb_tree.hpp
@@ -0,0 +1,503 @@
+#ifndef LIBS_LIBCONTAINERS_INCLUDE_DATA_STRUCTURES_MAPS_INTRUSIVE_RB_TREE_HPP_
+#define LIBS_LIBCONTAINERS_INCLUDE_DATA_STRUCTURES_MAPS_INTRUSIVE_RB_TREE_HPP_
+
+#include <assert.h>
+#include <types.h>
+#include <concepts.hpp>
+#include <data_structures/intrusive_linked_list.hpp>
+#include <defines.hpp>
+#include <template/special_members.hpp>
+
+namespace data_structures
+{
+template <class T, class KeyT>
+struct IntrusiveRbNode {
+    enum class Color : u8 {
+        kBlack = 0,
+        kRed   = 1,
+    };
+
+    T *parent;
+    union {
+        struct {
+            T *left;
+            T *right;
+        };
+        T *child[2];
+    };
+
+    Color color;
+    KeyT key;
+};
+static_assert(sizeof(IntrusiveRbNode<u64, u64>) == 5 * 8);
+
+template <class T, class KeyT>
+    requires(
+        std::derived_from<T, IntrusiveRbNode<T, KeyT>> and
+        std::derived_from<T, IntrusiveListNode<T>>
+    )
+class IntrusiveRBTree : template_lib::NoCopy
+{
+    using Color = typename IntrusiveRbNode<T, KeyT>::Color;
+
+    public:
+    // ------------------------------
+    // Class creation
+    // ------------------------------
+
+    IntrusiveRBTree()  = default;
+    ~IntrusiveRBTree() = default;
+
+    // ------------------------------
+    // Class interaction
+    // ------------------------------
+
+    NODISCARD FORCE_INLINE_F T *Root() { return root_; }
+
+    NODISCARD FORCE_INLINE_F bool IsEmpty() { return root_ == nullptr; }
+
+    void Insert(T *item)
+    {
+        ASSERT_NOT_NULL(item);
+
+        item->left   = nullptr;
+        item->right  = nullptr;
+        item->parent = nullptr;
+        item->color  = Color::kRed;
+        item->next   = nullptr;
+
+        // 1. Check if key already exists
+        T *existing = Find(item->key);
+        if (existing != nullptr) {
+            item->next     = existing->next;
+            existing->next = item;
+            return;
+        }
+
+        // 2. Standard BST Insert
+        T *y = nullptr;
+        T *x = root_;
+
+        while (x != nullptr) {
+            y = x;
+            if (item->key < x->key) {
+                x = x->left;
+            } else {
+                x = x->right;
+            }
+        }
+
+        item->parent = y;
+
+        if (y == nullptr) {
+            root_ = item;
+        } else if (item->key < y->key) {
+            y->left = item;
+        } else {
+            y->right = item;
+        }
+
+        if (min_ == nullptr || item->key < min_->key) {
+            min_ = item;
+        }
+        if (max_ == nullptr || item->key > max_->key) {
+            max_ = item;
+        }
+
+        InsertFixup_(item);
+    }
+
+    void Delete(T *item)
+    {
+        ASSERT_NOT_NULL(item);
+
+        // Case A: The item is NOT part of the RB tree structure,
+
+        T *node_in_tree = Find(item->key);
+        if (node_in_tree == nullptr) {
+            return;
+        }
+
+        if (node_in_tree != item) {
+            T *prev = node_in_tree;
+            while (prev->next != nullptr && prev->next != item) {
+                prev = prev->next;
+            }
+
+            if (prev->next == item) {
+                prev->next = item->next;
+                item->next = nullptr;
+            }
+            return;
+        }
+
+        // Case B: item IS the node in the RB Tree.
+        if (item->next != nullptr) {
+            ReplaceWithNext_(item);
+            return;
+        }
+
+        RBDelete_(item);
+    }
+
+    FORCE_INLINE_F void Delete(KeyT key)
+    {
+        T *node = Find(key);
+        if (node == nullptr) {
+            return;
+        }
+
+        RBDelete_(node);
+    }
+
+    NODISCARD bool Contains(T *item)
+    {
+        ASSERT_NOT_NULL(item);
+
+        T *found = Find(item->key);
+        if (!found) {
+            return false;
+        }
+
+        T *curr = found;
+        while (curr) {
+            if (curr == item) {
+                return true;
+            }
+            curr = curr->next;
+        }
+        return false;
+    }
+
+    NODISCARD FORCE_INLINE_F bool Contains(KeyT key) { return Find(key) != nullptr; }
+
+    NODISCARD FORCE_INLINE_F T *Min() { return min_; }
+
+    NODISCARD FORCE_INLINE_F T *Max() { return max_; }
+
+    NODISCARD FORCE_INLINE_F T *Find(KeyT key)
+    {
+        T *current = root_;
+        while (current != nullptr) {
+            if (key == current->key) {
+                return current;
+            } else if (key < current->key) {
+                current = current->left;
+            } else {
+                current = current->right;
+            }
+        }
+        return nullptr;
+    }
+
+    // ------------------------------
+    // Private methods
+    // ------------------------------
+
+    private:
+    void RecalculateMinMax_()
+    {
+        if (!root_) {
+            min_ = nullptr;
+            max_ = nullptr;
+            return;
+        }
+
+        T *curr = root_;
+        while (curr->left) curr = curr->left;
+        min_ = curr;
+
+        curr = root_;
+        while (curr->right) curr = curr->right;
+        max_ = curr;
+    }
+
+    void ReplaceWithNext_(T *item)
+    {
+        T *replacement = item->next;
+        ASSERT_NOT_NULL(replacement);
+
+        // Copy RB properties
+        replacement->parent = item->parent;
+        replacement->left   = item->left;
+        replacement->right  = item->right;
+        replacement->color  = item->color;
+
+        // Update parent's child pointer
+        if (item->parent == nullptr) {
+            root_ = replacement;
+        } else if (item == item->parent->left) {
+            item->parent->left = replacement;
+        } else {
+            item->parent->right = replacement;
+        }
+
+        // Update children's parent pointer
+        if (item->left) {
+            item->left->parent = replacement;
+        }
+        if (item->right) {
+            item->right->parent = replacement;
+        }
+
+        // Update Cached Min/Max if necessary
+        if (min_ == item) {
+            min_ = replacement;
+        }
+        if (max_ == item) {
+            max_ = replacement;
+        }
+
+        // Clear item's pointers
+        item->parent = nullptr;
+        item->left   = nullptr;
+        item->right  = nullptr;
+        item->next   = nullptr;
+    }
+
+    void RotateLeft_(T *x)
+    {
+        T *y     = x->right;
+        x->right = y->left;
+
+        if (y->left != nullptr) {
+            y->left->parent = x;
+        }
+
+        y->parent = x->parent;
+
+        if (x->parent == nullptr) {
+            root_ = y;
+        } else if (x == x->parent->left) {
+            x->parent->left = y;
+        } else {
+            x->parent->right = y;
+        }
+
+        y->left   = x;
+        x->parent = y;
+    }
+
+    void RotateRight_(T *x)
+    {
+        T *y    = x->left;
+        x->left = y->right;
+
+        if (y->right != nullptr) {
+            y->right->parent = x;
+        }
+
+        y->parent = x->parent;
+
+        if (x->parent == nullptr) {
+            root_ = y;
+        } else if (x == x->parent->right) {
+            x->parent->right = y;
+        } else {
+            x->parent->left = y;
+        }
+
+        y->right  = x;
+        x->parent = y;
+    }
+
+    void InsertFixup_(T *z)
+    {
+        while (z->parent != nullptr && z->parent->color == Color::kRed) {
+            if (z->parent == z->parent->parent->left) {
+                T *y = z->parent->parent->right;  // Uncle
+
+                if (y != nullptr && y->color == Color::kRed) {
+                    // Case 1: Uncle is Red
+                    z->parent->color         = Color::kBlack;
+                    y->color                 = Color::kBlack;
+                    z->parent->parent->color = Color::kRed;
+                    z                        = z->parent->parent;
+                } else {
+                    // Case 2: Uncle is Black (Triangle)
+                    if (z == z->parent->right) {
+                        z = z->parent;
+                        RotateLeft_(z);
+                    }
+                    // Case 3: Uncle is Black (Line)
+                    z->parent->color         = Color::kBlack;
+                    z->parent->parent->color = Color::kRed;
+                    RotateRight_(z->parent->parent);
+                }
+            } else {
+                // Symmetric to above
+                T *y = z->parent->parent->left;
+
+                if (y != nullptr && y->color == Color::kRed) {
+                    z->parent->color         = Color::kBlack;
+                    y->color                 = Color::kBlack;
+                    z->parent->parent->color = Color::kRed;
+                    z                        = z->parent->parent;
+                } else {
+                    if (z == z->parent->left) {
+                        z = z->parent;
+                        RotateRight_(z);
+                    }
+                    z->parent->color         = Color::kBlack;
+                    z->parent->parent->color = Color::kRed;
+                    RotateLeft_(z->parent->parent);
+                }
+            }
+        }
+        root_->color = Color::kBlack;
+    }
+
+    void RBTransplant_(T *u, T *v)
+    {
+        if (u->parent == nullptr) {
+            root_ = v;
+        } else if (u == u->parent->left) {
+            u->parent->left = v;
+        } else {
+            u->parent->right = v;
+        }
+        if (v != nullptr) {
+            v->parent = u->parent;
+        }
+    }
+
+    T *TreeMinimum_(T *node)
+    {
+        while (node->left != nullptr) {
+            node = node->left;
+        }
+        return node;
+    }
+
+    void RBDelete_(T *z)
+    {
+        T *y                   = z;
+        T *x                   = nullptr;
+        Color y_original_color = y->color;
+
+        T *x_parent = nullptr;
+
+        if (z->left == nullptr) {
+            x        = z->right;
+            x_parent = z->parent;
+            RBTransplant_(z, z->right);
+        } else if (z->right == nullptr) {
+            x        = z->left;
+            x_parent = z->parent;
+            RBTransplant_(z, z->left);
+        } else {
+            y                = TreeMinimum_(z->right);
+            y_original_color = y->color;
+            x                = y->right;
+
+            if (y->parent == z) {
+                x_parent = y;
+            } else {
+                x_parent = y->parent;
+                RBTransplant_(y, y->right);
+                y->right         = z->right;
+                y->right->parent = y;
+            }
+
+            RBTransplant_(z, y);
+            y->left         = z->left;
+            y->left->parent = y;
+            y->color        = z->color;
+        }
+
+        if (y_original_color == Color::kBlack) {
+            DeleteFixup_(x, x_parent);
+        }
+
+        z->parent = nullptr;
+        z->left   = nullptr;
+        z->right  = nullptr;
+
+        if (z == min_ || z == max_) {
+            RecalculateMinMax_();
+        }
+    }
+
+    void DeleteFixup_(T *x, T *x_parent)
+    {
+        while (x != root_ && (x == nullptr || x->color == Color::kBlack)) {
+            if (x == (x_parent ? x_parent->left : nullptr)) {  // x is left child
+                T *w = x_parent->right;                        // Sibling
+
+                if (w->color == Color::kRed) {
+                    w->color        = Color::kBlack;
+                    x_parent->color = Color::kRed;
+                    RotateLeft_(x_parent);
+                    w = x_parent->right;
+                }
+
+                if ((w->left == nullptr || w->left->color == Color::kBlack) &&
+                    (w->right == nullptr || w->right->color == Color::kBlack)) {
+                    w->color = Color::kRed;
+                    x        = x_parent;
+                    x_parent = x ? x->parent : nullptr;
+                } else {
+                    if (w->right == nullptr || w->right->color == Color::kBlack) {
+                        if (w->left)
+                            w->left->color = Color::kBlack;
+                        w->color = Color::kRed;
+                        RotateRight_(w);
+                        w = x_parent->right;
+                    }
+                    w->color        = x_parent->color;
+                    x_parent->color = Color::kBlack;
+                    if (w->right)
+                        w->right->color = Color::kBlack;
+                    RotateLeft_(x_parent);
+                    x        = root_;
+                    x_parent = nullptr;
+                }
+            } else {  // x is right child (symmetric)
+                T *w = x_parent->left;
+
+                if (w->color == Color::kRed) {
+                    w->color        = Color::kBlack;
+                    x_parent->color = Color::kRed;
+                    RotateRight_(x_parent);
+                    w = x_parent->left;
+                }
+
+                if ((w->right == nullptr || w->right->color == Color::kBlack) &&
+                    (w->left == nullptr || w->left->color == Color::kBlack)) {
+                    w->color = Color::kRed;
+                    x        = x_parent;
+                    x_parent = x ? x->parent : nullptr;
+                } else {
+                    if (w->left == nullptr || w->left->color == Color::kBlack) {
+                        if (w->right)
+                            w->right->color = Color::kBlack;
+                        w->color = Color::kRed;
+                        RotateLeft_(w);
+                        w = x_parent->left;
+                    }
+                    w->color        = x_parent->color;
+                    x_parent->color = Color::kBlack;
+                    if (w->left)
+                        w->left->color = Color::kBlack;
+                    RotateRight_(x_parent);
+                    x        = root_;
+                    x_parent = nullptr;
+                }
+            }
+        }
+        if (x != nullptr) {
+            x->color = Color::kBlack;
+        }
+    }
+
+    // ------------------------------
+    // Class fields
+    // ------------------------------
+
+    T *root_{};
+    T *min_{};
+    T *max_{};
+};
+}  // namespace data_structures
+
+#endif  // LIBS_LIBCONTAINERS_INCLUDE_DATA_STRUCTURES_MAPS_INTRUSIVE_RB_TREE_HPP_
diff --git a/libs/libcpp/include/random.hpp b/libs/libcpp/include/random.hpp
new file mode 100644
index 00000000..21a239cc
--- /dev/null
+++ b/libs/libcpp/include/random.hpp
@@ -0,0 +1,22 @@
+#ifndef LIBS_LIBCPP_INCLUDE_RANDOM_HPP_
+#define LIBS_LIBCPP_INCLUDE_RANDOM_HPP_
+
+#include <types.h>
+#include <defines.hpp>
+
+class SimpleRandom
+{
+    public:
+    explicit SimpleRandom(const u32 seed = 12345) : state(seed == 0 ? 12345 : seed) {}
+
+    NODISCARD FORCE_INLINE_F u32 next()
+    {
+        state = state * 1664525 + 1013904223;
+        return (state >> 16) % 32768;
+    }
+
+    private:
+    u32 state;
+};
+
+#endif  // LIBS_LIBCPP_INCLUDE_RANDOM_HPP_

From 268a2af124ebdb3d9e5720efba6b8070195ffaad Mon Sep 17 00:00:00 2001
From: Jakub Lisowski <115403674+Jlisowskyy@users.noreply.github.com>
Date: Sun, 4 Jan 2026 16:05:07 +0100
Subject: [PATCH 49/56] jlisowskyy/scheduler-imprv-4 (#271)

---
 .../arch/x86_64/src/hal/impl/scheduling.hpp   |   2 +-
 kernel/arch/x86_64/src/include/thread.nasm    |   2 +
 kernel/arch/x86_64/src/interrupts/idt.cpp     |   2 +-
 .../arch/x86_64/src/scheduling/scheduling.cpp |   4 +-
 .../x86_64/src/scheduling/scheduling.nasm     |   8 +-
 kernel/src/hal/scheduling.hpp                 |   2 +-
 kernel/src/mem/virt/page_fault.cpp            |   2 +-
 kernel/src/scheduling/error.hpp               |   9 ++
 .../{scheduler_lock.hpp => local_lock.hpp}    |   6 +-
 .../policies/priority_queue_policy.hpp        |   5 +
 .../policies/round_robin_policy.hpp           |   2 +
 kernel/src/scheduling/policy.hpp              |  12 ++
 kernel/src/scheduling/scheduler.cpp           |  32 ++++-
 kernel/src/scheduling/scheduler.hpp           |  33 ++++--
 kernel/src/scheduling/task_mgr.cpp            | 110 ++++++++++++++++--
 kernel/src/scheduling/task_mgr.hpp            |  32 ++++-
 kernel/src/scheduling/thread.hpp              |   9 +-
 kernel/src/scheduling/threads.cpp             |  11 +-
 kernel/src/scheduling/threads.hpp             |  11 ++
 kernel/src/syscalls/calls/panic.hpp           |   2 +-
 kernel/src/syscalls/calls/thread.hpp          |  65 ++++++++++-
 libs/libc/src/abi/platform.h                  |   2 +-
 libs/libc/src/include/alkos/sys/thread.h      |   7 +-
 libs/libc/src/include/alkos/thread.h          |  16 ++-
 libs/libc/src/internal/libc_backend.cpp       |   2 +-
 25 files changed, 336 insertions(+), 52 deletions(-)
 rename kernel/src/scheduling/{scheduler_lock.hpp => local_lock.hpp} (74%)

diff --git a/kernel/arch/x86_64/src/hal/impl/scheduling.hpp b/kernel/arch/x86_64/src/hal/impl/scheduling.hpp
index c7c73790..bc5594b5 100644
--- a/kernel/arch/x86_64/src/hal/impl/scheduling.hpp
+++ b/kernel/arch/x86_64/src/hal/impl/scheduling.hpp
@@ -7,7 +7,7 @@
 
 extern "C" void ConvertContext(Sched::Thread *thread);
 extern "C" void ContextSwitch(Sched::Thread *thread);
-extern "C" void JumpToUserSpace(void (*f)());
+extern "C" void JumpToUserSpace(void *, void *arg);
 
 namespace arch
 {
diff --git a/kernel/arch/x86_64/src/include/thread.nasm b/kernel/arch/x86_64/src/include/thread.nasm
index e6273816..5b90f28c 100644
--- a/kernel/arch/x86_64/src/include/thread.nasm
+++ b/kernel/arch/x86_64/src/include/thread.nasm
@@ -9,6 +9,8 @@ struc Thread
     .owner:                 resq 1
     .flags                  resq 1
     .state                  resq 1
+    .retval                 resq 1
+
     .kernel_stack:          resq 1
     .kernel_stack_bottom:   resq 1
     .user_stack:            resq 1
diff --git a/kernel/arch/x86_64/src/interrupts/idt.cpp b/kernel/arch/x86_64/src/interrupts/idt.cpp
index 87fb5c10..f9f3ff1c 100644
--- a/kernel/arch/x86_64/src/interrupts/idt.cpp
+++ b/kernel/arch/x86_64/src/interrupts/idt.cpp
@@ -128,7 +128,7 @@ Sched::Thread *DefaultExceptionHandler(intr::LitExcEntry &entry, hal::ExceptionD
             exception_msg ? exception_msg : "Unknown", data->isr_stack_frame.rip
         );
 
-        SchedulingModule::Get().GetTaskMgr().CommitSuicide(pid);
+        SchedulingModule::Get().GetTaskMgr().CommitSuicide();
         return nullptr;
     } else {
         // Kernel Panic
diff --git a/kernel/arch/x86_64/src/scheduling/scheduling.cpp b/kernel/arch/x86_64/src/scheduling/scheduling.cpp
index a567371a..7551195b 100644
--- a/kernel/arch/x86_64/src/scheduling/scheduling.cpp
+++ b/kernel/arch/x86_64/src/scheduling/scheduling.cpp
@@ -23,7 +23,7 @@ FAST_CALL void DumpFpStateIfNeeded(Sched::Thread *thread)
 {
     ASSERT_NOT_NULL(thread);
 
-    if (thread->flags.PreserveFloats) {
+    if (thread->flags.preserve_floats) {
         u8 *mem = thread->arch_data.fp_state;
 
         __asm__ volatile("xsave64 %0" : "=m"(*mem) : "a"(0xFFFFFFFF), "d"(0xFFFFFFFF) : "memory");
@@ -34,7 +34,7 @@ FAST_CALL void LoadFpStateIfNeeded(Sched::Thread *thread)
 {
     ASSERT_NOT_NULL(thread);
 
-    if (thread->flags.PreserveFloats) {
+    if (thread->flags.preserve_floats) {
         u8 *mem = thread->arch_data.fp_state;
 
         __asm__ volatile("xrstor64 %0" : : "m"(*mem), "a"(0xFFFFFFFF), "d"(0xFFFFFFFF) : "memory");
diff --git a/kernel/arch/x86_64/src/scheduling/scheduling.nasm b/kernel/arch/x86_64/src/scheduling/scheduling.nasm
index e954c602..9c65d90b 100644
--- a/kernel/arch/x86_64/src/scheduling/scheduling.nasm
+++ b/kernel/arch/x86_64/src/scheduling/scheduling.nasm
@@ -33,14 +33,18 @@ ConvertContext:
     iretq
 
 ; c_decl
-; void JumpToUserSpace(void (*func)())
+; void JumpToUserSpace(void (*func)(), void* arg)
 ;   RDI = func
+;   RSI = arg
 ; Note: Caller is responsible for ensuring proper environment before calling (disabling IRQs)
 ; Note: FS already should be changed during contex switch
 JumpToUserSpace:
     sub rsp, _jump_userspace_stack_space
+    push rsi
+    ; aligned properly
 
     mov rsi, rsp
+    add rsi, 8
     call cdecl_JumpToUserSpaceEntry
 
     xor rax, rax
@@ -50,6 +54,8 @@ JumpToUserSpace:
     mov fs, ax
     mov gs, ax
 
+    pop rsi
+    mov rdi, rsi ; prepare void* arg for func if needed
     iretq
 
 ; c_decl
diff --git a/kernel/src/hal/scheduling.hpp b/kernel/src/hal/scheduling.hpp
index c6c98775..83e3fc2a 100644
--- a/kernel/src/hal/scheduling.hpp
+++ b/kernel/src/hal/scheduling.hpp
@@ -8,7 +8,7 @@
 
 namespace hal
 {
-WRAP_CALL void JumpToUserSpace(void (*f)()) { arch::JumpToUserSpace(f); }
+WRAP_CALL void JumpToUserSpace(void *f, void *arg) { arch::JumpToUserSpace(f, arg); }
 WRAP_CALL void ContextSwitch(Sched::Thread *thread) { arch::ContextSwitch(thread); }
 WRAP_CALL void ConvertContext(Sched::Thread *thread) { arch::ConvertContext(thread); }
 WRAP_CALL void InitializeThreadStack(void **stack, const Sched::Task &task)
diff --git a/kernel/src/mem/virt/page_fault.cpp b/kernel/src/mem/virt/page_fault.cpp
index f54d63fd..9fbc3a90 100644
--- a/kernel/src/mem/virt/page_fault.cpp
+++ b/kernel/src/mem/virt/page_fault.cpp
@@ -78,7 +78,7 @@ void HandleUnresolvableFault(const PageFaultData &pfd, const hal::ExceptionData
             TRACE_FATAL_GENERAL("Reason: Page not present");
         }
 
-        SchedulingModule::Get().GetTaskMgr().CommitSuicide(pid);
+        SchedulingModule::Get().GetTaskMgr().CommitSuicide();
     } else {
         PanicPageFault(pfd, data);
     }
diff --git a/kernel/src/scheduling/error.hpp b/kernel/src/scheduling/error.hpp
index bd146a54..6194fa89 100644
--- a/kernel/src/scheduling/error.hpp
+++ b/kernel/src/scheduling/error.hpp
@@ -13,6 +13,9 @@ enum class Error {
     ThreadNotFound,
     ProcessNameTooLong,
     ExecPathNotFound,
+    JoiningDetachedThread,
+    SelfJoin,
+    AlreadyJoined,
 };
 
 }  // namespace Sched
@@ -32,6 +35,12 @@ static constexpr const char *to_string(const Sched::Error &error)
             return "ProcessNameTooLong";
         case Sched::Error::ExecPathNotFound:
             return "ExecPathNotFound";
+        case Sched::Error::JoiningDetachedThread:
+            return "JoiningDetachedThread";
+        case Sched::Error::SelfJoin:
+            return "SelfJoin";
+        case Sched::Error::AlreadyJoined:
+            return "AlreadyJoined";
     }
 
     return "unknown error";
diff --git a/kernel/src/scheduling/scheduler_lock.hpp b/kernel/src/scheduling/local_lock.hpp
similarity index 74%
rename from kernel/src/scheduling/scheduler_lock.hpp
rename to kernel/src/scheduling/local_lock.hpp
index f125b83b..dc63295d 100644
--- a/kernel/src/scheduling/scheduler_lock.hpp
+++ b/kernel/src/scheduling/local_lock.hpp
@@ -5,14 +5,14 @@
 
 #include "modules/hardware.hpp"
 
-class SchedulerLock
+class LocalCoreLock
 {
     public:
-    FORCE_INLINE_F SchedulerLock()
+    FORCE_INLINE_F LocalCoreLock()
     {
         HardwareModule::Get().GetInterrupts().BlockHardwareInterrupts();
     }
-    ~SchedulerLock() { HardwareModule::Get().GetInterrupts().EnableHardwareInterrupts(); }
+    ~LocalCoreLock() { HardwareModule::Get().GetInterrupts().EnableHardwareInterrupts(); }
 };
 
 #endif  // KERNEL_SRC_SCHEDULING_SCHEDULER_LOCK_HPP_
diff --git a/kernel/src/scheduling/policies/priority_queue_policy.hpp b/kernel/src/scheduling/policies/priority_queue_policy.hpp
index c12ccb51..d397ef11 100644
--- a/kernel/src/scheduling/policies/priority_queue_policy.hpp
+++ b/kernel/src/scheduling/policies/priority_queue_policy.hpp
@@ -59,6 +59,11 @@ class PriorityQueuePolicy : public PolicyImpl
         return first->flags.priority > second->flags.priority;
     }
 
+    NODISCARD bool ValidateThreadFlags(const ThreadFlags *flags)
+    {
+        return flags->priority >= kMaxPriority;
+    }
+
     // ------------------------------
     // Private methods
     // ------------------------------
diff --git a/kernel/src/scheduling/policies/round_robin_policy.hpp b/kernel/src/scheduling/policies/round_robin_policy.hpp
index de065a5b..8b423cf1 100644
--- a/kernel/src/scheduling/policies/round_robin_policy.hpp
+++ b/kernel/src/scheduling/policies/round_robin_policy.hpp
@@ -49,6 +49,8 @@ class RoundRobinPolicy : public PolicyImpl
 
     NODISCARD FORCE_INLINE_F bool IsFirstHigherPriority(Thread *, Thread *) { return false; }
 
+    NODISCARD bool ValidateThreadFlags(const ThreadFlags *) { return false; }
+
     // ------------------------------
     // Private methods
     // ------------------------------
diff --git a/kernel/src/scheduling/policy.hpp b/kernel/src/scheduling/policy.hpp
index aea7fefc..85670611 100644
--- a/kernel/src/scheduling/policy.hpp
+++ b/kernel/src/scheduling/policy.hpp
@@ -9,6 +9,7 @@
 namespace Sched
 {
 struct Thread;
+struct ThreadFlags;
 
 // ------------------------------
 // SchedulingPolicy
@@ -33,6 +34,7 @@ struct Policy {
         void (*add_task)(void *, Thread *);
         u64 (*get_preempt_time)(void *, Thread *);
         bool (*is_first_higher_priority)(void *, Thread *, Thread *);
+        bool (*validate_flags)(void *, const ThreadFlags *);
     } cbs;
     void *self;
 };
@@ -46,6 +48,7 @@ struct PolicyImpl {
     void AddTask(Thread *) { R_FAIL_ALWAYS("NOT_IMPLEMENTED"); }
     NODISCARD u64 GetPreemptTime(Thread *) { R_FAIL_ALWAYS("NOT_IMPLEMENTED"); }
     NODISCARD bool IsFirstHigherPriority(Thread *, Thread *) { R_FAIL_ALWAYS("NOT_IMPLEMENTED"); }
+    NODISCARD bool ValidateThreadFlags(const ThreadFlags *) { R_FAIL_ALWAYS("NOT_IMPLEMENTED"); }
 };
 
 template <class T>
@@ -80,6 +83,14 @@ bool IsFirstHigherPriorityImpl(void *self, Thread *first, Thread *second)
     return rr->IsFirstHigherPriority(first, second);
 }
 
+template <class T>
+    requires std::derived_from<T, PolicyImpl>
+bool ValidateThreadFlagsImpl(void *self, const ThreadFlags *flags)
+{
+    const auto rr = static_cast<T *>(self);
+    return rr->ValidateThreadFlags(flags);
+}
+
 template <class T>
     requires std::derived_from<T, PolicyImpl>
 NODISCARD FAST_CALL Policy PreparePolicy(T *self)
@@ -91,6 +102,7 @@ NODISCARD FAST_CALL Policy PreparePolicy(T *self)
     policy.cbs.add_task                 = AddTaskImpl<T>;
     policy.cbs.get_preempt_time         = GetPreemptTimeImpl<T>;
     policy.cbs.is_first_higher_priority = IsFirstHigherPriorityImpl<T>;
+    policy.cbs.validate_flags           = ValidateThreadFlagsImpl<T>;
 
     return policy;
 }
diff --git a/kernel/src/scheduling/scheduler.cpp b/kernel/src/scheduling/scheduler.cpp
index 7a1b5bc7..7ab722e0 100644
--- a/kernel/src/scheduling/scheduler.cpp
+++ b/kernel/src/scheduling/scheduler.cpp
@@ -4,7 +4,7 @@
 #include "modules/hardware.hpp"
 #include "modules/scheduling.hpp"
 #include "modules/timing.hpp"
-#include "scheduling/scheduler_lock.hpp"
+#include "scheduling/local_lock.hpp"
 
 // ------------------------------
 // statics
@@ -118,10 +118,15 @@ Thread *Scheduler::ScheduleAndUpdateThreads(const bool preempt, const ThreadStat
 
 void Scheduler::Yield()
 {
-    SchedulerLock lock{};
+    LocalCoreLock lock{};
     hal::ContextSwitch(ScheduleAndUpdateThreads(true, ThreadState::kReady));
 }
 
+void Scheduler::ExitThreadUnguarded(const ThreadState state)
+{
+    hal::ContextSwitch(ScheduleAndUpdateThreads(true, state));
+}
+
 void Scheduler::ConvertToScheduling()
 {
     TRACE_INFO_SCHEDULING("Converting to scheduling!");
@@ -151,7 +156,7 @@ void Scheduler::NanoSleepUntil(const u64 systime_ns)
 {
     u64 time;
     {
-        SchedulerLock lock{};
+        LocalCoreLock lock{};
         time = TimingModule::Get().GetSystemTime().ReadLifeTimeNs();
         if (systime_ns < time) {
             return;
@@ -166,7 +171,7 @@ void Scheduler::NanoSleepUntil(const u64 systime_ns)
     }
 
     {
-        SchedulerLock lock{};
+        LocalCoreLock lock{};
 
         hardware::GetCoreLocalTcb()->key = systime_ns;
         sleep_queue_.Insert(hardware::GetCoreLocalTcb());
@@ -175,6 +180,25 @@ void Scheduler::NanoSleepUntil(const u64 systime_ns)
     }
 }
 
+void Scheduler::NanoSleepUntilUnguarded(const u64 systime_ns)
+{
+    const u64 time = TimingModule::Get().GetSystemTime().ReadLifeTimeNs();
+    if (systime_ns < time) {
+        return;
+    }
+
+    if (systime_ns - time < kMinDelta) {
+        /* Do busy wait if window to scheduler irq is too small */
+        while (systime_ns - TimingModule::Get().GetSystemTime().ReadLifeTimeNs() < kMinDelta) {
+        }
+        return;
+    }
+    hardware::GetCoreLocalTcb()->key = systime_ns;
+    sleep_queue_.Insert(hardware::GetCoreLocalTcb());
+
+    hal::ContextSwitch(ScheduleAndUpdateThreads(true, ThreadState::kSleeping));
+}
+
 void Scheduler::SetupNextTimeEvent_(const u64 time_ns)
 {
     ASSERT_TRUE(HardwareModule::Get().GetEventClockRegistry().IsSelectedPicked());
diff --git a/kernel/src/scheduling/scheduler.hpp b/kernel/src/scheduling/scheduler.hpp
index 477c75d3..13391f19 100644
--- a/kernel/src/scheduling/scheduler.hpp
+++ b/kernel/src/scheduling/scheduler.hpp
@@ -44,16 +44,30 @@ class Scheduler
 
     void Yield();
 
-    void ConvertToScheduling();
+    void ExitThreadUnguarded(ThreadState state);
 
-    /* Should only be called inside syscall code or kernel thread code */
-    void NanoSleepUntil(u64 systime_ns);
+    void ConvertToScheduling();
 
     // True if should preempt
     NODISCARD bool WakeUpTasks();
 
     NODISCARD Thread *TimerRoutine();
 
+    NODISCARD FORCE_INLINE_F bool ValidateThreadFlags(const ThreadFlags flags)
+    {
+        const auto policy = GetPolicy_(flags);
+        return policy.cbs.validate_flags(policy.self, &flags);
+    }
+
+    // ------------------------------
+    // Syscalls
+    // ------------------------------
+    /* Should only be called inside syscall code or kernel thread code */
+
+    void NanoSleepUntil(u64 systime_ns);
+
+    void NanoSleepUntilUnguarded(u64 systime_ns);
+
     // ------------------------------
     // Private methods
     // ------------------------------
@@ -61,14 +75,17 @@ class Scheduler
     protected:
     void PrepareNextTimerInterruptBeforeSwitchUnguarded_(Thread *next_thread);
 
+    NODISCARD FORCE_INLINE_F const Policy &GetPolicy_(const ThreadFlags flags) const
+    {
+        ASSERT_LT(static_cast<size_t>(flags.policy), static_cast<size_t>(SchedulingPolicy::kLast));
+
+        return policies_[static_cast<size_t>(flags.policy)];
+    }
+
     NODISCARD FORCE_INLINE_F const Policy &GetPolicy_(Thread *thread) const
     {
         ASSERT_NOT_NULL(thread);
-        ASSERT_LT(
-            static_cast<size_t>(thread->flags.policy), static_cast<size_t>(SchedulingPolicy::kLast)
-        );
-
-        return policies_[static_cast<size_t>(thread->flags.policy)];
+        return GetPolicy_(thread->flags);
     }
 
     NODISCARD FORCE_INLINE_F u64 GetPreemptTime_(Thread *thread) const
diff --git a/kernel/src/scheduling/task_mgr.cpp b/kernel/src/scheduling/task_mgr.cpp
index 92e16819..309c5e78 100644
--- a/kernel/src/scheduling/task_mgr.cpp
+++ b/kernel/src/scheduling/task_mgr.cpp
@@ -8,11 +8,10 @@
 #include "scheduling/kworker.hpp"
 #include "task_mgr.hpp"
 
-#include <hal/panic.hpp>
-
-#include "trace_framework.hpp"
-
 #include "hal/scheduling.hpp"
+#include "modules/timing.hpp"
+#include "scheduling/local_lock.hpp"
+#include "trace_framework.hpp"
 
 // ------------------------------
 // statics
@@ -105,9 +104,9 @@ std::expected<Thread *, Error> TaskMgr::SpawnThread(const Pid pid, const Task &t
 
     ThreadFlags flags{};
 
-    flags.PreserveFloats = process.value()->flags.PreserveFloats;
-    flags.policy         = SchedulingPolicy::kNormalTasks_RR_P3;
-    flags.priority       = 0;
+    flags.preserve_floats = process.value()->flags.PreserveFloats;
+    flags.policy          = SchedulingPolicy::kNormalTasks_RR_P3;
+    flags.priority        = 0;
 
     return SpawnThread(process.value(), flags, task);
 }
@@ -274,10 +273,101 @@ std::expected<std::tuple<Pid, Tid>, Error> TaskMgr::ExecuteElf64(
 
 std::expected<void, Error> TaskMgr::CommitMurder(Pid) { R_FAIL_ALWAYS("NOT IMPLEMENTED"); }
 
-void TaskMgr::CommitSuicide(Pid) { R_FAIL_ALWAYS("NOT IMPLEMENTED"); }
+void TaskMgr::CommitSuicide() { R_FAIL_ALWAYS("NOT IMPLEMENTED"); }
+
+std::expected<void, Error> TaskMgr::ExitProcess() { R_FAIL_ALWAYS("NOT IMPLEMENTED"); }
+
+std::expected<Tid, Error> TaskMgr::CreateThread(const ThreadFlags flags, const Task &task)
+{
+    LocalCoreLock lock{};
+    const auto thread = SpawnThread(hardware::GetRunningPid(), flags, task);
+
+    if (!thread) {
+        return std::unexpected(thread.error());
+    }
+
+    SchedulingModule::Get().GetScheduler().AddReadyThread(thread.value());
+    return thread.value()->tid;
+}
+
+std::expected<Tid, Error> TaskMgr::CreateUserThread(
+    const ThreadFlags flags, const thread_func_t func, void *arg
+)
+{
+    const Task task = PrepareUserThreadTask(func, arg);
+    return CreateThread(flags, task);
+}
+
+std::expected<void, Error> TaskMgr::DetachThread(const Tid tid)
+{
+    LocalCoreLock core_lock{};
+    auto thread = SchedulingModule::Get().GetThreads().GetThread(tid);
+
+    if (!thread) {
+        return std::unexpected(thread.error());
+    }
+
+    if (thread.value()->state == ThreadState::kWaitingForJoin) {
+        thread.value()->state = ThreadState::kTerminated;
+        threads_to_clean_.Push(thread.value()->tid.id);
 
-std::expected<void, Error> TaskMgr::ExitProcess(Pid) { R_FAIL_ALWAYS("NOT IMPLEMENTED"); }
+        return {};
+    }
+
+    thread.value()->flags.detached = true;
+    return {};
+}
+
+void TaskMgr::ThreadExit(void *retval)
+{
+    const auto tcb = hardware::GetCoreLocalTcb();
+    ASSERT_EQ(tcb->state, ThreadState::kRunning);
+
+    tcb->retval = retval;
+
+    LocalCoreLock core_lock{};
+    ThreadState state{};
+    if (tcb->flags.detached) {
+        state = ThreadState::kTerminated;
+        threads_to_clean_.Push(tcb->tid.id);
+    } else {
+        state = ThreadState::kWaitingForJoin;
+    }
+    SchedulingModule::Get().GetScheduler().ExitThreadUnguarded(state);
+}
+
+std::expected<void *, Error> TaskMgr::JoinThread(const Tid tid)
+{
+    const auto tcb = hardware::GetCoreLocalTcb();
+    ASSERT_EQ(tcb->state, ThreadState::kRunning);
+
+    if (tcb->tid == tid) {
+        return std::unexpected(Error::SelfJoin);
+    }
 
-std::expected<void, Error> TaskMgr::ExitThread(Tid) { R_FAIL_ALWAYS("NOT IMPLEMENTED"); }
+    LocalCoreLock lock{};
+    auto thread = SchedulingModule::Get().GetThreads().GetThread(tid);
 
+    if (!thread) {
+        return std::unexpected(thread.error());
+    }
+
+    while (thread.value()->state != ThreadState::kWaitingForJoin ||
+           thread.value()->state != ThreadState::kTerminated) {
+        static constexpr u64 kWaitTime = 50'000'000;  // 50 ms
+
+        SchedulingModule::Get().GetScheduler().NanoSleepUntilUnguarded(
+            TimingModule::Get().GetSystemTime().ReadLifeTimeNs() + kWaitTime
+        );
+    }
+
+    if (thread.value()->state == ThreadState::kWaitingForJoin) {
+        thread.value()->state = ThreadState::kTerminated;
+        threads_to_clean_.Push(thread.value()->tid.id);
+
+        return {thread.value()->retval};
+    }
+
+    return std::unexpected(Error::AlreadyJoined);
+}
 }  // namespace Sched
diff --git a/kernel/src/scheduling/task_mgr.hpp b/kernel/src/scheduling/task_mgr.hpp
index cce115e9..f4b1e570 100644
--- a/kernel/src/scheduling/task_mgr.hpp
+++ b/kernel/src/scheduling/task_mgr.hpp
@@ -19,11 +19,15 @@ class TaskMgr
     ~TaskMgr() = default;
 
     // ------------------------------
-    // Class interaction
+    // Initialization
     // ------------------------------
 
     void InitializeMultitasking();
 
+    // ------------------------------
+    // Spawning
+    // ------------------------------
+
     NODISCARD std::expected<Pid, Error> SpawnEmptyProcess(const char *name, ProcessFlags flags);
 
     NODISCARD std::expected<Thread *, Error> SpawnThread(Pid pid, const Task &task);
@@ -42,19 +46,37 @@ class TaskMgr
 
     NODISCARD std::expected<Pid, Error> CloneProcess(Pid pid);
 
+    // ------------------------------
+    // Execute
+    // ------------------------------
+
     NODISCARD std::expected<Tid, Error> ExecuteElf64(Pid pid, const char *path);
 
     NODISCARD std::expected<std::tuple<Pid, Tid>, Error> ExecuteElf64(
         const char *path, ProcessFlags flags
     );
 
+    // ------------------------------
+    // Syscalls
+    // ------------------------------
+
     NODISCARD std::expected<void, Error> CommitMurder(Pid pid);
 
-    void CommitSuicide(Pid pid);
+    void CommitSuicide();
+
+    NODISCARD std::expected<void, Error> ExitProcess();
 
-    NODISCARD std::expected<void, Error> ExitProcess(Pid pid);
+    NODISCARD std::expected<Tid, Error> CreateThread(ThreadFlags flags, const Task &task);
+
+    NODISCARD std::expected<Tid, Error> CreateUserThread(
+        ThreadFlags flags, thread_func_t func, void *arg
+    );
 
-    NODISCARD std::expected<void, Error> ExitThread(Tid tid);
+    NODISCARD std::expected<void, Error> DetachThread(Tid tid);
+
+    void ThreadExit(void *retval);
+
+    NODISCARD std::expected<void *, Error> JoinThread(Tid tid);
 
     // ------------------------------
     // Private methods
@@ -64,6 +86,8 @@ class TaskMgr
     // ------------------------------
     // Class fields
     // ------------------------------
+
+    AtomicArraySingleTypeStaticStack<u32, kMaxThreads> threads_to_clean_{};
 };
 }  // namespace Sched
 
diff --git a/kernel/src/scheduling/thread.hpp b/kernel/src/scheduling/thread.hpp
index c35a6b02..16452f04 100644
--- a/kernel/src/scheduling/thread.hpp
+++ b/kernel/src/scheduling/thread.hpp
@@ -32,13 +32,16 @@ struct Task {
 struct PACK Tid {
     u16 id;
     u64 count : 48;
+
+    bool operator==(const Tid &other) const = default;
 };
 
 struct PACK ThreadFlags {
     SchedulingPolicy policy : 8;
     u8 priority : 8;
-    bool PreserveFloats : 1;
-    u64 padding : 47;
+    bool preserve_floats : 1;
+    bool detached : 1;
+    u64 padding : 46;
 };
 static_assert(sizeof(ThreadFlags) == 8);
 
@@ -46,6 +49,7 @@ enum class ThreadState : u64 {
     kReady = 0,
     kRunning,
     kSleeping,
+    kWaitingForJoin,
     kTerminated,
     kLast,
 };
@@ -58,6 +62,7 @@ struct Thread : data_structures::IntrusiveRbNode<Thread, u64>,
     Pid owner;
     ThreadFlags flags;
     ThreadState state;
+    void *retval;
 
     /* Thread resources */
     void *kernel_stack;
diff --git a/kernel/src/scheduling/threads.cpp b/kernel/src/scheduling/threads.cpp
index 4b92de9b..a2c45032 100644
--- a/kernel/src/scheduling/threads.cpp
+++ b/kernel/src/scheduling/threads.cpp
@@ -51,11 +51,16 @@ void Elf64EntryPoint(const Pid pid, const char *path)
         DEBUG_WARN_SCHEDULING(
             "Failed to execute ELF64 for process %llu. Failed on ELF loading.", pid
         );
-        SchedulingModule::Get().GetTaskMgr().CommitSuicide(pid);
+        SchedulingModule::Get().GetTaskMgr().CommitSuicide();
     }
 
-    const auto entry = reinterpret_cast<void (*)()>(entry_res.value());
-    hal::JumpToUserSpace(entry);
+    const auto entry = static_cast<void *>(entry_res.value());
+    hal::JumpToUserSpace(entry, nullptr);
+}
+
+void UserThreadEntryPoint(const thread_func_t func, void *arg)
+{
+    hal::JumpToUserSpace(reinterpret_cast<void *>(func), arg);
 }
 
 void UpdateTcbOnInterruptEntry(hal::ExceptionData *data)
diff --git a/kernel/src/scheduling/threads.hpp b/kernel/src/scheduling/threads.hpp
index 323e0b9a..eaa672e3 100644
--- a/kernel/src/scheduling/threads.hpp
+++ b/kernel/src/scheduling/threads.hpp
@@ -79,6 +79,7 @@ void KThreadEntrypoint(void (*f)());
 void OnKThreadExit();
 
 void Elf64EntryPoint(Pid pid, const char *path);
+void UserThreadEntryPoint(thread_func_t func, void *arg);
 
 void UpdateTcbOnInterruptEntry(hal::ExceptionData *data);
 void UpdateTcbOnInterruptExit(Thread *thread);
@@ -103,6 +104,16 @@ NODISCARD FAST_CALL Task PrepareElf64LoaderTask(Pid pid, const char *path)
     return task;
 }
 
+NODISCARD FAST_CALL Task PrepareUserThreadTask(thread_func_t func, void *arg)
+{
+    Task task{};
+    task.func       = reinterpret_cast<void *>(UserThreadEntryPoint);
+    task.args_count = 2;
+    task.args       = {reinterpret_cast<u64>(func), reinterpret_cast<u64>(arg)};
+
+    return task;
+}
+
 }  // namespace Sched
 
 extern "C" void cdecl_UpdateTcbOnSyscallEntry();
diff --git a/kernel/src/syscalls/calls/panic.hpp b/kernel/src/syscalls/calls/panic.hpp
index ee0c0afb..e7d2396d 100644
--- a/kernel/src/syscalls/calls/panic.hpp
+++ b/kernel/src/syscalls/calls/panic.hpp
@@ -30,7 +30,7 @@ NO_RET FORCE_INLINE_F void SysPanic(const char *msg)
         TRACE_WARN_GENERAL("User Panic in PID %llu: %s", pid.id, msg);
     }
 
-    SchedulingModule::Get().GetTaskMgr().CommitSuicide(pid);
+    SchedulingModule::Get().GetTaskMgr().CommitSuicide();
 
     __builtin_unreachable();
 }
diff --git a/kernel/src/syscalls/calls/thread.hpp b/kernel/src/syscalls/calls/thread.hpp
index fdcd130c..4116bd31 100644
--- a/kernel/src/syscalls/calls/thread.hpp
+++ b/kernel/src/syscalls/calls/thread.hpp
@@ -9,13 +9,70 @@
 
 namespace Syscall
 {
-FAST_CALL int SysThreadCreate(Thread *, thread_func_t, void *) { return 0; }
+FAST_CALL int SysThreadCreate(Thread *thread, thread_func_t func, void *arg)
+{
+    if (thread == nullptr || func == nullptr) {
+        return -1;
+    }
+
+    Sched::ThreadFlags flags{};
+    flags.policy          = static_cast<Sched::SchedulingPolicy>(thread->flags.policy);
+    flags.priority        = thread->flags.priority;
+    flags.preserve_floats = thread->flags.preserve_floats;
+
+    if (flags.policy < Sched::SchedulingPolicy::kNormalTasks_RR_P3) {
+        return -1;  // User may only spawn normal and background tasks
+    }
+
+    if (SchedulingModule::Get().GetScheduler().ValidateThreadFlags(flags)) {
+        return -1;  // Invalid thrad flags for given policy
+    }
+
+    const auto result = SchedulingModule::Get().GetTaskMgr().CreateUserThread(flags, func, arg);
+    if (!result) {
+        return -1;
+    }
 
-FAST_CALL int SysThreadJoin(Thread *) { return 0; }
+    const Sched::Tid tid = result.value();
+    thread->tid          = *reinterpret_cast<const u64 *>(&tid);
+    return 0;
+}
+
+FAST_CALL int SysThreadJoin(Thread *thread, void **retval)
+{
+    if (thread == nullptr) {
+        return -1;
+    }
+
+    const auto result = SchedulingModule::Get().GetTaskMgr().JoinThread(
+        *reinterpret_cast<Sched::Tid *>(&thread->tid)
+    );
 
-FAST_CALL int SysThreadDetach(Thread *) { return 0; }
+    if (!result) {
+        *retval = nullptr;
+        return -1;
+    }
 
-FAST_CALL void SysThreadExit(void *) {}
+    *retval = result.value();
+    return 0;
+}
+
+FAST_CALL int SysThreadDetach(Thread *thread)
+{
+    if (thread == nullptr) {
+        return -1;
+    }
+
+    const auto result = SchedulingModule::Get().GetTaskMgr().DetachThread(
+        *reinterpret_cast<Sched::Tid *>(&thread->tid)
+    );
+    return result ? 0 : -1;
+}
+
+FAST_CALL void SysThreadExit(void *retval)
+{
+    SchedulingModule::Get().GetTaskMgr().ThreadExit(retval);
+}
 
 FAST_CALL void SysNanoSleepUntil(const u64 systime_ns)
 {
diff --git a/libs/libc/src/abi/platform.h b/libs/libc/src/abi/platform.h
index ac45b899..32ff14d0 100644
--- a/libs/libc/src/abi/platform.h
+++ b/libs/libc/src/abi/platform.h
@@ -37,7 +37,7 @@ SYSCALL_NAME(file_info, kSysFileInfo, int, const char *, path, FileInfo *, info)
 /* Thread, processes */
 SYSCALL_NAME(thread_create, kThreadCreate, int, Thread *, thread, thread_func_t, f, void *, arg);
 SYSCALL_VOID_NAME(thread_exit, kThreadExit, void *, retval);
-SYSCALL_NAME(thread_join, kThreadJoin, int, Thread *, thread);
+SYSCALL_NAME(thread_join, kThreadJoin, int, Thread *, thread, void **, retval);
 SYSCALL_NAME(thread_detach, kThreadDetach, int, Thread *, thread);
 SYSCALL_VOID_NAME(proc_exit, kProcExit, int, status);
 SYSCALL_VOID_NAME(proc_abort, kProcAbort);
diff --git a/libs/libc/src/include/alkos/sys/thread.h b/libs/libc/src/include/alkos/sys/thread.h
index 3a944fe7..97747a6b 100644
--- a/libs/libc/src/include/alkos/sys/thread.h
+++ b/libs/libc/src/include/alkos/sys/thread.h
@@ -17,12 +17,15 @@ FAST_CALL int ThreadCreate(Thread *thread, ThreadFlags flags, thread_func_t f, v
     return __platform_thread_create(thread, f, arg);
 }
 
-FAST_CALL int ThreadJoin(Thread *thread) { return __platform_thread_join(thread); }
-
 FAST_CALL int ThreadDetach(Thread *thread) { return __platform_thread_detach(thread); }
 
 FAST_CALL void ThreadExit(void *retval) { __platform_thread_exit(retval); }
 
+FAST_CALL int ThreadJoin(Thread *thread, void **retval)
+{
+    return __platform_thread_join(thread, retval);
+}
+
 FAST_CALL void NanoSleepUntil(u64 systime_ns) { __platform_nanosleep_until(systime_ns); }
 
 FAST_CALL void NanoSleep(u64 time_ns) { __platform_nanosleep(time_ns); }
diff --git a/libs/libc/src/include/alkos/thread.h b/libs/libc/src/include/alkos/thread.h
index 84594bd7..4140d427 100644
--- a/libs/libc/src/include/alkos/thread.h
+++ b/libs/libc/src/include/alkos/thread.h
@@ -7,9 +7,21 @@
 
 typedef void (*thread_func_t)(void *);
 
+enum SchedulingPolicy {
+    kUberTask_PQ_P0 = 0,
+    kDrivers_PQ_P1,
+    kUrgentTasks_PQ_P2,
+    kNormalTasks_RR_P3,
+    kBackgroundTasks_RR_P4,
+    kLast,
+};
+
 typedef struct PACK {
-    bool PreserveFloats : 1;
-    u32 padding : 31;
+    enum SchedulingPolicy policy : 8;
+    u8 priority : 8;
+    bool preserve_floats : 1;
+    bool detached : 1;
+    u64 padding : 46;
 } ThreadFlags;
 
 typedef struct {
diff --git a/libs/libc/src/internal/libc_backend.cpp b/libs/libc/src/internal/libc_backend.cpp
index 01f24578..bb624e8e 100644
--- a/libs/libc/src/internal/libc_backend.cpp
+++ b/libs/libc/src/internal/libc_backend.cpp
@@ -31,7 +31,7 @@ DEFINE_SYSCALL(file_info, kSysFileInfo, int, const char *, path, FileInfo *, inf
 /* Thread, processes */
 DEFINE_SYSCALL(thread_create, kThreadCreate, int, Thread *, thread, thread_func_t, f, void *, arg)
 DEFINE_SYSCALL_VOID(thread_exit, kThreadExit, void *, retval)
-DEFINE_SYSCALL(thread_join, kThreadJoin, int, Thread *, thread)
+DEFINE_SYSCALL(thread_join, kThreadJoin, int, Thread *, thread, void **, retval)
 DEFINE_SYSCALL(thread_detach, kThreadDetach, int, Thread *, thread)
 DEFINE_SYSCALL_VOID(proc_exit, kProcExit, int, status)
 DEFINE_SYSCALL_VOID(proc_abort, kProcAbort)

From 5c2be0a86830a56cf62b4a85067938907579dce0 Mon Sep 17 00:00:00 2001
From: Jakub Lisowski <115403674+Jlisowskyy@users.noreply.github.com>
Date: Mon, 5 Jan 2026 01:52:54 +0100
Subject: [PATCH 50/56] F1r3d3v/userspace policy (#273)

Co-authored-by: F1r3d3v <ogieniewski.dev@gmail.com>
---
 kernel/arch/x86_64/src/include/thread.nasm    |   2 +-
 .../arch/x86_64/src/scheduling/scheduling.cpp |  23 +-
 kernel/src/hal/panic.hpp                      |  21 +-
 kernel/src/hardware/core_local.hpp            |   7 +
 kernel/src/kernel.cpp                         |  31 +-
 kernel/src/mem/virt/area.cpp                  |   4 +-
 .../src/scheduling/policies/mlfq_policy.hpp   | 204 +++++++++++
 .../policies/round_robin_policy.hpp           |   1 +
 kernel/src/scheduling/policy.hpp              |  26 +-
 kernel/src/scheduling/scheduler.cpp           |  82 +++--
 kernel/src/scheduling/scheduler.hpp           |  32 +-
 kernel/src/scheduling/task_mgr.cpp            |   7 +-
 kernel/src/scheduling/thread.cpp              |   2 +-
 kernel/src/scheduling/thread.hpp              |  10 +-
 kernel/src/scheduling/threads.cpp             |   3 +-
 kernel/src/syscalls/calls/thread.hpp          |   3 +-
 kernel/src/syscalls/calls/video.hpp           |   2 +-
 kernel/src/video/window_manager.cpp           |   4 -
 kernel/test/manual_tests.cpp                  |   7 +
 kernel/test/rb_test.cpp                       |   4 +-
 .../maps/intrusive_rb_tree.hpp                | 344 +++++++++---------
 userspace/programs/gui_test/main.cpp          |   3 +
 userspace/programs/shell/main.cpp             |   6 +-
 23 files changed, 591 insertions(+), 237 deletions(-)
 create mode 100644 kernel/src/scheduling/policies/mlfq_policy.hpp

diff --git a/kernel/arch/x86_64/src/include/thread.nasm b/kernel/arch/x86_64/src/include/thread.nasm
index 5b90f28c..b7e76cf8 100644
--- a/kernel/arch/x86_64/src/include/thread.nasm
+++ b/kernel/arch/x86_64/src/include/thread.nasm
@@ -3,7 +3,7 @@
 ; ------------------------------------------------------------
 
 struc Thread
-    .intrusive_data         resb 48
+    .intrusive_data         resb 88
 
     .tid:                   resq 1
     .owner:                 resq 1
diff --git a/kernel/arch/x86_64/src/scheduling/scheduling.cpp b/kernel/arch/x86_64/src/scheduling/scheduling.cpp
index 7551195b..88171008 100644
--- a/kernel/arch/x86_64/src/scheduling/scheduling.cpp
+++ b/kernel/arch/x86_64/src/scheduling/scheduling.cpp
@@ -115,13 +115,21 @@ extern "C" void cdecl_ConvertContextEntry(Sched::Thread *thread)
     LoadFpStateIfNeeded(thread);
     hardware::SetCoreLocalTcb(thread);
     SetTssRsp0(reinterpret_cast<u64>(thread->kernel_stack_bottom));
-    thread->timestamp = TimingModule::Get().GetSystemTime().ReadLifeTimeNs();
+
+    const auto t                         = TimingModule::Get().GetSystemTime().ReadLifeTimeNs();
+    thread->timestamp                    = t;
+    thread->timestamp_execution_start_ns = t;
+
     SwapAsIfNeeded(thread);
     SwapGsIfJumpingToUserspace(thread);
 }
 
 extern "C" void cdecl_JumpToUserSpaceEntry(void *addr, IsrStackFrame *frame)
 {
+    ASSERT_NOT_NULL(addr);
+    ASSERT_NOT_NULL(frame);
+    ASSERT_NOT_NULL(hardware::GetCoreLocalTcb());
+
     auto thread          = hardware::GetCoreLocalTcb();
     thread->kernel_stack = thread->kernel_stack_bottom;
 
@@ -143,8 +151,12 @@ extern "C" void cdecl_ContextSwitchEntry(
     Sched::Thread *thread, IsrErrorStackFrame *mem, const u64 rip
 )
 {
+    ASSERT_NOT_NULL(thread);
+    ASSERT_NOT_NULL(mem);
+    ASSERT_NOT_NULL(hardware::GetCoreLocalTcb());
+
     ASSERT_EQ(thread->state, Sched::ThreadState::kRunning);
-    ASSERT_EQ(hardware::GetCoreLocalTcb()->state, Sched::ThreadState::kReady);
+    ASSERT_NEQ(hardware::GetCoreLocalTcb()->state, Sched::ThreadState::kRunning);
 
     const auto current_tcb = hardware::GetCoreLocalTcb();
     DumpFpStateIfNeeded(current_tcb);
@@ -164,7 +176,8 @@ extern "C" void cdecl_ContextSwitchEntry(
     const u64 t                 = TimingModule::Get().GetSystemTime().ReadLifeTimeNs();
     current_tcb->kernel_time_ns = t - current_tcb->timestamp;
     current_tcb->num_context_switches++;
-    thread->timestamp = t;
+    thread->timestamp                    = t;
+    thread->timestamp_execution_start_ns = t;
 
     LoadFpStateIfNeeded(thread);
     SwapAsIfNeeded(thread);
@@ -173,6 +186,10 @@ extern "C" void cdecl_ContextSwitchEntry(
 
 extern "C" void cdecl_ContextSwitchOnInterrupt(Sched::Thread *thread, void *rsp)
 {
+    ASSERT_NOT_NULL(thread);
+    ASSERT_NOT_NULL(rsp);
+    ASSERT_NOT_NULL(hardware::GetCoreLocalTcb());
+
     ASSERT_EQ(thread->state, Sched::ThreadState::kRunning);
     ASSERT_EQ(hardware::GetCoreLocalTcb()->state, Sched::ThreadState::kReady);
 
diff --git a/kernel/src/hal/panic.hpp b/kernel/src/hal/panic.hpp
index 3c8a9a35..b9e7e6f6 100644
--- a/kernel/src/hal/panic.hpp
+++ b/kernel/src/hal/panic.hpp
@@ -6,6 +6,7 @@
 #include "trace_framework.hpp"
 
 #include <stdio.h>
+#include "scheduling/local_lock.hpp"
 
 namespace hal
 {
@@ -22,7 +23,6 @@ FAST_CALL void KernelPanic(const char *msg)
         HardwareModule::Get().GetInterrupts().BlockHardwareInterrupts();
         HardwareModule::Get().GetCoresController().PanicAllCores();
     }
-
     trace::DumpAllBuffersOnFailure();
 
     // BYPASS TRACE FRAMEWORK AS this function is used inside of it
@@ -31,20 +31,29 @@ FAST_CALL void KernelPanic(const char *msg)
     TerminalWriteString("\n");
 
     arch::KernelPanic();
+    __builtin_unreachable();
 }
 
 template <typename... Args>
 FAST_CALL NO_RET void KernelPanicFormat(const char *fmt, Args... args)
 {
-    HardwareModule::Get().GetInterrupts().BlockHardwareInterrupts();
-    HardwareModule::Get().GetCoresController().PanicAllCores();
+    static constexpr size_t kMaxSize = 2048;
+    char buff[kMaxSize];
+
+    if (HardwareModule::IsInited()) {
+        HardwareModule::Get().GetInterrupts().BlockHardwareInterrupts();
+        HardwareModule::Get().GetCoresController().PanicAllCores();
+    }
 
     // For some reason trace::DumpAllBuffersOnFailure() must be called before and after printing
     trace::DumpAllBuffersOnFailure();
-    TRACE_FATAL_GENERAL("[ KERNEL PANIC ]");
-    TRACE_FATAL_GENERAL(fmt, args...);
-    arch::KernelPanic();
 
+    TerminalWriteString("[ KERNEL PANIC ] ");
+    snprintf(buff, kMaxSize, fmt, args...);
+    TerminalWriteString(buff);
+    TerminalWriteString("\n");
+
+    arch::KernelPanic();
     __builtin_unreachable();
 }
 
diff --git a/kernel/src/hardware/core_local.hpp b/kernel/src/hardware/core_local.hpp
index 2727c28b..af235c4a 100644
--- a/kernel/src/hardware/core_local.hpp
+++ b/kernel/src/hardware/core_local.hpp
@@ -32,6 +32,13 @@ PREPARE_CORE_LOCAL_ACCESS(Tcb, Sched::Thread *, thread_control_block);
 PREPARE_CORE_LOCAL_ACCESS(Self, CoreLocal *, self);
 #pragma GCC diagnostic pop
 
+#define GET_CORE_LOCAL_THREAD_SAVE()           \
+    []() {                                     \
+        const auto thread = GetCoreLocalTcb(); \
+        ASSERT_NOT_NULL(thread);               \
+        return thread;                         \
+    }()
+
 NODISCARD FAST_CALL Sched::Pid GetRunningPid()
 {
     // During boot, TCB is null. Return {0,0} (Kernel PID) in that case.
diff --git a/kernel/src/kernel.cpp b/kernel/src/kernel.cpp
index 5461e77a..26331803 100644
--- a/kernel/src/kernel.cpp
+++ b/kernel/src/kernel.cpp
@@ -17,27 +17,24 @@ static void KernelRun()
 
     auto &task_mgr = SchedulingModule::Get().GetTaskMgr();
 
-    auto res = task_mgr.ExecuteElf64("/bin/hello", {});
-    R_ASSERT_TRUE(res, "Failed to spawn /bin/hello process...");
-    auto [pid, _] = res.value();
-
-    Sched::Task tracer_task;
-    tracer_task.func       = reinterpret_cast<void *>(Sched::StdoutTracerMain);
-    tracer_task.args_count = 1;
-    tracer_task.args       = {*reinterpret_cast<u64 *>(&pid)};
-
-    // Spawn StdoutTracer KWorker to monitor hello_world's stdout
-    R_ASSERT_TRUE(
-        task_mgr.SpawnKernelProcess("stdout-tracer", {}, tracer_task),
-        "Failed to spawn stdout tracer process..."
-    );
+    // auto res = task_mgr.ExecuteElf64("/bin/hello", {});
+    // R_ASSERT_TRUE(res, "Failed to spawn /bin/hello process...");
+    // auto [pid, _] = res.value();
+    //
+    // Sched::Task tracer_task;
+    // tracer_task.func       = reinterpret_cast<void *>(Sched::StdoutTracerMain);
+    // tracer_task.args_count = 1;
+    // tracer_task.args       = {*reinterpret_cast<u64 *>(&pid)};
+    //
+    // // Spawn StdoutTracer KWorker to monitor hello_world's stdout
+    // R_ASSERT_TRUE(
+    //     task_mgr.SpawnKernelProcess("stdout-tracer", {}, tracer_task),
+    //     "Failed to spawn stdout tracer process..."
+    // );
 
     const auto res1 = task_mgr.ExecuteElf64("/bin/gui_test", {});
     R_ASSERT_TRUE(static_cast<bool>(res1), "Failed to spawn /bin/gui process...");
 
-    for (volatile size_t i = 0; i < 1'000'000; i = i + 1) {
-    }
-
     const auto res2 = task_mgr.ExecuteElf64("/bin/shell", {});
     R_ASSERT_TRUE(static_cast<bool>(res2), "Failed to spawn /bin/shell process...");
 
diff --git a/kernel/src/mem/virt/area.cpp b/kernel/src/mem/virt/area.cpp
index 3c6d18f4..150ecaf7 100644
--- a/kernel/src/mem/virt/area.cpp
+++ b/kernel/src/mem/virt/area.cpp
@@ -67,7 +67,7 @@ bool AnonymousVMemArea::HandleFault(
         return false;
     }
 
-    TRACE_INFO_MEMORY("Handling Anonymous Fault at %p", fault_addr);
+    TRACE_FREQ_INFO_MEMORY("Handling Anonymous Fault at %p", fault_addr);
 
     auto &pmm = MemoryModule::Get().GetBitmapPmm();
 
@@ -99,7 +99,7 @@ bool DirectMappingVMemArea::HandleFault(
         return false;
     }
 
-    TRACE_INFO_MEMORY("Handling Direct Mapping Fault at %p", fault_addr);
+    TRACE_FREQ_INFO_MEMORY("Handling Direct Mapping Fault at %p", fault_addr);
 
     // Calculate physical address based on offset
     u64 offset         = Mem::PtrToUptr(fault_addr) - Mem::PtrToUptr(start_);
diff --git a/kernel/src/scheduling/policies/mlfq_policy.hpp b/kernel/src/scheduling/policies/mlfq_policy.hpp
new file mode 100644
index 00000000..c4787e10
--- /dev/null
+++ b/kernel/src/scheduling/policies/mlfq_policy.hpp
@@ -0,0 +1,204 @@
+#ifndef KERNEL_SRC_SCHEDULING_POLICIES_MLFQ_POLICY_HPP_
+#define KERNEL_SRC_SCHEDULING_POLICIES_MLFQ_POLICY_HPP_
+
+#include <assert.h>
+#include <data_structures/maps/intrusive_rb_tree.hpp>
+#include <defines.hpp>
+
+#include "scheduling/policy.hpp"
+#include "scheduling/thread.hpp"
+
+namespace Sched
+{
+
+/**
+ * Multi-Level Feedback Queue (MLFQ) Scheduling Policy
+ *
+ * MLFQ is a scheduling algorithm that:
+ * - Uses multiple priority queues (levels 0 to kNumLevels-1)
+ * - Higher priority queues have shorter time slice
+ * - Tasks that use their full time slice are demoted to lower priority
+ * - Tasks that yield early (interactive) may be boosted to higher priority
+ * - Prevents starvation through periodic priority boosting
+ * - Within each queue, schedules by minimum vruntime for fairness
+ *
+ * Vruntime scaling:
+ * - Used to adjust how quickly a thread's vruntime increases based on its priority level
+ * - Higher priority threads have slower vruntime growth, favoring responsiveness
+ * - Lower priority threads have faster vruntime growth, ensuring CPU time
+ *
+ * Priority Boosting:
+ * - All threads are boosted to highest priority level every kBoostIntervalNs to prevent starvation
+ */
+class MLFQPolicy : public PolicyImpl
+{
+    public:
+    static constexpr u8 kNumLevels        = 4;
+    static constexpr u64 kBaseTimeSliceNs = 5'000'000;    // 5ms
+    static constexpr u64 kBoostIntervalNs = 150'000'000;  // 150ms
+    static constexpr u64 kVruntimeScale   = 1024;
+    static constexpr std::array<u64, static_cast<size_t>(UserPriority::kLast)> kWeights =
+        [] constexpr {
+            static constexpr size_t kNumPriorities  = static_cast<size_t>(UserPriority::kLast);
+            std::array<u64, kNumPriorities> weights = {};
+            weights[0]                              = kVruntimeScale;
+            for (u8 level = 1; level < kNumPriorities; ++level) {
+                weights[level] = weights[level - 1] * 1.25;
+            }
+            return weights;
+        }();
+
+    // ------------------------------
+    // Class creation
+    // ------------------------------
+
+    MLFQPolicy()  = default;
+    ~MLFQPolicy() = default;
+
+    // ------------------------------
+    // Class interaction
+    // ------------------------------
+
+    NODISCARD Thread *PickNextTask()
+    {
+        for (size_t i = 0; i < kNumLevels; ++i) {
+            if (!queues_[i].IsEmpty()) {
+                return queues_[i].DeleteMin();
+            }
+        }
+
+        return nullptr;
+    }
+
+    void AddTask(Thread *thread)
+    {
+        ASSERT_NOT_NULL(thread);
+        ASSERT_EQ(thread->state, ThreadState::kReady);
+
+        thread->HookT::key = min_vruntime_;
+
+        thread->flags.priority = 0;
+        queues_[0].Insert(thread);
+    }
+
+    NODISCARD u64 GetPreemptTime(Thread *thread)
+    {
+        ASSERT_NOT_NULL(thread);
+
+        const u64 slice_ns = GetTimeSliceForLevel(thread->flags.priority);
+        if (thread->state != ThreadState::kRunning) {
+            // Thread is not running, return full slice for its level
+            return slice_ns;
+        }
+
+        // Thread is running, calculate remaining time in slice
+        const u64 cpu_time_ns = thread->CalculateCpuTime();
+
+        if (cpu_time_ns >= slice_ns) {
+            OnThreadQuantumExpired(thread);
+            return 0;
+        }
+
+        return slice_ns - cpu_time_ns;
+    }
+
+    NODISCARD bool IsFirstHigherPriority(Thread *first, Thread *second)
+    {
+        ASSERT_NOT_NULL(first);
+        ASSERT_NOT_NULL(second);
+
+        const u8 first_level  = first->flags.priority;
+        const u8 second_level = second->flags.priority;
+
+        if (first_level != second_level) {
+            return first_level < second_level;
+        }
+
+        // Compare by vruntime if same level
+        return first->HookT::key < second->HookT::key;
+    }
+
+    NODISCARD bool ValidateThreadFlags(const ThreadFlags *) { return false; }
+
+    void OnThreadYield(Thread *thread)
+    {
+        ASSERT_NOT_NULL(thread);
+
+        if (thread->flags.priority > 0) {
+            // Move up one level
+            --thread->flags.priority;
+        }
+
+        // Update vruntime based on time used (scaled by priority level)
+        const u64 time_used_ns = thread->CalculateCpuTime();
+        UpdateVruntime(thread, time_used_ns);
+    }
+
+    void OnThreadQuantumExpired(Thread *thread)
+    {
+        const u8 current_level = thread->flags.priority;
+
+        // Demote to lower priority if not already at lowest level
+        if (current_level < kNumLevels - 1) {
+            ++thread->flags.priority;
+        }
+
+        // Update vruntime based on full slice used
+        const u64 quantum_ns = GetTimeSliceForLevel(current_level);
+        UpdateVruntime(thread, quantum_ns);
+    }
+
+    void OnPeriodicUpdate(u64 current_time_ns)
+    {
+        ASSERT(current_time_ns >= last_boost_time_ns_);
+
+        if (current_time_ns - last_boost_time_ns_ >= kBoostIntervalNs) {
+            last_boost_time_ns_ = current_time_ns;
+
+            // Move all threads from all queues to the highest priority queue
+            for (u8 level = 1; level < kNumLevels; ++level) {
+                while (!queues_[level].IsEmpty()) {
+                    auto *thread           = queues_[level].DeleteMin();
+                    thread->flags.priority = 0;
+                    queues_[0].Insert(thread);
+                }
+            }
+        }
+    }
+
+    // ------------------------------
+    // Private methods
+    // ------------------------------
+
+    private:
+    NODISCARD FAST_CALL constexpr u64 GetTimeSliceForLevel(u8 level)
+    {
+        return kBaseTimeSliceNs * (1ULL << level);
+    }
+
+    FORCE_INLINE_F void UpdateVruntime(Thread *thread, u64 delta_ns)
+    {
+        ASSERT_NOT_NULL(thread);
+
+        thread->HookT::key += delta_ns * kWeights[static_cast<size_t>(UserPriority::kMedium)] /
+                              kWeights[static_cast<size_t>(thread->flags.user_priority)];
+
+        if (thread->HookT::key < min_vruntime_ || min_vruntime_ == 0) {
+            min_vruntime_ = thread->HookT::key;
+        }
+    }
+
+    // ------------------------------
+    // Class fields
+    // ------------------------------
+
+    data_structures::IntrusiveRBTree<Thread, u64, 1> queues_[kNumLevels];
+    using HookT = data_structures::IntrusiveRBTree<Thread, u64, 1>::HookT;
+
+    u64 last_boost_time_ns_{0};
+    u64 min_vruntime_{0};
+};
+
+}  // namespace Sched
+
+#endif  // KERNEL_SRC_SCHEDULING_POLICIES_MLFQ_POLICY_HPP_
diff --git a/kernel/src/scheduling/policies/round_robin_policy.hpp b/kernel/src/scheduling/policies/round_robin_policy.hpp
index 8b423cf1..d0cb540c 100644
--- a/kernel/src/scheduling/policies/round_robin_policy.hpp
+++ b/kernel/src/scheduling/policies/round_robin_policy.hpp
@@ -29,6 +29,7 @@ class RoundRobinPolicy : public PolicyImpl
 
     FORCE_INLINE_F void AddTask(Thread *thread)
     {
+        ASSERT_NOT_NULL(thread);
         ASSERT_EQ(thread->state, ThreadState::kReady);
         threads_.PushBack(thread);
     }
diff --git a/kernel/src/scheduling/policy.hpp b/kernel/src/scheduling/policy.hpp
index 85670611..3f9fd301 100644
--- a/kernel/src/scheduling/policy.hpp
+++ b/kernel/src/scheduling/policy.hpp
@@ -19,7 +19,7 @@ enum class SchedulingPolicy : u8 {
     kUberTask_PQ_P0 = 0,
     kDrivers_PQ_P1,
     kUrgentTasks_PQ_P2,
-    kNormalTasks_RR_P3,
+    kNormalTasks_MLFQ_P3,
     kBackgroundTasks_RR_P4,
     kLast,
 };
@@ -35,6 +35,8 @@ struct Policy {
         u64 (*get_preempt_time)(void *, Thread *);
         bool (*is_first_higher_priority)(void *, Thread *, Thread *);
         bool (*validate_flags)(void *, const ThreadFlags *);
+        void (*on_thread_yield)(void *, Thread *);
+        void (*on_periodic_update)(void *, u64 current_time_ns);
     } cbs;
     void *self;
 };
@@ -49,6 +51,10 @@ struct PolicyImpl {
     NODISCARD u64 GetPreemptTime(Thread *) { R_FAIL_ALWAYS("NOT_IMPLEMENTED"); }
     NODISCARD bool IsFirstHigherPriority(Thread *, Thread *) { R_FAIL_ALWAYS("NOT_IMPLEMENTED"); }
     NODISCARD bool ValidateThreadFlags(const ThreadFlags *) { R_FAIL_ALWAYS("NOT_IMPLEMENTED"); }
+
+    // Event callbacks
+    void OnThreadYield(Thread *) {}
+    void OnPeriodicUpdate(u64) {}
 };
 
 template <class T>
@@ -91,6 +97,22 @@ bool ValidateThreadFlagsImpl(void *self, const ThreadFlags *flags)
     return rr->ValidateThreadFlags(flags);
 }
 
+template <class T>
+    requires std::derived_from<T, PolicyImpl>
+void OnThreadYieldImpl(void *self, Thread *thread)
+{
+    const auto policy = static_cast<T *>(self);
+    policy->OnThreadYield(thread);
+}
+
+template <class T>
+    requires std::derived_from<T, PolicyImpl>
+void OnPeriodicUpdateImpl(void *self, u64 current_time_ns)
+{
+    const auto policy = static_cast<T *>(self);
+    policy->OnPeriodicUpdate(current_time_ns);
+}
+
 template <class T>
     requires std::derived_from<T, PolicyImpl>
 NODISCARD FAST_CALL Policy PreparePolicy(T *self)
@@ -103,6 +125,8 @@ NODISCARD FAST_CALL Policy PreparePolicy(T *self)
     policy.cbs.get_preempt_time         = GetPreemptTimeImpl<T>;
     policy.cbs.is_first_higher_priority = IsFirstHigherPriorityImpl<T>;
     policy.cbs.validate_flags           = ValidateThreadFlagsImpl<T>;
+    policy.cbs.on_thread_yield          = OnThreadYieldImpl<T>;
+    policy.cbs.on_periodic_update       = OnPeriodicUpdateImpl<T>;
 
     return policy;
 }
diff --git a/kernel/src/scheduling/scheduler.cpp b/kernel/src/scheduling/scheduler.cpp
index 7ab722e0..815538dd 100644
--- a/kernel/src/scheduling/scheduler.cpp
+++ b/kernel/src/scheduling/scheduler.cpp
@@ -29,8 +29,8 @@ Scheduler::Scheduler()
         PreparePolicy<PriorityQueuePolicy>(&policy1_);
     policies_[static_cast<size_t>(SchedulingPolicy::kUrgentTasks_PQ_P2)] =
         PreparePolicy<PriorityQueuePolicy>(&policy2_);
-    policies_[static_cast<size_t>(SchedulingPolicy::kNormalTasks_RR_P3)] =
-        PreparePolicy<RoundRobinPolicy>(&policy3_);
+    policies_[static_cast<size_t>(SchedulingPolicy::kNormalTasks_MLFQ_P3)] =
+        PreparePolicy<MLFQPolicy>(&policy3_);
     policies_[static_cast<size_t>(SchedulingPolicy::kBackgroundTasks_RR_P4)] =
         PreparePolicy<RoundRobinPolicy>(&policy4_);
 }
@@ -47,6 +47,8 @@ void Scheduler::InstallInterruptHandler()
 
 void Scheduler::AddReadyThread(Thread *thread)
 {
+    ASSERT_NOT_NULL(thread);
+
     ASSERT_EQ(thread->state, ThreadState::kReady);
 
     const auto idx = static_cast<size_t>(thread->flags.policy);
@@ -68,7 +70,6 @@ Thread *Scheduler::Schedule()
         }
     }
 
-    // TODO: IDLE
     return nullptr;
 }
 
@@ -82,27 +83,42 @@ Thread *Scheduler::ScheduleAndUpdateThreads(const bool preempt, const ThreadStat
     // 2. Check for sleepers time
     const u64 time = TimingModule::Get().GetSystemTime().ReadLifeTimeNs();
     if (!sleep_queue_.IsEmpty()) {
-        min_time_ns = sleep_queue_.Min()->key - time;
+        min_time_ns = sleep_queue_.Min()->HookT::key - time;
     }
 
     // 3. Scheduling new thread if needed and update structs
     Thread *thread{};
     u64 preempt_time_ns = GetPreemptTime_(hardware::GetCoreLocalTcb());
     if (preempt || force_preempt || ShouldPreempt_(preempt_time_ns)) {
-        const auto next_thread = Schedule();
-        ASSERT_EQ(next_thread->state, ThreadState::kReady);
-        preempt_time_ns    = GetPreemptTime_(next_thread);
-        next_thread->state = ThreadState::kRunning;
-
-        ASSERT_NOT_NULL(hardware::GetCoreLocalTcb());
-        ASSERT_EQ(hardware::GetCoreLocalTcb()->state, ThreadState::kRunning);
-        hardware::GetCoreLocalTcb()->state = thread_state;
-
-        if (thread_state == ThreadState::kReady) {
-            AddReadyThread(hardware::GetCoreLocalTcb());
+        auto next_thread = Schedule();
+
+        if (!next_thread && thread_state == ThreadState::kReady) {
+            // Prevent preemption as we are only one running thread...
+            hardware::GetCoreLocalTcb()->state = ThreadState::kReady;
+            preempt_time_ns                    = GetPreemptTime_(hardware::GetCoreLocalTcb());
+            hardware::GetCoreLocalTcb()->state = ThreadState::kRunning;
+        } else {
+            if (!next_thread) {
+                // We are blocking current thread so we have no threads to scheduler -> idle
+                next_thread = Idle();
+            }
+
+            ASSERT_NOT_NULL(next_thread);
+
+            ASSERT_EQ(next_thread->state, ThreadState::kReady);
+            preempt_time_ns    = GetPreemptTime_(next_thread);
+            next_thread->state = ThreadState::kRunning;
+
+            ASSERT_NOT_NULL(hardware::GetCoreLocalTcb());
+            ASSERT_EQ(hardware::GetCoreLocalTcb()->state, ThreadState::kRunning);
+            hardware::GetCoreLocalTcb()->state = thread_state;
+
+            if (thread_state == ThreadState::kReady) {
+                AddReadyThread(hardware::GetCoreLocalTcb());
+            }
+
+            thread = next_thread;
         }
-
-        thread = next_thread;
     }
 
     // 4. Check with preempt time
@@ -119,7 +135,16 @@ Thread *Scheduler::ScheduleAndUpdateThreads(const bool preempt, const ThreadStat
 void Scheduler::Yield()
 {
     LocalCoreLock lock{};
-    hal::ContextSwitch(ScheduleAndUpdateThreads(true, ThreadState::kReady));
+
+    // Notify policy that thread is voluntarily yielding
+    OnThreadYield_(hardware::GetCoreLocalTcb());
+
+    const auto thread = ScheduleAndUpdateThreads(true, ThreadState::kReady);
+    if (thread == nullptr) {
+        return;
+    }
+
+    hal::ContextSwitch(thread);
 }
 
 void Scheduler::ExitThreadUnguarded(const ThreadState state)
@@ -140,6 +165,9 @@ void Scheduler::ConvertToScheduling()
     event_clock.cbs.set_oneshot(&event_clock);
 
     const auto thread = Schedule();
+    ASSERT_NOT_NULL(thread);
+    TODO_WHEN_MULTICORE
+
     ASSERT_EQ(thread->state, ThreadState::kReady);
 
     const u64 preempt_time_ns = GetPreemptTime_(thread);
@@ -152,6 +180,8 @@ void Scheduler::ConvertToScheduling()
     hal::ConvertContext(thread);
 }
 
+Thread *Scheduler::Idle() { R_FAIL_ALWAYS("IDLE NOT IMPLEMENTED!"); }
+
 void Scheduler::NanoSleepUntil(const u64 systime_ns)
 {
     u64 time;
@@ -173,9 +203,12 @@ void Scheduler::NanoSleepUntil(const u64 systime_ns)
     {
         LocalCoreLock lock{};
 
-        hardware::GetCoreLocalTcb()->key = systime_ns;
+        hardware::GetCoreLocalTcb()->HookT::key = systime_ns;
         sleep_queue_.Insert(hardware::GetCoreLocalTcb());
 
+        // Notify policy that thread is going to sleep
+        OnThreadYield_(hardware::GetCoreLocalTcb());
+
         hal::ContextSwitch(ScheduleAndUpdateThreads(true, ThreadState::kSleeping));
     }
 }
@@ -193,7 +226,7 @@ void Scheduler::NanoSleepUntilUnguarded(const u64 systime_ns)
         }
         return;
     }
-    hardware::GetCoreLocalTcb()->key = systime_ns;
+    hardware::GetCoreLocalTcb()->HookT::key = systime_ns;
     sleep_queue_.Insert(hardware::GetCoreLocalTcb());
 
     hal::ContextSwitch(ScheduleAndUpdateThreads(true, ThreadState::kSleeping));
@@ -214,13 +247,15 @@ bool Scheduler::WakeUpTasks()
     bool should_preempt = false;
     while (!sleep_queue_.IsEmpty()) {
         const u64 time       = TimingModule::Get().GetSystemTime().ReadLifeTimeNs();
-        const u64 sleep_time = sleep_queue_.Min()->key;
+        const u64 sleep_time = sleep_queue_.Min()->HookT::key;
 
-        if (sleep_time > time && sleep_time - time > kMinDelta) {
+        if (sleep_time > time && sleep_time - time > 2 * kMinDelta) {
             break;
         }
 
         const auto thread = sleep_queue_.Min();
+        ASSERT_NOT_NULL(thread);
+
         should_preempt |= IsFirstHigherPriority_(thread, hardware::GetCoreLocalTcb());
 
         sleep_queue_.Delete(thread);
@@ -240,6 +275,9 @@ Thread *Scheduler::TimerRoutine()
         return nullptr;
     }
 
+    // Notify all policies of periodic update
+    OnPeriodicUpdate_(hardware::GetCoreLocalTcb());
+
     // TODO: Idle
     return ScheduleAndUpdateThreads(false, ThreadState::kReady);
 }
diff --git a/kernel/src/scheduling/scheduler.hpp b/kernel/src/scheduling/scheduler.hpp
index 13391f19..373c02e0 100644
--- a/kernel/src/scheduling/scheduler.hpp
+++ b/kernel/src/scheduling/scheduler.hpp
@@ -12,6 +12,8 @@
 #include "hal/scheduling.hpp"
 #include "hal/spinlock.hpp"
 #include "hardware/core_local.hpp"
+#include "modules/timing.hpp"
+#include "policies/mlfq_policy.hpp"
 #include "policies/priority_queue_policy.hpp"
 #include "policies/round_robin_policy.hpp"
 
@@ -20,7 +22,7 @@ namespace Sched
 
 class Scheduler
 {
-    static constexpr u64 kMinDelta = 2'000;
+    static constexpr u64 kMinDelta = 3'000;
 
     public:
     // ------------------------------
@@ -38,9 +40,9 @@ class Scheduler
 
     void AddReadyThread(Thread *thread);
 
-    Thread *Schedule();
+    NODISCARD Thread *Schedule();
 
-    Thread *ScheduleAndUpdateThreads(bool preempt, ThreadState thread_state);
+    NODISCARD Thread *ScheduleAndUpdateThreads(bool preempt, ThreadState thread_state);
 
     void Yield();
 
@@ -59,6 +61,8 @@ class Scheduler
         return policy.cbs.validate_flags(policy.self, &flags);
     }
 
+    NODISCARD Thread *Idle();
+
     // ------------------------------
     // Syscalls
     // ------------------------------
@@ -111,6 +115,23 @@ class Scheduler
         return first->flags.policy > second->flags.policy;
     }
 
+    FORCE_INLINE_F void OnThreadYield_(Thread *thread) const
+    {
+        const auto &policy = GetPolicy_(thread);
+        if (policy.cbs.on_thread_yield != nullptr) {
+            policy.cbs.on_thread_yield(policy.self, thread);
+        }
+    }
+
+    FORCE_INLINE_F void OnPeriodicUpdate_(Thread *thread) const
+    {
+        const u64 time     = TimingModule::Get().GetSystemTime().ReadLifeTimeNs();
+        const auto &policy = GetPolicy_(thread);
+        if (policy.cbs.on_periodic_update != nullptr) {
+            policy.cbs.on_periodic_update(policy.self, time);
+        }
+    }
+
     NODISCARD FAST_CALL bool ShouldPreempt_(const u64 preempt_time_ns)
     {
         return preempt_time_ns == 0 || preempt_time_ns < kMinDelta;
@@ -121,7 +142,8 @@ class Scheduler
     // ------------------------------
 
     // Sleeping queue
-    data_structures::IntrusiveRBTree<Thread, u64> sleep_queue_{};
+    data_structures::IntrusiveRBTree<Thread, u64, 0> sleep_queue_{};
+    using HookT = data_structures::IntrusiveRBTree<Thread, u64, 0>::HookT;
 
     // Locking
     hal::Spinlock spinlock_{};
@@ -130,7 +152,7 @@ class Scheduler
     PriorityQueuePolicy policy0_{};  // kUberTask_PQ_P0
     PriorityQueuePolicy policy1_{};  // kDrivers_PQ_P1
     PriorityQueuePolicy policy2_{};  // kUrgentTasks_PQ_P2
-    RoundRobinPolicy policy3_{};     // kNormalTasks_RR_P3
+    MLFQPolicy policy3_{};           // kNormalTasks_MLFQ_P3
     RoundRobinPolicy policy4_{};     // kBackgroundTasks_RR_P4
 
     // Abstraction
diff --git a/kernel/src/scheduling/task_mgr.cpp b/kernel/src/scheduling/task_mgr.cpp
index 309c5e78..2803f900 100644
--- a/kernel/src/scheduling/task_mgr.cpp
+++ b/kernel/src/scheduling/task_mgr.cpp
@@ -33,7 +33,7 @@ void TaskMgr::InitializeMultitasking()
     R_ASSERT_TRUE(static_cast<bool>(result), "Failed to spawn trace dumper process...");
 
     // Spawn 3 Kernel Workers
-    static constexpr size_t kNumKWorkers = 3;
+    static constexpr size_t kNumKWorkers = 0;
     for (size_t i = 0; i < kNumKWorkers; ++i) {
         char name[] = "kworker-0";
 
@@ -105,8 +105,9 @@ std::expected<Thread *, Error> TaskMgr::SpawnThread(const Pid pid, const Task &t
     ThreadFlags flags{};
 
     flags.preserve_floats = process.value()->flags.PreserveFloats;
-    flags.policy          = SchedulingPolicy::kNormalTasks_RR_P3;
+    flags.policy          = SchedulingPolicy::kNormalTasks_MLFQ_P3;
     flags.priority        = 0;
+    flags.user_priority   = UserPriority::kMedium;
 
     return SpawnThread(process.value(), flags, task);
 }
@@ -321,6 +322,7 @@ std::expected<void, Error> TaskMgr::DetachThread(const Tid tid)
 void TaskMgr::ThreadExit(void *retval)
 {
     const auto tcb = hardware::GetCoreLocalTcb();
+    ASSERT_NOT_NULL(tcb);
     ASSERT_EQ(tcb->state, ThreadState::kRunning);
 
     tcb->retval = retval;
@@ -339,6 +341,7 @@ void TaskMgr::ThreadExit(void *retval)
 std::expected<void *, Error> TaskMgr::JoinThread(const Tid tid)
 {
     const auto tcb = hardware::GetCoreLocalTcb();
+    ASSERT_NOT_NULL(tcb);
     ASSERT_EQ(tcb->state, ThreadState::kRunning);
 
     if (tcb->tid == tid) {
diff --git a/kernel/src/scheduling/thread.cpp b/kernel/src/scheduling/thread.cpp
index e150dbea..c7742521 100644
--- a/kernel/src/scheduling/thread.cpp
+++ b/kernel/src/scheduling/thread.cpp
@@ -10,6 +10,6 @@ u64 Thread::CalculateCpuTime()
     const u64 time = TimingModule::Get().GetSystemTime().ReadLifeTimeNs();
     kernel_time_ns += (time - timestamp);
 
-    return kernel_time_ns + user_time_ns;
+    return (kernel_time_ns + user_time_ns) - (time - timestamp_execution_start_ns);
 }
 }  // namespace Sched
diff --git a/kernel/src/scheduling/thread.hpp b/kernel/src/scheduling/thread.hpp
index 16452f04..d18119fa 100644
--- a/kernel/src/scheduling/thread.hpp
+++ b/kernel/src/scheduling/thread.hpp
@@ -29,6 +29,8 @@ struct Task {
 // Thread
 // ------------------------------
 
+enum class UserPriority : u8 { kLow = 0, kMediumLow, kMedium, kMediumHigh, kHigh, kLast };
+
 struct PACK Tid {
     u16 id;
     u64 count : 48;
@@ -39,9 +41,10 @@ struct PACK Tid {
 struct PACK ThreadFlags {
     SchedulingPolicy policy : 8;
     u8 priority : 8;
+    UserPriority user_priority : 3;
     bool preserve_floats : 1;
     bool detached : 1;
-    u64 padding : 46;
+    u64 padding : 43;
 };
 static_assert(sizeof(ThreadFlags) == 8);
 
@@ -55,7 +58,8 @@ enum class ThreadState : u64 {
 };
 static_assert(sizeof(ThreadState) == sizeof(u64));
 
-struct Thread : data_structures::IntrusiveRbNode<Thread, u64>,
+struct Thread : data_structures::IntrusiveRbNode<Thread, u64, 0>,
+                data_structures::IntrusiveRbNode<Thread, u64, 1>,
                 data_structures::IntrusiveListNode<Thread> {
     /* Management */
     Tid tid;
@@ -74,10 +78,10 @@ struct Thread : data_structures::IntrusiveRbNode<Thread, u64>,
     u64 kernel_time_ns;
     u64 user_time_ns;
     u64 timestamp;
+    u64 timestamp_execution_start_ns;
     u64 num_interrupts;
     u64 num_syscalls;
     u64 num_context_switches;
-    u64 padding0;
 
     /* Arch */
     hal::Thread arch_data;
diff --git a/kernel/src/scheduling/threads.cpp b/kernel/src/scheduling/threads.cpp
index a2c45032..6e5df5cb 100644
--- a/kernel/src/scheduling/threads.cpp
+++ b/kernel/src/scheduling/threads.cpp
@@ -99,7 +99,8 @@ void UpdateTcbOnInterruptExit(Thread *thread)
 
     if (thread) {
         /* Context Switch occurs */
-        thread->timestamp = t;
+        thread->timestamp                    = t;
+        thread->timestamp_execution_start_ns = t;
 
         ASSERT_EQ(current_thread->state, ThreadState::kReady);
         ASSERT_EQ(thread->state, ThreadState::kRunning);
diff --git a/kernel/src/syscalls/calls/thread.hpp b/kernel/src/syscalls/calls/thread.hpp
index 4116bd31..c8f521ac 100644
--- a/kernel/src/syscalls/calls/thread.hpp
+++ b/kernel/src/syscalls/calls/thread.hpp
@@ -20,7 +20,7 @@ FAST_CALL int SysThreadCreate(Thread *thread, thread_func_t func, void *arg)
     flags.priority        = thread->flags.priority;
     flags.preserve_floats = thread->flags.preserve_floats;
 
-    if (flags.policy < Sched::SchedulingPolicy::kNormalTasks_RR_P3) {
+    if (flags.policy < Sched::SchedulingPolicy::kNormalTasks_MLFQ_P3) {
         return -1;  // User may only spawn normal and background tasks
     }
 
@@ -81,6 +81,7 @@ FAST_CALL void SysNanoSleepUntil(const u64 systime_ns)
 
 FAST_CALL void SysNanoSleep(const u64 time_ns)
 {
+    // TODO: NO CORRECTION FROM KERNEL SPACE
     static constexpr u64 kSyscallCorrection = 200;
     SysNanoSleepUntil(
         TimingModule::Get().GetSystemTime().ReadLifeTimeNs() + time_ns - kSyscallCorrection
diff --git a/kernel/src/syscalls/calls/video.hpp b/kernel/src/syscalls/calls/video.hpp
index c10093b5..c5cd44bb 100644
--- a/kernel/src/syscalls/calls/video.hpp
+++ b/kernel/src/syscalls/calls/video.hpp
@@ -59,7 +59,7 @@ FORCE_INLINE_F void SysBlit()
     auto &wm = VideoModule::Get().GetWindowManager();
     auto pid = hardware::GetRunningPid();
 
-    DEBUG_INFO_GENERAL("SysBlit called by PID: %llu", pid);
+    DEBUG_FREQ_INFO_GENERAL("SysBlit called by PID: %llu", pid);
     wm.Blit(pid);
 }
 
diff --git a/kernel/src/video/window_manager.cpp b/kernel/src/video/window_manager.cpp
index d327b7c7..d36f73da 100644
--- a/kernel/src/video/window_manager.cpp
+++ b/kernel/src/video/window_manager.cpp
@@ -136,14 +136,10 @@ void WindowManager::Blit(Sched::Pid pid)
     auto [session, target_idx] = FindSession(pid);
 
     if (!session) {
-        DEBUG_INFO_GENERAL("Blit skipped: No session for PID %llu", pid);
         return;
     }
 
     if (active_session_idx_ != target_idx) {
-        DEBUG_INFO_GENERAL(
-            "Blit skipped: Target %zu != Active %zu", target_idx, active_session_idx_
-        );
         // If not active, the data is safely sitting in the session.phys_buffer (RAM),
         // ready to be restored when the user switches back.
         return;
diff --git a/kernel/test/manual_tests.cpp b/kernel/test/manual_tests.cpp
index 9ca6f0ae..2df699d3 100644
--- a/kernel/test/manual_tests.cpp
+++ b/kernel/test/manual_tests.cpp
@@ -31,6 +31,8 @@ static void Task0()
         const auto tcb = hardware::GetCoreLocalTcb();
         HardwareModule::Get().GetInterrupts().BlockHardwareInterrupts();
         trace::DumpAllBuffersOnFailure();
+        tcb->state       = Sched::ThreadState::kReady;
+        tcb->next->state = Sched::ThreadState::kRunning;
         hal::ContextSwitch(tcb->next);
     }
 }
@@ -52,6 +54,9 @@ static void Task1()
 
         HardwareModule::Get().GetInterrupts().BlockHardwareInterrupts();
         trace::DumpAllBuffersOnFailure();
+
+        tcb->state       = Sched::ThreadState::kReady;
+        tcb->next->state = Sched::ThreadState::kRunning;
         hal::ContextSwitch(tcb->next);
     }
 }
@@ -83,5 +88,7 @@ MTEST(KernelTaskSwitchTest)
     t1.value()->next = t0.value();
 
     HardwareModule::Get().GetInterrupts().BlockHardwareInterrupts();
+
+    t0.value()->state = Sched::ThreadState::kRunning;
     hal::ConvertContext(t0.value());
 }
diff --git a/kernel/test/rb_test.cpp b/kernel/test/rb_test.cpp
index 8219c599..495191be 100644
--- a/kernel/test/rb_test.cpp
+++ b/kernel/test/rb_test.cpp
@@ -8,7 +8,7 @@
 namespace data_structures::test
 {
 
-struct TestNode : IntrusiveRbNode<TestNode, int>, IntrusiveListNode<TestNode> {
+struct TestNode : IntrusiveRbNode<TestNode, int, 0>, IntrusiveListNode<TestNode> {
     TestNode *tracking_next = nullptr;
     TestNode *tracking_prev = nullptr;
 
@@ -32,7 +32,7 @@ struct TestNode : IntrusiveRbNode<TestNode, int>, IntrusiveListNode<TestNode> {
 class IntrusiveRBTreeTest : public TestGroupBase
 {
     public:
-    using TreeType = IntrusiveRBTree<TestNode, int>;
+    using TreeType = IntrusiveRBTree<TestNode, int, 0>;
 
     TreeType tree{};
     TestNode *tracking_head = nullptr;
diff --git a/libs/libcontainers/include/data_structures/maps/intrusive_rb_tree.hpp b/libs/libcontainers/include/data_structures/maps/intrusive_rb_tree.hpp
index ee2e21eb..b0d52c86 100644
--- a/libs/libcontainers/include/data_structures/maps/intrusive_rb_tree.hpp
+++ b/libs/libcontainers/include/data_structures/maps/intrusive_rb_tree.hpp
@@ -10,7 +10,7 @@
 
 namespace data_structures
 {
-template <class T, class KeyT>
+template <class T, class KeyT, int kIntrusiveLevel>
 struct IntrusiveRbNode {
     enum class Color : u8 {
         kBlack = 0,
@@ -29,18 +29,20 @@ struct IntrusiveRbNode {
     Color color;
     KeyT key;
 };
-static_assert(sizeof(IntrusiveRbNode<u64, u64>) == 5 * 8);
+static_assert(sizeof(IntrusiveRbNode<u64, u64, 0>) == 5 * 8);
 
-template <class T, class KeyT>
+template <class T, class KeyT, int kIntrusiveLevel>
     requires(
-        std::derived_from<T, IntrusiveRbNode<T, KeyT>> and
+        std::derived_from<T, IntrusiveRbNode<T, KeyT, kIntrusiveLevel>> and
         std::derived_from<T, IntrusiveListNode<T>>
     )
 class IntrusiveRBTree : template_lib::NoCopy
 {
-    using Color = typename IntrusiveRbNode<T, KeyT>::Color;
+    using Color = typename IntrusiveRbNode<T, KeyT, kIntrusiveLevel>::Color;
 
     public:
+    using HookT = IntrusiveRbNode<T, KeyT, kIntrusiveLevel>;
+
     // ------------------------------
     // Class creation
     // ------------------------------
@@ -60,14 +62,14 @@ class IntrusiveRBTree : template_lib::NoCopy
     {
         ASSERT_NOT_NULL(item);
 
-        item->left   = nullptr;
-        item->right  = nullptr;
-        item->parent = nullptr;
-        item->color  = Color::kRed;
-        item->next   = nullptr;
+        item->HookT::left   = nullptr;
+        item->HookT::right  = nullptr;
+        item->HookT::parent = nullptr;
+        item->HookT::color  = Color::kRed;
+        item->next          = nullptr;
 
         // 1. Check if key already exists
-        T *existing = Find(item->key);
+        T *existing = Find(item->HookT::key);
         if (existing != nullptr) {
             item->next     = existing->next;
             existing->next = item;
@@ -80,27 +82,27 @@ class IntrusiveRBTree : template_lib::NoCopy
 
         while (x != nullptr) {
             y = x;
-            if (item->key < x->key) {
-                x = x->left;
+            if (item->HookT::key < x->HookT::key) {
+                x = x->HookT::left;
             } else {
-                x = x->right;
+                x = x->HookT::right;
             }
         }
 
-        item->parent = y;
+        item->HookT::parent = y;
 
         if (y == nullptr) {
             root_ = item;
-        } else if (item->key < y->key) {
-            y->left = item;
+        } else if (item->HookT::key < y->HookT::key) {
+            y->HookT::left = item;
         } else {
-            y->right = item;
+            y->HookT::right = item;
         }
 
-        if (min_ == nullptr || item->key < min_->key) {
+        if (min_ == nullptr || item->HookT::key < min_->HookT::key) {
             min_ = item;
         }
-        if (max_ == nullptr || item->key > max_->key) {
+        if (max_ == nullptr || item->HookT::key > max_->HookT::key) {
             max_ = item;
         }
 
@@ -113,7 +115,7 @@ class IntrusiveRBTree : template_lib::NoCopy
 
         // Case A: The item is NOT part of the RB tree structure,
 
-        T *node_in_tree = Find(item->key);
+        T *node_in_tree = Find(item->HookT::key);
         if (node_in_tree == nullptr) {
             return;
         }
@@ -154,7 +156,7 @@ class IntrusiveRBTree : template_lib::NoCopy
     {
         ASSERT_NOT_NULL(item);
 
-        T *found = Find(item->key);
+        T *found = Find(item->HookT::key);
         if (!found) {
             return false;
         }
@@ -179,17 +181,31 @@ class IntrusiveRBTree : template_lib::NoCopy
     {
         T *current = root_;
         while (current != nullptr) {
-            if (key == current->key) {
+            if (key == current->HookT::key) {
                 return current;
-            } else if (key < current->key) {
-                current = current->left;
+            } else if (key < current->HookT::key) {
+                current = current->HookT::left;
             } else {
-                current = current->right;
+                current = current->HookT::right;
             }
         }
         return nullptr;
     }
 
+    NODISCARD FORCE_INLINE_F T *DeleteMin()
+    {
+        T *min_node = Min();
+        Delete(min_node);
+        return min_node;
+    }
+
+    NODISCARD FORCE_INLINE_F T *DeleteMax()
+    {
+        T *max_node = Max();
+        Delete(max_node);
+        return max_node;
+    }
+
     // ------------------------------
     // Private methods
     // ------------------------------
@@ -204,11 +220,11 @@ class IntrusiveRBTree : template_lib::NoCopy
         }
 
         T *curr = root_;
-        while (curr->left) curr = curr->left;
+        while (curr->HookT::left) curr = curr->HookT::left;
         min_ = curr;
 
         curr = root_;
-        while (curr->right) curr = curr->right;
+        while (curr->HookT::right) curr = curr->HookT::right;
         max_ = curr;
     }
 
@@ -218,26 +234,26 @@ class IntrusiveRBTree : template_lib::NoCopy
         ASSERT_NOT_NULL(replacement);
 
         // Copy RB properties
-        replacement->parent = item->parent;
-        replacement->left   = item->left;
-        replacement->right  = item->right;
-        replacement->color  = item->color;
+        replacement->HookT::parent = item->HookT::parent;
+        replacement->HookT::left   = item->HookT::left;
+        replacement->HookT::right  = item->HookT::right;
+        replacement->HookT::color  = item->HookT::color;
 
         // Update parent's child pointer
-        if (item->parent == nullptr) {
+        if (item->HookT::parent == nullptr) {
             root_ = replacement;
-        } else if (item == item->parent->left) {
-            item->parent->left = replacement;
+        } else if (item == item->HookT::parent->HookT::left) {
+            item->HookT::parent->HookT::left = replacement;
         } else {
-            item->parent->right = replacement;
+            item->HookT::parent->HookT::right = replacement;
         }
 
         // Update children's parent pointer
-        if (item->left) {
-            item->left->parent = replacement;
+        if (item->HookT::left) {
+            item->HookT::left->HookT::parent = replacement;
         }
-        if (item->right) {
-            item->right->parent = replacement;
+        if (item->HookT::right) {
+            item->HookT::right->HookT::parent = replacement;
         }
 
         // Update Cached Min/Max if necessary
@@ -249,122 +265,122 @@ class IntrusiveRBTree : template_lib::NoCopy
         }
 
         // Clear item's pointers
-        item->parent = nullptr;
-        item->left   = nullptr;
-        item->right  = nullptr;
-        item->next   = nullptr;
+        item->HookT::parent = nullptr;
+        item->HookT::left   = nullptr;
+        item->HookT::right  = nullptr;
+        item->next          = nullptr;
     }
 
     void RotateLeft_(T *x)
     {
-        T *y     = x->right;
-        x->right = y->left;
+        T *y            = x->HookT::right;
+        x->HookT::right = y->HookT::left;
 
-        if (y->left != nullptr) {
-            y->left->parent = x;
+        if (y->HookT::left != nullptr) {
+            y->HookT::left->HookT::parent = x;
         }
 
-        y->parent = x->parent;
+        y->HookT::parent = x->HookT::parent;
 
-        if (x->parent == nullptr) {
+        if (x->HookT::parent == nullptr) {
             root_ = y;
-        } else if (x == x->parent->left) {
-            x->parent->left = y;
+        } else if (x == x->HookT::parent->HookT::left) {
+            x->HookT::parent->HookT::left = y;
         } else {
-            x->parent->right = y;
+            x->HookT::parent->HookT::right = y;
         }
 
-        y->left   = x;
-        x->parent = y;
+        y->HookT::left   = x;
+        x->HookT::parent = y;
     }
 
     void RotateRight_(T *x)
     {
-        T *y    = x->left;
-        x->left = y->right;
+        T *y           = x->HookT::left;
+        x->HookT::left = y->HookT::right;
 
-        if (y->right != nullptr) {
-            y->right->parent = x;
+        if (y->HookT::right != nullptr) {
+            y->HookT::right->HookT::parent = x;
         }
 
-        y->parent = x->parent;
+        y->HookT::parent = x->HookT::parent;
 
-        if (x->parent == nullptr) {
+        if (x->HookT::parent == nullptr) {
             root_ = y;
-        } else if (x == x->parent->right) {
-            x->parent->right = y;
+        } else if (x == x->HookT::parent->HookT::right) {
+            x->HookT::parent->HookT::right = y;
         } else {
-            x->parent->left = y;
+            x->HookT::parent->HookT::left = y;
         }
 
-        y->right  = x;
-        x->parent = y;
+        y->HookT::right  = x;
+        x->HookT::parent = y;
     }
 
     void InsertFixup_(T *z)
     {
-        while (z->parent != nullptr && z->parent->color == Color::kRed) {
-            if (z->parent == z->parent->parent->left) {
-                T *y = z->parent->parent->right;  // Uncle
+        while (z->HookT::parent != nullptr && z->HookT::parent->HookT::color == Color::kRed) {
+            if (z->HookT::parent == z->HookT::parent->HookT::parent->HookT::left) {
+                T *y = z->HookT::parent->HookT::parent->HookT::right;  // Uncle
 
-                if (y != nullptr && y->color == Color::kRed) {
+                if (y != nullptr && y->HookT::color == Color::kRed) {
                     // Case 1: Uncle is Red
-                    z->parent->color         = Color::kBlack;
-                    y->color                 = Color::kBlack;
-                    z->parent->parent->color = Color::kRed;
-                    z                        = z->parent->parent;
+                    z->HookT::parent->HookT::color                = Color::kBlack;
+                    y->HookT::color                               = Color::kBlack;
+                    z->HookT::parent->HookT::parent->HookT::color = Color::kRed;
+                    z                                             = z->HookT::parent->HookT::parent;
                 } else {
                     // Case 2: Uncle is Black (Triangle)
-                    if (z == z->parent->right) {
-                        z = z->parent;
+                    if (z == z->HookT::parent->HookT::right) {
+                        z = z->HookT::parent;
                         RotateLeft_(z);
                     }
                     // Case 3: Uncle is Black (Line)
-                    z->parent->color         = Color::kBlack;
-                    z->parent->parent->color = Color::kRed;
-                    RotateRight_(z->parent->parent);
+                    z->HookT::parent->HookT::color                = Color::kBlack;
+                    z->HookT::parent->HookT::parent->HookT::color = Color::kRed;
+                    RotateRight_(z->HookT::parent->HookT::parent);
                 }
             } else {
                 // Symmetric to above
-                T *y = z->parent->parent->left;
+                T *y = z->HookT::parent->HookT::parent->HookT::left;
 
-                if (y != nullptr && y->color == Color::kRed) {
-                    z->parent->color         = Color::kBlack;
-                    y->color                 = Color::kBlack;
-                    z->parent->parent->color = Color::kRed;
-                    z                        = z->parent->parent;
+                if (y != nullptr && y->HookT::color == Color::kRed) {
+                    z->HookT::parent->HookT::color                = Color::kBlack;
+                    y->HookT::color                               = Color::kBlack;
+                    z->HookT::parent->HookT::parent->HookT::color = Color::kRed;
+                    z                                             = z->HookT::parent->HookT::parent;
                 } else {
-                    if (z == z->parent->left) {
-                        z = z->parent;
+                    if (z == z->HookT::parent->HookT::left) {
+                        z = z->HookT::parent;
                         RotateRight_(z);
                     }
-                    z->parent->color         = Color::kBlack;
-                    z->parent->parent->color = Color::kRed;
-                    RotateLeft_(z->parent->parent);
+                    z->HookT::parent->HookT::color                = Color::kBlack;
+                    z->HookT::parent->HookT::parent->HookT::color = Color::kRed;
+                    RotateLeft_(z->HookT::parent->HookT::parent);
                 }
             }
         }
-        root_->color = Color::kBlack;
+        root_->HookT::color = Color::kBlack;
     }
 
     void RBTransplant_(T *u, T *v)
     {
-        if (u->parent == nullptr) {
+        if (u->HookT::parent == nullptr) {
             root_ = v;
-        } else if (u == u->parent->left) {
-            u->parent->left = v;
+        } else if (u == u->HookT::parent->HookT::left) {
+            u->HookT::parent->HookT::left = v;
         } else {
-            u->parent->right = v;
+            u->HookT::parent->HookT::right = v;
         }
         if (v != nullptr) {
-            v->parent = u->parent;
+            v->HookT::parent = u->HookT::parent;
         }
     }
 
     T *TreeMinimum_(T *node)
     {
-        while (node->left != nullptr) {
-            node = node->left;
+        while (node->HookT::left != nullptr) {
+            node = node->HookT::left;
         }
         return node;
     }
@@ -373,45 +389,45 @@ class IntrusiveRBTree : template_lib::NoCopy
     {
         T *y                   = z;
         T *x                   = nullptr;
-        Color y_original_color = y->color;
+        Color y_original_color = y->HookT::color;
 
         T *x_parent = nullptr;
 
-        if (z->left == nullptr) {
-            x        = z->right;
-            x_parent = z->parent;
-            RBTransplant_(z, z->right);
-        } else if (z->right == nullptr) {
-            x        = z->left;
-            x_parent = z->parent;
-            RBTransplant_(z, z->left);
+        if (z->HookT::left == nullptr) {
+            x        = z->HookT::right;
+            x_parent = z->HookT::parent;
+            RBTransplant_(z, z->HookT::right);
+        } else if (z->HookT::right == nullptr) {
+            x        = z->HookT::left;
+            x_parent = z->HookT::parent;
+            RBTransplant_(z, z->HookT::left);
         } else {
-            y                = TreeMinimum_(z->right);
-            y_original_color = y->color;
-            x                = y->right;
+            y                = TreeMinimum_(z->HookT::right);
+            y_original_color = y->HookT::color;
+            x                = y->HookT::right;
 
-            if (y->parent == z) {
+            if (y->HookT::parent == z) {
                 x_parent = y;
             } else {
-                x_parent = y->parent;
-                RBTransplant_(y, y->right);
-                y->right         = z->right;
-                y->right->parent = y;
+                x_parent = y->HookT::parent;
+                RBTransplant_(y, y->HookT::right);
+                y->HookT::right                = z->HookT::right;
+                y->HookT::right->HookT::parent = y;
             }
 
             RBTransplant_(z, y);
-            y->left         = z->left;
-            y->left->parent = y;
-            y->color        = z->color;
+            y->HookT::left                = z->HookT::left;
+            y->HookT::left->HookT::parent = y;
+            y->HookT::color               = z->HookT::color;
         }
 
         if (y_original_color == Color::kBlack) {
             DeleteFixup_(x, x_parent);
         }
 
-        z->parent = nullptr;
-        z->left   = nullptr;
-        z->right  = nullptr;
+        z->HookT::parent = nullptr;
+        z->HookT::left   = nullptr;
+        z->HookT::right  = nullptr;
 
         if (z == min_ || z == max_) {
             RecalculateMinMax_();
@@ -420,65 +436,69 @@ class IntrusiveRBTree : template_lib::NoCopy
 
     void DeleteFixup_(T *x, T *x_parent)
     {
-        while (x != root_ && (x == nullptr || x->color == Color::kBlack)) {
-            if (x == (x_parent ? x_parent->left : nullptr)) {  // x is left child
-                T *w = x_parent->right;                        // Sibling
+        while (x != root_ && (x == nullptr || x->HookT::color == Color::kBlack)) {
+            if (x == (x_parent ? x_parent->HookT::left : nullptr)) {  // x is left child
+                T *w = x_parent->HookT::right;                        // Sibling
 
-                if (w->color == Color::kRed) {
-                    w->color        = Color::kBlack;
-                    x_parent->color = Color::kRed;
+                if (w->HookT::color == Color::kRed) {
+                    w->HookT::color        = Color::kBlack;
+                    x_parent->HookT::color = Color::kRed;
                     RotateLeft_(x_parent);
-                    w = x_parent->right;
+                    w = x_parent->HookT::right;
                 }
 
-                if ((w->left == nullptr || w->left->color == Color::kBlack) &&
-                    (w->right == nullptr || w->right->color == Color::kBlack)) {
-                    w->color = Color::kRed;
-                    x        = x_parent;
-                    x_parent = x ? x->parent : nullptr;
+                if ((w->HookT::left == nullptr || w->HookT::left->HookT::color == Color::kBlack) &&
+                    (w->HookT::right == nullptr ||
+                     w->HookT::right->HookT::color == Color::kBlack)) {
+                    w->HookT::color = Color::kRed;
+                    x               = x_parent;
+                    x_parent        = x ? x->HookT::parent : nullptr;
                 } else {
-                    if (w->right == nullptr || w->right->color == Color::kBlack) {
-                        if (w->left)
-                            w->left->color = Color::kBlack;
-                        w->color = Color::kRed;
+                    if (w->HookT::right == nullptr ||
+                        w->HookT::right->HookT::color == Color::kBlack) {
+                        if (w->HookT::left)
+                            w->HookT::left->HookT::color = Color::kBlack;
+                        w->HookT::color = Color::kRed;
                         RotateRight_(w);
-                        w = x_parent->right;
+                        w = x_parent->HookT::right;
                     }
-                    w->color        = x_parent->color;
-                    x_parent->color = Color::kBlack;
-                    if (w->right)
-                        w->right->color = Color::kBlack;
+                    w->HookT::color        = x_parent->HookT::color;
+                    x_parent->HookT::color = Color::kBlack;
+                    if (w->HookT::right)
+                        w->HookT::right->HookT::color = Color::kBlack;
                     RotateLeft_(x_parent);
                     x        = root_;
                     x_parent = nullptr;
                 }
             } else {  // x is right child (symmetric)
-                T *w = x_parent->left;
+                T *w = x_parent->HookT::left;
 
-                if (w->color == Color::kRed) {
-                    w->color        = Color::kBlack;
-                    x_parent->color = Color::kRed;
+                if (w->HookT::color == Color::kRed) {
+                    w->HookT::color        = Color::kBlack;
+                    x_parent->HookT::color = Color::kRed;
                     RotateRight_(x_parent);
-                    w = x_parent->left;
+                    w = x_parent->HookT::left;
                 }
 
-                if ((w->right == nullptr || w->right->color == Color::kBlack) &&
-                    (w->left == nullptr || w->left->color == Color::kBlack)) {
-                    w->color = Color::kRed;
-                    x        = x_parent;
-                    x_parent = x ? x->parent : nullptr;
+                if ((w->HookT::right == nullptr ||
+                     w->HookT::right->HookT::color == Color::kBlack) &&
+                    (w->HookT::left == nullptr || w->HookT::left->HookT::color == Color::kBlack)) {
+                    w->HookT::color = Color::kRed;
+                    x               = x_parent;
+                    x_parent        = x ? x->HookT::parent : nullptr;
                 } else {
-                    if (w->left == nullptr || w->left->color == Color::kBlack) {
-                        if (w->right)
-                            w->right->color = Color::kBlack;
-                        w->color = Color::kRed;
+                    if (w->HookT::left == nullptr ||
+                        w->HookT::left->HookT::color == Color::kBlack) {
+                        if (w->HookT::right)
+                            w->HookT::right->HookT::color = Color::kBlack;
+                        w->HookT::color = Color::kRed;
                         RotateLeft_(w);
-                        w = x_parent->left;
+                        w = x_parent->HookT::left;
                     }
-                    w->color        = x_parent->color;
-                    x_parent->color = Color::kBlack;
-                    if (w->left)
-                        w->left->color = Color::kBlack;
+                    w->HookT::color        = x_parent->HookT::color;
+                    x_parent->HookT::color = Color::kBlack;
+                    if (w->HookT::left)
+                        w->HookT::left->HookT::color = Color::kBlack;
                     RotateRight_(x_parent);
                     x        = root_;
                     x_parent = nullptr;
@@ -486,7 +506,7 @@ class IntrusiveRBTree : template_lib::NoCopy
             }
         }
         if (x != nullptr) {
-            x->color = Color::kBlack;
+            x->HookT::color = Color::kBlack;
         }
     }
 
diff --git a/userspace/programs/gui_test/main.cpp b/userspace/programs/gui_test/main.cpp
index 09fc99f4..10c8a28e 100644
--- a/userspace/programs/gui_test/main.cpp
+++ b/userspace/programs/gui_test/main.cpp
@@ -1,3 +1,4 @@
+#include <alkos/sys/thread.h>
 #include <alkos/video.h>
 #include <platform.h>
 #include <stdio.h>
@@ -53,6 +54,8 @@ extern "C" int main()
         __platform_blit();
 
         color_offset += 1;
+
+        NanoSleep(16'000'000);
     }
 
     return 0;
diff --git a/userspace/programs/shell/main.cpp b/userspace/programs/shell/main.cpp
index b8e010a9..2a6d20d7 100644
--- a/userspace/programs/shell/main.cpp
+++ b/userspace/programs/shell/main.cpp
@@ -1,3 +1,5 @@
+#include <alkos/sys/thread.h>
+
 #include "fonts/drdos8x8.hpp"
 #include "shell.hpp"
 
@@ -22,9 +24,7 @@ extern "C" int main()
         shell.Update();
         Blit();
 
-        // TODO: Replace with CpuHalt or smth like scheduler sleep.
-        for (volatile i32 i = 0; i < 10000; ++i) {
-        }
+        NanoSleep(16'000'000);
     }
 
     return 0;

From 475853a0d2f088b968d0055c27e84f268608df80 Mon Sep 17 00:00:00 2001
From: Jakub Lisowski <115403674+Jlisowskyy@users.noreply.github.com>
Date: Mon, 5 Jan 2026 23:57:48 +0100
Subject: [PATCH 51/56] jlisowskyy/scheduler-imprv-5 (#272)

Things done in this  PR:
- added syscall exec
- finished exec cmd
- added recursive interrupt lock
---
 kernel/arch/x86_64/src/hal/impl/sync.hpp | 28 ++++++++++++
 kernel/src/fs/file_descriptor.cpp        |  3 ++
 kernel/src/hal/sync.hpp                  |  7 +++
 kernel/src/kernel.cpp                    | 25 +----------
 kernel/src/mem/heap.cpp                  |  5 +++
 kernel/src/mem/virt/vmm.cpp              |  3 ++
 kernel/src/scheduling/kworker.cpp        |  2 -
 kernel/src/scheduling/local_lock.hpp     | 12 +++--
 kernel/src/scheduling/scheduler.cpp      | 24 ++--------
 kernel/src/scheduling/scheduler.hpp      |  2 -
 kernel/src/scheduling/task_mgr.cpp       | 56 ++++++++++++++++++++----
 kernel/src/scheduling/task_mgr.hpp       |  2 +
 kernel/src/scheduling/threads.cpp        |  9 +++-
 kernel/src/sys/loader.hpp                | 16 +++++++
 kernel/src/syscalls/calls/proc.hpp       | 26 ++++++++++-
 kernel/src/syscalls/syscalls.cpp         |  1 +
 libs/libc/src/abi/platform.h             |  1 +
 libs/libc/src/include/alkos/sys/proc.h   |  2 +
 libs/libc/src/include/alkos/syscall.h    |  1 +
 libs/libc/src/internal/libc_backend.cpp  |  1 +
 userspace/programs/shell/shell.cpp       | 10 ++++-
 21 files changed, 172 insertions(+), 64 deletions(-)

diff --git a/kernel/arch/x86_64/src/hal/impl/sync.hpp b/kernel/arch/x86_64/src/hal/impl/sync.hpp
index ce1391c2..873525ee 100644
--- a/kernel/arch/x86_64/src/hal/impl/sync.hpp
+++ b/kernel/arch/x86_64/src/hal/impl/sync.hpp
@@ -6,6 +6,34 @@
 
 namespace arch
 {
+using CpuInterruptFlags = u64;
+
+FAST_CALL void RestoreCpuInterruptFlags(const CpuInterruptFlags &flags)
+{
+    __asm__ volatile(
+        "pushq %0\n\t"
+        "popfq"
+        :
+        : "r"(flags)
+        : "memory", "cc"
+    );
+}
+
+FAST_CALL CpuInterruptFlags GetCpuInterruptFlags()
+{
+    CpuInterruptFlags flags;
+
+    __asm__ volatile(
+        "pushfq\n\t"
+        "popq %0"
+        : "=r"(flags)
+        :
+        : "memory"
+    );
+
+    return flags;
+}
+
 FAST_CALL void FullMemFence() { __asm__ volatile("mfence" ::: "memory"); }
 
 FAST_CALL void LoadMemFence() { __asm__ volatile("lfence" ::: "memory"); }
diff --git a/kernel/src/fs/file_descriptor.cpp b/kernel/src/fs/file_descriptor.cpp
index 7d416aeb..8e1d6418 100644
--- a/kernel/src/fs/file_descriptor.cpp
+++ b/kernel/src/fs/file_descriptor.cpp
@@ -2,6 +2,7 @@
 
 #include "modules/scheduling.hpp"
 #include "mutex.hpp"
+#include "scheduling/local_lock.hpp"
 #include "scheduling/processes.hpp"
 #include "vfs.hpp"
 
@@ -44,6 +45,7 @@ FdResult<fd_t> FdTable::AllocateAt(data_structures::RefPtr<OpenFileEntry> global
     RET_UNEXPECTED_IF(!IsValidFd(fd), FdError::kInvalidFd);
 
     std::lock_guard lock(lock_);
+    LocalCoreLock local_lock{};
 
     RET_UNEXPECTED_IF(entries_[fd] != nullptr, FdError::kBadFileDescriptor);
 
@@ -221,6 +223,7 @@ FdResult<data_structures::RefPtr<OpenFileEntry>> OpenFileTable::OpenPipe(
 )
 {
     std::lock_guard lock(lock_);
+    LocalCoreLock local_lock{};
 
     const size_t idx = entries_.Allocate();
     if (idx == std::numeric_limits<size_t>::max()) {
diff --git a/kernel/src/hal/sync.hpp b/kernel/src/hal/sync.hpp
index 6e7f5e82..8181fcac 100644
--- a/kernel/src/hal/sync.hpp
+++ b/kernel/src/hal/sync.hpp
@@ -5,6 +5,13 @@
 
 namespace hal
 {
+using arch::CpuInterruptFlags;
+WRAP_CALL CpuInterruptFlags GetCpuInterruptFlags() { return arch::GetCpuInterruptFlags(); }
+WRAP_CALL void RestoreCpuInterruptFlags(const CpuInterruptFlags &flags)
+{
+    arch::RestoreCpuInterruptFlags(flags);
+}
+
 WRAP_CALL void FullMemFence() { arch::FullMemFence(); }
 
 WRAP_CALL void LoadMemFence() { arch::LoadMemFence(); }
diff --git a/kernel/src/kernel.cpp b/kernel/src/kernel.cpp
index 26331803..4657d4e8 100644
--- a/kernel/src/kernel.cpp
+++ b/kernel/src/kernel.cpp
@@ -14,29 +14,8 @@ extern void KernelInit(const hal::RawBootArguments &);
 static void KernelRun()
 {
     TRACE_INFO_GENERAL("Hello from AlkOS!");
-
-    auto &task_mgr = SchedulingModule::Get().GetTaskMgr();
-
-    // auto res = task_mgr.ExecuteElf64("/bin/hello", {});
-    // R_ASSERT_TRUE(res, "Failed to spawn /bin/hello process...");
-    // auto [pid, _] = res.value();
-    //
-    // Sched::Task tracer_task;
-    // tracer_task.func       = reinterpret_cast<void *>(Sched::StdoutTracerMain);
-    // tracer_task.args_count = 1;
-    // tracer_task.args       = {*reinterpret_cast<u64 *>(&pid)};
-    //
-    // // Spawn StdoutTracer KWorker to monitor hello_world's stdout
-    // R_ASSERT_TRUE(
-    //     task_mgr.SpawnKernelProcess("stdout-tracer", {}, tracer_task),
-    //     "Failed to spawn stdout tracer process..."
-    // );
-
-    const auto res1 = task_mgr.ExecuteElf64("/bin/gui_test", {});
-    R_ASSERT_TRUE(static_cast<bool>(res1), "Failed to spawn /bin/gui process...");
-
-    const auto res2 = task_mgr.ExecuteElf64("/bin/shell", {});
-    R_ASSERT_TRUE(static_cast<bool>(res2), "Failed to spawn /bin/shell process...");
+    const auto res = SchedulingModule::Get().GetTaskMgr().ExecuteElf64("/bin/shell", {});
+    R_ASSERT_TRUE(static_cast<bool>(res), "Failed to spawn /bin/shell process...");
 
     SchedulingModule::Get().GetScheduler().ConvertToScheduling();
 }
diff --git a/kernel/src/mem/heap.cpp b/kernel/src/mem/heap.cpp
index 7914b09d..38b88562 100644
--- a/kernel/src/mem/heap.cpp
+++ b/kernel/src/mem/heap.cpp
@@ -7,6 +7,7 @@
 #include "mem/phys/mngr/buddy.hpp"
 #include "mem/phys/mngr/slab.hpp"
 #include "modules/memory.hpp"
+#include "scheduling/local_lock.hpp"
 
 namespace Mem
 {
@@ -124,12 +125,14 @@ void Heap::FreeAligned(VPtr<void> ptr)
 
 expected<VPtr<void>, MemError> KMalloc(size_t size)
 {
+    LocalCoreLock lock{};
     return MemoryModule::Get().GetHeap().Malloc(size);
 }
 
 template <>
 void KFree(VPtr<void> ptr)
 {
+    LocalCoreLock lock{};
     MemoryModule::Get().GetHeap().Free(ptr);
 }
 
@@ -139,12 +142,14 @@ void KFree(VPtr<void> ptr)
 
 expected<VPtr<void>, MemError> KMallocAligned(KMallocRequest r)
 {
+    LocalCoreLock lock{};
     return MemoryModule::Get().GetHeap().MallocAligned(r);
 }
 
 template <>
 void KFreeAligned(VPtr<void> ptr)
 {
+    LocalCoreLock lock{};
     MemoryModule::Get().GetHeap().FreeAligned(ptr);
 }
 
diff --git a/kernel/src/mem/virt/vmm.cpp b/kernel/src/mem/virt/vmm.cpp
index 85c4828e..930d4ff2 100644
--- a/kernel/src/mem/virt/vmm.cpp
+++ b/kernel/src/mem/virt/vmm.cpp
@@ -12,6 +12,7 @@
 #include "mem/virt/addr_space.hpp"
 #include "mem/virt/area.hpp"
 #include "modules/memory.hpp"
+#include "scheduling/local_lock.hpp"
 #include "trace_framework.hpp"
 
 namespace Mem
@@ -45,6 +46,8 @@ void Vmm::Init(
 
 expected<VPtr<AddressSpace>, MemError> Vmm::CreateUserAddrSpace()
 {
+    LocalCoreLock local_lock{};
+
     auto as_res = KNew<AddressSpace>();
     RET_UNEXPECTED_IF_ERR(as_res);
     auto as = *as_res;
diff --git a/kernel/src/scheduling/kworker.cpp b/kernel/src/scheduling/kworker.cpp
index 60a8d3a5..7f1ddfa8 100644
--- a/kernel/src/scheduling/kworker.cpp
+++ b/kernel/src/scheduling/kworker.cpp
@@ -26,8 +26,6 @@ void Sched::KWorkerMain()
         }
 
         SchedulingModule::Get().GetScheduler().Yield();
-        // const auto pid = hardware::GetRunningPid();
-        // TRACE_INFO_SCHEDULING("ACK FROM PID: %llu", pid);
     }
 }
 
diff --git a/kernel/src/scheduling/local_lock.hpp b/kernel/src/scheduling/local_lock.hpp
index dc63295d..daabd0de 100644
--- a/kernel/src/scheduling/local_lock.hpp
+++ b/kernel/src/scheduling/local_lock.hpp
@@ -1,18 +1,22 @@
-#ifndef KERNEL_SRC_SCHEDULING_SCHEDULER_LOCK_HPP_
-#define KERNEL_SRC_SCHEDULING_SCHEDULER_LOCK_HPP_
+#ifndef KERNEL_SRC_SCHEDULING_LOCAL_LOCK_HPP_
+#define KERNEL_SRC_SCHEDULING_LOCAL_LOCK_HPP_
 
 #include <defines.hpp>
 
+#include "hal/sync.hpp"
 #include "modules/hardware.hpp"
 
 class LocalCoreLock
 {
+    hal::CpuInterruptFlags state_{};
+
     public:
     FORCE_INLINE_F LocalCoreLock()
     {
+        state_ = hal::GetCpuInterruptFlags();
         HardwareModule::Get().GetInterrupts().BlockHardwareInterrupts();
     }
-    ~LocalCoreLock() { HardwareModule::Get().GetInterrupts().EnableHardwareInterrupts(); }
+    ~LocalCoreLock() { hal::RestoreCpuInterruptFlags(state_); }
 };
 
-#endif  // KERNEL_SRC_SCHEDULING_SCHEDULER_LOCK_HPP_
+#endif  // KERNEL_SRC_SCHEDULING_LOCAL_LOCK_HPP_
diff --git a/kernel/src/scheduling/scheduler.cpp b/kernel/src/scheduling/scheduler.cpp
index 815538dd..858d71e2 100644
--- a/kernel/src/scheduling/scheduler.cpp
+++ b/kernel/src/scheduling/scheduler.cpp
@@ -48,9 +48,10 @@ void Scheduler::InstallInterruptHandler()
 void Scheduler::AddReadyThread(Thread *thread)
 {
     ASSERT_NOT_NULL(thread);
-
     ASSERT_EQ(thread->state, ThreadState::kReady);
 
+    LocalCoreLock lock{};
+
     const auto idx = static_cast<size_t>(thread->flags.policy);
     ASSERT_LT(idx, static_cast<size_t>(SchedulingPolicy::kLast));
 
@@ -156,7 +157,7 @@ void Scheduler::ConvertToScheduling()
 {
     TRACE_INFO_SCHEDULING("Converting to scheduling!");
 
-    HardwareModule::Get().GetInterrupts().BlockHardwareInterrupts();
+    LocalCoreLock lock{};
 
     ASSERT_TRUE(HardwareModule::Get().GetEventClockRegistry().IsSelectedPicked());
 
@@ -213,25 +214,6 @@ void Scheduler::NanoSleepUntil(const u64 systime_ns)
     }
 }
 
-void Scheduler::NanoSleepUntilUnguarded(const u64 systime_ns)
-{
-    const u64 time = TimingModule::Get().GetSystemTime().ReadLifeTimeNs();
-    if (systime_ns < time) {
-        return;
-    }
-
-    if (systime_ns - time < kMinDelta) {
-        /* Do busy wait if window to scheduler irq is too small */
-        while (systime_ns - TimingModule::Get().GetSystemTime().ReadLifeTimeNs() < kMinDelta) {
-        }
-        return;
-    }
-    hardware::GetCoreLocalTcb()->HookT::key = systime_ns;
-    sleep_queue_.Insert(hardware::GetCoreLocalTcb());
-
-    hal::ContextSwitch(ScheduleAndUpdateThreads(true, ThreadState::kSleeping));
-}
-
 void Scheduler::SetupNextTimeEvent_(const u64 time_ns)
 {
     ASSERT_TRUE(HardwareModule::Get().GetEventClockRegistry().IsSelectedPicked());
diff --git a/kernel/src/scheduling/scheduler.hpp b/kernel/src/scheduling/scheduler.hpp
index 373c02e0..6ca0d626 100644
--- a/kernel/src/scheduling/scheduler.hpp
+++ b/kernel/src/scheduling/scheduler.hpp
@@ -70,8 +70,6 @@ class Scheduler
 
     void NanoSleepUntil(u64 systime_ns);
 
-    void NanoSleepUntilUnguarded(u64 systime_ns);
-
     // ------------------------------
     // Private methods
     // ------------------------------
diff --git a/kernel/src/scheduling/task_mgr.cpp b/kernel/src/scheduling/task_mgr.cpp
index 2803f900..343b741b 100644
--- a/kernel/src/scheduling/task_mgr.cpp
+++ b/kernel/src/scheduling/task_mgr.cpp
@@ -33,7 +33,7 @@ void TaskMgr::InitializeMultitasking()
     R_ASSERT_TRUE(static_cast<bool>(result), "Failed to spawn trace dumper process...");
 
     // Spawn 3 Kernel Workers
-    static constexpr size_t kNumKWorkers = 0;
+    static constexpr size_t kNumKWorkers = 3;
     for (size_t i = 0; i < kNumKWorkers; ++i) {
         char name[] = "kworker-0";
 
@@ -53,6 +53,8 @@ void TaskMgr::InitializeMultitasking()
 
 std::expected<Pid, Error> TaskMgr::SpawnEmptyProcess(const char *name, const ProcessFlags flags)
 {
+    LocalCoreLock local_lock{};
+
     if (strnlen(name, Process::kMaxNameLength) == Process::kMaxNameLength) {
         return std::unexpected(Error::ProcessNameTooLong);
     }
@@ -99,6 +101,7 @@ std::expected<Pid, Error> TaskMgr::SpawnEmptyProcess(const char *name, const Pro
 
 std::expected<Thread *, Error> TaskMgr::SpawnThread(const Pid pid, const Task &task)
 {
+    LocalCoreLock local_lock{};
     const auto process = SchedulingModule::Get().GetProcesses().GetProcess(pid);
     ASSERT_TRUE(static_cast<bool>(process));
 
@@ -116,6 +119,8 @@ std::expected<Thread *, Error> TaskMgr::SpawnThread(
     const Pid pid, const ThreadFlags flags, const Task &task
 )
 {
+    LocalCoreLock local_lock{};
+
     const auto process = SchedulingModule::Get().GetProcesses().GetProcess(pid);
     ASSERT_TRUE(static_cast<bool>(process));
 
@@ -126,6 +131,8 @@ std::expected<Thread *, Error> TaskMgr::SpawnThread(
     const Process *process, const ThreadFlags flags, const Task &task
 )
 {
+    LocalCoreLock local_lock{};
+
     bool dismiss = false;
 
     // 1. Prepare internal structure for execution unit - thread:
@@ -193,6 +200,8 @@ std::expected<std::tuple<Pid, Tid>, Error> TaskMgr::SpawnKernelProcess(
     const char *name, ProcessFlags flags, const Task &task
 )
 {
+    LocalCoreLock local_lock{};
+
     flags.KernelSpaceOnly = true;
 
     auto process = SpawnEmptyProcess(name, flags);
@@ -210,9 +219,7 @@ std::expected<std::tuple<Pid, Tid>, Error> TaskMgr::SpawnKernelProcess(
         return std::unexpected(thread.error());
     }
 
-    HardwareModule::Get().GetInterrupts().BlockHardwareInterrupts();
     SchedulingModule::Get().GetScheduler().AddReadyThread(thread.value());
-    HardwareModule::Get().GetInterrupts().EnableHardwareInterrupts();
 
     DEBUG_INFO_SCHEDULING(
         "Created kernel process with pid: %llu, name: %s and initial thread with tid: %llu",
@@ -227,23 +234,37 @@ std::expected<Pid, Error> TaskMgr::CloneProcess(Pid) { R_FAIL_ALWAYS("NOT IMPLEM
 
 std::expected<Tid, Error> TaskMgr::ExecuteElf64(const Pid pid, const char *path)
 {
+    LocalCoreLock local_lock{};
+
     auto process = SchedulingModule::Get().GetProcesses().GetProcess(pid);
     RET_UNEXPECTED_IF_ERR(process);
 
+    template_lib::ScopeGuard process_guard([&] {
+        const auto result = SchedulingModule::Get().GetProcesses().Free(process.value()->pid);
+        ASSERT_TRUE(static_cast<bool>(result));
+    });
+
     // TODO: KILL ALL EXISTING THREADS FROM THIS PROCESS
 
-    auto thread = SpawnThread(pid, PrepareElf64LoaderTask(pid, path));
+    const size_t path_size = strlen(path);
+    const auto mem         = Mem::KMalloc(path_size);
+    if (!mem) {
+        return std::unexpected(Error::OutOfMemory);
+    }
+    memcpy(mem.value(), path, path_size);
+
+    auto thread =
+        SpawnThread(pid, PrepareElf64LoaderTask(pid, static_cast<const char *>(mem.value())));
     RET_UNEXPECTED_IF_ERR(thread);
 
-    HardwareModule::Get().GetInterrupts().BlockHardwareInterrupts();
     SchedulingModule::Get().GetScheduler().AddReadyThread(thread.value());
-    HardwareModule::Get().GetInterrupts().EnableHardwareInterrupts();
 
     DEBUG_INFO_SCHEDULING(
         "Created userspace process with pid: %llu and initial thread with tid: %llu", pid,
         thread.value()->tid
     );
 
+    process_guard.dismiss();
     return thread.value()->tid;
 }
 
@@ -251,6 +272,8 @@ std::expected<std::tuple<Pid, Tid>, Error> TaskMgr::ExecuteElf64(
     const char *path, const ProcessFlags flags
 )
 {
+    LocalCoreLock local_lock{};
+
     const auto exists_res = VfsModule::Get().FileExists(vfs::Path(path));
     if (!exists_res.has_value() || !exists_res.value()) {
         return std::unexpected(Error::ExecPathNotFound);
@@ -274,7 +297,7 @@ std::expected<std::tuple<Pid, Tid>, Error> TaskMgr::ExecuteElf64(
 
 std::expected<void, Error> TaskMgr::CommitMurder(Pid) { R_FAIL_ALWAYS("NOT IMPLEMENTED"); }
 
-void TaskMgr::CommitSuicide() { R_FAIL_ALWAYS("NOT IMPLEMENTED"); }
+void TaskMgr::CommitSuicide() { R_FAIL_ALWAYS("CommitSuicide NOT IMPLEMENTED"); }
 
 std::expected<void, Error> TaskMgr::ExitProcess() { R_FAIL_ALWAYS("NOT IMPLEMENTED"); }
 
@@ -359,7 +382,7 @@ std::expected<void *, Error> TaskMgr::JoinThread(const Tid tid)
            thread.value()->state != ThreadState::kTerminated) {
         static constexpr u64 kWaitTime = 50'000'000;  // 50 ms
 
-        SchedulingModule::Get().GetScheduler().NanoSleepUntilUnguarded(
+        SchedulingModule::Get().GetScheduler().NanoSleepUntil(
             TimingModule::Get().GetSystemTime().ReadLifeTimeNs() + kWaitTime
         );
     }
@@ -373,4 +396,21 @@ std::expected<void *, Error> TaskMgr::JoinThread(const Tid tid)
 
     return std::unexpected(Error::AlreadyJoined);
 }
+
+std::expected<Pid, Error> TaskMgr::Exec(const char *path)
+{
+    ASSERT_NOT_NULL(path);
+
+    ProcessFlags flags{};
+    flags.KernelSpaceOnly = false;
+    flags.PreserveFloats  = true;
+
+    LocalCoreLock lock{};
+    const auto result = ExecuteElf64(path, flags);
+    if (!result) {
+        return std::unexpected(result.error());
+    }
+
+    return std::get<Pid>(result.value());
+}
 }  // namespace Sched
diff --git a/kernel/src/scheduling/task_mgr.hpp b/kernel/src/scheduling/task_mgr.hpp
index f4b1e570..afe4e92b 100644
--- a/kernel/src/scheduling/task_mgr.hpp
+++ b/kernel/src/scheduling/task_mgr.hpp
@@ -78,6 +78,8 @@ class TaskMgr
 
     NODISCARD std::expected<void *, Error> JoinThread(Tid tid);
 
+    NODISCARD std::expected<Pid, Error> Exec(const char *path);
+
     // ------------------------------
     // Private methods
     // ------------------------------
diff --git a/kernel/src/scheduling/threads.cpp b/kernel/src/scheduling/threads.cpp
index 6e5df5cb..bbf2f654 100644
--- a/kernel/src/scheduling/threads.cpp
+++ b/kernel/src/scheduling/threads.cpp
@@ -8,6 +8,7 @@
 #include "mem/virt/addr_space.hpp"
 #include "modules/scheduling.hpp"
 #include "modules/timing.hpp"
+#include "scheduling/local_lock.hpp"
 #include "sys/loader.hpp"
 
 namespace Sched
@@ -40,6 +41,9 @@ void OnKThreadExit()
 
 void Elf64EntryPoint(const Pid pid, const char *path)
 {
+    ASSERT_NOT_NULL(path);
+    LocalCoreLock core_lock{};
+
     const auto process = SchedulingModule::Get().GetProcesses().GetProcess(pid);
     ASSERT_TRUE(static_cast<bool>(process));  // TODO: CAN IT BE MISSING HERE????
 
@@ -47,9 +51,12 @@ void Elf64EntryPoint(const Pid pid, const char *path)
     ASSERT_NOT_NULL(as);
 
     const auto entry_res = System::ElfLoader::Load(vfs::Path(path), *as);
+    Mem::KFree(reinterpret_cast<void *>(reinterpret_cast<u64>(path)));
+
     if (!entry_res) {
         DEBUG_WARN_SCHEDULING(
-            "Failed to execute ELF64 for process %llu. Failed on ELF loading.", pid
+            "Failed to execute ELF64 for process %llu. Failed on ELF loading: %s.", pid,
+            to_string(entry_res.error())
         );
         SchedulingModule::Get().GetTaskMgr().CommitSuicide();
     }
diff --git a/kernel/src/sys/loader.hpp b/kernel/src/sys/loader.hpp
index f803853f..3e6d15e6 100644
--- a/kernel/src/sys/loader.hpp
+++ b/kernel/src/sys/loader.hpp
@@ -12,6 +12,22 @@ using std::expected;
 
 enum class LoadError : u8 { FileNotFound, InvalidElf, IoError, MemoryError };
 
+static constexpr const char *to_string(const LoadError &error)
+{
+    switch (error) {
+        case LoadError::FileNotFound:
+            return "FileNotFound";
+        case LoadError::IoError:
+            return "IoError";
+        case LoadError::MemoryError:
+            return "MemoryError";
+        case LoadError::InvalidElf:
+            return "InvalidElf";
+        default:
+            return "Unknown";
+    }
+}
+
 class ElfLoader
 {
     public:
diff --git a/kernel/src/syscalls/calls/proc.hpp b/kernel/src/syscalls/calls/proc.hpp
index 46086bf8..5a66699e 100644
--- a/kernel/src/syscalls/calls/proc.hpp
+++ b/kernel/src/syscalls/calls/proc.hpp
@@ -3,14 +3,36 @@
 
 #include <defines.hpp>
 #include "hardware/core_local.hpp"
+#include "modules/scheduling.hpp"
 #include "modules/video.hpp"
+#include "scheduling/local_lock.hpp"
 
 namespace Syscall
 {
-FAST_CALL void SysExit(int) {}
+FAST_CALL void SysExit(int status) {}
+
 FAST_CALL void SysAbort() {}
 
-FORCE_INLINE_F void SysFocusTransfer(Sched::Pid target_child)
+FAST_CALL int SysExec(const char *path, u64 *pid)
+{
+    if (path == nullptr) {
+        return -1;
+    }
+
+    const auto result = SchedulingModule::Get().GetTaskMgr().Exec(path);
+
+    if (!result) {
+        return -1;
+    }
+
+    if (pid != nullptr) {
+        *pid = *reinterpret_cast<const u64 *>(&result.value());
+    }
+
+    return 0;
+}
+
+FAST_CALL void SysFocusTransfer(Sched::Pid target_child)
 {
     auto &wm = VideoModule::Get().GetWindowManager();
     wm.SetFocus(target_child);
diff --git a/kernel/src/syscalls/syscalls.cpp b/kernel/src/syscalls/syscalls.cpp
index 7b79a7b5..fab5d50e 100644
--- a/kernel/src/syscalls/syscalls.cpp
+++ b/kernel/src/syscalls/syscalls.cpp
@@ -37,6 +37,7 @@ constinit auto g_syscall_dispatch_table = SyscallDispatchTable<kSysMax>::Create<
     /* Thread, processes */
     table.RegisterHandler<kProcAbort, SysAbort>();
     table.RegisterHandler<kProcExit, SysExit>();
+    table.RegisterHandler<kExec, SysExec>();
     table.RegisterHandler<kThreadCreate, SysThreadCreate>();
     table.RegisterHandler<kThreadExit, SysThreadExit>();
     table.RegisterHandler<kThreadJoin, SysThreadJoin>();
diff --git a/libs/libc/src/abi/platform.h b/libs/libc/src/abi/platform.h
index 32ff14d0..d37eee5e 100644
--- a/libs/libc/src/abi/platform.h
+++ b/libs/libc/src/abi/platform.h
@@ -36,6 +36,7 @@ SYSCALL_NAME(file_info, kSysFileInfo, int, const char *, path, FileInfo *, info)
 
 /* Thread, processes */
 SYSCALL_NAME(thread_create, kThreadCreate, int, Thread *, thread, thread_func_t, f, void *, arg);
+SYSCALL_NAME(exec, kExec, int, const char *, path, u64 *, pid);
 SYSCALL_VOID_NAME(thread_exit, kThreadExit, void *, retval);
 SYSCALL_NAME(thread_join, kThreadJoin, int, Thread *, thread, void **, retval);
 SYSCALL_NAME(thread_detach, kThreadDetach, int, Thread *, thread);
diff --git a/libs/libc/src/include/alkos/sys/proc.h b/libs/libc/src/include/alkos/sys/proc.h
index 97266beb..6e30f7e9 100644
--- a/libs/libc/src/include/alkos/sys/proc.h
+++ b/libs/libc/src/include/alkos/sys/proc.h
@@ -14,6 +14,8 @@ FAST_CALL void Exit(int status) { __platform_proc_exit(status); }
 
 FAST_CALL void Abort() { __platform_proc_abort(); }
 
+FAST_CALL int Exec(const char *path, u64 *pid) { return __platform_exec(path, pid); }
+
 END_DECL_C
 
 #endif  // LIBS_LIBC_SRC_INCLUDE_ALKOS_SYS_PROC_H_
diff --git a/libs/libc/src/include/alkos/syscall.h b/libs/libc/src/include/alkos/syscall.h
index e4135967..511b516c 100644
--- a/libs/libc/src/include/alkos/syscall.h
+++ b/libs/libc/src/include/alkos/syscall.h
@@ -42,6 +42,7 @@ enum SyscallNumber {
     kProcAbort,
     kNanoSleep,
     kNanoSleepUntil,
+    kExec,
 
     /* Video Syscalls */
     kSysCreateGraphicSession,
diff --git a/libs/libc/src/internal/libc_backend.cpp b/libs/libc/src/internal/libc_backend.cpp
index bb624e8e..c485c8f6 100644
--- a/libs/libc/src/internal/libc_backend.cpp
+++ b/libs/libc/src/internal/libc_backend.cpp
@@ -30,6 +30,7 @@ DEFINE_SYSCALL(file_info, kSysFileInfo, int, const char *, path, FileInfo *, inf
 
 /* Thread, processes */
 DEFINE_SYSCALL(thread_create, kThreadCreate, int, Thread *, thread, thread_func_t, f, void *, arg)
+DEFINE_SYSCALL(exec, kExec, int, const char *, path, u64 *, pid)
 DEFINE_SYSCALL_VOID(thread_exit, kThreadExit, void *, retval)
 DEFINE_SYSCALL(thread_join, kThreadJoin, int, Thread *, thread, void **, retval)
 DEFINE_SYSCALL(thread_detach, kThreadDetach, int, Thread *, thread)
diff --git a/userspace/programs/shell/shell.cpp b/userspace/programs/shell/shell.cpp
index ede8a040..29bd5243 100644
--- a/userspace/programs/shell/shell.cpp
+++ b/userspace/programs/shell/shell.cpp
@@ -4,6 +4,7 @@
 #include <string.h>
 #include <string.hpp>
 
+#include "alkos/calls.h"
 #include "alkos/sys/fd.h"
 #include "alkos/sys/power.h"
 
@@ -328,8 +329,15 @@ void Shell::CmdExec(std::string_view args)
     }
 
     Path programPath = ResolvePath(args);
+    int result       = Exec(programPath.CString(), nullptr);
 
-    // TODO: Implement program execution
+    if (result != 0) {
+        const char *err = "exec: invalid filename or not enough resources\n";
+        console_.Write(std::span<const byte>(reinterpret_cast<const byte *>(err), strlen(err)));
+    }
+
+    const char *msg = "Successfully executed program!\n";
+    console_.Write(std::span<const byte>(reinterpret_cast<const byte *>(msg), strlen(msg)));
 }
 
 }  // namespace System

From 57a28edaf93954f67ad0bdf21f9cb29237dc99c3 Mon Sep 17 00:00:00 2001
From: Jakub Lisowski <Jlisowskyy@gmail.com>
Date: Tue, 6 Jan 2026 00:18:02 +0100
Subject: [PATCH 52/56] kworker fix

---
 kernel/src/scheduling/kworker.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/kernel/src/scheduling/kworker.cpp b/kernel/src/scheduling/kworker.cpp
index 7f1ddfa8..d470abc9 100644
--- a/kernel/src/scheduling/kworker.cpp
+++ b/kernel/src/scheduling/kworker.cpp
@@ -17,7 +17,7 @@ void Sched::KWorkerMain()
     TRACE_INFO_SCHEDULING("Created new KWorker!");
 
     while (true) {
-        static size_t kSpins = 1'000;
+        static size_t kSpins = 1'000'000;
         for (size_t i = 0; i < kSpins; i++) {
             hal::Noop();
             hal::Noop();

From 85aa0f03ed92cc643fcb9989e2e482e7dcaa067b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C5=81ukasz=20Kryczka?=
 <60490378+kryczkal@users.noreply.github.com>
Date: Wed, 7 Jan 2026 20:15:50 +0100
Subject: [PATCH 53/56] docs: Redesign README (#275)

---
 README.md | 406 +++++++-----------------------------------------------
 1 file changed, 51 insertions(+), 355 deletions(-)

diff --git a/README.md b/README.md
index ba3cc4d9..0405844f 100644
--- a/README.md
+++ b/README.md
@@ -1,385 +1,81 @@
 # AlkOS
+[![License](https://img.shields.io/github/license/AlkOS-Dev/AlkOS)](https://github.com/AlkOS-Dev/AlkOS/blob/main/LICENSE)
+[![Stars](https://img.shields.io/github/stars/AlkOS-Dev/AlkOS)](https://github.com/AlkOS-Dev/AlkOS/stargazers)
+[![Issues](https://img.shields.io/github/issues/AlkOS-Dev/AlkOS)](https://github.com/AlkOS-Dev/AlkOS/issues)
+[![Contributors](https://img.shields.io/github/contributors/AlkOS-Dev/AlkOS)](https://github.com/AlkOS-Dev/AlkOS/graphs/contributors)
 
-[![License](https://img.shields.io/github/license/Jlisowskyy/AlkOS)](https://github.com/Jlisowskyy/AlkOS/blob/main/LICENSE)
-[![Stars](https://img.shields.io/github/stars/Jlisowskyy/AlkOS)](https://github.com/Jlisowskyy/AlkOS/stargazers)
-[![Issues](https://img.shields.io/github/issues/Jlisowskyy/AlkOS)](https://github.com/Jlisowskyy/AlkOS/issues)
-[![Contributors](https://img.shields.io/github/contributors/Jlisowskyy/AlkOS)](https://github.com/Jlisowskyy/AlkOS/graphs/contributors)
+A modern kernel written in **C++23**. Can run doom.
 
-AlkOS is an open-source operating system project targeting the x86_64 architecture. This project serves as an engineering thesis, focusing on the development of a functional operating system kernel. The immediate goal is to implement a preemptive multitasking scheduler. Future plans include developing a shell and support for user-mode programs.
+### ⚡ Capabilities
 
-**Current Features:**
+*   **Architecture:** Portable HAL-based core (x86_64 implemented), Higher Half, SMP-ready.
+*   **Memory:** PMM (Buddy/Bitmap), VMM (Recursive mapping, VMA), Heap (Slab).
+*   **Scheduling:** Preemptive Multitasking via MLFQ and Round Robin policies.
+*   **Userspace:** Ring 3 isolation, ELF64 loader, Syscall interface (`int 0x80`).
+*   **Filesystem:** VFS abstraction with FAT12/16/32 and Initrd support.
+*   **Graphics:** Linear Framebuffer, Compositor/Window Manager, Double Buffering.
+*   **Hardware:** ACPI (via uACPI), IO/Local APIC, HPET, PCI, PS/2, Serial.
+*   **Runtime:** Custom `libc` and `libcpp` implementation (no upstream deps).
+*   **Apps:** Shell, GUI Demo, **Doom**.
 
-*   **Boots to a 64-bit kernel:** The system successfully loads and executes a 64-bit kernel.
-*   **Basic memory management:**  Includes setting up page tables for identity mapping the first 1 GiB of memory using 2 MiB pages in the boot process.
-*   **Serial port debugging output:**  Supports sending debug messages to a serial port, which is captured by QEMU and can be redirected to the standard output or a file.
-*   **Custom testing framework:** Similar to Google Test, allowing for easy definition and execution of test cases within the kernel environment. Tests can be filtered and managed using command-line arguments. The framework supports test assertions (e.g., `ASSERT`, `R_ASSERT_EQ`) and automatic test discovery.
-*   **Support for floating-point operations:** The kernel correctly sets up the x87 FPU and AVX extensions, allowing for floating-point calculations.
-*   **Interrupt handling:** The kernel includes an Interrupt Descriptor Table (IDT) and can handle basic interrupts. Programmable Interrupt Controller (PIC) is configured to handle hardware interrupts.
-*   **Support for GCC C++ Standard Library features:** Includes features like new/delete operators and static initializers.
-*   **Stack Smashing Protection:** The kernel utilizes the `-fstack-protector-all` flag during compilation and has a basic implementation of stack canaries to detect stack buffer overflows.
-*   **VGA driver:** Supports basic text output to the screen using the VGA text mode.
-*   **C Standard Library:** A partial implementation of the C standard library is provided, including functions like `snprintf`, `strlen`, `strcpy`, `strcmp`, `memcpy`, `memset`, etc.
-*   **Input from serial port:** The kernel can read input from the serial port, enabling basic interaction via a terminal emulator.
+### 🚀 Quick Start
 
-## Table of Contents
+**Prerequisites:** Linux (Arch/Ubuntu recommended) or Docker.
 
-*   [AlkOS](#alkos)
-    *   [Project Goals](#project-goals)
-    *   [Directory Structure](#-directory-structure)
-    *   [Key Scripts](#️-key-scripts)
-    *   [Getting Started](#getting-started)
-        *   [Prerequisites](#-prerequisites)
-        *   [Installation](#️-installation-dependencies-and-toolchain)
-        *   [Feature flags](#feature-flags)
-    *   [Development Workflow](#-development-workflow)
-        *   [Building AlkOS](#️-building-alkos)
-        *   [Running AlkOS in QEMU](#️-running-alkos-in-qemu)
-        *   [Running Tests](#-running-tests)
-        *   [Debugging with GDB](#-debugging-with-gdb)
-        *   [Applying clang-format for Code Style](#-applying-clang-format-for-code-style)
-        *   [Shell Completions for Scripts](#-shell-completions-for-scripts)
-    *   [License](#-license)
-
-## Project Goals
-
-The primary goals of AlkOS are:
-
-1.  **Implement a preemptive multitasking scheduler:** This is the current focus and a critical step towards a functional operating system.
-2.  **Develop a shell:** A basic shell will allow user interaction with the system.
-3.  **Support user-mode programs:** This will enable the execution of user applications.
-4.  **Serve as an engineering thesis:** AlkOS is being developed as part of an academic project to demonstrate OS development principles.
-
-## 📁 Directory Structure
-
-*   **alkos/** - Contains the source code for the operating system.
-    *   **kernel/** - The core kernel code.
-        *   **abi/** - Definitions of the kernel ABI (Application Binary Interface).
-        *   **arch/** - Architecture-specific code.
-            *   **x86_64/** - Code specific to the x86_64 architecture.
-                *   **boot32/** - 32-bit bootloader code.
-                *   **boot64/** - 64-bit kernel code.
-                *   **common/** - Architecture-specific code shared between bootloaders and the kernel.
-        *   **include/** - Public kernel header files.
-        *   **src/** - Kernel source files.
-        *   **test/** - Test framework and test cases for the kernel.
-    *   **libc/** - Implementation of the C standard library.
-        *   **arch/** - Architecture-specific code for the C standard library.
-        *   **cxx/** - C++ support code (e.g., new/delete, static initializers).
-        *   **include/** - Public header files for the C standard library.
-        *   **io/** - I/O related functions (e.g., `snprintf`).
-        *   **libssp/** - Stack Smashing Protector library.
-        *   **math/** - Math functions.
-        *   **memory/** - Memory manipulation functions.
-        *   **string/** - String manipulation functions.
-    *   **toolchains/** - CMake toolchain files for cross-compilation.
-*   **scripts/**
-    *   **actions/** - Wrappers for other scripts, that perform useful operations on the repository (e.g., formatting, cleaning, building, running).
-    *   **env/** - Scripts for preparing, updating, and modifying the development and user environments.
-    *   **install/** - Scripts for performing user operations like preparing ISO, compiling user versions, or installing the OS.
-    *   **tests/** - Scripts and framework used to automatically test the project.
-    *   **utils/** - Utility scripts to be sourced and used by other scripts.
-    *   **git-hooks/** - Git hooks for the project.
-    *   `alkos_cli.bash` - Main CLI script for managing the project.
-    *   `config/conf.generated.bash` - Configuration file.
-    *   `configure.bash` - Configuration script.
-
-## 🛠️ Key Scripts
-
-*   `scripts/alkos_cli.bash` - Main CLI script that orchestrates the project. It can install dependencies, build the project, run it in QEMU, and more.
-*   `scripts/config/configure.bash` - Used to configure the project for a specific architecture and build type.
-*   `scripts/actions/build_alkos.bash` - Builds the AlkOS kernel and creates an ISO image.
-*   `scripts/actions/make_iso.bash` - Creates an ISO image from the built kernel and modules.
-*   `scripts/actions/run_alkos.bash` - Runs AlkOS in QEMU.
-*   `scripts/actions/attach_to_qemu_gdb.bash` - Attaches GDB to a running QEMU instance for debugging the kernel.
-*   `scripts/actions/apply_clang_format.bash` - Applies clang-format to the source code to maintain consistent code style.
-*   `scripts/tests/runner.py` - Entry point for the test framework.
-*   `scripts/env/build_cross_compile.bash` - Script for building the cross-compiler.
-*   `scripts/git-hooks/setup-hooks.bash` - Script for setting up git hooks.
-*   `scripts/git-hooks/pre-commit` - Pre-commit hook for clang-format.
-
-## Getting Started
-
-### 📋 Prerequisites
-
-*   A system running **Arch Linux** or **Ubuntu** for installing dependencies. Otherwise you will need to install the dependencies in `scripts/env/arch_packages.txt` manually.
-*   A **Unix-like environment** for running the scripts (bash shell)
-*   **CMake** >= 3.30: Used as the build system.
-*   **QEMU:** Used for emulating the x86_64 architecture and running AlkOS.
-*   **NASM:** Used as the assembler for assembly code.
-*   **grub-mkrescue:** Used for creating bootable ISO images.
-*   **wget:** Used by the installation scripts for downloading necessary source files.
-*   A cross-compilation toolchain for x86_64-elf (installed by `alkos_cli.bash`).
-*   **make**: Used for building the project.
-*   **ld** (the GNU linker): Used for linking the project.
-
-### 🛠️ Installation: Dependencies and Toolchain
-
-1.  **Clone the repository:**
-
-    ```bash
-    git clone [https://github.com/Jlisowskyy/AlkOS](https://github.com/Jlisowskyy/AlkOS)
-    ```
-
-2.  **Navigate to the scripts directory:**
-
-    ```bash
-    cd AlkOS/scripts
-    ```
-
-3.  **Configure the build:**
-    You need to configure the build using the `configure.bash` script. This script sets up the build environment for a specific architecture and build type.
-
-    For example, to configure a debug build for QEMU with tests enabled, run:
-
-    ```
-    ./configure.bash x86_64 debug -v
-    ```
-
-    This will create a `conf.generated.bash` file in the `scripts/config` directory. This file is sourced by other scripts to get configuration information. The configuration script will 
-    also create a build directory at `../build`.
-
-    To see all available configuration options, run:
-
-    ```
-    ./configure.bash -h
-    ```
-    
-    Modify feature flags in `scripts/config/feature_flags.conf` to enable or disable specific features. The configuration script will automatically update the generated files based on these flags.
-    For more information refer to feature flags section below [Feature flags](#feature-flags).
-4.  **Install dependencies and the cross-compilation toolchain:**
-
-    ```bash
-    ./alkos_cli.bash --install deps -v
-    ./alkos_cli.bash --install toolchain -v
-    ```
-    or:
-    ```bash
-    ./alkos_cli.bash -i all -v
-    ```
-
-    This step will install all necessary dependencies and set up the toolchain for the architecture set with `configure.bash`.
-
-    Note: Installing the dependencies assumes you are running on Arch Linux. If not, you will need to manually install the packages listed in `scripts/env/arch_packages.txt`.
-
-    Note 2: There exists a dependencies installer for Ubuntu: `./scripts/env/install_deps_ubuntu.bash`
-
-### Feature flags
-
-#### Initial Setup
-
-When you first run the configure script, it will generate a feature flags configuration file at `config/feature_flags.conf`. This file contains all available feature flags with their default values:
+**1. Setup Environment**
+Builds the custom GCC 15.1.0 cross-toolchain. System dependency installation is automated for **Arch** and **Ubuntu**.
 
 ```bash
-./scripts/configure/configure.bash x86_64 debug
+./scripts/alkos_cli.bash --install all --verbose
 ```
 
-This creates `config/feature_flags.conf` with entries like:
-```bash
-# run_test_mode - Instead of proceeding to usual kernel boot enter the test mode
-CONFIGURE_FEATURE_FLAGS["run_test_mode"]=false
-
-# debug_spinlock - Enables additional debug information for spinlocks
-CONFIGURE_FEATURE_FLAGS["debug_spinlock"]=false
-```
-
-#### Manual Configuration
-
-You can edit `config/feature_flags.conf` directly to enable or disable features:
+> [!NOTE]
+> On other distributions, install prerequisites manually (see `scripts/env/`), then run with `--install toolchain`.
 
+**2. Configure Build**
+Generates CMake configuration and feature flags.
 ```bash
-# Enable test mode
-CONFIGURE_FEATURE_FLAGS["run_test_mode"]=true
-
-# Enable debug output for troubleshooting
-CONFIGURE_FEATURE_FLAGS["debug_output"]=true
+./scripts/alkos_cli.bash --configure
 ```
 
-**Important**: Only use `true` or `false` values. The system will validate your configuration.
-
-#### Using Presets
-
-For common configurations, you can use presets instead of manually editing flags:
-
+**3. Build & Run**
+Compiles the kernel, userspace apps, generates the ISO, and launches QEMU.
 ```bash
-# Configure for testing
-./scripts/configure/configure.bash x86_64 debug -p test_mode
-
-# Configure for regression testing  
-./scripts/configure/configure.bash x86_64 debug -p regression_mode
-
-# Reset to defaults
-./scripts/configure/configure.bash x86_64 debug -p default
+./scripts/alkos_cli.bash --run
 ```
 
-**Available Presets:**
-- `test_mode`: Enables test mode with full debugging (`run_test_mode=true debug_spinlock=true debug_output=true debug_traces=true`)
-- `regression_mode`: Enables debugging without test mode (`debug_spinlock=true debug_output=true debug_traces=true`)
-- `default`: Resets all flags to their default values
-
-#### Verifying Configuration
-
-After configuration, the system will warn you about any unrecognized flags in your configuration file. This helps catch typos or outdated flag names.
-
-The generated header file at `alkos/generated/include/autogen/feature_flags.h` shows the final configuration that will be used in your build.
-
-#### Best Practices
-
-1. **Keep a backup**: Before making extensive changes, copy your working `feature_flags.conf`
-2. **Use presets when possible**: They ensure consistent, tested configurations
-3. **Check generated files**: Review the generated header to confirm your settings
-4. **Clean builds**: After changing feature flags, consider doing a clean build to ensure all code is recompiled with new settings
-
-## 💻 Development Workflow
+> [!TIP]
+> If something doesn't work during the quickstart: append the `--verbose` flag to see the exact error
 
-### 🏗️ Building AlkOS
+### 🛠 CLI Tooling
 
-1.  **Navigate to the scripts directory:**
+The project is managed via `scripts/alkos_cli.bash`.
 
-    ```bash
-    cd AlkOS/scripts
-    ```
+| Command | Description |
+| :--- | :--- |
+| `-i`, `--install [all/deps/toolchain]` | Sets up the dev environment. |
+| `-c`, `--configure` | Generates CMake configs and feature flags. |
+| `-r`, `--run` | Builds the ISO and boots QEMU. |
+| `-g`, `--git-hooks` | Installs pre-commit hooks (clang-format). |
 
-2.  **Build the project:**
-    The build system uses CMake. When you run `alkos_cli.bash` with `-r`, it first invokes the `build_alkos.bash` script. This script creates a build directory, 
-    generates Makefiles using CMake with the specified cross-compilation toolchain, and then builds the project using `make`.
+### 📂 Structure
 
-    ```
-    ./alkos_cli.bash --verbose --run
-    ```
+*   `kernel/` - Core kernel source (Arch specific, MM, Sched, Drivers).
+*   `libs/` - Custom implementation of `libc`, `libcpp`, and containers.
+*   `userspace/` - Ring 3 applications (Shell, Doom, GUI tests).
+*   `scripts/` - Build system, CI/CD, and environment automation.
 
-    or:
-
-    ```
-    ./alkos_cli.bash -v -r
-    ```
-
-    Note: This assumes you have the necessary dependencies, generated a config using `configure.bash` and have a cross-compiler toolchain for the chosen architecture.
-
-
-### ▶️ Running AlkOS in QEMU
-
-The `-r` flag of `alkos_cli.bash` also handles running AlkOS in QEMU after building it. It invokes `run_alkos.bash` script. This script will start QEMU with the correct parameters, including booting from the generated ISO image.
-
-   ```bash
-   ./alkos_cli.bash -v -r
-   ```
-
-### Setting up pre-commit hooks
-
-The `-g` flag of `alkos_cli.bash` sets up default git hook dir of this repository to `scripts/git-hooks`
-   ```bash
-   ./alkos_cli.bash -g
-   ```
-
-### 🧪 Running Tests
-
-AlkOS includes a custom testing framework inspired by Google Test. Tests are defined within the kernel code and are executed in the QEMU environment.
-
-1.  **Navigate to the scripts directory:**
-
-    ```
-    cd AlkOS/scripts
-    ```
-
-2.  **Run the test framework:**
-
-    ```
-    ./actions/run_tests.bash
-    ```
-
-    The build process must have been run at least once before running the tests, also the test configuration must have been set.
-    Changing the configuration to one which supports tests requires a rebuild before running this script.
-
-### 🐛 Debugging with GDB
-
-1.  **Build the project in debug mode (default when using `debug_qemu` or `debug_qemu_tests`).**
-2.  **Run AlkOS in QEMU with GDB debugging enabled:**
-
-    ```
-    ./actions/run_alkos.bash -v -g
-    ```
-
-    This will start QEMU with the `-s` and `-S` flags, which will make QEMU wait for a GDB connection on port 1234.
-3.  **In a separate terminal, attach GDB to the running QEMU instance:**
-
-    ```
-    ./install/attach_to_qemu_gdb.bash <path_to_kernel_binary> -g <path_to_gdb>
-    ```
-
-    Replace `<path_to_kernel_binary>` with the path to your compiled kernel binary (e.g. `../build/alkos/sysroot/boot/alkos.kernel`).
-    Replace `<path_to_gdb>` with the path to your GDB executable appropiate for the architecture (in tools).
-
-### 🎨 Applying clang-format for Code Style
-
-1.  **Navigate to the scripts directory:**
-
-    ```bash
-    cd AlkOS/scripts
-    ```
-
-2.  **Run the clang-format script:**
-
-    ```bash
-    ./actions/apply_clang_format.bash
-    ```
-
-    This will format all C++ and C source files according to the project's style defined in `.clang-format` file.
-
-### 🔧 Shell Completions for Scripts
-
-AlkOS provides shell completions for main project scripts to improve developer productivity. The completion generator supports bash, zsh, and fish shells.
-
-#### Setting Up Completions
-
-1.  **Navigate to the scripts directory:**
-
-    ```bash
-    cd AlkOS/scripts
-    ```
-
-2.  **Generate and enable completions for your shell:**
-
-    For bash:
-    ```bash
-    ./completions/generate.bash bash --run --enable
-    ```
-
-    For zsh:
-    ```bash
-    ./completions/generate.bash zsh --run --enable
-    ```
-
-    For fish:
-    ```bash
-    ./completions/generate.bash fish --run --enable
-    ```
-    
-#### Disabling Completions
-
-To disable completions for any shell:
+### 🔧 Debugging
 
+To attach GDB to a running QEMU instance:
 ```bash
-./completions/generate.bash <shell> --disable
-```
-
-#### Regenerating Completions
+# Terminal 1
+./scripts/alkos_cli.bash --run --gdb
 
-If you add new scripts or modify existing ones, just regenerate the completions:
-
-```bash
-./completions/generate.bash <shell> --run
+# Terminal 2
+./scripts/install/attach_to_qemu_gdb.bash build/alkos/sysroot/boot/alkos.kernel
 ```
 
-#### Supported Features
-
-The generated completions provide:
-
-- **Command completion**: Tab completion for all available scripts
-- **Option completion**: Completion for script flags and options (e.g., `--verbose`, `-h`)
-- **Argument completion**: Context-aware completion for script arguments
-- **Choice completion**: Predefined choices for parameters (e.g., architecture types, build modes)
-- **Path completion**: File or directory completion where appropriate
-
-## 📄 License
+### 📄 License
 
-This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+MIT License. See [LICENSE](LICENSE).

From 7320c59643c662cb77674d61c727a4696ff6a058 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C5=81ukasz=20Kryczka?= <lukasz.kryczka000@gmail.com>
Date: Wed, 7 Jan 2026 20:23:39 +0100
Subject: [PATCH 54/56] docs: Add test running instructions to README and
 create tests README

---
 README.md       | 16 ++++++++++++++++
 tests/README.md |  1 +
 2 files changed, 17 insertions(+)
 create mode 100644 tests/README.md

diff --git a/README.md b/README.md
index 0405844f..fdb82c1f 100644
--- a/README.md
+++ b/README.md
@@ -76,6 +76,22 @@ To attach GDB to a running QEMU instance:
 ./scripts/install/attach_to_qemu_gdb.bash build/alkos/sysroot/boot/alkos.kernel
 ```
 
+### Tests
+
+To run UT:
+
+Build AlkOS in test mode
+```bash
+./scripts/actions/build_and_run_tests.bash
+```
+
+Run tests
+```
+./scripts/actions/run_tests.bash
+```
+
+```
+
 ### 📄 License
 
 MIT License. See [LICENSE](LICENSE).
diff --git a/tests/README.md b/tests/README.md
new file mode 100644
index 00000000..b858f0a7
--- /dev/null
+++ b/tests/README.md
@@ -0,0 +1 @@
+The unit tests run in a custom kernel framework and are placed in `kernel/test`

From 11b53e25e7e65717515ba32ef7a725564f4ef27a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C5=81ukasz=20Kryczka?= <lukasz.kryczka000@gmail.com>
Date: Wed, 7 Jan 2026 20:24:07 +0100
Subject: [PATCH 55/56] docs: Remove extra code block from README

---
 README.md | 2 --
 1 file changed, 2 deletions(-)

diff --git a/README.md b/README.md
index fdb82c1f..1f208cef 100644
--- a/README.md
+++ b/README.md
@@ -90,8 +90,6 @@ Run tests
 ./scripts/actions/run_tests.bash
 ```
 
-```
-
 ### 📄 License
 
 MIT License. See [LICENSE](LICENSE).

From 0cb36829af9fc345fc3993a5a2c6f768e8e74892 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C5=81ukasz=20Kryczka?= <lukasz.kryczka000@gmail.com>
Date: Wed, 7 Jan 2026 20:34:29 +0100
Subject: [PATCH 56/56] docs: Update memory management description in README

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 1f208cef..032082f7 100644
--- a/README.md
+++ b/README.md
@@ -9,7 +9,7 @@ A modern kernel written in **C++23**. Can run doom.
 ### ⚡ Capabilities
 
 *   **Architecture:** Portable HAL-based core (x86_64 implemented), Higher Half, SMP-ready.
-*   **Memory:** PMM (Buddy/Bitmap), VMM (Recursive mapping, VMA), Heap (Slab).
+*   **Memory:** PMM (Buddy/Bitmap), VMM (Higher Half Direct Map, VMA), Heap (Slab).
 *   **Scheduling:** Preemptive Multitasking via MLFQ and Round Robin policies.
 *   **Userspace:** Ring 3 isolation, ELF64 loader, Syscall interface (`int 0x80`).
 *   **Filesystem:** VFS abstraction with FAT12/16/32 and Initrd support.