diff --git a/Loader/Makefile b/Loader/Makefile
index f506060..db8c94e 100644
--- a/Loader/Makefile
+++ b/Loader/Makefile
@@ -18,8 +18,9 @@ LD:=ld
 
 # -O2 sets -foptimize-sibling-calls which breaks code...
 CFLAGS:=-Wall -Werror -nostdlib -std=c99 -g -ffreestanding
-CFLAGS+=-I ./include -O2 -fno-optimize-sibling-calls
-CFLAGS+= -fno-builtin -nostdinc -target i586-elf
+CFLAGS+=-I ./include -O1 -fno-optimize-sibling-calls
+CFLAGS+= -fno-builtin -nostdinc -target i586-elf -nostdlib
+
 LFLAGS:=-nostdlib -nostartfiles -nodefaultlibs -m elf_i386
 
 .PHONY: all clean loader.bin emulate hdd.img
diff --git a/Loader/src/elf.h b/Loader/src/elf.h
index b6e1215..7bfa356 100644
--- a/Loader/src/elf.h
+++ b/Loader/src/elf.h
@@ -26,6 +26,9 @@ struct elf_header {
     u16 SectionEntryStrings;
 };
 
+#define SHT_PROGBITS 1
+#define SHT_NOBITS 8
+
 struct elf_section_header {
     u32 Name;
     u32 Type;
diff --git a/Loader/src/io.c b/Loader/src/io.c
index ebe57d3..137bcab 100644
--- a/Loader/src/io.c
+++ b/Loader/src/io.c
@@ -82,6 +82,32 @@ void move_cursor(u8 X, u8 Y)
     outb(0x3D5, (u8)(Position >> 8 & 0xFF));
 }
 
+
+void puti(s32 Number)
+{
+    s32 Sign, i;
+    
+    if ((Sign = Number) < 0)
+        Number = -Number;
+
+    u8 szString[21];
+
+    i = 0;
+    do {
+        szString[i++] = Number % 10 + '0';
+    } while (( Number /= 10) > 0);
+
+    if (Sign < 0)
+        szString[i] = '-';
+    else
+        i--;
+    
+    for (s32 j = i; j >= 0; j--)
+    {
+        putch(szString[j]);
+    }
+}
+
 void putch(s8 Character)
 {
     volatile u8 *VideoMemory = (u8 *)0xB8000;
@@ -149,9 +175,72 @@ void print_hex(u64 Number)
     }
 }
 
-void update_load_context(T_LOAD_CONTEXT* Context)
+void io_update_load_context(T_LOAD_CONTEXT* Context)
 {
     Context->VGACurrentLine = stdio_current_line;
     Context->VGACursorX = stdio_cur_x;
     Context->VGACursorY = stdio_cur_y;
+}
+
+u32 strlen(const s8 *szString)
+{
+    const s8 *s;
+    for (s = szString; *s; ++s)
+    {}
+    return s - szString;
+}
+
+#define va_start(v,l) __builtin_va_start(v,l)
+#define va_arg(v,l)   __builtin_va_arg(v,l)
+#define va_end(v)     __builtin_va_end(v)
+#define va_copy(d,s)  __builtin_va_copy(d,s)
+typedef __builtin_va_list va_list;
+
+void printf(const s8 *szFormat, ...)
+{
+    va_list ap;
+    va_start(ap, szFormat);
+    
+    u32 Offset = 0;
+    while (Offset < strlen(szFormat))
+    {
+        if (szFormat[Offset] == '%')
+        {
+            switch (szFormat[Offset + 1])
+            {
+                case '%':
+                    putch('%');
+                    break;
+                case 'c':
+                    putch(va_arg(ap, u32));
+                    break;
+                case 's':
+                    puts(va_arg(ap, s8*));
+                    break;
+                case 'i':
+                    puti(va_arg(ap, s64));
+                    break;
+                case 'u':
+                    puti(va_arg(ap, u64));
+                    break;
+                case 'X':
+                case 'x':
+                    {
+                        u64 bData = va_arg(ap, u64);
+                        print_hex(bData);
+                        break;
+                    }
+                default:
+                    printf("printf: Unknown escape character %c!\n", szFormat[Offset + 1]);
+            }
+            Offset += 2;
+        }
+        else
+        {
+            putch(szFormat[Offset]);
+            Offset++;
+        }
+    }
+    
+    va_end(ap);
 }
