diff --git a/Core/Driver/Driver.cpp b/Core/Driver/Driver.cpp
index cf45f33..7967097 100644
--- a/Core/Driver/Driver.cpp
+++ b/Core/Driver/Driver.cpp
@@ -39,6 +39,7 @@ namespace Driver
             debug("Stopping & unloading driver %ld [%#lx]", drv->DriverUID, drv->Address);
             DriverManager->IOCB(drv->DriverUID, (void *)&callback);
 
+            delete drv->MemTrk;
             for (size_t i = 0; i < sizeof(drv->InterruptHook) / sizeof(drv->InterruptHook[0]); i++)
             {
                 if (!drv->InterruptHook[i])
@@ -59,6 +60,7 @@ namespace Driver
                 debug("Stopping & unloading driver %ld [%#lx]", drv->DriverUID, drv->Address);
                 DriverManager->IOCB(drv->DriverUID, (void *)&callback);
 
+                delete drv->MemTrk;
                 for (size_t i = 0; i < sizeof(drv->InterruptHook) / sizeof(drv->InterruptHook[0]); i++)
                 {
                     if (!drv->InterruptHook[i])
@@ -81,16 +83,15 @@ namespace Driver
         return -1;
     }
 
-    DriverCode Driver::CallDriverEntryPoint(void *fex)
+    DriverCode Driver::CallDriverEntryPoint(void *fex, void *KAPIAddress)
     {
-        KernelAPI *API = (KernelAPI *)KernelAllocator.RequestPages(TO_PAGES(sizeof(KernelAPI)));
-        memcpy(API, &KAPI, sizeof(KernelAPI));
+        memcpy(KAPIAddress, &KernelAPITemplate, sizeof(KernelAPI));
 
-        API->Info.Offset = (unsigned long)fex;
-        API->Info.DriverUID = DriverUIDs++;
+        ((KernelAPI *)KAPIAddress)->Info.Offset = (unsigned long)fex;
+        ((KernelAPI *)KAPIAddress)->Info.DriverUID = DriverUIDs++;
 
-        debug("Calling driver entry point ( %#lx %ld )", (unsigned long)fex, API->Info.DriverUID);
-        int ret = ((int (*)(KernelAPI *))((uint64_t)((Fex *)fex)->EntryPoint + (uint64_t)fex))(API);
+        debug("Calling driver entry point ( %#lx %ld )", (unsigned long)fex, ((KernelAPI *)KAPIAddress)->Info.DriverUID);
+        int ret = ((int (*)(KernelAPI *))((uint64_t)((Fex *)fex)->EntryPoint + (uint64_t)fex))(((KernelAPI *)KAPIAddress));
 
         if (DriverReturnCode::OK != ret)
             return DriverCode::DRIVER_RETURNED_ERROR;
diff --git a/Core/Driver/DriverAPI.cpp b/Core/Driver/DriverAPI.cpp
index 6bba26f..6f11546 100644
--- a/Core/Driver/DriverAPI.cpp
+++ b/Core/Driver/DriverAPI.cpp
@@ -91,7 +91,7 @@ char *DriverPCIGetDeviceName(unsigned int VendorID, unsigned int DeviceID)
     return (char *)"Unknown";
 }
 
-KernelAPI KAPI = {
+KernelAPI KernelAPITemplate = {
     .Version = {
         .Major = 0,
         .Minor = 0,
diff --git a/Core/Driver/DriverLoading/BindInput.cpp b/Core/Driver/DriverLoading/BindInput.cpp
index 574027b..fc9905a 100644
--- a/Core/Driver/DriverLoading/BindInput.cpp
+++ b/Core/Driver/DriverLoading/BindInput.cpp
@@ -16,7 +16,8 @@ namespace Driver
 {
     DriverCode Driver::DriverLoadBindInput(void *DrvExtHdr, uint64_t DriverAddress, uint64_t Size, bool IsElf)
     {
-        Fex *fex = (Fex *)KernelAllocator.RequestPages(TO_PAGES(Size));
+        Memory::Tracker *Tracker = new Memory::Tracker;
+        Fex *fex = (Fex *)Tracker->RequestPages(TO_PAGES(Size));
         memcpy(fex, (void *)DriverAddress, Size);
         FexExtended *fexExtended = (FexExtended *)((uint64_t)fex + EXTENDED_SECTION_ADDRESS);
         debug("Driver allocated at %#lx-%#lx", fex, (uint64_t)fex + Size);
@@ -27,14 +28,16 @@ namespace Driver
               result[8], result[9], result[10], result[11], result[12], result[13], result[14], result[15]);
         kfree(result);
 #endif
-        if (CallDriverEntryPoint(fex) != DriverCode::OK)
+        KernelAPI *KAPI = (KernelAPI *)Tracker->RequestPages(TO_PAGES(sizeof(KernelAPI)));
+
+        if (CallDriverEntryPoint(fex, KAPI) != DriverCode::OK)
         {
-            KernelAllocator.FreePages(fex, TO_PAGES(Size));
+            delete Tracker;
             return DriverCode::DRIVER_RETURNED_ERROR;
         }
         debug("Starting driver %s (offset: %#lx)", fexExtended->Driver.Name, fex);
 
-        KernelCallback *KCallback = (KernelCallback *)KernelAllocator.RequestPages(TO_PAGES(sizeof(KernelCallback)));
+        KernelCallback *KCallback = (KernelCallback *)Tracker->RequestPages(TO_PAGES(sizeof(KernelCallback)));
 
         switch (fexExtended->Driver.Type)
         {
@@ -47,25 +50,23 @@ namespace Driver
             int CallbackRet = ((int (*)(KernelCallback *))((uint64_t)fexExtended->Driver.Callback + (uint64_t)fex))(KCallback);
             if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED)
             {
-                KernelAllocator.FreePages(fex, TO_PAGES(Size));
-                KernelAllocator.FreePages(KCallback, TO_PAGES(sizeof(KernelCallback)));
+                delete Tracker;
                 error("Driver %s does not implement the configuration callback", fexExtended->Driver.Name);
                 break;
             }
             else if (CallbackRet != DriverReturnCode::OK)
             {
-                KernelAllocator.FreePages(fex, TO_PAGES(Size));
-                KernelAllocator.FreePages(KCallback, TO_PAGES(sizeof(KernelCallback)));
+                delete Tracker;
                 error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet);
                 break;
             }
 
-            KernelAllocator.FreePages(fex, TO_PAGES(Size));
-            KernelAllocator.FreePages(KCallback, TO_PAGES(sizeof(KernelCallback)));
+            fixme("Input driver: %s", fexExtended->Driver.Name);
 
             DriverFile *DrvFile = new DriverFile;
             DrvFile->DriverUID = this->DriverUIDs - 1;
             DrvFile->Address = (void *)fex;
+            DrvFile->MemTrk = Tracker;
             DrvFile->InterruptHook[0] = nullptr;
             Drivers.push_back(DrvFile);
             break;
@@ -73,6 +74,7 @@ namespace Driver
         default:
         {
             warn("Unknown driver type: %d", fexExtended->Driver.Type);
+            delete Tracker;
             break;
         }
         }
diff --git a/Core/Driver/DriverLoading/BindInterrupt.cpp b/Core/Driver/DriverLoading/BindInterrupt.cpp
index e545299..0316cde 100644
--- a/Core/Driver/DriverLoading/BindInterrupt.cpp
+++ b/Core/Driver/DriverLoading/BindInterrupt.cpp
@@ -16,7 +16,8 @@ namespace Driver
 {
     DriverCode Driver::DriverLoadBindInterrupt(void *DrvExtHdr, uint64_t DriverAddress, uint64_t Size, bool IsElf)
     {
-        Fex *fex = (Fex *)KernelAllocator.RequestPages(TO_PAGES(Size));
+        Memory::Tracker *Tracker = new Memory::Tracker;
+        Fex *fex = (Fex *)Tracker->RequestPages(TO_PAGES(Size));
         memcpy(fex, (void *)DriverAddress, Size);
         FexExtended *fexExtended = (FexExtended *)((uint64_t)fex + EXTENDED_SECTION_ADDRESS);
         debug("Driver allocated at %#lx-%#lx", fex, (uint64_t)fex + Size);
@@ -27,14 +28,16 @@ namespace Driver
               result[8], result[9], result[10], result[11], result[12], result[13], result[14], result[15]);
         kfree(result);
 #endif
-        if (CallDriverEntryPoint(fex) != DriverCode::OK)
+        KernelAPI *KAPI = (KernelAPI *)Tracker->RequestPages(TO_PAGES(sizeof(KernelAPI)));
+
+        if (CallDriverEntryPoint(fex, KAPI) != DriverCode::OK)
         {
-            KernelAllocator.FreePages(fex, TO_PAGES(Size));
+            delete Tracker;
             return DriverCode::DRIVER_RETURNED_ERROR;
         }
         debug("Starting driver %s (offset: %#lx)", fexExtended->Driver.Name, fex);
 
-        KernelCallback *KCallback = (KernelCallback *)KernelAllocator.RequestPages(TO_PAGES(sizeof(KernelCallback)));
+        KernelCallback *KCallback = (KernelCallback *)Tracker->RequestPages(TO_PAGES(sizeof(KernelCallback)));
 
         switch (fexExtended->Driver.Type)
         {
@@ -44,17 +47,20 @@ namespace Driver
             DriverFile *DrvFile = new DriverFile;
             DrvFile->DriverUID = this->DriverUIDs - 1;
             DrvFile->Address = (void *)fex;
+            DrvFile->MemTrk = Tracker;
             Drivers.push_back(DrvFile);
             break;
         }
         case FexDriverType::FexDriverType_Display:
         {
             fixme("Display driver: %s", fexExtended->Driver.Name);
+            delete Tracker;
             break;
         }
         case FexDriverType::FexDriverType_Network:
         {
             fixme("Network driver: %s", fexExtended->Driver.Name);
+            delete Tracker;
             break;
         }
         case FexDriverType::FexDriverType_Storage:
@@ -68,8 +74,7 @@ namespace Driver
             }
 
             fixme("Not implemented");
-            KernelAllocator.FreePages(fex, TO_PAGES(Size));
-            KernelAllocator.FreePages(KCallback, TO_PAGES(sizeof(KernelCallback)));
+            delete Tracker;
             break;
 
             KCallback->RawPtr = nullptr;
@@ -77,29 +82,28 @@ namespace Driver
             int CallbackRet = ((int (*)(KernelCallback *))((uint64_t)fexExtended->Driver.Callback + (uint64_t)fex))(KCallback);
             if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED)
             {
-                KernelAllocator.FreePages(fex, TO_PAGES(Size));
-                KernelAllocator.FreePages(KCallback, TO_PAGES(sizeof(KernelCallback)));
                 error("Driver %s does not implement the configuration callback", fexExtended->Driver.Name);
+                delete Tracker;
                 break;
             }
             else if (CallbackRet != DriverReturnCode::OK)
             {
-                KernelAllocator.FreePages(fex, TO_PAGES(Size));
-                KernelAllocator.FreePages(KCallback, TO_PAGES(sizeof(KernelCallback)));
                 error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet);
+                delete Tracker;
                 break;
             }
 
-            KernelAllocator.FreePages(fex, TO_PAGES(Size));
-            KernelAllocator.FreePages(KCallback, TO_PAGES(sizeof(KernelCallback)));
-
-            // DriverFile *DrvFile = new DriverFile;
-            // Drivers.push_back(DrvFile);
+            DriverFile *DrvFile = new DriverFile;
+            DrvFile->DriverUID = this->DriverUIDs - 1;
+            DrvFile->Address = (void *)fex;
+            DrvFile->MemTrk = Tracker;
+            Drivers.push_back(DrvFile);
             break;
         }
         case FexDriverType::FexDriverType_FileSystem:
         {
             fixme("Filesystem driver: %s", fexExtended->Driver.Name);
+            delete Tracker;
             break;
         }
         case FexDriverType::FexDriverType_Input:
