diff --git a/ndsfactory/ndsfactory.cpp b/ndsfactory/ndsfactory.cpp
index c055481..192b343 100644
--- a/ndsfactory/ndsfactory.cpp
+++ b/ndsfactory/ndsfactory.cpp
@@ -22,107 +22,95 @@
 #define ROOT_DIRECTORY_ADDRESS 0xF000
 
 
-NDSFactory::NDSFactory()
-{
-
-}
-
-bool NDSFactory::loadRomHeader(const std::string& romPath, std::vector<char>& romHeader)
+NFResult NDSFactory::loadRomHeader(const std::string& romPath, std::vector<char>& romHeader)
 {
     std::streampos headerSize = sizeof(NDSHeader);
     std::ifstream romFile (romPath, std::ios::binary);
-    if (romFile.is_open())
-    {
-        romHeader.resize(static_cast<unsigned long>(headerSize));
-
-        romFile.read (romHeader.data(), headerSize);
-        romFile.close();
-
-        return true;
-    }
-    return false;
+    if (!romFile.is_open())
+		return NFResult({ false, "Error opening file: " + romPath });
+    
+    romHeader.resize(static_cast<unsigned long>(headerSize));
+    romFile.read (romHeader.data(), headerSize);
+    romFile.close();
+	return NFResult({ true, "" });
 }
 
-bool NDSFactory::dumpDataFromFile(const std::string& romPath, const std::string& savePath, uint32_t startAddr, uint32_t size)
+NFResult NDSFactory::dumpDataFromFile(const std::string& romPath, const std::string& savePath, uint32_t startAddr, uint32_t size)
 {
     std::ifstream romFile (romPath, std::ios::binary);
     std::ofstream savedFile (savePath, std::ios::binary);
-    if (romFile.is_open() && savedFile.is_open())
-    {
-        std::vector<char> dumpBuffer(size);
-        romFile.seekg (startAddr, std::ios::beg);
-        romFile.read (dumpBuffer.data(), size);
-        romFile.close();
+	if (!romFile.is_open()) return NFResult({ false, "Error opening file: " + romPath });
+	if (!savedFile.is_open()) return NFResult({ false, "Error creating file: " + savePath });
 
-        savedFile.write(dumpBuffer.data(), size);
-        savedFile.close();
-        return true;
-    }
-    return false;
+    std::vector<char> dumpBuffer(size);
+    romFile.seekg (startAddr, std::ios::beg);
+    romFile.read (dumpBuffer.data(), size);
+    romFile.close();
+
+    savedFile.write(dumpBuffer.data(), size);
+    savedFile.close();
+    return NFResult({ true, "" });
 }
 
 bool NDSFactory::logToFile(const std::string& logPath, const std::string& log)
 {
     std::ofstream savedFile(logPath, std::ios::out | std::ios::binary | std::ios::app);
-    if (savedFile.is_open())
-    {
-		savedFile.write(log.c_str(), log.size());
-        savedFile.close();
-        return true;
-    }
-    return false;
+    if (!savedFile.is_open())
+        return false;
+
+	savedFile.write(log.c_str(), log.size());
+    savedFile.close();
+    return true;
 }
 
 
-bool NDSFactory::readBytesFromFile(std::vector<char>& byteBuffer, const std::string& romPath, uint32_t startAddr, uint32_t size)
+NFResult NDSFactory::readBytesFromFile(std::vector<char>& byteBuffer, const std::string& romPath, uint32_t startAddr, uint32_t size)
 {
     std::ifstream romFile (romPath, std::ios::binary);
-    if (romFile.is_open())
-    {
-        romFile.seekg (startAddr, std::ios::beg);
-        romFile.read (byteBuffer.data(), size);
-        romFile.close();
-        return true;
-    }
-    return false;
+    if (!romFile.is_open())
+		return NFResult({ false, "Error opening file: " + romPath });
+
+    romFile.seekg (startAddr, std::ios::beg);
+    romFile.read (byteBuffer.data(), size);
+    romFile.close();
+	return NFResult({ true, "" });
 }
 
-bool NDSFactory::writeSectionToFile(const std::string& sectionPath, const std::string& savePath, uint32_t startAddr, uint32_t size)
+NFResult NDSFactory::writeSectionToFile(const std::string& sectionPath, const std::string& savePath, uint32_t startAddr, uint32_t size)
 {
     std::ifstream sectionFile (sectionPath, std::ios::binary);
-    if (sectionFile.is_open())
-    {
-        std::vector<char> dumpBuffer(size);
-        sectionFile.read (dumpBuffer.data(), size);
-        sectionFile.close();
-        return writeBytesToFile(dumpBuffer, savePath, startAddr, size);
-    }
-    return false;
+    if (!sectionFile.is_open())
+		return NFResult({ false, "Error opening file: " + sectionPath });
+    
+    std::vector<char> dumpBuffer(size);
+    sectionFile.read (dumpBuffer.data(), size);
+    sectionFile.close();
+    return writeBytesToFile(dumpBuffer, savePath, startAddr, size);
 }
 
-bool NDSFactory::writeBytesToFile(std::vector<char>& byteBuffer, const std::string& savePath, uint32_t startAddr, uint32_t size)
+NFResult NDSFactory::writeBytesToFile(std::vector<char>& byteBuffer, const std::string& savePath, uint32_t startAddr, uint32_t size)
 {
     std::ofstream savedFile (savePath, std::ios::in | std::ios::out | std::ios::binary);
     if (!savedFile.is_open())
     {
         savedFile.open(savePath, std::ios::out | std::ios::binary);
         if (!savedFile.is_open()) {
-            return false;
+			return NFResult({ false, "Error creating file: " + savePath });
         }
         savedFile.close();
         savedFile.open(savePath, std::ios::in | std::ios::out | std::ios::binary);
         if (!savedFile.is_open())
-            return false;
+			return NFResult({ false, "Error opening file: " + savePath });
     }
 
     savedFile.seekp(startAddr);
     savedFile.write(byteBuffer.data(), size);
     savedFile.close();
-    return true;
+	return NFResult({ true, "" });
 }
 
 