\ No newline at end of file
diff --git a/Loader/src/io.h b/Loader/src/io.h
index 889e250..f82790c 100644
--- a/Loader/src/io.h
+++ b/Loader/src/io.h
@@ -16,6 +16,7 @@ void clear(void);
 void dump_nibble(u8 Nibble);
 void print_hex_32(u32 Number);
 void print_hex(u64 Number);
-void update_load_context(T_LOAD_CONTEXT *Context);
+void io_update_load_context(T_LOAD_CONTEXT *Context);
+void printf(const s8 *szFormat, ...);
 
 #endif
\ No newline at end of file
diff --git a/Loader/src/load.c b/Loader/src/load.c
index 04290d1..37e1266 100644
--- a/Loader/src/load.c
+++ b/Loader/src/load.c
@@ -2,6 +2,8 @@
 #include "io.h"
 #include "context.h"
 #include "elf.h"
+#include "paging.h"
+#include "multiboot.h"
 
 extern u64 omg64;
 extern u64 _end;
@@ -12,111 +14,7 @@ static inline void cpuid(u32 code, u32 *a, u32 *d) {
     __asm__ volatile("cpuid":"=a"(*a),"=d"(*d):"0"(code):"ecx","ebx");
 }
 
-
-// A simple PAE paging structure so we can jump into 64-bit.
-// This will be replaced later on by the kernel code.
-
-u64 pml4[512] __attribute__((aligned(0x1000)));
-
-u64 page_dir_ptr_tab_low[512] __attribute__((aligned(0x1000)));
-u64 page_dir_low[512] __attribute__((aligned(0x1000)));
-u64 page_tab_low[512] __attribute__((aligned(0x1000)));
-
-u64 page_dir_ptr_tab_high[512] __attribute__((aligned(0x1000)));
-u64 page_dir_high[512] __attribute__((aligned(0x1000)));
-u64 page_tab_high[512] __attribute__((aligned(0x1000)));
-
-#define GET_PML4_ENTRY(x) (((u64)x >> 39) & 0x1FF)
-#define GET_PDP_ENTRY(x) (((u64)x >> 30) & 0x1FF)
-#define GET_DIR_ENTRY(x) (((u64)x >> 21) & 0x1FF)
-#define GET_TAB_ENTRY(x) (((u64)x >> 12) & 0x1FF)
-#define GET_OFFSET(x) (x & 0xFFF)
-
-u32 create_ia32e_paging(u64 KernelPhysicalStart, u64 KernelVirtualStart, u64 KernelSize)
-{
-    puts("Clearing paging structures...\n");
-
-    for (u16 i = 0; i < 512; i++)
-    {
-        pml4[i] = 0;
-        page_dir_ptr_tab_low[i] = 0;
-        page_dir_low[i] = 0;
-        page_tab_low[i] = 0;
-        page_dir_ptr_tab_high[i] = 0;
-        page_dir_high[i] = 0;
-        page_tab_high[i] = 0;
-    }
-
-    puts("Setting up identity paging for first 2MiB...\n");
-    pml4[GET_PML4_ENTRY(0)] = (u32)page_dir_ptr_tab_low | 3;
-    page_dir_ptr_tab_low[GET_PDP_ENTRY(0)] = (u32)page_dir_low | 3;
-    page_dir_low[GET_DIR_ENTRY(0)] = (u32)page_tab_low | 3;
-
-    u64 Address = 0;
-    for (u16 i = 0; i < 512; i++)
-    {
-        page_tab_low[i] = Address | 3;
-        Address += 0x1000;
-    }
-
-    puts("Setting up paging for the kernel...\n");
-    u16 NumPages = KernelSize / 0x1000;
-    puts("  (0x");
-    print_hex(NumPages);
-    puts(" pages)\n");
-
-    if (NumPages > 512)
-    {
-        puts("Error: Kernel size > 2MiB not implemented!");
-        return 1;
-    }
-    puts("Kernel PML4: "); print_hex(GET_PML4_ENTRY(KernelVirtualStart)); puts("\n");
-    puts("Kernel  PDP: "); print_hex(GET_PDP_ENTRY(KernelVirtualStart)); puts("\n");
-    puts("Kernel  DIR: "); print_hex(GET_DIR_ENTRY(KernelVirtualStart)); puts("\n");
-
-    if (GET_PML4_ENTRY(KernelVirtualStart) != 0)
-    {
-        // We're NOT mapping the same PML4 entry as for identity mapping...
-        puts("Different PML4...\n");
-        pml4[GET_PML4_ENTRY(KernelVirtualStart)] = (u32)page_dir_ptr_tab_high | 3;
-        puts("Setting pml4["); print_hex_32(GET_PML4_ENTRY(KernelVirtualStart)); puts("] to "); print_hex_32((u32)page_dir_ptr_tab_high | 3); puts(".\n");
-        page_dir_ptr_tab_high[GET_PDP_ENTRY(KernelVirtualStart)] = (u32)page_dir_high | 3;
-        puts("Setting pdp["); print_hex_32(GET_PDP_ENTRY(KernelVirtualStart)); puts("] to "); print_hex_32((u32)page_dir_high | 3); puts(".\n");
-        page_dir_high[GET_DIR_ENTRY(KernelVirtualStart)] = (u32)page_tab_high | 3;
-        puts("Setting dir["); print_hex_32(GET_DIR_ENTRY(KernelVirtualStart)); puts("] to "); print_hex_32((u32)page_tab_high | 3); puts(".\n");
-    }
-    else if (GET_PDP_ENTRY(KernelVirtualStart) != 0)
-    {
-        // We're NOT mapping the same page directory pointer table entry as for identity paging...
-        puts("Different PDPT... (");
-        print_hex(GET_PDP_ENTRY(KernelVirtualStart));
-        puts(")\n");
-        page_dir_ptr_tab_low[GET_PDP_ENTRY(KernelVirtualStart)] = (u32)page_dir_high | 3;
-        page_dir_high[GET_DIR_ENTRY(KernelVirtualStart)] = (u32)page_tab_high | 3;
-    }
-    else if (GET_DIR_ENTRY(KernelVirtualStart) != 0)
-    {
-        // We're NOT mapping the same page directory entry as for identity paging...
-        puts("Different DIR...\n");
-        page_dir_low[GET_DIR_ENTRY(KernelVirtualStart)] = (u32)page_tab_high | 3;
-    }
-    else
-    {
-        puts("Error: kernel overlaps 2MiB identity paging!\n");
-        return 1;
-    }
-
-    Address = KernelPhysicalStart;
-    for (u16 i = GET_TAB_ENTRY(KernelVirtualStart); i < GET_TAB_ENTRY(KernelVirtualStart) + 512; i++)
-    {
-        page_tab_high[i] = Address | 3;
-        
-        Address += 0x1000;
-    }
-    return 0;
-}
-
-u64 g_multiboot_header;
+TMULTIBOOT_INFO *g_Multiboot;
 T_LOAD_CONTEXT g_Context;
 extern u64 GDT;
 extern u32 ldrEntryLow;