@@ -125,16 +129,16 @@ namespace Driver
             int CallbackRet = ((int (*)(KernelCallback *))((uint64_t)fexExtended->Driver.Callback + (uint64_t)fex))(KCallback);
             if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED)
             {
-                KernelAllocator.FreePages(fex, TO_PAGES(Size));
-                KernelAllocator.FreePages(KCallback, TO_PAGES(sizeof(KernelCallback)));
                 error("Driver %s does not implement the configuration callback", fexExtended->Driver.Name);
+                delete InterruptHook;
+                delete Tracker;
                 break;
             }
             else if (CallbackRet != DriverReturnCode::OK)
             {
-                KernelAllocator.FreePages(fex, TO_PAGES(Size));
-                KernelAllocator.FreePages(KCallback, TO_PAGES(sizeof(KernelCallback)));
                 error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet);
+                delete InterruptHook;
+                delete Tracker;
                 break;
             }
 
@@ -144,6 +148,7 @@ namespace Driver
             DriverFile *DrvFile = new DriverFile;
             DrvFile->DriverUID = this->DriverUIDs - 1;
             DrvFile->Address = (void *)fex;
+            DrvFile->MemTrk = Tracker;
             DrvFile->InterruptHook[0] = InterruptHook;
             Drivers.push_back(DrvFile);
             break;
