:boom: A big refactor on the filesystem structure.

Signed-off-by: Amlal <amlal@el-mahrouss-logic.com>

56 files changed, 5503 insertions, 0 deletions

diff --git a/dev/zka/src/Array.cxx b/dev/zka/src/Array.cxx
new file mode 100644
index 00000000..202bee7e
--- /dev/null
+++ b/dev/zka/src/Array.cxx
@@ -0,0 +1,7 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+------------------------------------------- */
+
+#include <NewKit/Array.hxx>
diff --git a/dev/zka/src/ArrayList.cxx b/dev/zka/src/ArrayList.cxx
new file mode 100644
index 00000000..71589c9b
--- /dev/null
+++ b/dev/zka/src/ArrayList.cxx
@@ -0,0 +1,7 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+------------------------------------------- */
+
+#include <NewKit/ArrayList.hxx>
diff --git a/dev/zka/src/Atom.cxx b/dev/zka/src/Atom.cxx
new file mode 100644
index 00000000..e5a3f407
--- /dev/null
+++ b/dev/zka/src/Atom.cxx
@@ -0,0 +1,10 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+------------------------------------------- */
+
+#include <NewKit/Atom.hxx>
+
+// @file Atom.cpp
+// @brief Atomic primitives
diff --git a/dev/zka/src/CodeMgr.cxx b/dev/zka/src/CodeMgr.cxx
new file mode 100644
index 00000000..13bcd640
--- /dev/null
+++ b/dev/zka/src/CodeMgr.cxx
@@ -0,0 +1,33 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+------------------------------------------- */
+
+#include <NewKit/Utils.hxx>
+#include <KernelKit/CodeMgr.hxx>
+#include <KernelKit/UserProcessScheduler.hxx>
+
+namespace Kernel
+{
+	/// @brief Executes a new process from a function. Kernel code only.
+	/// @note This sets up a new stack, anything on the main function that calls the Kernel will not be accessible.
+	/// @param main the start of the process.
+	/// @return if the process was started or not.
+	Bool sched_execute_thread(MainKind main, const Char* process_name) noexcept
+	{
+		if (!main)
+			return No;
+
+		UserProcess proc;
+		proc.SetImageStart(reinterpret_cast<VoidPtr>(main));
+
+		proc.Kind	   = UserProcess::kExeKind;
+		proc.StackSize = kib_cast(32);
+
+		rt_set_memory(proc.Name, 0, kProcessLen);
+		rt_copy_memory((VoidPtr)process_name, proc.Name, rt_string_len(process_name));
+
+		return UserProcessScheduler::The().Add(proc) > 0;
+	}
+} // namespace Kernel
diff --git a/dev/zka/src/Crc32.cxx b/dev/zka/src/Crc32.cxx
new file mode 100644
index 00000000..42dc9b8e
--- /dev/null
+++ b/dev/zka/src/Crc32.cxx
@@ -0,0 +1,74 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+------------------------------------------- */
+
+#include <NewKit/Crc32.hxx>
+
+// @file CRC32.cpp
+// @brief Check sequence implementation.
+
+namespace Kernel
+{
+	/// @brief The CRC32 table.
+	UInt kCrcTbl[kCrcCnt] = {
+		0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
+		0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
+		0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
+		0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
+		0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
+		0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
+		0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
+		0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
+		0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
+		0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
+		0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,
+		0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
+		0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
+		0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
+		0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
+		0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
+		0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
+		0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
+		0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
+		0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
+		0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
+		0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
+		0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
+		0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
+		0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
+		0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
+		0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
+		0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
+		0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
+		0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
+		0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
+		0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
+		0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
+		0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
+		0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
+		0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
+		0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
+		0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
+		0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
+		0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
+		0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
+		0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
+		0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d};
+
+	/// @brief Calculate CRC32 of p
+	/// @param p the data to compute.
+	/// @param len the length of the data.
+	/// @return the CRC32.
+	UInt ke_calculate_crc32(const Char* p, UInt len) noexcept
+	{
+		UInt crc = 0xffffffff;
+
+		while (len-- != 0)
+			crc = kCrcTbl[((UInt8)crc ^ *(p++))] ^ (crc >> 8);
+
+		// return (~crc); also works, does the same thing.
+		return (crc ^ 0xffffffff);
+	}
+} // namespace Kernel
diff --git a/dev/zka/src/CxxAbi-AMD64.cxx b/dev/zka/src/CxxAbi-AMD64.cxx
new file mode 100644
index 00000000..908e26f4
--- /dev/null
+++ b/dev/zka/src/CxxAbi-AMD64.cxx
@@ -0,0 +1,91 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+------------------------------------------- */
+
+#ifdef __ZKA_AMD64__
+
+#include <KernelKit/DebugOutput.hxx>
+#include <NewKit/CxxAbi.hxx>
+#include <KernelKit/LPC.hxx>
+
+atexit_func_entry_t __atexit_funcs[kDSOMaxObjects];
+
+uarch_t __atexit_func_count;
+
+/// @brief Dynamic Shared Object Handle.
+Kernel::UIntPtr __dso_handle;
+
+EXTERN_C void __cxa_pure_virtual()
+{
+	kcout << "C++ placeholder method.\n";
+}
+
+EXTERN_C void ___chkstk_ms(void)
+{
+	Kernel::err_bug_check_raise();
+	Kernel::err_bug_check();
+}
+
+EXTERN_C int atexit(void (*f)(void*), void* arg, void* dso)
+{
+	if (__atexit_func_count >= kDSOMaxObjects)
+		return -1;
+
+	__atexit_funcs[__atexit_func_count].destructor_func = f;
+	__atexit_funcs[__atexit_func_count].obj_ptr			= arg;
+	__atexit_funcs[__atexit_func_count].dso_handle		= dso;
+
+	__atexit_func_count++;
+
+	return 0;
+}
+
+EXTERN_C void __cxa_finalize(void* f)
+{
+	uarch_t i = __atexit_func_count;
+	if (!f)
+	{
+		while (i--)
+		{
+			if (__atexit_funcs[i].destructor_func)
+			{
+				(*__atexit_funcs[i].destructor_func)(__atexit_funcs[i].obj_ptr);
+			};
+		}
+
+		return;
+	}
+
+	while (i--)
+	{
+		if (__atexit_funcs[i].destructor_func)
+		{
+			(*__atexit_funcs[i].destructor_func)(__atexit_funcs[i].obj_ptr);
+			__atexit_funcs[i].destructor_func = 0;
+		};
+	}
+}
+
+namespace cxxabiv1
+{
+	EXTERN_C int __cxa_guard_acquire(__guard* g)
+	{
+		(void)g;
+		return 0;
+	}
+
+	EXTERN_C int __cxa_guard_release(__guard* g)
+	{
+		*(char*)g = 1;
+		return 0;
+	}
+
+	EXTERN_C void __cxa_guard_abort(__guard* g)
+	{
+		(void)g;
+	}
+} // namespace cxxabiv1
+
+#endif // ifdef __ZKA_AMD64__
diff --git a/dev/zka/src/CxxAbi-ARM64.cxx b/dev/zka/src/CxxAbi-ARM64.cxx
new file mode 100644
index 00000000..679be041
--- /dev/null
+++ b/dev/zka/src/CxxAbi-ARM64.cxx
@@ -0,0 +1,74 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+------------------------------------------- */
+
+#ifdef __ZKA_ARM64__
+
+#include <KernelKit/DebugOutput.hxx>
+#include <NewKit/CxxAbi.hxx>
+#include <KernelKit/LPC.hxx>
+
+EXTERN_C
+{
+#include <limits.h>
+}
+
+int const cUninitialized	= 0;
+int const cBeingInitialized = -1;
+int const cEpochStart		= INT_MIN;
+
+EXTERN_C
+{
+	int			 _Init_global_epoch = cEpochStart;
+	__thread int _Init_thread_epoch = cEpochStart;
+}
+
+Kernel::UInt32 const cNKTimeout = 100; // ms
+
+EXTERN_C void __cdecl _Init_thread_wait(Kernel::UInt32 const timeout)
+{
+	MUST_PASS(timeout != INT_MAX);
+}
+
+EXTERN_C void __cdecl _Init_thread_header(int* const pOnce) noexcept
+{
+	if (*pOnce == cUninitialized)
+	{
+		*pOnce = cBeingInitialized;
+	}
+	else
+	{
+		while (*pOnce == cBeingInitialized)
+		{
+			_Init_thread_wait(cNKTimeout);
+
+			if (*pOnce == cUninitialized)
+			{
+				*pOnce = cBeingInitialized;
+				return;
+			}
+		}
+		_Init_thread_epoch = _Init_global_epoch;
+	}
+}
+
+EXTERN_C void __cdecl _Init_thread_abort(int* const pOnce) noexcept
+{
+	*pOnce = cUninitialized;
+}
+
+EXTERN_C void __cdecl _Init_thread_footer(int* const pOnce) noexcept
+{
+	++_Init_global_epoch;
+	*pOnce			   = _Init_global_epoch;
+	_Init_thread_epoch = _Init_global_epoch;
+}
+
+EXTERN_C void _purecall()
+{
+	kcout << "C++ placeholder method.\n";
+}
+
+#endif // ifdef __ZKA_ARM64__
diff --git a/dev/zka/src/Defines.cxx b/dev/zka/src/Defines.cxx
new file mode 100644
index 00000000..2e8dde86
--- /dev/null
+++ b/dev/zka/src/Defines.cxx
@@ -0,0 +1,7 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+------------------------------------------- */
+
+#include <NewKit/Defines.hxx>
diff --git a/dev/zka/src/DeviceMgr.cxx b/dev/zka/src/DeviceMgr.cxx
new file mode 100644
index 00000000..70d01984
--- /dev/null
+++ b/dev/zka/src/DeviceMgr.cxx
@@ -0,0 +1,7 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+------------------------------------------- */
+
+#include <KernelKit/DeviceMgr.hxx>
diff --git a/dev/zka/src/DriveMgr.cxx b/dev/zka/src/DriveMgr.cxx
new file mode 100644
index 00000000..f6436f75
--- /dev/null
+++ b/dev/zka/src/DriveMgr.cxx
@@ -0,0 +1,151 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+------------------------------------------- */
+
+#include <KernelKit/DebugOutput.hxx>
+#include <KernelKit/DriveMgr.hxx>
+#include <NewKit/Utils.hxx>
+
+#include <Modules/ATA/ATA.hxx>
+#include <Modules/AHCI/AHCI.hxx>
+#include <Modules/NVME/Defines.hxx>
+
+/// @file DriveMgr.cxx
+/// @brief Kernel drive manager.
+
+namespace Kernel
+{
+	STATIC UInt16 kATAIO	 = 0U;
+	STATIC UInt8  kATAMaster = 0U;
+
+	/// @brief reads from an ATA drive.
+	/// @param pckt
+	/// @return
+	Void ke_drv_input(DriveTrait::DrivePacket* pckt)
+	{
+		if (!pckt)
+		{
+			return;
+		}
+
+#ifdef __AHCI__
+		drv_std_read(pckt->fLba, (Char*)pckt->fPacketContent, kAHCISectorSize, pckt->fPacketSize);
+#elif defined(__ATA_PIO__) || defined(__ATA_DMA__)
+		drv_std_read(pckt->fLba, kATAIO, kATAMaster, (Char*)pckt->fPacketContent, kATASectorSize, pckt->fPacketSize);
+#endif
+	}
+
+	/// @brief Writes to an ATA drive.
+	/// @param pckt
+	/// @return
+	Void ke_drv_output(DriveTrait::DrivePacket* pckt)
+	{
+		if (!pckt)
+		{
+			return;
+		}
+
+#ifdef __AHCI__
+		drv_std_write(pckt->fLba, (Char*)pckt->fPacketContent, kAHCISectorSize, pckt->fPacketSize);
+#elif defined(__ATA_PIO__) || defined(__ATA_DMA__)
+		drv_std_write(pckt->fLba, kATAIO, kATAMaster, (Char*)pckt->fPacketContent, kATASectorSize, pckt->fPacketSize);
+#endif
+	}
+
+	/// @brief Executes a disk check on the ATA drive.
+	/// @param pckt
+	/// @return
+	Void ke_drv_init(DriveTrait::DrivePacket* pckt)
+	{
+		if (!pckt)
+		{
+			return;
+		}
+
+		pckt->fPacketGood = false;
+
+#if defined(__ATA_PIO__) || defined(__ATA_DMA__)
+		kATAMaster = true;
+		kATAIO	   = ATA_PRIMARY_IO;
+
+		MUST_PASS(drv_std_init(kATAIO, kATAMaster, kATAIO, kATAMaster));
+#elif defined(__AHCI__)
+		UInt16 pi = 0;
+		MUST_PASS(drv_std_init(pi));
+#endif // if defined(__ATA_PIO__) || defined (__ATA_DMA__)
+
+		pckt->fPacketGood = true;
+	}
+
+/// @brief Gets the drive kind (ATA, SCSI, AHCI...)
+/// @param
+/// @return
+#ifdef __ATA_PIO__
+	const Char* ke_drv_kind(Void)
+	{
+		return "ATA-PIO";
+	}
+#endif
+
+#ifdef __ATA_DMA__
+	const Char* ke_drv_kind(Void)
+	{
+		return "ATA-DMA";
+	}
+#endif
+
+#ifdef __AHCI__
+	const Char* ke_drv_kind(Void)
+	{
+		return "AHCI";
+	}
+#endif
+
+	/// @brief Unimplemented drive.
+	/// @param pckt
+	/// @return
+	Void io_drv_unimplemented(DriveTrait::DrivePacket* pckt)
+	{
+		ZKA_UNUSED(pckt);
+	}
+
+	/// @brief Makes a new drive.
+	/// @return the new drive.
+	DriveTrait io_construct_drive() noexcept
+	{
+		DriveTrait trait;
+
+		rt_copy_memory((VoidPtr) "\\Mount\\NUL:", trait.fName, rt_string_len("\\Mount\\NUL:"));
+		trait.fKind = kInvalidDrive;
+
+		trait.fInput	 = io_drv_unimplemented;
+		trait.fOutput	 = io_drv_unimplemented;
+		trait.fVerify	 = io_drv_unimplemented;
+		trait.fInit		 = io_drv_unimplemented;
+		trait.fDriveKind = ke_drv_kind;
+
+		return trait;
+	}
+
+	/// @brief Fetches the main drive.
+	/// @return the new drive.
+	DriveTrait io_construct_main_drive() noexcept
+	{
+		DriveTrait trait;
+
+		rt_copy_memory((VoidPtr) "\\Mount\\MainDisk:", trait.fName, rt_string_len("\\Mount\\MainDisk:"));
+		trait.fKind = kMassStorage;
+
+		trait.fInput	 = ke_drv_input;
+		trait.fOutput	 = ke_drv_output;
+		trait.fVerify	 = io_drv_unimplemented;
+		trait.fInit		 = ke_drv_init;
+		trait.fDriveKind = ke_drv_kind;
+
+		kcout << "Construct drive with success.\r";
+
+		return trait;
+	}
+} // namespace Kernel
diff --git a/dev/zka/src/ErrorOr.cxx b/dev/zka/src/ErrorOr.cxx
new file mode 100644
index 00000000..0205506d
--- /dev/null
+++ b/dev/zka/src/ErrorOr.cxx
@@ -0,0 +1,12 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+------------------------------------------- */
+
+#include <NewKit/ErrorOr.hxx>
+
+/***********************************************************************************/
+/// @file ErrorOr.cxx                                                            ///
+/// @brief Error Or Value class.                                                 ///
+/***********************************************************************************/
diff --git a/dev/zka/src/FS/FAT32.cxx b/dev/zka/src/FS/FAT32.cxx
new file mode 100644
index 00000000..9e22e2a8
--- /dev/null
+++ b/dev/zka/src/FS/FAT32.cxx
@@ -0,0 +1,12 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+------------------------------------------- */
+
+#ifdef __FSKIT_INCLUDES_HPFS__
+
+#include <FirmwareKit/GPT.hxx>
+#include <FirmwareKit/EPM.hxx>
+
+#endif // ifdef __FSKIT_INCLUDES_HPFS__
diff --git a/dev/zka/src/FS/NeFS.cxx b/dev/zka/src/FS/NeFS.cxx
new file mode 100644
index 00000000..69b0c401
--- /dev/null
+++ b/dev/zka/src/FS/NeFS.cxx
@@ -0,0 +1,1055 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+------------------------------------------- */
+
+#ifdef __FSKIT_USE_NEFS__
+
+#include <Modules/AHCI/AHCI.hxx>
+#include <Modules/ATA/ATA.hxx>
+#include <Modules/Flash/Flash.hxx>
+#include <FSKit/NeFS.hxx>
+#include <KernelKit/LPC.hxx>
+#include <NewKit/Crc32.hxx>
+#include <NewKit/KernelCheck.hxx>
+#include <NewKit/String.hxx>
+#include <NewKit/Utils.hxx>
+#include <FirmwareKit/EPM.hxx>
+#include <KernelKit/UserProcessScheduler.hxx>
+#include <KernelKit/User.hxx>
+
+using namespace Kernel;
+
+#ifdef __ED__
+/***********************************************************************************/
+/**
+	Define those external symbols, to make the editor shutup
+*/
+/***********************************************************************************/
+
+/***********************************************************************************/
+/// @brief get sector count.
+/***********************************************************************************/
+Kernel::SizeT drv_get_sector_count();
+
+/***********************************************************************************/
+/// @brief get device size.
+/***********************************************************************************/
+Kernel::SizeT drv_get_size();
+
+#endif
+
+///! BUGS: 0
+
+/***********************************************************************************/
+/// This file implements the New File System.
+///	New File System implements a B-Tree based algortihm.
+///		\\
+///	\\Path1\\		\\ath2\\
+/// \\readme.rtf		\\ListContents.pef \\readme.lnk <-- symlink.
+///								\\Path1\\readme.rtf
+/***********************************************************************************/
+
+STATIC MountpointInterface sMountpointInterface;
+
+/***********************************************************************************/
+/// @brief Creates a new fork inside the New filesystem partition.
+/// @param catalog it's catalog
+/// @param the_fork the fork itself.
+/// @return the fork
+/***********************************************************************************/
+_Output NFS_FORK_STRUCT* NeFSParser::CreateFork(_Input NFS_CATALOG_STRUCT* catalog,
+												_Input NFS_FORK_STRUCT&	   the_fork)
+{
+	if (catalog && the_fork.ForkName[0] != 0 &&
+		the_fork.DataSize <= kNeFSForkDataSz)
+	{
+		Lba lba = (the_fork.Kind == kNeFSDataForkKind) ? catalog->DataFork
+													   : catalog->ResourceFork;
+
+		kcout << "fork lba: " << hex_number(lba) << endl;
+
+		if (lba <= kNeFSCatalogStartAddress)
+			return nullptr;
+
+		auto drv = sMountpointInterface.A();
+
+		/// special treatment.
+		rt_copy_memory((VoidPtr) "fs/newfs-packet", drv.fPacket.fPacketMime,
+					   rt_string_len("fs/newfs-packet"));
+
+		NFS_FORK_STRUCT curFork{0};
+		NFS_FORK_STRUCT prevFork{0};
+		Lba				lbaOfPreviousFork = lba;
+
+		/// do not check for anything. Loop until we get what we want, that is a free fork zone.
+		while (true)
+		{
+			if (lba <= kNeFSCatalogStartAddress)
+				break;
+
+			drv.fPacket.fLba		   = lba;
+			drv.fPacket.fPacketSize	   = sizeof(NFS_FORK_STRUCT);
+			drv.fPacket.fPacketContent = &curFork;
+
+			drv.fInput(&drv.fPacket);
+
+			if (curFork.NextSibling > kBadAddress)
+			{
+				kcout << "bad fork: " << hex_number(curFork.NextSibling) << endl;
+				break;
+			}
+
+			kcout << "next fork: " << hex_number(curFork.NextSibling) << endl;
+
+			if (curFork.Flags & kNeFSFlagCreated)
+			{
+				kcout << "fork already exists.\r";
+
+				/// sanity check.
+				if (StringBuilder::Equals(curFork.ForkName, the_fork.ForkName) &&
+					StringBuilder::Equals(curFork.CatalogName, catalog->Name))
+					return nullptr;
+
+				kcout << "next fork: " << hex_number(curFork.NextSibling) << endl;
+
+				lbaOfPreviousFork = lba;
+				lba				  = curFork.NextSibling;
+
+				prevFork = curFork;
+			}
+			else
+			{
+				/// This is a check that we have, in order to link the previous fork
+				/// entry.
+				if (lba >= kNeFSCatalogStartAddress)
+				{
+					drv.fPacket.fLba		   = lbaOfPreviousFork;
+					drv.fPacket.fPacketSize	   = sizeof(NFS_FORK_STRUCT);
+					drv.fPacket.fPacketContent = &prevFork;
+
+					prevFork.NextSibling = lba;
+
+					/// write to disk.
+					drv.fOutput(&drv.fPacket);
+				}
+
+				break;
+			}
+		}
+
+		constexpr auto cForkPadding =
+			4; /// this value gives us space for the data offset.
+
+		the_fork.Flags |= kNeFSFlagCreated;
+		the_fork.DataOffset		 = lba - sizeof(NFS_FORK_STRUCT);
+		the_fork.PreviousSibling = lbaOfPreviousFork;
+		the_fork.NextSibling	 = the_fork.DataOffset - the_fork.DataSize - sizeof(NFS_FORK_STRUCT);
+
+		drv.fPacket.fLba		   = lba;
+		drv.fPacket.fPacketSize	   = sizeof(NFS_FORK_STRUCT);
+		drv.fPacket.fPacketContent = &the_fork;
+
+		drv.fOutput(&drv.fPacket);
+
+		/// log what we have now.
+		kcout << "Wrote fork data at: " << hex_number(the_fork.DataOffset)
+			  << endl;
+
+		kcout << "Wrote fork at: " << hex_number(lba) << endl;
+
+		return &the_fork;
+	}
+
+	return nullptr;
+}
+
+/***********************************************************************************/
+/// @brief Find fork inside New filesystem.
+/// @param catalog the catalog.
+/// @param name the fork name.
+/// @return the fork.
+/***********************************************************************************/
+_Output NFS_FORK_STRUCT* NeFSParser::FindFork(_Input NFS_CATALOG_STRUCT* catalog,
+											  _Input const Char*		 name,
+											  Boolean					 isDataFork)
+{
+	auto			 drv	  = sMountpointInterface.A();
+	NFS_FORK_STRUCT* the_fork = nullptr;
+
+	Lba lba = isDataFork ? catalog->DataFork : catalog->ResourceFork;
+
+	while (lba != 0)
+	{
+		drv.fPacket.fLba		   = lba;
+		drv.fPacket.fPacketSize	   = sizeof(NFS_FORK_STRUCT);
+		drv.fPacket.fPacketContent = (VoidPtr)the_fork;
+
+		rt_copy_memory((VoidPtr) "fs/newfs-packet", drv.fPacket.fPacketMime, 16);
+
+		if (auto res =
+				fs_newfs_read(&sMountpointInterface, drv, this->fDriveIndex);
+			res)
+		{
+			switch (res)
+			{
+			case 1:
+				ErrLocal() = kErrorDiskReadOnly;
+				break;
+			case 2:
+				ErrLocal() = kErrorDiskIsFull;
+				break;
+				ErrLocal() = kErrorNoSuchDisk;
+				break;
+
+			default:
+				break;
+			}
+			return nullptr;
+		}
+
+		if (StringBuilder::Equals(the_fork->ForkName, name))
+		{
+			break;
+		}
+
+		lba = the_fork->NextSibling;
+	}
+
+	return the_fork;
+}
+
+/***********************************************************************************/
+/// @brief Simpler factory to create a catalog (assumes you want to create a
+/// file.)
+/// @param name
+/// @return catalog pointer.
+/***********************************************************************************/
+_Output NFS_CATALOG_STRUCT* NeFSParser::CreateCatalog(_Input const Char* name)
+{
+	return this->CreateCatalog(name, 0, kNeFSCatalogKindFile);
+}
+
+/***********************************************************************************/
+/// @brief Creates a new catalog into the disk.
+/// @param name the catalog name.
+/// @param flags the flags of the catalog.
+/// @param kind the catalog kind.
+/// @return catalog pointer.
+/***********************************************************************************/
+_Output NFS_CATALOG_STRUCT* NeFSParser::CreateCatalog(_Input const Char*  name,
+													  _Input const Int32& flags,
+													  _Input const Int32& kind)
+{
+	kcout << "CreateCatalog(...)\r";
+
+	Lba out_lba = 0UL;
+
+	kcout << "Checking for extension...\r";
+
+	/// a directory should have a slash in the end.
+	if (kind == kNeFSCatalogKindDir &&
+		name[rt_string_len(name) - 1] != NeFileSystemHelper::Separator())
+		return nullptr;
+
+	/// a file shouldn't have a slash in the end.
+	if (kind != kNeFSCatalogKindDir &&
+		name[rt_string_len(name) - 1] == NeFileSystemHelper::Separator())
+		return nullptr;
+
+	NFS_CATALOG_STRUCT* catalog_copy = this->FindCatalog(name, out_lba);
+
+	if (catalog_copy)
+	{
+		kcout << "Catalog already exists: " << name << ".\r";
+		ErrLocal() = kErrorFileExists;
+
+		return catalog_copy;
+	}
+
+	Char parentName[kNeFSNodeNameLen] = {0};
+
+	for (SizeT indexName = 0UL; indexName < rt_string_len(name); ++indexName)
+	{
+		parentName[indexName] = name[indexName];
+	}
+
+	if (*parentName == 0)
+	{
+		kcout << "Parent name is NUL.\r";
+		ErrLocal() = kErrorFileNotFound;
+		return nullptr;
+	}
+
+	/// Locate parent catalog, to then allocate right after it.
+
+	for (SizeT indexFill = 0; indexFill < rt_string_len(name); ++indexFill)
+	{
+		parentName[indexFill] = name[indexFill];
+	}
+
+	SizeT indexReverseCopy = rt_string_len(parentName);
+
+	// zero character it.
+	parentName[--indexReverseCopy] = 0;
+
+	// mandatory / character, zero it.
+	parentName[--indexReverseCopy] = 0;
+
+	while (parentName[indexReverseCopy] != NeFileSystemHelper::Separator())
+	{
+		parentName[indexReverseCopy] = 0;
+		--indexReverseCopy;
+	}
+
+	NFS_CATALOG_STRUCT* catalog = this->FindCatalog(parentName, out_lba);
+
+	auto drive = sMountpointInterface.A();
+
+	if (catalog && catalog->Kind == kNeFSCatalogKindFile)
+	{
+		kcout << "Parent name is file.\r";
+		delete catalog;
+		return nullptr;
+	}
+	else if (!catalog)
+	{
+		Char sectorBufPartBlock[kNeFSSectorSz] = {0};
+
+		drive.fPacket.fPacketContent = sectorBufPartBlock;
+		drive.fPacket.fPacketSize	 = kNeFSSectorSz;
+		drive.fPacket.fLba			 = kNeFSRootCatalogStartAddress;
+
+		drive.fInput(&drive.fPacket);
+
+		constexpr auto cNeFSCatalogPadding = 4;
+
+		NFS_ROOT_PARTITION_BLOCK* partBlock = (NFS_ROOT_PARTITION_BLOCK*)sectorBufPartBlock;
+		out_lba								= partBlock->StartCatalog;
+	}
+
+	constexpr SizeT cDefaultForkSize = kNeFSForkSize;
+
+	NFS_CATALOG_STRUCT* catalogChild = new NFS_CATALOG_STRUCT();
+
+	Int32 flagsList = flags;
+
+	catalogChild->ResourceForkSize = cDefaultForkSize;
+	catalogChild->DataForkSize	   = cDefaultForkSize;
+
+	catalogChild->NextSibling = out_lba;
+	catalogChild->PrevSibling = out_lba;
+	catalogChild->Kind		  = kind;
+	catalogChild->Flags		  = kNeFSFlagCreated | flagsList;
+
+	rt_copy_memory((VoidPtr)name, (VoidPtr)catalogChild->Name,
+				   rt_string_len(name));
+
+	UInt16 catalogBuf[kNeFSSectorSz] = {0};
+
+	Lba start_free = out_lba;
+
+	rt_copy_memory((VoidPtr) "fs/newfs-packet", drive.fPacket.fPacketMime,
+				   rt_string_len("fs/newfs-packet"));
+
+	drive.fPacket.fPacketContent = catalogBuf;
+	drive.fPacket.fPacketSize	 = kNeFSSectorSz;
+	drive.fPacket.fLba			 = start_free;
+
+	drive.fInput(&drive.fPacket);
+
+	NFS_CATALOG_STRUCT* nextSibling = (NFS_CATALOG_STRUCT*)catalogBuf;
+
+	start_free = nextSibling->NextSibling;
+
+	catalogChild->PrevSibling = out_lba;
+
+	drive.fPacket.fLba = start_free;
+	drive.fInput(&drive.fPacket);
+
+	while (drive.fPacket.fPacketGood)
+	{
+		nextSibling = reinterpret_cast<NFS_CATALOG_STRUCT*>(catalogBuf);
+
+		if (start_free <= kNeFSRootCatalogStartAddress)
+		{
+			delete catalogChild;
+			delete catalog;
+
+			return nullptr;
+		}
+
+		// ========================== //
+		// Allocate catalog now...
+		// ========================== //
+		if ((nextSibling->Flags & kNeFSFlagCreated) == 0)
+		{
+			Char sectorBufPartBlock[kNeFSSectorSz] = {0};
+
+			drive.fPacket.fPacketContent = sectorBufPartBlock;
+			drive.fPacket.fPacketSize	 = kNeFSSectorSz;
+			drive.fPacket.fLba			 = kNeFSRootCatalogStartAddress;
+
+			drive.fInput(&drive.fPacket);
+
+			constexpr auto cNeFSCatalogPadding = 4;
+
+			NFS_ROOT_PARTITION_BLOCK* partBlock = (NFS_ROOT_PARTITION_BLOCK*)sectorBufPartBlock;
+
+			if (partBlock->FreeCatalog < 1)
+			{
+				delete catalogChild;
+				return nullptr;
+			}
+
+			catalogChild->DataFork	   = partBlock->DiskSize - start_free;
+			catalogChild->ResourceFork = catalogChild->DataFork;
+
+			// Write the new catalog next sibling, if we don't know this parent. //
+			// This is necessary, so that we don't have to get another lba to allocate. //
+			if (!StringBuilder::Equals(parentName, nextSibling->Name))
+			{
+				catalogChild->NextSibling =
+					start_free + (sizeof(NFS_CATALOG_STRUCT) * cNeFSCatalogPadding);
+			}
+
+			drive.fPacket.fPacketContent = catalogChild;
+			drive.fPacket.fPacketSize	 = sizeof(NFS_CATALOG_STRUCT);
+			drive.fPacket.fLba			 = start_free;
+
+			drive.fOutput(&drive.fPacket);
+
+			// Get NeFS partition's block.
+
+			drive.fPacket.fPacketContent = sectorBufPartBlock;
+			drive.fPacket.fPacketSize	 = kNeFSSectorSz;
+			drive.fPacket.fLba			 = kNeFSRootCatalogStartAddress;
+
+			drive.fInput(&drive.fPacket);
+
+			partBlock->FreeSectors -= 1;
+			partBlock->CatalogCount += 1;
+			partBlock->FreeCatalog -= 1;
+
+			drive.fOutput(&drive.fPacket);
+
+			kcout << "Create new catalog, status: "
+				  << hex_number(catalogChild->Flags) << endl;
+			kcout << "Create new catalog, name: " << catalogChild->Name
+				  << endl;
+
+			delete catalog;
+			return catalogChild;
+		}
+		else if ((nextSibling->Flags & kNeFSFlagCreated) &&
+				 StringBuilder::Equals(nextSibling->Name, name))
+		{
+			return nextSibling;
+		}
+
+		constexpr auto cNeFSCatalogPadding = 4;
+
+		//// @note that's how we find the next catalog in the partition block.
+		start_free = start_free + (sizeof(NFS_CATALOG_STRUCT) * cNeFSCatalogPadding);
+
+		drive.fPacket.fPacketContent = catalogBuf;
+		drive.fPacket.fPacketSize	 = kNeFSSectorSz;
+		drive.fPacket.fLba			 = start_free;
+
+		drive.fInput(&drive.fPacket);
+	}
+
+	delete catalog;
+	return nullptr;
+}
+
+/// @brief Make a EPM+NeFS drive out of the disk.
+/// @param drive The drive to write on.
+/// @return If it was sucessful, see ErrLocal().
+bool NeFSParser::Format(_Input _Output DriveTrait* drive, _Input const Lba endLba, _Input const Int32 flags, const Char* part_name)
+{
+	if (*part_name == 0 ||
+		endLba == 0)
+		return false;
+
+	// verify disk.
+	drive->fVerify(&drive->fPacket);
+
+	rt_copy_memory((VoidPtr) "fs/newfs-packet", drive->fPacket.fPacketMime,
+				   rt_string_len("fs/newfs-packet"));
+
+	// if disk isn't good, then error out.
+	if (false == drive->fPacket.fPacketGood)
+	{
+		ErrLocal() = kErrorDiskIsCorrupted;
+		return false;
+	}
+
+	Char fs_buf[kNeFSSectorSz] = {0};
+
+	Lba start = kNeFSRootCatalogStartAddress;
+
+	drive->fPacket.fPacketContent = fs_buf;
+	drive->fPacket.fPacketSize	  = kNeFSSectorSz;
+	drive->fPacket.fLba			  = start;
+
+	drive->fInput(&drive->fPacket);
+
+	if (flags & kNeFSPartitionTypeBoot)
+	{
+		// make it bootable when needed.
+		Char bufEpmHdr[kNeFSSectorSz] = {0};
+
+		BOOT_BLOCK_STRUCT* epmBoot = (BOOT_BLOCK_STRUCT*)bufEpmHdr;
+
+		// EPM header.
+
+		constexpr auto cFsName	  = "NeFS";
+		constexpr auto cBlockName = "ZKA:";
+
+		rt_copy_memory(reinterpret_cast<VoidPtr>(const_cast<Char*>(cFsName)), epmBoot->Fs, rt_string_len(cFsName));
+
+		epmBoot->FsVersion = kNeFSVersionInteger;
+		epmBoot->LbaStart  = start;
+		epmBoot->SectorSz  = kNeFSSectorSz;
+
+		rt_copy_memory(reinterpret_cast<VoidPtr>(const_cast<Char*>(cBlockName)), epmBoot->Name, rt_string_len(cBlockName));
+		rt_copy_memory(reinterpret_cast<VoidPtr>(const_cast<Char*>(kEPMMagic)), epmBoot->Magic, rt_string_len(kEPMMagic));
+
+		Lba outEpmLba = kEpmBase;
+
+		Char buf[kNeFSSectorSz];
+
+		Lba	  prevStart = 0;
+		SizeT cnt		= 0;
+
+		while (drive->fPacket.fPacketGood)
+		{
+			drive->fPacket.fPacketContent = buf;
+			drive->fPacket.fPacketSize	  = kNeFSSectorSz;
+			drive->fPacket.fLba			  = outEpmLba;
+
+			drive->fInput(&drive->fPacket);
+
+			if (buf[0] == 0)
+			{
+				epmBoot->LbaStart = prevStart;
+
+				if (epmBoot->LbaStart)
+					epmBoot->LbaStart = outEpmLba;
+
+				epmBoot->LbaEnd	   = endLba;
+				epmBoot->NumBlocks = cnt;
+
+				drive->fPacket.fPacketContent = bufEpmHdr;
+				drive->fPacket.fPacketSize	  = kNeFSSectorSz;
+				drive->fPacket.fLba			  = outEpmLba;
+
+				drive->fOutput(&drive->fPacket);
+
+				break;
+			}
+			else
+			{
+				prevStart = ((BOOT_BLOCK_STRUCT*)buf)->LbaStart + ((BOOT_BLOCK_STRUCT*)buf)->LbaEnd;
+			}
+
+			outEpmLba += sizeof(BOOT_BLOCK_STRUCT);
+			++cnt;
+		}
+	}
+
+	// disk isnt faulty and data has been fetched.
+	while (drive->fPacket.fPacketGood)
+	{
+		NFS_ROOT_PARTITION_BLOCK* partBlock = (NFS_ROOT_PARTITION_BLOCK*)fs_buf;
+
+		// check for an empty partition here.
+		if (partBlock->PartitionName[0] == 0 &&
+			rt_string_cmp(partBlock->Ident, kNeFSIdent, kNeFSIdentLen))
+		{
+			// partition is free and valid.
+
+			partBlock->Version = kNeFSVersionInteger;
+
+			const auto cUntitledHD = part_name;
+
+			rt_copy_memory((VoidPtr)kNeFSIdent, (VoidPtr)partBlock->Ident,
+						   kNeFSIdentLen);
+
+			rt_copy_memory((VoidPtr)cUntitledHD, (VoidPtr)partBlock->PartitionName,
+						   rt_string_len(cUntitledHD));
+
+			SizeT catalogCount = 0UL;
+
+			SizeT sectorCount = drv_get_sector_count();
+			SizeT diskSize	  = drv_get_size();
+
+			partBlock->Kind			= kNeFSPartitionTypeStandard;
+			partBlock->StartCatalog = kNeFSCatalogStartAddress;
+			partBlock->Flags		= kNeFSPartitionTypeStandard;
+			partBlock->CatalogCount = sectorCount / sizeof(NFS_CATALOG_STRUCT);
+			partBlock->SectorCount	= sectorCount;
+			partBlock->DiskSize		= diskSize;
+			partBlock->FreeCatalog	= sectorCount / sizeof(NFS_CATALOG_STRUCT);
+
+			drive->fPacket.fPacketContent = fs_buf;
+			drive->fPacket.fPacketSize	  = kNeFSSectorSz;
+			drive->fPacket.fLba			  = kNeFSRootCatalogStartAddress;
+
+			drive->fOutput(&drive->fPacket);
+
+			kcout << "drive kind: " << drive->fDriveKind() << endl;
+
+			kcout << "partition name: " << partBlock->PartitionName << endl;
+			kcout << "start: " << hex_number(partBlock->StartCatalog) << endl;
+			kcout << "number of catalogs: " << hex_number(partBlock->CatalogCount) << endl;
+			kcout << "free catalog: " << hex_number(partBlock->FreeCatalog) << endl;
+			kcout << "free sectors: " << hex_number(partBlock->FreeSectors) << endl;
+			kcout << "sector size: " << hex_number(partBlock->SectorSize) << endl;
+
+			// write the root catalog.
+			this->CreateCatalog(kNeFSRoot, 0, kNeFSCatalogKindDir);
+
+			return true;
+		}
+
+		kcout << "partition block already exists.\r";
+
+		start += partBlock->DiskSize;
+
+		drive->fPacket.fPacketContent = fs_buf;
+		drive->fPacket.fPacketSize	  = kNeFSSectorSz;
+		drive->fPacket.fLba			  = start;
+
+		drive->fInput(&drive->fPacket);
+	}
+
+	return false;
+}
+
+/// @brief Writes the data fork into a specific catalog.
+/// @param catalog the catalog itself
+/// @param data the data.
+/// @return if the catalog w rote the contents successfully.
+bool NeFSParser::WriteCatalog(_Input _Output NFS_CATALOG_STRUCT* catalog, Bool is_rsrc_fork, _Input VoidPtr data, _Input SizeT size_of_data, _Input const Char* forkName)
+{
+	if (size_of_data > kNeFSForkDataSz ||
+		size_of_data == 0)
+		return No;
+
+	auto buf = new UInt8[kNeFSForkDataSz];
+	rt_set_memory(buf, 0, kNeFSForkDataSz);
+
+	rt_copy_memory(data, buf, size_of_data);
+
+	auto drive = sMountpointInterface.A();
+
+	rt_copy_memory((VoidPtr) "fs/newfs-packet", drive.fPacket.fPacketMime,
+				   rt_string_len("fs/newfs-packet"));
+
+	auto startFork = (!is_rsrc_fork) ? catalog->DataFork
+									 : catalog->ResourceFork;
+
+	NFS_FORK_STRUCT* fork_data_input = new NFS_FORK_STRUCT();
+	NFS_FORK_STRUCT	 prevFork{};
+
+	// sanity check of the fork position as the condition to run the loop.
+	while (startFork >= kNeFSCatalogStartAddress)
+	{
+		drive.fPacket.fPacketContent = fork_data_input;
+		drive.fPacket.fPacketSize	 = sizeof(NFS_FORK_STRUCT);
+		drive.fPacket.fLba			 = startFork;
+
+		drive.fInput(&drive.fPacket);
+
+		// check the fork, if it's position is valid.
+		if (fork_data_input->DataOffset <= kNeFSCatalogStartAddress)
+		{
+			ErrLocal() = kErrorDiskIsCorrupted;
+
+			kcout << "Invalid fork offset.\r";
+
+			return false;
+		}
+
+		if (fork_data_input->Flags != kNeFSFlagUnallocated &&
+			fork_data_input->Flags != kNeFSFlagDeleted &&
+			StringBuilder::Equals(fork_data_input->ForkName, forkName) &&
+			StringBuilder::Equals(fork_data_input->CatalogName, catalog->Name) &&
+			fork_data_input->DataSize == size_of_data)
+		{
+			// ===================================================== //
+			// Store the blob now.
+			// ===================================================== //
+
+			fork_data_input->Flags |= kNeFSFlagCreated;
+
+			drive.fPacket.fPacketContent = buf;
+			drive.fPacket.fPacketSize	 = kNeFSForkDataSz;
+			drive.fPacket.fLba			 = fork_data_input->DataOffset;
+
+			kcout << "data offset: " << hex_number(fork_data_input->DataOffset) << endl;
+
+			drive.fOutput(&drive.fPacket);
+
+			drive.fPacket.fPacketContent = fork_data_input;
+			drive.fPacket.fPacketSize	 = sizeof(NFS_FORK_STRUCT);
+			drive.fPacket.fLba			 = startFork - sizeof(NFS_FORK_STRUCT);
+
+			drive.fOutput(&drive.fPacket);
+
+			kcout << "wrote fork at offset: " << hex_number(fork_data_input->DataOffset) << endl;
+			kcout << "wrote fork at offset: " << hex_number(startFork - sizeof(NFS_FORK_STRUCT)) << endl;
+
+			delete catalog;
+
+			return true;
+		}
+
+		// stumble upon a fork, store it.
+
+		prevFork = *fork_data_input;
+
+		startFork = fork_data_input->NextSibling;
+	}
+
+	return false;
+}
+
+/// @brief
+/// @param catalogName the catalog name.
+/// @return the newly found catalog.
+_Output NFS_CATALOG_STRUCT* NeFSParser::FindCatalog(_Input const Char* catalogName,
+													Lba&			   out_lba)
+{
+	kcout << "Start finding catalog...\r";
+
+	NFS_ROOT_PARTITION_BLOCK fs_buf{0};
+	auto					 drive = sMountpointInterface.A();
+
+	rt_copy_memory((VoidPtr) "fs/newfs-packet", drive.fPacket.fPacketMime,
+				   rt_string_len("fs/newfs-packet"));
+
+	drive.fPacket.fPacketContent = &fs_buf;
+	drive.fPacket.fPacketSize	 = sizeof(NFS_ROOT_PARTITION_BLOCK);
+	drive.fPacket.fLba			 = kNeFSRootCatalogStartAddress;
+
+	drive.fInput(&drive.fPacket);
+
+	NFS_ROOT_PARTITION_BLOCK* part = (NFS_ROOT_PARTITION_BLOCK*)&fs_buf;
+
+	auto	   startCatalogList	 = part->StartCatalog;
+	const auto cCtartCatalogList = startCatalogList;
+
+	auto localSearchFirst = false;
+
+	NFS_CATALOG_STRUCT catalogBuf{0};
+
+	drive.fPacket.fLba			 = startCatalogList;
+	drive.fPacket.fPacketContent = &catalogBuf;
+	drive.fPacket.fPacketSize	 = sizeof(NFS_CATALOG_STRUCT);
+
+	drive.fInput(&drive.fPacket);
+
+	if (!StringBuilder::Equals(catalogName, NeFileSystemHelper::Root()))
+	{
+		Char parentName[kNeFSNodeNameLen] = {0};
+
+		for (SizeT indexFill = 0; indexFill < rt_string_len(catalogName); ++indexFill)
+		{
+			parentName[indexFill] = catalogName[indexFill];
+		}
+
+		SizeT indexReverseCopy = rt_string_len(parentName);
+
+		// zero character.
+		parentName[--indexReverseCopy] = 0;
+
+		// mandatory '/' character.
+		parentName[--indexReverseCopy] = 0;
+
+		while (parentName[indexReverseCopy] != NeFileSystemHelper::Separator())
+		{
+			parentName[indexReverseCopy] = 0;
+			--indexReverseCopy;
+		}
+
+		NFS_CATALOG_STRUCT* parentCatalog = this->FindCatalog(parentName, out_lba);
+
+		if (parentCatalog &&
+			!StringBuilder::Equals(parentName, NeFileSystemHelper::Root()))
+		{
+			startCatalogList = parentCatalog->NextSibling;
+			delete parentCatalog;
+
+			localSearchFirst = true;
+		}
+		else if (parentCatalog)
+		{
+			delete parentCatalog;
+		}
+		else
+		{
+			return nullptr;
+		}
+	}
+
+	kcout << "Fetching catalog...\r";
+
+NeFSSearchThroughCatalogList:
+	while (drive.fPacket.fPacketGood)
+	{
+		drive.fPacket.fLba			 = startCatalogList;
+		drive.fPacket.fPacketContent = &catalogBuf;
+		drive.fPacket.fPacketSize	 = sizeof(NFS_CATALOG_STRUCT);
+
+		drive.fInput(&drive.fPacket);
+
+		NFS_CATALOG_STRUCT* catalog = (NFS_CATALOG_STRUCT*)&catalogBuf;
+
+		if (StringBuilder::Equals(catalogName, catalog->Name))
+		{
+			/// ignore unallocated catalog, break
+			if (!(catalog->Flags & kNeFSFlagCreated))
+			{
+				goto NeFSContinueSearch;
+			}
+
+			NFS_CATALOG_STRUCT* catalogPtr = new NFS_CATALOG_STRUCT();
+			rt_copy_memory(catalog, catalogPtr, sizeof(NFS_CATALOG_STRUCT));
+
+			kcout << "Found catalog at: " << hex_number(startCatalogList) << endl;
+			kcout << "Found catalog at: " << catalog->Name << endl;
+
+			out_lba = startCatalogList;
+			return catalogPtr;
+		}
+
+	NeFSContinueSearch:
+		startCatalogList = catalog->NextSibling;
+
+		if (startCatalogList <= kNeFSRootCatalogStartAddress)
+			break;
+	}
+
+	if (localSearchFirst)
+	{
+		localSearchFirst = false;
+		startCatalogList = cCtartCatalogList;
+
+		goto NeFSSearchThroughCatalogList;
+	}
+
+	out_lba = 0UL;
+	return nullptr;
+}
+
+/// @brief Get catalog from filesystem.
+/// @param name the catalog's name/
+/// @return
+_Output NFS_CATALOG_STRUCT* NeFSParser::GetCatalog(_Input const Char* name)
+{
+	Lba unused = 0;
+	return this->FindCatalog(name, unused);
+}
+
+/// @brief Closes a catalog, (frees it).
+/// @param catalog the catalog to close.
+/// @return
+Boolean NeFSParser::CloseCatalog(_Input _Output NFS_CATALOG_STRUCT* catalog)
+{
+	if (!catalog)
+		return false;
+
+	delete catalog;
+	catalog = nullptr;
+
+	return true;
+}
+
+/// @brief Mark catalog as removed.
+/// @param catalog The catalog structure.
+/// @return if the catalog was removed or not.
+Boolean NeFSParser::RemoveCatalog(_Input const Char* catalogName)
+{
+	if (!catalogName ||
+		StringBuilder::Equals(catalogName, NeFileSystemHelper::Root()))
+	{
+		ErrLocal() = kErrorInternal;
+		return false;
+	}
+
+	Lba	 out_lba = 0;
+	auto catalog = this->FindCatalog(catalogName, out_lba);
+
+	if (out_lba >= kNeFSCatalogStartAddress ||
+		catalog->Flags & kNeFSFlagCreated)
+	{
+		catalog->Flags |= kNeFSFlagDeleted;
+
+		auto drive = sMountpointInterface.A();
+
+		rt_copy_memory((VoidPtr) "fs/newfs-packet", drive.fPacket.fPacketMime,
+					   rt_string_len("fs/newfs-packet"));
+
+		drive.fPacket.fLba = out_lba; // the catalog position.
+		drive.fPacket.fPacketSize =
+			sizeof(NFS_CATALOG_STRUCT);			// size of catalog. roughly the sector size.
+		drive.fPacket.fPacketContent = catalog; // the catalog itself.
+
+		drive.fOutput(&drive.fPacket); // send packet.
+
+		Char partitionBlockBuf[sizeof(NFS_ROOT_PARTITION_BLOCK)] = {0};
+
+		drive.fPacket.fLba			 = kNeFSRootCatalogStartAddress;
+		drive.fPacket.fPacketContent = partitionBlockBuf;
+		drive.fPacket.fPacketSize	 = sizeof(NFS_ROOT_PARTITION_BLOCK);
+
+		drive.fInput(&drive.fPacket);
+
+		NFS_ROOT_PARTITION_BLOCK* partBlock =
+			reinterpret_cast<NFS_ROOT_PARTITION_BLOCK*>(partitionBlockBuf);
+
+		--partBlock->CatalogCount;
+		++partBlock->FreeSectors;
+
+		drive.fOutput(&drive.fPacket);
+
+		return true;
+	}
+
+	delete catalog;
+	return false;
+}
+
+/// ***************************************************************** ///
+/// Reading,Seek,Tell are unimplemented on catalogs, refer to forks I/O instead.
+/// ***************************************************************** ///
+
+/***********************************************************************************/
+/// @brief Read the catalog data fork.
+/// @param catalog
+/// @param dataSz
+/// @return
+/***********************************************************************************/
+
+VoidPtr NeFSParser::ReadCatalog(_Input _Output NFS_CATALOG_STRUCT* catalog,
+								_Input Bool						   is_rsrc_fork,
+								_Input SizeT					   dataSz,
+								_Input const Char*				   forkName)
+{
+	if (!catalog)
+	{
+		ErrLocal() = kErrorFileNotFound;
+		return nullptr;
+	}
+
+	constexpr auto cNeFSCatalogPadding = 4;
+
+	Lba	 dataForkLba  = (!is_rsrc_fork) ? catalog->DataFork : catalog->ResourceFork;
+	Size dataForkSize = (!is_rsrc_fork) ? catalog->DataForkSize : catalog->ResourceForkSize;
+
+	kcout << "catalog " << catalog->Name
+		  << ", fork: " << hex_number(dataForkLba) << endl;
+
+	NFS_FORK_STRUCT* fs_buf = new NFS_FORK_STRUCT();
+	auto			 drive	= sMountpointInterface.A();
+
+	rt_copy_memory((VoidPtr) "fs/newfs-packet", drive.fPacket.fPacketMime,
+				   rt_string_len("fs/newfs-packet"));
+
+	NFS_FORK_STRUCT* fs_fork_data = nullptr;
+
+	while (dataForkLba > kNeFSCatalogStartAddress)
+	{
+		drive.fPacket.fLba			 = dataForkLba;
+		drive.fPacket.fPacketSize	 = sizeof(NFS_FORK_STRUCT);
+		drive.fPacket.fPacketContent = fs_buf;
+
+		drive.fInput(&drive.fPacket);
+
+		fs_fork_data = fs_buf;
+
+		kcout << "ForkName: " << fs_fork_data->ForkName << endl;
+		kcout << "CatalogName: " << fs_fork_data->CatalogName << endl;
+
+		if (StringBuilder::Equals(forkName, fs_fork_data->ForkName) &&
+			StringBuilder::Equals(catalog->Name, fs_fork_data->CatalogName))
+			break;
+
+		dataForkLba = fs_fork_data->NextSibling;
+	}
+
+	if (dataForkLba < kNeFSCatalogStartAddress)
+	{
+		delete fs_buf;
+		return nullptr;
+	}
+
+	return fs_fork_data;
+}
+
+/***********************************************************************************/
+/// @brief Seek in the data fork.
+/// @param catalog the catalog offset.
+/// @param off where to seek.
+/// @return if the seeking was successful.
+/***********************************************************************************/
+
+bool NeFSParser::Seek(_Input _Output NFS_CATALOG_STRUCT* catalog, SizeT off)
+{
+	if (!catalog)
+	{
+		ErrLocal() = kErrorFileNotFound;
+		return false;
+	}
+
+	ErrLocal() = kErrorUnimplemented;
+	return false;
+}
+
+/***********************************************************************************/
+/// @brief Tell where we are inside the data fork.
+/// @param catalog
+/// @return The position on the file.
+/***********************************************************************************/
+
+SizeT NeFSParser::Tell(_Input _Output NFS_CATALOG_STRUCT* catalog)
+{
+	if (!catalog)
+	{
+		ErrLocal() = kErrorFileNotFound;
+		return 0;
+	}
+
+	ErrLocal() = kErrorUnimplemented;
+	return 0;
+}
+
+namespace Kernel::Detail
+{
+	/***********************************************************************************/
+	/// @brief Construct NeFS drives.
+	/***********************************************************************************/
+	Boolean fs_init_newfs(Void) noexcept
+	{
+		kcout << "Creating drives...\r";
+
+		sMountpointInterface.A() = io_construct_main_drive();
+		sMountpointInterface.B() = io_construct_drive();
+		sMountpointInterface.C() = io_construct_drive();
+		sMountpointInterface.D() = io_construct_drive();
+
+		kcout << "Constructing A:\r";
+
+		sMountpointInterface.A().fInit(&sMountpointInterface.A().fPacket);
+
+		kcout << "Constructing A: [ OK ]\r";
+
+		return true;
+	}
+} // namespace Kernel::Detail
+
+#endif // ifdef __FSKIT_USE_NEFS__
diff --git a/dev/zka/src/FileMgr.cxx b/dev/zka/src/FileMgr.cxx
new file mode 100644
index 00000000..a7be26b8
--- /dev/null
+++ b/dev/zka/src/FileMgr.cxx
@@ -0,0 +1,190 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+------------------------------------------- */
+
+#include <KernelKit/FileMgr.hxx>
+#include <NewKit/Utils.hxx>
+
+/// BUGS: 0
+//! @brief File manager for Kernel.
+
+namespace Kernel
+{
+	STATIC IFilesystemMgr* kMounted = nullptr;
+
+	/// @brief FilesystemMgr getter.
+	/// @return The mounted filesystem.
+	_Output IFilesystemMgr* IFilesystemMgr::GetMounted()
+	{
+		return kMounted;
+	}
+
+	/// @brief Unmount filesystem.
+	/// @return The unmounted filesystem.
+	_Output IFilesystemMgr* IFilesystemMgr::Unmount()
+	{
+		if (kMounted)
+		{
+			auto mount = kMounted;
+			kMounted   = nullptr;
+
+			return mount;
+		}
+
+		return nullptr;
+	}
+
+	/// @brief Mount filesystem.
+	/// @param mount_ptr The filesystem to mount.
+	/// @return if it succeeded true, otherwise false.
+	bool IFilesystemMgr::Mount(_Input IFilesystemMgr* mount_ptr)
+	{
+		if (mount_ptr != nullptr)
+		{
+			kMounted = mount_ptr;
+			return true;
+		}
+
+		return false;
+	}
+
+#ifdef __FSKIT_USE_NEFS__
+	/// @brief Opens a new file.
+	/// @param path
+	/// @param r
+	/// @return
+	_Output NodePtr NeFileSystemMgr::Open(_Input const Char* path, _Input const Char* r)
+	{
+		if (!path || *path == 0)
+			return nullptr;
+
+		if (!r || *r == 0)
+			return nullptr;
+
+		auto catalog = fImpl->GetCatalog(path);
+
+		return node_cast(catalog);
+	}
+
+	/// @brief Writes to a catalog's fork.
+	/// @param node the node ptr.
+	/// @param data the data.
+	/// @param flags the size.
+	/// @return
+	Void NeFileSystemMgr::Write(_Input NodePtr node, _Input VoidPtr data, _Input Int32 flags, _Input SizeT size)
+	{
+		if (!node)
+			return;
+		if (!size)
+			return;
+
+		constexpr auto cDataForkName = kNeFSDataFork;
+		this->Write(cDataForkName, node, data, flags, size);
+	}
+
+	/// @brief Read from filesystem fork.
+	/// @param node the catalog node.
+	/// @param flags the flags with it.
+	/// @param sz the size to read.
+	/// @return
+	_Output VoidPtr NeFileSystemMgr::Read(_Input NodePtr node, _Input Int32 flags, _Input SizeT size)
+	{
+		if (!node)
+			return nullptr;
+		if (!size)
+			return nullptr;
+
+		constexpr auto cDataForkName = kNeFSDataFork;
+		return this->Read(cDataForkName, node, flags, size);
+	}
+
+	Void NeFileSystemMgr::Write(_Input const Char* name,
+								_Input NodePtr	   node,
+								_Input VoidPtr	   data,
+								_Input Int32	   flags,
+								_Input SizeT	   size)
+	{
+		if (!size ||
+			size > kNeFSForkSize)
+			return;
+
+		if (!data)
+			return;
+
+		ZKA_UNUSED(flags);
+
+		if ((reinterpret_cast<NFS_CATALOG_STRUCT*>(node))->Kind == kNeFSCatalogKindFile)
+			fImpl->WriteCatalog(reinterpret_cast<NFS_CATALOG_STRUCT*>(node), (flags & cFileFlagRsrc ? true : false), data, size,
+								name);
+	}
+
+	_Output VoidPtr NeFileSystemMgr::Read(_Input const Char* name,
+										  _Input NodePtr	 node,
+										  _Input Int32		 flags,
+										  _Input SizeT		 sz)
+	{
+		if (sz > kNeFSForkSize)
+			return nullptr;
+
+		if (!sz)
+			return nullptr;
+
+		ZKA_UNUSED(flags);
+
+		if ((reinterpret_cast<NFS_CATALOG_STRUCT*>(node))->Kind == kNeFSCatalogKindFile)
+			return fImpl->ReadCatalog(reinterpret_cast<NFS_CATALOG_STRUCT*>(node), (flags & cFileFlagRsrc ? true : false), sz,
+									  name);
+
+		return nullptr;
+	}
+
+	/// @brief Seek from Catalog.
+	/// @param node
+	/// @param off
+	/// @retval true always returns false, this is unimplemented.
+	/// @retval false always returns this, it is unimplemented.
+
+	_Output Bool NeFileSystemMgr::Seek(NodePtr node, SizeT off)
+	{
+		if (!node || off == 0)
+			return false;
+
+		return fImpl->Seek(reinterpret_cast<NFS_CATALOG_STRUCT*>(node), off);
+	}
+
+	/// @brief Tell where the catalog is.
+	/// @param node
+	/// @retval true always returns false, this is unimplemented.
+	/// @retval false always returns this, it is unimplemented.
+
+	_Output SizeT NeFileSystemMgr::Tell(NodePtr node)
+	{
+		if (!node)
+			return kNPos;
+
+		return fImpl->Tell(reinterpret_cast<NFS_CATALOG_STRUCT*>(node));
+	}
+
+	/// @brief Rewinds the catalog.
+	/// @param node
+	/// @retval true always returns false, this is unimplemented.
+	/// @retval false always returns this, it is unimplemented.
+
+	_Output Bool NeFileSystemMgr::Rewind(NodePtr node)
+	{
+		if (!node)
+			return false;
+
+		return this->Seek(node, 0);
+	}
+
+	/// @brief Returns the filesystem parser.
+	/// @return the Filesystem parser class.
+	_Output NeFSParser* NeFileSystemMgr::GetParser() noexcept
+	{
+		return fImpl;
+	}
+#endif // __FSKIT_USE_NEFS__
+} // namespace Kernel
diff --git a/dev/zka/src/Framebuffer.cxx b/dev/zka/src/Framebuffer.cxx
new file mode 100644
index 00000000..3794e458
--- /dev/null
+++ b/dev/zka/src/Framebuffer.cxx
@@ -0,0 +1,113 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+	File: Framebuffer.cxx
+	Purpose: Framebuffer object
+
+	Revision History:
+
+	01/02/24: Added file (amlel)
+	02/02/24: Add documentation (amlel)
+	07/07/07: Moved Framebuffer methods into Kernel::
+
+------------------------------------------- */
+
+#include <KernelKit/Framebuffer.hxx>
+#include <HintKit/CompilerHint.hxx>
+
+/**
+ * @brief Framebuffer object implementation.
+ *
+ */
+
+namespace Kernel
+{
+	Framebuffer::Framebuffer(_Input Ref<FramebufferContext*>& addr)
+		: fFrameBufferAddr(addr)
+	{
+	}
+
+	/**
+	 * @brief Get Pixel at **pos**
+	 *
+	 * @param pos position of pixel.
+	 * @return volatile*
+	 */
+	_Output volatile UIntPtr* Framebuffer::operator[](_Input const UIntPtr& pos)
+	{
+		return (UIntPtr*)(fFrameBufferAddr->fBase * pos);
+	}
+
+	/// @brief Boolean operator.
+	Framebuffer::operator bool()
+	{
+		return fFrameBufferAddr.Leak()->fBase != 0 &&
+			   fColour != FramebufferColorKind::INVALID &&
+			   fFrameBufferAddr.Leak()->fBase != kInvalidAddress;
+	}
+
+	/// @brief Set color kind of framebuffer.
+	/// @param colour
+	/// @return
+	_Output const FramebufferColorKind& Framebuffer::Color(
+		const FramebufferColorKind& colour)
+	{
+		if (fColour != FramebufferColorKind::INVALID &&
+			colour != FramebufferColorKind::INVALID)
+		{
+			fColour = colour;
+		}
+
+		return fColour;
+	}
+
+	/// @brief Leak framebuffer context.
+	/// @return The reference of the framebuffer context.
+	_Output Ref<FramebufferContext*>& Framebuffer::Leak()
+	{
+		return this->fFrameBufferAddr;
+	}
+
+	/// @brief Draws a rectangle.
+	/// @param width
+	/// @param height
+	/// @param x
+	/// @param y
+	/// @param color
+	/// @return
+	_Output Framebuffer& Framebuffer::DrawRect(SizeT width, SizeT height, SizeT x, SizeT y, UInt32 color)
+	{
+		for (Kernel::SizeT i = x; i < width + x; ++i)
+		{
+			for (Kernel::SizeT u = y; u < height + y; ++u)
+			{
+				*(((volatile Kernel::UInt32*)(fFrameBufferAddr.Leak()->fBase +
+											  4 * fFrameBufferAddr.Leak()->fBpp * i +
+											  4 * u))) = color;
+			}
+		}
+
+		return *this;
+	}
+
+	/// @brief Put a pixel on the screen.
+	/// @param x
+	/// @param y
+	/// @param color
+	/// @return
+	_Output Framebuffer& Framebuffer::PutPixel(SizeT x, SizeT y, UInt32 color)
+	{
+		*(((volatile Kernel::UInt32*)(fFrameBufferAddr.Leak()->fBase +
+									  4 * fFrameBufferAddr.Leak()->fBpp * x +
+									  4 * y))) = color;
+
+		return *this;
+	}
+
+	const UInt32 kRgbRed   = 0x000000FF;
+	const UInt32 kRgbGreen = 0x0000FF00;
+	const UInt32 kRgbBlue  = 0x00FF0000;
+	const UInt32 kRgbBlack = 0x00000000;
+	const UInt32 kRgbWhite = 0xFFFFFFFF;
+} // namespace Kernel
diff --git a/dev/zka/src/GUIDWizard.cxx b/dev/zka/src/GUIDWizard.cxx
new file mode 100644
index 00000000..aede3a19
--- /dev/null
+++ b/dev/zka/src/GUIDWizard.cxx
@@ -0,0 +1,72 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+	File: GUIDWizard.cxx
+	Purpose: GUID helper code
+
+	Revision History:
+
+------------------------------------------- */
+
+#include <CFKit/GUIDWizard.hxx>
+#include <NewKit/Ref.hxx>
+
+// begin of ascii 'readable' characters. (A, C, C, 1, 2)
+#define kAsciiBegin 47
+// @brief Size of UUID.
+#define kUUIDSize 37
+
+namespace Kernel::XRN::Version1
+{
+	auto cf_make_sequence(const ArrayList<UInt32>& uuidSeq) -> Ref<GUIDSequence*>
+	{
+		GUIDSequence* seq = new GUIDSequence();
+		MUST_PASS(seq);
+
+		Ref<GUIDSequence*> sequenceReference{seq, true};
+
+		sequenceReference->fMs1	   = uuidSeq[0];
+		sequenceReference->fMs2	   = uuidSeq[1];
+		sequenceReference->fMs3	   = uuidSeq[2];
+		sequenceReference->fMs4[0] = uuidSeq[3];
+		sequenceReference->fMs4[1] = uuidSeq[4];
+		sequenceReference->fMs4[2] = uuidSeq[5];
+		sequenceReference->fMs4[3] = uuidSeq[6];
+		sequenceReference->fMs4[4] = uuidSeq[7];
+		sequenceReference->fMs4[5] = uuidSeq[8];
+		sequenceReference->fMs4[6] = uuidSeq[9];
+		sequenceReference->fMs4[7] = uuidSeq[10];
+
+		return sequenceReference;
+	}
+
+	// @brief Tries to make a guid out of a string.
+	// This function is not complete for now
+	auto cf_try_guid_to_string(Ref<GUIDSequence*>& seq) -> ErrorOr<Ref<StringView>>
+	{
+		Char buf[kUUIDSize];
+
+		for (SizeT index = 0; index < 16; ++index)
+		{
+			buf[index] = seq->u8[index] + kAsciiBegin;
+		}
+
+		for (SizeT index = 16; index < 24; ++index)
+		{
+			buf[index] = seq->u16[index] + kAsciiBegin;
+		}
+
+		for (SizeT index = 24; index < 28; ++index)
+		{
+			buf[index] = seq->u32[index] + kAsciiBegin;
+		}
+
+		auto view = StringBuilder::Construct(buf);
+
+		if (view)
+			return ErrorOr<Ref<StringView>>{view.Leak()};
+
+		return ErrorOr<Ref<StringView>>{-1};
+	}
+} // namespace Kernel::XRN::Version1
diff --git a/dev/zka/src/GUIDWrapper.cxx b/dev/zka/src/GUIDWrapper.cxx
new file mode 100644
index 00000000..f87d792d
--- /dev/null
+++ b/dev/zka/src/GUIDWrapper.cxx
@@ -0,0 +1,11 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+------------------------------------------- */
+
+#include <CFKit/GUIDWrapper.hxx>
+
+namespace Kernel::XRN
+{
+}
diff --git a/dev/zka/src/HardwareThreadScheduler.cxx b/dev/zka/src/HardwareThreadScheduler.cxx
new file mode 100644
index 00000000..22a69b9b
--- /dev/null
+++ b/dev/zka/src/HardwareThreadScheduler.cxx
@@ -0,0 +1,195 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+------------------------------------------- */
+
+#include <ArchKit/ArchKit.hxx>
+#include <KernelKit/UserProcessScheduler.hxx>
+#include <KernelKit/HardwareThreadScheduler.hxx>
+#include <CFKit/Property.hxx>
+
+///! BUGS: 0
+
+///! @file MP.cxx
+///! @brief This file handles multi processing in the Kernel.
+///! @brief Multi processing is needed for multi-tasking operations.
+
+namespace Kernel
+{
+	HardwareThreadScheduler* cHardwareThreadScheduler = nullptr;
+
+	///! A HardwareThread class takes care of it's owned hardware thread.
+	///! It has a stack for it's core.
+
+	///! @brief C++ constructor.
+	HardwareThread::HardwareThread() = default;
+
+	///! @brief C++ destructor.
+	HardwareThread::~HardwareThread() = default;
+
+	//! @brief returns the id of the thread.
+	const ThreadID& HardwareThread::ID() noexcept
+	{
+		return fID;
+	}
+
+	//! @brief returns the kind of thread we have.
+	const ThreadKind& HardwareThread::Kind() noexcept
+	{
+		return fKind;
+	}
+
+	//! @brief is the thread busy?
+	Bool HardwareThread::IsBusy() noexcept
+	{
+		STATIC Int64 busy_timer = 0U;
+
+		if (busy_timer > this->fPTime)
+		{
+			busy_timer = 0U;
+			fBusy	   = No;
+		}
+
+		return fBusy;
+	}
+
+	/// @brief Get processor stack frame.
+
+	HAL::StackFramePtr HardwareThread::StackFrame() noexcept
+	{
+		MUST_PASS(fStack);
+		return fStack;
+	}
+
+	Void HardwareThread::Busy(const Bool busy) noexcept
+	{
+		fBusy = busy;
+	}
+
+	HardwareThread::operator bool()
+	{
+		return fStack;
+	}
+
+	/// @brief Wakeup the processor.
+
+	Void HardwareThread::Wake(const bool wakeup) noexcept
+	{
+		fWakeup = wakeup;
+
+		if (!fWakeup)
+			mp_hang_thread(fStack);
+		else
+			mp_wakeup_thread(fStack);
+	}
+
+	/// @note Those symbols are needed in order to switch and validate the stack.
+
+	EXTERN Bool	  hal_check_stack(HAL::StackFramePtr stackPtr);
+	EXTERN_C Bool mp_register_process(VoidPtr image, UInt8* stack_ptr, HAL::StackFramePtr frame_ptr);
+
+	/// @brief Switch to hardware thread.
+	/// @param stack the new hardware thread.
+	/// @retval true stack was changed, code is running.
+	/// @retval false stack is invalid, previous code is running.
+	Bool HardwareThread::Switch(VoidPtr image, UInt8* stack_ptr, HAL::StackFramePtr frame)
+	{
+		if (!frame ||
+			!image ||
+			!stack_ptr)
+			return No;
+
+		if (!this->IsWakeup())
+			return No;
+
+		if (this->IsBusy())
+			return No;
+
+		fStack = frame;
+
+		kcout << "Trying to register progress...\r";
+
+		Bool ret = mp_register_process(image, stack_ptr, fStack);
+
+		if (ret)
+			this->Busy(true);
+
+		return ret;
+	}
+
+	///! @brief Tells if processor is waked up.
+	bool HardwareThread::IsWakeup() noexcept
+	{
+		return fWakeup;
+	}
+
+	///! @brief Constructor and destructors.
+
+	///! @brief Default constructor.
+	HardwareThreadScheduler::HardwareThreadScheduler() = default;
+
+	///! @brief Default destructor.
+	HardwareThreadScheduler::~HardwareThreadScheduler() = default;
+
+	/// @brief Shared singleton function
+	HardwareThreadScheduler& HardwareThreadScheduler::The()
+	{
+		MUST_PASS(cHardwareThreadScheduler);
+		return *cHardwareThreadScheduler;
+	}
+
+	/// @brief Get Stack Frame of Core
+	HAL::StackFramePtr HardwareThreadScheduler::Leak() noexcept
+	{
+		return fThreadList[fCurrentThread].fStack;
+	}
+
+	/**
+	 * Get Hardware thread at index.
+	 * @param idx the index
+	 * @return the reference to the hardware thread.
+	 */
+	Ref<HardwareThread*> HardwareThreadScheduler::operator[](const SizeT& idx)
+	{
+		if (idx == 0)
+		{
+			if (fThreadList[idx].Kind() != kHartSystemReserved)
+			{
+				fThreadList[idx].fKind = kHartBoot;
+			}
+		}
+		else if (idx >= cMaxHWThreads)
+		{
+			static HardwareThread* fakeThread = nullptr;
+			return {fakeThread};
+		}
+
+		return &fThreadList[idx];
+	}
+
+	/**
+	 * Check if thread pool isn't empty.
+	 * @return
+	 */
+	HardwareThreadScheduler::operator bool() noexcept
+	{
+		return !fThreadList.Empty();
+	}
+
+	/**
+	 * Reverse operator bool
+	 * @return
+	 */
+	bool HardwareThreadScheduler::operator!() noexcept
+	{
+		return fThreadList.Empty();
+	}
+
+	/// @brief Returns the amount of core present.
+	/// @return the number of cores.
+	SizeT HardwareThreadScheduler::Count() noexcept
+	{
+		return fThreadList.Capacity();
+	}
+} // namespace Kernel
diff --git a/dev/zka/src/Heap.cxx b/dev/zka/src/Heap.cxx
new file mode 100644
index 00000000..a75eaeb1
--- /dev/null
+++ b/dev/zka/src/Heap.cxx
@@ -0,0 +1,268 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+------------------------------------------- */
+
+#include <KernelKit/DebugOutput.hxx>
+#include <KernelKit/LPC.hxx>
+#include <KernelKit/Heap.hxx>
+#include <NewKit/Crc32.hxx>
+#include <NewKit/PageMgr.hxx>
+#include <NewKit/Utils.hxx>
+
+//! @file KernelHeap.cxx
+//! @brief Kernel heap allocator.
+
+#define kKernelHeapMagic		   (0xD4D7D5)
+#define kKernelHeapHeaderPaddingSz (__BIGGEST_ALIGNMENT__)
+
+namespace Kernel
+{
+
+	/// @brief Contains data structures and algorithms for the heap.
+	namespace Detail
+	{
+		struct PACKED HEAP_INFORMATION_BLOCK;
+
+		/// @brief Kernel heap information block.
+		/// Located before the address bytes.
+		/// | HIB |  ADDRESS  |
+		struct PACKED HEAP_INFORMATION_BLOCK final
+		{
+			///! @brief 32-bit value which contains the magic number of the heap.
+			UInt32 fMagic;
+			///! @brief Boolean value which tells if the heap is allocated.
+			Boolean fPresent;
+			/// @brief Is this valued owned by the user?
+			Boolean fUser;
+			/// @brief Is this a page pointer?
+			Boolean fPage;
+			///! @brief 32-bit CRC checksum.
+			UInt32 fCRC32;
+			/// @brief 64-bit pointer size.
+			SizeT fHeapSize;
+			/// @brief 64-bit target pointer.
+			UIntPtr fHeapPtr;
+			/// @brief Padding bytes for header.
+			UInt8 fPadding[kKernelHeapHeaderPaddingSz];
+		};
+
+		/// @brief Check for heap address validity.
+		/// @param heap_ptr The address_ptr
+		/// @return Bool if the pointer is valid or not.
+		auto mm_check_heap_address(VoidPtr heap_ptr) -> Bool
+		{
+			if (!heap_ptr)
+				return false;
+
+			/// Add that check in case we're having an integer underflow. ///
+
+			auto base_heap = (IntPtr)(heap_ptr) - sizeof(Detail::HEAP_INFORMATION_BLOCK);
+
+			if (base_heap < 0)
+			{
+				return false;
+			}
+
+			return true;
+		}
+
+		typedef HEAP_INFORMATION_BLOCK* HEAP_INFORMATION_BLOCK_PTR;
+
+		Void mm_alloc_init_timeout(Void) noexcept
+		{
+			ZKA_UNUSED(0);
+		}
+
+		Void mm_alloc_fini_timeout(Void) noexcept
+		{
+			ZKA_UNUSED(0);
+		}
+	} // namespace Detail
+
+	Detail::HEAP_INFORMATION_BLOCK_PTR kLatestAllocation = nullptr;
+
+	/// @brief Declare a new size for ptr_heap.
+	/// @param ptr_heap the pointer.
+	/// @return Newly allocated heap header.
+	voidPtr mm_realloc_heap(voidPtr ptr_heap, SizeT new_sz)
+	{
+		if (Detail::mm_check_heap_address(ptr_heap) == No)
+			return nullptr;
+
+		if (!ptr_heap || new_sz < 1)
+			return nullptr;
+
+		kcout << "This function is not implemented in the kernel, please refrain from using that.\r";
+		ke_stop(RUNTIME_CHECK_PROCESS);
+
+		return nullptr;
+	}
+
+	/// @brief Allocate chunk of memory.
+	/// @param sz Size of pointer
+	/// @param rw Read Write bit.
+	/// @param user User enable bit.
+	/// @return The newly allocated pointer.
+	VoidPtr mm_new_heap(const SizeT sz, const bool rw, const bool user)
+	{
+		Detail::mm_alloc_init_timeout();
+
+		auto sz_fix = sz;
+
+		if (sz_fix == 0)
+			return nullptr;
+
+		sz_fix += sizeof(Detail::HEAP_INFORMATION_BLOCK);
+
+		PageMgr heap_mgr;
+		auto	wrapper = heap_mgr.Request(rw, user, No, sz_fix);
+
+		Detail::HEAP_INFORMATION_BLOCK_PTR heap_info_ptr =
+			reinterpret_cast<Detail::HEAP_INFORMATION_BLOCK_PTR>(
+				wrapper.VirtualAddress() + sizeof(Detail::HEAP_INFORMATION_BLOCK));
+
+		heap_info_ptr->fHeapSize = sz_fix;
+		heap_info_ptr->fMagic	 = kKernelHeapMagic;
+		heap_info_ptr->fCRC32	 = No; // dont fill it for now.
+		heap_info_ptr->fHeapPtr	 = reinterpret_cast<UIntPtr>(heap_info_ptr) + sizeof(Detail::HEAP_INFORMATION_BLOCK);
+		heap_info_ptr->fPage	 = No;
+		heap_info_ptr->fUser	 = user;
+		heap_info_ptr->fPresent	 = Yes;
+
+		rt_set_memory(heap_info_ptr->fPadding, 0, kKernelHeapHeaderPaddingSz);
+
+		auto result = reinterpret_cast<VoidPtr>(heap_info_ptr->fHeapPtr);
+
+		kLatestAllocation = heap_info_ptr;
+
+		Detail::mm_alloc_fini_timeout();
+
+		return result;
+	}
+
+	/// @brief Makes a page heap.
+	/// @param heap_ptr
+	/// @return
+	Int32 mm_make_ke_page(VoidPtr heap_ptr)
+	{
+		if (Detail::mm_check_heap_address(heap_ptr) == No)
+			return -kErrorHeapNotPresent;
+
+		Detail::mm_alloc_init_timeout();
+
+		Detail::HEAP_INFORMATION_BLOCK_PTR heap_blk =
+			reinterpret_cast<Detail::HEAP_INFORMATION_BLOCK_PTR>(
+				(UIntPtr)heap_ptr - sizeof(Detail::HEAP_INFORMATION_BLOCK));
+
+		if (!heap_ptr)
+			return -kErrorHeapNotPresent;
+
+		heap_blk->fPage = true;
+
+		Detail::mm_alloc_fini_timeout();
+
+		return kErrorSuccess;
+	}
+
+	/// @brief Declare pointer as free.
+	/// @param heap_ptr the pointer.
+	/// @return
+	Int32 mm_delete_heap(VoidPtr heap_ptr)
+	{
+		if (Detail::mm_check_heap_address(heap_ptr) == No)
+			return -kErrorHeapNotPresent;
+
+		Detail::mm_alloc_init_timeout();
+
+		Detail::HEAP_INFORMATION_BLOCK_PTR heap_blk =
+			reinterpret_cast<Detail::HEAP_INFORMATION_BLOCK_PTR>(
+				(UIntPtr)(heap_ptr) - sizeof(Detail::HEAP_INFORMATION_BLOCK));
+
+		if (heap_blk && heap_blk->fMagic == kKernelHeapMagic)
+		{
+			if (!heap_blk->fPresent)
+			{
+				Detail::mm_alloc_fini_timeout();
+				return -kErrorHeapNotPresent;
+			}
+
+			if (heap_blk->fCRC32 != 0)
+			{
+				if (heap_blk->fCRC32 !=
+					ke_calculate_crc32((Char*)heap_blk->fHeapPtr,
+									   heap_blk->fHeapSize))
+				{
+					if (!heap_blk->fUser)
+					{
+						ke_stop(RUNTIME_CHECK_POINTER);
+					}
+				}
+			}
+
+			heap_blk->fHeapSize = 0UL;
+			heap_blk->fPresent	= No;
+			heap_blk->fHeapPtr	= 0;
+			heap_blk->fCRC32	= 0;
+			heap_blk->fMagic	= 0;
+
+			PTEWrapper		pageWrapper(false, false, false, reinterpret_cast<UIntPtr>(heap_blk) - sizeof(Detail::HEAP_INFORMATION_BLOCK));
+			Ref<PTEWrapper> pteAddress{pageWrapper};
+
+			kcout << "Freeing pointer address: " << hex_number(reinterpret_cast<UIntPtr>(heap_blk) - sizeof(Detail::HEAP_INFORMATION_BLOCK)) << endl;
+
+			PageMgr heap_mgr;
+			heap_mgr.Free(pteAddress);
+
+			Detail::mm_alloc_fini_timeout();
+
+			return kErrorSuccess;
+		}
+
+		return -kErrorInternal;
+	}
+
+	/// @brief Check if pointer is a valid Kernel pointer.
+	/// @param heap_ptr the pointer
+	/// @return if it exists.
+	Boolean mm_is_valid_heap(VoidPtr heap_ptr)
+	{
+		if (heap_ptr)
+		{
+			Detail::HEAP_INFORMATION_BLOCK_PTR heap_blk =
+				reinterpret_cast<Detail::HEAP_INFORMATION_BLOCK_PTR>(
+					(UIntPtr)(heap_ptr) - sizeof(Detail::HEAP_INFORMATION_BLOCK));
+
+			if (heap_blk && heap_blk->fPresent && heap_blk->fMagic == kKernelHeapMagic)
+			{
+				return Yes;
+			}
+		}
+
+		return No;
+	}
+
+	/// @brief Protect the heap with a CRC value.
+	/// @param heap_ptr HIB pointer.
+	/// @return if it valid: point has crc now., otherwise fail.
+	Boolean mm_protect_heap(VoidPtr heap_ptr)
+	{
+		if (heap_ptr)
+		{
+			Detail::HEAP_INFORMATION_BLOCK_PTR heap_blk =
+				reinterpret_cast<Detail::HEAP_INFORMATION_BLOCK_PTR>(
+					(UIntPtr)(heap_ptr) - sizeof(Detail::HEAP_INFORMATION_BLOCK));
+
+			if (heap_ptr && heap_blk->fPresent && kKernelHeapMagic == heap_blk->fMagic)
+			{
+				heap_blk->fCRC32 =
+					ke_calculate_crc32((Char*)heap_blk->fHeapPtr, heap_blk->fHeapSize);
+
+				return Yes;
+			}
+		}
+
+		return No;
+	}
+} // namespace Kernel
diff --git a/dev/zka/src/IDLLObject.cxx b/dev/zka/src/IDLLObject.cxx
new file mode 100644
index 00000000..b6b6a348
--- /dev/null
+++ b/dev/zka/src/IDLLObject.cxx
@@ -0,0 +1,15 @@
+/*
+ * ========================================================
+ *
+ * newoskrnl
+ * Copyright ZKA Technologies., all rights reserved.
+ *
+ *  ========================================================
+ */
+
+#include <KernelKit/IDLLObject.hxx>
+#include <KernelKit/DebugOutput.hxx>
+
+#include <KernelKit/UserProcessScheduler.hxx>
+
+using namespace Kernel;
diff --git a/dev/zka/src/IPEFDLLObject.cxx b/dev/zka/src/IPEFDLLObject.cxx
new file mode 100644
index 00000000..a8505eb3
--- /dev/null
+++ b/dev/zka/src/IPEFDLLObject.cxx
@@ -0,0 +1,100 @@
+/*
+ * ========================================================
+ *
+ * newoskrnl
+ * Copyright ZKA Technologies., all rights reserved.
+ *
+ *  ========================================================
+ */
+
+#include <KernelKit/DebugOutput.hxx>
+#include <KernelKit/PEF.hxx>
+#include <KernelKit/IPEFDLLObject.hxx>
+#include <KernelKit/UserProcessScheduler.hxx>
+#include <KernelKit/ThreadLocalStorage.hxx>
+#include <NewKit/Defines.hxx>
+
+/* -------------------------------------------
+
+ Revision History:
+
+	 01/02/24: Rework shared sharedObj ABI, except a rtl_init_dll and
+ rtl_fini_dll (amlel) 15/02/24: Breaking changes, changed the name of the
+ routines. (amlel)
+
+	07/28/24: Replace rt_library_free with rtl_fini_dll
+
+ ------------------------------------------- */
+
+using namespace Kernel;
+
+/***********************************************************************************/
+/// @file PEFSharedObjectRT.cxx
+/// @brief PEF's shared object runtime.
+/***********************************************************************************/
+
+/***********************************************************************************/
+/** @brief Library initializer. */
+/***********************************************************************************/
+
+EXTERN_C IDLL rtl_init_dll(UserProcess* header)
+{
+	IDLL sharedObj = tls_new_class<IPEFDLLObject>();
+
+	if (!sharedObj)
+	{
+		header->Crash();
+
+		return nullptr;
+	}
+
+	sharedObj->Mount(tls_new_class<IPEFDLLObject::DLL_TRAITS>());
+
+	if (!sharedObj->Get())
+	{
+		header->Crash();
+
+		return nullptr;
+	}
+
+	sharedObj->Get()->fImageObject =
+		header->Image;
+
+	if (!sharedObj->Get()->fImageObject)
+	{
+		header->Crash();
+
+		return nullptr;
+	}
+
+	sharedObj->Get()->fImageEntrypointOffset =
+		sharedObj->Load<VoidPtr>(kPefStart, rt_string_len(kPefStart, 0), kPefCode);
+
+	return sharedObj;
+}
+
+/***********************************************************************************/
+/** @brief Frees the sharedObj. */
+/** @note Please check if the lib got freed! */
+/** @param lib The sharedObj to free. */
+/** @param successful Reports if successful or not. */
+/***********************************************************************************/
+
+EXTERN_C Void rtl_fini_dll(UserProcess* header, IDLL lib, Bool* successful)
+{
+	MUST_PASS(successful);
+
+	// sanity check (will also trigger a bug check if this fails)
+	if (lib == nullptr)
+	{
+		*successful = false;
+		header->Crash();
+	}
+
+	delete lib->Get();
+	delete lib;
+
+	lib = nullptr;
+
+	*successful = true;
+}
diff --git a/dev/zka/src/IndexableProperty.cxx b/dev/zka/src/IndexableProperty.cxx
new file mode 100644
index 00000000..a5f1bc0b
--- /dev/null
+++ b/dev/zka/src/IndexableProperty.cxx
@@ -0,0 +1,59 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+------------------------------------------- */
+
+//! @brief Filesystem Indexer.
+
+#include <CompilerKit/CompilerKit.hxx>
+#include <FSKit/IndexableProperty.hxx>
+#include <NewKit/MutableArray.hxx>
+#include <NewKit/Utils.hxx>
+
+/// @brief File Indexer.
+/// BUGS: 0
+
+#define kMaxLenIndexer 256
+
+namespace Kernel
+{
+	namespace Indexer
+	{
+		IndexProperty& IndexableProperty::Leak() noexcept
+		{
+			return fIndex;
+		}
+
+		Void IndexableProperty::AddFlag(Int16 flag)
+		{
+			fFlags |= flag;
+		}
+
+		Void IndexableProperty::RemoveFlag(Int16 flag)
+		{
+			fFlags &= flag;
+		}
+
+		Int16 IndexableProperty::HasFlag(Int16 flag)
+		{
+			return fFlags & flag;
+		}
+
+		/// @brief Index a file into the indexer instance.
+		/// @param filename path
+		/// @param filenameLen used bytes in path.
+		/// @param indexer the filesystem indexer.
+		/// @return none.
+		Void fs_index_file(const Char* filename, SizeT filenameLen, IndexableProperty& indexer)
+		{
+			if (!indexer.HasFlag(kIndexerClaimed))
+			{
+				indexer.AddFlag(kIndexerClaimed);
+				rt_copy_memory((VoidPtr)indexer.Leak().Path, (VoidPtr)filename, filenameLen);
+
+				kcout << "filesystem: index new file: " << filename << endl;
+			}
+		}
+	} // namespace Indexer
+} // namespace Kernel
diff --git a/dev/zka/src/Json.cxx b/dev/zka/src/Json.cxx
new file mode 100644
index 00000000..df0d0ef8
--- /dev/null
+++ b/dev/zka/src/Json.cxx
@@ -0,0 +1,12 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+------------------------------------------- */
+
+#include <NewKit/Json.hxx>
+
+using namespace Kernel;
+
+/// @brief Undefined object, is null in length.
+cInitObject(Kernel::JsonType::kNull, Kernel::JsonType);
diff --git a/dev/zka/src/KernelCheck.cxx b/dev/zka/src/KernelCheck.cxx
new file mode 100644
index 00000000..4c316c0b
--- /dev/null
+++ b/dev/zka/src/KernelCheck.cxx
@@ -0,0 +1,155 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+------------------------------------------- */
+
+#include <ArchKit/ArchKit.hxx>
+#include <KernelKit/Timer.hxx>
+#include <KernelKit/DebugOutput.hxx>
+#include <NewKit/KernelCheck.hxx>
+#include <NewKit/String.hxx>
+#include <FirmwareKit/Handover.hxx>
+#include <Modules/ACPI/ACPIFactoryInterface.hxx>
+#include <KernelKit/FileMgr.hxx>
+#include <Modules/CoreCG/Accessibility.hxx>
+#include <Modules/CoreCG/FbRenderer.hxx>
+#include <Modules/CoreCG/TextRenderer.hxx>
+#include <Modules/CoreCG/WindowRenderer.hxx>
+
+#define SetMem(dst, byte, sz) Kernel::rt_set_memory((Kernel::VoidPtr)dst, byte, sz)
+#define CopyMem(dst, src, sz) Kernel::rt_copy_memory((Kernel::VoidPtr)src, (Kernel::VoidPtr)dst, sz)
+#define MoveMem(dst, src, sz) Kernel::rt_copy_memory((Kernel::VoidPtr)src, (Kernel::VoidPtr)dst, sz)
+
+#define cWebsiteMacro "https://help.el-mahrouss-logic.com/"
+
+/* Each error code is attributed with an ID, which will prompt a string onto the
+ * screen. Wait for debugger... */
+
+namespace Kernel
+{
+	void ke_stop(const Kernel::Int& id)
+	{
+		CGInit();
+
+		auto panicTxt = RGB(0xff, 0xff, 0xff);
+
+		CG::CGDrawBackground();
+
+		auto start_y = 10;
+		auto x		 = 10;
+
+		CGDrawString("newoskrnl.exe Stopped working properly so it had to stop.", start_y, x, panicTxt);
+		start_y += 10;
+
+		// simply offset from previous string and then write the website.
+		CGDrawString("Please visit: ", start_y, x, panicTxt);
+		CGDrawString(cWebsiteMacro, start_y, x + (FONT_SIZE_X * rt_string_len("Please visit: ")), panicTxt);
+
+		CGFini();
+
+		start_y += 10;
+
+		// show text according to error id.
+
+		switch (id)
+		{
+		case RUNTIME_CHECK_PROCESS: {
+			CGDrawString("0x00000008 No more processes to run, this is because that ZKA ran out of processes.", start_y, x, panicTxt);
+			RecoveryFactory::Recover();
+			break;
+		}
+		case RUNTIME_CHECK_ACPI: {
+			CGDrawString("0x00000006 ACPI configuration error.", start_y, x, panicTxt);
+			RecoveryFactory::Recover();
+			break;
+		}
+		case RUNTIME_CHECK_PAGE: {
+			CGDrawString("0x0000000B Write/Read in non paged area.", start_y, x, panicTxt);
+			RecoveryFactory::Recover();
+		}
+		case RUNTIME_CHECK_FILESYSTEM: {
+			CGDrawString("0x0000000A Filesystem error.", start_y, x, panicTxt);
+
+			PowerFactoryInterface power(nullptr);
+			power.Shutdown();
+			break;
+		}
+		case RUNTIME_CHECK_POINTER: {
+			CGDrawString("0x00000000 Heap error, the heap is corrupted.", start_y, x, panicTxt);
+
+			PowerFactoryInterface power(nullptr);
+			power.Shutdown();
+			break;
+		}
+		case RUNTIME_CHECK_BAD_BEHAVIOR: {
+			CGDrawString("0x00000009 CPU access error.", start_y, x, panicTxt);
+
+			PowerFactoryInterface power(nullptr);
+			power.Shutdown();
+			break;
+		}
+		case RUNTIME_CHECK_BOOTSTRAP: {
+			CGDrawString("0x0000000A Boot Processor finished executing.", start_y, x, panicTxt);
+
+			PowerFactoryInterface power(nullptr);
+			power.Shutdown();
+			break;
+		}
+		case RUNTIME_CHECK_HANDSHAKE: {
+			CGDrawString("0x00000005 Handshake fault.", start_y, x, panicTxt);
+			RecoveryFactory::Recover();
+			break;
+		}
+		case RUNTIME_CHECK_IPC: {
+			CGDrawString("0x00000003 Bad IPC/XPCOM message.", start_y, x, panicTxt);
+			RecoveryFactory::Recover();
+			break;
+		}
+		case RUNTIME_CHECK_INVALID_PRIVILEGE: {
+			CGDrawString("0x00000007 Privilege access violation.", start_y, x, panicTxt);
+			RecoveryFactory::Recover();
+			break;
+		case RUNTIME_CHECK_UNEXCPECTED: {
+			CGDrawString("0x0000000B Kernel access violation.", start_y, x, panicTxt);
+			break;
+		}
+		case RUNTIME_CHECK_VIRTUAL_OUT_OF_MEM: {
+			CGDrawString("0x10000001 Out of virtual memory.", start_y, x, panicTxt);
+			RecoveryFactory::Recover();
+			break;
+		}
+		case RUNTIME_CHECK_FAILED: {
+			CGDrawString("0x10000001 Kernel Bug check failed.", start_y, x, panicTxt);
+			RecoveryFactory::Recover();
+			break;
+		}
+		default: {
+			RecoveryFactory::Recover();
+			CGDrawString("0xFFFFFFFC Unknown Kernel error.", start_y, x, panicTxt);
+			break;
+		}
+		}
+		};
+
+		PowerFactoryInterface power(nullptr);
+		power.Reboot();
+	}
+
+	Void RecoveryFactory::Recover() noexcept
+	{
+		PowerFactoryInterface power(nullptr);
+		power.Reboot();
+	}
+
+	void ke_runtime_check(bool expr, const Char* file, const Char* line)
+	{
+		if (!expr)
+		{
+			kcout << "FAILED: FILE: " << file << endl;
+			kcout << "FAILED: LINE: " << line << endl;
+
+			ke_stop(RUNTIME_CHECK_FAILED); // Runtime Check failed
+		}
+	}
+} // namespace Kernel
diff --git a/dev/zka/src/LPC.cxx b/dev/zka/src/LPC.cxx
new file mode 100644
index 00000000..46f621bb
--- /dev/null
+++ b/dev/zka/src/LPC.cxx
@@ -0,0 +1,34 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+------------------------------------------- */
+
+#include <KernelKit/LPC.hxx>
+#include <NewKit/KernelCheck.hxx>
+
+namespace Kernel
+{
+	STATIC Bool cRaise = false;
+
+	/// @brief Does a system wide bug check.
+	/// @param void no params.
+	/// @return if error-free: false, otherwise true.
+	Boolean err_bug_check(void) noexcept
+	{
+		if (cRaise)
+		{
+			ke_stop(RUNTIME_CHECK_BAD_BEHAVIOR);
+		}
+
+		return false;
+	}
+
+	/// @brief Tells if we should raise a bug check not.
+	/// @param  void
+	/// @return void
+	Void err_bug_check_raise(Void) noexcept
+	{
+		cRaise = true;
+	}
+} // namespace Kernel
diff --git a/dev/zka/src/LockDelegate.cxx b/dev/zka/src/LockDelegate.cxx
new file mode 100644
index 00000000..f23c46d3
--- /dev/null
+++ b/dev/zka/src/LockDelegate.cxx
@@ -0,0 +1,12 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+------------------------------------------- */
+
+#include <KernelKit/LockDelegate.hxx>
+
+namespace Kernel
+{
+	/// Leave it empty for now.
+} // namespace Kernel
\ No newline at end of file
diff --git a/dev/zka/src/MutableArray.cxx b/dev/zka/src/MutableArray.cxx
new file mode 100644
index 00000000..766cb304
--- /dev/null
+++ b/dev/zka/src/MutableArray.cxx
@@ -0,0 +1,7 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+------------------------------------------- */
+
+#include <NewKit/MutableArray.hxx>
diff --git a/dev/zka/src/NeFS+FileMgr.cxx b/dev/zka/src/NeFS+FileMgr.cxx
new file mode 100644
index 00000000..fa14aaae
--- /dev/null
+++ b/dev/zka/src/NeFS+FileMgr.cxx
@@ -0,0 +1,110 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+------------------------------------------- */
+
+#include <KernelKit/FileMgr.hxx>
+#include <KernelKit/Heap.hxx>
+
+#ifdef __FSKIT_USE_NEFS__
+
+/// @brief NeFS File manager.
+/// BUGS: 0
+
+namespace Kernel
+{
+	/// @brief C++ constructor
+	NeFileSystemMgr::NeFileSystemMgr()
+	{
+		MUST_PASS(Detail::fs_init_newfs());
+		fImpl = mm_new_class<NeFSParser>();
+		MUST_PASS(fImpl);
+
+		kcout << "We are done here... (NeFileSystemMgr).\r";
+	}
+
+	NeFileSystemMgr::~NeFileSystemMgr()
+	{
+		if (fImpl)
+		{
+			kcout << "Destroying FS class (NeFS)...\r";
+
+			delete fImpl;
+			fImpl = nullptr;
+		}
+	}
+
+	/// @brief Removes a node from the filesystem.
+	/// @param fileName The filename
+	/// @return If it was deleted or not.
+	bool NeFileSystemMgr::Remove(const Char* fileName)
+	{
+		if (fileName == nullptr || *fileName == 0)
+			return false;
+
+		return fImpl->RemoveCatalog(fileName);
+	}
+
+	/// @brief Creates a node with the specified.
+	/// @param path The filename path.
+	/// @return The Node pointer.
+	NodePtr NeFileSystemMgr::Create(const Char* path)
+	{
+		return node_cast(fImpl->CreateCatalog(path));
+	}
+
+	/// @brief Creates a node with is a directory.
+	/// @param path The filename path.
+	/// @return The Node pointer.
+	NodePtr NeFileSystemMgr::CreateDirectory(const Char* path)
+	{
+		return node_cast(fImpl->CreateCatalog(path, 0, kNeFSCatalogKindDir));
+	}
+
+	/// @brief Creates a node with is a alias.
+	/// @param path The filename path.
+	/// @return The Node pointer.
+	NodePtr NeFileSystemMgr::CreateAlias(const Char* path)
+	{
+		return node_cast(fImpl->CreateCatalog(path, 0, kNeFSCatalogKindAlias));
+	}
+
+	/// @brief Creates a node with is a page file.
+	/// @param path The filename path.
+	/// @return The Node pointer.
+	NodePtr NeFileSystemMgr::CreateSwapFile(const Char* path)
+	{
+		return node_cast(fImpl->CreateCatalog(path, 0, kNeFSCatalogKindPage));
+	}
+
+	/// @brief Gets the root directory.
+	/// @return
+	const Char* NeFileSystemHelper::Root()
+	{
+		return kNeFSRoot;
+	}
+
+	/// @brief Gets the up-dir directory.
+	/// @return
+	const Char* NeFileSystemHelper::UpDir()
+	{
+		return kNeFSUpDir;
+	}
+
+	/// @brief Gets the separator character.
+	/// @return
+	const Char NeFileSystemHelper::Separator()
+	{
+		return kNeFSSeparator;
+	}
+
+	/// @brief Gets the metafile character.
+	/// @return
+	const Char NeFileSystemHelper::MetaFile()
+	{
+		return kNeFSMetaFilePrefix;
+	}
+} // namespace Kernel
+
+#endif // ifdef __FSKIT_USE_NEFS__
diff --git a/dev/zka/src/NeFS+IO.cxx b/dev/zka/src/NeFS+IO.cxx
new file mode 100644
index 00000000..6c3aa6e1
--- /dev/null
+++ b/dev/zka/src/NeFS+IO.cxx
@@ -0,0 +1,101 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+------------------------------------------- */
+
+#include <KernelKit/DriveMgr.hxx>
+#include <KernelKit/FileMgr.hxx>
+
+/*************************************************************
+ *
+ * File: NeFS+IO.cxx
+ * Purpose: Filesystem to mountpoint interface.
+ * Date: 3/26/24
+ *
+ * Copyright ZKA Technologies., all rights reserved.
+ *
+ *************************************************************/
+
+#ifdef __FSKIT_USE_NEFS__
+
+#include <FirmwareKit/EPM.hxx>
+
+/// Useful macros.
+
+#define NEFS_WRITE(DRV, TRAITS, MP) (MP->DRV()).fOutput(&TRAITS)
+#define NEFS_READ(DRV, TRAITS, MP)	(MP->DRV()).fInput(&TRAITS)
+
+using namespace Kernel;
+
+/// @brief Read from newfs disk.
+/// @param Mnt mounted interface.
+/// @param DrvTrait drive info
+/// @param DrvIndex drive index.
+/// @return
+Int32 fs_newfs_read(MountpointInterface* Mnt, DriveTrait& DrvTrait, Int32 DrvIndex)
+{
+	if (!Mnt)
+		return -1;
+
+	DrvTrait.fPacket.fPacketGood = false;
+
+	switch (DrvIndex)
+	{
+	case kNeFSSubDriveA: {
+		NEFS_READ(A, DrvTrait.fPacket, Mnt);
+		break;
+	}
+	case kNeFSSubDriveB: {
+		NEFS_READ(B, DrvTrait.fPacket, Mnt);
+		break;
+	}
+	case kNeFSSubDriveC: {
+		NEFS_READ(C, DrvTrait.fPacket, Mnt);
+		break;
+	}
+	case kNeFSSubDriveD: {
+		NEFS_READ(D, DrvTrait.fPacket, Mnt);
+		break;
+	}
+	}
+
+	return DrvTrait.fPacket.fPacketGood;
+}
+
+/// @brief Write to newfs disk.
+/// @param Mnt mounted interface.
+/// @param DrvTrait drive info
+/// @param DrvIndex drive index.
+/// @return
+Int32 fs_newfs_write(MountpointInterface* Mnt, DriveTrait& DrvTrait, Int32 DrvIndex)
+{
+	if (!Mnt)
+		return -1;
+
+	DrvTrait.fPacket.fPacketGood = false;
+
+	switch (DrvIndex)
+	{
+	case kNeFSSubDriveA: {
+		NEFS_WRITE(A, DrvTrait.fPacket, Mnt);
+		break;
+	}
+	case kNeFSSubDriveB: {
+		NEFS_WRITE(B, DrvTrait.fPacket, Mnt);
+		break;
+	}
+	case kNeFSSubDriveC: {
+		NEFS_WRITE(C, DrvTrait.fPacket, Mnt);
+		break;
+	}
+	case kNeFSSubDriveD: {
+		NEFS_WRITE(D, DrvTrait.fPacket, Mnt);
+		break;
+	}
+	}
+
+	return DrvTrait.fPacket.fPacketGood;
+}
+
+#endif // ifdef __FSKIT_USE_NEFS__
diff --git a/dev/zka/src/Network/IP.cxx b/dev/zka/src/Network/IP.cxx
new file mode 100644
index 00000000..77571bc7
--- /dev/null
+++ b/dev/zka/src/Network/IP.cxx
@@ -0,0 +1,126 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+------------------------------------------- */
+
+#include <NetworkKit/IP.hxx>
+#include <NewKit/Utils.hxx>
+
+namespace Kernel
+{
+	char* RawIPAddress::Address()
+	{
+		return fAddr;
+	}
+
+	RawIPAddress::RawIPAddress(char bytes[4])
+	{
+		rt_copy_memory(bytes, fAddr, 4);
+	}
+
+	bool RawIPAddress::operator==(const RawIPAddress& ipv4)
+	{
+		for (Size index = 0; index < 4; ++index)
+		{
+			if (ipv4.fAddr[index] != fAddr[index])
+				return false;
+		}
+
+		return true;
+	}
+
+	bool RawIPAddress::operator!=(const RawIPAddress& ipv4)
+	{
+		for (Size index = 0; index < 4; ++index)
+		{
+			if (ipv4.fAddr[index] == fAddr[index])
+				return false;
+		}
+
+		return true;
+	}
+
+	char& RawIPAddress::operator[](const Size& index)
+	{
+		kcout << "[RawIPAddress::operator[]] Fetching Index...\r";
+
+		static char IP_PLACEHOLDER = '0';
+		if (index > 4)
+			return IP_PLACEHOLDER;
+
+		return fAddr[index];
+	}
+
+	RawIPAddress6::RawIPAddress6(char bytes[8])
+	{
+		rt_copy_memory(bytes, fAddr, 8);
+	}
+
+	char& RawIPAddress6::operator[](const Size& index)
+	{
+		kcout << "[RawIPAddress6::operator[]] Fetching Index...\r";
+
+		static char IP_PLACEHOLDER = '0';
+		if (index > 8)
+			return IP_PLACEHOLDER;
+
+		return fAddr[index];
+	}
+
+	bool RawIPAddress6::operator==(const RawIPAddress6& ipv6)
+	{
+		for (SizeT index = 0; index < 8; ++index)
+		{
+			if (ipv6.fAddr[index] != fAddr[index])
+				return false;
+		}
+
+		return true;
+	}
+
+	bool RawIPAddress6::operator!=(const RawIPAddress6& ipv6)
+	{
+		for (SizeT index = 0; index < 8; ++index)
+		{
+			if (ipv6.fAddr[index] == fAddr[index])
+				return false;
+		}
+
+		return true;
+	}
+
+	ErrorOr<StringView> IPFactory::ToStringView(Ref<RawIPAddress6>& ipv6)
+	{
+		auto str = StringBuilder::Construct(ipv6.Leak().Address());
+		return str;
+	}
+
+	ErrorOr<StringView> IPFactory::ToStringView(Ref<RawIPAddress>& ipv4)
+	{
+		auto str = StringBuilder::Construct(ipv4.Leak().Address());
+		return str;
+	}
+
+	bool IPFactory::IpCheckVersion4(const Char* ip)
+	{
+		int cnter = 0;
+
+		for (Size base = 0; base < rt_string_len(ip); ++base)
+		{
+			if (ip[base] == '.')
+			{
+				cnter = 0;
+			}
+			else
+			{
+				if (cnter == 3)
+					return false;
+
+				++cnter;
+			}
+		}
+
+		return true;
+	}
+} // namespace Kernel
diff --git a/dev/zka/src/Network/IPC.cxx b/dev/zka/src/Network/IPC.cxx
new file mode 100644
index 00000000..42b0fcb9
--- /dev/null
+++ b/dev/zka/src/Network/IPC.cxx
@@ -0,0 +1,114 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+------------------------------------------- */
+
+#include <NetworkKit/IPC.hxx>
+#include <KernelKit/LPC.hxx>
+#include <KernelKit/UserProcessScheduler.hxx>
+
+using namespace Kernel;
+
+/// @internal
+/// @brief The internal sanitize function.
+Bool ipc_int_sanitize_packet(IPC_MESSAGE_STRUCT* pckt)
+{
+	auto endian = DEDUCE_ENDIAN(pckt, ((Char*)pckt)[0]);
+
+	switch (endian)
+	{
+	case Endian::kEndianBig: {
+		if (pckt->IpcEndianess == eIPCEPLittleEndian)
+			goto ipc_check_failed;
+
+		break;
+	}
+	case Endian::kEndianLittle: {
+		if (pckt->IpcEndianess == eIPCEPBigEndian)
+			goto ipc_check_failed;
+
+		break;
+	}
+	case Endian::kEndianMixed: {
+		if (pckt->IpcEndianess == eIPCEPMixedEndian)
+			goto ipc_check_failed;
+
+		break;
+	}
+	default:
+		goto ipc_check_failed;
+	}
+
+	if (pckt->IpcFrom == pckt->IpcTo ||
+		pckt->IpcPacketSize > cXPCOMMsgSize)
+	{
+		goto ipc_check_failed;
+	}
+
+	return pckt->IpcPacketSize > 1 && pckt->IpcHeaderMagic == cXPCOMHeaderMagic;
+
+ipc_check_failed:
+	ErrLocal() = kErrorIPC;
+	return false;
+}
+
+namespace Kernel
+{
+	/// @brief Sanitize packet function
+	/// @retval true packet is correct.
+	/// @retval false packet is incorrect and process has crashed.
+	Bool ipc_sanitize_packet(IPC_MESSAGE_STRUCT* pckt)
+	{
+		if (!pckt ||
+			!ipc_int_sanitize_packet(pckt))
+		{
+			UserProcessScheduler::The().CurrentProcess().Leak().Crash();
+			return false;
+		}
+
+		return true;
+	}
+
+	/// @brief Construct packet function
+	/// @retval true packet is correct.
+	/// @retval false packet is incorrect and process has crashed.
+	Bool ipc_construct_packet(_Output IPC_MESSAGE_STRUCT** pckt_in)
+	{
+		// don't do anything if it's valid already.
+		if (*pckt_in)
+			return true;
+
+		// crash process if the packet pointer of pointer is NULL.
+		if (!pckt_in)
+		{
+			UserProcessScheduler::The().CurrentProcess().Leak().Crash();
+			return false;
+		}
+
+		*pckt_in = new IPC_MESSAGE_STRUCT();
+
+		MUST_PASS((*pckt_in));
+
+		if (*pckt_in)
+		{
+			auto endian = DEDUCE_ENDIAN((*pckt_in), ((Char*)(*pckt_in))[0]);
+
+			(*pckt_in)->IpcHeaderMagic = cXPCOMHeaderMagic;
+
+			(*pckt_in)->IpcEndianess  = static_cast<UInt8>(endian);
+			(*pckt_in)->IpcPacketSize = sizeof(IPC_MESSAGE_STRUCT);
+
+			(*pckt_in)->IpcTo.UserProcessID	  = 0;
+			(*pckt_in)->IpcTo.UserProcessTeam = 0;
+
+			(*pckt_in)->IpcFrom.UserProcessID	= Kernel::UserProcessScheduler::The().CurrentProcess().Leak().ProcessId;
+			(*pckt_in)->IpcFrom.UserProcessTeam = Kernel::UserProcessScheduler::The().CurrentTeam().mTeamId;
+
+			return true;
+		}
+
+		UserProcessScheduler::The().CurrentProcess().Leak().Crash();
+		return false;
+	}
+} // namespace Kernel
diff --git a/dev/zka/src/Network/NetworkDevice.cxx b/dev/zka/src/Network/NetworkDevice.cxx
new file mode 100644
index 00000000..afb3e468
--- /dev/null
+++ b/dev/zka/src/Network/NetworkDevice.cxx
@@ -0,0 +1,35 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+------------------------------------------- */
+
+#include <NetworkKit/NetworkDevice.hxx>
+#include <NewKit/Utils.hxx>
+
+namespace Kernel
+{
+	/// \brief Getter for fNetworkName.
+	const Char* NetworkDevice::Name() const
+	{
+		return this->fNetworkName;
+	}
+
+	/// \brief Setter for fNetworkName.
+	Boolean NetworkDevice::Name(const Char* strView)
+	{
+		if (strView == nullptr)
+			return false;
+
+		if (*strView == 0)
+			return false;
+
+		if (rt_string_len(strView) > cNetworkNameLen)
+			return false;
+
+		rt_copy_memory((VoidPtr)strView,
+					   (VoidPtr)this->fNetworkName, rt_string_len(strView));
+
+		return true;
+	}
+} // namespace Kernel
diff --git a/dev/zka/src/New+Delete.cxx b/dev/zka/src/New+Delete.cxx
new file mode 100644
index 00000000..36808a21
--- /dev/null
+++ b/dev/zka/src/New+Delete.cxx
@@ -0,0 +1,50 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+------------------------------------------- */
+
+#include <KernelKit/Heap.hxx>
+#include <NewKit/New.hxx>
+
+void* operator new[](size_t sz)
+{
+	if (sz == 0)
+		++sz;
+
+	return Kernel::mm_new_heap(sz, true, false);
+}
+
+void* operator new(size_t sz)
+{
+	if (sz == 0)
+		++sz;
+
+	return Kernel::mm_new_heap(sz, true, false);
+}
+
+void operator delete[](void* ptr)
+{
+	if (ptr == nullptr)
+		return;
+
+	Kernel::mm_delete_heap(ptr);
+}
+
+void operator delete(void* ptr)
+{
+	if (ptr == nullptr)
+		return;
+
+	Kernel::mm_delete_heap(ptr);
+}
+
+void operator delete(void* ptr, size_t sz)
+{
+	if (ptr == nullptr)
+		return;
+
+	ZKA_UNUSED(sz);
+
+	Kernel::mm_delete_heap(ptr);
+}
diff --git a/dev/zka/src/OwnPtr.cxx b/dev/zka/src/OwnPtr.cxx
new file mode 100644
index 00000000..8b0442a7
--- /dev/null
+++ b/dev/zka/src/OwnPtr.cxx
@@ -0,0 +1,7 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+------------------------------------------- */
+
+#include <NewKit/OwnPtr.hxx>
diff --git a/dev/zka/src/PEFCodeMgr.cxx b/dev/zka/src/PEFCodeMgr.cxx
new file mode 100644
index 00000000..80bd9206
--- /dev/null
+++ b/dev/zka/src/PEFCodeMgr.cxx
@@ -0,0 +1,258 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+------------------------------------------- */
+
+#include <KernelKit/DebugOutput.hxx>
+#include <KernelKit/Heap.hxx>
+#include <KernelKit/PEFCodeMgr.hxx>
+#include <KernelKit/UserProcessScheduler.hxx>
+#include <NewKit/Defines.hxx>
+#include <NewKit/KernelCheck.hxx>
+#include <NewKit/OwnPtr.hxx>
+#include <NewKit/String.hxx>
+
+/// @brief PEF stack size symbol.
+#define cPefStackSizeSymbol "SizeOfReserveStack"
+#define cPefHeapSizeSymbol	"SizeOfReserveHeap"
+#define cPefNameSymbol		"ProgramName"
+
+namespace Kernel
+{
+	namespace Detail
+	{
+		/// @brief Get the PEF platform signature according to the compiled backebnd
+		UInt32 rt_get_pef_platform(void) noexcept
+		{
+#ifdef __ZKA_32X0__
+			return kPefArch32x0;
+#elif defined(__ZKA_64X0__)
+			return kPefArch64x0;
+#elif defined(__ZKA_AMD64__)
+			return kPefArchAMD64;
+#elif defined(__ZKA_PPC64__)
+			return kPefArchPowerPC;
+#elif defined(__ZKA_ARM64__)
+			return kPefArchARM64;
+#else
+			return kPefArchInvalid;
+#endif // __32x0__ || __64x0__ || __x86_64__
+		}
+	} // namespace Detail
+
+	/// @brief PEF loader constructor w/ blob.
+	/// @param blob
+	PEFLoader::PEFLoader(const VoidPtr blob)
+		: fCachedBlob(blob)
+	{
+		MUST_PASS(fCachedBlob);
+		fBad = false;
+	}
+
+	/// @brief PEF loader constructor.
+	/// @param path the filesystem path.
+	PEFLoader::PEFLoader(const Char* path)
+		: fCachedBlob(nullptr), fBad(false), fFatBinary(false)
+	{
+		fFile.New(const_cast<Char*>(path), cRestrictRB);
+		fPath = StringBuilder::Construct(path).Leak();
+
+		auto cPefHeader = "PEF_CONTAINER";
+
+		fCachedBlob = fFile->Read(cPefHeader);
+
+		PEFContainer* container = reinterpret_cast<PEFContainer*>(fCachedBlob);
+
+		if (container->Cpu == Detail::rt_get_pef_platform() &&
+			container->Magic[0] == kPefMagic[0] &&
+			container->Magic[1] == kPefMagic[1] &&
+			container->Magic[2] == kPefMagic[2] &&
+			container->Magic[3] == kPefMagic[3] &&
+			container->Magic[4] == kPefMagic[4] && container->Abi == kPefAbi)
+		{
+			return;
+		}
+		else if (container->Magic[4] == kPefMagic[0] &&
+				 container->Magic[3] == kPefMagic[1] &&
+				 container->Magic[2] == kPefMagic[2] &&
+				 container->Magic[1] == kPefMagic[3] &&
+				 container->Magic[0] == kPefMagic[0] && container->Abi == kPefAbi)
+		{
+			/// This is a fat binary.
+			this->fFatBinary = true;
+			return;
+		}
+
+		fBad = true;
+
+		if (fCachedBlob)
+			mm_delete_heap(fCachedBlob);
+
+		kcout << "CodeMgrPEF: Warning: Executable format error!\r";
+		fCachedBlob = nullptr;
+	}
+
+	/// @brief PEF destructor.
+	PEFLoader::~PEFLoader()
+	{
+		if (fCachedBlob)
+			mm_delete_heap(fCachedBlob);
+
+		fFile.Delete();
+	}
+
+	VoidPtr PEFLoader::FindSymbol(const Char* name, Int32 kind)
+	{
+		if (!fCachedBlob || fBad || !name)
+			return nullptr;
+
+		PEFContainer* container = reinterpret_cast<PEFContainer*>(fCachedBlob);
+
+		auto blob = fFile->Read(name);
+
+		PEFCommandHeader* container_header = reinterpret_cast<PEFCommandHeader*>(blob);
+
+		constexpr auto cMangleCharacter	 = '$';
+		const Char*	   cContainerKinds[] = {".code64", ".data64", ".zero64", nullptr};
+
+		ErrorOr<StringView> errOrSym;
+
+		switch (kind)
+		{
+		case kPefCode: {
+			errOrSym = StringBuilder::Construct(cContainerKinds[0]); // code symbol.
+			break;
+		}
+		case kPefData: {
+			errOrSym = StringBuilder::Construct(cContainerKinds[1]); // data symbol.
+			break;
+		}
+		case kPefZero: {
+			errOrSym = StringBuilder::Construct(cContainerKinds[2]); // block starting symbol.
+			break;
+		}
+		default:
+			return nullptr;
+		}
+
+		char* unconstSymbol = const_cast<char*>(name);
+
+		for (SizeT i = 0UL; i < rt_string_len(unconstSymbol, kPefNameLen); ++i)
+		{
+			if (unconstSymbol[i] == ' ')
+			{
+				unconstSymbol[i] = cMangleCharacter;
+			}
+		}
+
+		errOrSym.Leak().Leak() += name;
+
+		for (SizeT index = 0; index < container->Count; ++index)
+		{
+			if (StringBuilder::Equals(container_header->Name,
+									  errOrSym.Leak().Leak().CData()))
+			{
+				if (container_header->Kind == kind)
+				{
+					if (container_header->Cpu != Detail::rt_get_pef_platform())
+					{
+						if (!this->fFatBinary)
+						{
+							mm_delete_heap(blob);
+							return nullptr;
+						}
+					}
+
+					Char* blobRet = new Char[container_header->Size];
+
+					rt_copy_memory((VoidPtr)((Char*)blob + sizeof(PEFCommandHeader)), blobRet, container_header->Size);
+					mm_delete_heap(blob);
+
+					return blobRet;
+				}
+			}
+		}
+
+		mm_delete_heap(blob);
+		return nullptr;
+	}
+
+	/// @brief Finds the executable entrypoint.
+	/// @return
+	ErrorOr<VoidPtr> PEFLoader::FindStart()
+	{
+		if (auto sym = this->FindSymbol(kPefStart, kPefCode); sym)
+			return ErrorOr<VoidPtr>(sym);
+
+		return ErrorOr<VoidPtr>(kErrorExecutable);
+	}
+
+	/// @brief Tells if the executable is loaded or not.
+	/// @return
+	bool PEFLoader::IsLoaded() noexcept
+	{
+		return !fBad && fCachedBlob;
+	}
+
+	namespace Utils
+	{
+		Bool execute_from_image(PEFLoader& exec, const Int32& procKind) noexcept
+		{
+			auto errOrStart = exec.FindStart();
+
+			if (errOrStart.Error() != kErrorSuccess)
+				return false;
+
+			UserProcess proc;
+
+			proc.SetImageStart(errOrStart.Leak().Leak());
+			proc.Kind		 = procKind;
+			proc.StackSize	 = *(UIntPtr*)exec.FindSymbol(cPefStackSizeSymbol, kPefData);
+			proc.MemoryLimit = *(UIntPtr*)exec.FindSymbol(cPefHeapSizeSymbol, kPefData);
+
+			rt_set_memory(proc.Name, 0, kProcessLen);
+
+			if (exec.FindSymbol(cPefNameSymbol, kPefData))
+				rt_copy_memory((VoidPtr)exec.FindSymbol(cPefNameSymbol, kPefData), proc.Name, rt_string_len((Char*)exec.FindSymbol(cPefNameSymbol, kPefData)));
+			else
+				rt_copy_memory((VoidPtr) "UNNAMED PROCESS.", proc.Name, rt_string_len("UNNAMED PROCESS."));
+
+			if (!proc.StackSize)
+			{
+				const auto cDefaultStackSizeMib = 8;
+
+				proc.StackSize = mib_cast(cDefaultStackSizeMib);
+			}
+
+			return UserProcessScheduler::The().Add(proc) > 0;
+		}
+	} // namespace Utils
+
+	const Char* PEFLoader::Path()
+	{
+		return fPath.Leak().CData();
+	}
+
+	const Char* PEFLoader::AsString()
+	{
+#ifdef __32x0__
+		return "32x0 PEF executable.";
+#elif defined(__64x0__)
+		return "64x0 PEF executable.";
+#elif defined(__x86_64__)
+		return "x86_64 PEF executable.";
+#elif defined(__aarch64__)
+		return "aarch64 PEF executable.";
+#elif defined(__powerpc64__)
+		return "POWER64 PEF executable.";
+#else
+		return "???? PEF executable.";
+#endif // __32x0__ || __64x0__ || __x86_64__ || __powerpc64__
+	}
+
+	const Char* PEFLoader::MIME()
+	{
+		return kPefApplicationMime;
+	}
+} // namespace Kernel
diff --git a/dev/zka/src/PRDT.cxx b/dev/zka/src/PRDT.cxx
new file mode 100644
index 00000000..f9bbd685
--- /dev/null
+++ b/dev/zka/src/PRDT.cxx
@@ -0,0 +1,22 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+------------------------------------------- */
+
+#include <KernelKit/DebugOutput.hxx>
+#include <NewKit/String.hxx>
+#include <StorageKit/PRDT.hxx>
+
+namespace Kernel
+{
+	/// @brief constructs a new PRD.
+	/// @param prd PRD reference.
+	/// @note This doesnt construct a valid, please fill it by yourself.
+	void construct_prdt(Ref<PRDT>& prd)
+	{
+		prd.Leak().fPhysAddress = 0x0;
+		prd.Leak().fSectorCount = 0x0;
+		prd.Leak().fEndBit		= 0x0;
+	}
+} // namespace Kernel
diff --git a/dev/zka/src/PageMgr.cxx b/dev/zka/src/PageMgr.cxx
new file mode 100644
index 00000000..3eefe491
--- /dev/null
+++ b/dev/zka/src/PageMgr.cxx
@@ -0,0 +1,111 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+------------------------------------------- */
+
+#include <KernelKit/DebugOutput.hxx>
+#include <NewKit/PageMgr.hxx>
+
+#ifdef __ZKA_AMD64__
+#include <HALKit/AMD64/Paging.hxx>
+#elif defined(__ZKA_ARM64__)
+#include <HALKit/ARM64/Paging.hxx>
+#endif // ifdef __ZKA_AMD64__ || defined(__ZKA_ARM64__)
+
+//! null deref will throw (Page Zero detected, aborting app!)
+#define kProtectedRegionEnd (512)
+
+namespace Kernel
+{
+	PTEWrapper::PTEWrapper(Boolean Rw, Boolean User, Boolean ExecDisable, UIntPtr VirtAddr)
+		: fRw(Rw),
+		  fUser(User),
+		  fExecDisable(ExecDisable),
+		  fVirtAddr(VirtAddr),
+		  fCache(false),
+		  fShareable(false),
+		  fWt(false),
+		  fPresent(true),
+		  fAccessed(false)
+	{
+	}
+
+	PTEWrapper::~PTEWrapper() = default;
+
+	/// @brief Flush virtual address.
+	/// @param VirtAddr
+	Void PageMgr::FlushTLB()
+	{
+		hal_flush_tlb();
+	}
+
+	/// @brief Reclaim freed page.
+	/// @return
+	Bool PTEWrapper::Reclaim()
+	{
+		if (!this->fPresent)
+		{
+			this->fPresent = true;
+			return true;
+		}
+
+		return false;
+	}
+
+	/// @brief Request a PTE.
+	/// @param Rw r/w?
+	/// @param User user mode?
+	/// @param ExecDisable disable execution on page?
+	/// @return
+	PTEWrapper PageMgr::Request(Boolean Rw, Boolean User, Boolean ExecDisable, SizeT Sz)
+	{
+		// Store PTE wrapper right after PTE.
+		VoidPtr ptr = Kernel::HAL::mm_alloc_bitmap(Rw, User, Sz);
+
+		return PTEWrapper{Rw, User, ExecDisable, reinterpret_cast<UIntPtr>(ptr)};
+	}
+
+	/// @brief Disable BitMap.
+	/// @param wrapper the wrapper.
+	/// @return If the page bitmap was cleared or not.
+	Bool PageMgr::Free(Ref<PTEWrapper>& wrapper)
+	{
+		if (!Kernel::HAL::mm_free_bitmap((VoidPtr)wrapper.Leak().VirtualAddress()))
+			return false;
+
+		return true;
+	}
+
+	/// @brief Virtual PTE address.
+	/// @return The virtual address of the page.
+	const UIntPtr PTEWrapper::VirtualAddress()
+	{
+		return (fVirtAddr);
+	}
+
+	bool PTEWrapper::Shareable()
+	{
+		return fShareable;
+	}
+
+	bool PTEWrapper::Present()
+	{
+		return fPresent;
+	}
+
+	bool PTEWrapper::Access()
+	{
+		return fAccessed;
+	}
+
+	void PTEWrapper::NoExecute(const bool enable)
+	{
+		this->fExecDisable = enable;
+	}
+
+	const bool& PTEWrapper::NoExecute()
+	{
+		return this->fExecDisable;
+	}
+} // namespace Kernel
diff --git a/dev/zka/src/Pmm.cxx b/dev/zka/src/Pmm.cxx
new file mode 100644
index 00000000..394b634c
--- /dev/null
+++ b/dev/zka/src/Pmm.cxx
@@ -0,0 +1,94 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+------------------------------------------- */
+
+#include <KernelKit/DebugOutput.hxx>
+#include <NewKit/Pmm.hxx>
+
+#if defined(__ZKA_ARM64__)
+#include <HALKit/ARM64/Processor.hxx>
+#endif // defined(__ZKA_ARM64__)
+
+#if defined(__ZKA_AMD64__)
+#include <HALKit/AMD64/Processor.hxx>
+#endif // defined(__ZKA_AMD64__)
+
+namespace Kernel
+{
+	/// @brief Pmm constructor.
+	Pmm::Pmm()
+		: fPageMgr()
+	{
+		kcout << "[PMM] Allocate PageMemoryMgr";
+	}
+
+	Pmm::~Pmm() = default;
+
+	/* If this returns Null pointer, enter emergency mode */
+	/// @param user is this a user page?
+	/// @param readWrite is it r/w?
+	Ref<PTEWrapper> Pmm::RequestPage(Boolean user, Boolean readWrite)
+	{
+		PTEWrapper pt = fPageMgr.Leak().Request(user, readWrite, false, kPageSize);
+
+		if (pt.fPresent)
+		{
+			kcout << "[PMM]: Allocation failed.\r";
+			return {};
+		}
+
+		return Ref<PTEWrapper>(pt);
+	}
+
+	Boolean Pmm::FreePage(Ref<PTEWrapper> PageRef)
+	{
+		if (!PageRef)
+			return false;
+
+		PageRef.Leak().fPresent = false;
+
+		return true;
+	}
+
+	Boolean Pmm::TogglePresent(Ref<PTEWrapper> PageRef, Boolean Enable)
+	{
+		if (!PageRef)
+			return false;
+
+		PageRef.Leak().fPresent = Enable;
+
+		return true;
+	}
+
+	Boolean Pmm::ToggleUser(Ref<PTEWrapper> PageRef, Boolean Enable)
+	{
+		if (!PageRef)
+			return false;
+
+		PageRef.Leak().fRw = Enable;
+
+		return true;
+	}
+
+	Boolean Pmm::ToggleRw(Ref<PTEWrapper> PageRef, Boolean Enable)
+	{
+		if (!PageRef)
+			return false;
+
+		PageRef.Leak().fRw = Enable;
+
+		return true;
+	}
+
+	Boolean Pmm::ToggleShare(Ref<PTEWrapper> PageRef, Boolean Enable)
+	{
+		if (!PageRef)
+			return false;
+
+		PageRef.Leak().fShareable = Enable;
+
+		return true;
+	}
+} // namespace Kernel
diff --git a/dev/zka/src/Property.cxx b/dev/zka/src/Property.cxx
new file mode 100644
index 00000000..04b4367e
--- /dev/null
+++ b/dev/zka/src/Property.cxx
@@ -0,0 +1,27 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+------------------------------------------- */
+
+#include <CFKit/Property.hxx>
+
+namespace Kernel
+{
+	Property::~Property() = default;
+
+	bool Property::StringEquals(StringView& name)
+	{
+		return this->fName && this->fName == name;
+	}
+
+	StringView& Property::GetKey()
+	{
+		return this->fName;
+	}
+
+	PropertyId& Property::GetValue()
+	{
+		return fAction;
+	}
+} // namespace Kernel
diff --git a/dev/zka/src/Ref.cxx b/dev/zka/src/Ref.cxx
new file mode 100644
index 00000000..cf383271
--- /dev/null
+++ b/dev/zka/src/Ref.cxx
@@ -0,0 +1,7 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+------------------------------------------- */
+
+#include <NewKit/Ref.hxx>
diff --git a/dev/zka/src/Semaphore.cxx b/dev/zka/src/Semaphore.cxx
new file mode 100644
index 00000000..3e30cc31
--- /dev/null
+++ b/dev/zka/src/Semaphore.cxx
@@ -0,0 +1,62 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+------------------------------------------- */
+
+#include <KernelKit/UserProcessScheduler.hxx>
+#include <KernelKit/Semaphore.hxx>
+
+namespace Kernel
+{
+	bool Semaphore::Unlock() noexcept
+	{
+		if (fLockingProcess)
+			fLockingProcess = nullptr;
+
+		return fLockingProcess == nullptr;
+	}
+
+	bool Semaphore::Lock(UserProcess* process)
+	{
+		if (!process || fLockingProcess)
+			return false;
+
+		fLockingProcess = process;
+
+		return true;
+	}
+
+	bool Semaphore::IsLocked() const
+	{
+		return fLockingProcess;
+	}
+
+	bool Semaphore::LockOrWait(UserProcess* process, TimerInterface* timer)
+	{
+		if (process == nullptr)
+			return false;
+
+		if (timer == nullptr)
+			return false;
+
+		this->Lock(process);
+
+		timer->Wait();
+
+		return this->Lock(process);
+	}
+
+	/// @brief Wait with process, either wait for process being invalid, or not being run.
+	Void Semaphore::WaitForProcess() noexcept
+	{
+		while (fLockingProcess)
+		{
+			if (fLockingProcess->GetStatus() != ProcessStatusKind::kRunning)
+			{
+				this->Unlock();
+				break;
+			}
+		}
+	}
+} // namespace Kernel
diff --git a/dev/zka/src/Storage/AHCIDeviceInterface.cxx b/dev/zka/src/Storage/AHCIDeviceInterface.cxx
new file mode 100644
index 00000000..1dc52b72
--- /dev/null
+++ b/dev/zka/src/Storage/AHCIDeviceInterface.cxx
@@ -0,0 +1,35 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+------------------------------------------- */
+
+#include <StorageKit/AHCI.hxx>
+
+using namespace Kernel;
+
+/// @brief Class constructor
+/// @param Out Drive output
+/// @param In  Drive input
+/// @param Cleanup Drive cleanup.
+AHCIDeviceInterface::AHCIDeviceInterface(void (*Out)(MountpointInterface* outpacket),
+										 void (*In)(MountpointInterface* inpacket),
+										 void (*Cleanup)(void))
+	: DeviceInterface(Out, In), fCleanup(Cleanup)
+{
+}
+
+/// @brief Class desctructor
+AHCIDeviceInterface::~AHCIDeviceInterface()
+{
+	MUST_PASS(fCleanup);
+	if (fCleanup)
+		fCleanup();
+}
+
+/// @brief Returns the name of the device interface.
+/// @return it's name as a string.
+const Char* AHCIDeviceInterface::Name() const
+{
+	return "AHCIDeviceInterface";
+}
diff --git a/dev/zka/src/Storage/ATADeviceInterface.cxx b/dev/zka/src/Storage/ATADeviceInterface.cxx
new file mode 100644
index 00000000..78abada0
--- /dev/null
+++ b/dev/zka/src/Storage/ATADeviceInterface.cxx
@@ -0,0 +1,88 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+------------------------------------------- */
+
+#include <StorageKit/ATA.hxx>
+
+using namespace Kernel;
+
+/// @brief Class constructor
+/// @param Out Drive output
+/// @param In  Drive input
+/// @param Cleanup Drive cleanup.
+ATADeviceInterface::ATADeviceInterface(
+	void (*Out)(MountpointInterface* outpacket),
+	void (*In)(MountpointInterface* inpacket),
+	void (*Cleanup)(void))
+	: DeviceInterface(Out, In), fCleanup(Cleanup)
+{
+}
+
+/// @brief Class desctructor
+ATADeviceInterface::~ATADeviceInterface()
+{
+	MUST_PASS(fCleanup);
+	if (fCleanup)
+		fCleanup();
+}
+
+/// @brief Returns the name of the device interface.
+/// @return it's name as a string.
+const Char* ATADeviceInterface::Name() const
+{
+	return "ATADeviceInterface";
+}
+
+/// @brief Output operator.
+/// @param Data
+/// @return
+ATADeviceInterface& ATADeviceInterface::operator<<(MountpointInterface* Data)
+{
+	if (!Data)
+		return *this;
+
+	for (SizeT driveCount = 0; driveCount < kDriveMgrCount; ++driveCount)
+	{
+		auto interface = Data->GetAddressOf(driveCount);
+		if ((interface) && rt_string_cmp((interface)->fDriveKind(), "ATA-", 5) == 0)
+		{
+			continue;
+		}
+		else if ((interface) &&
+				 rt_string_cmp((interface)->fDriveKind(), "ATA-", 5) != 0)
+		{
+			return *this;
+		}
+	}
+
+	return (ATADeviceInterface&)DeviceInterface<MountpointInterface*>::operator<<(
+		Data);
+}
+
+/// @brief Input operator.
+/// @param Data
+/// @return
+ATADeviceInterface& ATADeviceInterface::operator>>(MountpointInterface* Data)
+{
+	if (!Data)
+		return *this;
+
+	for (SizeT driveCount = 0; driveCount < kDriveMgrCount; ++driveCount)
+	{
+		auto interface = Data->GetAddressOf(driveCount);
+		if ((interface) && rt_string_cmp((interface)->fDriveKind(), "ATA-", 5) == 0)
+		{
+			continue;
+		}
+		else if ((interface) &&
+				 rt_string_cmp((interface)->fDriveKind(), "ATA-", 5) != 0)
+		{
+			return *this;
+		}
+	}
+
+	return (ATADeviceInterface&)DeviceInterface<MountpointInterface*>::operator>>(
+		Data);
+}
diff --git a/dev/zka/src/Storage/NVMEDeviceInterface.cxx b/dev/zka/src/Storage/NVMEDeviceInterface.cxx
new file mode 100644
index 00000000..5809a5e6
--- /dev/null
+++ b/dev/zka/src/Storage/NVMEDeviceInterface.cxx
@@ -0,0 +1,28 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+------------------------------------------- */
+
+#include <StorageKit/NVME.hxx>
+
+namespace Kernel
+{
+	NVMEDeviceInterface::NVMEDeviceInterface(void (*Out)(MountpointInterface* outpacket),
+											 void (*In)(MountpointInterface* inpacket),
+											 void (*Cleanup)(void))
+		: DeviceInterface(Out, In), fCleanup(Cleanup)
+	{
+	}
+
+	NVMEDeviceInterface::~NVMEDeviceInterface()
+	{
+		if (fCleanup)
+			fCleanup();
+	}
+
+	const Char* NVMEDeviceInterface::Name() const
+	{
+		return ("NVMEDeviceInterface");
+	}
+} // namespace Kernel
diff --git a/dev/zka/src/Storage/SCSIDeviceInterface.cxx b/dev/zka/src/Storage/SCSIDeviceInterface.cxx
new file mode 100644
index 00000000..da75a181
--- /dev/null
+++ b/dev/zka/src/Storage/SCSIDeviceInterface.cxx
@@ -0,0 +1,11 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+------------------------------------------- */
+
+#include <StorageKit/SCSI.hxx>
+
+///! @brief ATAPI SCSI packet.
+const scsi_packet_type kCDRomPacketTemplate = {0x43, 0, 1, 0, 0, 0,
+											   0, 12, 0x40, 0, 0};
diff --git a/dev/zka/src/Stream.cxx b/dev/zka/src/Stream.cxx
new file mode 100644
index 00000000..3a809a8d
--- /dev/null
+++ b/dev/zka/src/Stream.cxx
@@ -0,0 +1,12 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+	File: Stream.cxx
+	Purpose: Stream object
+
+	Revision History:
+
+------------------------------------------- */
+
+#include <NewKit/Stream.hxx>
diff --git a/dev/zka/src/String.cxx b/dev/zka/src/String.cxx
new file mode 100644
index 00000000..bfa80711
--- /dev/null
+++ b/dev/zka/src/String.cxx
@@ -0,0 +1,257 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+------------------------------------------- */
+
+#include <NewKit/String.hxx>
+#include <NewKit/Utils.hxx>
+#include <KernelKit/DebugOutput.hxx>
+
+namespace Kernel
+{
+	Char* StringView::Data()
+	{
+		return fData;
+	}
+
+	const Char* StringView::CData() const
+	{
+		return fData;
+	}
+
+	Size StringView::Length() const
+	{
+		return fSz;
+	}
+
+	bool StringView::operator==(const StringView& rhs) const
+	{
+		if (rhs.Length() != this->Length())
+			return false;
+
+		for (Size index = 0; index < this->Length(); ++index)
+		{
+			if (rhs.fData[index] != fData[index])
+				return false;
+		}
+
+		return true;
+	}
+
+	bool StringView::operator==(const Char* rhs) const
+	{
+		if (rt_string_len(rhs) != this->Length())
+			return false;
+
+		for (Size index = 0; index < rt_string_len(rhs); ++index)
+		{
+			if (rhs[index] != fData[index])
+				return false;
+		}
+
+		return true;
+	}
+
+	bool StringView::operator!=(const StringView& rhs) const
+	{
+		if (rhs.Length() != this->Length())
+			return false;
+
+		for (Size index = 0; index < rhs.Length(); ++index)
+		{
+			if (rhs.fData[index] == fData[index])
+				return false;
+		}
+
+		return true;
+	}
+
+	bool StringView::operator!=(const Char* rhs) const
+	{
+		if (rt_string_len(rhs) != this->Length())
+			return false;
+
+		for (Size index = 0; index < rt_string_len(rhs); ++index)
+		{
+			if (rhs[index] == fData[index])
+				return false;
+		}
+
+		return true;
+	}
+
+	ErrorOr<StringView> StringBuilder::Construct(const Char* data)
+	{
+		if (!data || *data == 0)
+			return {};
+
+		StringView view(rt_string_len(data));
+
+		view += data;
+
+		return ErrorOr<StringView>(view);
+	}
+
+	const Char* StringBuilder::FromInt(const Char* fmt, int i)
+	{
+		if (!fmt)
+			return ("-1");
+
+		char* ret = (char*)ALLOCA(sizeof(char) * 8 + rt_string_len(fmt));
+
+		if (!ret)
+			return ("-1");
+
+		Char result[8];
+
+		if (!rt_to_string(result, sizeof(int), i))
+		{
+			return ("-1");
+		}
+
+		const auto fmt_len = rt_string_len(fmt);
+		const auto res_len = rt_string_len(result);
+
+		for (Size idx = 0; idx < fmt_len; ++idx)
+		{
+			if (fmt[idx] == '%')
+			{
+				SizeT result_cnt = idx;
+
+				for (auto y_idx = idx; y_idx < res_len; ++y_idx)
+				{
+					ret[result_cnt] = result[y_idx];
+					++result_cnt;
+				}
+
+				break;
+			}
+
+			ret[idx] = fmt[idx];
+		}
+
+		return ret; /* Copy that ret into a buffer, 'ALLOCA' allocates to the stack */
+	}
+
+	const Char* StringBuilder::FromBool(const Char* fmt, bool i)
+	{
+		if (!fmt)
+			return ("?");
+
+		const Char* boolean_expr = i ? "true" : "false";
+		char*		ret			 = (char*)ALLOCA((sizeof(char) * i) ? 4 : 5 + rt_string_len(fmt));
+
+		if (!ret)
+			return ("?");
+
+		const auto fmt_len = rt_string_len(fmt);
+		const auto res_len = rt_string_len(boolean_expr);
+
+		for (Size idx = 0; idx < fmt_len; ++idx)
+		{
+			if (fmt[idx] == '%')
+			{
+				SizeT result_cnt = idx;
+
+				for (auto y_idx = idx; y_idx < res_len; ++y_idx)
+				{
+					ret[result_cnt] = boolean_expr[y_idx];
+					++result_cnt;
+				}
+
+				break;
+			}
+
+			ret[idx] = fmt[idx];
+		}
+
+		return ret;
+	}
+
+	bool StringBuilder::Equals(const Char* lhs, const Char* rhs)
+	{
+		if (rt_string_len(rhs) != rt_string_len(lhs))
+			return false;
+
+		for (Size index = 0; index < rt_string_len(rhs); ++index)
+		{
+			if (rhs[index] != lhs[index])
+				return false;
+		}
+
+		return true;
+	}
+
+	bool StringBuilder::Equals(const WideChar* lhs, const WideChar* rhs)
+	{
+		for (Size index = 0; rhs[index] != 0; ++index)
+		{
+			if (rhs[index] != lhs[index])
+				return false;
+		}
+
+		return true;
+	}
+
+	const Char* StringBuilder::Format(const Char* fmt, const Char* fmt2)
+	{
+		if (!fmt || !fmt2)
+			return ("?");
+
+		char* ret =
+			(char*)ALLOCA(sizeof(char) * rt_string_len(fmt2) + rt_string_len(fmt2));
+
+		if (!ret)
+			return ("?");
+
+		for (Size idx = 0; idx < rt_string_len(fmt); ++idx)
+		{
+			if (fmt[idx] == '%')
+			{
+				Size result_cnt = idx;
+				for (Size y_idx = 0; y_idx < rt_string_len(fmt2); ++y_idx)
+				{
+					ret[result_cnt] = fmt2[y_idx];
+					++result_cnt;
+				}
+
+				break;
+			}
+
+			ret[idx] = fmt[idx];
+		}
+
+		return ret;
+	}
+
+	STATIC void rt_string_append(Char* lhs, const Char* rhs, Int32 cur)
+	{
+		SizeT sz_rhs = rt_string_len(rhs);
+		SizeT rhs_i	 = 0;
+
+		for (; rhs_i < sz_rhs; ++rhs_i)
+		{
+			lhs[rhs_i + cur] = rhs[rhs_i];
+		}
+	}
+
+	StringView& StringView::operator+=(const Char* rhs)
+	{
+		rt_string_append(this->fData, rhs, this->fCur);
+		this->fCur += rt_string_len(rhs);
+
+		return *this;
+	}
+
+	StringView& StringView::operator+=(const StringView& rhs)
+	{
+		if (rt_string_len(rhs.fData) > this->Length())
+			return *this;
+
+		rt_string_append(this->fData, const_cast<Char*>(rhs.fData), this->fCur);
+		this->fCur += rt_string_len(const_cast<Char*>(rhs.fData));
+
+		return *this;
+	}
+} // namespace Kernel
diff --git a/dev/zka/src/ThreadLocalStorage.cxx b/dev/zka/src/ThreadLocalStorage.cxx
new file mode 100644
index 00000000..587edafd
--- /dev/null
+++ b/dev/zka/src/ThreadLocalStorage.cxx
@@ -0,0 +1,68 @@
+/*
+ * ========================================================
+ *
+ * newoskrnl
+ * Copyright ZKA Technologies., all rights reserved.
+ *
+ *  ========================================================
+ */
+
+#include <NewKit/String.hxx>
+#include <CFKit/Property.hxx>
+#include <KernelKit/UserProcessScheduler.hxx>
+#include <KernelKit/ThreadLocalStorage.hxx>
+
+///! BUGS: 0
+
+/***********************************************************************************/
+/// @file ThreadLocalStorage.cxx
+/// @brief TLS inside the Kernel.
+/***********************************************************************************/
+
+using namespace Kernel;
+
+/**
+ * @brief Checks for cookie inside the TIB.
+ * @param tib the TIB to check.
+ * @return if the cookie is enabled.
+ */
+
+Boolean tls_check_tib(THREAD_INFORMATION_BLOCK* the_tib)
+{
+	if (!the_tib ||
+		!the_tib->f_ThreadRecord)
+		return false;
+
+	IEncoderObject encoder;
+	const char*	   tibAsBytes = encoder.AsBytes(the_tib);
+
+	kcout << "checking for a valid cookie inside the TIB...\r";
+
+	return tibAsBytes[0] == kCookieMag0 && tibAsBytes[1] == kCookieMag1 &&
+		   tibAsBytes[2] == kCookieMag2;
+}
+
+/**
+ * @brief System call implementation of the TLS check.
+ * @param tib_ptr The TIB record.
+ * @return
+ */
+EXTERN_C Bool tls_check_syscall_impl(Kernel::VoidPtr tib_ptr) noexcept
+{
+	if (!tib_ptr)
+	{
+		kcout << "failing because of an invalid TIB...\r";
+		return false;
+	}
+
+	THREAD_INFORMATION_BLOCK* tib_struct = (THREAD_INFORMATION_BLOCK*)tib_ptr;
+
+	if (!tls_check_tib(tib_struct))
+	{
+		kcout << "crashing because of an invalid TIB...\r";
+		return false;
+	}
+
+	kcout << "Verification succeeded! staying alive...\r";
+	return true;
+}
diff --git a/dev/zka/src/Timer.cxx b/dev/zka/src/Timer.cxx
new file mode 100644
index 00000000..397c19a9
--- /dev/null
+++ b/dev/zka/src/Timer.cxx
@@ -0,0 +1,47 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+------------------------------------------- */
+
+#include <KernelKit/Timer.hxx>
+
+///! BUGS: 0
+///! @file Timer.cxx
+///! @brief Software Timer implementation
+
+using namespace Kernel;
+
+/// @brief Unimplemented as it is an interface.
+Int32 TimerInterface::Wait() noexcept
+{
+	return kErrorUnimplemented;
+}
+
+/// @brief SoftwareTimer class, meant to be generic.
+
+SoftwareTimer::SoftwareTimer(Int64 seconds)
+	: fWaitFor(seconds)
+{
+	fDigitalTimer = new IntPtr();
+	MUST_PASS(fDigitalTimer);
+}
+
+SoftwareTimer::~SoftwareTimer()
+{
+	delete fDigitalTimer;
+	fWaitFor = 0;
+}
+
+Int32 SoftwareTimer::Wait() noexcept
+{
+	if (fWaitFor < 1)
+		return -1;
+
+	while (*fDigitalTimer < (*fDigitalTimer + fWaitFor))
+	{
+		++(*fDigitalTimer);
+	}
+
+	return 0;
+}
diff --git a/dev/zka/src/URL.cxx b/dev/zka/src/URL.cxx
new file mode 100644
index 00000000..e10310f5
--- /dev/null
+++ b/dev/zka/src/URL.cxx
@@ -0,0 +1,98 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+------------------------------------------- */
+
+#include <CFKit/URL.hxx>
+#include <KernelKit/DebugOutput.hxx>
+#include <NewKit/Utils.hxx>
+
+/// BUGS: 0
+
+namespace Kernel
+{
+	URL::URL(StringView& strUrl)
+		: fUrlView(strUrl, false)
+	{
+	}
+
+	URL::~URL() = default;
+
+	/// @brief internal and reserved protocols by Kernel.
+	constexpr const Char* kURLProtocols[] = {
+		"file",	 // Filesystem protocol
+		"zup",	 // ZKA update protocol
+		"oscc",	 // Open System Configuration Connectivity.
+		"odbc",	 // ODBC connectivity.
+		"https", // HTTPS layer driver (HTTPS.sys).
+	};
+
+	constexpr const int kUrlOutSz	 = 1; //! such as: ://
+	constexpr const int kProtosCount = 5;
+	constexpr const int kRangeSz	 = 4096;
+
+	ErrorOr<StringView> url_extract_location(const Char* url)
+	{
+		if (!url || *url == 0 || rt_string_len(url, kRangeSz) > kRangeSz)
+			return ErrorOr<StringView>{-1};
+
+		StringView view(rt_string_len(url));
+
+		SizeT i			   = 0;
+		bool  scheme_found = false;
+
+		for (; i < rt_string_len(url); ++i)
+		{
+			if (!scheme_found)
+			{
+				for (int y = 0; kProtosCount; ++y)
+				{
+					if (rt_string_in_string(view.CData(), kURLProtocols[y]))
+					{
+						i += rt_string_len(kURLProtocols[y]) + kUrlOutSz;
+						scheme_found = true;
+
+						break;
+					}
+				}
+			}
+
+			view.Data()[i] = url[i];
+		}
+
+		return ErrorOr<StringView>(view);
+	}
+
+	ErrorOr<StringView> url_extract_protocol(const Char* url)
+	{
+		if (!url || *url == 0 || rt_string_len(url, kRangeSz) > kRangeSz)
+			return ErrorOr<StringView>{-1};
+
+		ErrorOr<StringView> view{-1};
+
+		return view;
+	}
+
+	Ref<ErrorOr<StringView>> URL::Location() noexcept
+	{
+		const Char* src = fUrlView.Leak().CData();
+		auto		loc = url_extract_location(src);
+
+		if (!loc)
+			return {};
+
+		return Ref<ErrorOr<StringView>>(loc);
+	}
+
+	Ref<ErrorOr<StringView>> URL::Protocol() noexcept
+	{
+		const Char* src = fUrlView.Leak().CData();
+		auto		loc = url_extract_protocol(src);
+
+		if (!loc)
+			return {};
+
+		return Ref<ErrorOr<StringView>>(loc);
+	}
+} // namespace Kernel
diff --git a/dev/zka/src/User.cxx b/dev/zka/src/User.cxx
new file mode 100644
index 00000000..066a3e06
--- /dev/null
+++ b/dev/zka/src/User.cxx
@@ -0,0 +1,138 @@
+/*
+ *	========================================================
+ *
+ *  ZKA
+ * 	Copyright ZKA Technologies., all rights reserved.
+ *
+ *	File: User.cxx
+ * 	Purpose: User class, used to provide authentication and security.
+ *
+ * 	========================================================
+ */
+
+#include <KernelKit/LPC.hxx>
+#include <KernelKit/User.hxx>
+#include <NewKit/KernelCheck.hxx>
+#include <KernelKit/FileMgr.hxx>
+#include <KernelKit/UserProcessScheduler.hxx>
+
+#include <KernelKit/Heap.hxx>
+
+#define cStdUser   (0xCF)
+#define cSuperUser (0xEF)
+
+/// BUGS: 0
+
+namespace Kernel
+{
+	namespace Detail
+	{
+		/// \brief Constructs a password by hashing the password.
+		/// \param password password to hash.
+		/// \return the hashed password
+		const Int32 cred_construct_token(Char* password, const Char* in_password, User* user, SizeT length)
+		{
+			if (!password || !user)
+				return -1;
+
+			kcout << "Constructing password...\r";
+
+			for (Size i_pass = 0; i_pass < length; ++i_pass)
+			{
+				Char cur_chr = in_password[i_pass];
+
+				if (cur_chr == 0)
+					break;
+
+				password[i_pass] = cur_chr + (user->IsStdUser() ? cStdUser : cSuperUser);
+			}
+
+			kcout << "Done constructing password...\r";
+
+			return 0;
+		}
+	} // namespace Detail
+
+	User::User(const Int32& sel, const Char* userName)
+		: fRing((RingKind)sel)
+	{
+		MUST_PASS(sel >= 0);
+		rt_copy_memory((VoidPtr)userName, this->fUserName, rt_string_len(userName));
+	}
+
+	User::User(const RingKind& ringKind, const Char* userName)
+		: fRing(ringKind)
+	{
+		rt_copy_memory((VoidPtr)userName, this->fUserName, rt_string_len(userName));
+	}
+
+	User::~User() = default;
+
+	Bool User::TrySave(const Char* password_to_fill) noexcept
+	{
+		if (!password_to_fill ||
+			*password_to_fill == 0)
+			return false;
+
+		SizeT len = rt_string_len(password_to_fill);
+
+		Char* password = new Char[len];
+		MUST_PASS(password);
+
+		// fill data first, generate hash.
+		// return false on error.
+
+		rt_copy_memory((VoidPtr)password_to_fill, password, len);
+
+		if (!Detail::cred_construct_token(password, password_to_fill, this, len))
+		{
+			delete[] password;
+			password = nullptr;
+
+			return false;
+		}
+
+		// then store password.
+
+		rt_copy_memory(password, this->fUserToken, rt_string_len(password_to_fill));
+
+		delete[] password;
+		password = nullptr;
+
+		kcout << "Saved password...\r";
+
+		return true;
+	}
+
+	bool User::operator==(const User& lhs)
+	{
+		return lhs.fRing == this->fRing;
+	}
+
+	bool User::operator!=(const User& lhs)
+	{
+		return lhs.fRing != this->fRing;
+	}
+
+	Char* User::Name() noexcept
+	{
+		return this->fUserName;
+	}
+
+	/// @brief Returns the user's ring.
+	/// @return The king of ring the user is attached to.
+	const RingKind& User::Ring() noexcept
+	{
+		return this->fRing;
+	}
+
+	Bool User::IsStdUser() noexcept
+	{
+		return this->Ring() == RingKind::kRingStdUser;
+	}
+
+	Bool User::IsSuperUser() noexcept
+	{
+		return this->Ring() == RingKind::kRingSuperUser;
+	}
+} // namespace Kernel
diff --git a/dev/zka/src/UserProcessScheduler.cxx b/dev/zka/src/UserProcessScheduler.cxx
new file mode 100644
index 00000000..88980f8d
--- /dev/null
+++ b/dev/zka/src/UserProcessScheduler.cxx
@@ -0,0 +1,484 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+	FILE: UserProcessScheduler.cxx
+	PURPOSE: Low Exception Process scheduler.
+
+------------------------------------------- */
+
+/***********************************************************************************/
+/// @file UserProcessScheduler.cxx
+/// @brief User Process scheduler.
+/***********************************************************************************/
+
+#include <KernelKit/UserProcessScheduler.hxx>
+#include <KernelKit/IPEFDLLObject.hxx>
+#include <KernelKit/HardwareThreadScheduler.hxx>
+#include <KernelKit/Heap.hxx>
+#include <NewKit/String.hxx>
+#include <KernelKit/LPC.hxx>
+
+///! BUGS: 0
+
+/***********************************************************************************/
+/** TODO: Document the Kernel, SDK and kits. */
+/***********************************************************************************/
+
+namespace Kernel
+{
+	/***********************************************************************************/
+	/// @brief Exit Code global variable.
+	/***********************************************************************************/
+
+	STATIC UInt32 cLastExitCode = 0U;
+
+	/***********************************************************************************/
+	/// @brief User Process scheduler global object.
+	/***********************************************************************************/
+
+	UserProcessScheduler* cProcessScheduler = nullptr;
+
+	/// @brief Gets the last exit code.
+	/// @note Not thread-safe.
+	/// @return Int32 the last exit code.
+	const UInt32& sched_get_exit_code(void) noexcept
+	{
+		return cLastExitCode;
+	}
+
+	/***********************************************************************************/
+	/// @brief crash current process.
+	/***********************************************************************************/
+
+	Void UserProcess::Crash()
+	{
+		if (*this->Name != 0)
+			kcout << this->Name << ": crashed, error id: " << number(kErrorProcessFault) << endl;
+
+		this->Exit(kErrorProcessFault);
+	}
+
+	/// @brief Gets the local last exit code.
+	/// @note Not thread-safe.
+	/// @return Int32 the last exit code.
+	const UInt32& UserProcess::GetExitCode() noexcept
+	{
+		return this->fLastExitCode;
+	}
+
+	/***********************************************************************************/
+	/// @brief Error code variable getter.
+	/***********************************************************************************/
+
+	Int32& UserProcess::GetLocalCode() noexcept
+	{
+		return fLocalCode;
+	}
+
+	void UserProcess::Wake(const bool should_wakeup)
+	{
+		this->Status =
+			should_wakeup ? ProcessStatusKind::kRunning : ProcessStatusKind::kFrozen;
+	}
+
+	/***********************************************************************************/
+
+	/** @brief Add pointer to entry. */
+	VoidPtr UserProcess::New(const SizeT& sz)
+	{
+#ifdef __ZKA_AMD64__
+		auto pd = hal_read_cr3();
+		hal_write_cr3(reinterpret_cast<VoidPtr>(this->MemoryPD));
+
+		auto ptr = mm_new_heap(sz, Yes, Yes);
+
+		hal_write_cr3(reinterpret_cast<VoidPtr>(pd));
+#else
+		auto ptr = mm_new_heap(sz, Yes, Yes);
+#endif
+
+		if (!this->MemoryEntryList)
+		{
+			this->MemoryEntryList			   = new UserProcess::PROCESS_MEMORY_ENTRY();
+			this->MemoryEntryList->MemoryEntry = ptr;
+
+			this->MemoryEntryList->MemoryPrev = nullptr;
+			this->MemoryEntryList->MemoryNext = nullptr;
+
+			return ptr;
+		}
+		else
+		{
+			auto				  entry		 = this->MemoryEntryList;
+			PROCESS_MEMORY_ENTRY* prev_entry = nullptr;
+
+			while (!entry)
+			{
+				prev_entry = entry;
+				entry	   = entry->MemoryNext;
+			}
+
+			entry->MemoryNext			   = new UserProcess::PROCESS_MEMORY_ENTRY();
+			entry->MemoryNext->MemoryEntry = ptr;
+
+			entry->MemoryNext->MemoryPrev = entry;
+			entry->MemoryNext->MemoryNext = nullptr;
+		}
+
+		return nullptr;
+	}
+
+	/***********************************************************************************/
+
+	/** @brief Free pointer from usage. */
+	Boolean UserProcess::Delete(VoidPtr ptr, const SizeT& sz)
+	{
+		auto entry = this->MemoryEntryList;
+
+		while (entry)
+		{
+			if (entry->MemoryEntry == ptr)
+			{
+#ifdef __ZKA_AMD64__
+				auto pd = hal_read_cr3();
+				hal_write_cr3(reinterpret_cast<VoidPtr>(this->MemoryPD));
+
+				Bool ret = mm_delete_heap(ptr);
+				hal_write_cr3(reinterpret_cast<VoidPtr>(pd));
+
+				return ret;
+#else
+				bool ret = mm_delete_heap(ptr);
+				return ret;
+#endif
+			}
+
+			entry = entry->MemoryNext;
+		}
+
+		return false;
+	}
+
+	/// @brief UserProcess name getter.
+	const Char* UserProcess::GetProcessName() noexcept
+	{
+		return this->Name;
+	}
+
+	/// @brief UserProcess user getter.
+	const User* UserProcess::GetOwner() noexcept
+	{
+		return this->Owner;
+	}
+
+	/// @brief UserProcess status getter.
+	const ProcessStatusKind& UserProcess::GetStatus() noexcept
+	{
+		return this->Status;
+	}
+
+	/***********************************************************************************/
+
+	/**
+	@brief Affinity is the time slot allowed for the process.
+	*/
+	const AffinityKind& UserProcess::GetAffinity() noexcept
+	{
+		return this->Affinity;
+	}
+
+	/**
+	@brief Standard exit proc.
+	*/
+	void UserProcess::Exit(const Int32& exit_code)
+	{
+		this->Status = ProcessStatusKind::kDead;
+
+		fLastExitCode = exit_code;
+		cLastExitCode = exit_code;
+
+		//! Delete image if not done already.
+		if (this->Image && mm_is_valid_heap(this->Image))
+			mm_delete_heap(this->Image);
+
+		if (this->StackFrame && mm_is_valid_heap(this->StackFrame))
+			mm_delete_heap((VoidPtr)this->StackFrame);
+
+		this->Image		 = nullptr;
+		this->StackFrame = nullptr;
+
+		if (this->Kind == kDLLKind)
+		{
+			Bool success = false;
+			rtl_fini_dll(this, this->DLLPtr, &success);
+
+			if (success)
+			{
+				this->DLLPtr = nullptr;
+			}
+		}
+
+		if (this->StackReserve)
+			delete[] this->StackReserve;
+
+		this->ProcessId = 0;
+
+		if (this->ProcessId > 0)
+			UserProcessScheduler::The().Remove(this->ProcessId);
+	}
+
+	/// @brief Add process to list.
+	/// @param process the process *Ref* class.
+	/// @return the process index inside the team.
+	SizeT UserProcessScheduler::Add(UserProcess process)
+	{
+		if (mTeam.mProcessAmount > kSchedProcessLimitPerTeam)
+			return 0;
+
+#ifdef __ZKA_AMD64__
+		process.MemoryPD = reinterpret_cast<UIntPtr>(hal_read_cr3());
+#endif // __ZKA_AMD64__
+
+		process.Status = ProcessStatusKind::kStarting;
+
+		process.StackFrame = (HAL::StackFramePtr)mm_new_heap(sizeof(HAL::StackFrame), Yes, Yes);
+
+		if (!process.StackFrame)
+		{
+			process.Crash();
+			return -kErrorProcessFault;
+		}
+
+		// Create heap according to type of process.
+		if (process.Kind == UserProcess::kDLLKind)
+		{
+			process.DLLPtr = rtl_init_dll(&process);
+		}
+
+		if (!process.Image)
+		{
+			if (process.Kind != UserProcess::kDLLKind)
+			{
+				process.Crash();
+				return -kErrorProcessFault;
+			}
+		}
+
+		// get preferred stack size by app.
+		const auto cMaxStackSize = process.StackSize;
+		process.StackReserve	 = (UInt8*)mm_new_heap(sizeof(UInt8) * cMaxStackSize, Yes, Yes);
+
+		if (!process.StackReserve)
+		{
+			mm_delete_heap(process.StackFrame);
+			process.StackFrame = nullptr;
+			return -kErrorProcessFault;
+		}
+
+		++mTeam.mProcessAmount;
+
+		process.ProcessId = mTeam.mProcessAmount;
+		process.Status	  = ProcessStatusKind::kRunning;
+
+		// avoid the pitfalls of moving process.
+		auto ret_pid = process.ProcessId;
+
+		mTeam.AsArray()[process.ProcessId] = move(process);
+
+		return ret_pid;
+	}
+
+	/***********************************************************************************/
+
+	UserProcessScheduler& UserProcessScheduler::The()
+	{
+		MUST_PASS(cProcessScheduler);
+		return *cProcessScheduler;
+	}
+
+	/***********************************************************************************/
+
+	/// @brief Remove process from list.
+	/// @param process_id process slot inside team.
+	/// @retval true process was removed.
+	/// @retval false process doesn't exist in team.
+
+	/***********************************************************************************/
+
+	Bool UserProcessScheduler::Remove(ProcessID process_id)
+	{
+		// check if process is within range.
+		if (process_id > mTeam.AsArray().Count())
+			return false;
+
+		mTeam.AsArray()[process_id].Status = ProcessStatusKind::kDead;
+		--mTeam.mProcessAmount;
+
+		return true;
+	}
+
+	/***********************************************************************************/
+
+	/// @brief Run User scheduler object.
+	/// @return Process executed within team.
+
+	/***********************************************************************************/
+
+	SizeT UserProcessScheduler::Run() noexcept
+	{
+		SizeT process_index = 0; //! we store this guy to tell the scheduler how many
+								 //! things we have scheduled.
+
+		for (; process_index < mTeam.AsArray().Capacity(); ++process_index)
+		{
+			kcout << "Grabbing available process in team...\r";
+
+			auto& process = mTeam.AsArray()[process_index];
+
+			//! check if process needs to be scheduled.
+			if (UserProcessHelper::CanBeScheduled(process))
+			{
+				kcout << process.Name << ": will be runned.\r";
+
+				// Set current process header.
+				this->CurrentProcess() = process;
+
+				process.PTime = static_cast<Int32>(process.Affinity);
+
+				// tell helper to find a core to schedule on.
+				if (!UserProcessHelper::Switch(process.Image, &process.StackReserve[process.StackSize - 1], process.StackFrame,
+											   process.ProcessId))
+				{
+					process.Crash();
+					continue;
+				}
+			}
+		}
+
+		kcout << "Scheduled Process Count: " << number(process_index) << endl;
+
+		return process_index;
+	}
+
+	/// @brief Gets the current scheduled team.
+	/// @return
+	UserProcessTeam& UserProcessScheduler::CurrentTeam()
+	{
+		return mTeam;
+	}
+
+	/// @internal
+
+	/// @brief Gets current running process.
+	/// @return
+	Ref<UserProcess>& UserProcessScheduler::CurrentProcess()
+	{
+		return mTeam.AsRef();
+	}
+
+	/// @brief Current proccess id getter.
+	/// @return UserProcess ID integer.
+	PID& UserProcessHelper::TheCurrentPID()
+	{
+		kcout << "UserProcessHelper::TheCurrentPID: Leaking ProcessId...\r";
+		return cProcessScheduler->CurrentProcess().Leak().ProcessId;
+	}
+
+	/// @brief Check if process can be schedulded.
+	/// @param process the process reference.
+	/// @retval true can be schedulded.
+	/// @retval false cannot be schedulded.
+	bool UserProcessHelper::CanBeScheduled(const UserProcess& process)
+	{
+		kcout << "Checking process status...\r";
+
+		if (process.Status == ProcessStatusKind::kFrozen ||
+			process.Status == ProcessStatusKind::kDead)
+			return No;
+
+		if (!process.Image &&
+			process.Kind == UserProcess::kExeKind)
+			return No;
+
+		return Yes;
+	}
+
+	/**
+	 * @brief Scheduler helper class.
+	 */
+
+	EXTERN
+	HardwareThreadScheduler* cHardwareThreadScheduler;
+
+	SizeT UserProcessHelper::StartScheduling()
+	{
+		if (!cHardwareThreadScheduler)
+		{
+			cHardwareThreadScheduler = mm_new_class<HardwareThreadScheduler>();
+			MUST_PASS(cHardwareThreadScheduler);
+		}
+
+		if (!cProcessScheduler)
+		{
+			cProcessScheduler = mm_new_class<UserProcessScheduler>();
+			MUST_PASS(cProcessScheduler);
+		}
+
+		SizeT ret = cProcessScheduler->Run();
+		return ret;
+	}
+
+	/**
+	 * \brief Does a context switch in a CPU.
+	 * \param the_stack the stackframe of the running app.
+	 * \param new_pid the process's PID.
+	 */
+
+	Bool UserProcessHelper::Switch(VoidPtr image_ptr, UInt8* stack, HAL::StackFramePtr frame_ptr, const PID& new_pid)
+	{
+		if (!stack || !frame_ptr || !image_ptr || new_pid < 0)
+			return No;
+
+		for (SizeT index = 0UL; index < HardwareThreadScheduler::The().Count(); ++index)
+		{
+			if (HardwareThreadScheduler::The()[index].Leak()->Kind() == kInvalidHart)
+				continue;
+
+			if (HardwareThreadScheduler::The()[index].Leak()->Kind() !=
+					ThreadKind::kHartBoot &&
+				HardwareThreadScheduler::The()[index].Leak()->Kind() !=
+					ThreadKind::kHartSystemReserved)
+			{
+				PID prev_pid					   = UserProcessHelper::TheCurrentPID();
+				UserProcessHelper::TheCurrentPID() = new_pid;
+
+				auto prev_ptime										 = HardwareThreadScheduler::The()[index].Leak()->fPTime;
+				HardwareThreadScheduler::The()[index].Leak()->fPTime = UserProcessScheduler::The().CurrentTeam().AsArray()[new_pid].ProcessId;
+				Bool ret											 = HardwareThreadScheduler::The()[index].Leak()->Switch(image_ptr, stack, frame_ptr);
+
+				if (!ret)
+				{
+					HardwareThreadScheduler::The()[index].Leak()->fPTime = prev_ptime;
+					UserProcessHelper::TheCurrentPID()					 = prev_pid;
+
+					continue;
+				}
+			}
+		}
+
+		return false;
+	}
+
+	/// @brief this checks if any process is on the team.
+	UserProcessScheduler::operator bool()
+	{
+		return mTeam.AsArray().Count() > 0;
+	}
+
+	/// @brief this checks if no process is on the team.
+	bool UserProcessScheduler::operator!()
+	{
+		return mTeam.AsArray().Count() == 0;
+	}
+} // namespace Kernel
diff --git a/dev/zka/src/UserProcessTeam.cxx b/dev/zka/src/UserProcessTeam.cxx
new file mode 100644
index 00000000..bb5726f7
--- /dev/null
+++ b/dev/zka/src/UserProcessTeam.cxx
@@ -0,0 +1,38 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+------------------------------------------- */
+
+/***********************************************************************************/
+/// @file UserProcessTeam.cxx
+/// @brief UserProcess teams implementation.
+/***********************************************************************************/
+
+#include <KernelKit/UserProcessScheduler.hxx>
+
+namespace Kernel
+{
+	/// @brief UserProcess list array getter.
+	/// @return The list of process to schedule.
+	Array<UserProcess, kSchedProcessLimitPerTeam>& UserProcessTeam::AsArray()
+	{
+		return mProcessList;
+	}
+
+	/// @brief Get team ID.
+	/// @return The team's ID.
+	ProcessID& UserProcessTeam::Id() noexcept
+	{
+		return mTeamId;
+	}
+
+	/// @brief Current process getter.
+	/// @return The current process header.
+	Ref<UserProcess>& UserProcessTeam::AsRef()
+	{
+		return mCurrentProcess;
+	}
+} // namespace Kernel
+
+// last rev 05-03-24
diff --git a/dev/zka/src/UserThreadScheduler.cxx b/dev/zka/src/UserThreadScheduler.cxx
new file mode 100644
index 00000000..3fc9aee4
--- /dev/null
+++ b/dev/zka/src/UserThreadScheduler.cxx
@@ -0,0 +1,49 @@
+/*
+ * ========================================================
+ *
+ * newoskrnl
+ * Copyright ZKA Technologies., all rights reserved.
+ *
+ *  ========================================================
+ */
+
+#include <NewKit/String.hxx>
+#include <CFKit/Property.hxx>
+#include <KernelKit/UserProcessScheduler.hxx>
+
+namespace Kernel
+{
+	/// \brief UserProcess thread information header.
+	struct USER_THREAD_BLOCK final
+	{
+		STATIC constexpr SizeT cMaxLen = 256;
+
+		Char			  fName[cMaxLen] = {"THREAD #0 (PROCESS 0)"};
+		ProcessStatusKind fThreadStatus;
+		Int64			  fThreadID;
+		UserProcessPtr	  fProcess{nullptr};
+		VoidPtr			  fCode{nullptr};
+		VoidPtr			  fStack{nullptr};
+		VoidPtr			  fData{nullptr};
+
+		Void Exit() noexcept
+		{
+			this->fThreadStatus = ProcessStatusKind::kKilled;
+		}
+
+		VoidPtr GetStack() noexcept
+		{
+			return fStack;
+		}
+
+		VoidPtr GetData() noexcept
+		{
+			return fData;
+		}
+
+		VoidPtr GetPC() noexcept
+		{
+			return fCode;
+		}
+	};
+} // namespace Kernel
diff --git a/dev/zka/src/Utils.cxx b/dev/zka/src/Utils.cxx
new file mode 100644
index 00000000..8ecfd805
--- /dev/null
+++ b/dev/zka/src/Utils.cxx
@@ -0,0 +1,212 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+------------------------------------------- */
+
+#include <NewKit/Utils.hxx>
+#include <KernelKit/DebugOutput.hxx>
+
+namespace Kernel
+{
+	Int rt_string_cmp(const Char* src, const Char* cmp, Size size)
+	{
+		if (!cmp ||
+			!src)
+			return 1;
+
+		Int32 counter = 0;
+
+		for (Size index = 0; index < size; ++index)
+		{
+			if (src[index] != cmp[index])
+				++counter;
+		}
+
+		return counter;
+	}
+
+	void rt_zero_memory(voidPtr pointer, Size len)
+	{
+		rt_set_memory(pointer, 0, len);
+	}
+
+	Size rt_string_len(const Char* str, SizeT _len)
+	{
+		Size len{0};
+		while (str[len] != '\0')
+		{
+			if (len > _len)
+			{
+				return 0;
+			}
+
+			len++;
+		}
+
+		return len;
+	}
+
+	Size rt_string_len(const Char* ptr)
+	{
+		if (*ptr == 0)
+			return 0;
+
+		SizeT cnt = 0;
+
+		while (ptr[cnt] != (Char)0)
+		{
+			cnt++;
+		}
+
+		return cnt;
+	}
+
+	voidPtr rt_set_memory(voidPtr src, UInt32 value, Size len)
+	{
+		if (!src || len < 1)
+			return nullptr;
+
+		UInt32* start = reinterpret_cast<UInt32*>(src);
+
+		while (len)
+		{
+			*start = value;
+			++start;
+			--len;
+		}
+
+		return (voidPtr)start;
+	}
+
+	Int rt_move_memory(const voidPtr src, voidPtr dst, Size len)
+	{
+		if (len < 1)
+			return -2;
+		if (!src || !dst)
+			return -1;
+
+		char* srcChr  = reinterpret_cast<Char*>(src);
+		char* dstChar = reinterpret_cast<Char*>(dst);
+		Size  index	  = 0;
+
+		while (index < len)
+		{
+			dstChar[index] = srcChr[index];
+			srcChr[index]  = 0;
+
+			++index;
+		}
+
+		return 0;
+	}
+
+	Int rt_copy_memory(const voidPtr src, voidPtr dst, Size len)
+	{
+		if (len < 1)
+			return -2;
+
+		char* srcChr  = reinterpret_cast<char*>(src);
+		char* dstChar = reinterpret_cast<char*>(dst);
+		Size  index	  = 0;
+
+		while (index < len)
+		{
+			dstChar[index] = srcChr[index];
+			++index;
+		}
+
+		return index;
+	}
+
+	const Char* alloc_string(const Char* text)
+	{
+		if (!text)
+			return nullptr;
+
+		const Char* string = new Char[rt_string_len(text)];
+		if (!string)
+			return nullptr;
+
+		voidPtr vText = reinterpret_cast<voidPtr>(const_cast<char*>(text));
+		voidPtr vStr  = reinterpret_cast<voidPtr>(const_cast<char*>(string));
+		rt_copy_memory(vText, vStr, rt_string_len(text));
+
+		return string;
+	}
+
+	Int rt_to_uppercase(Int character)
+	{
+		if (character >= 'a' && character <= 'z')
+			return character - 0x20;
+
+		return character;
+	}
+
+	Int rt_to_lower(Int character)
+	{
+		if (character >= 'A' && character <= 'Z')
+			return character + 0x20;
+
+		return character;
+	}
+
+	bool rt_to_string(Char* str, Int limit, Int base)
+	{
+		if (limit == 0)
+			return false;
+
+		Int copy_limit = limit;
+		Int cnt		   = 0;
+		Int ret		   = base;
+
+		while (limit != 1)
+		{
+			ret		 = ret % 10;
+			str[cnt] = ret;
+
+			++cnt;
+			--limit;
+			--ret;
+		}
+
+		str[copy_limit] = '\0';
+		return true;
+	}
+
+	Boolean is_space(Char chr)
+	{
+		return chr == ' ';
+	}
+
+	Boolean is_newln(Char chr)
+	{
+		return chr == '\n';
+	}
+
+	voidPtr rt_string_in_string(const Char* in, const Char* needle)
+	{
+		for (SizeT i = 0; i < rt_string_len(in); ++i)
+		{
+			if (rt_string_cmp(in + i, needle, rt_string_len(needle)) == 0)
+				return reinterpret_cast<voidPtr>(const_cast<char*>(in + i));
+		}
+
+		return nullptr;
+	}
+
+	// @brief Checks for a string start at the character.
+
+	char* rt_string_has_char(char* str, const Char chr)
+	{
+		while (*str != chr)
+		{
+			++str;
+
+			if (*str == 0)
+				return nullptr;
+		}
+
+		return str;
+	}
+} // namespace Kernel
diff --git a/dev/zka/src/Variant.cxx b/dev/zka/src/Variant.cxx
new file mode 100644
index 00000000..e988d783
--- /dev/null
+++ b/dev/zka/src/Variant.cxx
@@ -0,0 +1,31 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+------------------------------------------- */
+
+#include <NewKit/Variant.hxx>
+
+namespace Kernel
+{
+	const Char* Variant::ToString()
+	{
+		switch (fKind)
+		{
+		case VariantKind::kJson:
+			return ("Class:{Json}");
+		case VariantKind::kString:
+			return ("Class:{String}");
+		case VariantKind::kBlob:
+			return ("Class:{Blob}");
+		default:
+			return ("Class:{Null}");
+		}
+	}
+
+	/// @brief Leak variant's instance.
+	VoidPtr Variant::Leak()
+	{
+		return fPtr;
+	}
+} // namespace Kernel