diff --git a/requirements.txt b/requirements.txt
index 08001f7..41e6fd5 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,8 +1,8 @@
-PySide6==6.6.0
+PySide6==6.6.1
 semantic-version==2.10.0
 patool==1.12.0
 
 # For external purposes
-pyinstaller==6.2.0
-pytest==7.4.2
-pytest-qt==4.2.0
\ No newline at end of file
+pyinstaller==6.3.0
+pytest==7.4.4
+pytest-qt==4.3.1
\ No newline at end of file
diff --git a/src/constant_vars.py b/src/constant_vars.py
index 264ee6b..6684e32 100644
--- a/src/constant_vars.py
+++ b/src/constant_vars.py
@@ -96,4 +96,4 @@ class ProfileRole():
 # Program Info
 PROGRAM_NAME = 'Myth Mod Manager'
 
-VERSION = semantic_version.Version(major=1, minor=4, patch=0)
+VERSION = semantic_version.Version(major=1, minor=4, patch=1)
diff --git a/src/getPath.py b/src/getPath.py
index 10ede5a..89b4a35 100644
--- a/src/getPath.py
+++ b/src/getPath.py
@@ -11,19 +11,19 @@ def __init__(self, optionFile: str = OPTIONS_CONFIG) -> None:
     
     def __getGamepath(self) -> str:
         return OptionsManager(self.option).getGamepath()
-    
+
     def mod_overrides(self) -> str:
         '''Returns mod_overrides path'''
         return os.path.join(self.__getGamepath(), 'assets', 'mod_overrides')
-    
+
     def mods(self) -> str:
         '''Returns mods directory path'''
         return os.path.join(self.__getGamepath(), 'mods')
-    
+
     def maps(self) -> str:
         '''Returns maps directory path'''
         return os.path.join(self.__getGamepath(), 'Maps')
-    
+
     def mod(self, type: ModType, modName: str) -> list[str] | str:
         '''
         Returns mod path given the type and name,
diff --git a/src/threaded/QThread.py b/src/threaded/QThread.py
deleted file mode 100644
index 8df9191..0000000
--- a/src/threaded/QThread.py
+++ /dev/null
@@ -1,18 +0,0 @@
-from PySide6.QtCore import QThread, Signal
-
-class Thread(QThread):
-    '''Base Class for threading inheriting PySide's QThread'''
-
-    setTotalProgress = Signal(int)
-
-    addTotalProgress = Signal(int)
-
-    setCurrentProgress = Signal(int, str)
-
-    succeeded = Signal()
-
-    doneCanceling = Signal()
-
-    error = Signal(str)
-
-    cancel = False
diff --git a/src/threaded/backupMods.py b/src/threaded/backupMods.py
index 167b2a0..b893bc8 100644
--- a/src/threaded/backupMods.py
+++ b/src/threaded/backupMods.py
@@ -2,18 +2,14 @@
 import shutil
 import logging
 
-from src.threaded.file_mover import FileMover
+from src.threaded.workerQObject import Worker
 from src.constant_vars import ModType, BACKUP_MODS, MODSIGNORE, MOD_CONFIG
 
-class BackupMods(FileMover):
+class BackupMods(Worker):
 
     bundledFilePath = os.path.join(os.path.abspath(os.curdir), BACKUP_MODS)
 
-    def run(self) -> None:
-        self.backupMods()
-        return super().run()
-
-    def backupMods(self) -> None:
+    def start(self) -> None:
             '''Takes all of the mods and compresses them into a zip file, the output is in the exe directory'''
 
             # Step 1: Gather Options
@@ -113,7 +109,4 @@ def backupMods(self) -> None:
                     shutil.rmtree(self.bundledFilePath)
 
                 if not self.cancel:
-                    logging.error('Something went wrong in FileSaver.backupMods():\n%s', str(e))
                     self.error.emit(f'Something went wrong in FileSaver.backupMods():\n{e}')
-                
-                    self.cancel = True
diff --git a/src/threaded/changeModType.py b/src/threaded/changeModType.py
index 2cfe9ff..6bb0ab0 100644
--- a/src/threaded/changeModType.py
+++ b/src/threaded/changeModType.py
@@ -2,31 +2,27 @@
 import os
 
 import src.errorChecking as errorChecking
