misc: C++->CHEADmain

I know; it's POINTLESS! However, I do enjoy programming in C more than
C++ so I ended up spending the hour it takes converting this project
from C++ to C.

39 files changed, 205 insertions, 774 deletions

diff --git a/cmake/toolchain.cmake b/cmake/toolchain.cmake
index 152bf45..84cecbc 100644
--- a/cmake/toolchain.cmake
+++ b/cmake/toolchain.cmake
@@ -6,6 +6,9 @@ set(CMAKE_ASM_COMPILER nasm)
 set(CMAKE_CXX_LINK_EXECUTABLE
   "<CMAKE_LINKER> <FLAGS> <CMAKE_CXX_LINK_FLAGS> <LINK_FLAGS> <OBJECTS> -o <TARGET> <LINK_LIBRARIES>"
 )
+set(CMAKE_C_LINK_EXECUTABLE
+  "<CMAKE_LINKER> <FLAGS> <CMAKE_CXX_LINK_FLAGS> <LINK_FLAGS> <OBJECTS> -o <TARGET> <LINK_LIBRARIES>"
+)
 
 set(CMAKE_ASM_NASM_COMPILER nasm)
 set(CMAKE_ASM_NASM_SOURCE_FILE_EXTENSIONS s)
diff --git a/kernel/CMakeLists.txt b/kernel/CMakeLists.txt
index 56b783a..46d4fd7 100644
--- a/kernel/CMakeLists.txt
+++ b/kernel/CMakeLists.txt
@@ -2,33 +2,33 @@ cmake_minimum_required(VERSION 3.21)
 project(kernel C ASM_NASM)
 
 set(SRC
-  boot/gdt/gdt.cc
+  boot/gdt/gdt.c
   boot/gdt/gdt.s
   boot/init/boot.s
   boot/init/crti.s
   boot/init/crtn.s
-  boot/interrupts/exceptions.cc
-  boot/interrupts/idt.cc
-  boot/interrupts/interrupts.cc
+  boot/interrupts/exceptions.c
+  boot/interrupts/idt.c
+  boot/interrupts/interrupts.c
   boot/interrupts/isr.s
-  drivers/serial.cc
-  drivers/vga_text_buffer.cc
-  kernel/halt.cc
-  kernel/io.cc
-  kernel/kernel.cc
-  kernel/spinlock.cc
-  kernel/stack_smashing_protector.cc
-  libk/liballoc.cc
-  libk/memset.cc
-  libk/printf.cc
-  libk/printk.cc
-  libk/strlen.cc
-  mm/memory_map.cc
-  mm/physical_mm/bitmap.cc
-  mm/physical_mm/physical_mm.cc
-  mm/virtual_mm/page_table_allocator.cc
-  mm/virtual_mm/pages.cc
-  mm/virtual_mm/virtual_mm.cc
+  drivers/serial.c
+  drivers/vga_text_buffer.c
+  kernel/halt.c
+  kernel/io.c
+  kernel/kernel.c
+  kernel/spinlock.c
+  kernel/stack_smashing_protector.c
+  libk/liballoc.c
+  libk/memset.c
+  libk/printf.c
+  libk/printk.c
+  libk/strlen.c
+  mm/memory_map.c
+  mm/physical_mm/bitmap.c
+  mm/physical_mm/physical_mm.c
+  mm/virtual_mm/page_table_allocator.c
+  mm/virtual_mm/pages.c
+  mm/virtual_mm/virtual_mm.c
 )
 
 add_executable(kernel ${SRC})
diff --git a/kernel/boot/gdt/gdt.cc b/kernel/boot/gdt/gdt.c
index bf53566..3728b32 100644
--- a/kernel/boot/gdt/gdt.cc
+++ b/kernel/boot/gdt/gdt.c
@@ -18,10 +18,7 @@
 
 #include <boot/gdt.h>
 