@@ -151,11 +156,13 @@ namespace Driver
         case FexDriverType::FexDriverType_Audio:
         {
             fixme("Audio driver: %s", fexExtended->Driver.Name);
+            delete Tracker;
             break;
         }
         default:
         {
             warn("Unknown driver type: %d", fexExtended->Driver.Type);
+            delete Tracker;
             break;
         }
         }
diff --git a/Core/Driver/DriverLoading/BindPCI.cpp b/Core/Driver/DriverLoading/BindPCI.cpp
index d661a31..8672bbf 100644
--- a/Core/Driver/DriverLoading/BindPCI.cpp
+++ b/Core/Driver/DriverLoading/BindPCI.cpp
@@ -31,7 +31,8 @@ namespace Driver
                 foreach (auto PCIDevice in devices)
                 {
                     debug("[%ld] VendorID: %#x; DeviceID: %#x", devices.size(), PCIDevice->VendorID, PCIDevice->DeviceID);
-                    Fex *fex = (Fex *)KernelAllocator.RequestPages(TO_PAGES(Size));
+                    Memory::Tracker *Tracker = new Memory::Tracker();
+                    Fex *fex = (Fex *)Tracker->RequestPages(TO_PAGES(Size));
                     memcpy(fex, (void *)DriverAddress, Size);
                     FexExtended *fexExtended = (FexExtended *)((uint64_t)fex + EXTENDED_SECTION_ADDRESS);
                     debug("Driver allocated at %#lx-%#lx", fex, (uint64_t)fex + Size);
@@ -42,14 +43,16 @@ namespace Driver
                           result[8], result[9], result[10], result[11], result[12], result[13], result[14], result[15]);
                     kfree(result);
 #endif
