diff --git a/pype/hooks/celaction/pre_celaction_registers.py b/pype/hooks/celaction/pre_celaction_registers.py
new file mode 100644
index 0000000000..c638ce3c0b
--- /dev/null
+++ b/pype/hooks/celaction/pre_celaction_registers.py
@@ -0,0 +1,128 @@
+import os
+import shutil
+import winreg
+from pype.lib import PreLaunchHook
+from pype.hosts import celaction
+
+
+class CelactionPrelaunchHook(PreLaunchHook):
+    """
+    This hook will check if current workfile path has Unreal
+    project inside. IF not, it initialize it and finally it pass
+    path to the project by environment variable to Unreal launcher
+    shell script.
+    """
+    workfile_ext = "scn"
+    hosts = ["celaction"]
+    platforms = ["windows"]
+
+    def execute(self):
+        # Add workfile path to launch arguments
+        workfile_path = self.workfile_path()
+        if workfile_path:
+            self.launch_context.launch_args.append(
+                "\"{}\"".format(workfile_path)
+            )
+
+        project_name = self.data["project_name"]
+        asset_name = self.data["asset_name"]
+        task_name = self.data["task_name"]
+
+        # get publish version of celaction
+        app = "celaction_publish"
+
+        # setting output parameters
+        path = r"Software\CelAction\CelAction2D\User Settings"
+        winreg.CreateKey(winreg.HKEY_CURRENT_USER, path)
+        hKey = winreg.OpenKey(
+            winreg.HKEY_CURRENT_USER,
+            "Software\\CelAction\\CelAction2D\\User Settings", 0,
+            winreg.KEY_ALL_ACCESS)
+
+        # TODO: change to root path and pyblish standalone to premiere way
+        pype_root_path = os.getenv("PYPE_SETUP_PATH")
+        path = os.path.join(pype_root_path,
+                            "pype.bat")
+
+        winreg.SetValueEx(hKey, "SubmitAppTitle", 0, winreg.REG_SZ, path)
+
+        parameters = [
+            "launch",
+            f"--app {app}",
+            f"--project {project_name}",
+            f"--asset {asset_name}",
+            f"--task {task_name}",
+            "--currentFile \\\"\"*SCENE*\"\\\"",
+            "--chunk 10",
+            "--frameStart *START*",
+            "--frameEnd *END*",
+            "--resolutionWidth *X*",
+            "--resolutionHeight *Y*",
+            # "--programDir \"'*PROGPATH*'\""
+        ]
+        winreg.SetValueEx(hKey, "SubmitParametersTitle", 0, winreg.REG_SZ,
+                          " ".join(parameters))
+
+        # setting resolution parameters
+        path = r"Software\CelAction\CelAction2D\User Settings\Dialogs"
+        path += r"\SubmitOutput"
+        winreg.CreateKey(winreg.HKEY_CURRENT_USER, path)
+        hKey = winreg.OpenKey(winreg.HKEY_CURRENT_USER, path, 0,
+                              winreg.KEY_ALL_ACCESS)
+        winreg.SetValueEx(hKey, "SaveScene", 0, winreg.REG_DWORD, 1)
+        winreg.SetValueEx(hKey, "CustomX", 0, winreg.REG_DWORD, 1920)
+        winreg.SetValueEx(hKey, "CustomY", 0, winreg.REG_DWORD, 1080)
+
+        # making sure message dialogs don't appear when overwriting
+        path = r"Software\CelAction\CelAction2D\User Settings\Messages"
+        path += r"\OverwriteScene"
+        winreg.CreateKey(winreg.HKEY_CURRENT_USER, path)
+        hKey = winreg.OpenKey(winreg.HKEY_CURRENT_USER, path, 0,
+                              winreg.KEY_ALL_ACCESS)
+        winreg.SetValueEx(hKey, "Result", 0, winreg.REG_DWORD, 6)
+        winreg.SetValueEx(hKey, "Valid", 0, winreg.REG_DWORD, 1)
+
+        path = r"Software\CelAction\CelAction2D\User Settings\Messages"
+        path += r"\SceneSaved"
+        winreg.CreateKey(winreg.HKEY_CURRENT_USER, path)
+        hKey = winreg.OpenKey(winreg.HKEY_CURRENT_USER, path, 0,
+                              winreg.KEY_ALL_ACCESS)
+        winreg.SetValueEx(hKey, "Result", 0, winreg.REG_DWORD, 1)
+        winreg.SetValueEx(hKey, "Valid", 0, winreg.REG_DWORD, 1)
+
+    def workfile_path(self):
+        workfile_path = self.data["last_workfile"]
+
+        # copy workfile from template if doesnt exist any on path
+        if not os.path.exists(workfile_path):
+            # TODO add ability to set different template workfile path via
+            # settings
+            pype_celaction_dir = os.path.dirname(
+                os.path.abspath(celaction.__file__)
+            )
+            template_path = os.path.join(
+                pype_celaction_dir,
+                "celaction_template_scene.scn"
+            )
+
+            if not os.path.exists(template_path):
+                self.log.warning(
+                    "Couldn't find workfile template file in {}".format(
+                        template_path
+                    )
+                )
+                return
+
+            self.log.info(
+                f"Creating workfile from template: \"{template_path}\""
+            )
+
+            # Copy template workfile to new destinantion
+            shutil.copy2(
+                os.path.normpath(template_path),
+                os.path.normpath(workfile_path)
+            )
+
+        self.log.info(f"Workfile to open: \"{workfile_path}\"")
+
+        return workfile_path
diff --git a/pype/hooks/fusion/pre_fusion_setup.py b/pype/hooks/fusion/pre_fusion_setup.py
new file mode 100644
index 0000000000..ac7dda4250
--- /dev/null
+++ b/pype/hooks/fusion/pre_fusion_setup.py
@@ -0,0 +1,50 @@
+import os
+import importlib
+from pype.lib import PreLaunchHook
+from pype.hosts.fusion import utils
+
+
+class FusionPrelaunch(PreLaunchHook):
+    """
+    This hook will check if current workfile path has Fusion
+    project inside.
+    """
+    hosts = ["fusion"]
+
+    def execute(self):
+        # making sure pyton 3.6 is installed at provided path
+        py36_dir = os.path.normpath(self.env.get("PYTHON36", ""))
+        assert os.path.isdir(py36_dir), (
+            "Python 3.6 is not installed at the provided folder path. Either "
+            "make sure the `environments\resolve.json` is having correctly "
+            "set `PYTHON36` or make sure Python 3.6 is installed "
+            f"in given path. \nPYTHON36E: `{py36_dir}`"
+        )
+        self.log.info(f"Path to Fusion Python folder: `{py36_dir}`...")
+        self.env["PYTHON36"] = py36_dir
+
+        # setting utility scripts dir for scripts syncing
+        us_dir = os.path.normpath(
+            self.env.get("FUSION_UTILITY_SCRIPTS_DIR", "")
+        )
+        assert os.path.isdir(us_dir), (
+            "Fusion utility script dir does not exists. Either make sure "
+            "the `environments\fusion.json` is having correctly set "
+            "`FUSION_UTILITY_SCRIPTS_DIR` or reinstall DaVinci Resolve. \n"
+            f"FUSION_UTILITY_SCRIPTS_DIR: `{us_dir}`"
+        )
+
+        try:
+            __import__("avalon.fusion")
+            __import__("pyblish")
+
+        except ImportError:
+            self.log.warning(
+                "pyblish: Could not load Fusion integration.",
+                exc_info=True
+            )
+
+        else:
+            # Resolve Setup integration
+            importlib.reload(utils)
+            utils.setup(self.env)
diff --git a/pype/hooks/photoshop/pre_launch_args.py b/pype/hooks/photoshop/pre_launch_args.py
new file mode 100644
index 0000000000..bc747dc495
--- /dev/null
+++ b/pype/hooks/photoshop/pre_launch_args.py
@@ -0,0 +1,53 @@
+import os
+import platform
+
+from pype.lib import PreLaunchHook
+
+
+class PhotoshopPrelaunchHook(PreLaunchHook):
+    """Launch arguments preparation.
+
+    Hook add python executable and execute python script of photoshop
+    implementation before photoshop executable.
+    """
+    hosts = ["photoshop"]
+
+    def execute(self):
+        # Pop tvpaint executable
+        photoshop_executable = self.launch_context.launch_args.pop(0)
+
+        # Pop rest of launch arguments - There should not be other arguments!
+        remainders = []
+        while self.launch_context.launch_args:
+            remainders.append(self.launch_context.launch_args.pop(0))
+
+        python_launch_args = [
+            self.python_executable(),
+            "-c",
+            (
+                "^\"import avalon.photoshop;"
+                "avalon.photoshop.launch(\"{}\")^\"\""
+            ).format(photoshop_executable)
+        ]
+        if platform.system().lower() != "windows":
+            new_launch_args = python_launch_args
+        else:
+            new_launch_args = [
+                "cmd.exe",
+                "/k",
+                "\"{}\"".format(" ".join(python_launch_args))
+            ]
+
+        # Append as whole list as these areguments should not be separated
+        self.launch_context.launch_args.append(new_launch_args)
+
+        if remainders:
+            self.log.warning((
+                "There are unexpected launch arguments in Photoshop launch. {}"
+            ).format(str(remainders)))
+            self.launch_context.launch_args.extend(remainders)
+
+    def python_executable(self):
+        """Should lead to python executable."""
+        # TODO change in Pype 3
+        return os.environ["PYPE_PYTHON_EXE"]
diff --git a/pype/hooks/tvpaint/pre_launch_args.py b/pype/hooks/tvpaint/pre_launch_args.py
index 9f90398433..6c59a8ce20 100644
--- a/pype/hooks/tvpaint/pre_launch_args.py
+++ b/pype/hooks/tvpaint/pre_launch_args.py
@@ -22,30 +22,30 @@ class TvpaintPrelaunchHook(PreLaunchHook):
     hosts = ["tvpaint"]
 
     def execute(self):
+        # Pop tvpaint executable
         tvpaint_executable = self.launch_context.launch_args.pop(0)
 
-        # This should never be used!
+        # Pop rest of launch arguments - There should not be other arguments!
         remainders = []
         while self.launch_context.launch_args:
             remainders.append(self.launch_context.launch_args.pop(0))
 
-        self.launch_context.launch_args.append(
-            self.main_executable()
-        )
-        self.launch_context.launch_args.append(
-            "\"{}\"".format(self.launch_script_path())
-        )
-        self.launch_context.launch_args.append(
+        new_launch_args = [
+            self.main_executable(),
+            "\"{}\"".format(self.launch_script_path()),
             "\"{}\"".format(tvpaint_executable)
-        )
+        ]
 
         # Add workfile to launch arguments
         workfile_path = self.workfile_path()
         if workfile_path:
-            self.launch_context.launch_args.append(
+            new_launch_args.append(
                 "\"{}\"".format(workfile_path)
             )
 
+        # Append as whole list as these areguments should not be separated
+        self.launch_context.launch_args.append(new_launch_args)
+
         if remainders:
             self.log.warning((
                 "There are unexpected launch arguments in TVPaint launch. {}"