-from src.threaded.file_mover import FileMover
+from src.threaded.workerQObject import Worker
 from src.constant_vars import ModType
 
-class ChangeModType(FileMover):
+class ChangeModType(Worker):
     def __init__(self, *mods: tuple[str, ModType]):
         super().__init__()
         logging.getLogger(__name__)
 
         self.mods = mods
-
-    def run(self) -> None:
-        self.changeModType(*self.mods)
-        return super().run()
     
-    def changeModType(self, *mods: tuple[str, ModType]) -> None:
+    def start(self) -> None:
         '''
         Moves the mod to a new directory
         '''
 
         try:
-            self.setTotalProgress.emit(len(mods))
+            self.setTotalProgress.emit(len(self.mods))
 
             ChosenDir = None
             
-            for mod in mods:
+            for mod in self.mods:
 
                 self.cancelCheck()
 
@@ -47,6 +43,4 @@ def changeModType(self, *mods: tuple[str, ModType]) -> None:
             self.succeeded.emit()
 
         except Exception as e:
-            logging.error('An error occured in changeModType:\n%s', str(e))
-            self.error.emit(str(e))
-            self.cancel = True
+            self.error.emit(f'An error occured in changeModType:\n{e}')
diff --git a/src/threaded/deleteMod.py b/src/threaded/deleteMod.py
index 372209a..be56e0a 100644
--- a/src/threaded/deleteMod.py
+++ b/src/threaded/deleteMod.py
@@ -2,30 +2,27 @@
 import os
 import shutil
 
-from src.threaded.file_mover import FileMover
+from src.threaded.workerQObject import Worker
 
-class DeleteMod(FileMover):
-    def __init__(self, *mods: str):
-        super().__init__()
-        logging.getLogger(__name__)
+from src.constant_vars import MOD_CONFIG, OPTIONS_CONFIG
+
+class DeleteMod(Worker):
+    def __init__(self, *mods: str, optionsPath: str = OPTIONS_CONFIG, savePath: str = MOD_CONFIG):
+        super().__init__(optionsPath=optionsPath, savePath=savePath)
 
         self.mods = mods
-    
-    def run(self) -> None:
-        self.deleteMod(*self.mods)
-        return super().run()
-    
-    def deleteMod(self, *mods: str) -> None:
+
+    def start(self) -> None:
         '''Removes the mod(s) from the user's computer'''
 
-        logging.info('Deleting mods from computer: %s', ', '.join(mods))
+        logging.info('Deleting mods from computer: %s', ', '.join(self.mods))
 
-        self.setTotalProgress.emit(len(mods))
+        self.setTotalProgress.emit(len(self.mods))
 
         disPath = self.optionsManager.getDispath()
 
         try: 
-            for modName in mods:
+            for modName in self.mods:
 
                 self.cancelCheck()
 
@@ -47,6 +44,4 @@ def deleteMod(self, *mods: str) -> None:
             self.succeeded.emit()
 
         except Exception as e:
-            logging.error('An error has occured in deleteMod():\n%s', str(e))
-            self.error.emit(str(e))
-            self.cancel = True
+            self.error.emit(f'An error has occured in deleteMod():\n{e}')
diff --git a/src/threaded/moveToDisabledDir.py b/src/threaded/moveToDisabledDir.py
index 0356d9a..17da54e 100644
--- a/src/threaded/moveToDisabledDir.py
+++ b/src/threaded/moveToDisabledDir.py
@@ -1,29 +1,26 @@
 import os
 import logging
 
-from src.threaded.file_mover import FileMover
+from src.threaded.workerQObject import Worker
 
+from src.constant_vars import MOD_CONFIG, OPTIONS_CONFIG
 
-class MoveToDisabledDir(FileMover):
-    def __init__(self, *mods: str) -> None:
-        super().__init__()
+class MoveToDisabledDir(Worker):
+    def __init__(self, *mods: str, optionsPath: str = OPTIONS_CONFIG, savePath: str = MOD_CONFIG) -> None:
+        super().__init__(optionsPath=optionsPath, savePath=savePath)
 
         self.mods = mods
