diff --git a/hatsploit/__main__.py b/hatsploit/__main__.py
index 970dbf5a5..d536f574e 100755
--- a/hatsploit/__main__.py
+++ b/hatsploit/__main__.py
@@ -46,6 +46,7 @@
 from hatsploit.lib.jobs import Jobs
 from hatsploit.lib.runtime import Runtime
 from hatsploit.lib.payloads import Payloads
+from hatsploit.lib.encoders import Encoders
 from hatsploit.lib.show import Show
 
 
@@ -326,6 +327,7 @@ def __init__(self) -> None:
 
         self.hatasm = HatAsm()
         self.payloads = Payloads()
+        self.encoders = Encoders()
 
         self.show = Show()
 
@@ -462,9 +464,11 @@ def cli(self) -> None:
                 query += '/' + args.arch
 
             if args.payloads:
-                self.show.show_search_payloads(query)
+                self.show.show_search_payloads(
+                    self.payloads.get_payloads(), query)
             elif args.encoders:
-                self.show.show_search_encoders(query)
+                self.show.show_search_encoders(
+                    self.encoders.get_encoders(), query)
 
         elif args.formats:
             if not args.platform:
diff --git a/hatsploit/commands/advanced.py b/hatsploit/commands/advanced.py
index b98d08426..20f3740a9 100755
--- a/hatsploit/commands/advanced.py
+++ b/hatsploit/commands/advanced.py
@@ -30,4 +30,4 @@ def rpc(self, *args):
         return self.modules.get_current_advanced()
 
     def run(self, argc, argv):
-        self.show.show_advanced()
+        self.show.show_advanced(self.modules.get_current_module())
diff --git a/hatsploit/commands/encoder_db.py b/hatsploit/commands/encoder_db.py
index ceb7c3d4f..ef8e533c8 100755
--- a/hatsploit/commands/encoder_db.py
+++ b/hatsploit/commands/encoder_db.py
@@ -60,10 +60,14 @@ def run(self, argc, argv):
         choice = argv[1]
 
         if choice == '-l':
-            self.show.show_encoder_databases()
+            self.show.show_encoder_databases(
+                self.db.get_encoder_databases())
+
         elif choice == '-d':
             self.db.disconnect_encoder_database(argv[2])
+
         elif choice == '-b':
             self.builder.build_encoder_database(argv[2], argv[3])
+
         elif choice == '-c':
             self.db.connect_encoder_database(argv[2], argv[3])
diff --git a/hatsploit/commands/encoders.py b/hatsploit/commands/encoders.py
index 10c5832b9..07cbe751b 100755
--- a/hatsploit/commands/encoders.py
+++ b/hatsploit/commands/encoders.py
@@ -30,4 +30,4 @@ def rpc(self, *args):
         return self.encoders.get_encoders()
 
     def run(self, argc, argv):
-        self.show.show_encoders()
+        self.show.show_encoders(self.encoders.get_encoders())
diff --git a/hatsploit/commands/jobs.py b/hatsploit/commands/jobs.py
index a7713cbec..318eb06ab 100755
--- a/hatsploit/commands/jobs.py
+++ b/hatsploit/commands/jobs.py
@@ -34,7 +34,7 @@ def run(self, argc, argv):
         choice = argv[1]
 
         if choice == '-l':
-            self.show.show_jobs()
+            self.show.show_jobs(self.jobs.get_jobs())
 
         elif choice == '-k':
             self.jobs.delete_job(argv[2])
diff --git a/hatsploit/commands/loot.py b/hatsploit/commands/loot.py
index 1aa05e266..44be146b5 100755
--- a/hatsploit/commands/loot.py
+++ b/hatsploit/commands/loot.py
@@ -34,7 +34,7 @@ def run(self, argc, argv):
         choice = argv[1]
 
         if choice == '-l':
-            self.show.show_loot()
+            self.show.show_loot(self.loot.list_loot())
 
         elif choice == '-r':
             self.loot.remove_loot(argv[2])
diff --git a/hatsploit/commands/module_db.py b/hatsploit/commands/module_db.py
index a00742e8b..846e9dcd3 100755
--- a/hatsploit/commands/module_db.py
+++ b/hatsploit/commands/module_db.py
@@ -57,10 +57,14 @@ def run(self, argc, argv):
         choice = argv[1]
 
         if choice == '-l':
-            self.show.show_module_databases()
+            self.show.show_module_databases(
+                self.db.get_module_databases())
+
         elif choice == '-d':
             self.db.disconnect_module_database(argv[2])
+
         elif choice == '-b':
             self.builder.build_module_database(argv[2], argv[3])
+
         elif choice == '-c':
             self.db.connect_module_database(argv[2], argv[3])
diff --git a/hatsploit/commands/modules.py b/hatsploit/commands/modules.py
index 255c81bfa..9ceb696db 100755
--- a/hatsploit/commands/modules.py
+++ b/hatsploit/commands/modules.py
@@ -48,9 +48,9 @@ def run(self, argc, argv):
 
         if argc > 1:
             if argv[1] in categories:
-                self.show.show_modules(argv[1])
+                self.show.show_modules(self.modules.get_modules(), argv[1])
             else:
                 self.print_error("Invalid module category!")
                 self.print_information(f"Available categories: {str(categories)}")
         else:
-            self.show.show_modules()
+            self.show.show_modules(self.modules.get_modules())
diff --git a/hatsploit/commands/options.py b/hatsploit/commands/options.py
index 70b3fa9a9..ed1de6687 100755
--- a/hatsploit/commands/options.py
+++ b/hatsploit/commands/options.py
@@ -30,4 +30,4 @@ def rpc(self, *args):
         return self.modules.get_current_options()
 
     def run(self, argc, argv):
-        self.show.show_options()
+        self.show.show_options(self.modules.get_current_module())
diff --git a/hatsploit/commands/payload_db.py b/hatsploit/commands/payload_db.py
index ca1fb066c..34e77589b 100755
--- a/hatsploit/commands/payload_db.py
+++ b/hatsploit/commands/payload_db.py
@@ -60,10 +60,14 @@ def run(self, argc, argv):
         choice = argv[1]
 
         if choice == '-l':
-            self.show.show_payload_databases()
+            self.show.show_payload_databases(
+                self.db.get_payload_databases())
+
         elif choice == '-d':
             self.db.disconnect_payload_database(argv[2])
+
         elif choice == '-b':
             self.builder.build_payload_database(argv[2], argv[3])
+
         elif choice == '-c':
             self.db.connect_payload_database(argv[2], argv[3])
