:boom: A big refactor on the filesystem structure.

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

22 files changed, 1657 insertions, 0 deletions

diff --git a/dev/zba/src/.gitkeep b/dev/zba/src/.gitkeep
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/dev/zba/src/.gitkeep
diff --git a/dev/zba/src/BootloaderRsrc.rsrc b/dev/zba/src/BootloaderRsrc.rsrc
new file mode 100644
index 00000000..6aa1d5a5
--- /dev/null
+++ b/dev/zba/src/BootloaderRsrc.rsrc
@@ -0,0 +1,25 @@
+#include "../../Kernel/CompilerKit/Version.hxx"
+
+1 VERSIONINFO
+FILEVERSION     1,0,0,0
+PRODUCTVERSION  1,0,0,0
+BEGIN
+  BLOCK "StringFileInfo"
+  BEGIN
+    BLOCK "080904E4"
+    BEGIN
+      VALUE "CompanyName", "ZKA Technologies"
+      VALUE "FileDescription", "New OS Loader."
+      VALUE "FileVersion", BOOTLOADER_VERSION
+      VALUE "InternalName", "newosldr"
+      VALUE "LegalCopyright", "Copyright ZKA Technologies., all rights reserved."
+      VALUE "OriginalFilename", "newosldr.exe"
+      VALUE "ProductName", "newosldr"
+      VALUE "ProductVersion", BOOTLOADER_VERSION
+    END
+  END
+  BLOCK "VarFileInfo"
+  BEGIN
+    VALUE "Translation", 0x809, 1252
+  END
+END
diff --git a/dev/zba/src/HEL/64X000/.gitkeep b/dev/zba/src/HEL/64X000/.gitkeep
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/dev/zba/src/HEL/64X000/.gitkeep
diff --git a/dev/zba/src/HEL/64X000/Boot64x0.S b/dev/zba/src/HEL/64X000/Boot64x0.S
new file mode 100644
index 00000000..cd9662f2
--- /dev/null
+++ b/dev/zba/src/HEL/64X000/Boot64x0.S
@@ -0,0 +1,35 @@
+/* -------------------------------------------
+
+    Copyright ZKA Technologies.
+
+------------------------------------------- */
+
+.section .boot_hdr
+.align 4
+
+/* NewBoot boot header begin for a 64x000 Kernel. */
+
+boot_hdr_mag:
+        .ascii "CB"
+boot_hdr_name:
+        // it has to match ten bytes.
+        .asciz "newosldr\0\0"
+boot_hdr_ver:
+        .word 0x104
+boot_hdr_proc:
+        .long bootloader_start
+
+/* NewBoot boot header end */
+
+.extern bootloader_main
+.extern bootloader_stack
+
+.globl bootloader_start
+bootloader_start:
+    psh	4			/* real address of .Laddr */
+    ldi     0,(bootloader_stack-bootloader_start)(4)	/* stack address location */
+    mv	19,0			/* use user defined stack */
+    jrl
+
+    bl bootloader_main
+    blr
diff --git a/dev/zba/src/HEL/AMD64/.gitkeep b/dev/zba/src/HEL/AMD64/.gitkeep
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/dev/zba/src/HEL/AMD64/.gitkeep
diff --git a/dev/zba/src/HEL/AMD64/BootAHCI.cxx b/dev/zba/src/HEL/AMD64/BootAHCI.cxx
new file mode 100644
index 00000000..776f3f88
--- /dev/null
+++ b/dev/zba/src/HEL/AMD64/BootAHCI.cxx
@@ -0,0 +1,20 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+------------------------------------------- */
+
+/**
+ * @file AHCI.cxx
+ * @author Amlal El Mahrouss (amlalelmahrouss@icloud.com)
+ * @brief AHCI driver.
+ * @version 0.1
+ * @date 2024-02-02
+ *
+ * @copyright Copyright (c) ZKA Technologies
+ *
+ */
+
+#include <BootKit/Platform.hxx>
+#include <BootKit/Protocol.hxx>
+#include <BootKit/HW/SATA.hxx>
diff --git a/dev/zba/src/HEL/AMD64/BootAPI.S b/dev/zba/src/HEL/AMD64/BootAPI.S
new file mode 100644
index 00000000..47f250f1
--- /dev/null
+++ b/dev/zba/src/HEL/AMD64/BootAPI.S
@@ -0,0 +1,52 @@
+.global rt_jump_to_address
+.global rt_reset_hardware
+
+.text
+
+.intel_syntax noprefix
+
+/**
+ @brief this function setups a stack and then jumps to
+ a function */
+rt_jump_to_address:
+    mov rbx, rcx
+    mov rcx, rdx
+    jmp rbx
+
+    ret
+
+rt_reset_hardware:
+    /* dont raise any interrupts. (except ofc NMIs.) */
+    cli
+    /* remap PIC */
+wait_gate1:
+    in al,0x64
+    and al,2
+    jnz wait_gate1
+    mov al,0x0D1
+    out 0x64,al
+wait_gate2:
+    in al,0x64
+    and al,2
+    jnz wait_gate2
+    mov al,0x0FE
+    out 0x60,al
+
+    /* trigger triple fault, by writing to cr4 */
+
+    mov rax, 0
+    lidt [rax]
+
+reset_wait:
+    jmp reset_wait
+
+.global boot_write_cr3
+.global boot_read_cr3
+
+boot_read_cr3:
+    mov rax, rax
+    ret
+
+boot_write_cr3:
+    mov cr3, rcx
+    ret
diff --git a/dev/zba/src/HEL/AMD64/BootATA.cxx b/dev/zba/src/HEL/AMD64/BootATA.cxx
new file mode 100644
index 00000000..0595f49c
--- /dev/null
+++ b/dev/zba/src/HEL/AMD64/BootATA.cxx
@@ -0,0 +1,278 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+------------------------------------------- */
+
+/**
+ * @file ATA.cxx
+ * @author Amlal El Mahrouss (amlalelmahrouss@icloud.com)
+ * @brief ATA driver.
+ * @version 0.1
+ * @date 2024-02-02
+ *
+ * @copyright Copyright (c) ZKA Technologies
+ *
+ */
+
+#include <FirmwareKit/EFI.hxx>
+#include <BootKit/BootKit.hxx>
+#include <BootKit/HW/ATA.hxx>
+
+/// bugs: 0
+
+using namespace Boot;
+
+#define kATADataLen 256
+
+static Boolean kATADetected			 = false;
+static Int32   kATADeviceType		 = kATADeviceCount;
+static UInt16  kATAData[kATADataLen] = {0};
+
+Boolean boot_ata_detected(Void);
+
+STATIC Boolean boot_ata_wait_io(UInt16 IO)
+{
+	for (int i = 0; i < 400; i++)
+		In8(IO + ATA_REG_STATUS);
+
+ATAWaitForIO_Retry:
+	auto statRdy = In8(IO + ATA_REG_STATUS);
+
+	if ((statRdy & ATA_SR_BSY))
+		goto ATAWaitForIO_Retry;
+
+ATAWaitForIO_Retry2:
+	statRdy = In8(IO + ATA_REG_STATUS);
+
+	if (statRdy & ATA_SR_ERR)
+		return false;
+
+	if (!(statRdy & ATA_SR_DRDY))
+		goto ATAWaitForIO_Retry2;
+
+	return true;
+}
+
+Void boot_ata_select(UInt16 Bus)
+{
+	if (Bus == ATA_PRIMARY_IO)
+		Out8(Bus + ATA_REG_HDDEVSEL, ATA_PRIMARY_SEL);
+	else
+		Out8(Bus + ATA_REG_HDDEVSEL, ATA_SECONDARY_SEL);
+}
+
+Boolean boot_ata_init(UInt16 Bus, UInt8 Drive, UInt16& OutBus, UInt8& OutMaster)
+{
+	if (boot_ata_detected())
+		return true;
+
+	BTextWriter writer;
+
+	UInt16 IO = Bus;
+
+	boot_ata_select(IO);
+
+	// Bus init, NEIN bit.
+	Out8(IO + ATA_REG_NEIN, 1);
+
+	// identify until it's good.
+ATAInit_Retry:
+	auto statRdy = In8(IO + ATA_REG_STATUS);
+
+	if (statRdy & ATA_SR_ERR)
+	{
+		writer.Write(
+			L"NEWOSLDR: ATA: Select error, not an IDE based hard-drive.\r");
+
+		return false;
+	}
+
+	if ((statRdy & ATA_SR_BSY))
+		goto ATAInit_Retry;
+
+	Out8(IO + ATA_REG_COMMAND, ATA_CMD_IDENTIFY);
+
+	/// fetch serial info
+	/// model, speed, number of sectors...
+
+	boot_ata_wait_io(IO);
+
+	for (SizeT indexData = 0ul; indexData < kATADataLen; ++indexData)
+	{
+		kATAData[indexData] = In16(IO + ATA_REG_DATA);
+	}
+
+	OutBus =
+		(Bus == ATA_PRIMARY_IO) ? BootDeviceATA::kPrimary : BootDeviceATA::kSecondary;
+
+	OutMaster = (Bus == ATA_PRIMARY_IO) ? ATA_MASTER : ATA_SLAVE;
+
+	return true;
+}
+
+Void boot_ata_read(UInt64 Lba, UInt16 IO, UInt8 Master, CharacterTypeUTF8* Buf, SizeT SectorSz, SizeT Size)
+{
+	Lba /= SectorSz;
+
+	UInt8 Command = ((!Master) ? 0xE0 : 0xF0);
+
+	boot_ata_wait_io(IO);
+	boot_ata_select(IO);
+
+	Out8(IO + ATA_REG_HDDEVSEL, (Command) | (((Lba) >> 24) & 0x0F));
+
+	Out8(IO + ATA_REG_SEC_COUNT0, ((Size + SectorSz) / SectorSz));
+
+	Out8(IO + ATA_REG_LBA0, (Lba) & 0xFF);
+	Out8(IO + ATA_REG_LBA1, (Lba) >> 8);
+	Out8(IO + ATA_REG_LBA2, (Lba) >> 16);
+	Out8(IO + ATA_REG_LBA3, (Lba) >> 24);
+
+	Out8(IO + ATA_REG_COMMAND, ATA_CMD_READ_PIO);
+
+	boot_ata_wait_io(IO);
+
+	for (SizeT IndexOff = 0; IndexOff < Size; ++IndexOff)
+	{
+		boot_ata_wait_io(IO);
+		Buf[IndexOff] = In16(IO + ATA_REG_DATA);
+		boot_ata_wait_io(IO);
+	}
+}
+
+Void boot_ata_write(UInt64 Lba, UInt16 IO, UInt8 Master, CharacterTypeUTF8* Buf, SizeT SectorSz, SizeT Size)
+{
+	Lba /= SectorSz;
+
+	UInt8 Command = ((!Master) ? 0xE0 : 0xF0);
+
+	boot_ata_wait_io(IO);
+	boot_ata_select(IO);
+
+	Out8(IO + ATA_REG_HDDEVSEL, (Command) | (((Lba) >> 24) & 0x0F));
+
+	Out8(IO + ATA_REG_SEC_COUNT0, ((Size + (SectorSz)) / SectorSz));
+
+	Out8(IO + ATA_REG_LBA0, (Lba) & 0xFF);
+	Out8(IO + ATA_REG_LBA1, (Lba) >> 8);
+	Out8(IO + ATA_REG_LBA2, (Lba) >> 16);
+	Out8(IO + ATA_REG_LBA3, (Lba) >> 24);
+
+	Out8(IO + ATA_REG_COMMAND, ATA_CMD_WRITE_PIO);
+
+	boot_ata_wait_io(IO);
+
+	for (SizeT IndexOff = 0; IndexOff < Size; ++IndexOff)
+	{
+		boot_ata_wait_io(IO);
+		Out16(IO + ATA_REG_DATA, Buf[IndexOff]);
+		boot_ata_wait_io(IO);
+	}
+}
+
+/// @check is ATA detected?
+Boolean boot_ata_detected(Void)
+{
+	return kATADetected;
+}
+
+/***
+ *
+ *
+ * @brief ATA Device class.
+ *
+ *
+ */
+
+/**
+ * @brief ATA Device constructor.
+ * @param void none.
+ */
+BootDeviceATA::BootDeviceATA() noexcept
+{
+	if (boot_ata_init(ATA_PRIMARY_IO, true, this->Leak().mBus,
+					  this->Leak().mMaster) ||
+		boot_ata_init(ATA_SECONDARY_IO, true, this->Leak().mBus,
+					  this->Leak().mMaster))
+	{
+		kATADetected = true;
+	}
+}
+/**
+ * @brief Is ATA detected?
+ */
+BootDeviceATA::operator bool()
+{
+	return boot_ata_detected();
+}
+
+/**
+	@brief Read Buf from disk
+	@param Sz Sector size
+	@param Buf buffer
+*/
+BootDeviceATA& BootDeviceATA::Read(CharacterTypeUTF8* Buf, const SizeT& SectorSz)
+{
+	if (!boot_ata_detected())
+	{
+		Leak().mErr = true;
+		return *this;
+	}
+
+	this->Leak().mErr = false;
+
+	if (!Buf || SectorSz < 1)
+		return *this;
+
+	boot_ata_read(this->Leak().mBase, this->Leak().mBus, this->Leak().mMaster,
+				  Buf, SectorSz, this->Leak().mSize);
+
+	return *this;
+}
+
+/**
+	@brief Write Buf into disk
+	@param Sz Sector size
+	@param Buf buffer
+*/
+BootDeviceATA& BootDeviceATA::Write(CharacterTypeUTF8* Buf, const SizeT& SectorSz)
+{
+	if (!boot_ata_detected())
+	{
+		Leak().mErr = true;
+		return *this;
+	}
+
+	Leak().mErr = false;
+
+	if (!Buf || SectorSz < 1)
+		return *this;
+
+	boot_ata_write(this->Leak().mBase, this->Leak().mBus, this->Leak().mMaster,
+				   Buf, SectorSz, this->Leak().mSize);
+
+	return *this;
+}
+
+/**
+ * @brief ATA trait getter.
+ * @return BootDeviceATA::ATATrait& the drive config.
+ */
+BootDeviceATA::ATATrait& BootDeviceATA::Leak()
+{
+	return mTrait;
+}
+
+/***
+	@brief Getter, gets the number of sectors inside the drive.
+*/
+SizeT BootDeviceATA::GetSectorsCount() noexcept
+{
+	return (kATAData[61] << 16) | kATAData[60];
+}
+
+SizeT BootDeviceATA::GetDiskSize() noexcept
+{
+	return this->GetSectorsCount() * BootDeviceATA::kSectorSize;
+}
diff --git a/dev/zba/src/HEL/AMD64/BootFileReader.cxx b/dev/zba/src/HEL/AMD64/BootFileReader.cxx
new file mode 100644
index 00000000..ffbcf413
--- /dev/null
+++ b/dev/zba/src/HEL/AMD64/BootFileReader.cxx
@@ -0,0 +1,203 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+	File: FileReader.cxx
+	Purpose: New Boot FileReader,
+	Read complete file and store it in a buffer.
+
+------------------------------------------- */
+
+#include <BootKit/Platform.hxx>
+#include <BootKit/Protocol.hxx>
+#include <BootKit/BootKit.hxx>
+#include <FirmwareKit/Handover.hxx>
+#include <FirmwareKit/EFI/API.hxx>
+#include <Modules/CoreCG/TextRenderer.hxx>
+
+/// @file BootFileReader
+/// @brief Bootloader File reader.
+/// BUGS: 0
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+///
+///
+///  @name BFileReader class
+///  @brief Reads the file as a blob.
+///
+///
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+/***
+	@brief File Reader constructor.
+*/
+Boot::BFileReader::BFileReader(const CharacterTypeUTF16* path,
+							   EfiHandlePtr				 ImageHandle)
+{
+	if (path != nullptr)
+	{
+		SizeT index = 0UL;
+		for (; path[index] != L'\0'; ++index)
+		{
+			mPath[index] = path[index];
+		}
+
+		mPath[index] = 0;
+	}
+
+	/// Load protocols with their GUIDs.
+
+	EfiGUID guidEfp = EfiGUID(EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_GUID);
+
+	EfiSimpleFilesystemProtocol* efp = nullptr;
+
+	EfiLoadImageProtocol* img	  = nullptr;
+	EfiGUID				  guidImg = EfiGUID(EFI_LOADED_IMAGE_PROTOCOL_GUID);
+
+	if (BS->HandleProtocol(ImageHandle, &guidImg, (void**)&img) != kEfiOk)
+	{
+		mWriter.Write(L"NEWOSLDR: Handle-Protocol: No-Such-Protocol").Write(L"\r");
+		this->mErrorCode = kNotSupported;
+	}
+
+	if (BS->HandleProtocol(img->DeviceHandle, &guidEfp, (void**)&efp) != kEfiOk)
+	{
+		mWriter.Write(L"NEWOSLDR: Handle-Protocol: No-Such-Protocol").Write(L"\r");
+		this->mErrorCode = kNotSupported;
+		return;
+	}
+
+	/// Start doing disk I/O
+
+	if (efp->OpenVolume(efp, &mRootFs) != kEfiOk)
+	{
+		mWriter.Write(L"NEWOSLDR: Fetch-Protocol: No-Such-Volume").Write(L"\r");
+		this->mErrorCode = kNotSupported;
+		return;
+	}
+
+	EfiFileProtocol* KernelFile = nullptr;
+
+	if (mRootFs->Open(mRootFs, &KernelFile, mPath, kEFIFileRead, kEFIReadOnly) !=
+		kEfiOk)
+	{
+		mWriter.Write(L"NEWOSLDR: Fetch-Protocol: No-Such-Path: ")
+			.Write(mPath)
+			.Write(L"\r");
+		this->mErrorCode = kNotSupported;
+
+		CGDrawString("NEWOSLDR: PLEASE RECOVER YOUR NEWOSKRNL INSTALL.", 40, 10, RGB(0xFF, 0xFF, 0xFF));
+
+		mRootFs->Close(mRootFs);
+
+		return;
+	}
+
+	mSizeFile  = 0;
+	mFile	   = KernelFile;
+	mErrorCode = kOperationOkay;
+}
+
+Boot::BFileReader::~BFileReader()
+{
+	if (this->mFile)
+	{
+		this->mFile->Close(this->mFile);
+		this->mFile = nullptr;
+	}
+
+	if (this->mRootFs)
+	{
+		this->mRootFs->Close(this->mRootFs);
+		this->mRootFs = nullptr;
+	}
+
+	if (this->mBlob)
+	{
+		BS->FreePool(this->mBlob);
+		this->mBlob = nullptr;
+	}
+
+	BSetMem(this->mPath, 0, kPathLen);
+}
+
+/**
+	@brief Reads all of the file into a buffer.
+	@param **readUntil** size of file
+	@param **chunkToRead** chunk to read each time.
+*/
+Void Boot::BFileReader::ReadAll(SizeT readUntil, SizeT chunkToRead, UIntPtr outAddress)
+{
+	if (mBlob == nullptr)
+	{
+		EfiFileInfo newPtrInfo;
+		UInt32		szInfo = 0;
+
+		EfiGUID cFileInfoGUID = EFI_FILE_INFO_GUID;
+
+		if (mFile->GetInfo(mFile, &cFileInfoGUID, &szInfo, &newPtrInfo) == kEfiOk)
+		{
+			if (newPtrInfo.FileSize < readUntil)
+				readUntil = newPtrInfo.FileSize;
+			else if (readUntil < 1)
+				readUntil = newPtrInfo.FileSize;
+
+			mWriter.Write(L"NEWOSLDR: Physical size: ").Write(readUntil).Write("\r");
+		}
+
+		if (!outAddress)
+		{
+			if (auto err = BS->AllocatePool(EfiLoaderCode, readUntil, (VoidPtr*)&mBlob) !=
+						   kEfiOk)
+			{
+				mWriter.Write(L"*** error: ").Write(err).Write(L" ***\r");
+				EFI::ThrowError(L"OutOfMemory", L"Out of memory.");
+			}
+		}
+		else
+		{
+			mBlob = (VoidPtr)outAddress;
+		}
+	}
+
+	mErrorCode = kNotSupported;
+
+	UInt64 bufSize = chunkToRead;
+	UInt64 szCnt   = 0UL;
+
+	while (szCnt < readUntil)
+	{
+		auto res = mFile->Read(mFile, &bufSize, (VoidPtr)(&((Char*)mBlob)[szCnt]));
+
+		szCnt += bufSize;
+
+		if (res == kBufferTooSmall)
+		{
+			bufSize = chunkToRead;
+		}
+	}
+
+	mSizeFile  = szCnt;
+	mErrorCode = kOperationOkay;
+}
+
+/// @brief error code getter.
+/// @return the error code.
+Int32& Boot::BFileReader::Error()
+{
+	return mErrorCode;
+}
+
+/// @brief blob getter.
+/// @return the blob.
+VoidPtr Boot::BFileReader::Blob()
+{
+	return mBlob;
+}
+
+/// @breif Size getter.
+/// @return the size of the file.
+UInt64& Boot::BFileReader::Size()
+{
+	return mSizeFile;
+}
diff --git a/dev/zba/src/HEL/AMD64/BootMain.cxx b/dev/zba/src/HEL/AMD64/BootMain.cxx
new file mode 100644
index 00000000..5557f8dd
--- /dev/null
+++ b/dev/zba/src/HEL/AMD64/BootMain.cxx
@@ -0,0 +1,317 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+------------------------------------------- */
+
+#include <BootKit/BootKit.hxx>
+#include <BootKit/Rsrc/NewBoot.rsrc>
+#include <Modules/CoreCG/FbRenderer.hxx>
+#include <Modules/CoreCG/TextRenderer.hxx>
+#include <FirmwareKit/EFI.hxx>
+#include <FirmwareKit/EFI/API.hxx>
+#include <FirmwareKit/Handover.hxx>
+#include <KernelKit/MSDOS.hxx>
+#include <KernelKit/PE.hxx>
+#include <KernelKit/PEF.hxx>
+#include <NewKit/Macros.hxx>
+#include <NewKit/Ref.hxx>
+#include <BootKit/Thread.hxx>
+#include <cstring>
+
+// make the compiler shut up.
+#ifndef kMachineModel
+#define kMachineModel "ZKA SSD"
+#endif // !kMachineModel
+
+#ifndef cExpectedWidth
+#define cExpectedWidth 1280
+#endif
+
+#ifndef cExpectedHeight
+#define cExpectedHeight 720
+#endif
+
+/** Graphics related. */
+
+STATIC EfiGraphicsOutputProtocol* kGop	  = nullptr;
+STATIC UInt16					  kStride = 0U;
+STATIC EfiGUID					  kGopGuid;
+
+EXTERN_C Void rt_reset_hardware();
+
+/**
+	@brief Finds and stores the GOP.
+*/
+
+STATIC Void InitVideoFB() noexcept
+{
+	kGopGuid = EfiGUID(EFI_GRAPHICS_OUTPUT_PROTOCOL_GUID);
+	kGop	 = nullptr;
+
+	extern EfiBootServices* BS;
+
+	BS->LocateProtocol(&kGopGuid, nullptr, (VoidPtr*)&kGop);
+
+	kStride = 4;
+
+	for (SizeT i = 0; i < kGop->Mode->MaxMode; ++i)
+	{
+		EfiGraphicsOutputProtocolModeInformation* infoPtr = nullptr;
+		UInt32									  sz	  = 0U;
+
+		kGop->QueryMode(kGop, i, &sz, &infoPtr);
+
+		if (infoPtr->HorizontalResolution == cExpectedWidth &&
+			infoPtr->VerticalResolution == cExpectedHeight)
+		{
+			kGop->SetMode(kGop, i);
+			break;
+		}
+	}
+}
+
+/// @brief check the BootDevice if suitable.
+STATIC Bool CheckBootDevice(BootDeviceATA& ataDev)
+{
+	if (ataDev.Leak().mErr)
+		return false;
+	return true;
+}
+
+EXTERN_C VoidPtr boot_read_cr3();
+EXTERN_C Void	 boot_write_cr3(VoidPtr new_cr3);
+
+EXTERN EfiBootServices* BS;
+
+/// @brief Main EFI entrypoint.
+/// @param ImageHandle Handle of this image.
+/// @param SystemTable The system table of it.
+/// @return nothing, never returns.
+EFI_EXTERN_C EFI_API Int Main(EfiHandlePtr	  ImageHandle,
+							  EfiSystemTable* SystemTable)
+{
+	InitEFI(SystemTable); ///! Init the EFI library.
+	InitVideoFB();		  ///! Init the GOP.
+
+	UInt32				 MapKey		= 0;
+	UInt32				 SizePtr	= sizeof(EfiMemoryDescriptor);
+	EfiMemoryDescriptor* Descriptor = nullptr;
+	UInt32				 SzDesc		= sizeof(EfiMemoryDescriptor);
+	UInt32				 RevDesc	= 0;
+
+	HEL::HANDOVER_INFO_HEADER* handover_hdr =
+		new HEL::HANDOVER_INFO_HEADER();
+
+	for (SizeT indexVT = 0; indexVT < SystemTable->NumberOfTableEntries;
+		 ++indexVT)
+	{
+		Char* vendorTable = reinterpret_cast<Char*>(
+			SystemTable->ConfigurationTable[indexVT].VendorTable);
+
+		/// ACPI's 'RSD PTR', which contains hardware tables (MADT, FACP...)
+		if (vendorTable[0] == 'R' && vendorTable[1] == 'S' &&
+			vendorTable[2] == 'D' && vendorTable[3] == ' ' &&
+			vendorTable[4] == 'P' && vendorTable[5] == 'T' &&
+			vendorTable[6] == 'R' && vendorTable[7] == ' ')
+		{
+			handover_hdr->f_HardwareTables.f_VendorPtr = (VoidPtr)vendorTable;
+			break;
+		}
+	}
+
+	// ------------------------------------------ //
+	// draw background color.
+	// ------------------------------------------ //
+
+	handover_hdr->f_GOP.f_The		   = kGop->Mode->FrameBufferBase;
+	handover_hdr->f_GOP.f_Width		   = kGop->Mode->Info->VerticalResolution;
+	handover_hdr->f_GOP.f_Height	   = kGop->Mode->Info->HorizontalResolution;
+	handover_hdr->f_GOP.f_PixelPerLine = kGop->Mode->Info->PixelsPerScanLine;
+	handover_hdr->f_GOP.f_PixelFormat  = kGop->Mode->Info->PixelFormat;
+	handover_hdr->f_GOP.f_Size		   = kGop->Mode->FrameBufferSize;
+
+	// ------------------------------------------- //
+	// Grab MP services, extended to runtime.	   //
+	// ------------------------------------------- //
+
+	auto				   guid_mp = EfiGUID(EFI_MP_SERVICES_PROTOCOL_GUID);
+	EfiMpServicesProtocol* mp	   = nullptr;
+
+	BS->LocateProtocol(&guid_mp, nullptr, reinterpret_cast<VoidPtr*>(&mp));
+
+	handover_hdr->f_HardwareTables.f_MpPtr = reinterpret_cast<VoidPtr>(mp);
+
+	kHandoverHeader = handover_hdr;
+
+	CGInit();
+	CGDrawInRegion(CGColor(0xFF, 0x3A, 0x3A), handover_hdr->f_GOP.f_Height, handover_hdr->f_GOP.f_Width, 0, 0);
+	CGFini();
+
+	UInt32 cnt_enabled	= 0;
+	UInt32 cnt_disabled = 0;
+
+	mp->GetNumberOfProcessors(mp, &cnt_disabled, &cnt_enabled);
+
+	CGDrawString("NEWOSLDR (C) ZKA TECHNOLOGIES.", 10, 10, RGB(0xFF, 0xFF, 0xFF));
+	CGDrawString((cnt_enabled > 1) ? "MULTIPLE PROCESSORS DETECTED." : "SINGLE PROCESSOR DETECTED.", 20, 10, RGB(0xFF, 0xFF, 0xFF));
+
+	handover_hdr->f_HardwareTables.f_MultiProcessingEnabled = cnt_enabled > 1;
+	// Fill handover header now.
+
+	Boot::BDiskFormatFactory<BootDeviceATA> checkPart;
+
+	// ---------------------------------------------------- //
+	// The following checks for an exisiting partition
+	// inside the disk, if it doesn't have one,
+	// format the disk.
+	// ---------------------------------------------------- //
+
+	if (!checkPart.IsPartitionValid())
+	{
+		Boot::BDiskFormatFactory<BootDeviceATA>::BFileDescriptor root;
+		root.fFileName[0] = kNeFSRoot[0];
+		root.fFileName[1] = 0;
+
+		root.fKind = kNeFSCatalogKindDir;
+
+		checkPart.Format("FileSystem (A:)", &root, 1);
+
+		rt_reset_hardware();
+	}
+
+	BS->GetMemoryMap(&SizePtr, Descriptor, &MapKey, &SzDesc, &RevDesc);
+
+	Descriptor = new EfiMemoryDescriptor[SzDesc];
+	BS->GetMemoryMap(&SizePtr, Descriptor, &MapKey, &SzDesc, &RevDesc);
+
+	auto cDefaultMemoryMap = 0; // Grab any usable entries.
+
+	//-----------------------------------------------------------//
+	// A simple loop which finds a usable memory region for us.
+	//-----------------------------------------------------------//
+
+	SizeT lookIndex = 0UL;
+
+	for (; Descriptor[lookIndex].Kind != EfiMemoryType::EfiConventionalMemory; ++lookIndex)
+	{
+		ZKA_UNUSED(0);
+	}
+
+	cDefaultMemoryMap = lookIndex;
+
+	//-----------------------------------------------------------//
+	// Update handover file specific table and phyiscal start field.
+	//-----------------------------------------------------------//
+
+	handover_hdr->f_BitMapStart = nullptr;			 /* # of pages */
+	handover_hdr->f_BitMapSize	= kHandoverBitMapSz; /* # of pages */
+
+	while (BS->AllocatePool(EfiLoaderData, handover_hdr->f_BitMapSize, &handover_hdr->f_BitMapStart) != kEfiOk)
+	{
+		if (handover_hdr->f_BitMapStart)
+		{
+			BS->FreePool(handover_hdr->f_BitMapStart);
+			handover_hdr->f_BitMapStart = nullptr;
+		}
+	}
+
+	handover_hdr->f_FirmwareCustomTables[0] = (VoidPtr)BS;
+	handover_hdr->f_FirmwareCustomTables[1] = (VoidPtr)ST;
+
+	Boot::BFileReader readerSysChk(L"syschk.sys", ImageHandle);
+	readerSysChk.ReadAll(0);
+
+	Boot::BThread* loaderSysChk = nullptr;
+
+	// ------------------------------------------ //
+	// If we succeed in reading the blob, then execute it.
+	// ------------------------------------------ //
+
+	if (readerSysChk.Blob())
+	{
+		loaderSysChk = new Boot::BThread(readerSysChk.Blob());
+		loaderSysChk->SetName("System Check SYS.");
+	}
+
+	loaderSysChk->Start(handover_hdr);
+
+	// nullify these fields, to avoid being reused later.
+
+	handover_hdr->f_FirmwareCustomTables[0] = nullptr;
+	handover_hdr->f_FirmwareCustomTables[1] = nullptr;
+
+	handover_hdr->f_FirmwareVendorLen = Boot::BStrLen(SystemTable->FirmwareVendor);
+
+	handover_hdr->f_Magic	= kHandoverMagic;
+	handover_hdr->f_Version = kHandoverVersion;
+
+	// Provide fimware vendor name.
+
+	Boot::BCopyMem(handover_hdr->f_FirmwareVendorName, SystemTable->FirmwareVendor,
+				   handover_hdr->f_FirmwareVendorLen);
+
+	handover_hdr->f_FirmwareVendorLen = Boot::BStrLen(SystemTable->FirmwareVendor);
+
+	// Assign to global 'kHandoverHeader'.
+
+	Boot::BFileReader readerKernel(L"newoskrnl.exe", ImageHandle);
+
+	readerKernel.ReadAll(0);
+
+	Boot::BThread* loader = nullptr;
+
+	// ------------------------------------------ //
+	// If we succeed in reading the blob, then execute it.
+	// ------------------------------------------ //
+
+	if (readerKernel.Blob())
+	{
+		loader = new Boot::BThread(readerKernel.Blob());
+		loader->SetName("64-Bit Kernel EXE.");
+
+		handover_hdr->f_KernelImage = readerKernel.Blob();
+	}
+	else
+	{
+		CGDrawString("NEWOSLDR: PLEASE RECOVER YOUR NEWOSKRNL KERNEL DLL.", 30, 10, RGB(0xFF, 0xFF, 0xFF));
+	}
+
+	Boot::BFileReader chimeWav(L"ZKA\\startup.wav", ImageHandle);
+	Boot::BFileReader readerSysDrv(L"ZKA\\startup.sys", ImageHandle);
+	Boot::BFileReader urbanistTTF(L"ZKA\\urbanist.ttf", ImageHandle);
+
+	readerSysDrv.ReadAll(0);
+	chimeWav.ReadAll(0);
+	urbanistTTF.ReadAll(0);
+
+	if (readerSysDrv.Blob() &&
+		chimeWav.Blob() &&
+		urbanistTTF.Blob())
+	{
+		handover_hdr->f_StartupChime   = chimeWav.Blob();
+		handover_hdr->f_ChimeSz		   = chimeWav.Size();
+		handover_hdr->f_StartupImage   = readerSysDrv.Blob();
+		handover_hdr->f_StartupSz	   = readerSysDrv.Size();
+		handover_hdr->f_KernelImage	   = readerKernel.Blob();
+		handover_hdr->f_KernelSz	   = readerKernel.Size();
+		handover_hdr->f_TTFallbackFont = urbanistTTF.Blob();
+		handover_hdr->f_FontSz		   = urbanistTTF.Size();
+	}
+	else
+	{
+		CGDrawString("NEWOSLDR: ONE OR MORE SYSTEM COMPONENTS ARE MISSING, PLEASE REINSTALL THE OS.", 30, 10, RGB(0xFF, 0xFF, 0xFF));
+	}
+
+	EFI::ExitBootServices(MapKey, ImageHandle);
+
+	// ---------------------------------------------------- //
+	// Finally load Kernel, and the cr3 to it.
+	// ---------------------------------------------------- //
+
+	loader->Start(handover_hdr);
+
+	EFI::Stop();
+
+	CANT_REACH();
+}
diff --git a/dev/zba/src/HEL/AMD64/BootPlatform.cxx b/dev/zba/src/HEL/AMD64/BootPlatform.cxx
new file mode 100644
index 00000000..31566a95
--- /dev/null
+++ b/dev/zba/src/HEL/AMD64/BootPlatform.cxx
@@ -0,0 +1,105 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+------------------------------------------- */
+
+#include <BootKit/Platform.hxx>
+#include <BootKit/Protocol.hxx>
+#include <BootKit/BootKit.hxx>
+
+#ifdef __STANDALONE__
+
+using namespace Boot;
+
+EXTERN_C void rt_hlt()
+{
+	asm volatile("hlt");
+}
+
+EXTERN_C void rt_cli()
+{
+	asm volatile("cli");
+}
+
+EXTERN_C void rt_sti()
+{
+	asm volatile("sti");
+}
+
+EXTERN_C void rt_cld()
+{
+	asm volatile("cld");
+}
+
+EXTERN_C void rt_std()
+{
+	asm volatile("std");
+}
+
+EXTERN_C void Out8(UInt16 port, UInt8 value)
+{
+	asm volatile("outb %%al, %1"
+				 :
+				 : "a"(value), "Nd"(port)
+				 : "memory");
+}
+
+EXTERN_C void Out16(UInt16 port, UInt16 value)
+{
+	asm volatile("outw %%ax, %1"
+				 :
+				 : "a"(value), "Nd"(port)
+				 : "memory");
+}
+
+EXTERN_C void Out32(UInt16 port, UInt32 value)
+{
+	asm volatile("outl %%eax, %1"
+				 :
+				 : "a"(value), "Nd"(port)
+				 : "memory");
+}
+
+EXTERN_C UInt8 In8(UInt16 port)
+{
+	UInt8 value;
+	asm volatile("inb %1, %%al"
+				 : "=a"(value)
+				 : "Nd"(port)
+				 : "memory");
+
+	return value;
+}
+
+EXTERN_C UInt16 In16(UInt16 port)
+{
+	UInt16 value;
+	asm volatile("inw %%dx, %%ax"
+				 : "=a"(value)
+				 : "d"(port));
+
+	return value;
+}
+
+EXTERN_C UInt32 In32(UInt16 port)
+{
+	UInt32 value;
+	asm volatile("inl %1, %%eax"
+				 : "=a"(value)
+				 : "Nd"(port)
+				 : "memory");
+
+	return value;
+}
+
+#else
+
+#include <HALKit/AMD64/Processor.hxx>
+
+void rt_hlt()
+{
+	Kernel::HAL::rt_halt();
+}
+
+#endif // 0
diff --git a/dev/zba/src/HEL/AMD64/BootString.cxx b/dev/zba/src/HEL/AMD64/BootString.cxx
new file mode 100644
index 00000000..1c109b80
--- /dev/null
+++ b/dev/zba/src/HEL/AMD64/BootString.cxx
@@ -0,0 +1,92 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+	File: String.cxx
+	Purpose: NewBoot string library
+
+	Revision History:
+
+
+
+------------------------------------------- */
+
+#include <BootKit/Platform.hxx>
+#include <BootKit/Protocol.hxx>
+#include <BootKit/BootKit.hxx>
+
+/// BUGS: 0
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+Kernel::SizeT Boot::BCopyMem(CharacterTypeUTF16* dest, CharacterTypeUTF16* src, const Kernel::SizeT len)
+{
+	if (!dest || !src)
+		return 0;
+
+	SizeT index = 0UL;
+	for (; index < len; ++index)
+	{
+		dest[index] = src[index];
+	}
+
+	return index;
+}
+
+Kernel::SizeT Boot::BStrLen(const CharacterTypeUTF16* ptr)
+{
+	if (!ptr)
+		return 0;
+
+	Kernel::SizeT cnt = 0;
+
+	while (*ptr != (CharacterTypeUTF16)0)
+	{
+		++ptr;
+		++cnt;
+	}
+
+	return cnt;
+}
+
+Kernel::SizeT Boot::BSetMem(CharacterTypeUTF16* src, const CharacterTypeUTF16 byte, const Kernel::SizeT len)
+{
+	if (!src)
+		return 0;
+
+	Kernel::SizeT cnt = 0UL;
+
+	while (*src != 0)
+	{
+		if (cnt > len)
+			break;
+
+		*src = byte;
+		++src;
+
+		++cnt;
+	}
+
+	return cnt;
+}
+
+Kernel::SizeT Boot::BSetMem(CharacterTypeUTF8* src, const CharacterTypeUTF8 byte, const Kernel::SizeT len)
+{
+	if (!src)
+		return 0;
+
+	Kernel::SizeT cnt = 0UL;
+
+	while (*src != 0)
+	{
+		if (cnt > len)
+			break;
+
+		*src = byte;
+		++src;
+
+		++cnt;
+	}
+
+	return cnt;
+}
diff --git a/dev/zba/src/HEL/AMD64/BootTextWriter.cxx b/dev/zba/src/HEL/AMD64/BootTextWriter.cxx
new file mode 100644
index 00000000..b0679715
--- /dev/null
+++ b/dev/zba/src/HEL/AMD64/BootTextWriter.cxx
@@ -0,0 +1,169 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+	File: String.cxx
+	Purpose: NewBoot string library
+
+	Revision History:
+
+
+
+------------------------------------------- */
+
+#include <FirmwareKit/EFI/API.hxx>
+#include <BootKit/Platform.hxx>
+#include <BootKit/Protocol.hxx>
+#include <BootKit/BootKit.hxx>
+
+/// BUGS: 0
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+/**
+@brief puts wrapper over EFI ConOut.
+*/
+Boot::BTextWriter& Boot::BTextWriter::Write(const CharacterTypeUTF16* str)
+{
+#ifdef __DEBUG__
+	if (!str || *str == 0)
+		return *this;
+
+	CharacterTypeUTF16 strTmp[2];
+	strTmp[1] = 0;
+
+	for (size_t i = 0; str[i] != 0; i++)
+	{
+		if (str[i] == '\r')
+		{
+			strTmp[0] = str[i];
+			ST->ConOut->OutputString(ST->ConOut, strTmp);
+
+			strTmp[0] = '\n';
+			ST->ConOut->OutputString(ST->ConOut, strTmp);
+		}
+		else
+		{
+			strTmp[0] = str[i];
+			ST->ConOut->OutputString(ST->ConOut, strTmp);
+		}
+	}
+#endif // ifdef __DEBUG__
+
+	return *this;
+}
+
+/// @brief UTF-8 equivalent of Write (UTF-16).
+/// @param str the input string.
+Boot::BTextWriter& Boot::BTextWriter::Write(const Char* str)
+{
+#ifdef __DEBUG__
+	if (!str || *str == 0)
+		return *this;
+
+	CharacterTypeUTF16 strTmp[2];
+	strTmp[1] = 0;
+
+	for (size_t i = 0; str[i] != 0; i++)
+	{
+		if (str[i] == '\r')
+		{
+			strTmp[0] = str[i];
+			ST->ConOut->OutputString(ST->ConOut, strTmp);
+
+			strTmp[0] = '\n';
+			ST->ConOut->OutputString(ST->ConOut, strTmp);
+		}
+		else
+		{
+			strTmp[0] = str[i];
+			ST->ConOut->OutputString(ST->ConOut, strTmp);
+		}
+	}
+#endif // ifdef __DEBUG__
+
+	return *this;
+}
+
+Boot::BTextWriter& Boot::BTextWriter::Write(const UChar* str)
+{
+#ifdef __DEBUG__
+	if (!str || *str == 0)
+		return *this;
+
+	CharacterTypeUTF16 strTmp[2];
+	strTmp[1] = 0;
+
+	for (size_t i = 0; str[i] != 0; i++)
+	{
+		if (str[i] == '\r')
+		{
+			strTmp[0] = str[i];
+			ST->ConOut->OutputString(ST->ConOut, strTmp);
+
+			strTmp[0] = '\n';
+			ST->ConOut->OutputString(ST->ConOut, strTmp);
+		}
+		else
+		{
+			strTmp[0] = str[i];
+			ST->ConOut->OutputString(ST->ConOut, strTmp);
+		}
+	}
+#endif // ifdef __DEBUG__
+
+	return *this;
+}
+
+/**
+@brief putc wrapper over EFI ConOut.
+*/
+Boot::BTextWriter& Boot::BTextWriter::WriteCharacter(CharacterTypeUTF16 c)
+{
+#ifdef __DEBUG__
+	EfiCharType str[2];
+
+	str[0] = c;
+	str[1] = 0;
+	ST->ConOut->OutputString(ST->ConOut, str);
+#endif // ifdef __DEBUG__
+
+	return *this;
+}
+
+Boot::BTextWriter& Boot::BTextWriter::Write(const Long& x)
+{
+#ifdef __DEBUG__
+	this->_Write(x);
+	this->Write("h");
+#endif // ifdef __DEBUG__
+
+	return *this;
+}
+
+Boot::BTextWriter& Boot::BTextWriter::_Write(const Long& x)
+{
+#ifdef __DEBUG__
+	UInt64 y = (x > 0 ? x : -x) / 16;
+	UInt64 h = (x > 0 ? x : -x) % 16;
+
+	if (y)
+		this->_Write(y);
+
+	/* fail if the hex number is not base-16 */
+	if (h > 16)
+	{
+		this->WriteCharacter('?');
+		return *this;
+	}
+
+	if (y < 0)
+		y = -y;
+
+	const char cNumbers[] = "0123456789ABCDEF";
+
+	this->WriteCharacter(cNumbers[h]);
+#endif // ifdef __DEBUG__
+
+	return *this;
+}
diff --git a/dev/zba/src/HEL/AMD64/New+Delete.cxx b/dev/zba/src/HEL/AMD64/New+Delete.cxx
new file mode 100644
index 00000000..4a308f94
--- /dev/null
+++ b/dev/zba/src/HEL/AMD64/New+Delete.cxx
@@ -0,0 +1,62 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+------------------------------------------- */
+
+#include <BootKit/Platform.hxx>
+#include <BootKit/Protocol.hxx>
+#include <BootKit/BootKit.hxx>
+
+#ifdef __STANDALONE__
+#include <cstddef> /* Since we're using GCC for this EFI program. */
+
+EXTERN EfiBootServices* BS;
+
+/// @brief Allocates a new object.
+/// @param sz the size.
+/// @return
+void* operator new(size_t sz)
+{
+	void* buf = nullptr;
+
+	while (BS->AllocatePool(EfiMemoryType::EfiLoaderData, sz, &buf) == kBufferTooSmall)
+		BS->FreePool(buf);
+
+	return buf;
+}
+
+/// @brief Allocates a new object.
+/// @param sz the size.
+/// @return
+void* operator new[](size_t sz)
+{
+	void* buf = nullptr;
+	BS->AllocatePool(EfiMemoryType::EfiLoaderData, sz, &buf);
+
+	return buf;
+}
+
+/// @brief Deletes the object.
+/// @param buf the object.
+void operator delete(void* buf)
+{
+	BS->FreePool(buf);
+}
+
+/// @brief Deletes the object.
+/// @param buf the object.
+void operator delete[](void* buf)
+{
+	BS->FreePool(buf);
+}
+
+/// @brief Deletes the object (array specific).
+/// @param buf the object.
+/// @param size it's size.
+void operator delete(void* buf, size_t size)
+{
+	BS->FreePool(buf);
+}
+
+#endif // __STANDALONE__
diff --git a/dev/zba/src/HEL/AMD64/Support.cxx b/dev/zba/src/HEL/AMD64/Support.cxx
new file mode 100644
index 00000000..aa93318b
--- /dev/null
+++ b/dev/zba/src/HEL/AMD64/Support.cxx
@@ -0,0 +1,82 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+------------------------------------------- */
+
+#include <BootKit/BootKit.hxx>
+#include <FirmwareKit/EFI/API.hxx>
+#include <FirmwareKit/EFI/EFI.hxx>
+#include <FirmwareKit/Handover.hxx>
+#include <BootKit/Support.hxx>
+#include <KernelKit/MSDOS.hxx>
+#include <KernelKit/PE.hxx>
+
+#ifdef __STANDALONE__
+
+/// @brief memset definition in C++.
+/// @param dst destination pointer.
+/// @param byte value to fill in.
+/// @param len length of of src.
+EXTERN_C VoidPtr memset(void* dst, int byte, long long unsigned int len)
+{
+	for (size_t i = 0UL; i < len; ++i)
+	{
+		((int*)dst)[i] = byte;
+	}
+
+	return dst;
+}
+
+/// @brief memcpy definition in C++.
+/// @param dst destination pointer.
+/// @param  src source pointer.
+/// @param len length of of src.
+EXTERN_C VoidPtr memcpy(void* dst, const void* src, long long unsigned int len)
+{
+	for (size_t i = 0UL; i < len; ++i)
+	{
+		((int*)dst)[i] = ((int*)src)[i];
+	}
+
+	return dst;
+}
+
+/// @brief strlen definition in C++.
+EXTERN_C size_t strlen(const char* whatToCheck)
+{
+	SizeT len = 0;
+
+	while (whatToCheck[len] != 0)
+	{
+		++len;
+	}
+
+	return len;
+}
+
+/// @brief strcmp definition in C++.
+EXTERN_C int strcmp(const char* whatToCheck, const char* whatToCheckRight)
+{
+	if (!whatToCheck || *whatToCheck == 0)
+		return 0;
+
+	SizeT len = 0;
+
+	while (whatToCheck[len] == whatToCheckRight[len])
+	{
+		if (whatToCheck[len] == 0)
+			return 0;
+
+		++len;
+	}
+
+	return len;
+}
+
+/// @brief somthing specific to the Microsoft's ABI, When the stack grows too big.
+EXTERN_C void ___chkstk_ms(void)
+{
+}
+
+#endif
diff --git a/dev/zba/src/HEL/ARM64/.gitkeep b/dev/zba/src/HEL/ARM64/.gitkeep
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/dev/zba/src/HEL/ARM64/.gitkeep
diff --git a/dev/zba/src/HEL/POWER/.gitkeep b/dev/zba/src/HEL/POWER/.gitkeep
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/dev/zba/src/HEL/POWER/.gitkeep
diff --git a/dev/zba/src/HEL/POWER/CoreBootStartup.S b/dev/zba/src/HEL/POWER/CoreBootStartup.S
new file mode 100644
index 00000000..502f415c
--- /dev/null
+++ b/dev/zba/src/HEL/POWER/CoreBootStartup.S
@@ -0,0 +1,34 @@
+/* -------------------------------------------
+
+    Copyright ZKA Technologies.
+
+------------------------------------------- */
+
+.section .boot_hdr
+.align 4
+
+/* NewBoot boot header begin */
+
+boot_hdr_mag:
+	.ascii "CB"
+boot_hdr_name:
+	// it has to match ten bytes.
+	.asciz "newosldr\0\0"
+boot_hdr_ver:
+	.word 0x104
+boot_hdr_proc:
+	.long bootloader_start
+
+/* NewBoot boot header end */
+
+.extern bootloader_main
+.extern bootloader_stack
+
+.globl bootloader_start
+bootloader_start:
+    mflr	4			/* real address of .Laddr */
+    lwz	0,(bootloader_stack-bootloader_start)(4)	/* stack address location */
+    mr	1,0			/* use user defined stack */
+
+    bl bootloader_main
+    blr
diff --git a/dev/zba/src/Root/EFI/STARTUP.NSH b/dev/zba/src/Root/EFI/STARTUP.NSH
new file mode 100644
index 00000000..d29ba8fd
--- /dev/null
+++ b/dev/zba/src/Root/EFI/STARTUP.NSH
@@ -0,0 +1,2 @@
+fs0:
+BOOT\BOOTX64.EFI
diff --git a/dev/zba/src/Root/ZKA/startup.wav b/dev/zba/src/Root/ZKA/startup.wav
new file mode 100644
index 00000000..524921f5
--- /dev/null
+++ b/dev/zba/src/Root/ZKA/startup.wav
diff --git a/dev/zba/src/Root/ZKA/urbanist.ttf b/dev/zba/src/Root/ZKA/urbanist.ttf
new file mode 100644
index 00000000..e9a6dbb0
--- /dev/null
+++ b/dev/zba/src/Root/ZKA/urbanist.ttf
diff --git a/dev/zba/src/Thread.cxx b/dev/zba/src/Thread.cxx
new file mode 100644
index 00000000..1f780fa2
--- /dev/null
+++ b/dev/zba/src/Thread.cxx
@@ -0,0 +1,181 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies.
+
+------------------------------------------- */
+
+#include <BootKit/Thread.hxx>
+#include <BootKit/Support.hxx>
+#include <BootKit/BootKit.hxx>
+#include <FirmwareKit/EFI/API.hxx>
+
+#include <KernelKit/PEF.hxx>
+#include <KernelKit/PE.hxx>
+#include <KernelKit/MSDOS.hxx>
+#include <CFKit/LoaderUtils.hxx>
+#include <Modules/CoreCG/TextRenderer.hxx>
+
+EXTERN_C
+{
+#include <string.h>
+
+	Void
+	rt_jump_to_address(VoidPtr start, VoidPtr handover);
+}
+
+// External boot services symbol.
+EXTERN EfiBootServices* BS;
+
+/// @note BThread doesn't parse the symbols so doesn't nullify them, .bss is though.
+
+namespace Boot
+{
+	BThread::BThread(VoidPtr blob)
+		: fBlob(blob), fStartAddress(nullptr)
+	{
+		// detect the format.
+		const Char* firstBytes = reinterpret_cast<char*>(fBlob);
+
+		BTextWriter writer;
+
+		if (!firstBytes)
+		{
+			// failed to provide a valid pointer.
+			return;
+		}
+
+		if (firstBytes[0] == kMagMz0 &&
+			firstBytes[1] == kMagMz1)
+		{
+			LDR_EXEC_HEADER_PTR		hdrPtr = ldr_find_exec_header(firstBytes);
+			LDR_OPTIONAL_HEADER_PTR optHdr = ldr_find_opt_exec_header(firstBytes);
+
+			if (hdrPtr->mMachine != kPeMachineAMD64 ||
+				hdrPtr->mSignature != kPeMagic)
+			{
+				writer.Write("NEWOSLDR: Not a PE32+ executable.\r");
+				return;
+			}
+
+			if (optHdr->mSubsystem != kZKASubsystem)
+			{
+				writer.Write("NEWOSLDR: Not a ZKA Subsystem executable.\r");
+				return;
+			}
+
+			writer.Write("NEWOSLDR: PE32+ executable detected (ZKA Subsystem).\r");
+
+			auto numSecs = hdrPtr->mNumberOfSections;
+
+			writer.Write("NEWOSLDR: Major Linker Ver: ").Write(optHdr->mMajorLinkerVersion).Write("\r");
+			writer.Write("NEWOSLDR: Minor Linker Ver: ").Write(optHdr->mMinorLinkerVersion).Write("\r");
+			writer.Write("NEWOSLDR: Major Subsystem Ver: ").Write(optHdr->mMajorSubsystemVersion).Write("\r");
+			writer.Write("NEWOSLDR: Minor Subsystem Ver: ").Write(optHdr->mMinorSubsystemVersion).Write("\r");
+			writer.Write("NEWOSLDR: Magic: ").Write(hdrPtr->mSignature).Write("\r");
+
+			constexpr auto cPageSize = 512;
+
+			EfiPhysicalAddress loadStartAddress = optHdr->mImageBase;
+			loadStartAddress += optHdr->mBaseOfData;
+
+			writer.Write("NEWOSLDR: ImageBase: ").Write(loadStartAddress).Write("\r");
+
+			auto numPages = optHdr->mSizeOfImage / cPageSize;
+			BS->AllocatePages(AllocateAddress, EfiLoaderData, numPages, &loadStartAddress);
+
+			LDR_SECTION_HEADER_PTR sectPtr = (LDR_SECTION_HEADER_PTR)(((Char*)optHdr) + hdrPtr->mSizeOfOptionalHeader);
+
+			constexpr auto sectionForCode	= ".text";
+			constexpr auto sectionForNewLdr = ".ldr";
+			constexpr auto sectionForBSS	= ".bss";
+
+			for (SizeT sectIndex = 0; sectIndex < numSecs; ++sectIndex)
+			{
+				LDR_SECTION_HEADER_PTR sect = &sectPtr[sectIndex];
+
+				SetMem((VoidPtr)(loadStartAddress + sect->mVirtualAddress), 0, sect->mSizeOfRawData);
+
+				if (StrCmp(sectionForCode, sect->mName) == 0)
+				{
+					fStartAddress = (VoidPtr)((UIntPtr)loadStartAddress + optHdr->mAddressOfEntryPoint);
+					writer.Write("NEWOSLDR: Entrypoint of DLL: ").Write((UIntPtr)fStartAddress).Write("\r");
+				}
+				else if (StrCmp(sectionForNewLdr, sect->mName) == 0)
+				{
+					struct HANDOVER_INFORMATION_STUB
+					{
+						UInt64 HandoverMagic;
+						UInt32 HandoverType;
+					}* structHandover = (struct HANDOVER_INFORMATION_STUB*)((UIntPtr)fBlob + sect->mPointerToRawData);
+
+					if (structHandover->HandoverMagic != kHandoverMagic &&
+						structHandover->HandoverType != HEL::kTypeKernel)
+					{
+						writer.Write("NEWOSLDR: Entrypoint of EXE: ").Write((UIntPtr)fStartAddress).Write("\r");
+						CGDrawString("NEWOSLDR: NOT AN HANDOVER IMAGE...", 40, 10, RGB(0xFF, 0xFF, 0xFF));
+					}
+				}
+
+				writer.Write("NEWOSLDR: offset ").Write(sect->mPointerToRawData).Write(" of ").Write(sect->mName).Write("\r");
+
+				CopyMem((VoidPtr)(loadStartAddress + sect->mVirtualAddress), (VoidPtr)((UIntPtr)fBlob + sect->mPointerToRawData), sect->mSizeOfRawData);
+			}
+		}
+		else if (firstBytes[0] == kPefMagic[0] &&
+				 firstBytes[1] == kPefMagic[1] &&
+				 firstBytes[2] == kPefMagic[2] &&
+				 firstBytes[3] == kPefMagic[3])
+		{
+			//  =========================================  //
+			//  PEF executable detected.
+			//  =========================================  //
+
+			fStartAddress = nullptr;
+			writer.Write("NEWOSLDR: PEF executable detected, won't load it.\r");
+			writer.Write("NEWOSLDR: note: PEF executables aren't loadable by default.\r");
+		}
+		else
+		{
+			writer.Write("NEWOSLDR: Invalid executable.\r");
+		}
+	}
+
+	/// @note handover header has to be valid!
+	Void BThread::Start(HEL::HANDOVER_INFO_HEADER* handover)
+	{
+		BTextWriter writer;
+
+		if (!handover)
+		{
+			writer.Write("NEWOSLDR: Exec format error.\r");
+			return;
+		}
+
+		HEL::HandoverProc err_fn = [](HEL::HANDOVER_INFO_HEADER* rcx) -> void {
+			CGDrawString("NEWOSLDR: INVALID IMAGE! ABORTING...", 50, 10, RGB(0xFF, 0xFF, 0xFF));
+			::EFI::Stop();
+		};
+
+		if (!fStartAddress)
+		{
+			err_fn(handover);
+		}
+
+		reinterpret_cast<HEL::HandoverProc>(fStartAddress)(handover);
+	}
+
+	const Char* BThread::GetName()
+	{
+		return fBlobName;
+	}
+
+	Void BThread::SetName(const Char* name)
+	{
+		CopyMem(fBlobName, name, StrLen(name));
+	}
+
+	bool BThread::IsValid()
+	{
+		return fStartAddress != nullptr;
+	}
+} // namespace Boot