-namespace GDT
-{
-
-entry_t l_entries[] = {
+static gdt_entry_t l_entries[] = {
   /* NULL Descriptor */
   GDT_ENTRY(0, 0, 0, 0),
 
@@ -41,12 +38,10 @@ entry_t l_entries[] = {
   /* TODO: LDT? */
 };
 
-descriptor_t descriptor = { sizeof(l_entries) - 1, l_entries };
+static gdt_descriptor_t descriptor = { sizeof(l_entries) - 1, l_entries };
 
 void
-load(void)
+gdt_load(void)
 {
   _GDT_flush(&descriptor);
 }
-
-}
diff --git a/kernel/boot/interrupts/exceptions.cc b/kernel/boot/interrupts/exceptions.c
index 964d025..fadd3b0 100644
--- a/kernel/boot/interrupts/exceptions.cc
+++ b/kernel/boot/interrupts/exceptions.c
@@ -22,9 +22,6 @@
 #include <libk/stdio.h>
 #include <stdbool.h>
 
-namespace Interrupts
-{
-
 void
 exception_handler(int irq_number)
 {
@@ -34,5 +31,3 @@ exception_handler(int irq_number)
   while (true)
     __asm__ volatile("cli; hlt");
 }
-
-}
diff --git a/kernel/boot/interrupts/idt.cc b/kernel/boot/interrupts/idt.c
index 1b42853..dadb7c1 100644
--- a/kernel/boot/interrupts/idt.cc
+++ b/kernel/boot/interrupts/idt.c
@@ -22,13 +22,10 @@
 #include <kernel/io.h>
 #include <libk/stdio.h>
 
-namespace Interrupts
-{
-
-extern "C" void *isr_stub_table[];
+extern void *isr_stub_table[];
 
-entry_t l_entries[256];
-descriptor_t descriptor = { sizeof(l_entries) - 1, l_entries };
+static entry_t l_entries[256];
+static descriptor_t descriptor = { sizeof(l_entries) - 1, l_entries };
 static bool l_idt_loaded = false;
 
 bool
@@ -38,7 +35,7 @@ idt_loaded(void)
 }
 
 void
-load_idt(void)
+idt_load(void)
 {
   for (uint16_t i = 0; i < 256; i++)
     l_entries[i] = (entry_t) { 0 };
@@ -53,5 +50,3 @@ load_idt(void)
 
   l_idt_loaded = true;
 }
-
-}
diff --git a/kernel/boot/interrupts/interrupts.cc b/kernel/boot/interrupts/interrupts.c
index b3f13a2..e15cbdc 100644
--- a/kernel/boot/interrupts/interrupts.cc
+++ b/kernel/boot/interrupts/interrupts.c
@@ -22,21 +22,18 @@
 #include <kernel/io.h>
 #include <libk/stdio.h>
 
-namespace Interrupts
-{
-
 void
-initialize()
+interrupts_initialize(void)
 {
-  load_idt();
+  idt_load();
   printk("\ninterrupts", "IDT Loaded.");
 
-  enable();
+  interrupts_enable();
   printk("interrupts", "Initialized.");
 }
 
 void
-enable(void)
+interrupts_enable(void)
 {
   if (!idt_loaded()) {
     printk("interrupts", "Attempt to enable before IDT load.");
@@ -48,10 +45,8 @@ enable(void)
 }
 
 void
-disable(void)
+interrupts_disable(void)
 {
   __asm__ volatile("cli");
   // printk("\ninterrupts", "Disabled.");
 }
-
-}
diff --git a/kernel/drivers/serial.cc b/kernel/drivers/serial.c
index df40481..bec5245 100644
--- a/kernel/drivers/serial.cc
+++ b/kernel/drivers/serial.c
@@ -25,11 +25,8 @@
 /* Implementation adapted from
  * https://wiki.osdev.org/Inline_Assembly/Examples */
 
-namespace Serial
-{
-
 bool
-initialize(void)
+serial_initialize(void)
 {
   outb(PORT + 1, 0x00); // Disable all interrupts
   outb(PORT + 3, 0x80); // Enable DLAB (set baud rate divisor)
@@ -61,7 +58,7 @@ is_transmit_empty(void)
 }
 
 void
-write_char(const char chr)
+serial_write_char(const char chr)
 {
   while (is_transmit_empty() == 0)
     ;
@@ -70,11 +67,9 @@ write_char(const char chr)
 }
 
 void
-write_string(const char *string)
+serial_write_string(const char *string)
 {
   size_t size = strlen(string);
   for (size_t i = 0; i < size; i++)
-    write_char(string[i]);
-}
-
+    serial_write_char(string[i]);
 }
diff --git a/kernel/drivers/vga_text_buffer.cc b/kernel/drivers/vga_text_buffer.c
index 69b1fe3..ee0a1ea 100644
--- a/kernel/drivers/vga_text_buffer.cc
+++ b/kernel/drivers/vga_text_buffer.c
@@ -29,14 +29,10 @@
 
 #include <drivers/vga_text_buffer.h>
 
-namespace VGATextBuffer
-{
-
 static uint16_t *l_buffer = (uint16_t *) 0xB8000;
 static uint8_t l_row = 0;
 static uint8_t l_column = 0;
-static uint8_t l_color = vga_entry_color(VGATextBuffer::COLOR_LIGHT_GREY,
-                                         VGATextBuffer::COLOR_BLACK);
+static uint8_t l_color = vga_entry_color(COLOR_LIGHT_GREY, COLOR_BLACK);
 
 ALWAYS_INLINE static void
 write_entry_at(const char c,
@@ -49,7 +45,7 @@ write_entry_at(const char c,
 }
 
 void
-initialize(void)
+vgatb_initialize(void)
 {
   /*
    * Disable the cursor
@@ -64,7 +60,7 @@ initialize(void)
 }
 
 void
-write_char(const char c)
+vgatb_write_char(const char c)
 {
   if (c == '\n') {
     l_row++;
@@ -81,15 +77,15 @@ write_char(const char c)
 }
 
 void
-write_string(const char *string)
+vgatb_write_string(const char *string)
 {
   size_t size = strlen(string);
   for (size_t i = 0; i < size; i++)
-    write_char(string[i]);
+    vgatb_write_char(string[i]);
 }
 
 void
-printf(const char *string, ...)
+vgatb_printf(const char *string, ...)
 {
   /* TODO: Dynamic Memory Allocation */
   char str[256];
@@ -99,7 +95,5 @@ printf(const char *string, ...)
   vsnprintf(str, sizeof(str), string, ap);
   va_end(ap);
 
-  write_string(str);
-}
-
+  vgatb_write_string(str);
 }
diff --git a/kernel/include/boot/gdt.h b/kernel/include/boot/gdt.h
index 49067bd..b104db8 100644
--- a/kernel/include/boot/gdt.h
+++ b/kernel/include/boot/gdt.h
@@ -92,9 +92,6 @@
 #define GDT_KERNEL_CODE_OFFSET 0x8
 #define GDT_KERNEL_DATA_OFFSET 0x10
 
-namespace GDT
-{
-
 typedef struct {
   uint16_t limit_low;
   uint16_t base_low;
@@ -102,18 +99,16 @@ typedef struct {
   uint8_t access_flags;
   uint8_t flags_limit_high;
   uint8_t base_high;
-} PACKED entry_t;
+} PACKED gdt_entry_t;
 
 typedef struct {
-  uint16_t limit; /* sizeof(GDT) - 1 */
-  entry_t *ptr;   /* Address of GDT */
-} PACKED descriptor_t;
-
-extern "C" void _GDT_flush(descriptor_t *descriptor);
+  uint16_t limit;   /* sizeof(GDT) - 1 */
+  gdt_entry_t *ptr; /* Address of GDT */
+} PACKED gdt_descriptor_t;
 
-void initialize(void);
-void load(void);
+void _GDT_flush(gdt_descriptor_t *descriptor);
 
-}
+void gdt_initialize(void);
+void gdt_load(void);
 
 #endif
diff --git a/kernel/include/boot/interrupts.h b/kernel/include/boot/interrupts.h
index 4df66e9..d436d30 100644
--- a/kernel/include/boot/interrupts.h
+++ b/kernel/include/boot/interrupts.h
@@ -21,6 +21,7 @@
 
 #include <boot/gdt.h>
 #include <common.h>
+#include <stdbool.h>
 #include <stdint.h>
 
 #define IDT_ENTRY(isr, attributes)                                            \
@@ -36,14 +37,11 @@
 #define IDT_PRESENT (1 << 7)
 #define IDT_KERNEL_PRIVILEGE_LEVEL (0)
 #define IDT_USER_PRIVILEGE_LEVEL (3 << 5)
-#define IDT_TASK_GATE (0b0101)
-#define IDT_16BIT_INTERRUPT_GATE (0b0110)
-#define IDT_16BIT_TRAP_GATE (0b0111)
-#define IDT_32BIT_INTERRUPT_GATE (0b1110)
-#define IDT_32BIT_TRAP_GATE (0b1111)
-
-namespace Interrupts
-{
+#define IDT_TASK_GATE (0x05)
+#define IDT_16BIT_INTERRUPT_GATE (0x06)
+#define IDT_16BIT_TRAP_GATE (0x07)
+#define IDT_32BIT_INTERRUPT_GATE (0x0e)
+#define IDT_32BIT_TRAP_GATE (0x0f)
 
 typedef struct {
   uint16_t isr_low;
@@ -59,16 +57,14 @@ typedef struct {
 } PACKED descriptor_t;
 
 /* Simply loads IDT and enables interrupts */
-void initialize(void);
-void enable(void);
-void disable(void);
+void interrupts_initialize(void);
+void interrupts_enable(void);
+void interrupts_disable(void);
 
 /* IDT */
-void load_idt(void);
+void idt_load(void);
 bool idt_loaded(void);
 
-extern "C" NORETURN void exception_handler(int irq_number);
-
-}
+NORETURN void exception_handler(int irq_number);
 
 #endif
diff --git a/kernel/include/drivers/serial.h b/kernel/include/drivers/serial.h
index 33947eb..48ed75c 100644
--- a/kernel/include/drivers/serial.h
+++ b/kernel/include/drivers/serial.h
@@ -23,13 +23,8 @@
 
 #define PORT 0x3f8 // COM1
 
-namespace Serial
-{
-
-bool initialize(void);
-void write_char(const char chr);
-void write_string(const char *string);
-
-}
+bool serial_initialize(void);
+void serial_write_char(const char chr);
+void serial_write_string(const char *string);
 
 #endif
diff --git a/kernel/include/drivers/vga_text_buffer.h b/kernel/include/drivers/vga_text_buffer.h
index 389c864..ada5228 100644
--- a/kernel/include/drivers/vga_text_buffer.h
+++ b/kernel/include/drivers/vga_text_buffer.h
@@ -43,9 +43,6 @@
 #define vga_entry(character, color)                                           \
   ((uint16_t) color << 8 | (uint16_t) character)
 
-namespace VGATextBuffer
-{
-
 /* Hardware text mode color constants. */
 typedef enum {
   COLOR_BLACK = 0,
@@ -64,13 +61,11 @@ typedef enum {
   COLOR_LIGHT_MAGENTA = 13,
   COLOR_LIGHT_BROWN = 14,
   COLOR_WHITE = 15
-} colors;
-
-void initialize(void);
-void write_char(const char);
-void write_string(const char *string);
-void printf(const char *string, ...);
+} vgatb_colors;
 
-}
+void vgatb_initialize(void);
+void vgatb_write_char(const char);
+void vgatb_write_string(const char *string);
+void vgatb_printf(const char *string, ...);
 
 #endif
diff --git a/kernel/include/kernel/spinlock.h b/kernel/include/kernel/spinlock.h
index bd255ad..70c0303 100644
--- a/kernel/include/kernel/spinlock.h
+++ b/kernel/include/kernel/spinlock.h
@@ -23,14 +23,7 @@
 
 typedef uint8_t spinlock_t;
 
-class Spinlock
-{
-private:
-  spinlock_t m_lock;
-
-public:
-  void acquire(void);
-  void release(void);
-};
+void spinlock_acquire(spinlock_t *lock);
+void spinlock_release(spinlock_t *lock);
 
 #endif
diff --git a/kernel/include/libk/liballoc.h b/kernel/include/libk/liballoc.h
index b1568e9..82186c4 100644
--- a/kernel/include/libk/liballoc.h
+++ b/kernel/include/libk/liballoc.h
@@ -21,9 +21,6 @@
 
 #include <stddef.h>
 
-namespace LibAlloc
-{
-
 /** This is a boundary tag which is prepended to the
  * page or section of a page which we have allocated. It is
  * used to identify valid memory blocks that the
@@ -47,6 +44,4 @@ void *krealloc(void *, size_t);
 void *kcalloc(size_t, size_t);
 void kfree(void *);
 
-}
-
 #endif
diff --git a/kernel/include/libk/stdio.h b/kernel/include/libk/stdio.h
index 44050dd..f944fe4 100644
--- a/kernel/include/libk/stdio.h
+++ b/kernel/include/libk/stdio.h
@@ -22,10 +22,6 @@
 #include <stdarg.h>
 #include <stddef.h>
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 typedef int (*_printf_engine_output_func)(const char *str,
                                           size_t len,
                                           void *state);
@@ -43,8 +39,4 @@ int vsnprintf(char *str, size_t len, const char *fmt, va_list ap);
 void printk(const char *from, const char *msg, ...);
 void printk_raw(const char *msg, ...);
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif
diff --git a/kernel/include/libk/string.h b/kernel/include/libk/string.h
index 8ea5b92..88b9888 100644
--- a/kernel/include/libk/string.h
+++ b/kernel/include/libk/string.h
@@ -21,15 +21,7 @@
 
 #include <stddef.h>
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 size_t strlen(const char *str);
 void *memset(void *s, int c, size_t n);
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif
diff --git a/kernel/include/mm/memory_map.h b/kernel/include/mm/memory_map.h
index de8296b..ec67b64 100644
--- a/kernel/include/mm/memory_map.h
+++ b/kernel/include/mm/memory_map.h
@@ -30,12 +30,7 @@ typedef struct {
   multiboot_memory_map_t *region_list[MAX_FREE_REGIONS];
 } free_memory_regions_t;
 
-namespace MemoryMap
-{
-
-void load(multiboot_info_t *mmap);
-free_memory_regions_t *get_free_regions(void);
-
-}
+void mmap_load(multiboot_info_t *mmap);
+free_memory_regions_t *mmap_get_free_regions(void);
 
 #endif
diff --git a/kernel/include/mm/multiboot.h b/kernel/include/mm/multiboot.h
index d95ab55..d7cd8cc 100644
--- a/kernel/include/mm/multiboot.h
+++ b/kernel/include/mm/multiboot.h
@@ -94,10 +94,6 @@
 
 #ifndef ASM_FILE
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 typedef uint8_t multiboot_uint8_t;
 typedef uint16_t multiboot_uint16_t;
 typedef uint32_t multiboot_uint32_t;
@@ -271,10 +267,6 @@ struct multiboot_apm_info {
   multiboot_uint16_t dseg_len;
 };
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif /* ! ASM_FILE */
 
 #endif /* ! MULTIBOOT_HEADER */
diff --git a/kernel/include/mm/page_table_allocator.h b/kernel/include/mm/page_table_allocator.h
index 4a0b0fb..80de80e 100644
--- a/kernel/include/mm/page_table_allocator.h
+++ b/kernel/include/mm/page_table_allocator.h
@@ -21,12 +21,7 @@
 
 #include <stdint.h>
 
-namespace PageTableAllocator
-{
-
-uint32_t *allocate(void);
-void initialize(void);
-
-}
+uint32_t *pta_allocate(void);
+void pta_initialize(void);
 
 #endif
diff --git a/kernel/include/mm/physical.h b/kernel/include/mm/physical.h
new file mode 100644
index 0000000..8f79e1c
--- /dev/null
+++ b/kernel/include/mm/physical.h
@@ -0,0 +1,2 @@
+
+pmm_initialize
diff --git a/kernel/include/mm/physical_mm.h b/kernel/include/mm/physical_mm.h
index abdf178..d10b010 100644
--- a/kernel/include/mm/physical_mm.h
+++ b/kernel/include/mm/physical_mm.h
@@ -34,40 +34,35 @@
  */
 #define MAX_BLOCKS 1048576
 
-namespace PhysicalMM
-{
-
 /* Initialize the memory map by getting all free regions, setting all blocks to
  * used, initializing regions marked free by the memory map provided by
  * multiboot, and deinitializing the memory used by the kernel */
-void initialize(void);
+void pmm_initialize(void);
 
 /* Find and allocate a free memory block, returning the physical address of the
  * block */
-void *allocate_block(void);
+void *pmm_allocate_block(void);
 
 /* Free an allocated memory block, given the physical address (from
  * allocate_block) */
-void free_block(void *physical_address);
+void pmm_free_block(void *physical_address);
 
 /*-- BITMAP --*/
 
 /* Marks the block as 'used' */
-void set_used(const uint32_t bit,
-              uint32_t *total_free_blocks,
-              uint32_t *memory_map);
+void pmm_set_used(const uint32_t bit,
+                  uint32_t *total_free_blocks,
+                  uint32_t *memory_map);
 
 /* Marks the block as 'unused' */
-void set_usable(const uint32_t bit,
-                uint32_t *total_free_blocks,
-                uint32_t *memory_map);
+void pmm_set_usable(const uint32_t bit,
+                    uint32_t *total_free_blocks,
+                    uint32_t *memory_map);
 
 /* Returns:
  * True if the bit is set (block is in use)
  * False if the bit is unset (block isn't in use)
  */
-bool test_bit(const uint32_t bit, uint32_t *memory_map);
-
-}
+bool pmm_test_bit(const uint32_t bit, uint32_t *memory_map);
 
 #endif
diff --git a/kernel/include/mm/virtual_mm.h b/kernel/include/mm/virtual_mm.h
index 818ce8b..4583fc0 100644
--- a/kernel/include/mm/virtual_mm.h
+++ b/kernel/include/mm/virtual_mm.h
@@ -69,51 +69,46 @@
 #define VIRTUAL_ADDRESS(pd_index, pt_index)                                   \
   (((pd_index) << 22) | ((pt_index) << 12))
 
-namespace VirtualMM
-{
-
-uint32_t *get_page_directory(void);
+uint32_t *vmm_get_page_directory(void);
 
 /*
  * Loads a given page directory into CR0
  */
-void load_page_directory(uint32_t *page_directory);
+void vmm_load_page_directory(uint32_t *page_directory);
 
 /*
  * Switches the current page directory to a given page directory
  */
-bool switch_page_directory(uint32_t *page_directory);
+bool vmm_switch_page_directory(uint32_t *page_directory);
 
 /*
  * Initialize the virtual memory manager
  */
-void initialize(void);
+void vmm_initialize(void);
 
 /*
  * Map a physical address to a virtual address
  */
-void map_page(void *physical_address, void *virtual_address);
+void vmm_map_page(void *physical_address, void *virtual_address);
 
 /*
  * Unmap a page starting at virtual address
  */
-void unmap_page(void *virtual_address);
+void vmm_unmap_page(void *virtual_address);
 
 /*
  * Find a virtual address with n consecutive free addresses.
  */
-void *find_free_pages(uint32_t n_pages);
+void *vmm_find_free_pages(uint32_t n_pages);
 
 /*
  * Allocate and map n pages.
  */
-void *alloc_pages(uint32_t n_pages);
+void *vmm_alloc_pages(uint32_t n_pages);
 
 /*
  * Free n pages from the starting address.
  */
-void free_pages(void *starting_address, uint32_t n_pages);
-
-}
+void vmm_free_pages(void *starting_address, uint32_t n_pages);
 
 #endif
diff --git a/kernel/include/stddef.h b/kernel/include/stddef.h
index 46341d7..0510010 100644
--- a/kernel/include/stddef.h
+++ b/kernel/include/stddef.h
@@ -1,465 +1,29 @@
-/* Copyright (C) 1989-2025 Free Software Foundation, Inc.
-
-This file is part of GCC.
-
-GCC is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 3, or (at your option)
-any later version.
-
-GCC is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-Under Section 7 of GPL version 3, you are granted additional
-permissions described in the GCC Runtime Library Exception, version
-3.1, as published by the Free Software Foundation.
-
-You should have received a copy of the GNU General Public License and
-a copy of the GCC Runtime Library Exception along with this program;
-see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
-<http://www.gnu.org/licenses/>.  */
-
-/* https://github.com/gcc-mirror/gcc/blob/master/gcc/ginclude/stddef.h */
-
-/*
- * ISO C Standard:  7.17  Common definitions  <stddef.h>
- */
-#if (!defined(_STDDEF_H) && !defined(_STDDEF_H_) && !defined(_ANSI_STDDEF_H) \
-     && !defined(__STDDEF_H__)) \
-    || defined(__need_wchar_t) || defined(__need_size_t) \
-    || defined(__need_ptrdiff_t) || defined(__need_NULL) \
-    || defined(__need_wint_t)
-
-/* Any one of these symbols __need_* means that GNU libc
-   wants us just to define one data type.  So don't define
-   the symbols that indicate this file's entire job has been done.  */
-#if (!defined(__need_wchar_t) && !defined(__need_size_t)	\
-     && !defined(__need_ptrdiff_t) && !defined(__need_NULL)	\
-     && !defined(__need_wint_t))
+#ifndef _STDDEF_H
 #define _STDDEF_H
-#define _STDDEF_H_
-/* snaroff@next.com says the NeXT needs this.  */
-#define _ANSI_STDDEF_H
-#endif
 
-#ifndef __sys_stdtypes_h
-/* This avoids lossage on SunOS but only if stdtypes.h comes first.
-   There's no way to win with the other order!  Sun lossage.  */
+#ifndef _BITSIZE_STDDEF_H
+#define _BITSIZE_STDDEF_H
 
-#if defined(__NetBSD__)
-#include <machine/ansi.h>
-#endif
-
-#if defined (__FreeBSD__)
-#include <sys/_types.h>
-#endif
-
-#if defined(__NetBSD__)
-#if !defined(_SIZE_T_) && !defined(_BSD_SIZE_T_)
 #define _SIZE_T
-#endif
-#if !defined(_PTRDIFF_T_) && !defined(_BSD_PTRDIFF_T_)
-#define _PTRDIFF_T
-#endif
-/* On BSD/386 1.1, at least, machine/ansi.h defines _BSD_WCHAR_T_
-   instead of _WCHAR_T_. */
-#if !defined(_WCHAR_T_) && !defined(_BSD_WCHAR_T_)
-#ifndef _BSD_WCHAR_T_
-#define _WCHAR_T
-#endif
-#endif
-/* Undef _FOO_T_ if we are supposed to define foo_t.  */
-#if defined (__need_ptrdiff_t) || defined (_STDDEF_H_)
-#undef _PTRDIFF_T_
-#undef _BSD_PTRDIFF_T_
-#endif
-#if defined (__need_size_t) || defined (_STDDEF_H_)
-#undef _SIZE_T_
-#undef _BSD_SIZE_T_
-#endif
-#if defined (__need_wchar_t) || defined (_STDDEF_H_)
-#undef _WCHAR_T_
-#undef _BSD_WCHAR_T_
-#endif
-#endif /* defined(__NetBSD__) */
-
-/* Sequent's header files use _PTRDIFF_T_ in some conflicting way.
-   Just ignore it.  */
-#if defined (__sequent__) && defined (_PTRDIFF_T_)
-#undef _PTRDIFF_T_
-#endif
-
-/* On VxWorks, <type/vxTypesBase.h> may have defined macros like
-   _TYPE_size_t which will typedef size_t.  fixincludes patched the
-   vxTypesBase.h so that this macro is only defined if _GCC_SIZE_T is
-   not defined, and so that defining this macro defines _GCC_SIZE_T.
-   If we find that the macros are still defined at this point, we must
-   invoke them so that the type is defined as expected.  */
-#if defined (_TYPE_ptrdiff_t) && (defined (__need_ptrdiff_t) || defined (_STDDEF_H_))
-_TYPE_ptrdiff_t;
-#undef _TYPE_ptrdiff_t
-#endif
-#if defined (_TYPE_size_t) && (defined (__need_size_t) || defined (_STDDEF_H_))
-_TYPE_size_t;
-#undef _TYPE_size_t
-#endif
-#if defined (_TYPE_wchar_t) && (defined (__need_wchar_t) || defined (_STDDEF_H_))
-_TYPE_wchar_t;
-#undef _TYPE_wchar_t
-#endif
-
-/* In case nobody has defined these types, but we aren't running under
-   GCC 2.00, make sure that __PTRDIFF_TYPE__, __SIZE_TYPE__, and
-   __WCHAR_TYPE__ have reasonable values.  This can happen if the
-   parts of GCC is compiled by an older compiler, that actually
-   include gstddef.h, such as collect2.  */
-
-/* Signed type of difference of two pointers.  */
-
-/* Define this type if we are doing the whole job,
-   or if we want this type in particular.  */
-#if defined (_STDDEF_H) || defined (__need_ptrdiff_t)
-#ifndef _PTRDIFF_T	/* in case <sys/types.h> has defined it. */
-#ifndef _T_PTRDIFF_
-#ifndef _T_PTRDIFF
-#ifndef __PTRDIFF_T
-#ifndef _PTRDIFF_T_
-#ifndef _BSD_PTRDIFF_T_
-#ifndef ___int_ptrdiff_t_h
-#ifndef _GCC_PTRDIFF_T
-#ifndef _PTRDIFF_T_DECLARED /* DragonFly */
-#ifndef __DEFINED_ptrdiff_t /* musl libc */
-#define _PTRDIFF_T
-#define _T_PTRDIFF_
-#define _T_PTRDIFF
-#define __PTRDIFF_T
-#define _PTRDIFF_T_
-#define _BSD_PTRDIFF_T_
-#define ___int_ptrdiff_t_h
-#define _GCC_PTRDIFF_T
-#define _PTRDIFF_T_DECLARED
-#define __DEFINED_ptrdiff_t
-#ifndef __PTRDIFF_TYPE__
-#define __PTRDIFF_TYPE__ long int
-#endif
-typedef __PTRDIFF_TYPE__ ptrdiff_t;
-#endif /* __DEFINED_ptrdiff_t */
-#endif /* _PTRDIFF_T_DECLARED */
-#endif /* _GCC_PTRDIFF_T */
-#endif /* ___int_ptrdiff_t_h */
-#endif /* _BSD_PTRDIFF_T_ */
-#endif /* _PTRDIFF_T_ */
-#endif /* __PTRDIFF_T */
-#endif /* _T_PTRDIFF */
-#endif /* _T_PTRDIFF_ */
-#endif /* _PTRDIFF_T */
-
-/* If this symbol has done its job, get rid of it.  */
-#undef	__need_ptrdiff_t
-
-#endif /* _STDDEF_H or __need_ptrdiff_t.  */
-
-/* Unsigned type of `sizeof' something.  */
-
-/* Define this type if we are doing the whole job,
-   or if we want this type in particular.  */
-#if defined (_STDDEF_H) || defined (__need_size_t)
-#ifndef __size_t__	/* BeOS */
-#ifndef __SIZE_T__	/* Cray Unicos/Mk */
-#ifndef _SIZE_T	/* in case <sys/types.h> has defined it. */
-#ifndef _SYS_SIZE_T_H
-#ifndef _T_SIZE_
-#ifndef _T_SIZE
-#ifndef __SIZE_T
-#ifndef _SIZE_T_
-#ifndef _BSD_SIZE_T_
-#ifndef _SIZE_T_DEFINED_
-#ifndef _SIZE_T_DEFINED
-#ifndef _BSD_SIZE_T_DEFINED_	/* Darwin */
-#ifndef _SIZE_T_DECLARED	/* FreeBSD 5 */
-#ifndef __DEFINED_size_t	/* musl libc */
-#ifndef ___int_size_t_h
-#ifndef _GCC_SIZE_T
-#ifndef _SIZET_
-#ifndef __size_t
-#define __size_t__	/* BeOS */
-#define __SIZE_T__	/* Cray Unicos/Mk */
-#define _SIZE_T
-#define _SYS_SIZE_T_H
-#define _T_SIZE_
-#define _T_SIZE
-#define __SIZE_T
-#define _SIZE_T_
-#define _BSD_SIZE_T_
-#define _SIZE_T_DEFINED_
-#define _SIZE_T_DEFINED
-#define _BSD_SIZE_T_DEFINED_	/* Darwin */
-#define _SIZE_T_DECLARED	/* FreeBSD 5 */
-#define __DEFINED_size_t	/* musl libc */
-#define ___int_size_t_h
-#define _GCC_SIZE_T
-#define _SIZET_
-#if defined (__FreeBSD__) \
-  || defined(__DragonFly__) \
-  || defined(__FreeBSD_kernel__) \
-  || defined(__VMS__)
-/* __size_t is a typedef, must not trash it.  */
+#if defined(__s390__) || defined(__cris__)
+typedef unsigned long size_t;
 #else
-#define __size_t
-#endif
-#ifndef __SIZE_TYPE__
-#define __SIZE_TYPE__ long unsigned int
-#endif
-#if !(defined (__GNUG__) && defined (size_t))
-typedef __SIZE_TYPE__ size_t;
-#ifdef __BEOS__
-typedef long ssize_t;
-#endif /* __BEOS__ */
-#endif /* !(defined (__GNUG__) && defined (size_t)) */
-#endif /* __size_t */
-#endif /* _SIZET_ */
-#endif /* _GCC_SIZE_T */
-#endif /* ___int_size_t_h */
-#endif /* __DEFINED_size_t */
-#endif /* _SIZE_T_DECLARED */
-#endif /* _BSD_SIZE_T_DEFINED_ */
-#endif /* _SIZE_T_DEFINED */
-#endif /* _SIZE_T_DEFINED_ */
-#endif /* _BSD_SIZE_T_ */
-#endif /* _SIZE_T_ */
-#endif /* __SIZE_T */
-#endif /* _T_SIZE */
-#endif /* _T_SIZE_ */
-#endif /* _SYS_SIZE_T_H */
-#endif /* _SIZE_T */
-#endif /* __SIZE_T__ */
-#endif /* __size_t__ */
-#undef	__need_size_t
-#endif /* _STDDEF_H or __need_size_t.  */
-
-
-/* Wide character type.
-   Locale-writers should change this as necessary to
-   be big enough to hold unique values not between 0 and 127,
-   and not (wchar_t) -1, for each defined multibyte character.  */
-
-/* Define this type if we are doing the whole job,
-   or if we want this type in particular.  */
-#if defined (_STDDEF_H) || defined (__need_wchar_t)
-#ifndef __wchar_t__	/* BeOS */
-#ifndef __WCHAR_T__	/* Cray Unicos/Mk */
-#ifndef _WCHAR_T
-#ifndef _T_WCHAR_
-#ifndef _T_WCHAR
-#ifndef __WCHAR_T
-#ifndef _WCHAR_T_
-#ifndef _BSD_WCHAR_T_
-#ifndef _BSD_WCHAR_T_DEFINED_    /* Darwin */
-#ifndef _BSD_RUNE_T_DEFINED_	/* Darwin */
-#ifndef _WCHAR_T_DECLARED /* FreeBSD 5 */
-#ifndef __DEFINED_wchar_t /* musl libc */
-#ifndef _WCHAR_T_DEFINED_
-#ifndef _WCHAR_T_DEFINED
-#ifndef _WCHAR_T_H
-#ifndef ___int_wchar_t_h
-#ifndef __INT_WCHAR_T_H
-#ifndef _GCC_WCHAR_T
-#define __wchar_t__	/* BeOS */
-#define __WCHAR_T__	/* Cray Unicos/Mk */
-#define _WCHAR_T
-#define _T_WCHAR_
-#define _T_WCHAR
-#define __WCHAR_T
-#define _WCHAR_T_
-#define _BSD_WCHAR_T_
-#define _WCHAR_T_DEFINED_
-#define _WCHAR_T_DEFINED
-#define _WCHAR_T_H
-#define ___int_wchar_t_h
-#define __INT_WCHAR_T_H
-#define _GCC_WCHAR_T
-#define _WCHAR_T_DECLARED
-#define __DEFINED_wchar_t
-
-/* On BSD/386 1.1, at least, machine/ansi.h defines _BSD_WCHAR_T_
-   instead of _WCHAR_T_, and _BSD_RUNE_T_ (which, unlike the other
-   symbols in the _FOO_T_ family, stays defined even after its
-   corresponding type is defined).  If we define wchar_t, then we
-   must undef _WCHAR_T_; for BSD/386 1.1 (and perhaps others), if
-   we undef _WCHAR_T_, then we must also define rune_t, since
-   headers like runetype.h assume that if machine/ansi.h is included,
-   and _BSD_WCHAR_T_ is not defined, then rune_t is available.
-   machine/ansi.h says, "Note that _WCHAR_T_ and _RUNE_T_ must be of
-   the same type." */
-#ifdef _BSD_WCHAR_T_
-#undef _BSD_WCHAR_T_
-#ifdef _BSD_RUNE_T_
-#if !defined (_ANSI_SOURCE) && !defined (_POSIX_SOURCE)
-typedef _BSD_RUNE_T_ rune_t;
-#define _BSD_WCHAR_T_DEFINED_
-#define _BSD_RUNE_T_DEFINED_	/* Darwin */
-#if defined (__FreeBSD__) && (__FreeBSD__ < 5)
-/* Why is this file so hard to maintain properly?  In contrast to
-   the comment above regarding BSD/386 1.1, on FreeBSD for as long
-   as the symbol has existed, _BSD_RUNE_T_ must not stay defined or
-   redundant typedefs will occur when stdlib.h is included after this file. */
-#undef _BSD_RUNE_T_
-#endif
-#endif
-#endif
-#endif
-/* FreeBSD 5 can't be handled well using "traditional" logic above
-   since it no longer defines _BSD_RUNE_T_ yet still desires to export
-   rune_t in some cases... */
-#if defined (__FreeBSD__) && (__FreeBSD__ >= 5)
-#if !defined (_ANSI_SOURCE) && !defined (_POSIX_SOURCE)
-#if __BSD_VISIBLE
-#ifndef _RUNE_T_DECLARED
-typedef __rune_t        rune_t;
-#define _RUNE_T_DECLARED
-#endif
-#endif
-#endif
+typedef unsigned int size_t;
 #endif
 
-#ifndef __WCHAR_TYPE__
-#define __WCHAR_TYPE__ int
-#endif
-#ifndef __cplusplus
-typedef __WCHAR_TYPE__ wchar_t;
-#endif
-#endif
-#endif
-#endif
-#endif
-#endif
-#endif
-#endif /* __DEFINED_wchar_t */
-#endif /* _WCHAR_T_DECLARED */
-#endif /* _BSD_RUNE_T_DEFINED_ */
-#endif
-#endif
-#endif
-#endif
-#endif
-#endif
-#endif
-#endif /* __WCHAR_T__ */
-#endif /* __wchar_t__ */
-#undef	__need_wchar_t
-#endif /* _STDDEF_H or __need_wchar_t.  */
-
-#if defined (__need_wint_t)
-#ifndef _WINT_T
-#define _WINT_T
-
-#ifndef __WINT_TYPE__
-#define __WINT_TYPE__ unsigned int
-#endif
-typedef __WINT_TYPE__ wint_t;
-#endif
-#undef __need_wint_t
-#endif
-
-#if defined(__NetBSD__)
-/*  The references to _GCC_PTRDIFF_T_, _GCC_SIZE_T_, and _GCC_WCHAR_T_
-    are probably typos and should be removed before 2.8 is released.  */
-#ifdef _GCC_PTRDIFF_T_
-#undef _PTRDIFF_T_
-#undef _BSD_PTRDIFF_T_
-#endif
-#ifdef _GCC_SIZE_T_
-#undef _SIZE_T_
-#undef _BSD_SIZE_T_
-#endif
-#ifdef _GCC_WCHAR_T_
-#undef _WCHAR_T_
-#undef _BSD_WCHAR_T_
-#endif
-/*  The following ones are the real ones.  */
-#ifdef _GCC_PTRDIFF_T
-#undef _PTRDIFF_T_
-#undef _BSD_PTRDIFF_T_
-#endif
-#ifdef _GCC_SIZE_T
-#undef _SIZE_T_
-#undef _BSD_SIZE_T_
-#endif
-#ifdef _GCC_WCHAR_T
-#undef _WCHAR_T_
-#undef _BSD_WCHAR_T_
-#endif
-#endif /* __NetBSD__ */
-
-#endif /* __sys_stdtypes_h */
+#define _PTRDIFF_T
+typedef signed int ptrdiff_t;
 
-/* A null pointer constant.  */
+#endif /* _BITSIZE_STDDEF_H */
 
-#if defined (_STDDEF_H) || defined (__need_NULL)
-#undef NULL		/* in case <stdio.h> has defined it. */
-#ifdef __GNUG__
-#define NULL __null
-#else   /* G++ */
-#ifndef __cplusplus
-#define NULL ((void *)0)
-#else   /* C++ */
+#undef NULL
+#ifdef __cplusplus
 #define NULL 0
-#endif  /* C++ */
-#endif  /* G++ */
-#endif	/* NULL not defined and <stddef.h> or need NULL.  */
-#undef	__need_NULL
-
-#ifdef _STDDEF_H
-
-/* Offset of member MEMBER in a struct of type TYPE. */
-#undef offsetof		/* in case a system header has defined it. */
-#define offsetof(TYPE, MEMBER) __builtin_offsetof (TYPE, MEMBER)
-
-#if (defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) \
-  || (defined(__cplusplus) && __cplusplus >= 201103L)
-#ifndef _GCC_MAX_ALIGN_T
-#define _GCC_MAX_ALIGN_T
-/* Type whose alignment is supported in every context and is at least
-   as great as that of any standard type not using alignment
-   specifiers.  */
-typedef struct {
-  long long __max_align_ll __attribute__((__aligned__(__alignof__(long long))));
-  long double __max_align_ld __attribute__((__aligned__(__alignof__(long double))));
-  /* _Float128 is defined as a basic type, so max_align_t must be
-     sufficiently aligned for it.  This code must work in C++, so we
-     use __float128 here; that is only available on some
-     architectures, but only on i386 is extra alignment needed for
-     __float128.  */
-#ifdef __i386__
-  __float128 __max_align_f128 __attribute__((__aligned__(__alignof(__float128))));
-#endif
-} max_align_t;
-#endif
-#endif /* C11 or C++11.  */
-
-#if defined(__cplusplus) && __cplusplus >= 201103L
-#ifndef _GXX_NULLPTR_T
-#define _GXX_NULLPTR_T
-  typedef decltype(nullptr) nullptr_t;
-#endif
-#endif /* C++11.  */
-
-#if (defined (__STDC_VERSION__) && __STDC_VERSION__ > 201710L)
-#ifndef _GCC_NULLPTR_T
-#define _GCC_NULLPTR_T
-  typedef __typeof__(nullptr) nullptr_t;
-/* ??? This doesn't define __STDC_VERSION_STDDEF_H__ yet.  */
-#endif
-#endif /* C23.  */
-
-#if defined __STDC_VERSION__ && __STDC_VERSION__ > 201710L
-#define unreachable() (__builtin_unreachable ())
-#define __STDC_VERSION_STDDEF_H__	202311L
+#else
+#define NULL ((void *) 0)
 #endif
 
-#endif /* _STDDEF_H was defined this time */
+#undef offsetof
+#define offsetof(t, m) ((size_t) &((t *) 0)->m)
 
-#endif /* !_STDDEF_H && !_STDDEF_H_ && !_ANSI_STDDEF_H && !__STDDEF_H__
-	  || __need_XXX was not defined before */
+#endif /* _STDDEF_H */
diff --git a/kernel/kernel/halt.cc b/kernel/kernel/halt.c
index 7c5356a..12b73e8 100644
--- a/kernel/kernel/halt.cc
+++ b/kernel/kernel/halt.c
@@ -19,6 +19,7 @@
 #include <kernel/halt.h>
 #include <kernel/io.h>
 #include <libk/stdio.h>
+#include <stdbool.h>
 
 void
 halt(void)
diff --git a/kernel/kernel/io.cc b/kernel/kernel/io.c
index e081ed7..e081ed7 100644
--- a/kernel/kernel/io.cc
+++ b/kernel/kernel/io.c
diff --git a/kernel/kernel/kernel.cc b/kernel/kernel/kernel.c
index 3200dd8..cb3e81d 100644
--- a/kernel/kernel/kernel.cc
+++ b/kernel/kernel/kernel.c
@@ -30,22 +30,22 @@
 #include <mm/virtual_mm.h>
 #include <stdint.h>
 
-extern "C" void
+void
 kernel_main(uint32_t magic, multiboot_info_t *multiboot_info)
 {
-  Serial::initialize();
-  VGATextBuffer::initialize();
+  serial_initialize();
+  vgatb_initialize();
 
   if (magic != MULTIBOOT_BOOTLOADER_MAGIC) {
     printk("kernel", "Invalid Multiboot Magic: %x", magic);
     halt();
   }
 
-  GDT::load();
-  MemoryMap::load(multiboot_info);
-  PhysicalMM::initialize();
-  VirtualMM::initialize();
-  Interrupts::initialize();
+  gdt_load();
+  mmap_load(multiboot_info);
+  pmm_initialize();
+  vmm_initialize();
+  interrupts_initialize();
 
   printk("\nkernel", "Started.");
 
diff --git a/kernel/kernel/spinlock.cc b/kernel/kernel/spinlock.c
index 02164f0..4d5d5e3 100644
--- a/kernel/kernel/spinlock.cc
+++ b/kernel/kernel/spinlock.c
@@ -20,18 +20,18 @@
 #include <kernel/spinlock.h>
 
 void
-Spinlock::acquire(void)
+spinlock_acquire(spinlock_t *lock)
 {
-  Interrupts::disable();
-  while (!__sync_bool_compare_and_swap(&m_lock, 0, 1))
-    while (m_lock)
+  interrupts_disable();
+  while (!__sync_bool_compare_and_swap(lock, 0, 1))
+    while (lock)
       __asm__ volatile("rep; nop");
 }
 
 void
-Spinlock::release(void)
+spinlock_release(spinlock_t *lock)
 {
-  __sync_bool_compare_and_swap(&m_lock, 1, 0);
-  if (Interrupts::idt_loaded())
-    Interrupts::enable();
+  __sync_bool_compare_and_swap(lock, 1, 0);
+  if (idt_loaded())
+    interrupts_enable();
 }
diff --git a/kernel/kernel/stack_smashing_protector.cc b/kernel/kernel/stack_smashing_protector.c
index 2a63540..f9c83b2 100644
--- a/kernel/kernel/stack_smashing_protector.cc
+++ b/kernel/kernel/stack_smashing_protector.c
@@ -25,7 +25,7 @@
 
 uintptr_t __stack_chk_guard = STACK_CHK_GUARD;
 
-extern "C" void
+void
 __stack_chk_fail(void)
 {
   /* TODO: Panic the kernel */
diff --git a/kernel/libk/liballoc.cc b/kernel/libk/liballoc.c
index 333b1b5..d8f220e 100644
--- a/kernel/libk/liballoc.cc
+++ b/kernel/libk/liballoc.c
@@ -22,15 +22,12 @@
 #include <mm/virtual_mm.h>
 #include <stddef.h>
 
-namespace LibAlloc
-{
-
-Spinlock lock;
+spinlock_t lock;
 
-#define liballoc_lock lock.acquire
-#define liballoc_unlock lock.release
-#define liballoc_alloc VirtualMM::alloc_pages
-#define liballoc_free VirtualMM::free_pages
+#define liballoc_lock() spinlock_acquire(&lock)
+#define liballoc_unlock() spinlock_release(&lock)
+#define liballoc_alloc vmm_alloc_pages
+#define liballoc_free vmm_free_pages
 
 #define LIBALLOC_MAGIC 0xc001c0de
 #define MAXCOMPLETE 5
@@ -216,7 +213,7 @@ allocate_new_tag(unsigned int size)
   if (pages < l_pageCount)
     pages = l_pageCount;
 
-  tag = (struct boundary_tag *) liballoc_alloc(pages);
+  tag = (struct boundary_tag *) vmm_alloc_pages(pages);
 
   if (tag == NULL)
     return NULL; // uh oh, we ran out of memory.
@@ -451,5 +448,3 @@ krealloc(void *p, size_t size)
 
   return ptr;
 }
-
-}
diff --git a/kernel/libk/memset.cc b/kernel/libk/memset.c
index ab0bc27..ab0bc27 100644
--- a/kernel/libk/memset.cc
+++ b/kernel/libk/memset.c
diff --git a/kernel/libk/printf.cc b/kernel/libk/printf.c
index cacb338..cacb338 100644
--- a/kernel/libk/printf.cc
+++ b/kernel/libk/printf.c
diff --git a/kernel/libk/printk.cc b/kernel/libk/printk.c
index c6a1496..f97fa1c 100644
--- a/kernel/libk/printk.cc
+++ b/kernel/libk/printk.c
@@ -32,11 +32,11 @@ printk(const char *from, const char *msg, ...)
   vsnprintf(str, sizeof(str), msg, ap);
   va_end(ap);
 
-  Serial::write_string("\033[33m");
-  Serial::write_string(from);
-  Serial::write_string(":\033[0m ");
-  Serial::write_string(str);
-  Serial::write_string("\033[0m\n");
+  serial_write_string("\033[33m");
+  serial_write_string(from);
+  serial_write_string(":\033[0m ");
+  serial_write_string(str);
+  serial_write_string("\033[0m\n");
 }
 
 void
@@ -50,5 +50,5 @@ printk_raw(const char *msg, ...)
   vsnprintf(str, sizeof(str), msg, ap);
   va_end(ap);
 
-  Serial::write_string(str);
+  serial_write_string(str);
 }
diff --git a/kernel/libk/strlen.cc b/kernel/libk/strlen.c
index 8e2cf7d..8e2cf7d 100644
--- a/kernel/libk/strlen.cc
+++ b/kernel/libk/strlen.c
diff --git a/kernel/mm/memory_map.cc b/kernel/mm/memory_map.c
index 884f92f..797c0b0 100644
--- a/kernel/mm/memory_map.cc
+++ b/kernel/mm/memory_map.c
@@ -23,9 +23,6 @@
 #include <mm/multiboot.h>
 #include <stdint.h>
 
-namespace MemoryMap
-{
-
 static free_memory_regions_t l_free_memory_regions = { 0 };
 
 ALWAYS_INLINE static char *
@@ -48,7 +45,7 @@ fetch_type(multiboot_memory_map_t *mmap)
 }
 
 void
-load(multiboot_info_t *multiboot_info)
+mmap_load(multiboot_info_t *multiboot_info)
 {
   printk("mm", "Loading Memory Map:");
 
@@ -95,9 +92,7 @@ load(multiboot_info_t *multiboot_info)
 }
 
 free_memory_regions_t *
-get_free_regions(void)
+mmap_get_free_regions(void)
 {
   return &l_free_memory_regions;
 }
-
-}
diff --git a/kernel/mm/physical_mm/bitmap.cc b/kernel/mm/physical_mm/bitmap.c
index 1c1285d..1fea30c 100644
--- a/kernel/mm/physical_mm/bitmap.cc
+++ b/kernel/mm/physical_mm/bitmap.c
@@ -20,11 +20,10 @@
 #include <stdbool.h>
 #include <stdint.h>
 
