diff --git a/SUPERCOPY.py b/SUPERCOPY.py
index 1ddc516..a8f29b1 100644
--- a/SUPERCOPY.py
+++ b/SUPERCOPY.py
@@ -1,6 +1,7 @@
 files = [
     "core/app_launcher.py",
     "core/discord_presence.py",
+    "core/dukto.py",
     "core/file_search.py",
     "core/headers.py",
     "core/updater.py",
diff --git a/core/discord_presence.py b/core/discord_presence.py
index 0b201c7..bde3d7c 100644
--- a/core/discord_presence.py
+++ b/core/discord_presence.py
@@ -75,7 +75,7 @@ class DiscordPresence:
         print("Stopping Discord presence...")
         self._stop_thread.set()
         if self._thread and self._thread.is_alive():
-            self._thread.join(timeout=5)
+            self._thread.join(timeout=1)
         
         self.running = False
         self.presence = None
diff --git a/core/dukto.py b/core/dukto.py
new file mode 100644
index 0000000..6812bd4
--- /dev/null
+++ b/core/dukto.py
@@ -0,0 +1,507 @@
+#!/usr/bin/env python3
+
+import socket
+import struct
+import threading
+import os
+import platform
+import getpass
+from pathlib import Path
+from typing import List, Optional, Callable, Dict
+
+DEFAULT_UDP_PORT = 4644
+DEFAULT_TCP_PORT = 4644
+
+
+class Peer:
+    def __init__(self, address: str, signature: str, port: int = DEFAULT_UDP_PORT):
+        self.address = address
+        self.signature = signature
+        self.port = port
+    
+    def __repr__(self):
+        return f"Peer({self.address}, {self.signature}, port={self.port})"
+
+
+class DuktoProtocol:    
+    def __init__(self):
+        self.local_udp_port = DEFAULT_UDP_PORT
+        self.local_tcp_port = DEFAULT_TCP_PORT
+        
+        self.udp_socket: Optional[socket.socket] = None
+        self.tcp_server: Optional[socket.socket] = None
+        
+        self.peers: Dict[str, Peer] = {}
+        self.is_sending = False
+        self.is_receiving = False
+        self.is_awaiting_approval = False
+        
+        self.running = False
+        
+        # Confirmation for receiving
+        self._transfer_decision = threading.Event()
+        self._transfer_approved = False
+        
+        # Callbacks
+        self.on_peer_added: Optional[Callable[[Peer], None]] = None
+        self.on_peer_removed: Optional[Callable[[Peer], None]] = None
+        self.on_receive_start: Optional[Callable[[str], None]] = None
+        self.on_receive_request: Optional[Callable[[str], None]] = None
+        self.on_receive_complete: Optional[Callable[[List[str], int], None]] = None
+        self.on_receive_text: Optional[Callable[[str, int], None]] = None
+        self.on_send_start: Optional[Callable[[str], None]] = None
+        self.on_send_complete: Optional[Callable[[List[str]], None]] = None
+        self.on_transfer_progress: Optional[Callable[[int, int], None]] = None
+        self.on_error: Optional[Callable[[str], None]] = None
+        
+    def set_ports(self, udp_port: int, tcp_port: int):
+        self.local_udp_port = udp_port
+        self.local_tcp_port = tcp_port
+    
+    def get_system_signature(self) -> str:
+        name = getpass.getuser() + "'s CLARA"
+        hostname = socket.gethostname()
+        system = platform.system()
+        return f"{name} at {hostname} ({system})"
+    
+    def initialize(self):
+        # UDP Socket for peer discovery
+        self.udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        self.udp_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        self.udp_socket.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
+        self.udp_socket.bind(('', self.local_udp_port))
+        
+        # TCP Server for receiving files
+        self.tcp_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self.tcp_server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        self.tcp_server.bind(('', self.local_tcp_port))
+        self.tcp_server.listen(5)
+        
+        self.running = True
+        
+        # Start listener threads
+        threading.Thread(target=self._udp_listener, daemon=True).start()
+        threading.Thread(target=self._tcp_listener, daemon=True).start()
+        
+    def say_hello(self, dest: str = '<broadcast>', port: int = None):
+        if port is None:
+            port = self.local_udp_port
+        
+        # Prepare packet
+        if port == DEFAULT_UDP_PORT and self.local_udp_port == DEFAULT_UDP_PORT:
+            if dest == '<broadcast>':
+                msg_type = b'\x01'  # HELLO MESSAGE (broadcast)
+            else:
+                msg_type = b'\x02'  # HELLO MESSAGE (unicast)
+            packet = msg_type + self.get_system_signature().encode('utf-8')
+        else:
+            if dest == '<broadcast>':
+                msg_type = b'\x04'  # HELLO MESSAGE (broadcast) with PORT
+            else:
+                msg_type = b'\x05'  # HELLO MESSAGE (unicast) with PORT
+            packet = msg_type + struct.pack('<H', self.local_udp_port) + \
+                     self.get_system_signature().encode('utf-8')
+        
+        # Send packet
+        if dest == '<broadcast>':
+            self._send_to_all_broadcast(packet, port)
+            if port != DEFAULT_UDP_PORT:
+                self._send_to_all_broadcast(packet, DEFAULT_UDP_PORT)
+        else:
+            self.udp_socket.sendto(packet, (dest, port))
+    
+    def say_goodbye(self):
+        packet = b'\x03' + b'Bye Bye'
+        
+        # Collect all discovered ports
+        ports = {self.local_udp_port}
+        if self.local_udp_port != DEFAULT_UDP_PORT:
+            ports.add(DEFAULT_UDP_PORT)
+        for peer in self.peers.values():
+            ports.add(peer.port)
+        
+        # Send to all ports
+        for port in ports:
+            self._send_to_all_broadcast(packet, port)
+    
+    def send_file(self, ip_dest: str, files: List[str], port: int = 0):
+        if port == 0:
+            port = DEFAULT_TCP_PORT
+        
+        if self.is_receiving or self.is_sending:
+            if self.on_error:
+                self.on_error("Already busy with another transfer")
+            return
+        
+        self.is_sending = True
+        threading.Thread(target=self._send_file_thread, 
+                        args=(ip_dest, port, files), daemon=True).start()
+    
+    def send_text(self, ip_dest: str, text: str, port: int = 0):
+        if port == 0:
+            port = DEFAULT_TCP_PORT
+        
+        if self.is_receiving or self.is_sending:
+            if self.on_error:
+                self.on_error("Already busy with another transfer")
+            return
+        
+        self.is_sending = True
+        threading.Thread(target=self._send_text_thread,
+                        args=(ip_dest, port, text), daemon=True).start()
+    
+    def approve_transfer(self):
+        self._transfer_approved = True
+        self._transfer_decision.set()
+
+    def reject_transfer(self):
+        self._transfer_approved = False
+        self._transfer_decision.set()
+
+    def _udp_listener(self):
+        while self.running:
+            try:
+                data, addr = self.udp_socket.recvfrom(4096)
+                self._handle_message(data, addr[0])
+            except Exception as e:
+                if self.running:
+                    print(f"UDP listener error: {e}")
+    
+    def _handle_message(self, data: bytes, sender: str):
+        if len(data) == 0:
+            return
+        
+        msg_type = data[0]
+        
+        if msg_type in (0x01, 0x02):  # HELLO (broadcast/unicast)
+            signature = data[1:].decode('utf-8', errors='ignore')
+            if signature != self.get_system_signature():
+                self.peers[sender] = Peer(sender, signature, DEFAULT_UDP_PORT)
+                if msg_type == 0x01:  # Reply to broadcast
+                    self.say_hello(sender, DEFAULT_UDP_PORT)
+                if self.on_peer_added:
+                    self.on_peer_added(self.peers[sender])
+        
+        elif msg_type == 0x03:  # GOODBYE
+            if sender in self.peers:
+                peer = self.peers[sender]
+                if self.on_peer_removed:
+                    self.on_peer_removed(peer)
+                del self.peers[sender]
+        
+        elif msg_type in (0x04, 0x05):  # HELLO with PORT
+            port = struct.unpack('<H', data[1:3])[0]
+            signature = data[3:].decode('utf-8', errors='ignore')
+            if signature != self.get_system_signature():
+                self.peers[sender] = Peer(sender, signature, port)
+                if msg_type == 0x04:  # Reply to broadcast
+                    self.say_hello(sender, port)
+                if self.on_peer_added:
+                    self.on_peer_added(self.peers[sender])
+    
+    def _tcp_listener(self):
+        while self.running:
+            try:
+                conn, addr = self.tcp_server.accept()
+                if self.is_receiving or self.is_sending or self.is_awaiting_approval:
+                    conn.close()
+                    continue
+                
+                threading.Thread(target=self._handle_transfer_request, 
+                               args=(conn, addr[0]), daemon=True).start()
+            except Exception as e:
+                if self.running:
+                    print(f"TCP listener error: {e}")
+
+    def _handle_transfer_request(self, conn: socket.socket, sender_ip: str):
+        try:
+            self.is_awaiting_approval = True
+            self._transfer_decision.clear()
+
+            if self.on_receive_request:
+                self.on_receive_request(sender_ip)
+            else:
+                self.reject_transfer()
+
+            self._transfer_decision.wait()
+
+            if self._transfer_approved:
+                self._receive_files(conn, sender_ip)
+            else:
+                conn.close()
+        finally:
+            self.is_awaiting_approval = False
+
+    def _receive_files(self, conn: socket.socket, sender_ip: str):
+        self.is_receiving = True
+        
+        # Define the receive directory
+        receive_dir = Path.home() / "Received"
+        receive_dir.mkdir(parents=True, exist_ok=True)
+
+        if self.on_receive_start:
+            self.on_receive_start(sender_ip)
+        
+        try:
+            conn.settimeout(10)
+            
+            # Read header
+            header = conn.recv(16)
+            if len(header) < 16:
+                return
+            
+            elements_count = struct.unpack('<Q', header[0:8])[0]
+            total_size = struct.unpack('<Q', header[8:16])[0]
+            
+            conn.settimeout(None)
+            
+            received_files = []
+            total_received = 0
+            root_folder_name = ""
+            root_folder_renamed = ""
+            receiving_text = False
+            text_data = b""
+            
+            for _ in range(elements_count):
+                # Read element name
+                name_bytes = b""
+                while True:
+                    c = conn.recv(1)
+                    if not c or c == b'\x00':
+                        break
+                    name_bytes += c
+                
+                name = name_bytes.decode('utf-8')
+                
+                # Read element size
+                size_bytes = conn.recv(8)
+                element_size = struct.unpack('<q', size_bytes)[0]
+                
+                if element_size == -1:  # Directory
+                    root_name = name.split('/')[0]
+                    
+                    if root_folder_name != root_name:
+                        # Find unique name
+                        i = 2
+                        original_name = name
+                        dest_path = receive_dir / name
+                        while dest_path.exists():
+                            dest_path = receive_dir / f"{original_name} ({i})"
+                            i += 1
+                        
+                        root_folder_name = original_name
+                        root_folder_renamed = dest_path.name
+                        
+                        final_path = dest_path
+                        received_files.append(str(final_path))
+
+                    elif root_folder_name != root_folder_renamed:
+                        name = name.replace(root_folder_name, root_folder_renamed, 1)
+                        final_path = receive_dir / name
+                    else:
+                        final_path = receive_dir / name
+                    
+                    final_path.mkdir(parents=True, exist_ok=True)
+                
+                elif name == "___DUKTO___TEXT___":  # Text transfer
+                    receiving_text = True
+                    received_files.append(name)
+                    text_data = b""
+                    
+                    # Read text data
+                    received = 0
+                    while received < element_size:
+                        chunk = conn.recv(min(8192, element_size - received))
+                        if not chunk:
+                            break
+                        text_data += chunk
+                        received += len(chunk)
+                        total_received += len(chunk)
+                        if self.on_transfer_progress:
+                            self.on_transfer_progress(total_size, total_received)
+                
+                else:  # Regular file
+                    dest_name = name
+                    if '/' in name and name.split('/')[0] == root_folder_name:
+                        dest_name = dest_name.replace(root_folder_name, root_folder_renamed, 1)
+                    
+                    # Find unique filename
+                    i = 2
+                    original_path = receive_dir / dest_name
+                    dest_path = original_path
+                    while dest_path.exists():
+                        dest_path = original_path.with_name(f"{original_path.stem} ({i}){original_path.suffix}")
+                        i += 1
+                    
+                    received_files.append(str(dest_path))
+                    dest_path.parent.mkdir(parents=True, exist_ok=True)
+                    
+                    # Receive file data
+                    with open(dest_path, 'wb') as f:
+                        received = 0
+                        while received < element_size:
+                            chunk = conn.recv(min(8192, element_size - received))
+                            if not chunk:
+                                break
+                            f.write(chunk)
+                            received += len(chunk)
+                            total_received += len(chunk)
+                            if self.on_transfer_progress:
+                                self.on_transfer_progress(total_size, total_received)
+            
+            # Transfer complete
+            if receiving_text:
+                text = text_data.decode('utf-8')
+                if self.on_receive_text:
+                    self.on_receive_text(text, total_size)
+            else:
+                if self.on_receive_complete:
+                    self.on_receive_complete(received_files, total_size)
+        
+        except Exception as e:
+            if self.on_error:
+                self.on_error(f"Receive error: {e}")
+        
+        finally:
+            conn.close()
+            self.is_receiving = False
+    
+    def _send_file_thread(self, ip_dest: str, port: int, files: List[str]):
+        try:
+            if self.on_send_start:
+                self.on_send_start(ip_dest)
+            
+            # Expand file tree
+            expanded_files = self._expand_tree(files)
+            
+            # Connect
+            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            sock.connect((ip_dest, port))
+            
+            # Calculate total size
+            total_size = self._compute_total_size(expanded_files)
+            
+            # Send header
+            header = struct.pack('<Q', len(expanded_files))
+            header += struct.pack('<Q', total_size)
+            sock.sendall(header)
+            
+            base_path = str(Path(files[0]).parent)
+            sent_data = len(header)
+            
+            # Send each element
+            for filepath in expanded_files:
+                path = Path(filepath)
+                relative_name = str(path.relative_to(base_path))
+                
+                # Send name
+                sock.sendall(relative_name.encode('utf-8') + b'\x00')
+                
+                if path.is_dir():
+                    # Send directory marker
+                    sock.sendall(struct.pack('<q', -1))
+                else:
+                    # Send file size
+                    file_size = path.stat().st_size
+                    sock.sendall(struct.pack('<q', file_size))
+                    
+                    # Send file data
+                    with open(filepath, 'rb') as f:
+                        while True:
+                            chunk = f.read(10000)
+                            if not chunk:
+                                break
+                            sock.sendall(chunk)
+                            sent_data += len(chunk)
+                            if self.on_transfer_progress:
+                                self.on_transfer_progress(total_size, sent_data)
+            
+            sock.close()
+            
+            if self.on_send_complete:
+                self.on_send_complete(files)
+        
+        except Exception as e:
+            if self.on_error:
+                self.on_error(f"Send error: {e}")
+        
+        finally:
+            self.is_sending = False
+    
+    def _send_text_thread(self, ip_dest: str, port: int, text: str):
+        try:
+            if self.on_send_start:
+                self.on_send_start(ip_dest)
+            
+            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            sock.connect((ip_dest, port))
+            
+            text_bytes = text.encode('utf-8')
+            total_size = len(text_bytes)
+            
+            # Send header
+            header = struct.pack('<Q', 1)  # 1 element
+            header += struct.pack('<Q', total_size)
+            sock.sendall(header)
+            
+            # Send text marker
+            sock.sendall(b'___DUKTO___TEXT___\x00')
+            sock.sendall(struct.pack('<q', total_size))
+            
+            # Send text data
+            sock.sendall(text_bytes)
+            
+            sock.close()
+            
+            if self.on_send_complete:
+                self.on_send_complete(["___DUKTO___TEXT___"])
+        
+        except Exception as e:
+            if self.on_error:
+                self.on_error(f"Send text error: {e}")
+        
+        finally:
+            self.is_sending = False
+    
+    def _expand_tree(self, files: List[str]) -> List[str]:
+        expanded = []
+        
+        for filepath in files:
+            path = Path(filepath)
+            if path.is_dir():
+                self._add_recursive(expanded, path)
+            else:
+                expanded.append(str(path))
+        
+        return expanded
+    
+    def _add_recursive(self, expanded: List[str], path: Path):
+        expanded.append(str(path))
+        
+        if path.is_dir():
+            for entry in path.iterdir():
+                self._add_recursive(expanded, entry)
+    
+    def _compute_total_size(self, files: List[str]) -> int:
+        total = 0
+        for filepath in files:
+            path = Path(filepath)
+            if path.is_file():
+                total += path.stat().st_size
+        return total
+    
+    def _send_to_all_broadcast(self, packet: bytes, port: int):
+        # Try common broadcast
+        try:
+            self.udp_socket.sendto(packet, ('255.255.255.255', port))
+        except:
+            pass
+    
+    def shutdown(self):
+        self.running = False
+        self.say_goodbye()
+        
+        if self.udp_socket:
+            self.udp_socket.close()
+        if self.tcp_server:
+            self.tcp_server.close()
\ No newline at end of file
diff --git a/main.py b/main.py
index 6234f30..d54acc3 100644
--- a/main.py
+++ b/main.py
@@ -9,6 +9,7 @@ from core.web_search import MullvadLetaWrapper
 from core.discord_presence import presence
 from core.app_launcher import list_apps, launch
 from core.updater import update_repository, is_update_available
+from core.dukto import DuktoProtocol, Peer
 
 ASSET = Path(__file__).parent / "assets" / "2ktan.png"
 
@@ -316,10 +317,55 @@ class WebSearchResults(QtWidgets.QDialog):
             QtWidgets.QApplication.restoreOverrideCursor()
 
 
+class TextViewerDialog(QtWidgets.QDialog):
+    def __init__(self, text, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle("Text Received")
+        self.setMinimumSize(400, 300)
+
+        self.text_to_copy = text
+        layout = QtWidgets.QVBoxLayout(self)
+
+        self.text_edit = QtWidgets.QTextEdit()
+        self.text_edit.setPlainText(text)
+        self.text_edit.setReadOnly(True)
+        layout.addWidget(self.text_edit)
+
+        button_layout = QtWidgets.QHBoxLayout()
+        button_layout.addStretch()
+
+        copy_button = QtWidgets.QPushButton("Copy to Clipboard")
+        copy_button.clicked.connect(self.copy_text)
+        button_layout.addWidget(copy_button)
+
+        close_button = QtWidgets.QPushButton("Close")
+        close_button.clicked.connect(self.accept)
+        button_layout.addWidget(close_button)
+
+        layout.addLayout(button_layout)
+
+    def copy_text(self):
+        clipboard = QtWidgets.QApplication.clipboard()
+        clipboard.setText(self.text_to_copy)
+
+
 class MainWindow(QtWidgets.QMainWindow):
     show_menu_signal = QtCore.Signal()
+    
+    # Dukto signals
+    peer_added_signal = QtCore.Signal(Peer)
+    peer_removed_signal = QtCore.Signal(Peer)
+    receive_request_signal = QtCore.Signal(str)
+    progress_update_signal = QtCore.Signal(int, int)
+    receive_start_signal = QtCore.Signal(str)
+    receive_complete_signal = QtCore.Signal(list, int)
+    receive_text_signal = QtCore.Signal(str, int)
+    send_start_signal = QtCore.Signal(str)
+    send_complete_signal = QtCore.Signal(list)
+    dukto_error_signal = QtCore.Signal(str)
 
-    def __init__(self, restart=False, no_quit=False, super_menu=True):
+
+    def __init__(self, dukto_handler, restart=False, no_quit=False, super_menu=True):
         super().__init__()
 
         flags = (
@@ -344,6 +390,32 @@ class MainWindow(QtWidgets.QMainWindow):
         self.setMask(mask)
 
         self.super_menu = super_menu
+        self.dukto_handler = dukto_handler
+        self.progress_dialog = None
+
+        # Connect Dukto callbacks to emit signals
+        self.dukto_handler.on_peer_added = lambda peer: self.peer_added_signal.emit(peer)
+        self.dukto_handler.on_peer_removed = lambda peer: self.peer_removed_signal.emit(peer)
+        self.dukto_handler.on_receive_request = lambda ip: self.receive_request_signal.emit(ip)
+        self.dukto_handler.on_transfer_progress = lambda total, rec: self.progress_update_signal.emit(total, rec)
+        self.dukto_handler.on_receive_start = lambda ip: self.receive_start_signal.emit(ip)
+        self.dukto_handler.on_receive_complete = lambda files, size: self.receive_complete_signal.emit(files, size)
+        self.dukto_handler.on_receive_text = lambda text, size: self.receive_text_signal.emit(text, size)
+        self.dukto_handler.on_send_start = lambda ip: self.send_start_signal.emit(ip)
+        self.dukto_handler.on_send_complete = lambda files: self.send_complete_signal.emit(files)
+        self.dukto_handler.on_error = lambda msg: self.dukto_error_signal.emit(msg)
+        
+        # Connect signals to GUI slots
+        self.peer_added_signal.connect(self.update_peer_menus)
+        self.peer_removed_signal.connect(self.update_peer_menus)
+        self.receive_request_signal.connect(self.show_receive_confirmation)
+        self.progress_update_signal.connect(self.update_progress_dialog)
+        self.receive_start_signal.connect(self.handle_receive_start)
+        self.receive_complete_signal.connect(self.handle_receive_complete)
+        self.receive_text_signal.connect(self.handle_receive_text)
+        self.send_start_signal.connect(self.handle_send_start)
+        self.send_complete_signal.connect(self.handle_send_complete)
+        self.dukto_error_signal.connect(self.handle_dukto_error)
 
         self.tray = QtWidgets.QSystemTrayIcon(self)
         self.tray.setIcon(QtGui.QIcon(str(ASSET)))
@@ -354,6 +426,10 @@ class MainWindow(QtWidgets.QMainWindow):
         right_menu.addAction("Search Files", self.start_file_search)
         right_menu.addAction("Search Web", self.start_web_search)
         right_menu.addSeparator()
+        send_menu_right = right_menu.addMenu("Send")
+        self.send_files_submenu_right = send_menu_right.addMenu("Send File(s)")
+        self.send_text_submenu_right = send_menu_right.addMenu("Send Text")
+        right_menu.addSeparator()
         right_menu.addAction("Check for updates", self.update_git)
         if restart:
             right_menu.addAction("Restart", self.restart_application)
@@ -370,6 +446,12 @@ class MainWindow(QtWidgets.QMainWindow):
         self.left_menu.addAction("Launch App", self.start_app_launcher)
         self.left_menu.addAction("Search Files", self.start_file_search)
         self.left_menu.addAction("Search Web", self.start_web_search)
+        self.left_menu.addSeparator()
+        send_menu_left = self.left_menu.addMenu("Send")
+        self.send_files_submenu_left = send_menu_left.addMenu("Send File(s)")
+        self.send_text_submenu_left = send_menu_left.addMenu("Send Text")
+        
+        self.update_peer_menus()
 
         # always on top timer
         self.stay_on_top_timer = QtCore.QTimer(self)
@@ -418,6 +500,141 @@ class MainWindow(QtWidgets.QMainWindow):
     def toggle_visible(self):
         self.setVisible(not self.isVisible())
 
+    def update_peer_menus(self):
+        self.send_files_submenu_left.clear()
+        self.send_text_submenu_left.clear()
+        self.send_files_submenu_right.clear()
+        self.send_text_submenu_right.clear()
+
+        peers = list(self.dukto_handler.peers.values())
+
+        if not peers:
+            no_peers_action_left_files = self.send_files_submenu_left.addAction("No peers found")
+            no_peers_action_left_files.setEnabled(False)
+            no_peers_action_left_text = self.send_text_submenu_left.addAction("No peers found")
+            no_peers_action_left_text.setEnabled(False)
+            
+            no_peers_action_right_files = self.send_files_submenu_right.addAction("No peers found")
+            no_peers_action_right_files.setEnabled(False)
+            no_peers_action_right_text = self.send_text_submenu_right.addAction("No peers found")
+            no_peers_action_right_text.setEnabled(False)
+            return
+
+        for peer in sorted(peers, key=lambda p: p.signature):
+            file_action_left = self.send_files_submenu_left.addAction(peer.signature)
+            file_action_right = self.send_files_submenu_right.addAction(peer.signature)
+            
+            text_action_left = self.send_text_submenu_left.addAction(peer.signature)
+            text_action_right = self.send_text_submenu_right.addAction(peer.signature)
+
+            file_action_left.triggered.connect(lambda checked=False, p=peer: self.start_file_send(p))
+            file_action_right.triggered.connect(lambda checked=False, p=peer: self.start_file_send(p))
+            
+            text_action_left.triggered.connect(lambda checked=False, p=peer: self.start_text_send(p))
+            text_action_right.triggered.connect(lambda checked=False, p=peer: self.start_text_send(p))
+
+    def start_file_send(self, peer: Peer):
+        file_paths, _ = QtWidgets.QFileDialog.getOpenFileNames(
+            self,
+            f"Select files to send to {peer.signature}",
+            str(Path.home()),
+        )
+        if file_paths:
+            self.dukto_handler.send_file(peer.address, file_paths, peer.port)
+
+    def start_text_send(self, peer: Peer):
+        text, ok = QtWidgets.QInputDialog.getMultiLineText(
+            self,
+            f"Send Text to {peer.signature}",
+            "Enter text to send:"
+        )
+        if ok and text:
+            self.dukto_handler.send_text(peer.address, text, peer.port)
+
+    def show_receive_confirmation(self, sender_ip: str):
+        reply = QtWidgets.QMessageBox.question(
+            self,
+            "Incoming Transfer",
+            f"You have an incoming transfer from {sender_ip}.\nDo you want to accept it?",
+            QtWidgets.QMessageBox.StandardButton.Yes | QtWidgets.QMessageBox.StandardButton.No,
+            QtWidgets.QMessageBox.StandardButton.No
+        )
+        if reply == QtWidgets.QMessageBox.StandardButton.Yes:
+            self.dukto_handler.approve_transfer()
+        else:
+            self.dukto_handler.reject_transfer()
+
+    @QtCore.Slot(str)
+    def handle_receive_start(self, sender_ip: str):
+        self.progress_dialog = QtWidgets.QProgressDialog("Receiving data...", "Cancel", 0, 100, self)
+        self.progress_dialog.setWindowTitle(f"Receiving from {sender_ip}")
+        self.progress_dialog.setWindowModality(QtCore.Qt.WindowModal) # type: ignore
+        self.progress_dialog.show()
+    
+    @QtCore.Slot(str)
+    def handle_send_start(self, dest_ip: str):
+        self.progress_dialog = QtWidgets.QProgressDialog("Sending data...", "Cancel", 0, 100, self)
+        self.progress_dialog.setWindowTitle(f"Sending to {dest_ip}")
+        self.progress_dialog.setWindowModality(QtCore.Qt.WindowModal) # type: ignore
+        self.progress_dialog.show()
+
+    @QtCore.Slot(int, int)
+    def update_progress_dialog(self, total_size: int, received: int):
+        if self.progress_dialog:
+            self.progress_dialog.setMaximum(total_size)
+            self.progress_dialog.setValue(received)
+
+    @QtCore.Slot(list, int)
+    def handle_receive_complete(self, received_files: list, total_size: int):
+        if self.progress_dialog:
+            self.progress_dialog.setValue(total_size)
+            self.progress_dialog.close()
+            self.progress_dialog = None
+        
+        QtWidgets.QMessageBox.information(self, "Transfer Complete", f"Successfully received {len(received_files)} items to ~/Received.")
+        
+        reply = QtWidgets.QMessageBox.question(
+            self,
+            "Open Directory",
+            "Do you want to open the folder now?",
+            QtWidgets.QMessageBox.StandardButton.Yes | QtWidgets.QMessageBox.StandardButton.No,
+            QtWidgets.QMessageBox.StandardButton.Yes
+        )
+
+        if reply == QtWidgets.QMessageBox.StandardButton.Yes:
+            receive_dir = str(Path.home() / "Received")
+            url = QtCore.QUrl.fromLocalFile(receive_dir)
+            QtGui.QDesktopServices.openUrl(url)
+    
+    @QtCore.Slot(list)
+    def handle_send_complete(self, sent_files: list):
+        if self.progress_dialog:
+            if self.progress_dialog.maximum() > 0:
+                self.progress_dialog.setValue(self.progress_dialog.maximum())
+            self.progress_dialog.close()
+            self.progress_dialog = None
+        
+        if sent_files and sent_files[0] == "___DUKTO___TEXT___":
+            QtWidgets.QMessageBox.information(self, "Transfer Complete", "Text sent successfully.")
+        else:
+            QtWidgets.QMessageBox.information(self, "Transfer Complete", f"Successfully sent {len(sent_files)} items.")
+
+    @QtCore.Slot(str, int)
+    def handle_receive_text(self, text: str, total_size: int):
+        if self.progress_dialog:
+            self.progress_dialog.close()
+            self.progress_dialog = None
+        
+        dialog = TextViewerDialog(text, self)
+        dialog.exec()
+
+    @QtCore.Slot(str)
+    def handle_dukto_error(self, error_msg: str):
+        if self.progress_dialog:
+            self.progress_dialog.close()
+            self.progress_dialog = None
+        QtWidgets.QMessageBox.critical(self, "Transfer Error", error_msg)
+
     def start_app_launcher(self):
         self.app_launcher_dialog = AppLauncherDialog(self)
         self.app_launcher_dialog.move(QtGui.QCursor.pos())
@@ -519,6 +736,7 @@ class MainWindow(QtWidgets.QMainWindow):
 
     def restart_application(self):
         presence.end()
+        self.dukto_handler.shutdown()
         
         args = [sys.executable] + sys.argv
 
@@ -534,9 +752,16 @@ def main():
     restart = "--restart" in sys.argv
     no_quit = "--no-quit" in sys.argv
     super_menu = not "--no-super" in sys.argv
-    pet = MainWindow(restart=restart, no_quit=no_quit, super_menu=super_menu)
+    
+    dukto_handler = DuktoProtocol()
+    
+    pet = MainWindow(dukto_handler=dukto_handler, restart=restart, no_quit=no_quit, super_menu=super_menu)
+    
     presence.start()
     
+    dukto_handler.initialize()
+    dukto_handler.say_hello()
+    
     # bottom right corner
     screen_geometry = app.primaryScreen().availableGeometry()
     pet_geometry = pet.frameGeometry()
@@ -547,6 +772,7 @@ def main():
     pet.show()
 
     app.aboutToQuit.connect(presence.end)
+    app.aboutToQuit.connect(dukto_handler.shutdown)
     sys.exit(app.exec())