-bool NDSFactory::writePaddingToFile(char paddingChar, const std::string& filePath, uint32_t startAddr, const uint32_t size)
+NFResult NDSFactory::writePaddingToFile(char paddingChar, const std::string& filePath, uint32_t startAddr, const uint32_t size)
 {
     std::vector<char> paddingBytes(size, paddingChar);
     return writeBytesToFile(paddingBytes, filePath, startAddr, size);
@@ -148,7 +136,7 @@ bool NDSFactory::checkArm9FooterPresence(const std::string& sectionPath, uint32_
     return false;
 }
 
-bool NDSFactory::extractFatData(const std::string& fatDataSectionPath, const std::string& fatSectionPath,
+NFResult NDSFactory::extractFatData(const std::string& fatDataSectionPath, const std::string& fatSectionPath,
     const std::string& fntSectionPath, uint32_t originalFatDataAddr, const std::string& savePath, bool logFileIDs)
 {
     std::vector<char> fatDataBytes;
@@ -156,7 +144,7 @@ bool NDSFactory::extractFatData(const std::string& fatDataSectionPath, const std
     std::vector<char> fntBytes;
 
     std::ifstream fatDataSectionFile(fatDataSectionPath, std::ios::in | std::ios::binary | std::ios::ate);
-    if (!fatDataSectionFile.is_open()) return false;
+    if (!fatDataSectionFile.is_open()) return NFResult({ false, "Error opening file: " + fatDataSectionPath });
     std::streamoff fatDataSectionSize = fatDataSectionFile.tellg();
     fatDataBytes.resize(fatDataSectionSize);
     fatDataSectionFile.seekg(0, std::ios::beg);
@@ -164,7 +152,7 @@ bool NDSFactory::extractFatData(const std::string& fatDataSectionPath, const std
     fatDataSectionFile.close();
 
     std::ifstream fatSectionFile(fatSectionPath, std::ios::in | std::ios::binary | std::ios::ate);
-    if (!fatSectionFile.is_open()) return false;
+    if (!fatSectionFile.is_open()) return NFResult({ false, "Error opening file: " + fatSectionPath });
     std::streamoff fatSectionSize = fatSectionFile.tellg();
     fatBytes.resize(fatSectionSize);
     fatSectionFile.seekg(0, std::ios::beg);
@@ -172,7 +160,7 @@ bool NDSFactory::extractFatData(const std::string& fatDataSectionPath, const std
     fatSectionFile.close();
 
     std::ifstream fntSectionFile(fntSectionPath, std::ios::in | std::ios::binary | std::ios::ate);
-    if (!fntSectionFile.is_open()) return false;
+    if (!fntSectionFile.is_open()) return NFResult({ false, "Error opening file: " + fntSectionPath });
     std::streamoff fntSectionSize = fntSectionFile.tellg();
     fntBytes.resize(fntSectionSize);
     fntSectionFile.seekg(0, std::ios::beg);
@@ -248,16 +236,16 @@ bool NDSFactory::extractFatData(const std::string& fatDataSectionPath, const std
                 currentOffset += 2;
 
                 if (!std::filesystem::exists(newPath))
-                    if (!std::filesystem::create_directory(newPath)) return false;
+					if (!std::filesystem::create_directory(newPath)) return NFResult({ false, "Error creating directory: " + newPath });
 
                 if (logFileIDs)
                 {
 					std::string log = std::format("{:x}",subFolderId) + ":::" + newPath.substr(savePath.size()+1) + '\n';
-                    if (!logToFile(savePath + "/_file_IDs.txt", log)) return false;
+					if (!logToFile(savePath + "/_file_IDs.txt", log)) return NFResult({ false, "Error writing to file: " + savePath + "/_file_IDs.txt" });
                 }
 
                 // Jump back to the FNT header and repeat the process for subdirectory !
-                if (!parseFolder(subFolderId, newPath, parseFolder)) return false;
+                if (!parseFolder(subFolderId, newPath, parseFolder).result) return NFResult({ false, "Error parsing folder: " + newPath });
             }
             else
             {
@@ -267,31 +255,31 @@ bool NDSFactory::extractFatData(const std::string& fatDataSectionPath, const std
 
                 uint32_t fileStartAddr = (pfatrange + fatOffset)->startAddr - originalFatDataAddr;
                 uint32_t fileSize = (pfatrange + fatOffset)->endAddr - (pfatrange + fatOffset)->startAddr;
-                if (!dumpDataFromFile(fatDataSectionPath, newPath, fileStartAddr, fileSize)) return false;
+                if (!dumpDataFromFile(fatDataSectionPath, newPath, fileStartAddr, fileSize).result) return NFResult({ false, "Error dumping file: " + newPath });
 
                 if (logFileIDs)
                 {
                     std::string log = std::format("{:x}", fatOffset) + ":::" + newPath.substr(savePath.size()+1) + '\n';
-                    if (!logToFile(savePath + "/_file_IDs.txt", log)) return false;
+					if (!logToFile(savePath + "/_file_IDs.txt", log)) return NFResult({ false, "Error writing to file: " + savePath + "/_file_IDs.txt" });
                 }
 				
                 fatOffset++;
             }
         }
 
-        return true;
+		return NFResult({ true, "" });
     };
 
     return parseFolder(ROOT_DIRECTORY_ADDRESS, savePath, parseFolder);
 }
 
-bool NDSFactory::patchFat(const std::string& fatSectionPath, uint32_t shiftSize, const std::string& savePath)
+NFResult NDSFactory::patchFat(const std::string& fatSectionPath, uint32_t shiftSize, const std::string& savePath)
 {
     std::vector<char> fatBytes;
 
     std::ifstream sectionFile (fatSectionPath, std::ios::in|std::ios::binary|std::ios::ate);
     if (!sectionFile.is_open())
-        return false;
+        return { false, "Error opening file: " + fatSectionPath };
 
     std::streamoff sectionSize = sectionFile.tellg();
     fatBytes.resize(sectionSize);
@@ -313,7 +301,7 @@ bool NDSFactory::patchFat(const std::string& fatSectionPath, uint32_t shiftSize,
     return writeBytesToFile(fatBytes, savePath, 0, static_cast<uint32_t>(sectionSize));
 }
 
-bool NDSFactory::buildFatData(const std::string& fatDataDirPath, const std::string& originalFatPath, uint32_t fatDataAddr, const std::string& savePath)
+NFResult NDSFactory::buildFatData(const std::string& fatDataDirPath, const std::string& originalFatPath, uint32_t fatDataAddr, const std::string& savePath)
 {
     std::vector<char> fatDataBytes;
     std::vector<FatRange> fat;
@@ -321,7 +309,7 @@ bool NDSFactory::buildFatData(const std::string& fatDataDirPath, const std::stri
 
     std::vector<FatFileID> fileIDs;
     std::ifstream fileIDsFile(fatDataDirPath + "/_file_IDs.txt", std::ios::in | std::ios::beg);
-    if (!fileIDsFile.is_open()) return false;
+    if (!fileIDsFile.is_open()) return { false, "Error opening file: " + fatDataDirPath + "/_file_IDs.txt" };
     std::string fileIDsLine;
     while (std::getline(fileIDsFile, fileIDsLine))
     {
@@ -344,7 +332,7 @@ bool NDSFactory::buildFatData(const std::string& fatDataDirPath, const std::stri
         if (firstFileId > 0)
         {
             std::ifstream originalFatFile(originalFatPath, std::ios::in | std::ios::binary | std::ios::beg);
-            if (!originalFatFile.is_open()) return false;
+            if (!originalFatFile.is_open()) return { false, "Error opening file: " + originalFatPath };
             std::vector<char> ovrBytes;
             uint32_t requiredBytes = firstFileId * sizeof(FatRange);
             ovrBytes.resize(requiredBytes);
@@ -368,7 +356,7 @@ bool NDSFactory::buildFatData(const std::string& fatDataDirPath, const std::stri
         fatRange.startAddr = fatDataAddr + static_cast<uint32_t>(fatDataBytes.size());
 
         std::ifstream currentFatDataFile(currentFile, std::ios::in | std::ios::binary | std::ios::ate);
-		if (!currentFatDataFile.is_open()) return false;
+        if (!currentFatDataFile.is_open()) return NFResult({ false, "Error opening file: " + currentFile });
         std::streamsize size = currentFatDataFile.tellg();
         currentFatDataFile.seekg(0, std::ios::beg);
 
@@ -377,25 +365,26 @@ bool NDSFactory::buildFatData(const std::string& fatDataDirPath, const std::stri
             fatDataBytes.insert(fatDataBytes.end(), buffer.begin(), buffer.end());
         else
         {
-			currentFatDataFile.close();
-			return false;
+            currentFatDataFile.close();
+            return NFResult({ false, "Error reading file: " + currentFile });
         }
         currentFatDataFile.close();
 
         fatRange.endAddr = fatDataAddr + static_cast<uint32_t>(fatDataBytes.size());
-		fat.push_back(fatRange);
+        fat.push_back(fatRange);
     }
 
-   
+
     const char* fat_ptr = reinterpret_cast<const char*>(fat.data());
     std::vector<char> fatBytes(fat_ptr, fat_ptr + fat.size() * sizeof(FatRange));
     std::remove((savePath + "/fat_data.bin").c_str());
     std::remove((savePath + "/fat.bin").c_str());
-    bool res = true;
-    res &= writeBytesToFile(fatDataBytes, savePath + "/fat_data.bin", 0, static_cast<uint32_t>(fatDataBytes.size()));
-	res &= writeBytesToFile(fatBytes, savePath + "/fat.bin", 0, static_cast<uint32_t>(fatBytes.size()));
-    return res;
+    if (!writeBytesToFile(fatDataBytes, savePath + "/fat_data.bin", 0, static_cast<uint32_t>(fatDataBytes.size())).result)
+        return NFResult({ false, "Error writing to file: " + savePath + "/fat_data.bin" });
+    if (!writeBytesToFile(fatBytes, savePath + "/fat.bin", 0, static_cast<uint32_t>(fatBytes.size())).result)
+        return NFResult({ false, "Error writing to file: " + savePath + "/fat.bin" });
 
+    return NFResult({ true, "" });
 }
 
 uint16_t NDSFactory::calcHeaderCrc16(const std::vector<char>& romHeader)
diff --git a/ndsfactory/ndsfactory.h b/ndsfactory/ndsfactory.h
index 702e84f..8c9c02b 100644
--- a/ndsfactory/ndsfactory.h
+++ b/ndsfactory/ndsfactory.h
@@ -5,29 +5,28 @@
 #include <cstdint>
 #include "ndsheader.h"
 #include "fatstruct.h"
-
+#include "nfresult.h"
 
 
 class NDSFactory
 {
 public:
-    NDSFactory();
-    bool loadRomHeader(const std::string& romPath, std::vector<char>& header);
-    bool dumpDataFromFile(const std::string& romPath, const std::string& savePath, uint32_t startAddr, uint32_t size);
-    bool logToFile(const std::string& logPath, const std::string& log);
-    bool readBytesFromFile(std::vector<char>& byteBuffer, const std::string& romPath, uint32_t startAddr, uint32_t size);
-    bool writeSectionToFile(const std::string& sectionPath, const std::string& savePath, uint32_t startAddr, uint32_t size);
-    bool writeBytesToFile(std::vector<char>& byteBuffer, const std::string& savePath, uint32_t startAddr, uint32_t size);
-    bool writePaddingToFile(char paddingChar, const std::string& savePath, uint32_t startAddr, uint32_t size);
+    NFResult loadRomHeader(const std::string& romPath, std::vector<char>& header);
+    NFResult dumpDataFromFile(const std::string& romPath, const std::string& savePath, uint32_t startAddr, uint32_t size);
+    NFResult readBytesFromFile(std::vector<char>& byteBuffer, const std::string& romPath, uint32_t startAddr, uint32_t size);
+    NFResult writeSectionToFile(const std::string& sectionPath, const std::string& savePath, uint32_t startAddr, uint32_t size);
+    NFResult writeBytesToFile(std::vector<char>& byteBuffer, const std::string& savePath, uint32_t startAddr, uint32_t size);
+    NFResult writePaddingToFile(char paddingChar, const std::string& savePath, uint32_t startAddr, uint32_t size);
     int getCardSizeInBytes(int cardType);
     bool checkArm9FooterPresence(const std::string& sectionPath, uint32_t size);
-    bool extractFatData(const std::string& fatDataSectionPath, const std::string& fatSectionPath,
+    NFResult extractFatData(const std::string& fatDataSectionPath, const std::string& fatSectionPath,
         const std::string& fntSectionPath, uint32_t originalFatDataAddr, const std::string& savePath, bool logFileIDs);
-    bool patchFat(const std::string& sectionPath, uint32_t shiftSize, const std::string& savePath);
-	bool buildFatData(const std::string& fatDataDirPath, const std::string& originalFatPath, uint32_t fatDataAddr, const std::string& savePath);
+    NFResult patchFat(const std::string& sectionPath, uint32_t shiftSize, const std::string& savePath);
+    NFResult buildFatData(const std::string& fatDataDirPath, const std::string& originalFatPath, uint32_t fatDataAddr, const std::string& savePath);
     uint16_t calcHeaderCrc16(const std::vector<char>& romHeader);
 
 private:
+    bool logToFile(const std::string& logPath, const std::string& log);
 
 };
 
diff --git a/ndsfactory/nfresult.h b/ndsfactory/nfresult.h
new file mode 100644
index 0000000..b9c98a4
--- /dev/null
+++ b/ndsfactory/nfresult.h
@@ -0,0 +1,9 @@
+#pragma once
+
+#include <string>
+
+struct NFResult
+{
+	bool result;
+	std::string message;
+};
\ No newline at end of file
diff --git a/ui/dialogs/about/revision.h b/ui/dialogs/about/revision.h
index e701c03..5e6b873 100644
--- a/ui/dialogs/about/revision.h
+++ b/ui/dialogs/about/revision.h
@@ -1,6 +1,6 @@
 #ifndef REVISION_H
 #define REVISION_H
 
-#define GIT_COMMIT_HASH "f46e527"
+#define GIT_COMMIT_HASH "ac5df00"
 
 #endif
diff --git a/ui/mainwindow.h b/ui/mainwindow.h
index 21b44f2..bfe60ad 100644
--- a/ui/mainwindow.h
+++ b/ui/mainwindow.h
@@ -69,48 +69,48 @@ private:
     void populateHeader(NDSHeader* ndsHeader);
     void enableExtractionButtons();
     void disableExtractionButtons();
-    bool dumpHeader(const std::string& dirPath);
-    bool dumpArm9Bin(const std::string& dirPath, bool dumpExtraBytes);
-    bool dumpArm7Bin(const std::string& dirPath);
-    bool dumpFnt(const std::string& dirPath);
-    bool dumpFat(const std::string& dirPath);
-    bool dumpArm9Overlay(const std::string& dirPath);
-    bool dumpArm9OverlayFiles(const std::string& dirPath);
-    bool dumpArm7Overlay(const std::string& dirPath);
-    bool dumpArm7OverlayFiles(const std::string& dirPath);
-    bool dumpIconTitle(const std::string& dirPath);
-    bool dumpFatFiles(const std::string& dirPath);
-    bool dumpEverything(QString dirPath);
+    NFResult dumpHeader(const std::string& dirPath);
+    NFResult dumpArm9Bin(const std::string& dirPath, bool dumpExtraBytes);
+    NFResult dumpArm7Bin(const std::string& dirPath);
+    NFResult dumpFnt(const std::string& dirPath);
+    NFResult dumpFat(const std::string& dirPath);
+    NFResult dumpArm9Overlay(const std::string& dirPath);
+    NFResult dumpArm9OverlayFiles(const std::string& dirPath);
+    NFResult dumpArm7Overlay(const std::string& dirPath);
+    NFResult dumpArm7OverlayFiles(const std::string& dirPath);
+    NFResult dumpIconTitle(const std::string& dirPath);
+    NFResult dumpFatFiles(const std::string& dirPath);
+    NFResult dumpEverything(QString dirPath);
 
     void populatePackerSectionHeader(NDSHeader *ndsHeader);
     void enableCalcCrcButton();
     void enableBuildRomButton();
     void generateHeader(NDSHeader* pRomHeader);
-    bool writeHeader(const std::string& savePath);
+    NFResult writeHeader(const std::string& savePath);
     void calcHeaderCrc16();
-    bool writeArm9Bin(const std::string& savePath, bool isArm9FooterPresent);
-    bool writeArm7Bin(const std::string& savePath);
-    bool writeFnt(const std::string& savePath);
-    bool writeFat(const std::string& savePath);
-    bool writeArm9Overlay(const std::string& savePath);
-    bool writeArm9OverlayFiles(const std::string& savePath);
-    bool writeArm7Overlay(const std::string& savePath);
-    bool writeArm7OverlayFiles(const std::string& savePath);
-    bool writeIconTitle(const std::string& savePath);
-    bool writeFatFiles(const std::string& savePath);
-    bool writeEverything(const std::string& savePath);
+    NFResult writeArm9Bin(const std::string& savePath, bool isArm9FooterPresent);
+    NFResult writeArm7Bin(const std::string& savePath);
+    NFResult writeFnt(const std::string& savePath);
+    NFResult writeFat(const std::string& savePath);
+    NFResult writeArm9Overlay(const std::string& savePath);
+    NFResult writeArm9OverlayFiles(const std::string& savePath);
+    NFResult writeArm7Overlay(const std::string& savePath);
+    NFResult writeArm7OverlayFiles(const std::string& savePath);
+    NFResult writeIconTitle(const std::string& savePath);
+    NFResult writeFatFiles(const std::string& savePath);
+    NFResult writeEverything(const std::string& savePath);
 
-    bool writeHeaderPadding(char paddingByte, const std::string& savePath);
-    bool writeArm9BinPadding(char paddingByte, const std::string& savePath, bool isArm9FooterPresent);
-    bool writeArm7BinPadding(char paddingByte, const std::string& savePath);
-    bool writeFntPadding(char paddingByte, const std::string& savePath);
-    bool writeFatPadding(char paddingByte, const std::string& savePath);
-    bool writeRomPadding(const std::string& savePath);
+    NFResult writeHeaderPadding(char paddingByte, const std::string& savePath);
+    NFResult writeArm9BinPadding(char paddingByte, const std::string& savePath, bool isArm9FooterPresent);
+    NFResult writeArm7BinPadding(char paddingByte, const std::string& savePath);
+    NFResult writeFntPadding(char paddingByte, const std::string& savePath);
+    NFResult writeFatPadding(char paddingByte, const std::string& savePath);
+    NFResult writeRomPadding(const std::string& savePath);
 
     QString extractPackerHeaderTableData(int index);
 
-    bool extractFatData(const std::string& fatDataSectionPath, const std::string& fatSectionPath,
+    NFResult extractFatData(const std::string& fatDataSectionPath, const std::string& fatSectionPath,
         const std::string& fntSectionPath, uint32_t originalFatDataAddr, const std::string& savePath, bool logFileIDs);
-    bool patchFat(const std::string& loadPath, uint32_t shiftSize, const std::string& savePath);
-	bool buildFatData(const std::string& fatDataDirPath, const std::string& originalFatPath, uint32_t fatDataAddr, const std::string& savePath);
+    NFResult patchFat(const std::string& loadPath, uint32_t shiftSize, const std::string& savePath);
+    NFResult buildFatData(const std::string& fatDataDirPath, const std::string& originalFatPath, uint32_t fatDataAddr, const std::string& savePath);
 };
diff --git a/ui/tabs/fattools/fattoolstabfunctions.cpp b/ui/tabs/fattools/fattoolstabfunctions.cpp
index a57a492..8ca1603 100644
--- a/ui/tabs/fattools/fattoolstabfunctions.cpp
+++ b/ui/tabs/fattools/fattoolstabfunctions.cpp
@@ -2,19 +2,18 @@
 #include "./../../mainwindow.h"
 
 
-bool MainWindow::extractFatData(const std::string& fatDataSectionPath, const std::string& fatSectionPath,
+NFResult MainWindow::extractFatData(const std::string& fatDataSectionPath, const std::string& fatSectionPath,
     const std::string& fntSectionPath, uint32_t originalFatDataAddr, const std::string& savePath, bool logFileIDs)
 {
     return ndsFactory.extractFatData(fatDataSectionPath, fatSectionPath, fntSectionPath, originalFatDataAddr, savePath, logFileIDs);
 }
 
-bool MainWindow::patchFat(const std::string& loadPath, uint32_t shiftSize, const std::string& savePath)
+NFResult MainWindow::patchFat(const std::string& loadPath, uint32_t shiftSize, const std::string& savePath)
 {
     return ndsFactory.patchFat(loadPath, shiftSize, savePath);
 }
 
-bool MainWindow::buildFatData(const std::string& fatDataDirPath, const std::string& originalFatPath, uint32_t fatDataAddr, const std::string& savePath)
+NFResult MainWindow::buildFatData(const std::string& fatDataDirPath, const std::string& originalFatPath, uint32_t fatDataAddr, const std::string& savePath)
 {
-    if (!std::filesystem::exists(fatDataDirPath + "/_file_IDs.txt")) return false;
 	return ndsFactory.buildFatData(fatDataDirPath, originalFatPath, fatDataAddr, savePath);
 }
diff --git a/ui/tabs/fattools/fattoolstabsignals.cpp b/ui/tabs/fattools/fattoolstabsignals.cpp
index 6ca5c78..da63efc 100644
--- a/ui/tabs/fattools/fattoolstabsignals.cpp
+++ b/ui/tabs/fattools/fattoolstabsignals.cpp
@@ -55,14 +55,16 @@ void MainWindow::on_fatExtractorExtractBtn_clicked()
         "",
         QFileDialog::ShowDirsOnly | QFileDialog::DontResolveSymlinks);
 
-    if (!dirPath.isNull())
-        extractFatData(ui->fatExtractorFatDataPathEdt->text().toStdString(),
+    if (!dirPath.isNull()) {
+        NFResult nfResult = extractFatData(ui->fatExtractorFatDataPathEdt->text().toStdString(),
             ui->fatExtractorFatPathEdt->text().toStdString(),
             ui->fatExtractorFntPathEdt->text().toStdString(),
             ui->fatExtractorOriginalFatFilesAddrEdt->text().toUInt(nullptr, 16),
             dirPath.toStdString(),
-            ui->fatExtractorSaveFileIDsCbx->isChecked()) ? QMessageBox::information(this, tr("NDSFactory"), tr("FAT files extraction completed!"))
-        : QMessageBox::critical(this, tr("NDSFactory"), tr("Error extracting FAT files!"));
+            ui->fatExtractorSaveFileIDsCbx->isChecked());
+        nfResult.result? QMessageBox::information(this, tr("NDSFactory"), tr("FAT files extraction completed!"))
+            : QMessageBox::critical(this, tr("NDSFactory"), nfResult.message.c_str());
+    }
 
     ui->fatExtractorExtractBtn->setEnabled(true);
 
@@ -99,9 +101,9 @@ void MainWindow::on_fatPatcherPatchFatBtn_clicked()
         else
             positionDiff = originalPos - newPos;
 
-        patchFat(ui->fatPatcherFatPathEdt->text().toStdString(), positionDiff, dirPath.toStdString())
-            ? QMessageBox::information(this, tr("NDSFactory"), tr("FAT patching completed!"))
-            : QMessageBox::critical(this, tr("NDSFactory"), tr("Error patching FAT!"));
+        NFResult nfResult = patchFat(ui->fatPatcherFatPathEdt->text().toStdString(), positionDiff, dirPath.toStdString());
+        nfResult.result ? QMessageBox::information(this, tr("NDSFactory"), tr("FAT patching completed!"))
+            : QMessageBox::critical(this, tr("NDSFactory"), nfResult.message.c_str());
     }
 
     ui->fatPatcherPatchFatBtn->setEnabled(true);
@@ -140,11 +142,14 @@ void MainWindow::on_fatBuilderBuildBtn_clicked()
         QFileDialog::ShowDirsOnly | QFileDialog::DontResolveSymlinks);
 
     if (!dirPath.isNull())
-        buildFatData(ui->fatBuilderFatDirPathEdt->text().toStdString(),
-			ui->fatBuilderOriginalFatPathEdt->text().toStdString(),
+    {
+        NFResult nfResult = buildFatData(ui->fatBuilderFatDirPathEdt->text().toStdString(),
+            ui->fatBuilderOriginalFatPathEdt->text().toStdString(),
             ui->fatBuilderFatAddrEdt->text().toUInt(nullptr, 16),
-            dirPath.toStdString()) ? QMessageBox::information(this, tr("NDSFactory"), tr("fat_data.bin and fat.bin correctly built!"))
-        : QMessageBox::critical(this, tr("NDSFactory"), tr("Error building FAT!"));
+            dirPath.toStdString());
+        nfResult.result? QMessageBox::information(this, tr("NDSFactory"), tr("fat_data.bin and fat.bin correctly built!"))
+            : QMessageBox::critical(this, tr("NDSFactory"), nfResult.message.c_str());
+    }
 
     ui->fatBuilderOpenFatDataDirBtn->setEnabled(true);
 }
\ No newline at end of file
diff --git a/ui/tabs/packer/packertabfunctions.cpp b/ui/tabs/packer/packertabfunctions.cpp
index e1f08e0..0693524 100644
--- a/ui/tabs/packer/packertabfunctions.cpp
+++ b/ui/tabs/packer/packertabfunctions.cpp
@@ -102,17 +102,17 @@ void MainWindow::calcHeaderCrc16()
     ui->packerHeaderDataTable->model()->setData(headerCrcIndex, QString::number(ndsFactory.calcHeaderCrc16(romHeaderBuffer), 16), Qt::EditRole);
 }
 
-bool MainWindow::writeHeader(const std::string& savePath)
+NFResult MainWindow::writeHeader(const std::string& savePath)
 {
     std::vector<char> romHeaderBuffer(sizeof(NDSHeader));
     NDSHeader* pRomHeader = reinterpret_cast<NDSHeader*>(romHeaderBuffer.data());
 
     generateHeader(pRomHeader);
 
-    return ndsFactory.writeBytesToFile(romHeaderBuffer, savePath, 0, sizeof(NDSHeader));;
+    return ndsFactory.writeBytesToFile(romHeaderBuffer, savePath, 0, sizeof(NDSHeader));
 }
 
-bool MainWindow::writeHeaderPadding(char paddingType, const std::string& savePath)
+NFResult MainWindow::writeHeaderPadding(char paddingType, const std::string& savePath)
 {
     uint32_t startAddr = sizeof(NDSHeader);
     uint32_t size = extractPackerHeaderTableData(NDSHeaderNames::ARM9RomAddress).toUInt(nullptr, 16) - startAddr;
@@ -124,7 +124,7 @@ bool MainWindow::writeHeaderPadding(char paddingType, const std::string& savePat
         size);
 }
 
-bool MainWindow::writeArm9Bin(const std::string& savePath, bool isArm9FooterPresent)
+NFResult MainWindow::writeArm9Bin(const std::string& savePath, bool isArm9FooterPresent)
 {
     uint32_t size = extractPackerHeaderTableData(NDSHeaderNames::ARM9Size).toUInt(nullptr, 16);
     if (isArm9FooterPresent)
@@ -137,7 +137,7 @@ bool MainWindow::writeArm9Bin(const std::string& savePath, bool isArm9FooterPres
 }
 
 
-bool MainWindow::writeArm9BinPadding(char paddingType, const std::string& savePath, bool isFooterPresent)
+NFResult MainWindow::writeArm9BinPadding(char paddingType, const std::string& savePath, bool isFooterPresent)
 {
     uint32_t startAddr = extractPackerHeaderTableData(NDSHeaderNames::ARM9RomAddress).toUInt(nullptr, 16) +
         extractPackerHeaderTableData(NDSHeaderNames::ARM9Size).toUInt(nullptr, 16);
@@ -160,7 +160,7 @@ bool MainWindow::writeArm9BinPadding(char paddingType, const std::string& savePa
         size);
 }
 
-bool MainWindow::writeArm9Overlay(const std::string& savePath)
+NFResult MainWindow::writeArm9Overlay(const std::string& savePath)
 {
     return ndsFactory.writeSectionToFile(
         ui->loadedArm9OverlayPathEdt->text().toStdString(),
@@ -169,7 +169,7 @@ bool MainWindow::writeArm9Overlay(const std::string& savePath)
         extractPackerHeaderTableData(NDSHeaderNames::ARM9OverlaySize).toUInt(nullptr, 16));
 }
 
-bool MainWindow::writeArm9OverlayFiles(const std::string& savePath)
+NFResult MainWindow::writeArm9OverlayFiles(const std::string& savePath)
 {
     uint32_t startAddr = extractPackerHeaderTableData(NDSHeaderNames::ARM9OverlayAddress).toUInt(nullptr, 16) +
         extractPackerHeaderTableData(NDSHeaderNames::ARM9OverlaySize).toUInt(nullptr, 16);
@@ -181,7 +181,7 @@ bool MainWindow::writeArm9OverlayFiles(const std::string& savePath)
         size);
 }
 
-bool MainWindow::writeArm7Bin(const std::string& savePath)
+NFResult MainWindow::writeArm7Bin(const std::string& savePath)
 {
     return ndsFactory.writeSectionToFile(
                 ui->loadedArm7BinPathEdt->text().toStdString(),
@@ -190,7 +190,7 @@ bool MainWindow::writeArm7Bin(const std::string& savePath)
                 extractPackerHeaderTableData(NDSHeaderNames::ARM7Size).toUInt(nullptr, 16));
 }
 
-bool MainWindow::writeArm7BinPadding(char paddingType, const std::string& savePath)
+NFResult MainWindow::writeArm7BinPadding(char paddingType, const std::string& savePath)
 {
     uint32_t startAddr = extractPackerHeaderTableData(NDSHeaderNames::ARM7RomAddress).toUInt(nullptr, 16) +
         extractPackerHeaderTableData(NDSHeaderNames::ARM7Size).toUInt(nullptr, 16);
@@ -207,7 +207,7 @@ bool MainWindow::writeArm7BinPadding(char paddingType, const std::string& savePa
         size);
 }
 
-bool MainWindow::writeArm7Overlay(const std::string& savePath)
+NFResult MainWindow::writeArm7Overlay(const std::string& savePath)
 {
     return ndsFactory.writeSectionToFile(
         ui->loadedArm7OverlayPathEdt->text().toStdString(),
@@ -216,7 +216,7 @@ bool MainWindow::writeArm7Overlay(const std::string& savePath)
         extractPackerHeaderTableData(NDSHeaderNames::ARM7OverlaySize).toUInt(nullptr, 16));
 }
 
-bool MainWindow::writeArm7OverlayFiles(const std::string& savePath)
+NFResult MainWindow::writeArm7OverlayFiles(const std::string& savePath)
 {
     uint32_t startAddr = extractPackerHeaderTableData(NDSHeaderNames::ARM7OverlayAddress).toUInt(nullptr, 16) +
         extractPackerHeaderTableData(NDSHeaderNames::ARM7OverlaySize).toUInt(nullptr, 16);
@@ -228,7 +228,7 @@ bool MainWindow::writeArm7OverlayFiles(const std::string& savePath)
         size);
 }
 
-bool MainWindow::writeFnt(const std::string& savePath)
+NFResult MainWindow::writeFnt(const std::string& savePath)
 {
     return ndsFactory.writeSectionToFile(
                 ui->loadedFntPathEdt->text().toStdString(),
@@ -237,7 +237,7 @@ bool MainWindow::writeFnt(const std::string& savePath)
                 extractPackerHeaderTableData(NDSHeaderNames::FilenameTableSize).toUInt(nullptr, 16));
 }
 
-bool MainWindow::writeFntPadding(char paddingType, const std::string& savePath)
+NFResult MainWindow::writeFntPadding(char paddingType, const std::string& savePath)
 {
     uint32_t startAddr = extractPackerHeaderTableData(NDSHeaderNames::FilenameTableAddress).toUInt(nullptr, 16) +
         extractPackerHeaderTableData(NDSHeaderNames::FilenameTableSize).toUInt(nullptr, 16);
@@ -250,7 +250,7 @@ bool MainWindow::writeFntPadding(char paddingType, const std::string& savePath)
         size);
 }
 
-bool MainWindow::writeFat(const std::string& savePath)
+NFResult MainWindow::writeFat(const std::string& savePath)
 {
     return ndsFactory.writeSectionToFile(
                 ui->loadedFatPathEdt->text().toStdString(),
@@ -259,7 +259,7 @@ bool MainWindow::writeFat(const std::string& savePath)
                 extractPackerHeaderTableData(NDSHeaderNames::FATSize).toUInt(nullptr, 16));
 }
 
-bool MainWindow::writeFatPadding(char paddingType, const std::string& savePath)
+NFResult MainWindow::writeFatPadding(char paddingType, const std::string& savePath)
 {
     uint32_t startAddr = extractPackerHeaderTableData(NDSHeaderNames::FATAddress).toUInt(nullptr, 16) +
         extractPackerHeaderTableData(NDSHeaderNames::FATSize).toUInt(nullptr, 16);
@@ -272,7 +272,7 @@ bool MainWindow::writeFatPadding(char paddingType, const std::string& savePath)
         size);
 }
 
-bool MainWindow::writeIconTitle(const std::string& savePath)
+NFResult MainWindow::writeIconTitle(const std::string& savePath)
 {
     return ndsFactory.writeSectionToFile(
                 ui->loadedIconTitlePathEdt->text().toStdString(),
@@ -281,7 +281,7 @@ bool MainWindow::writeIconTitle(const std::string& savePath)
                 IconTitleSize);
 }
 
-bool MainWindow::writeFatFiles(const std::string& savePath)
+NFResult MainWindow::writeFatFiles(const std::string& savePath)
 {
     uint32_t startAddr = extractPackerHeaderTableData(NDSHeaderNames::IconTitleAddress).toUInt(nullptr, 16) + IconTitleSize;
     uint32_t size = extractPackerHeaderTableData(NDSHeaderNames::UsedRomSize).toUInt(nullptr, 16) - startAddr;
@@ -293,7 +293,7 @@ bool MainWindow::writeFatFiles(const std::string& savePath)
                 size);
 }
 
-bool MainWindow::writeRomPadding(const std::string& savePath)
+NFResult MainWindow::writeRomPadding(const std::string& savePath)
 {
      uint32_t startAddr = extractPackerHeaderTableData(NDSHeaderNames::UsedRomSize).toUInt(nullptr, 16);
      uint32_t size = static_cast<uint32_t>(ndsFactory.getCardSizeInBytes(extractPackerHeaderTableData(NDSHeaderNames::CardSize).toInt())) - startAddr;
@@ -305,9 +305,9 @@ bool MainWindow::writeRomPadding(const std::string& savePath)
                  size);
 }
 
-bool MainWindow::writeEverything(const std::string& savePath)
+NFResult MainWindow::writeEverything(const std::string& savePath)
 {
-    bool res = true;
+	NFResult nfResult;
     char paddingType;
     bool isArm9FooterPresent = ndsFactory.checkArm9FooterPresence(ui->loadedArm9BinPathEdt->text().toStdString(),
         extractPackerHeaderTableData(NDSHeaderNames::ARM9Size).toUInt(nullptr, 16));
@@ -318,32 +318,49 @@ bool MainWindow::writeEverything(const std::string& savePath)
 
     std::remove(savePath.c_str());
 
-    res &= writeHeader(savePath);
-    res &= writeHeaderPadding(paddingType, savePath);
-    res &= writeArm9Bin(savePath, isArm9FooterPresent);
-    res &= writeArm9BinPadding(paddingType, savePath, isArm9FooterPresent);
+    nfResult = writeHeader(savePath);
+    if (!nfResult.result) return nfResult;
+    nfResult = writeHeaderPadding(paddingType, savePath);
+    if (!nfResult.result) return nfResult;
+    nfResult = writeArm9Bin(savePath, isArm9FooterPresent);
+    if (!nfResult.result) return nfResult;
+    nfResult = writeArm9BinPadding(paddingType, savePath, isArm9FooterPresent);
+    if (!nfResult.result) return nfResult;
     if (extractPackerHeaderTableData(NDSHeaderNames::ARM9OverlayAddress).toUInt(nullptr, 16) != 0)
     {
-        res &= writeArm9Overlay(savePath);
-        res &= writeArm9OverlayFiles(savePath);
+        nfResult = writeArm9Overlay(savePath);
+        if (!nfResult.result) return nfResult;
+        nfResult = writeArm9OverlayFiles(savePath);
+        if (!nfResult.result) return nfResult;
     }
-    res &= writeArm7Bin(savePath);
-    res &= writeArm7BinPadding(paddingType, savePath);
+    nfResult = writeArm7Bin(savePath);
+    if (!nfResult.result) return nfResult;
+    nfResult = writeArm7BinPadding(paddingType, savePath);
+    if (!nfResult.result) return nfResult;
     if (extractPackerHeaderTableData(NDSHeaderNames::ARM7OverlayAddress).toUInt(nullptr, 16) != 0) {
-        res &= writeArm7Overlay(savePath);
-        res &= writeArm7OverlayFiles(savePath);
+        nfResult = writeArm7Overlay(savePath);
+        if (!nfResult.result) return nfResult;
+        nfResult = writeArm7OverlayFiles(savePath);
+        if (!nfResult.result) return nfResult;
     }
-    res &= writeFnt(savePath);
-    res &= writeFntPadding(paddingType, savePath);
-    res &= writeFat(savePath);
-    res &= writeFatPadding(paddingType, savePath);
-    res &= writeIconTitle(savePath);
-    res &= writeFatFiles(savePath);
+    nfResult = writeFnt(savePath);
+    if (!nfResult.result) return nfResult;
+    nfResult = writeFntPadding(paddingType, savePath);
+    if (!nfResult.result) return nfResult;
+    nfResult = writeFat(savePath);
+    if (!nfResult.result) return nfResult;
+    nfResult = writeFatPadding(paddingType, savePath);
+    if (!nfResult.result) return nfResult;
+    nfResult = writeIconTitle(savePath);
+    if (!nfResult.result) return nfResult;
+    nfResult = writeFatFiles(savePath);
+    if (!nfResult.result) return nfResult;
     if(!ui->packerTrimRomsCbx->isChecked())
     {
-        res &= writeRomPadding(savePath);
+        nfResult = writeRomPadding(savePath);
+        if (!nfResult.result) return nfResult;
     }
-    return res;
+	return { true, "" };
 }
 
 QString MainWindow::extractPackerHeaderTableData(int index)
diff --git a/ui/tabs/packer/packertabsignals.cpp b/ui/tabs/packer/packertabsignals.cpp
index 8db62ca..c1b72f7 100644
--- a/ui/tabs/packer/packertabsignals.cpp
+++ b/ui/tabs/packer/packertabsignals.cpp
@@ -16,13 +16,9 @@ void MainWindow::on_packerLoadHeaderBtn_clicked()
           QDir::currentPath(),
           "NDS Header (*.bin)");
 
-    if(headerPath.isNull())
-    {
-        QMessageBox::critical(this, tr("NDSFactory"), tr("Unable to open file!"));
-        return;
-    }
+    if (headerPath.isNull()) return;
 
-    if (ndsFactory.loadRomHeader(headerPath.toStdString(), romHeader))
+    if (ndsFactory.loadRomHeader(headerPath.toStdString(), romHeader).result)
     {
         pNDSHeader = reinterpret_cast<NDSHeader*>(romHeader.data());
         populatePackerSectionHeader(pNDSHeader);
@@ -180,9 +176,11 @@ void MainWindow::on_packerBuildNDSRomBtn_clicked()
         "NDS ROM (*.nds)");
 
     if (!dirPath.isNull())
-        writeEverything(dirPath.toStdString()) ? QMessageBox::information(this, tr("NDSFactory"), tr("Creation completed!"))
-                                               : QMessageBox::critical(this, tr("NDSFactory"), tr("Error during the creation!"));
-
+    {
+        NFResult nfResult = writeEverything(dirPath.toStdString());
+        nfResult.result? QMessageBox::information(this, tr("NDSFactory"), tr("Creation completed!"))
+            : QMessageBox::critical(this, tr("NDSFactory"), nfResult.message.c_str());
+    }
     ui->packerBuildNDSRomBtn->setEnabled(true);
 }
 