diff --git a/hatsploit/commands/payloads.py b/hatsploit/commands/payloads.py
index 9c31666e0..e6194351b 100755
--- a/hatsploit/commands/payloads.py
+++ b/hatsploit/commands/payloads.py
@@ -30,4 +30,4 @@ def rpc(self, *args):
         return self.payloads.get_payloads()
 
     def run(self, argc, argv):
-        self.show.show_payloads()
+        self.show.show_payloads(self.payloads.get_payloads())
diff --git a/hatsploit/commands/plugin_db.py b/hatsploit/commands/plugin_db.py
index 54819201d..976847af2 100755
--- a/hatsploit/commands/plugin_db.py
+++ b/hatsploit/commands/plugin_db.py
@@ -57,10 +57,14 @@ def run(self, argc, argv):
         choice = argv[1]
 
         if choice == '-l':
-            self.show.show_plugin_databases()
+            self.show.show_plugin_databases(
+                self.db.get_plugin_databases())
+
         elif choice == '-d':
             self.db.disconnect_plugin_database(argv[2])
+
         elif choice == '-b':
             self.builder.build_plugin_database(argv[2], argv[3])
+
         elif choice == '-c':
             self.db.connect_plugin_database(argv[2], argv[3])
diff --git a/hatsploit/commands/plugins.py b/hatsploit/commands/plugins.py
index d395cbc7e..ef2b843b0 100755
--- a/hatsploit/commands/plugins.py
+++ b/hatsploit/commands/plugins.py
@@ -13,7 +13,7 @@ def __init__(self):
         super().__init__()
 
         self.show = Show()