-    
-    def run(self) -> None:
-        self.moveToDisabledDir(*self.mods)
-        return super().run()
-    
-    def moveToDisabledDir(self, *mods: str) -> None:
+
+    def start(self) -> None:
         '''Moves a mod to the disabled folder'''
 
-        self.setTotalProgress.emit(len(mods))
+        self.setTotalProgress.emit(len(self.mods))
 
         disabledModsPath = self.optionsManager.getDispath()
 
         try:
 
-            for mod in mods:
+            for mod in self.mods:
 
                 self.cancelCheck()
 
@@ -37,11 +34,8 @@ def moveToDisabledDir(self, *mods: str) -> None:
                     self.move(modPath, os.path.join(disabledModsPath, mod))
                 else:
                     logging.info('%s is already in the disabled directory', mod)
-            
+
             self.succeeded.emit()
-        
+
         except Exception as e:
-            logging.error('An error occured while disabling a mod:\n%s', str(e))
             self.error.emit(f'An error occured while disabling a mod:\n{e}')
-
-            self.cancel = True
diff --git a/src/threaded/moveToEnabledDir.py b/src/threaded/moveToEnabledDir.py
index 7ecd015..fd0c0c5 100644
--- a/src/threaded/moveToEnabledDir.py
+++ b/src/threaded/moveToEnabledDir.py
@@ -1,28 +1,27 @@
 import logging
 import os
 
-from src.threaded.file_mover import FileMover
+from src.threaded.workerQObject import Worker
 
-class MoveToEnabledModDir(FileMover):
-    def __init__(self, *mods: str):
-        super().__init__()
+from src.constant_vars import MOD_CONFIG, OPTIONS_CONFIG
+
+class MoveToEnabledModDir(Worker):
+
+    def __init__(self, *mods: str, optionsPath: str = OPTIONS_CONFIG, savePath: str = MOD_CONFIG):
+        super().__init__(optionsPath=optionsPath, savePath=savePath)
 
         self.mods = mods
-    
-    def run(self) -> None:
-        self.moveToEnableModDir(*self.mods)
-        return super().run()
-    
-    def moveToEnableModDir(self, *mods: str) -> None:
+
+    def start(self) -> None:
         '''Returns a mod to their respective directory'''
 
         try:
 
-            self.setTotalProgress.emit(len(mods))
+            self.setTotalProgress.emit(len(self.mods))
 
             disabledModsPath = self.optionsManager.getDispath()
 
-            for mod in mods:
+            for mod in self.mods:
 
                 self.cancelCheck()
 
@@ -39,7 +38,4 @@ def moveToEnableModDir(self, *mods: str) -> None:
             self.succeeded.emit()
 
         except Exception as e:
-            logging.error('An error occured while enabling a mod:\n%s', str(e))
             self.error.emit(f'An error occured while enabling a mod:\n{e}')
-
-            self.cancel = True            
diff --git a/src/threaded/unZipMod.py b/src/threaded/unZipMod.py
index d5800c5..22796dc 100644
--- a/src/threaded/unZipMod.py
+++ b/src/threaded/unZipMod.py
@@ -3,29 +3,25 @@
 
 import patoolib
 
-from src.threaded.file_mover import FileMover
+from src.threaded.workerQObject import Worker
 from src.constant_vars import ModType
 
-class UnZipMod(FileMover):
+class UnZipMod(Worker):
     def __init__(self, *mods: tuple[str, ModType]):
         super().__init__()
 
         self.mods = mods
-    
-    def run(self) -> None:
-        self.unZipMod(*self.mods)
-        return super().run()
 
-    def unZipMod(self, *mods: tuple[str, ModType]) -> None:
+    def start(self) -> None:
         '''Extracts a mod and puts it into a destination based off the ModType Enum given'''
 
-        self.setTotalProgress.emit(len(mods))
+        self.setTotalProgress.emit(len(self.mods))
 
         modDestDict = {ModType.mods : self.p.mods(), ModType.mods_override : self.p.mod_overrides(), ModType.maps : self.p.maps()}
 
         try:
 