-                    if (CallDriverEntryPoint(fex) != DriverCode::OK)
+                    KernelAPI *KAPI = (KernelAPI *)Tracker->RequestPages(TO_PAGES(sizeof(KernelAPI)));
+
+                    if (CallDriverEntryPoint(fex, KAPI) != DriverCode::OK)
                     {
-                        KernelAllocator.FreePages(fex, TO_PAGES(Size));
+                        delete Tracker;
                         return DriverCode::DRIVER_RETURNED_ERROR;
                     }
                     debug("Starting driver %s", fexExtended->Driver.Name);
 
-                    KernelCallback *KCallback = (KernelCallback *)KernelAllocator.RequestPages(TO_PAGES(sizeof(KernelCallback)));
+                    KernelCallback *KCallback = (KernelCallback *)Tracker->RequestPages(TO_PAGES(sizeof(KernelCallback)));
 
                     debug("Type: %d; IOBase: %#x; MemoryBase: %#x",
                           ((PCI::PCIHeader0 *)PCIDevice)->BAR0 & 1,
@@ -82,11 +85,13 @@ namespace Driver
                     case FexDriverType::FexDriverType_Generic:
                     {
                         fixme("Generic driver: %s", fexExtended->Driver.Name);
+                        delete Tracker;
                         break;
                     }
                     case FexDriverType::FexDriverType_Display:
                     {
                         fixme("Display driver: %s", fexExtended->Driver.Name);
+                        delete Tracker;
                         break;
                     }
                     case FexDriverType::FexDriverType_Network:
@@ -100,20 +105,18 @@ namespace Driver
                         int CallbackRet = ((int (*)(KernelCallback *))((uint64_t)fexExtended->Driver.Callback + (uint64_t)fex))(KCallback);
                         if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED)
                         {
-                            KernelAllocator.FreePages(fex, TO_PAGES(Size));
-                            KernelAllocator.FreePages(KCallback, TO_PAGES(sizeof(KernelCallback)));
-                            delete InterruptHook;
                             error("Driver %s does not implement the configuration callback", fexExtended->Driver.Name);
+                            delete Tracker;
+                            delete InterruptHook;
                             continue;
                         }
                         else if (CallbackRet == DriverReturnCode::OK)
                             trace("Device found for driver: %s", fexExtended->Driver.Name);
                         else
                         {
-                            KernelAllocator.FreePages(fex, TO_PAGES(Size));
-                            KernelAllocator.FreePages(KCallback, TO_PAGES(sizeof(KernelCallback)));
-                            delete InterruptHook;
                             error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet);