diff --git a/ui/tabs/unpacker/unpackertabfunctions.cpp b/ui/tabs/unpacker/unpackertabfunctions.cpp
index 260c250..0bed758 100644
--- a/ui/tabs/unpacker/unpackertabfunctions.cpp
+++ b/ui/tabs/unpacker/unpackertabfunctions.cpp
@@ -51,7 +51,7 @@ void MainWindow::disableExtractionButtons()
     ui->unpackerExtraGbx->setEnabled(false);
 }
 
-bool MainWindow::dumpHeader(const std::string& dirPath)
+NFResult MainWindow::dumpHeader(const std::string& dirPath)
 {
     return ndsFactory.dumpDataFromFile(
                 ui->loadedRomPath->text().toStdString(),
@@ -60,7 +60,7 @@ bool MainWindow::dumpHeader(const std::string& dirPath)
                 ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::HeaderSize, 1).data().toString().toUInt(nullptr,16));
 }
 
-bool MainWindow::dumpArm9Bin(const std::string& dirPath, bool dumpExtraBytes)
+NFResult MainWindow::dumpArm9Bin(const std::string& dirPath, bool dumpExtraBytes)
 {
     uint32_t size = ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::ARM9Size, 1).data().toString().toUInt(nullptr,16);
     if (dumpExtraBytes)