-            for modURL in mods:
+            for modURL in self.mods:
 
                 src = modURL[0]
 
@@ -48,15 +44,7 @@ def unZipMod(self, *mods: tuple[str, ModType]) -> None:
             self.succeeded.emit()
         
         except patoolib.util.PatoolError as e:
-
-            logging.error('An error was raised in FileMover.unZipMod():\n%s\nTry extracting the mod manually first', str(e))
             self.error.emit(f'An error was raised in FileMover.unZipMod():\n{e}\nTry extracting the mod manually first')
 
-            self.cancel = True
-
         except Exception as e:
-
-            logging.error('An error was raised in FileMover.unZipMod():\n%s', str(e))
             self.error.emit(f'An error was raised in FileMover.unZipMod():\n{e}')
-
-            self.cancel = True
diff --git a/src/threaded/file_mover.py b/src/threaded/workerQObject.py
similarity index 88%
rename from src/threaded/file_mover.py
rename to src/threaded/workerQObject.py
index 557cdee..d6e96c8 100644
--- a/src/threaded/file_mover.py
+++ b/src/threaded/workerQObject.py
@@ -1,44 +1,47 @@
+import logging
 import shutil
 import os
-import logging
+
+from PySide6.QtCore import Signal, QObject
 
 from src.save import Save, OptionsManager
 from src.getPath import Pathing
 import src.errorChecking as errorChecking
-from src.threaded.QThread import Thread
 
 from src.constant_vars import MOD_CONFIG, OPTIONS_CONFIG
 
+class Worker(QObject):
+    setTotalProgress = Signal(int)
 
-class FileMover(Thread):
-    '''
-    Base class for threaded functions involving file manipulation
-    '''
+    addTotalProgress = Signal(int)
 
-    def __init__(self, optionsPath: str = OPTIONS_CONFIG, savePath: str = MOD_CONFIG):
-        super().__init__()
+    setCurrentProgress = Signal(int, str)
+
+    succeeded = Signal()
+
+    doneCanceling = Signal()
+
+    error = Signal(str)
 
+    cancel = False
+
+    def __init__(self, optionsPath: str = OPTIONS_CONFIG, savePath: str = MOD_CONFIG) -> None:
+        super().__init__()
         logging.getLogger(__name__)
 
         self.saveManager = Save(savePath)
         self.optionsManager = OptionsManager(optionsPath)
 
         self.p = Pathing(optionsPath)
-    
+
+    def start() -> None:
+        ...
+
     def cancelCheck(self) -> None:
         logging.info('%s was canceled', self.__class__)
         if self.cancel:
             self.doneCanceling.emit()
 
-    def onError(self, func, path, exc_info):
-        """Used for `shutil.rmtree()`s `onerror` kwarg"""
-
-        logging.warning('An error was raised in shutil:\n%s', exc_info)
-
-        if not errorChecking.permissionCheck(path):
-
-            func(path)
-    
     def move(self, src: str, dest: str):
         '''`shutil.move()` with some extra exception handling'''
 
@@ -81,3 +84,12 @@ def move(self, src: str, dest: str):
                 # If shutil.move made a partial dir of the mod delete it
                 if os.path.exists(dest):
                     shutil.rmtree(dest, onerror=self.onError)
+
+    def onError(self, func, path, exc_info):
+        """Used for `shutil.rmtree()`s `onerror` kwarg"""
+
+        logging.warning('An error was raised in shutil:\n%s', exc_info)
+
+        if not errorChecking.permissionCheck(path):
+
+            func(path)
diff --git a/src/widgets/QDialog/announcementQDialog.py b/src/widgets/QDialog/announcementQDialog.py
index 9937564..235eede 100644
--- a/src/widgets/QDialog/announcementQDialog.py
+++ b/src/widgets/QDialog/announcementQDialog.py
@@ -1,4 +1,3 @@
-
 import PySide6.QtWidgets as qtw
 
 from src.widgets.QDialog.QDialog import Dialog
@@ -14,7 +13,7 @@ def __init__(self, message: str, headline: str = 'Notice') -> None:
         self.warningLabel = qtw.QLabel(self, text=message)
         self.warningLabel.setWordWrap(True)
 
