diff --git a/aptester.spec b/arxis-pentester.spec
similarity index 95%
rename from aptester.spec
rename to arxis-pentester.spec
index e287632..81099c2 100644
--- a/aptester.spec
+++ b/arxis-pentester.spec
@@ -13,6 +13,8 @@ Requires:      python3, python3-tkinter, python3-pillow-tk, python3-pip
 %description
 The application helps identify vulnerable open ports on a network, providing insights into potential security risks.
 
+%pre
+pip3 install ipaddress asyncio numpy ttkbootstrap pillow logging tkthread
 
 %install
 mkdir -p %{buildroot}/usr/local/bin/
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 0000000..1af1190
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1,7 @@
+ipaddress
+asyncio
+numpy
+ttkbootstrap
+pillow
+logging
+tkthread
\ No newline at end of file
diff --git a/usr/lib/arxis-pentest-tool/Functions.py b/usr/lib/arxis-pentest-tool/Functions.py
index 984cd62..84069aa 100644
--- a/usr/lib/arxis-pentest-tool/Functions.py
+++ b/usr/lib/arxis-pentest-tool/Functions.py
@@ -1,89 +1,102 @@
-import asyncio
 import ipaddress
-import socket
-import logging
+import asyncio
 import numpy as np
+import socket
 
-logger = logging.getLogger(__name__)
+Version = "1.0.1.5"
 
 
-async def perform_port_scan(ip, port):
-    """Check if a TCP connection can be established to the host on the given port."""
-    try:
-        reader, writer = await asyncio.open_connection(ip, port)
-        writer.close()
-        await writer.wait_closed()
-        return True
-    except Exception:
-        return False
+async def scan_host(self, subnet, port_list):
+    self.logger.info(f"Scanning IP addresses in {subnet}...")
+    self.logger.info("----------------------------------------------------------")
+    ip_net = ipaddress.ip_network(subnet)
+    all_hosts = list(ip_net.hosts())
+    tasks = [scan_ports(self, str(ip), port_list) for ip in all_hosts]
+    await asyncio.gather(*tasks)
+
 
+async def TCP_connect(self, ip, port_number):
 
-async def resolve_hostname(ip):
-    """Resolve the hostname for an IP address."""
+    conn = asyncio.open_connection(ip, port_number)
     try:
-        return socket.gethostbyaddr(ip)[0]
-    except socket.herror:
-        return "Unknown"
+        reader, writer = await asyncio.wait_for(conn, timeout=5)
+        writer.close()
+        await writer.wait_closed()
+        return port_number, "Listening"
+    except (asyncio.TimeoutError, ConnectionRefusedError):
+        return port_number, ""
+    except OSError:
+        return port_number, ""
 
 
-async def scan_host(window, host, port_list, update_progress):
-    """Scan a single host for open ports."""
-    window.logger.info(f"Scanning host: {host}")
+async def get_hostname(ip):
     try:
-        # Convert port list to a numpy array for efficient handling
-        port_list = np.array(port_list)
-        open_ports = await perform_port_scan(host, port_list)
-        hostname = await resolve_hostname(host)
-
-        # Ensure Treeview update is called in the main thread
-        window.loop.call_soon_threadsafe(
-            lambda: window.update_treeview(
-                host, open_ports.tolist(), hostname
-            )  # Convert numpy array back to list
+        hostname, _, _ = await asyncio.wait_for(
+            asyncio.to_thread(socket.gethostbyaddr, ip), timeout=3
         )
+        return hostname.split()[0]
+    except (socket.herror, asyncio.TimeoutError):
+        return "Unknown"
 
-        # Await the update_progress coroutine to ensure it runs properly
-        await update_progress()  # Update the progress bar
-    except Exception as e:
-        window.logger.error(f"Error scanning {host}: {e}")
-    finally:
-        window.logger.info(f"Finished scanning host: {host}")
-
-
-async def scan_subnet(window, subnet, port_list, update_progress):
-    """Scan all hosts in the given subnet."""
-    network = ipaddress.IPv4Network(subnet, strict=False)
-    total_hosts = len(list(network.hosts()))
-    scanned_hosts = 0
-
-    # Convert port list to numpy array for better performance
-    port_list = np.array(port_list)
 
-    async def update_progress():
-        """Update the progress bar and meter."""
-        nonlocal scanned_hosts
-        scanned_hosts += 1
-        progress = (scanned_hosts / total_hosts) * 100
-        window.loop.call_soon_threadsafe(
-            lambda: [
-                window.progress.config(value=progress),
-                window.status.config(text=f"Scanning progress: {progress:.2f}%"),
-                window.meter.configure(amountused=scanned_hosts),
-            ]
-        )
+async def scan_ports(self, host_ip, port_list):
+    hostname = await get_hostname(host_ip)
+    max_concurrent_connections = self.meter.amountusedvar.get()
 
-    tasks = [
-        scan_host(window, str(ip), port_list, update_progress) for ip in network.hosts()
-    ]
-    try:
-        await asyncio.gather(*tasks)
-    except asyncio.CancelledError:
-        window.logger.info("Scan was cancelled.")
-    finally:
-        window.loop.call_soon_threadsafe(
-            lambda: window.status.config(text="Scan complete!")
+    self.logger.info(
+        "Running {} concurrent connections on host {}".format(
+            max_concurrent_connections, host_ip
         )
-
-
-def Version():
-    return "1.0.15"
+    )
+    semaphore = asyncio.Semaphore(max_concurrent_connections)
+
+    async def limited_tcp_connect(ip, port):
+        async with semaphore:
+            return await TCP_connect(self, ip, port)
+
+    port_array = np.array(port_list, dtype=int)
+    # tasks = [TCP_connect(self, host_ip, port) for port in port_array]
+    tasks = [limited_tcp_connect(host_ip, port) for port in port_array]
+    results = await asyncio.gather(*tasks)
+    res = np.array([], dtype=int)
+    for port, status in results:
+        if status == "Listening":
+            res = np.append(res, port)
+            self.results[host_ip] = {
+                "ports": res.tolist(),
+                "hostname": hostname,
+            }
+            existing_item = None
+            for item in self.tree.get_children():
+                if self.tree.item(item, "values")[0] == host_ip:
+                    existing_item = item
+                    break
+
+            if existing_item:
+                self.tree.item(
+                    existing_item,
+                    values=(
+                        host_ip,
+                        np.array2string(np.array(res.tolist()), separator=", ")
+                        .replace("[", "")
+                        .replace("]", "")
+                        .replace(" ", "")
+                        .strip(),
+                        hostname,
+                    ),
+                )
+            else:
+                self.tree.insert(
+                    "",
+                    "end",
+                    values=(
+                        host_ip,
+                        np.array2string(np.array(res.tolist()), separator=", ")
+                        .replace("[", "")
+                        .replace("]", "")
+                        .replace(" ", "")
+                        .strip(),
+                        hostname,
+                    ),
+                )
+            print(f"{host_ip}:{port} - {status}")
diff --git a/usr/lib/arxis-pentest-tool/Gui.py b/usr/lib/arxis-pentest-tool/Gui.py
index 76d2a0b..6722926 100644
--- a/usr/lib/arxis-pentest-tool/Gui.py
+++ b/usr/lib/arxis-pentest-tool/Gui.py
@@ -4,8 +4,6 @@
 from PIL import Image, ImageTk
 import tkinter.font as tkFont
 from Functions import Version
-import webbrowser
-from tkinter import messagebox
 
 
 def window(self):
@@ -13,6 +11,7 @@ def window(self):
     screen_width = self.winfo_screenwidth() / 2
     screen_width2 = screen_width + (screen_width / 2)
     screen_height = self.winfo_screenheight()
+    print(screen_width2)
     center_x = int(screen_width2 - (self.W / 2))
     center_y = int(screen_height / 2 - (self.H / 2))
     self.geometry(f"{self.W}x{self.H}+{center_x}+{center_y}")
@@ -41,17 +40,17 @@ def widgets(self):
     self.file = ttk.Menu(menubar, tearoff=1, background="#060607", fg="#ededef")
     self.about = ttk.Menu(menubar, tearoff=0, background="#060607", fg="#ededef")
 
-    self.file.add_command(label="Load", command=self.load_config)
-    self.file.add_command(label="Save", command=self.save_config)
+    self.file.add_command(label="Load", command=self.loadConfig)
+    self.file.add_command(label="Save", command=self.saveConfig)
     self.file.add_separator()
     self.file.add_command(label="Exit", command=self.quit)
 
     menubar.add_cascade(label="File", menu=self.file)
     menubar.add_cascade(label="Help", menu=self.about)
 
-    self.about.add_command(label="GitHub", command=self.nav_github)
-    self.about.add_separator()
-    self.about.add_command(label="About", command=self.show_about)
+    self.about.add_command(label="Github", command=lambda: self.navGithub())
+    self.file.add_separator()
+    self.about.add_command(label="About", command=lambda: self.aboutBox())
 
     self.config(menu=menubar, background="#202022")
     self.columnconfigure(1, weight=1)
@@ -62,28 +61,30 @@ def widgets(self):
     topFrm.columnconfigure(0, weight=1)
     topFrm.rowconfigure(0, weight=1)
 
-    self.var = ttk.IntVar(topFrm, value=0)
+    self.var = ttk.IntVar(topFrm, value=895)
     self.meter = ttk.Meter(
         topFrm,
         metersize=180,
         padding=5,
-        amountused=0,
-        amounttotal=1,
+        amountused=895,
+        amounttotal=1000,
         metertype="semi",
-        subtext="Hosts scanned",
+        subtext="Threads",
         interactive=True,
     )
     self.meter.configure(amountused=self.var.get())
+    self.meter.step(10)
     lbl1 = ttk.Label(
         topFrm, text="Enter the subnet of the network | Example: (192.168.1.0/24)"
     )
     lbl1.grid(sticky="n", columnspan=5, row=0, padx=10, pady=5)
+    self.meter.step(-15)
     self.meter.grid(sticky="w", columnspan=2, row=1, padx=20, pady=15)
 
-    self.subnet_entry = ttk.Entry(topFrm, background="#ededef", width=28)
-    self.subnet_entry.grid(sticky="e", column=1, columnspan=2, row=1, padx=0, pady=5)
+    self.subEnt = ttk.Entry(topFrm, background="#ededef", width=28)
+    self.subEnt.grid(sticky="e", column=1, columnspan=2, row=1, padx=0, pady=5)
     self.btn_unlockAll = ttk.Button(
-        topFrm, text="Start", command=self.start_scan, width=15
+        topFrm, text="Start", command=self.runScan, width=15
     )
     self.btn_unlockAll.grid(sticky="e", column=4, row=1, padx=5, pady=5)
 
@@ -117,6 +118,7 @@ def widgets(self):
         anchor=ttk.CENTER,
         command=lambda: self.sort_treeview(column="c3", reverse=False),
     )
+    self.tree.bind("<ButtonRelease-1>", self.selectItem)
     self.tree.grid(sticky=ttk.NSEW, row=1, columnspan=4, padx=8, pady=5)
 
     frmbtn = ttk.Frame(self)
@@ -126,40 +128,11 @@ def widgets(self):
 
     self.status = ttk.Label(frmbtn, text="Idle...")
     self.status.grid(sticky="w", column=0, row=1, padx=10, pady=2)
-    version = ttk.Label(frmbtn, text=Version())
+    version = ttk.Label(frmbtn, text=Version)
     version.grid(sticky="e", column=3, row=1, padx=10, pady=2)
     self.progress = ttk.Progressbar(frmbtn)
     self.progress.grid(sticky="wes", columnspan=4, row=2, pady=5)
 
 
-def open_github():
-    """Open the GitHub page for this project."""
-    webbrowser.open("https://github.com/your-repository-link")
-
-
-def show_about_window():
-    """Display the 'About' dialog box."""
-    about_message = "Arxis Pentester\nVersion: 1.0\nAuthor: Your Name\nA network security tool for scanning open ports."
-    messagebox.showinfo("About", about_message)
-
-
-def update_meter(self, total, value):
-    self.var.set(value)
-    self.meter.configure(amountused=value)
-    self.status.config(text=f"{value}/{total} hosts scanned")
-    self.progress.config(value=(value / total) * 100)
-    self.meter.configure(subtext=f"{value}/{total} Hosts")
-    self.meter.configure(amounttotal=total)
-
-
-def update_treeview(self, host, open_ports, hostname):
-    open_ports_str = ",".join(map(str, open_ports))
-    self.tree.insert(
-        "",
-        "end",
-        values=(host, open_ports_str, hostname if hostname else "Unknown"),
-    )
-
-
 def iconImage():
     return "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"  # noqa
diff --git a/usr/lib/arxis-pentest-tool/__pycache__/Functions.cpython-313.pyc b/usr/lib/arxis-pentest-tool/__pycache__/Functions.cpython-313.pyc
deleted file mode 100644
index 3d10f05..0000000
Binary files a/usr/lib/arxis-pentest-tool/__pycache__/Functions.cpython-313.pyc and /dev/null differ
diff --git a/usr/lib/arxis-pentest-tool/__pycache__/Gui.cpython-313.pyc b/usr/lib/arxis-pentest-tool/__pycache__/Gui.cpython-313.pyc
deleted file mode 100644
index 2bde14b..0000000
Binary files a/usr/lib/arxis-pentest-tool/__pycache__/Gui.cpython-313.pyc and /dev/null differ
diff --git a/usr/lib/arxis-pentest-tool/build-rpm b/usr/lib/arxis-pentest-tool/build-rpm
index 027a71a..ba59c5d 100755
--- a/usr/lib/arxis-pentest-tool/build-rpm
+++ b/usr/lib/arxis-pentest-tool/build-rpm
@@ -2,45 +2,21 @@
 # Stop script on errors
 set -e
 
-# Define source and build directories
-SOURCE_DIR=$(pwd)
-BUILD_DIR=~/rpmbuild/BUILD/APT
-SPEC_DIR=~/rpmbuild/SPECS
-ZIP_DIR=~/rpmbuild/SOURCES
-BASH_SCRIPT="../../local/bin"
-FUNCTIONS="$SOURCE_DIR/Functions.py"
-
-# Ensure build directory exists
-mkdir -p $BUILD_DIR
-
-# Step 1: Update DEBUG variable in the Bash script
-echo "Setting DEBUG to false in the Bash script..."
-sed -i 's/^DEBUG=true/DEBUG=false/' $BASH_SCRIPT/arxis-pentester
-
-# Automatically increment the version number in the .spec file
-echo "Incrementing version number in the .spec file..."
-sed -i -E 's/^(Version:[[:space:]]*)([0-9]+)\.([0-9]+)\.([0-9]+)\.([0-9]+)/echo "\1\2.\3.\4.$((\5+1))"/e' $SPEC_DIR/aptester.spec
-sed -i -E 's/^(Version[[:space:]]=[[:space:]]*)([0-9]+)\.([0-9]+)\.([0-9]+)\.([0-9]+)/echo "\1\2.\3.\4.$((\5+1))"/e' $FUNCTIONS
-
-# Extract the version number from the .spec file
-VERSION=$(grep -E '^Version:[[:space:]]*' $SPEC_DIR/aptester.spec | awk '{print $2}')
-
-#!/bin/bash
-# Stop script on errors
-set -e
+APP_NAME="arxis-pentester"
 
 # Define source and build directories
 EXEC_DIR=$(pwd)
 
+
 # Calculate the parent directory two levels up
 PARENT_X3_DIR=$(dirname "$(dirname "$(dirname "$EXEC_DIR")")")
 
 
 # Define source and build directories
 SOURCE_DIR=$EXEC_DIR
-BUILD_DIR=~/rpmbuild/BUILD/APT
-SPEC_DIR=~/rpmbuild/SPECS
-ZIP_DIR=~/rpmbuild/SOURCES
+BUILD_DIR=$HOME/rpmbuild/BUILD/APT
+SPEC_DIR=$HOME/rpmbuild/SPECS
+ZIP_DIR=$HOME/rpmbuild/SOURCES
 BASH_SCRIPT="../../local/bin"
 USRSOURCE="$PARENT_X3_DIR"
 FUNCTIONS="$SOURCE_DIR/Functions.py"
@@ -50,19 +26,23 @@ mkdir -p $BUILD_DIR
 
 # Step 1: Update DEBUG variable in the Bash script
 echo "Setting DEBUG to false in the Bash script..."
-sed -i 's/^DEBUG=true/DEBUG=false/' $BASH_SCRIPT/arxis-pentester
+sed -i 's/^DEBUG=true/DEBUG=false/' $BASH_SCRIPT/$APP_NAME
 
 # Automatically increment the version number in the .spec file
 echo "Incrementing version number in the .spec file..."
-sed -i -E 's/^(Version:[[:space:]]*)([0-9]+)\.([0-9]+)\.([0-9]+)\.([0-9]+)/echo "\1\2.\3.\4.$((\5+1))"/e' $SPEC_DIR/aptester.spec
+sed -i -E 's/^(Version:[[:space:]]*)([0-9]+)\.([0-9]+)/echo "\1\2.$((\3+1))"/e' "$SPEC_DIR/$APP_NAME.spec"
+
+# Increment version number in Functions.py
+echo "Incrementing version number in Functions.py..."
+sed -i -E 's/^(Version[[:space:]]*=[[:space:]]*")([0-9]+\.[0-9]+)\.([0-9]+)"/echo "\1\2.$((\3+1))\""/e' "$FUNCTIONS"
 
 # Extract the version number from the .spec file
-VERSION=$(grep -E '^Version:[[:space:]]*' $SPEC_DIR/aptester.spec | awk '{print $2}')
+VERSION=$(grep -E '^Version:[[:space:]]*' $SPEC_DIR/$APP_NAME.spec | awk '{print $2}')
 
 # Step 2: Compress the PROJECT-ROOT/usr directory
 echo "Compressing the $USRSOURCE/usr directory..."
 if [ -d "$USRSOURCE/usr" ]; then
-    tar -czf arxis-pentester-$VERSION.tar.gz -C "$USRSOURCE" usr
+    tar -czf $APP_NAME-$VERSION.tar.gz -C "$USRSOURCE" usr
 else
     echo "Error: Directory $USRSOURCE/usr does not exist."
     exit 1
@@ -70,9 +50,9 @@ fi
 
 # Step 3: Copy the .tar.gz to ZIP_DIR
 echo "Copying the .tar.gz to ZIP_DIR..."
-cp arxis-pentester-$VERSION.tar.gz $ZIP_DIR/
+cp $APP_NAME-$VERSION.tar.gz $ZIP_DIR/
 
-rm arxis-pentester-$VERSION.tar.gz
+rm $APP_NAME-$VERSION.tar.gz
 
 # Step 2: Compile Python modules using Cython (optional if needed)
 # echo "Compiling Python modules..."
@@ -99,12 +79,11 @@ echo "Copying files to RPM build directory..."
 cp -a ../../local/bin/* $BUILD_DIR/ || echo "No local binaries found to copy."
 cp -a ../../share/applications/* $BUILD_DIR/ || echo "No .desktop files found to copy."
 cp -a ../../share/pixmaps/* $BUILD_DIR/ || echo "No pixmap icons found to copy."
-cp -a ../../lib/arxis-pentester/* $BUILD_DIR/ || echo "No python files found to copy."
-cp -a *.py $BUILD_DIR/
+cp -a *.py $BUILD_DIR/ || echo "No python files found to copy."
 rm -f $BUILD_DIR/compile.py  # Remove compile script from package
 
 # Step 5: Build the RPM package
 echo "Building RPM package..."
-rpmbuild -ba ~/rpmbuild/SPECS/aptester.spec
+rpmbuild -ba $HOME/rpmbuild/SPECS/$APP_NAME.spec
 
 echo "Build completed successfully!"
\ No newline at end of file
diff --git a/usr/lib/arxis-pentest-tool/main.py b/usr/lib/arxis-pentest-tool/main.py
index 74c4616..f30b5b2 100644
--- a/usr/lib/arxis-pentest-tool/main.py
+++ b/usr/lib/arxis-pentest-tool/main.py
@@ -1,120 +1,188 @@
+import webbrowser
+import ttkbootstrap as ttk
+from ttkbootstrap.dialogs.dialogs import Messagebox
 import logging
 import os
-import json
-import asyncio
+import Functions as f
+import numpy as np
 import threading
-import queue
-import ttkbootstrap as ttk
+import Gui
+import json
 from pathlib import Path
-from concurrent.futures import ThreadPoolExecutor
-from Functions import scan_subnet, Version
-from Gui import widgets, open_github, show_about_window
-
-# Configure logger
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger("ArxisPentester")
 
 
 class PentestTool(ttk.Window):
     def __init__(self):
         super(PentestTool, self).__init__(
-            themename="trinity-dark", title=f"Arxis Pentester v{Version()}"
+            title="Arxis Pentestor", themename="trinity-dark"
         )
-        self.protocol("WM_DELETE_WINDOW", self.on_close)
-        self.config_dir = os.path.join(Path.home(), ".config/arxis-pentester")
-        self.port_list = [22, 80, 443, 8080, 3306]
-        self.queue = queue.Queue()
-        self.loop = asyncio.new_event_loop()
-        self.executor = ThreadPoolExecutor(max_workers=10)
-        self.running = False
-
-        self.logger = logger
-        self.loop_thread = threading.Thread(target=self.start_asyncio_loop, daemon=True)
-        self.loop_thread.start()
-
-        self.logger.info("Pentest Tool Initialized")
-        self.load_config()
-        widgets(self)
-
-    def start_asyncio_loop(self):
-        """Start the asyncio event loop in a separate thread."""
-        asyncio.set_event_loop(self.loop)
-        self.loop.run_forever()
-
-    def save_config(self):
-        """Save configuration to a JSON file."""
-        if not os.path.exists(self.config_dir):
-            os.makedirs(self.config_dir)
-        config_path = os.path.join(self.config_dir, "config.json")
-        data = {
-            "subnet": self.subnet_entry.get(),
-            "ports": self.port_list,
-        }
-        with open(config_path, "w") as f:
-            json.dump(data, f)
-        self.logger.info("Configuration saved.")
-
-    def load_config(self):
-        """Load configuration from a JSON file."""
-        config_path = os.path.join(self.config_dir, "config.json")
-        if os.path.exists(config_path):
-            with open(config_path, "r") as f:
-                data = json.load(f)
-            self.subnet_entry.insert(0, data.get("subnet", ""))
-            self.port_list = data.get("ports", self.port_list)
-            self.logger.info("Configuration loaded.")
-
-    def start_scan(self):
-        """Start the scanning process."""
-        if self.running:
-            self.logger.warning("A scan is already running.")
-            return
-
-        subnet = self.subnet_entry.get()
-        ports = self.port_list
-        self.running = True
-        self.logger.info(f"Starting scan on subnet {subnet} with ports {ports}")
-        asyncio.run_coroutine_threadsafe(
-            scan_subnet(self, subnet, ports, self.update_progress), self.loop
+        self.window_title = "Arxis Pentestor"
+        self.logger = logging.getLogger(__name__)
+        logging.basicConfig(level=logging.INFO)
+        self.logger.setLevel(logging.INFO)
+
+        self.logger.info("Initializing test suite")
+        self.home = str(Path.home())
+        self.configDir = "".join([self.home, "/.config/arxis-pentestor"])
+        self.ftp = [20, 21]
+        self.telnet = [23]
+        self.smtp = [25]
+        self.ldap = [389]
+        self.rdp = [3389]
+        self.mysql = [3306]
+        self.ftp_port_list = (
+            self.ftp + self.telnet + self.smtp + self.ldap + self.rdp + self.mysql
+        )
+        self.ssh = [22]
+        self.web = [443, 80, 8080, 8443]
+        self.port_list = np.concatenate((self.ftp_port_list, self.ssh, self.web))
+        self.results = {}
+        if not os.path.exists(self.configDir):
+            os.makedirs(self.configDir)
+
+        Gui.widgets(self)
+        self.logger.info("Tests initialized")
+
+        self.mainloop()
+
+    def sort_by_ip(self):
+        if self.tree.get_children():
+            self.sort_treeview(column=0, reverse=True)
+            self.logger.info("Hostnames sorted by descending order")
+
+    def sort_by_hostname(self):
+        if self.tree.get_children():
+            self.sort_treeview(column=2, reverse=True)
+            self.logger.info("Hostnames sorted by descending order")
+
+    def sort_by_ports(self):
+        if self.tree.get_children():
+            self.sort_treeview(column=1, reverse=True)
+            self.logger.info("Ports sorted by descending order")
+
+    def selectItem(self, event):
+        try:
+            selected_item = self.tree.item(self.tree.selection())
+            self.logger.info(f"Selected item: {selected_item['values'][0]}")
+            # print(selected_item)
+        except Exception as e:
+            self.logger.error(f"Error selecting item: {str(e)}")
+
+    def sort_treeview(self, column, reverse=False):
+        items = [(self.tree.set(k, column), k) for k in self.tree.get_children("")]
+        items.sort(reverse=reverse)
+
+        for index, (val, k) in enumerate(items):
+            self.tree.move(k, "", index)
+
+        self.tree.heading(
+            column, command=lambda: self.sort_treeview(column, not reverse)
         )
 
-    def handle_queue(self):
-        """Process the queue for scan results."""
-        while not self.queue.empty():
-            item = self.queue.get()
-            self.logger.info(f"Queue received: {item}")
-            if item == "COMPLETE":
-                self.running = False
-                self.logger.info("Scan completed.")
-            else:
-                self.tree.insert("", "end", values=item)
-
-    def nav_github(self):
-        """Navigate to the GitHub project page."""
-        open_github()
-
-    def show_about(self):
-        """Show the About dialog."""
-        show_about_window(self)
-
-    def update_progress(self, progress, scanned_hosts, total_hosts):
-        """Update the progress bar and meter."""
-        progress_value = (scanned_hosts / total_hosts) * 100
-        self.progress.config(value=progress_value)
-        self.status.config(text=f"Scanning progress: {progress_value:.2f}%")
-        self.meter.configure(amountused=scanned_hosts)
-
-    def on_close(self):
-        """Handle application close event."""
-        if self.running:
-            self.logger.warning("Scan in progress. Please wait.")
+    def loadConfig(self):
+        try:
+            if not os.path.isfile(self.configDir + "/config.json"):
+                self.logger.info("No configuration file found, using default settings")
+                if not os.path.exists(self.configDir):
+                    os.makedirs(self.configDir)
+                return {}
+            with open(self.configDir + "/config.json", "r") as file:
+                config = json.load(file)
+            for key, items in config.items():
+                self.tree.insert(
+                    "",
+                    "end",
+                    values=(
+                        key,
+                        np.array2string(np.array(items["ports"]), separator=", ")
+                        .replace("[", "")
+                        .replace("]", "")
+                        .replace(" ", "")
+                        .strip(),
+                        items["hostname"],
+                    ),
+                )
+
+        except FileNotFoundError:
+            self.logger.warning("No configuration file found")
+            return {}
+        except json.JSONDecodeError:
+            self.logger.error("Invalid JSON format in configuration file")
+            return {}
+
+    def saveConfig(self):
+        filename = self.configDir + "/config.json"
+        try:
+            with open(filename, "w") as file:
+                json.dump(self.results, file, indent=4)
+            self.logger.info(f"Configuration saved to {filename}")
+        except Exception as e:
+            self.logger.error(f"Error saving configuration: {str(e)}")
+
+    def runScan(self):
+        subnet = self.subEnt.get()
+        if not subnet:
+            self.messageBox(title="Error", message="No subnet specified", types="error")
+            self.logger.error("No subnet specified")
             return
-        self.loop.call_soon_threadsafe(self.loop.stop)
-        self.executor.shutdown(wait=False)
-        self.logger.info("Application closed.")
-        self.quit()
+        self.logger.info("Running Tests")
+        self.status.config(text="Scan in progress...")
+        self.progress.start()
+
+        scan_thread = threading.Thread(target=lambda: self.perform_scan(subnet))
+        scan_thread.start()
+
+    def perform_scan(self, subnet):
+        f.asyncio.run(f.scan_host(self, subnet, self.port_list))
+        self.progress.stop()
+        self.status.config(text="Scan complete")
+        self.logger.info("Scan Complete..")
+        self.logger.info("----------------------------------------------------------")
+
+    def navGithub(self):
+        webbrowser.open_new_tab("https://github.com/BradHeff/Arxis-Pentester")
+        self.logger.info("Navigated to GitHub repository")
+
+    def messageBox(self, title, message, types="info"):
+        if types == "info":
+            Messagebox.show_info(title=title, message=message, parent=self)
+        elif types == "warning":
+            Messagebox.show_warning(title=title, message=message, parent=self)
+        elif types == "error":
+            Messagebox.show_error(title=title, message=message, parent=self)
+        elif types == "question":
+            result = Messagebox.show_question(title=title, message=message, parent=self)
+            return result == "yes"
+        elif types == "yesno":
+            result = Messagebox.yesno(title=title, message=message, parent=self)
+            return result
+        elif types == "yesnocancel":
+            result = Messagebox.yesnocancel(title=title, message=message, parent=self)
+            return result == "yes"
+        elif types == "okcancel":
+            result = Messagebox.okcancel(title=title, message=message, parent=self)
+            return result
+        elif types == "retrycancel":
+            result = Messagebox.retrycancel(title=title, message=message, parent=self)
+            return result == "retry"
+        else:
+            raise ValueError(f"Invalid type: {types}")
+        self.logger.info("Message box shown")
+
+    def aboutBox(self):
+        Messagebox.show_info(
+            title="About Arxis Pentestor",
+            message=(
+                "Arxis Pentestor is a comprehensive tool designed for network security testing.\n\n"
+                "Purpose:\n"
+                "The application helps identify vulnerable open ports on a network, providing insights into potential security risks.\n\n"
+                f"Version: {f.Version}\n"
+                "Company: Arxis Security Solutions\n"
+                "Website: https://www.arxis.com.au\n"
+            ),
+        )
+        self.logger.info("About box shown")
 
 
 if __name__ == "__main__":
-    app = PentestTool()
-    app.mainloop()
+    PentestTool()