-namespace PhysicalMM
-{
-
 void
-set_used(const uint32_t bit, uint32_t *total_free_blocks, uint32_t *memory_map)
+pmm_set_used(const uint32_t bit,
+             uint32_t *total_free_blocks,
+             uint32_t *memory_map)
 {
   uint32_t memory_map_index = bit / BITMAP_ENTRY_SIZE;
   uint32_t bitmask = 1 << (bit % BITMAP_ENTRY_SIZE);
@@ -33,9 +32,9 @@ set_used(const uint32_t bit, uint32_t *total_free_blocks, uint32_t *memory_map)
 }
 
 void
-set_usable(const uint32_t bit,
-           uint32_t *total_free_blocks,
-           uint32_t *memory_map)
+pmm_set_usable(const uint32_t bit,
+               uint32_t *total_free_blocks,
+               uint32_t *memory_map)
 {
   uint32_t memory_map_index = bit / BITMAP_ENTRY_SIZE;
   uint32_t bitmask = 1 << (bit % BITMAP_ENTRY_SIZE);
@@ -44,11 +43,9 @@ set_usable(const uint32_t bit,
 }
 
 bool
-test_bit(const uint32_t bit, uint32_t *memory_map)
+pmm_test_bit(const uint32_t bit, uint32_t *memory_map)
 {
   uint32_t memory_map_index = bit / BITMAP_ENTRY_SIZE;
   uint32_t bitmask = 1 << (bit % BITMAP_ENTRY_SIZE);
   return memory_map[memory_map_index] & bitmask;
 }
-
-}
diff --git a/kernel/mm/physical_mm/physical_mm.cc b/kernel/mm/physical_mm/physical_mm.c
index dc9bf0e..d7a5c31 100644
--- a/kernel/mm/physical_mm/physical_mm.cc
+++ b/kernel/mm/physical_mm/physical_mm.c
@@ -30,17 +30,14 @@
 #include <stdbool.h>
 #include <stdint.h>
 
-namespace PhysicalMM
-{
-
-extern "C" uint32_t kernel_start;
-extern "C" uint32_t kernel_end;
+uint32_t kernel_start;
+uint32_t kernel_end;
 
 uint32_t l_block_count = 0;
 uint32_t l_total_free_blocks = 0;
 uint32_t l_memory_map[MAX_BLOCKS / BITMAP_ENTRY_SIZE];
 
-Spinlock l_lock;
+spinlock_t l_lock;
 
 ALWAYS_INLINE static void
 log_memory_map(free_memory_regions_t *free_memory_regions)
@@ -68,12 +65,12 @@ initialize_region(uint32_t start, uint32_t length)
   uint32_t n_blocks = length / BLOCK_SIZE;
 
   for (; n_blocks > 0; n_blocks--)
-    if (test_bit(bit, l_memory_map))
-      set_usable(bit++, &l_total_free_blocks, l_memory_map);
+    if (pmm_test_bit(bit, l_memory_map))
+      pmm_set_usable(bit++, &l_total_free_blocks, l_memory_map);
 
   /* First block is always used (first 64KiB) */
-  if (!test_bit(0, l_memory_map))
-    set_used(0, &l_total_free_blocks, l_memory_map);
+  if (!pmm_test_bit(0, l_memory_map))
+    pmm_set_used(0, &l_total_free_blocks, l_memory_map);
 }
 
 ALWAYS_INLINE static void
@@ -86,7 +83,7 @@ deinitialize_region(uint32_t start, uint32_t length)
     n_blocks++;
 
   for (; n_blocks > 0; n_blocks--)
-    set_used(bit++, &l_total_free_blocks, l_memory_map);
+    pmm_set_used(bit++, &l_total_free_blocks, l_memory_map);
 }
 
 ALWAYS_INLINE static uint32_t