@@ -72,7 +72,7 @@ bool MainWindow::dumpArm9Bin(const std::string& dirPath, bool dumpExtraBytes)
                 size);
 }
 
-bool MainWindow::dumpArm7Bin(const std::string& dirPath)
+NFResult MainWindow::dumpArm7Bin(const std::string& dirPath)
 {
     return ndsFactory.dumpDataFromFile(
                 ui->loadedRomPath->text().toStdString(),
@@ -81,7 +81,7 @@ bool MainWindow::dumpArm7Bin(const std::string& dirPath)
                 ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::ARM7Size, 1).data().toString().toUInt(nullptr,16));
 }
 
-bool MainWindow::dumpFnt(const std::string& dirPath)
+NFResult MainWindow::dumpFnt(const std::string& dirPath)
 {
     return ndsFactory.dumpDataFromFile(
                 ui->loadedRomPath->text().toStdString(),
@@ -90,7 +90,7 @@ bool MainWindow::dumpFnt(const std::string& dirPath)
                 ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::FilenameTableSize, 1).data().toString().toUInt(nullptr,16));
 }
 
-bool MainWindow::dumpFat(const std::string& dirPath)
+NFResult MainWindow::dumpFat(const std::string& dirPath)
 {
     return ndsFactory.dumpDataFromFile(
                 ui->loadedRomPath->text().toStdString(),
@@ -99,7 +99,7 @@ bool MainWindow::dumpFat(const std::string& dirPath)
                 ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::FATSize, 1).data().toString().toUInt(nullptr,16));
 }
 