+                            delete Tracker;
+                            delete InterruptHook;
                             continue;
                         }
 
@@ -134,18 +137,16 @@ namespace Driver
                         int CallbackRet = ((int (*)(KernelCallback *))((uint64_t)fexExtended->Driver.Callback + (uint64_t)fex))(KCallback);
                         if (CallbackRet == DriverReturnCode::NOT_IMPLEMENTED)
                         {
-                            KernelAllocator.FreePages(fex, TO_PAGES(Size));
-                            KernelAllocator.FreePages(KCallback, TO_PAGES(sizeof(KernelCallback)));
                             error("Driver %s does not implement the configuration callback", fexExtended->Driver.Name);
+                            delete Tracker;
                             continue;
                         }
                         else if (CallbackRet == DriverReturnCode::OK)
                             trace("Device found for driver: %s", fexExtended->Driver.Name);
                         else
                         {
-                            KernelAllocator.FreePages(fex, TO_PAGES(Size));
-                            KernelAllocator.FreePages(KCallback, TO_PAGES(sizeof(KernelCallback)));
                             error("Driver %s returned error %d", fexExtended->Driver.Name, CallbackRet);
+                            delete Tracker;
                             continue;
                         }
 
@@ -159,21 +160,25 @@ namespace Driver
                     case FexDriverType::FexDriverType_FileSystem:
                     {
                         fixme("Filesystem driver: %s", fexExtended->Driver.Name);
+                        delete Tracker;
                         break;
                     }
                     case FexDriverType::FexDriverType_Input:
                     {
                         fixme("Input driver: %s", fexExtended->Driver.Name);
+                        delete Tracker;
                         break;
                     }
                     case FexDriverType::FexDriverType_Audio:
                     {
                         fixme("Audio driver: %s", fexExtended->Driver.Name);
+                        delete Tracker;
                         break;
                     }
                     default:
                     {
                         warn("Unknown driver type: %d", fexExtended->Driver.Type);
+                        delete Tracker;
                         break;
                     }
                     }
diff --git a/Core/Driver/api.hpp b/Core/Driver/api.hpp
index 7f4a768..9474368 100644
--- a/Core/Driver/api.hpp
+++ b/Core/Driver/api.hpp
@@ -5,6 +5,6 @@
 
 #include "../../DAPI.hpp"
 
-extern KernelAPI KAPI;
+extern KernelAPI KernelAPITemplate;
 
 #endif // !__FENNIX_KERNEL_DRIVER_API_H__
diff --git a/include/driver.hpp b/include/driver.hpp
index 76a3a65..7349ea5 100644
--- a/include/driver.hpp
+++ b/include/driver.hpp
@@ -5,6 +5,7 @@
 
 #include <interrupts.hpp>
 #include <vector.hpp>
+#include <memory.hpp>
 #include <debug.h>
 #include <cpu.hpp>
 
@@ -46,6 +47,7 @@ namespace Driver
     {
         unsigned long DriverUID;
         void *Address;
+        Memory::Tracker *MemTrk;
         DriverInterruptHook *InterruptHook[16];
     };
 
@@ -55,7 +57,7 @@ namespace Driver
         Vector<DriverFile *> Drivers;
         unsigned long DriverUIDs = 0;
 
-        DriverCode CallDriverEntryPoint(void *fex);
+        DriverCode CallDriverEntryPoint(void *fex, void *KAPIAddress);
         DriverCode DriverLoadBindPCI(void *DrvExtHdr, uint64_t DriverAddress, uint64_t Size, bool IsElf = false);
         DriverCode DriverLoadBindInterrupt(void *DrvExtHdr, uint64_t DriverAddress, uint64_t Size, bool IsElf = false);
         DriverCode DriverLoadBindInput(void *DrvExtHdr, uint64_t DriverAddress, uint64_t Size, bool IsElf = false);