@@ -98,7 +95,7 @@ find_free_block(void)
     if (l_memory_map[i] != 0xffffffff)
       /* Test each bit to see if it's zero */
       for (uint32_t j = 0; j < BITMAP_ENTRY_SIZE; j++)
-        if (!test_bit(i * BITMAP_ENTRY_SIZE + j, l_memory_map))
+        if (!pmm_test_bit(i * BITMAP_ENTRY_SIZE + j, l_memory_map))
           return i * BITMAP_ENTRY_SIZE + j;
 
   /* Shouldn't be reached, since we're keeping track of the number of free
@@ -108,12 +105,12 @@ find_free_block(void)
 }
 
 void
-initialize(void)
+pmm_initialize(void)
 {
-  free_memory_regions_t *free_memory_regions = MemoryMap::get_free_regions();
+  free_memory_regions_t *free_memory_regions = mmap_get_free_regions();
   log_memory_map(free_memory_regions);
 
-  l_lock.acquire();
+  spinlock_acquire(&l_lock);
 
   /* All blocks are initially used */
   /* TODO: Move this block to a place after block_count is set. This is why
@@ -132,7 +129,7 @@ initialize(void)
   /* Deinitialize first 8MiB */
   deinitialize_region(0, 8 * MiB);
 
-  l_lock.release();
+  spinlock_release(&l_lock);
 
   /* Manually loop through and calculate the number of free blocks. */
   for (uint32_t i = 0; i < MAX_BLOCKS / BITMAP_ENTRY_SIZE; i++)