-        self.plguins = Plugins()
+        self.plugins = Plugins()
 
         self.details.update({
             'Category': "plugins",
@@ -30,4 +30,4 @@ def rpc(self, *args):
         return self.plugins.get_plugins()
 
     def run(self, argc, argv):
-        self.show.show_plugins()
+        self.show.show_plugins(self.plugins.get_plugins())
diff --git a/hatsploit/commands/search.py b/hatsploit/commands/search.py
index f076254e4..0b9906cac 100755
--- a/hatsploit/commands/search.py
+++ b/hatsploit/commands/search.py
@@ -6,12 +6,21 @@
 from hatsploit.lib.command import Command
 from hatsploit.lib.show import Show
 
+from hatsploit.lib.modules import Modules
+from hatsploit.lib.payloads import Payloads
+from hatsploit.lib.encoders import Encoders
+from hatsploit.lib.plugins import Plugins
+
 
 class HatSploitCommand(Command):
     def __init__(self):
         super().__init__()
 
         self.show = Show()
+        self.modules = Modules()
+        self.payloads = Payloads()
+        self.encoders = Encoders()
+        self.plugins = Plugins()
 
         self.details.update({
             'Category': "core",
@@ -20,26 +29,34 @@ def __init__(self):
                 'Ivan Nikolskiy (enty8080) - command developer',
             ],
             'Description': "Search payloads, modules and plugins.",
-            'Usage': "search <option> <keyword>",
-            'MinArgs': 2,
-            'Options': {
-                '-w': ['[payloads|encoders|modules|plugins]', "Select where to search."],
-                '-e': ['', "Search everywhere."],
-            },
+            'Usage': "search [where] <keyword>",
+            'MinArgs': 1,
         })
 
     def run(self, argc, argv):
-        if argv[1] not in ['-w', '--where']:
-            self.show.show_search_modules(argv[2])
-            self.show.show_search_payloads(argv[2])
-            self.show.show_search_encoders(argv[2])
-            self.show.show_search_plugins(argv[2])
-        else:
-            if argv[2] == 'modules':
-                self.show.show_search_modules(argv[3])
-            elif argv[2] == 'payloads':
-                self.show.show_search_payloads(argv[3])
-            elif argv[2] == 'encoders':
-                self.show.show_search_encoders(argv[3])
-            elif argv[2] == 'plugins':
-                self.show.show_search_plugins(argv[3])
+        if argc > 2:
+            if argv[1] == 'modules':
+                self.show.show_search_modules(
+                    self.modules.get_modules(), argv[2])
+
+            elif argv[1] == 'payloads':
+                self.show.show_search_payloads(
+                    self.payloads.get_payloads(), argv[2])
+
+            elif argv[1] == 'encoders':
+                self.show.show_search_encoders(
+                    self.encoders.get_encoders(), argv[2])
+
+            elif argv[1] == 'plugins':
+                self.show.show_search_plugins(
+                    self.plugins.get_plugins(), argv[2])
+            return
+
+        self.show.show_search_modules(
+            self.modules.get_modules(), argv[1])
+        self.show.show_search_payloads(
+            self.payloads.get_payloads(), argv[1])
+        self.show.show_search_encoders(
+            self.encoders.get_encoders(), argv[1])
+        self.show.show_search_plugins(
+            self.plugins.get_plugins(), argv[1])
diff --git a/hatsploit/commands/sessions.py b/hatsploit/commands/sessions.py
index a9761781a..8104d8378 100755
--- a/hatsploit/commands/sessions.py
+++ b/hatsploit/commands/sessions.py
@@ -36,17 +36,23 @@ def __init__(self):
 
     def run(self, argc, argv):
         if argv[1] == '-l':
-            self.show.show_sessions()
+            self.show.show_sessions(self.sessions.get_sessions())
+
         elif argv[1] == '-c':
             self.sessions.close_session(argv[2])
+
         elif argv[1] == '-i':
             self.sessions.interact_with_session(argv[2])
+
         elif argv[1] == '-d':
             self.sessions.session_download(argv[2], argv[3], argv[4])
+
         elif argv[1] == '-u':
             self.sessions.session_upload(argv[2], argv[3], argv[4])
+
         elif argv[1] == '--auto-interaction':
             if argv[2] == 'on':
                 self.sessions.enable_auto_interaction()
+
             elif argv[2] == 'off':
                 self.sessions.disable_auto_interaction()
diff --git a/hatsploit/core/base/console.py b/hatsploit/core/base/console.py
index 1007c359f..5e44306fe 100755
--- a/hatsploit/core/base/console.py
+++ b/hatsploit/core/base/console.py
@@ -27,11 +27,10 @@
 import sys
 
 from badges import Badges
+from pex.string import String
 
 from hatsploit.core.base.execute import Execute
 
-from hatsploit.core.cli.fmt import FMT
-
 from hatsploit.core.utils.ui.banner import Banner
 from hatsploit.core.utils.ui.completer import Completer
 from hatsploit.core.utils.ui.tip import Tip
@@ -54,7 +53,7 @@ def __init__(self) -> None:
 
         self.execute = Execute()
 
-        self.fmt = FMT()
+        self.string = String()
         self.badges = Badges()
 
         self.completer = Completer()
@@ -91,7 +90,8 @@ def shell_execute(self) -> None:
         commands = self.badges.input_empty(prompt)
 
         self.runtime.update()
-        self.execute.execute_command(self.fmt.format_commands(commands))
+        self.badges.print_function(self.execute.execute_command,
+                                   self.string.split_args(commands))
         self.runtime.update()
 
         if self.local_storage.get("history"):
@@ -211,7 +211,7 @@ def script(self, input_files: list, shell: bool = True) -> None:
                 file.close()
 
                 for line in file_text:
-                    commands = self.fmt.format_commands(line)
+                    commands = self.string.split_args(line)
 
                     self.runtime.update()
                     self.runtime.catch(
diff --git a/hatsploit/core/base/execute.py b/hatsploit/core/base/execute.py
index 1ebd57c56..51638026d 100755
--- a/hatsploit/core/base/execute.py
+++ b/hatsploit/core/base/execute.py
@@ -29,8 +29,6 @@
 from typing import Any, Tuple, Union
 from badges import Badges, Tables
 
-from hatsploit.core.cli.fmt import FMT
-
 from hatsploit.lib.jobs import Jobs
 from hatsploit.lib.modules import Modules
 from hatsploit.lib.show import Show
@@ -48,7 +46,6 @@ def __init__(self) -> None:
         super().__init__()
 
         self.jobs = Jobs()
-        self.fmt = FMT()
         self.badges = Badges()
         self.tables = Tables()
         self.local_storage = LocalStorage()
diff --git a/hatsploit/core/cli/__init__.py b/hatsploit/core/cli/__init__.py
deleted file mode 100755
index e1ed48b46..000000000
--- a/hatsploit/core/cli/__init__.py
+++ /dev/null
@@ -1,23 +0,0 @@
-"""
-MIT License
-
-Copyright (c) 2020-2024 EntySec
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-"""
diff --git a/hatsploit/core/cli/fmt.py b/hatsploit/core/cli/fmt.py
deleted file mode 100755
index 97f1344a2..000000000
--- a/hatsploit/core/cli/fmt.py
+++ /dev/null
@@ -1,53 +0,0 @@
-"""
-MIT License
-
-Copyright (c) 2020-2024 EntySec
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-"""
-
-import re
-
-
-class FMT(object):
-    """ Subclass of hatsploit.core.cli module.
-
-    This subclass of hatsploit.core.cli module is intended for
-    providing tools for formatting.
-    """
-
-    def __init__(self) -> None:
-        super().__init__()
-
-    @staticmethod
-    def format_commands(command: str) -> list:
-        """ Split command by space and commas.
-
-        :param str command: command to split
-        :return list: list of commands
-        """
-
-        commands = re.split(''' (?=(?:[^'"]|'[^']*'|"[^"]*")*$)''', command)
-        formatted_commands = []
-
-        for command in commands:
-            if command:
-                formatted_commands.append(command.strip('"').strip("'"))
-
-        return formatted_commands
diff --git a/hatsploit/core/cli/tools.py b/hatsploit/core/utils/tools.py
similarity index 100%
rename from hatsploit/core/cli/tools.py
rename to hatsploit/core/utils/tools.py
diff --git a/hatsploit/core/utils/ui/completer.py b/hatsploit/core/utils/ui/completer.py
index a6666c078..31a8a995d 100755
--- a/hatsploit/core/utils/ui/completer.py
+++ b/hatsploit/core/utils/ui/completer.py
@@ -24,7 +24,7 @@
 
 import readline
 
-from hatsploit.core.cli.fmt import FMT
+from pex.string import String
 from hatsploit.lib.commands import Commands
 
 
@@ -38,7 +38,7 @@ class Completer(object):
     def __init__(self) -> None:
         super().__init__()
 
-        self.fmt = FMT()
+        self.string = String()
         self.commands = Commands()
 
         self.matches = None
@@ -62,7 +62,7 @@ def completer(self, text: str, state: int) -> list:
             start_index = readline.get_begidx() - stripped
 
             if start_index > 0:
-                command = self.fmt.format_commands(line)
+                command = self.string.split_args(line)
 
                 if command[0] == "":
                     complete_function = self.default_completer
diff --git a/hatsploit/lib/encoder/__init__.py b/hatsploit/lib/encoder/__init__.py
index 636a5d5eb..79ce673b7 100644
--- a/hatsploit/lib/encoder/__init__.py
+++ b/hatsploit/lib/encoder/__init__.py
@@ -28,7 +28,7 @@
 
 from badges import Badges, Tables
 
-from hatsploit.core.cli.tools import Tools
+from hatsploit.core.utils.tools import Tools
 from hatsploit.lib.options import Options
 
 
diff --git a/hatsploit/lib/module/__init__.py b/hatsploit/lib/module/__init__.py
index 687394e2e..f75c30973 100644
--- a/hatsploit/lib/module/__init__.py
+++ b/hatsploit/lib/module/__init__.py
@@ -26,7 +26,7 @@
 
 from badges import Badges, Tables
 
-from hatsploit.core.cli.tools import Tools
+from hatsploit.core.utils.tools import Tools
 from hatsploit.lib.options import Options
 
 
diff --git a/hatsploit/lib/payload/__init__.py b/hatsploit/lib/payload/__init__.py
index 1cc438035..d20dc5efb 100644
--- a/hatsploit/lib/payload/__init__.py
+++ b/hatsploit/lib/payload/__init__.py
@@ -29,7 +29,7 @@
 
 from badges import Badges, Tables
 
-from hatsploit.core.cli.tools import Tools
+from hatsploit.core.utils.tools import Tools
 from hatsploit.lib.options import Options
 
 
diff --git a/hatsploit/lib/plugin.py b/hatsploit/lib/plugin.py
index 835cb2193..fc0f189dc 100755
--- a/hatsploit/lib/plugin.py
+++ b/hatsploit/lib/plugin.py
@@ -24,7 +24,7 @@
 
 from badges import Badges, Tables
 
-from hatsploit.core.cli.tools import Tools
+from hatsploit.core.utils.tools import Tools
 
 
 class Plugin(Badges, Tables, Tools):
diff --git a/hatsploit/lib/show.py b/hatsploit/lib/show.py
index 1c2adb241..2f1f30bee 100755
--- a/hatsploit/lib/show.py
+++ b/hatsploit/lib/show.py
@@ -26,12 +26,12 @@
 from textwrap import dedent
 
 from badges import Badges, Tables
-from colorscript import Colors
 
 from hatsploit.lib.encoders import Encoders
 from hatsploit.lib.jobs import Jobs
 from hatsploit.lib.loot import Loot
 from hatsploit.lib.modules import Modules
+from hatsploit.lib.module import Module
 from hatsploit.lib.payloads import Payloads
 from hatsploit.lib.plugins import Plugins
 from hatsploit.lib.sessions import Sessions
@@ -57,7 +57,6 @@ def __init__(self) -> None:
         self.encoders = Encoders()
         self.sessions = Sessions()
 
-        self.colors = Colors()
         self.tables = Tables()
         self.badges = Badges()
 
@@ -71,21 +70,19 @@ def show_custom_commands(self, commands: dict) -> None:
         :return None: None
         """
 
-        commands_data = {}
+        data = {}
         headers = ("Command", "Description")
 
         for command in sorted(commands):
-            label = commands[command].details['Category']
-            commands_data[label] = []
+            data[commands[command].details['Category']] = []
 
         for command in sorted(commands):
-            label = commands[command].details['Category']
-            commands_data[label].append(
+            data[commands[command].details['Category']].append(
                 (command, commands[command].details['Description'])
             )
 
-        for label in sorted(commands_data):
-            self.tables.print_table(label.title() + " Commands", headers, *commands_data[label])
+        for label in sorted(data):
+            self.tables.print_table(f"{label} Commands", headers, *data[label])
 
     def show_interface_commands(self) -> None:
         """ Show interface commands.
@@ -94,57 +91,62 @@ def show_interface_commands(self) -> None:
         :raises RuntimeWarning: with trailing warning message
         """
 
-        if self.local_storage.get("commands"):
-            self.show_custom_commands(self.local_storage.get("commands"))
-        else:
+        if not self.local_storage.get("commands"):
             raise RuntimeWarning("No commands available.")
 
-    def show_plugin_commands(self) -> None:
-        """ Show all loaded plugin commands.
+        self.show_custom_commands(self.local_storage.get("commands"))
 
+    def show_plugin_commands(self, plugins: dict) -> None:
+        """ Show all plugins commands.
+
+        Note: plugins is a dictionary containing plugin names as keys and
+        plugin objects as items.
+
+        :param dict plugins: plugins
         :return None: None
         """
 
-        plugins = self.plugins.get_loaded_plugins()
-
         for plugin in plugins:
             plugin = plugins[plugin]
 
-            if hasattr(plugin, "commands"):
-                commands_data = {}
-                headers = ("Command", "Description")
-                commands = plugin.commands
+            if not hasattr(plugin, "commands"):
+                continue
 
-                for label in sorted(commands):
-                    commands_data[label] = []
+            data = {}
+            headers = ("Command", "Description")
+            commands = plugin.commands
 
-                    for command in sorted(commands[label]):
-                        commands_data[label].append(
-                            (command, commands[label][command]['Description'])
-                        )
+            for label in sorted(commands):
+                data[label] = []
 
-                for label in sorted(commands_data):
-                    self.tables.print_table(label.title() + " Commands", headers, *commands_data[label])
+                for command in sorted(commands[label]):
+                    data[label].append(
+                        (command, commands[label][command]['Description'])
+                    )
 
-    def show_module_commands(self) -> None:
+            for label in sorted(data):
+                self.tables.print_table(f"{label} Commands", headers, *data[label])
+
+    def show_module_commands(self, module: Module) -> None:
         """ Show current module commands.
 
+        :param Module module: module object
         :return None: None
         """
 
-        module = self.modules.get_current_module()
+        if not hasattr(module, "commands"):
+            return
 
-        if hasattr(module, "commands"):
-            commands_data = []
-            headers = ("Command", "Description")
-            commands = module.commands
+        data = []
+        headers = ("Command", "Description")
+        commands = module.commands
 
-            for command in sorted(commands):
-                commands_data.append(
-                    (command, commands[command]['Description'])
-                )
+        for command in sorted(commands):
+            data.append(
+                (command, commands[command]['Description'])
+            )
 
-            self.tables.print_table("Module Commands", headers, *commands_data)
+        self.tables.print_table("Module Commands", headers, *data)
 
     def show_all_commands(self) -> None:
         """ Show all commands.
@@ -155,510 +157,526 @@ def show_all_commands(self) -> None:
         self.show_interface_commands()
 
         if self.modules.get_current_module():
-            self.show_module_commands()
+            self.show_module_commands(
+                self.modules.get_current_module())
 
         if self.plugins.get_loaded_plugins():
-            self.show_plugin_commands()
+            self.show_plugin_commands(
+                self.plugins.get_loaded_plugins())
 
-    def show_jobs(self) -> None:
+    def show_jobs(self, jobs: dict) -> None:
         """ Show active jobs.
 
+        :param dict jobs: dictionary of jobs, where job IDs are keys
+        and job objects are items
         :return None: None
         :raises RuntimeWarning: with trailing warning message
         """
 
-        jobs = self.jobs.get_jobs()
+        if not jobs:
+            raise RuntimeWarning("No running jobs available.")
 
-        if jobs:
-            jobs_data = []
-            headers = ("ID", "Name", "Module")
+        data = []
+        headers = ("ID", "Name", "Module")
 
-            for job_id in jobs:
-                jobs_data.append(
-                    (job_id, jobs[job_id]['Name'], jobs[job_id]['Module'])
-                )
+        for job_id, job in jobs.items():
+            data.append(
+                (job_id, job['Name'], job['Module'])
+            )
 
-            self.tables.print_table("Active Jobs", headers, *jobs_data)
-        else:
-            raise RuntimeWarning("No running jobs available.")
+        self.tables.print_table("Active Jobs", headers, *data)
 
-    def show_loot(self) -> None:
-        """ Show collected loot.
+    def show_sessions(self, sessions: dict) -> None:
+        """ Show opened sessions.
 
+        :param dict sessions: sessions dictionary, where session ID is a key
+        and session data is item
         :return None: None
         :raises RuntimeWarning: with trailing warning message
         """
 
-        loots = self.loot.list_loot()
+        if not sessions:
+            raise RuntimeWarning("No opened sessions available.")
+
+        data = []
+        headers = ("ID", "Platform", "Arch", "Type", "Host", "Port")
+
+        for session_id, session in sessions.items():
+            data.append(
+                (session_id, session['Platform'], session['Arch'],
+                 session['Type'], session['Host'], session['Port'])
+            )
 
-        if loots:
-            headers = ("Loot", "Path", "Time")
-            self.tables.print_table("Collected Loot", headers, *loots)
+        self.tables.print_table("Opened Sessions", headers, *data)
+
+    def show_loot(self, loot: list) -> None:
+        """ Show collected loot.
+
+        :param list loot: loot array
+        (array of tuples containing loot information)
+        :return None: None
+        :raises RuntimeWarning: with trailing warning message
+        """
 
-        else:
+        if not loot:
             raise RuntimeWarning("No loot collected yet.")
 
-    def show_module_databases(self) -> None:
+        headers = ("Loot", "Path", "Time")
+        self.tables.print_table("Collected Loot", headers, *loot)
+
+    def show_module_databases(self, databases: dict) -> None:
         """ Show connected module databases.
 
+        :param dict databases: module databases
         :return None: None
         :raises RuntimeWarning: with trailing warning message
         """
 
-        databases = self.local_storage.get("connected_module_databases")
+        if not databases:
+            raise RuntimeWarning("No module databases connected.")
 
-        if databases:
-            databases_data = []
-            number = 0
-            headers = ("Number", "Name", "Path")
+        data = []
+        number = 0
+        headers = ("Number", "Name", "Path")
 
-            for name in databases:
-                databases_data.append(
-                    (number, name, databases[name]['Path'])
-                )
-                number += 1
+        for name in databases:
+            data.append(
+                (number, name, databases[name]['Path'])
+            )
+            number += 1
 
-            self.tables.print_table("Connected Module Databases", headers, *databases_data)
-        else:
-            raise RuntimeWarning("No module databases connected.")
+        self.tables.print_table("Connected Module Databases", headers, *data)
 
-    def show_payload_databases(self) -> None:
+    def show_payload_databases(self, databases: dict) -> None:
         """ Show connected payload databases.
 
+        :param dict databases: payload databases
         :return None: None
         :raises RuntimeWarning: with trailing warning message
         """
 
-        databases = self.local_storage.get("connected_payload_databases")
+        if not databases:
+            raise RuntimeWarning("No payload databases connected.")
 
-        if databases:
-            databases_data = []
-            number = 0
-            headers = ("Number", "Name", "Path")
+        data = []
+        number = 0
+        headers = ("Number", "Name", "Path")
 
-            for name in databases:
-                databases_data.append(
-                    (number, name, databases[name]['Path'])
-                )
-                number += 1
+        for name in databases:
+            data.append(
+                (number, name, databases[name]['Path'])
+            )
+            number += 1
 
-            self.tables.print_table("Connected Payload Databases", headers, *databases_data)
-        else:
-            raise RuntimeWarning("No payload databases connected.")
+        self.tables.print_table("Connected Payload Databases", headers, *data)
 
-    def show_encoder_databases(self) -> None:
+    def show_encoder_databases(self, databases: dict) -> None:
         """ Show connected encoder databases.
 
+        :param dict databases: encoder databases
         :return None: None
         :raises RuntimeWarning: with trailing warning message
         """
 
-        databases = self.local_storage.get("connected_encoder_databases")
+        if not databases:
+            raise RuntimeWarning("No encoder databases connected.")
 
-        if databases:
-            databases_data = []
-            number = 0
-            headers = ("Number", "Name", "Path")
+        data = []
+        number = 0
+        headers = ("Number", "Name", "Path")
 
-            for name in databases:
-                databases_data.append(
-                    (number, name, databases[name]['Path'])
-                )
-                number += 1
+        for name in databases:
+            data.append(
+                (number, name, databases[name]['Path'])
+            )
+            number += 1
 
-            self.tables.print_table("Connected Encoder Databases", headers, *databases_data)
-        else:
-            raise RuntimeWarning("No encoder databases connected.")
+        self.tables.print_table("Connected Encoder Databases", headers, *data)
 
-    def show_plugin_databases(self) -> None:
+    def show_plugin_databases(self, databases: dict) -> None:
         """ Show connected plugin databases.
 
+        :param dict databases: plugin databases
         :return None: None
         :raises RuntimeWarning: with trailing warning message
         """
 
-        databases = self.local_storage.get("connected_plugin_databases")
+        if not databases:
+            raise RuntimeWarning("No plugin databases connected.")
 
-        if databases:
-            databases_data = []
-            number = 0
-            headers = ("Number", "Name", "Path")
+        data = []
+        number = 0
+        headers = ("Number", "Name", "Path")
 
-            for name in databases:
-                databases_data.append(
-                    (number, name, databases[name]['Path'])
-                )
-                number += 1
+        for name in databases:
+            data.append(
+                (number, name, databases[name]['Path'])
+            )
+            number += 1
 
-            self.tables.print_table("Connected Plugin Databases", headers, *databases_data)
-        else:
-            raise RuntimeWarning("No plugin databases connected.")
+        self.tables.print_table("Connected Plugin Databases", headers, *data)
 
-    def show_plugins(self) -> None:
-        """ Show plugins.
+    def show_loaded_plugins(self, plugins: dict) -> None:
+        """ Show loaded plugins.
 
+        :param dict plugins: dictionary of plugins, where plugin name is a key
+        and plugin object is an item
         :return None: None
         :raises RuntimeWarning: with trailing warning message
         """
 
-        all_plugins = self.plugins.get_plugins()
         headers = ("Number", "Plugin", "Name")
+        shorts = {}
+        data = []
+        number = 0
 
-        plugin_shorts = {}
+        for plugin in sorted(plugins):
+            data.append(
+                (number, plugin, plugin[plugin].details['Name'])
+            )
+
+            shorts.update({
+                number: plugin
+            })
+            number += 1
+
+        if not shorts:
+            raise RuntimeWarning("No plugins available.")
+
+        self.tables.print_table(f"Loaded Plugins", headers, *data)
+        self.local_storage.set("plugin_shorts", shorts)
+
+    def show_plugins(self, plugins: dict) -> None:
+        """ Show plugins.
+
+        :param dict plugins: dictionary of plugins, where plugin name is a key
+        and plugin data is an item
+        :return None: None
+        :raises RuntimeWarning: with trailing warning message
+        """
+
+        headers = ("Number", "Plugin", "Name")
+        shorts = {}
         number = 0
 
-        for database in sorted(all_plugins):
-            plugins_data = []
-            plugins = all_plugins[database]
+        for database in sorted(plugins):
+            db_plugins = plugins[database]
+            data = []
 
-            for plugin in sorted(plugins):
-                plugin = plugins[plugin]
+            for plugin in sorted(db_plugins):
+                plugin = db_plugins[plugin]
 
-                plugins_data.append(
+                data.append(
                     (number, plugin['Plugin'], plugin['Name'])
                 )
 
-                plugin_shorts.update({
+                shorts.update({
                     number: plugin['Plugin']
                 })
 
                 number += 1
 
-            self.tables.print_table(f"Plugins ({database})", headers, *plugins_data)
+            self.tables.print_table(f"Plugins ({database})", headers, *data)
 
-        if plugin_shorts:
-            self.local_storage.set("plugin_shorts", plugin_shorts)
-        else:
+        if not shorts:
             raise RuntimeWarning("No plugins available.")
 
-    def show_encoders(self) -> None:
+        self.local_storage.set("plugin_shorts", shorts)
+
+    def show_encoders(self, encoders: dict) -> None:
         """ Show encoders.
 
+        :param dict encoders: dictionary of encoders, where encoder name is a key
+        and encoder data is an item
         :return None: None
         :raises RuntimeWarning: with trailing warning message
         """
 
-        all_encoders = self.local_storage.get("encoders")
         headers = ("Number", "Encoder", "Name")
-
-        encoder_shorts = {}
+        shorts = {}
         number = 0
 
-        for database in sorted(all_encoders):
-            encoders_data = []
-            encoders = all_encoders[database]
+        for database in sorted(encoders):
+            db_encoders = encoders[database]
+            data = []
 
-            for encoder in sorted(encoders):
-                encoder = encoders[encoder]
+            for encoder in sorted(db_encoders):
+                encoder = db_encoders[encoder]
 
-                encoders_data.append(
+                data.append(
                     (number, encoder['Encoder'], encoder['Name'])
                 )
 
-                encoder_shorts.update({
+                shorts.update({
                     number: encoder['Encoder']
                 })
 
                 number += 1
 
-            self.tables.print_table(f"Encoders ({database})", headers, *encoders_data)
+            self.tables.print_table(f"Encoders ({database})", headers, *data)
 
-        if encoder_shorts:
-            self.local_storage.set("encoder_shorts", encoder_shorts)
-        else:
+        if not shorts:
             raise RuntimeWarning("No encoders available.")
 
-    def show_modules(self, category: Optional[str] = None) -> None:
+        self.local_storage.set("encoder_shorts", shorts)
+
+    def show_modules(self, modules: dict, category: Optional[str] = None) -> None:
         """ Show modules by category.
 
+        :param dict modules: modules dictionary, module name as key and
+        module data as item
         :param Optional[str] category: category
         :return None: None
         :raises RuntimeWarning: with trailing warning message
         """
 
-        all_modules = self.local_storage.get("modules")
         headers = ("Number", "Category", "Module", "Rank", "Name")
-
-        module_shorts = {}
+        shorts = {}
         number = 0
 
-        for database in sorted(all_modules):
-            modules_data = []
-            modules = all_modules[database]
-
-            for module in sorted(modules):
-                module = modules[module]
+        for database in sorted(modules):
+            db_modules = modules[database]
+            data = []
 
-                if category:
-                    if category == module['Category']:
-                        modules_data.append(
-                            (number, module['Category'], module['Module'],
-                             module['Rank'], module['Name'])
-                        )
+            for module in sorted(db_modules):
+                module = db_modules[module]
 
-                        module_shorts.update({
-                            number: module['Module']
-                        })
-
-                        number += 1
-                else:
-                    modules_data.append(
+                if not category:
+                    data.append(
                         (number, module['Category'], module['Module'],
                          module['Rank'], module['Name'])
                     )
 
-                    module_shorts.update(
+                    shorts.update(
                         {number: module['Module']}
                     )
 
                     number += 1
+                    continue
+
+                if category == module['Category']:
+                    data.append(
+                        (number, module['Category'], module['Module'],
+                         module['Rank'], module['Name'])
+                    )
+
+                    shorts.update({
+                        number: module['Module']
+                    })
+
+                    number += 1
 
             if category:
-                self.tables.print_table(f"{category.title()} Modules ({database})", headers, *modules_data)
+                self.tables.print_table(f"{category.title()} Modules ({database})", headers, *data)
             else:
-                self.tables.print_table(f"Modules ({database})", headers, *modules_data)
+                self.tables.print_table(f"Modules ({database})", headers, *data)
 
-        if module_shorts:
-            self.local_storage.set("module_shorts", module_shorts)
-        else:
+        if not shorts:
             raise RuntimeWarning("No modules available.")
 
-    def show_payloads(self) -> None:
+        self.local_storage.set("module_shorts", shorts)
+
+    def show_payloads(self, payloads: dict) -> None:
         """ Show payloads.
 
+        :param dict payloads: payloads dictionary, payload name as key
+        and payload data as item
         :return None: None
         :raises RuntimeWarning: with trailing warning message
         """
 
-        all_payloads = self.local_storage.get("payloads")
         headers = ("Number", "Payload", "Rank", "Name")
-
-        payload_shorts = {}
+        shorts = {}
         number = 0
 
-        for database in sorted(all_payloads):
-            payloads_data = []
-            payloads = all_payloads[database]
+        for database in sorted(payloads):
+            db_payloads = payloads[database]
+            data = []
 
-            for payload in sorted(payloads):
-                payload = payloads[payload]
+            for payload in sorted(db_payloads):
+                payload = db_payloads[payload]
 
-                payloads_data.append(
+                data.append(
                     (number, payload['Payload'], payload['Rank'],
                      payload['Name'])
                 )
 
-                payload_shorts.update({
+                shorts.update({
                     number: payload['Payload']
                 })
 
                 number += 1
 
-            self.tables.print_table(f"Payloads ({database})", headers, *payloads_data)
+            self.tables.print_table(f"Payloads ({database})", headers, *data)
 
-        if payload_shorts:
-            self.local_storage.set("payload_shorts", payload_shorts)
-        else:
+        if not shorts:
             raise RuntimeWarning("No payloads available.")
 
-    def show_search_plugins(self, keyword: str) -> None:
+        self.local_storage.set("payload_shorts", shorts)
+
+    def show_search_plugins(self, plugins: dict, keyword: str) -> None:
         """ Show plugins that contain the keyword.
 
+        :param dict plugins: dictionary of plugins, where plugin name is a key
+        and plugin data is an item
         :param str keyword: keyword
         :return None: None
         """
 
-        all_plugins = self.local_storage.get("plugins")
         headers = ("Number", "Plugin", "Name")
-
-        plugin_shorts = {}
+        shorts = {}
         number = 0
 
-        for database in all_plugins:
-            plugins_data = []
-            plugins = all_plugins[database]
-
-            for plugin in sorted(plugins):
-                plugin = plugins[plugin]
+        for database in plugins:
+            db_plugins = plugins[database]
+            data = []
 
-                if keyword in plugin['Plugin'] or keyword in plugin['Name']:
-                    name = plugin['Plugin'].replace(keyword, self.colors.RED + keyword + self.colors.END)
+            for plugin in sorted(db_plugins):
+                plugin = db_plugins[plugin]
 
-                    description = plugin['Name'].replace(
-                        keyword, self.colors.RED + keyword + self.colors.END)
+                if keyword not in plugin['Plugin'] + plugin['Name']:
+                    continue
 
-                    plugins_data.append(
-                        (number, name, description)
-                    )
+                data.append(
+                    (number, plugin['Plugin'].replace(keyword, f'%red{keyword}%end'),
+                     plugin['Name'].replace(keyword, f'%red{keyword}%end'))
+                )
 
-                    plugin_shorts.update(
-                        {number: plugin['Plugin']}
-                    )
+                shorts.update(
+                    {number: plugin['Plugin']}
+                )
 
-                    number += 1
+                number += 1
 
-            if plugins_data:
-                self.tables.print_table(f"Plugins ({database})", headers, *plugins_data)
+            if data:
+                self.tables.print_table(f"Plugins ({database})", headers, *data)
 
-        if plugin_shorts:
-            self.local_storage.set("plugin_shorts", plugin_shorts)
+        if shorts:
+            self.local_storage.set("plugin_shorts", shorts)
 
-    def show_search_encoders(self, keyword: str) -> None:
+    def show_search_encoders(self, encoders: dict, keyword: str) -> None:
         """ Show encoders that contain the keyword.
 
+        :param dict encoders: dictionary of encoders, where encoder name is a key
+        and encoder data is an item
         :param str keyword: keyword
         :return None: None
         """
 
-        all_encoders = self.local_storage.get("encoders")
         headers = ("Number", "Encoder", "Name")
-
-        encoder_shorts = {}
+        shorts = {}
         number = 0
 
-        for database in all_encoders:
-            encoders_data = []
-            encoders = all_encoders[database]
+        for database in encoders:
+            db_encoders = encoders[database]
+            data = []
 
-            for encoder in sorted(encoders):
-                encoder = encoders[encoder]
+            for encoder in sorted(db_encoders):
+                encoder = db_encoders[encoder]
 
-                if keyword in encoder['Encoder'] or keyword in encoder['Name']:
-                    name = encoder['Encoder'].replace(
-                        keyword, self.colors.RED + keyword + self.colors.END)
+                if keyword not in encoder['Encoder'] + encoder['Name']:
+                    continue
 
-                    description = encoder['Name'].replace(
-                        keyword, self.colors.RED + keyword + self.colors.END)
-
-                    encoders_data.append(
-                        (number, name, description)
-                    )
+                data.append(
+                    (number, encoder['Encoder'].replace(keyword, f'%red{keyword}%end'),
+                     encoder['Name'].replace(keyword, f'%red{keyword}%end'))
+                )
 
-                    encoder_shorts.update({
-                        number: encoder['Encoder']
-                    })
+                shorts.update(
+                    {number: encoder['Encoder']}
+                )
 
-                    number += 1
+                number += 1
 
-            if encoders_data:
-                self.tables.print_table(f"Encoders ({database})", headers, *encoders_data)
+            if data:
+                self.tables.print_table(f"Encoders ({database})", headers, *data)
 
-        if encoder_shorts:
-            self.local_storage.set("encoder_shorts", encoder_shorts)
+        if shorts:
+            self.local_storage.set("encoder_shorts", shorts)
 
-    def show_search_modules(self, keyword: str) -> None:
+    def show_search_modules(self, modules: dict, keyword: str) -> None:
         """ Show modules that contain the keyword.
 
+        :param dict modules: dictionary of modules, where module name is a key
+        and module data is an item
         :param str keyword: keyword
         :return None: None
         """
 
-        all_modules = self.local_storage.get("modules")
         headers = ("Number", "Category", "Module", "Rank", "Name")
-
-        module_shorts = {}
+        shorts = {}
         number = 0
 
-        for database in all_modules:
-            modules_data = []
-            modules = all_modules[database]
-
-            for module in sorted(modules):
-                module = modules[module]
+        for database in modules:
+            db_modules = modules[database]
+            data = []
 
-                if keyword in module['Module'] or keyword in module['Name']:
-                    name = module['Module'].replace(keyword, self.colors.RED + keyword + self.colors.END)
+            for module in sorted(db_modules):
+                module = db_modules[module]
 
-                    description = module['Name'].replace(
-                        keyword, self.colors.RED + keyword + self.colors.END)
+                if keyword not in module['Module'] + module['Name']:
+                    continue
 
-                    modules_data.append((number, module['Category'], name,
-                                         module['Rank'], description))
+                data.append(
+                    (number, module['Category'],
+                     module['Module'].replace(keyword, f'%red{keyword}%end'),
+                     module['Rank'],
+                     module['Name'].replace(keyword, f'%red{keyword}%end'))
+                )
 
-                    module_shorts.update(
-                        {number: module['Module']}
-                    )
+                shorts.update(
+                    {number: module['Module']}
+                )
 
-                    number += 1
+                number += 1
 
-            if modules_data:
-                self.tables.print_table(f"Modules ({database})", headers, *modules_data)
+            if data:
+                self.tables.print_table(f"Modules ({database})", headers, *data)
 
-        if module_shorts:
-            self.local_storage.set("module_shorts", module_shorts)
+        if shorts:
+            self.local_storage.set("module_shorts", shorts)
 
-    def show_search_payloads(self, keyword: str) -> None:
+    def show_search_payloads(self, payloads: dict, keyword: str) -> None:
         """ Show payloads that contain the keyword.
 
+        :param dict payloads: dictionary of payloads, where payload name is a key
+        and payload data is an item
         :param str keyword: keyword
         :return None: None
         """
 
-        all_payloads = self.local_storage.get("payloads")
-        headers = ("Number", "Payload", "Rank", "Name")
-
-        payload_shorts = {}
+        headers = ("Number", "Module", "Rank", "Name")
+        shorts = {}
         number = 0
 
-        for database in all_payloads:
-            payloads_data = []
-            payloads = all_payloads[database]
-
-            for payload in sorted(payloads):
-                payload = payloads[payload]
-
-                if keyword in payload['Payload'] or keyword in payload['Name']:
-                    name = payload['Payload'].replace(
-                        keyword, self.colors.RED + keyword + self.colors.END)
-
-                    description = payload['Name'].replace(
-                        keyword, self.colors.RED + keyword + self.colors.END)
-
-                    payloads_data.append(
-                        (number, name, payload['Rank'], description)
-                    )
-
-                    payload_shorts.update({
-                        number: payload['Payload']
-                    })
-
-                    number += 1
-
-            if payloads_data:
-                self.tables.print_table(f"Payloads ({database})", headers, *payloads_data)
+        for database in payloads:
+            db_payloads = payloads[database]
+            data = []
 
-        if payload_shorts:
-            self.local_storage.set("payload_shorts", payload_shorts)
-
-    def show_sessions(self) -> None:
-        """ Show opened sessions.
-
-        :return None: None
-        :raises RuntimeWarning: with trailing warning message
-        """
+            for payload in sorted(db_payloads):
+                payload = db_payloads[payload]
 
-        sessions = self.sessions.get_sessions()
+                if keyword not in payload['Payload'] + payload['Name']:
+                    continue
 
-        if sessions:
-            sessions_data = []
-            headers = ("ID", "Platform", "Arch", "Type", "Host", "Port")
+                data.append(
+                    (number,
+                     payload['Payload'].replace(keyword, f'%red{keyword}%end'),
+                     payload['Rank'],
+                     payload['Name'].replace(keyword, f'%red{keyword}%end'))
+                )
 
-            for session_id in sessions:
-                session = sessions[session_id]
+                shorts.update(
+                    {number: payload['Payload']}
+                )
 
-                platform = session['Platform']
-                architecture = session['Arch']
-                type = session['Type']
-                host = session['Host']
-                port = session['Port']
+                number += 1
 
-                sessions_data.append(
-                    (session_id, platform, architecture, type, host, port)
-                )
+            if data:
+                self.tables.print_table(f"Payloads ({database})", headers, *data)
 
-            self.tables.print_table("Opened Sessions", headers, *sessions_data)
-        else:
-            raise RuntimeWarning("No opened sessions available.")
+        if shorts:
+            self.local_storage.set("payload_shorts", shorts)
 
     def show_module_information(self, details: Optional[dict] = None) -> None:
         """ Show module details.
@@ -690,63 +708,66 @@ def show_options_table(self, title: str, options: dict) -> None:
         """
 
         headers = ("Option", "Value", "Required", "Description")
-        options_data = []
+        data = []
 
         for option in sorted(options):
-            if options[option]['Visible']:
-                value, required = options[option]['Value'], \
-                    options[option]['Required']
-
-                if required:
-                    required = "yes"
-                else:
-                    required = "no"
-
-                if isinstance(value, bool):
-                    if value:
-                        value = "yes"
-                    else:
-                        value = "no"
-
-                options_data.append(
-                    (option, "" if value is None else value, required, options[option]['Description'])
-                )
+            if not options[option]['Visible']:
+                continue
+
+            value, required = options[option]['Value'], \
+                options[option]['Required']
+
+            required = "yes" if required else "no"
+            value = "" if value is None else value
+
+            if isinstance(value, bool):
+                value = "yes" if value else "no"
 
-        self.tables.print_table(title, headers, *options_data)
+            data.append(
+                (option, value, required,
+                 options[option]['Description'])
+            )
+
+        self.tables.print_table(title, headers, *data)
 
-    def show_options(self) -> None:
+    def show_options(self, module: Module) -> None:
         """ Show options.
 
+        :param Module module: module object
         :return None: None
         :raises RuntimeWarning: with trailing warning message
         """
 
-        module = self.modules.get_current_module()
         payload = self.payloads.get_current_payload(module)
 
         if not module:
             raise RuntimeWarning("No module selected.")
 
         if hasattr(module, "options"):
-            self.show_options_table(f"Module Options ({module.details['Module']})", module.options)
+            self.show_options_table(
+                f"Module Options ({module.details['Module']})", module.options)
 
-        if payload:
-            encoder = self.encoders.get_current_encoder(module, payload)
+        if not payload:
+            return
 
-            if payload and hasattr(payload, "options"):
-                self.show_options_table(f"Payload Options ({payload.details['Payload']})", payload.options)
+        encoder = self.encoders.get_current_encoder(module, payload)
 
-            if encoder and hasattr(encoder, "options"):
-                self.show_options_table(f"Encoder Options ({encoder.details['Encoder']})", encoder.options)
+        if hasattr(payload, "options"):
+            self.show_options_table(
+                f"Payload Options ({payload.details['Payload']})", payload.options)
 
-    def show_advanced(self) -> None:
+        if encoder and hasattr(encoder, "options"):
+            self.show_options_table(
+                f"Encoder Options ({encoder.details['Encoder']})", encoder.options)
+
+    def show_advanced(self, module: Module) -> None:
         """ Show advanced options.
 
+        :param Module module: module object
         :return None: None
         :raises RuntimeWarning: with trailing warning message
         """
 
-        module = self.modules.get_current_module()
         payload = self.payloads.get_current_payload(module)
 
         if not module:
@@ -756,13 +777,15 @@ def show_advanced(self) -> None:
             self.show_options_table(
                 f"Module Advanced Options ({module.details['Module']})", module.advanced)
 
-        if payload:
-            encoder = self.encoders.get_current_encoder(module, payload)
+        if not payload:
+            return
+
+        encoder = self.encoders.get_current_encoder(module, payload)
 
-            if payload and hasattr(payload, "advanced"):
-                self.show_options_table(
-                    f"Payload Advanced Options ({payload.details['Payload']})", payload.advanced)
+        if hasattr(payload, "advanced"):
+            self.show_options_table(
+                f"Payload Advanced Options ({payload.details['Payload']})", payload.advanced)
 
-            if encoder and hasattr(encoder, "advanced"):
-                self.show_options_table(
-                    f"Encoder Advanced Options ({encoder.details['Encoder']})", encoder.advanced)
+        if encoder and hasattr(encoder, "advanced"):
+            self.show_options_table(
+                f"Encoder Advanced Options ({encoder.details['Encoder']})", encoder.advanced)