-bool MainWindow::dumpArm9Overlay(const std::string& dirPath)
+NFResult MainWindow::dumpArm9Overlay(const std::string& dirPath)
 {
     return ndsFactory.dumpDataFromFile(
                 ui->loadedRomPath->text().toStdString(),
@@ -108,7 +108,7 @@ bool MainWindow::dumpArm9Overlay(const std::string& dirPath)
                 ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::ARM9OverlaySize, 1).data().toString().toUInt(nullptr,16));
 }
 
-bool MainWindow::dumpArm9OverlayFiles(const std::string& dirPath)
+NFResult MainWindow::dumpArm9OverlayFiles(const std::string& dirPath)
 {
     uint32_t startAddr = ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::ARM9OverlayAddress, 1).data().toString().toUInt(nullptr, 16) +
         ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::ARM9OverlaySize, 1).data().toString().toUInt(nullptr, 16);
@@ -121,7 +121,7 @@ bool MainWindow::dumpArm9OverlayFiles(const std::string& dirPath)
         size);
 }
 
-bool MainWindow::dumpArm7Overlay(const std::string& dirPath)
+NFResult MainWindow::dumpArm7Overlay(const std::string& dirPath)
 {
     return ndsFactory.dumpDataFromFile(
                 ui->loadedRomPath->text().toStdString(),
@@ -130,7 +130,7 @@ bool MainWindow::dumpArm7Overlay(const std::string& dirPath)
                 ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::ARM7OverlaySize, 1).data().toString().toUInt(nullptr,16));
 }
 