@@ -140,36 +137,34 @@ initialize(void)
     if (l_memory_map[i] != 0xffffffff)
       /* Test each bit to see if it's zero */
       for (uint32_t j = 0; j < BITMAP_ENTRY_SIZE; j++)
-        if (!test_bit(i * BITMAP_ENTRY_SIZE + j, l_memory_map))
+        if (!pmm_test_bit(i * BITMAP_ENTRY_SIZE + j, l_memory_map))
           l_total_free_blocks++;
 
   printk("physical_mm", "Total free blocks: 0x%x", l_total_free_blocks);
 }
 
 void *
-allocate_block(void)
+pmm_allocate_block(void)
 {
   if (l_total_free_blocks == 0) {
     printk("physical_mm", "No more free blocks!");
     return NULL;
   }
 
-  l_lock.acquire();
+  spinlock_acquire(&l_lock);
 
   uint32_t block = find_free_block();
-  set_used(block, &l_total_free_blocks, l_memory_map);
+  pmm_set_used(block, &l_total_free_blocks, l_memory_map);
 
-  l_lock.release();
+  spinlock_release(&l_lock);
 
   uint32_t physical_address = block * BLOCK_SIZE;
   return (void *) physical_address;
 }
 
 void
-free_block(void *physical_address)
+pmm_free_block(void *physical_address)
 {
   uint32_t block = ((uint32_t) physical_address) / BLOCK_SIZE;
-  set_usable(block, &l_total_free_blocks, l_memory_map);
-}
-
+  pmm_set_usable(block, &l_total_free_blocks, l_memory_map);
 }