@@ -126,18 +24,8 @@ u32 load(void *Multiboot, unsigned int Magic)
 {
     clear();
     puts("Cucumber x86-64 loader...\n");
-    
-    puts("GDT: \n");
-    for (u32 i = 0; i < 5; i++)
-    {
-        puts("  ");
-        print_hex(*(&GDT + i));
-        puts("\n");
-    }
-
-    g_multiboot_header = (u32)Multiboot;
-
 
+    g_Multiboot = Multiboot;
     if (Magic != 0x2BADB002)
     {
         puts("Error: not booted via Multiboot!\n");
@@ -146,46 +34,40 @@ u32 load(void *Multiboot, unsigned int Magic)
 
     u32 CPUID_A, CPUID_D;
     cpuid(0x80000001, &CPUID_A, &CPUID_D);
-
     u8 SupportFor64 = (CPUID_D & (1 << 29)) > 0;
-
     if (!SupportFor64)
     {
         puts("Error: You CPU does not support long mode!\n");
         return 0;
     }
 
-    u32 Flags = *((u32*)Multiboot);
-
-    u8 ModulesPresent = (Flags & (1 << 3)) > 0;
-
-    if (!ModulesPresent)
+    if (!(g_Multiboot->Flags & MULTIBOOT_INFO_MODS))
     {
         puts("Error: no 64-bit kernel loaded!\n");
         puts("  (did you forget the module line in GRUB?)\n");
         return 0;
     }
 
-    u32 ModulesCount = *((u32*)Multiboot + 5);
-    u32 ModulesAddress = *((u32*)Multiboot + 6);
-    
-    if (ModulesCount == 0)
+    if (!g_Multiboot->ModulesCount)
     {
         puts("Error: No kernel specified! Can't boot non-existant code, sorry!\n");
         return 0;
     }
-
-    if (ModulesCount != 1)
+    if (g_Multiboot->ModulesCount != 1)
     {
         puts("Error: just one module is enough. Don't load a ton of them.\n");
             return 0;
     }
 
-    puts("Kernel is @");
-    print_hex(ModulesAddress);
+    u32 KernelStart = g_Multiboot->Modules[0].ModuleStart;
+    u32 KernelEnd = g_Multiboot->Modules[0].ModuleEnd;
+    puts("Kernel is ");
+    print_hex(KernelStart);
+    puts("-");
+    print_hex(KernelEnd);
     puts(".\n");
 
-    struct elf_header *Header = *((struct elf_header **)ModulesAddress);
+    struct elf_header *Header = (struct elf_header *)KernelStart;
     if (Header->Identification.Magic != 0x464C457F)
     {
         puts("Error: Module is not an ELF file!\n");
@@ -219,62 +101,86 @@ u32 load(void *Multiboot, unsigned int Magic)
 
     //u32 *Strings = (u32*)(ModulesAddress + (u32)StringSection->Offset);
 
-    puts("0x");
+    puts("Kernel ELF has 0x");
     print_hex(Header->NumSectionHeaderEntries);
-    puts(" ELF sections.\n");
+    puts(" sections.\n");
 
-    u64 ContinuityTest = 0;
+    // Loop through ELF sections to find physical space occupied by them
     u64 StartPhysical = 0;
-    u64 StartVirtual = 0;
-    u64 Size = 0;
+    u64 EndPhysical = 0;
 
     for (u16 i = 0; i < Header->NumSectionHeaderEntries; i++)
     {
-        s8* Name = (s8*)((u32)Header + (u32)StringSection->Offset + (u32)Sections[i].Name);
         u64 PhysicalAddress = (u32)Header + Sections[i].Offset;
         u64 VirtualAddress = Sections[i].Address;
 
         if (VirtualAddress)
         {
-            if (!StartVirtual)
-                StartVirtual = VirtualAddress;
-
             if (!StartPhysical)
                 StartPhysical = PhysicalAddress;
 
-            puts("-> Section ");
-            puts(Name);
-            puts(", 0x");
-            print_hex(PhysicalAddress);
-            puts(" will be located at 0x");
-            print_hex(VirtualAddress);
-            puts(".\n");
-
-            if (ContinuityTest && VirtualAddress != ContinuityTest)
-            {
-                puts("Error: kernel is not continuous!\n");
-                puts("Previous section ended at 0x"); print_hex(ContinuityTest); puts("\n");
-                return 0;
-            }
-
-            ContinuityTest = VirtualAddress + Sections[i].Size;
-            Size += Sections[i].Size;
+            u64 EndAddress = StartPhysical + Sections[i].Size;
+            if (EndAddress > EndPhysical)
+                EndPhysical = EndAddress;
         }
     }
 
-    puts("\nPaging setup:\n 0x");
-    print_hex(StartVirtual);
-    puts(" => 0x");
-    print_hex(StartPhysical);
-    puts("\n  (0x");
-    print_hex(Size);
-    puts(" bytes)\n");
+    u32 FreeSpaceStart = (u32)&_end;
+    if (EndPhysical > FreeSpaceStart)
+        FreeSpaceStart = EndPhysical;
+    if (KernelEnd > FreeSpaceStart)
+        FreeSpaceStart = KernelEnd;
+    if (FreeSpaceStart % 0x1000)
+        FreeSpaceStart = (FreeSpaceStart + 0x1000) & 0xFFFFF000;
+
+    g_Context.KernelPhysicalStart = FreeSpaceStart;
     
-    g_Context.KernelPhysicalStart = StartPhysical;
-    g_Context.KernelPhysicalEnd = StartPhysical + Size;
+    u32 KernelApproximateSize = FreeSpaceStart - StartPhysical;
+    if (FreeSpaceStart + KernelApproximateSize > 0x00EFFFFF)
+    {
+        puts("Kernel will probably not fit in extended memory. Failing.\n");
+        for(;;) {}
+    }
+    puts("Paging frames will be allocated from 0x"); print_hex(FreeSpaceStart); puts("\n");
+    paging_setup(FreeSpaceStart);
+    // allocate idnetity mapping of low & extended memory (up to 0x00EFFFFF)
+    paging_map_address(0, 0, 0x00EFFFFF);
+    // map the kernel sections
+    for (u16 i = 0; i < Header->NumSectionHeaderEntries; i++)
+    {
+        u64 PhysicalAddress = (u32)Header + Sections[i].Offset;
+        u64 VirtualAddress = Sections[i].Address;
+        u64 Size = Sections[i].Size;
+        s8* Name = (s8*)((u32)Header + (u32)StringSection->Offset + (u32)Sections[i].Name);
+
+        if (VirtualAddress)
+        {
+            // allocate space for that section...
+            u64 SizeAligned = Size;
+            if (SizeAligned % 0x1000)
+                SizeAligned = (SizeAligned + 0x1000) & 0xFFFFF000;
+            u8 *Destination = paging_allocate(VirtualAddress, SizeAligned);
+
+            puts(" -> "); puts(Name); puts(" at "); print_hex(VirtualAddress);
+            if (!(Sections[i].Type & SHT_NOBITS))
+            {
+                // not .bss - copy data
+                puts(" (copy from "); print_hex(PhysicalAddress); puts(")\n");
+                u8 *Source = (u8 *)((u32)PhysicalAddress);
+                for (u32 j = 0; j < Size; j++)
+                    Destination[j] = Source[j];
+            }
+            else
+            {
+                for (u32 j = 0; j < Size; j++)
+                    Destination[j] = 0;
+                puts(" (zeroed out)\n");
+            }
+        }
+    }
+    g_Context.KernelPhysicalEnd = paging_get_last_frame();
     
     s8 *LoaderName = "Cucumber x86-64 loader";
-    
     u8 i = 0;
     while (*LoaderName)
     {
@@ -292,15 +198,10 @@ u32 load(void *Multiboot, unsigned int Magic)
     print_hex((u32)&g_Context);
     puts(".\n");
 
-    if (create_ia32e_paging(StartPhysical, StartVirtual, Size))
-    {
-        puts("Could not create paging structure, for some reason... Failing.\n");
-        for (;;) {}
-    }
     __asm__ volatile ("movl %cr4, %eax; bts $5, %eax; movl %eax, %cr4");
-    __asm__ volatile ("movl %%eax, %%cr3" :: "a" (pml4));
+    __asm__ volatile ("movl %%eax, %%cr3" :: "a" (paging_get_pml4()));
     puts("CR3 is now pointing to PML4 (0x");
-    print_hex((u32)pml4);
+    print_hex((u32)paging_get_pml4());
     puts(")\n");
 
     puts("Here it goes, enabling long mode...\n");
@@ -314,8 +215,8 @@ u32 load(void *Multiboot, unsigned int Magic)
                         "movl %%ebx, %%cr0;":::"eax","ebx","ecx");
 
     puts("Now in 32-bit compability mode, jumping to the kernel...\n");
-    update_load_context(&g_Context);
-
+    io_update_load_context(&g_Context);
+    // for (;;) {}
     ldrEntryLow = Header->Entry & 0xFFFFFFFF;
     ldrEntryHigh = Header->Entry >> 32;
     return 1;
diff --git a/Loader/src/multiboot.h b/Loader/src/multiboot.h
new file mode 100644
index 0000000..a67fbc0
--- /dev/null
+++ b/Loader/src/multiboot.h
@@ -0,0 +1,37 @@
+#ifndef __MULTIBOOT_H__
+#define __MULTIBOOT_H__
+
+#include "types.h"
+
+typedef struct
+{
+    u32 ModuleStart;
+    u32 ModuleEnd;
+    s8 *String;
+    u32 Reserved;
+} __attribute__((packed)) TMULTIBOOT_MODULE;
+
+typedef struct {
+    u32 Flags;
+    u32 MemLower;
+    u32 MemUpper;
+    u32 BootDevice;
+    u32 CommandLines;
+    u32 ModulesCount;
+    TMULTIBOOT_MODULE *Modules;
+} __attribute__((packed)) TMULTIBOOT_INFO;
+
+#define MULTIBOOT_INFO_MEMORY                   0x00000001
+#define MULTIBOOT_INFO_BOOTDEV                  0x00000002
+#define MULTIBOOT_INFO_CMDLINE                  0x00000004
+#define MULTIBOOT_INFO_MODS                     0x00000008
+#define MULTIBOOT_INFO_AOUT_SYMS                0x00000010
+#define MULTIBOOT_INFO_ELF_SHDR                 0X00000020
+#define MULTIBOOT_INFO_MEM_MAP                  0x00000040
+#define MULTIBOOT_INFO_DRIVE_INFO               0x00000080
+#define MULTIBOOT_INFO_CONFIG_TABLE             0x00000100
+#define MULTIBOOT_INFO_BOOT_LOADER_NAME         0x00000200
+#define MULTIBOOT_INFO_APM_TABLE                0x00000400
+#define MULTIBOOT_INFO_VIDEO_INFO               0x00000800
+
+#endif
\ No newline at end of file
diff --git a/Loader/src/paging.c b/Loader/src/paging.c
new file mode 100644
index 0000000..b31d33d
--- /dev/null
+++ b/Loader/src/paging.c
@@ -0,0 +1,134 @@
+#include "paging.h"
+#include "context.h"
+#include "io.h"
+
+u32 g_FramePointer;
+u64 *g_PML4;
+
+void _zero_paging_structure(u64 *Structure)
+{
+    for (unsigned i = 0; i < 512; i++)
+        Structure[i] = 0;
+}
+
+u32 _allocate_frame_4k(void)
+{
+    u32 Frame = g_FramePointer;
+    if (Frame > 0xEFFFFF)
+    {
+        puts("BUG: Out of extended memory.\n");
+        for (;;) {}
+    }
+    g_FramePointer += 0x1000;
+    return Frame;
+}
+
+void paging_setup(u32 AllocateFramesFrom)
+{
+    g_FramePointer = AllocateFramesFrom;
+
+    // set up PML4
+    g_PML4 = (u64*)_allocate_frame_4k();
+    _zero_paging_structure(g_PML4);
+}
+
+u8 dbg = 0;
+void paging_map_page(u64 Virtual, u64 Physical)
+{
+    if (Virtual % 0x1000 || Physical % 0x1000)
+    {
+        puts("BUG: Requsted allocation of unaligned address.\n");
+        print_hex(Virtual);
+        for (;;) {}
+    }
+    // printf("Mapping %x\n", Virtual);
+    
+    u64 PML4I = GET_PML4_ENTRY(Virtual);
+    u64 PDPI = GET_PDP_ENTRY(Virtual);
+    u64 DIRI = GET_DIR_ENTRY(Virtual);
+    u64 TABI = GET_TAB_ENTRY(Virtual);
+    // printf("%x %i/%i/%i/%i\n", Virtual, PML4I, PDPI, DIRI, TABI);
+
+    u64 *PDP = (u64 *)(g_PML4[PML4I] & 0xFFFFF000);
+    if (PDP == 0)
+    {
+        // printf("-> Creating PDP @%i\n", PML4I);
+        PDP = (u64 *)_allocate_frame_4k();
+        _zero_paging_structure(PDP);
+        g_PML4[PML4I] = ((u64)PDP) | 3;
+    }
+    u64 *Directory = (u64 *)(PDP[PDPI] & 0xFFFFF000);
+    if (Directory == 0)
+    {
+        // printf("-> Creating Dirctory @%i/%i\n", PML4I, PDPI);
+        Directory = (u64 *)_allocate_frame_4k();
+        _zero_paging_structure(Directory);
+        PDP[PDPI] = ((u64)Directory) | 3;
+        printf("P%x[%i] < d%x\n", (u64)PDP, PDPI, (u64)Directory);
+        dbg = 0;
+    }
+    u64 *Table = (u64 *)(Directory[DIRI] & 0xFFFFF000);
+    if (Table == 0)
+    {
+        if (dbg < 3)
+        {
+            printf("P%x[%i] == D%x\n", (u64)PDP, PDPI, (u64)Directory);
+            dbg += 1;
+        }
+        // printf("P@ %x D@ %x, De %x\n", (u64)PDP, (u64)Directory, Directory[DIRI]);
+        // printf("-> Creating Table @%i/%i/%i\n", PML4I, PDPI, DIRI);
+        Table = (u64 *)_allocate_frame_4k();
+        // printf("aT %x\n", Table);
+        _zero_paging_structure(Table);
+        Directory[DIRI] = ((u64)Table) | 3;
+        // printf("De <- %x\n", Directory[DIRI]);
+    }
+    Table[TABI] = ((u64)Physical) | 3;
+}
+
+void paging_map_address(u64 PhysicalStart, u64 VirtualStart, u64 Size)
+{
+    if (VirtualStart % 0x1000 || PhysicalStart % 0x1000)
+    {
+        puts("BUG: Requsted allocation of unaligned address.\n");
+        for (;;) {}
+    }
+    u64 AlignedSize = Size;
+    if (AlignedSize % 0x1000)
+        AlignedSize = (AlignedSize + 0x1000) & 0xFFFFF000;
+    for (u64 i = 0; i < AlignedSize; i += 0x1000)
+    {
+        paging_map_page(VirtualStart + i, PhysicalStart + i);
+    }
+}
+
+void *paging_allocate(u64 VirtualStart, u64 Size)
+{
+    // let's first allocate all the pages for the actual data
+    u32 Start = 0;
+    for (u64 i = 0; i < Size; i += 0x1000)
+    {
+        u64 Frame = _allocate_frame_4k();
+        if (!Start)
+            Start = Frame;
+    }
+
+    // and now let's map the data (and allocate frames for mapping structures)
+    u32 Frame = Start;
+    for (u64 Virtual = VirtualStart; (Virtual - VirtualStart) < Size; Virtual += 0x1000)
+    {
+        paging_map_page(Virtual, Frame);
+        Frame += 0x1000;
+    }
+    return (void *)Start;
+}
+
+u32 paging_get_last_frame(void)
+{
+    return g_FramePointer;
+}
+
+void *paging_get_pml4(void)
+{
+    return g_PML4;
+}
\ No newline at end of file
diff --git a/Loader/src/paging.h b/Loader/src/paging.h
index e69de29..363e443 100644
--- a/Loader/src/paging.h
+++ b/Loader/src/paging.h
@@ -0,0 +1,18 @@
+#ifndef __PAGING_H__
+#define __PAGING_G__
+
+#include "types.h"
+
+#define GET_PML4_ENTRY(x) (((u64)x >> 39) & 0x1FF)
+#define GET_PDP_ENTRY(x) (((u64)x >> 30) & 0x1FF)
+#define GET_DIR_ENTRY(x) (((u64)x >> 21) & 0x1FF)
+#define GET_TAB_ENTRY(x) (((u64)x >> 12) & 0x1FF)
+#define GET_OFFSET(x) (x & 0xFFF)
+
+void paging_setup(u32 AllocateFramesFrom);
+void paging_map_address(u64 PhysicalStart, u64 VirtualStart, u64 Size);
+void *paging_allocate(u64 VirtualStart, u64 Size);
+u32 paging_get_last_frame(void);
+void *paging_get_pml4(void);
+
+#endif
\ No newline at end of file
diff --git a/Loader/src/types.h b/Loader/src/types.h
index a564091..83279c4 100644
--- a/Loader/src/types.h
+++ b/Loader/src/types.h
@@ -3,8 +3,11 @@
 
 typedef unsigned char u8;
 typedef unsigned short u16;
+typedef short s16;
 typedef unsigned int u32;
+typedef int s32;
 typedef unsigned long long u64;
+typedef long long s64;
 typedef char s8;
 
 #endif
\ No newline at end of file