-bool MainWindow::dumpArm7OverlayFiles(const std::string& dirPath)
+NFResult MainWindow::dumpArm7OverlayFiles(const std::string& dirPath)
 {
     uint32_t startAddr = ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::ARM7OverlayAddress, 1).data().toString().toUInt(nullptr, 16) +
         ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::ARM7OverlaySize, 1).data().toString().toUInt(nullptr, 16);
@@ -143,7 +143,7 @@ bool MainWindow::dumpArm7OverlayFiles(const std::string& dirPath)
         size);
 }
 
-bool MainWindow::dumpIconTitle(const std::string& dirPath)
+NFResult MainWindow::dumpIconTitle(const std::string& dirPath)
 {
     return ndsFactory.dumpDataFromFile(
                 ui->loadedRomPath->text().toStdString(),
@@ -152,7 +152,7 @@ bool MainWindow::dumpIconTitle(const std::string& dirPath)
                 ICON_TITLE_SIZE);
 }
 
-bool MainWindow::dumpFatFiles(const std::string& dirPath)
+NFResult MainWindow::dumpFatFiles(const std::string& dirPath)
 {
     uint32_t startAddr = ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::IconTitleAddress, 1).data().toString().toUInt(nullptr,16) + IconTitleSize ;
     uint32_t size = ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::UsedRomSize, 1).data().toString().toUInt(nullptr,16) - startAddr;