diff --git a/kernel/mm/virtual_mm/page_table_allocator.cc b/kernel/mm/virtual_mm/page_table_allocator.c
index 057724c..5c0bdcd 100644
--- a/kernel/mm/virtual_mm/page_table_allocator.cc
+++ b/kernel/mm/virtual_mm/page_table_allocator.c
@@ -24,10 +24,7 @@
 #include <mm/virtual_mm.h>
 #include <stddef.h>
 
-namespace PageTableAllocator
-{
-
-uint32_t *l_page_directory = 0;
+static uint32_t *l_page_directory = 0;
 uint32_t *l_heap = NULL;
 uint16_t l_table_index = 0;
 
@@ -36,10 +33,10 @@ make_table(uint32_t *table_address)
 {
   uint32_t *table = table_address;
   for (uint32_t i = 0; i < 1024; i++)
-    table[i] = PTE_FRAME((uint32_t) PhysicalMM::allocate_block())
-               | PTE_PRESENT(1) | PTE_WRITABLE(1);
+    table[i] = PTE_FRAME((uint32_t) pmm_allocate_block()) | PTE_PRESENT(1)
+               | PTE_WRITABLE(1);
 
-  void *starting_address = VirtualMM::find_free_pages(1);
+  void *starting_address = vmm_find_free_pages(1);
   uint32_t *pd_entry = &l_page_directory[GET_PD_INDEX(starting_address)];
   *pd_entry = PDE_FRAME((uint32_t) table) | PDE_PRESENT(1) | PDE_WRITABLE(1);
 
@@ -48,13 +45,13 @@ make_table(uint32_t *table_address)
 }
 
 void
-initialize(void)
+pta_initialize(void)
 {
   /* We can't just do this in allocate() because make_table() depends on
-   * VirtualMM::find_free_pages() */
+   * find_free_pages() */
 
-  if (l_page_directory != VirtualMM::get_page_directory())
-    l_page_directory = VirtualMM::get_page_directory();
+  if (l_page_directory != vmm_get_page_directory())
+    l_page_directory = vmm_get_page_directory();
 
   /* Initial table */
   if (l_heap == NULL)
@@ -62,11 +59,9 @@ initialize(void)
 }
 
 uint32_t *
-allocate(void)
+pta_allocate(void)
 {
   uint32_t *next_table = l_heap + (l_table_index * 4 * KiB);
   l_table_index++;
   return next_table;
 }
-
-}
diff --git a/kernel/mm/virtual_mm/pages.cc b/kernel/mm/virtual_mm/pages.c
index 6046dea..fb90f98 100644
--- a/kernel/mm/virtual_mm/pages.cc
+++ b/kernel/mm/virtual_mm/pages.c
@@ -24,30 +24,25 @@
 #include <stdbool.h>
 #include <stdint.h>
 