-        buttons = qtw.QDialogButtonBox.Ok
+        buttons = qtw.QDialogButtonBox.StandardButton.Ok
 
         self.buttonBox = qtw.QDialogButtonBox(buttons)
         self.buttonBox.accepted.connect(self.accept)
diff --git a/src/widgets/QDialog/deleteWarningQDialog.py b/src/widgets/QDialog/deleteWarningQDialog.py
index 82c2dc5..bd00f4a 100644
--- a/src/widgets/QDialog/deleteWarningQDialog.py
+++ b/src/widgets/QDialog/deleteWarningQDialog.py
@@ -1,4 +1,3 @@
-
 import PySide6.QtWidgets as qtw
 
 from src.widgets.QDialog.QDialog import Dialog
diff --git a/src/widgets/managerQTableWidget.py b/src/widgets/managerQTableWidget.py
index 0c72ca4..a4a8959 100644
--- a/src/widgets/managerQTableWidget.py
+++ b/src/widgets/managerQTableWidget.py
@@ -414,9 +414,12 @@ def openModDir(self) -> None:
             modName = self.getNameItem(self.row(selectedItem)).text()
             modType = self.getTypeItem(self.row(selectedItem)).text()
 
-            path = self.p.mod(ModType(modType), modName)
+            if not self.saveManager.getEnabled(modName):
+                path = os.path.join(self.optionsManager.getDispath(), modName)
+            else:
+                path = self.p.mod(ModType(modType), modName)
 
-            if os.path.exists(path):
+            if os.path.isdir(path):
                 errorChecking.startFile(path)
 
     def hideMod(self) -> None:
diff --git a/src/widgets/progressWidget.py b/src/widgets/progressWidget.py
index 0e88657..566730e 100644
--- a/src/widgets/progressWidget.py
+++ b/src/widgets/progressWidget.py
@@ -1,30 +1,43 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
 import logging
 
 import PySide6.QtGui as qtg
 import PySide6.QtWidgets as qtw
+from PySide6.QtCore import QThread
 
 from src.widgets.QDialog.QDialog import Dialog
 
-from src.threaded.file_mover import FileMover
+if TYPE_CHECKING:
+    from src.threaded.workerQObject import Worker
 
 class ProgressWidget(Dialog):
     '''
     QDialog object to show the progress of threaded functions
     '''
 
-    def __init__(self, mode: FileMover) -> None:
+    def __init__(self, mode: Worker) -> None:
         super().__init__()
-
-        self.mode = mode
-
         logging.getLogger(__name__)
 
         self.setWindowTitle('Myth Mod Manager Task')
 
+        self.mode = mode
+
         layout = qtw.QVBoxLayout()
 
-        self.warningLabel = qtw.QLabel(self)
+        # Create QThread
+        self.qthread = QThread()
+        self.qthread.started.connect(self.mode.start)
+
+        # Move task to QThread
+        self.mode.moveToThread(self.qthread)
 
+        # Label
+        self.infoLabel = qtw.QLabel(self)
+
+        # Progress bar and connecting signals
         self.progressBar = qtw.QProgressBar()
         self.mode.setTotalProgress.connect(lambda x: self.progressBar.setMaximum(x))
         self.mode.setCurrentProgress.connect(lambda x, y: self.updateProgressBar(x, y))
@@ -33,38 +46,43 @@ def __init__(self, mode: FileMover) -> None:
         self.mode.error.connect(lambda x: self.errorRaised(x))
         self.mode.succeeded.connect(self.succeeded)
 
+        # Button
         buttons = qtw.QDialogButtonBox.StandardButton.Cancel
 
         self.buttonBox = qtw.QDialogButtonBox(buttons)
-        self.buttonBox.rejected.connect(lambda: self.cancel())
+        self.buttonBox.rejected.connect(self.cancel)
 
-        for widget in (self.warningLabel, self.progressBar, self.buttonBox):
+        for widget in (self.infoLabel, self.progressBar, self.buttonBox):
             layout.addWidget(widget)
         
         self.setLayout(layout)
     
     def exec(self) -> int:
 