@@ -165,23 +165,34 @@ bool MainWindow::dumpFatFiles(const std::string& dirPath)
 }
 
 
-bool MainWindow::dumpEverything(QString dirPath)
+NFResult MainWindow::dumpEverything(QString dirPath)
 {
-    bool result = true;
-    result &= dumpHeader(QDir::toNativeSeparators(dirPath+"/header.bin").toStdString());
-    result &= dumpArm9Bin(QDir::toNativeSeparators(dirPath+"/arm9.bin").toStdString(), true);
-    result &= dumpArm7Bin(QDir::toNativeSeparators(dirPath+"/arm7.bin").toStdString());
-    result &= dumpFnt(QDir::toNativeSeparators(dirPath+"/fnt.bin").toStdString());
-    result &= dumpFat(QDir::toNativeSeparators(dirPath+"/fat.bin").toStdString());
+    NFResult nfResult;
+    nfResult = dumpHeader(QDir::toNativeSeparators(dirPath + "/header.bin").toStdString());
+	if (!nfResult.result) return nfResult;
+    nfResult = dumpArm9Bin(QDir::toNativeSeparators(dirPath+"/arm9.bin").toStdString(), true);
+    if (!nfResult.result) return nfResult;
+    nfResult = dumpArm7Bin(QDir::toNativeSeparators(dirPath+"/arm7.bin").toStdString());
+    if (!nfResult.result) return nfResult;
+    nfResult = dumpFnt(QDir::toNativeSeparators(dirPath+"/fnt.bin").toStdString());
+    if (!nfResult.result) return nfResult;
+    nfResult = dumpFat(QDir::toNativeSeparators(dirPath+"/fat.bin").toStdString());
+    if (!nfResult.result) return nfResult;
     if(ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::ARM9OverlayAddress, 1).data().toString().toUInt(nullptr,16) != 0) {
-		result &= dumpArm9Overlay(QDir::toNativeSeparators(dirPath+"/a9ovr.bin").toStdString());
-		result &= dumpArm9OverlayFiles(QDir::toNativeSeparators(dirPath+"/a9ovr_data.bin").toStdString());
+        nfResult = dumpArm9Overlay(QDir::toNativeSeparators(dirPath+"/a9ovr.bin").toStdString());
+        if (!nfResult.result) return nfResult;
+        nfResult = dumpArm9OverlayFiles(QDir::toNativeSeparators(dirPath+"/a9ovr_data.bin").toStdString());
+        if (!nfResult.result) return nfResult;
 	}
     if(ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::ARM7OverlayAddress, 1).data().toString().toUInt(nullptr,16) != 0) {
-        result &= dumpArm7Overlay(QDir::toNativeSeparators(dirPath+"/a7ovr.bin").toStdString());
-        result &= dumpArm7OverlayFiles(QDir::toNativeSeparators(dirPath+"/a7ovr_data.bin").toStdString());
-        }
-    result &= dumpIconTitle(QDir::toNativeSeparators(dirPath+"/itl.bin").toStdString());
-    result &= dumpFatFiles(QDir::toNativeSeparators(dirPath+"/fat_data.bin").toStdString());
-    return result;
+        nfResult = dumpArm7Overlay(QDir::toNativeSeparators(dirPath+"/a7ovr.bin").toStdString());
+        if (!nfResult.result) return nfResult;
+        nfResult = dumpArm7OverlayFiles(QDir::toNativeSeparators(dirPath+"/a7ovr_data.bin").toStdString());
+        if (!nfResult.result) return nfResult;
+    }
+    nfResult = dumpIconTitle(QDir::toNativeSeparators(dirPath+"/itl.bin").toStdString());
+    if (!nfResult.result) return nfResult;
+    nfResult = dumpFatFiles(QDir::toNativeSeparators(dirPath+"/fat_data.bin").toStdString());
+    if (!nfResult.result) return nfResult;
+	return { true, "" };
 }