-namespace VirtualMM
-{
-
 void *
-alloc_pages(uint32_t n_pages)
+vmm_alloc_pages(uint32_t n_pages)
 {
-  uint32_t starting_address = (uint32_t) find_free_pages(n_pages);
+  uint32_t starting_address = (uint32_t) vmm_find_free_pages(n_pages);
   if (!starting_address)
     return NULL;
 
   for (uint32_t i = 0; i < n_pages; i++) {
-    void *physical_address = PhysicalMM::allocate_block();
+    void *physical_address = pmm_allocate_block();
     void *virtual_address = (void *) (starting_address + (i * PAGE_SIZE));
-    map_page(physical_address, virtual_address);
+    vmm_map_page(physical_address, virtual_address);
   }
 
   return (void *) starting_address;
 }
 
 void
-free_pages(void *starting_address, uint32_t n_pages)
+vmm_free_pages(void *starting_address, uint32_t n_pages)
 {
   for (uint32_t i = 0; i < n_pages; i++)
-    unmap_page((void *) (((uint32_t) starting_address) + (i * 4096)));
-}
-
+    vmm_unmap_page((void *) (((uint32_t) starting_address) + (i * 4096)));
 }
diff --git a/kernel/mm/virtual_mm/virtual_mm.cc b/kernel/mm/virtual_mm/virtual_mm.c
index 0b4ce18..953d23e 100644
--- a/kernel/mm/virtual_mm/virtual_mm.cc
+++ b/kernel/mm/virtual_mm/virtual_mm.c
@@ -26,40 +26,37 @@
 #include <stdbool.h>
 #include <stdint.h>
 