-        self.mode.start()
+        self.qthread.start()
         return super().exec()
     
     def errorRaised(self, message: str):
-        self.warningLabel.setText(message)
+        logging.error(message)
+
+        self.infoLabel.setText(f'{message}\nExit to continue')
+        self.qthread.exit(1)
 
     def succeeded(self):
         self.progressBar.setValue(self.progressBar.maximum())
-        self.warningLabel.setText('Done!')
+        self.infoLabel.setText('Done!')
 
-        self.mode.terminate()
-        self.mode.deleteLater()
+        self.qthread.exit(0)
 
         self.accept()
     
     def closeEvent(self, arg__1: qtg.QCloseEvent) -> None:
 
-        if self.mode.isRunning():
+        if self.qthread.isRunning():
             self.cancel()
         else:
+            self.mode.deleteLater()
+            self.qthread.deleteLater()
             return super().closeEvent(arg__1)
     
     def cancel(self):
@@ -76,10 +94,11 @@ def cancel(self):
         isModeCanceled = self.mode.cancel
 
         if isModeCanceled:
+            self.qthread.exit(2)
             self.reject()
 
-        logging.info('Task %s was canceled...', str(self.mode))
-        self.warningLabel.setText('Canceling... (Finishing current step)')
+        logging.info('Task %s was canceled', str(self.mode))
+        self.infoLabel.setText('Canceled, exit to continue')
 
         self.mode.cancel = True
     
@@ -87,5 +106,5 @@ def updateProgressBar(self, x, y):
 
         newValue = x + self.progressBar.value()
 
-        self.warningLabel.setText(y)
+        self.infoLabel.setText(y)
         self.progressBar.setValue(newValue)