diff --git a/ui/tabs/unpacker/unpackertabsignals.cpp b/ui/tabs/unpacker/unpackertabsignals.cpp
index 0122003..95fb1d5 100644
--- a/ui/tabs/unpacker/unpackertabsignals.cpp
+++ b/ui/tabs/unpacker/unpackertabsignals.cpp
@@ -17,12 +17,11 @@ void MainWindow::on_loadRomBtn_clicked()
           QDir::currentPath(),
           "NDS Rom (*.nds)");
 
-    if( !romPath.isNull() )
-    {
-      ui->loadedRomPath->setText(romPath.toUtf8());
-    }
+    if (romPath.isNull()) return;
 
-    if (ndsFactory.loadRomHeader(ui->loadedRomPath->text().toStdString(), romHeader))
+    ui->loadedRomPath->setText(romPath.toUtf8());
+
+    if (ndsFactory.loadRomHeader(ui->loadedRomPath->text().toStdString(), romHeader).result)
     {
         pNDSHeader = reinterpret_cast<NDSHeader*>(romHeader.data());
         populateHeader(pNDSHeader);
diff --git a/ui/utils/ui.h b/ui/utils/ui.h
index d4f26f5..fea9464 100644
--- a/ui/utils/ui.h
+++ b/ui/utils/ui.h
@@ -1,15 +1,16 @@
 #pragma once
 
 #include <QMessageBox>
+#include "../../ndsfactory/nfresult.h"
 
-void notifyExtractionResult(bool result)
+void notifyExtractionResult(NFResult nfResult)
 {
-	if (result)
+	if (nfResult.result)
 	{
 		QMessageBox::information(Q_NULLPTR, "NDSFactory", "Extraction completed!");
 	}
 	else
 	{
-		QMessageBox::critical(Q_NULLPTR, "NDSFactory", "Error during the extraction!");
+		QMessageBox::critical(Q_NULLPTR, "NDSFactory", nfResult.message.c_str());
 	}
 }
\ No newline at end of file