-namespace VirtualMM
-{
-
 extern uint32_t kernel_start;
 extern uint32_t kernel_end;
 
 uint32_t *l_current_page_directory = 0;
 
 /* Kernel's page directory */
-uint32_t l_page_directory[1024] ALIGNED(4096);
+static uint32_t l_page_directory[1024] ALIGNED(4096);
 /* Page table for the first 4 MiB */
-uint32_t l_fourMiB_page_table[1024] ALIGNED(4096);
+static uint32_t l_fourMiB_page_table[1024] ALIGNED(4096);
 /* Page table for the next 4 MiB */
-uint32_t l_eightMiB_page_table[1024] ALIGNED(4096);
+static uint32_t l_eightMiB_page_table[1024] ALIGNED(4096);
 
 uint32_t *
-get_page_directory(void)
+vmm_get_page_directory(void)
 {
   return l_current_page_directory;
 }
 
 ALWAYS_INLINE void
-load_page_directory(uint32_t *page_directory)
+vmm_load_page_directory(uint32_t *page_directory)
 {
   __asm__ volatile("movl %0, %%cr3" ::"r"(page_directory));
 }
 
 bool
-switch_page_directory(uint32_t *page_directory)
+vmm_switch_page_directory(uint32_t *page_directory)
 {
   if (!page_directory)
     return false;
   l_current_page_directory = page_directory;
-  load_page_directory(page_directory);
+  vmm_load_page_directory(page_directory);
 
   return true;
 }
@@ -74,7 +71,7 @@ enable_paging(void)
 }
 
 void
-initialize(void)
+vmm_initialize(void)
 {
   /* Zero out the page tables and directories */
   for (uint32_t i = 0; i < 1024; i++) {
@@ -103,16 +100,16 @@ initialize(void)
   *eightMiB_pd_entry = PDE_FRAME((uint32_t) l_eightMiB_page_table)
                        | PDE_PRESENT(1) | PDE_WRITABLE(1);
 
-  switch_page_directory(l_page_directory);
+  vmm_switch_page_directory(l_page_directory);
   enable_paging();
 
-  PageTableAllocator::initialize();
+  pta_initialize();
 }
 
 uint32_t *
 make_table(uint32_t *pd_entry)
 {
-  uint32_t *table = PageTableAllocator::allocate();
+  uint32_t *table = pta_allocate();
 
   for (uint32_t i = 0; i < 1024; i++)
     table[i] = 0x0;
@@ -135,7 +132,7 @@ get_or_make_table(uint32_t *pd_entry)
 }
 
 void
-map_page(void *physical_address, void *virtual_address)
+vmm_map_page(void *physical_address, void *virtual_address)
 {
   uint32_t *pd_entry
       = &l_current_page_directory[GET_PD_INDEX(virtual_address)];
@@ -151,7 +148,7 @@ map_page(void *physical_address, void *virtual_address)
 }
 
 void
-unmap_page(void *virtual_address)
+vmm_unmap_page(void *virtual_address)
 {
   uint32_t *pd_entry
       = &l_current_page_directory[GET_PD_INDEX(virtual_address)];
@@ -169,7 +166,7 @@ unmap_page(void *virtual_address)
 }
 
 void *
-find_free_pages(uint32_t n_pages)
+vmm_find_free_pages(uint32_t n_pages)
 {
   /* Skip the first two page directory entries; we don't wanna touch the first
    * 8MiB. */
@@ -227,5 +224,3 @@ find_free_pages(uint32_t n_pages)
   ASSERT_NOT_REACHED();
   return 0;
 }
-
-}