diff --git a/tests/threaded/test_backupMods.py b/tests/threaded/test_backupMods.py
index e2c4955..27e1f7c 100644
--- a/tests/threaded/test_backupMods.py
+++ b/tests/threaded/test_backupMods.py
@@ -17,15 +17,15 @@ def test_thread(create_mod_dirs: str, createTemp_Config_ini: str, createTemp_Mod
     parser.setDispath(dispath)
     parser.writeData()
 
-    thread = BackupMods()
-    thread.saveManager = Save(createTemp_Mod_ini)
-    thread.optionsManager = parser
+    worker = BackupMods()
+    worker.saveManager = Save(createTemp_Mod_ini)
+    worker.optionsManager = parser
     bundledFilePath = os.path.join(create_mod_dirs, BACKUP_MODS)
-    thread.bundledFilePath = bundledFilePath
+    worker.bundledFilePath = bundledFilePath
 
-    thread.p = Pathing(createTemp_Config_ini)
+    worker.p = Pathing(createTemp_Config_ini)
 
-    thread.backupMods()
+    worker.start()
 
     assert os.path.isfile(f'{bundledFilePath}.zip')
 
diff --git a/tests/threaded/test_changeModType.py b/tests/threaded/test_changeModType.py
index 0cef39a..63dd94a 100644
--- a/tests/threaded/test_changeModType.py
+++ b/tests/threaded/test_changeModType.py
@@ -11,13 +11,13 @@ def test_thread(create_mod_dirs: str, createTemp_Config_ini: str, createTemp_Mod
     parser.setGamepath(create_mod_dirs)
     parser.writeData()
 
-    thread = ChangeModType()
-    thread.saveManager = Save(createTemp_Mod_ini)
-    thread.p = Pathing(createTemp_Config_ini)
-
     url = os.path.join(create_mod_dirs, 'mods', 'make game easy mod')
 
-    thread.changeModType((url, ModType.mods_override))
+    worker = ChangeModType((url, ModType.mods_override))
+    worker.saveManager = Save(createTemp_Mod_ini)
+    worker.p = Pathing(createTemp_Config_ini)
+
+    worker.start()
 
     assert os.path.isdir(os.path.join(create_mod_dirs, 'mods', 'make game easy mod')) == False
     assert os.path.isdir(os.path.join(create_mod_dirs, 'assets', 'mod_overrides', 'make game easy mod'))
diff --git a/tests/threaded/test_deleteMod.py b/tests/threaded/test_deleteMod.py
index 5e3464e..a1ab278 100644
--- a/tests/threaded/test_deleteMod.py
+++ b/tests/threaded/test_deleteMod.py
@@ -11,12 +11,12 @@ def test_thread(create_mod_dirs: str, createTemp_Config_ini: str, createTemp_Mod
     parser.setGamepath(create_mod_dirs)
     parser.writeData()
 
-    thread = DeleteMod()
-    thread.optionsManager = parser
-    thread.saveManager = Save(createTemp_Mod_ini)
+    worker = DeleteMod('make game easy mod')
+    worker.optionsManager = parser
+    worker.saveManager = Save(createTemp_Mod_ini)
 
-    thread.p = Pathing(createTemp_Config_ini)
+    worker.p = Pathing(createTemp_Config_ini)
 
-    thread.deleteMod('make game easy mod')
+    worker.start()
 
     assert os.path.isdir(os.path.join(create_mod_dirs, 'mods', 'make game easy mod')) == False
diff --git a/tests/threaded/test_moveToDisabledDir.py b/tests/threaded/test_moveToDisabledDir.py
index db6b091..1389c55 100644
--- a/tests/threaded/test_moveToDisabledDir.py
+++ b/tests/threaded/test_moveToDisabledDir.py
@@ -12,13 +12,13 @@ def test_thread(create_mod_dirs: str, createTemp_Config_ini: str, createTemp_Mod
     parser.setDispath(dispath)
     parser.writeData()
 
-    thread = MoveToDisabledDir()
-    thread.saveManager = Save(createTemp_Mod_ini)
-    thread.optionsManager = parser
+    worker = MoveToDisabledDir('make game easy mod')
+    worker.saveManager = Save(createTemp_Mod_ini)
+    worker.optionsManager = parser
 
-    thread.p = Pathing(createTemp_Config_ini)
+    worker.p = Pathing(createTemp_Config_ini)
 
-    thread.moveToDisabledDir('make game easy mod')
+    worker.start()
 
     assert os.path.isdir(os.path.join(create_mod_dirs, 'disabledMods', 'make game easy mod'))
     assert not os.path.isdir(os.path.join(create_mod_dirs, 'mods', 'make game easy mod'))
diff --git a/tests/threaded/test_moveToEnabledDir.py b/tests/threaded/test_moveToEnabledDir.py
index 71b9e9f..6300133 100644
--- a/tests/threaded/test_moveToEnabledDir.py
+++ b/tests/threaded/test_moveToEnabledDir.py
@@ -18,13 +18,13 @@ def test_thread(create_mod_dirs: str, createTemp_Config_ini: str, createTemp_Mod
 
     shutil.move(enabledDir, disabledDir)
 
-    thread = MoveToEnabledModDir()
-    thread.saveManager = Save(createTemp_Mod_ini)
-    thread.optionsManager = parser
+    worker = MoveToEnabledModDir('make game easy mod')
+    worker.saveManager = Save(createTemp_Mod_ini)
+    worker.optionsManager = parser
 
-    thread.p = Pathing(createTemp_Config_ini)
+    worker.p = Pathing(createTemp_Config_ini)
 
-    thread.moveToEnableModDir('make game easy mod')
+    worker.start()
 
     assert os.path.isdir(enabledDir)
     assert not os.path.isdir(disabledDir)
diff --git a/tests/threaded/test_unZipMod.py b/tests/threaded/test_unZipMod.py
index aa35367..29a752b 100644
--- a/tests/threaded/test_unZipMod.py
+++ b/tests/threaded/test_unZipMod.py
@@ -19,14 +19,14 @@ def test_thread(create_mod_dirs: str, createTemp_Config_ini: str, createTemp_Mod
     os.mkdir(zip_path)
     shutil.make_archive(zip_path, 'zip')
 
-    thread = UnZipMod()
-    thread.optionsManager = parser
-    thread.saveManager = Save(createTemp_Mod_ini)
+    url = os.path.join(create_mod_dirs, 'zip.zip')
 
-    thread.p = Pathing(createTemp_Config_ini)
+    worker = UnZipMod((url, ModType.mods))
+    worker.optionsManager = parser
+    worker.saveManager = Save(createTemp_Mod_ini)
 
-    url = os.path.join(create_mod_dirs, 'zip.zip')
+    worker.p = Pathing(createTemp_Config_ini)
 
-    thread.unZipMod((url, ModType.mods))
+    worker.start()
 
-    assert os.path.exists(os.path.join(create_mod_dirs, 'mods', 'zip'))
+    assert os.path.isdir(os.path.join(create_mod_dirs, 'mods', 'zip'))
diff --git a/tests/widgets/test_progressWidget.py b/tests/widgets/test_progressWidget.py
index ddc80c7..afa1f06 100644
--- a/tests/widgets/test_progressWidget.py
+++ b/tests/widgets/test_progressWidget.py
@@ -2,36 +2,36 @@
 from pytestqt.qtbot import QtBot
 
 from src.widgets.progressWidget import ProgressWidget
-from src.threaded.file_mover import FileMover
+from src.threaded.workerQObject import Worker
 
 @pytest.fixture(scope='function')
-def create_progressWidget(qtbot: QtBot) -> tuple[FileMover, ProgressWidget, QtBot]:
-    obj = FileMover()
+def create_progressWidget(qtbot: QtBot) -> tuple[Worker, ProgressWidget, QtBot]:
+    obj = Worker()
     widget = ProgressWidget(obj)
 
     qtbot.addWidget(widget)
 
     return obj, widget, qtbot
 
-def test_errorRaised(create_progressWidget: tuple[FileMover, ProgressWidget, QtBot]) -> None:
+def test_errorRaised(create_progressWidget: tuple[Worker, ProgressWidget, QtBot]) -> None:
 
     create_progressWidget[0].error.emit('error')
 
-    assert create_progressWidget[1].warningLabel.text() == 'error'
+    assert create_progressWidget[1].infoLabel.text() == 'error\nExit to continue'
 
-def test_succeeded(create_progressWidget: tuple[FileMover, ProgressWidget, QtBot]) -> None:
+def test_succeeded(create_progressWidget: tuple[Worker, ProgressWidget, QtBot]) -> None:
 
     create_progressWidget[0].succeeded.emit()
 
-    assert create_progressWidget[1].warningLabel.text() == 'Done!'
+    assert create_progressWidget[1].infoLabel.text() == 'Done!'
     assert create_progressWidget[1].progressBar.value() == create_progressWidget[1].progressBar.maximum()
     assert create_progressWidget[1].result() == 1
 
-def test_cancel(create_progressWidget: tuple[FileMover, ProgressWidget, QtBot]) -> None:
+def test_cancel(create_progressWidget: tuple[Worker, ProgressWidget, QtBot]) -> None:
 
     create_progressWidget[1].cancel()
 
-    assert create_progressWidget[1].warningLabel.text() == 'Canceling... (Finishing current step)'
+    assert create_progressWidget[1].infoLabel.text() == 'Canceled, exit to continue'
     assert create_progressWidget[0].cancel
 
     create_progressWidget[1].cancel()
@@ -42,7 +42,7 @@ def test_cancel(create_progressWidget: tuple[FileMover, ProgressWidget, QtBot])
 
     assert create_progressWidget[1].result() == 0
 
-def test_updateProgressBar(create_progressWidget: tuple[FileMover, ProgressWidget, QtBot]) -> None:
+def test_updateProgressBar(create_progressWidget: tuple[Worker, ProgressWidget, QtBot]) -> None:
 
     create_progressWidget[0].setTotalProgress.emit(100)
     assert create_progressWidget[1].progressBar.maximum() == 100
@@ -52,4 +52,4 @@ def test_updateProgressBar(create_progressWidget: tuple[FileMover, ProgressWidge
 
     create_progressWidget[0].setCurrentProgress.emit(51, 'testing ^_^')
     assert create_progressWidget[1].progressBar.value() == 50
-    assert create_progressWidget[1].warningLabel.text() == 'testing ^_^'
\ No newline at end of file
+    assert create_progressWidget[1].infoLabel.text() == 'testing ^_^'
\ No newline at end of file