commit ced7fd12320f996c1e85d9a6f93dd91277e34ecb
Author: Manos <manos555555@users.noreply.github.com>
Date:   Mon Jan 12 17:26:03 2026 +0200

    Initial commit: PS5 Upload Suite - High-Speed File Transfer

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..f9fa6f9
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,60 @@
+# Build results
+[Dd]ebug/
+[Dd]ebugPublic/
+[Rr]elease/
+[Rr]eleases/
+x64/
+x86/
+[Ww][Ii][Nn]32/
+[Aa][Rr][Mm]/
+[Aa][Rr][Mm]64/
+bld/
+[Bb]in/
+[Oo]bj/
+[Ll]og/
+[Ll]ogs/
+
+# Visual Studio cache/options
+.vs/
+*.suo
+*.user
+*.userosscache
+*.sln.docstates
+
+# Build results
+*.dll
+*.exe
+*.pdb
+*.cache
+
+# .NET Core
+project.lock.json
+project.fragment.lock.json
+artifacts/
+
+# Files built by Visual Studio
+*.pidb
+*.svclog
+*.scc
+
+# Caches
+*.swp
+*~
+
+# OS generated files
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Temporary files
+*.tmp
+*.log
+*.bak
+*.old
+
+# PowerShell script
+convert_to_ico.ps1
diff --git a/PROTOCOL.md b/PROTOCOL.md
new file mode 100644
index 0000000..d15d424
--- /dev/null
+++ b/PROTOCOL.md
@@ -0,0 +1,83 @@
+# PS5 Upload Protocol Specification
+
+## Overview
+Custom binary protocol for high-speed file transfers between PC and PS5.
+Port: 9113
+
+## Message Format
+
+All messages follow this structure:
+```
+[Command (1 byte)][Data Length (4 bytes)][Data (variable)]
+```
+
+## Commands
+
+### Client → Server
+
+| Command | Value | Description | Data Format |
+|---------|-------|-------------|-------------|
+| PING | 0x01 | Test connection | None |
+| LIST_STORAGE | 0x02 | Get storage info | None |
+| LIST_DIR | 0x03 | List directory | Path (null-terminated string) |
+| CREATE_DIR | 0x04 | Create directory | Path (null-terminated string) |
+| DELETE_FILE | 0x05 | Delete file | Path (null-terminated string) |
+| DELETE_DIR | 0x06 | Delete directory | Path (null-terminated string) |
+| START_UPLOAD | 0x10 | Start file upload | Path (null-terminated) + File size (8 bytes) |
+| UPLOAD_CHUNK | 0x11 | Upload file chunk | Chunk data (raw bytes) |
+| END_UPLOAD | 0x12 | Finish upload | None |
+| SHUTDOWN | 0xFF | Shutdown server | None |
+
+### Server → Client
+
+| Response | Value | Description | Data Format |
+|----------|-------|-------------|-------------|
+| OK | 0x01 | Success | Optional message |
+| ERROR | 0x02 | Error occurred | Error message (null-terminated) |
+| DATA | 0x03 | Response data | Variable format |
+| READY | 0x04 | Ready for next chunk | None |
+| PROGRESS | 0x05 | Upload progress | Bytes written (8 bytes) |
+
+## Data Formats
+
+### LIST_STORAGE Response
+```
+[Drive count (4 bytes)]
+For each drive:
+  [Path length (2 bytes)][Path][Total space (8 bytes)][Free space (8 bytes)]
+```
+
+### LIST_DIR Response
+```
+[Entry count (4 bytes)]
+For each entry:
+  [Type (1 byte: 0=file, 1=dir)][Name length (2 bytes)][Name][Size (8 bytes)][Timestamp (8 bytes)]
+```
+
+## Flow Examples
+
+### Upload File
+```
+Client: START_UPLOAD "/data/test.bin" size=1048576
+Server: READY
+Client: UPLOAD_CHUNK [4MB data]
+Server: PROGRESS bytes=4194304
+Client: UPLOAD_CHUNK [remaining data]
+Server: PROGRESS bytes=1048576
+Client: END_UPLOAD
+Server: OK
+```
+
+### List Directory
+```
+Client: LIST_DIR "/data"
+Server: DATA [directory listing]
+```
+
+## Performance Optimizations
+
+- 4MB socket buffers
+- SO_NOSIGPIPE enabled
+- TCP_NODELAY for low latency
+- Direct disk writes (no temp files)
+- Streaming chunks (no full file buffering)
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..3e00047
--- /dev/null
+++ b/README.md
@@ -0,0 +1,206 @@
+# 🚀 PS5 Upload Suite - High-Speed File Transfer
+
+**By Manos**
+
+Custom high-speed file transfer system for PS5 with etaHEN. Achieves **100+ MB/s** transfer speeds using a custom binary protocol.
+
+![PS5 Upload Client](screenshots/screenshot1.png)
+![Upload in Progress](screenshots/screenshot2.png)
+
+---
+
+## 📦 What's Included
+
+### 1. PS5 Server Payload
+- **File:** `payload/ps5_upload_server.elf`
+- **Port:** 9113
+- **Protocol:** Custom binary (optimized for speed)
+- **Features:**
+  - 4MB socket buffers
+  - SO_NOSIGPIPE enabled
+  - TCP_NODELAY for low latency
+  - Direct disk writes (no temp files)
+  - Multi-threaded client handling
+
+### 2. Windows GUI Client
+- **File:** `client/bin/Release/net6.0-windows/win-x64/publish/PS5Upload.exe`
+- **Framework:** .NET 6.0 WPF
+- **Features:**
+  - Modern dark theme UI
+  - Drag & drop file/folder upload
+  - Browse PS5 filesystem
+  - Real-time upload progress
+  - Speed indicator (MB/s)
+  - Storage space display
+  - Recursive folder upload
+
+---
+
+## 🚀 Quick Start
+
+### Step 1: Load PS5 Payload
+
+1. Copy `payload/ps5_upload_server.elf` to your PS5:
+   ```
+   /data/etaHEN/payloads/ps5_upload_server.elf
+   ```
+
+2. Load the payload with elfldr
+
+3. You should see notification:
+   ```
+   PS5 Upload Server: 192.168.0.XXX:9113 - By Manos
+   ```
+
+### Step 2: Run Windows Client
+
+1. Run `PS5Upload.exe` on your PC
+
+2. Enter your PS5's IP address (e.g., `192.168.0.160`)
+
+3. Click **Connect**
+
+4. Browse files/folders or drag & drop
+
+5. Click **Upload to PS5**
+
+---
+
+## 🎨 Features
+
+### PS5 Server
+✅ **High-Speed Protocol** - Custom binary protocol  
+✅ **4MB Buffers** - Maximum throughput  
+✅ **Direct Disk I/O** - No temp files  
+✅ **Multi-threaded** - Handle multiple clients  
+✅ **Robust Error Handling** - Graceful failures  
+
+### Windows Client
+✅ **Modern UI** - Dark theme, clean design  
+✅ **Drag & Drop** - Files and folders  
+✅ **Browse PS5** - Navigate filesystem  
+✅ **Real-time Progress** - Speed & percentage  
+✅ **Folder Upload** - Recursive directory upload  
+✅ **Storage Info** - Free space display  
+
+---
+
+## 📊 Performance
+
+| Network | Expected Speed |
+|---------|----------------|
+| **Gigabit Ethernet** | 100-120 MB/s |
+| **WiFi 6 (5GHz)** | 60-80 MB/s |
+| **WiFi 5 (5GHz)** | 40-60 MB/s |
+
+**Note:** Speeds depend on network quality and PS5 disk performance.
+
+---
+
+## 🔧 Building from Source
+
+### PS5 Payload
+
+Requirements:
+- PS5 SDK (prospero-clang)
+- WSL or Linux
+
+```bash
+cd payload
+bash compile.sh
+```
+
+### Windows Client
+
+Requirements:
+- .NET 6.0 SDK or later
+- Windows 10/11
+
+```cmd
+cd client
+build.bat
+```
+
+Or manually:
+```cmd
+dotnet publish -c Release -r win-x64 --self-contained true
+```
+
+---
+
+## 📋 Protocol Specification
+
+See [PROTOCOL.md](PROTOCOL.md) for detailed protocol documentation.
+
+### Commands
+- `PING` - Test connection
+- `LIST_STORAGE` - Get storage info
+- `LIST_DIR` - List directory contents
+- `CREATE_DIR` - Create directory
+- `DELETE_FILE` - Delete file
+- `DELETE_DIR` - Delete directory
+- `START_UPLOAD` - Begin file upload
+- `UPLOAD_CHUNK` - Upload file chunk
+- `END_UPLOAD` - Finish upload
+- `SHUTDOWN` - Shutdown server
+
+---
+
+## 🛠️ Troubleshooting
+
+### Connection Failed
+- Make sure PS5 payload is running
+- Check PS5 IP address is correct
+- Verify both devices are on same network
+- Check firewall settings
+
+### Slow Upload Speed
+- Use wired Ethernet connection (not WiFi)
+- Close other network applications
+- Check PS5 disk health
+
+### Upload Fails
+- Check PS5 has enough free space
+- Verify destination path exists
+- Check file permissions
+
+---
+
+## 🔒 Security Notes
+
+- Server only accepts connections from local network
+- No authentication required (local network only)
+- SHUTDOWN command only works from localhost
+
+---
+
+## 📝 License
+
+MIT License - Free to use and modify
+
+---
+
+## 👤 Author
+
+**Manos**
+
+Created with ❤️ for the PS5 homebrew community
+
+---
+
+## 🙏 Credits
+
+- PS5 SDK
+- etaHEN
+- Inspired by ps5upload by PhantomPtr
+- PS5 homebrew community
+
+---
+
+## 📞 Support
+
+For issues or questions, please open an issue on GitHub.
+
+---
+
+**Enjoy blazing-fast file transfers on your PS5!** 🚀
diff --git a/client/App.xaml b/client/App.xaml
new file mode 100644
index 0000000..3144dca
--- /dev/null
+++ b/client/App.xaml
@@ -0,0 +1,8 @@
+<Application x:Class="PS5Upload.App"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             StartupUri="MainWindow.xaml">
+    <Application.Resources>
+         
+    </Application.Resources>
+</Application>
diff --git a/client/App.xaml.cs b/client/App.xaml.cs
new file mode 100644
index 0000000..934fbaf
--- /dev/null
+++ b/client/App.xaml.cs
@@ -0,0 +1,8 @@
+using System.Windows;
+
+namespace PS5Upload
+{
+    public partial class App : Application
+    {
+    }
+}
diff --git a/client/MainWindow.xaml b/client/MainWindow.xaml
new file mode 100644
index 0000000..a35cb34
--- /dev/null
+++ b/client/MainWindow.xaml
@@ -0,0 +1,473 @@
+<Window x:Class="PS5Upload.MainWindow"
+        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        Title="PS5 Upload - High-Speed File Transfer" Height="600" Width="1200"
+        WindowStartupLocation="CenterScreen"
+        Background="#1E1E1E"
+        Icon="ps5_logo.png">
+    
+    <Window.Resources>
+        <Style TargetType="Button">
+            <Setter Property="Background" Value="#007ACC"/>
+            <Setter Property="Foreground" Value="White"/>
+            <Setter Property="BorderThickness" Value="0"/>
+            <Setter Property="Padding" Value="15,8"/>
+            <Setter Property="FontSize" Value="14"/>
+            <Setter Property="Cursor" Value="Hand"/>
+            <Setter Property="Template">
+                <Setter.Value>
+                    <ControlTemplate TargetType="Button">
+                        <Border Background="{TemplateBinding Background}" 
+                                CornerRadius="4" 
+                                Padding="{TemplateBinding Padding}">
+                            <ContentPresenter HorizontalAlignment="Center" VerticalAlignment="Center"/>
+                        </Border>
+                    </ControlTemplate>
+                </Setter.Value>
+            </Setter>
+            <Style.Triggers>
+                <Trigger Property="IsMouseOver" Value="True">
+                    <Setter Property="Background" Value="#1C97EA"/>
+                </Trigger>
+                <Trigger Property="IsEnabled" Value="False">
+                    <Setter Property="Background" Value="#3E3E42"/>
+                    <Setter Property="Foreground" Value="#666666"/>
+                </Trigger>
+            </Style.Triggers>
+        </Style>
+
+        <Style TargetType="TextBox">
+            <Setter Property="Background" Value="#2D2D30"/>
+            <Setter Property="Foreground" Value="White"/>
+            <Setter Property="BorderBrush" Value="#3E3E42"/>
+            <Setter Property="BorderThickness" Value="1"/>
+            <Setter Property="Padding" Value="8"/>
+            <Setter Property="FontSize" Value="14"/>
+        </Style>
+
+        <Style TargetType="ListBox">
+            <Setter Property="Background" Value="#2D2D30"/>
+            <Setter Property="Foreground" Value="White"/>
+            <Setter Property="BorderBrush" Value="#3E3E42"/>
+            <Setter Property="BorderThickness" Value="1"/>
+        </Style>
+
+        <Style TargetType="TextBlock">
+            <Setter Property="Foreground" Value="White"/>
+        </Style>
+    </Window.Resources>
+
+    <Grid Margin="20">
+        <Grid.RowDefinitions>
+            <RowDefinition Height="Auto"/>
+            <RowDefinition Height="Auto"/>
+            <RowDefinition Height="*"/>
+            <RowDefinition Height="Auto"/>
+            <RowDefinition Height="Auto"/>
+        </Grid.RowDefinitions>
+
+        <!-- Header -->
+        <StackPanel Grid.Row="0" Margin="0,0,0,20" Orientation="Horizontal" HorizontalAlignment="Center">
+            <Image Source="ps5_logo.png" 
+                   Width="80" 
+                   Height="80" 
+                   Margin="0,0,15,0"
+                   VerticalAlignment="Center"/>
+            <StackPanel VerticalAlignment="Center">
+                <TextBlock Text="PS5 Upload - High-Speed File Transfer" 
+                           FontSize="24" 
+                           FontWeight="Bold"
+                           Foreground="#007ACC"/>
+                <TextBlock Text="By Manos" 
+                           FontSize="12" 
+                           Foreground="#999999"
+                           Margin="0,5,0,0"/>
+            </StackPanel>
+        </StackPanel>
+
+        <!-- Connection Panel -->
+        <Border Grid.Row="1" 
+                Background="#252526" 
+                BorderBrush="#3E3E42" 
+                BorderThickness="1" 
+                CornerRadius="4" 
+                Padding="15"
+                Margin="0,0,0,15">
+            <Grid>
+                <Grid.ColumnDefinitions>
+                    <ColumnDefinition Width="Auto"/>
+                    <ColumnDefinition Width="*"/>
+                    <ColumnDefinition Width="Auto"/>
+                    <ColumnDefinition Width="Auto"/>
+                </Grid.ColumnDefinitions>
+
+                <TextBlock Grid.Column="0" 
+                           Text="PS5 IP Address:" 
+                           VerticalAlignment="Center"
+                           Margin="0,0,10,0"/>
+                
+                <TextBox Grid.Column="1" 
+                         x:Name="IpAddressTextBox"
+                         Text="192.168.0.160"
+                         VerticalAlignment="Center"
+                         Margin="0,0,10,0"/>
+                
+                <Button Grid.Column="2" 
+                        x:Name="ConnectButton"
+                        Content="Connect"
+                        Click="ConnectButton_Click"
+                        Width="100"
+                        Margin="0,0,10,0"/>
+
+                <StackPanel Grid.Column="3" 
+                            Orientation="Horizontal" 
+                            VerticalAlignment="Center">
+                    <Ellipse x:Name="StatusIndicator" 
+                             Width="12" 
+                             Height="12" 
+                             Fill="#DC3545"
+                             Margin="0,0,8,0"/>
+                    <TextBlock x:Name="StatusText" 
+                               Text="Disconnected"
+                               Foreground="#999999"/>
+                </StackPanel>
+            </Grid>
+        </Border>
+
+        <!-- Main Content -->
+        <Grid Grid.Row="2">
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="*"/>
+                <ColumnDefinition Width="15"/>
+                <ColumnDefinition Width="*"/>
+                <ColumnDefinition Width="15"/>
+                <ColumnDefinition Width="300"/>
+            </Grid.ColumnDefinitions>
+
+            <!-- Local Files -->
+            <Border Grid.Column="0" 
+                    Background="#252526" 
+                    BorderBrush="#3E3E42" 
+                    BorderThickness="1" 
+                    CornerRadius="4">
+                <Grid>
+                    <Grid.RowDefinitions>
+                        <RowDefinition Height="Auto"/>
+                        <RowDefinition Height="*"/>
+                        <RowDefinition Height="Auto"/>
+                    </Grid.RowDefinitions>
+
+                    <Border Grid.Row="0" 
+                            Background="#2D2D30" 
+                            Padding="10"
+                            BorderBrush="#3E3E42"
+                            BorderThickness="0,0,0,1">
+                        <TextBlock Text="📁 Local Files" 
+                                   FontSize="16" 
+                                   FontWeight="SemiBold"/>
+                    </Border>
+
+                    <ListBox Grid.Row="1" 
+                             x:Name="LocalFilesListBox"
+                             BorderThickness="0"
+                             AllowDrop="True"
+                             Drop="LocalFilesListBox_Drop"
+                             DragEnter="LocalFilesListBox_DragEnter"
+                             MouseRightButtonUp="LocalFilesListBox_RightClick">
+                        <ListBox.ItemTemplate>
+                            <DataTemplate>
+                                <StackPanel Orientation="Horizontal" Margin="5">
+                                    <TextBlock Text="{Binding Icon}" 
+                                               FontSize="16" 
+                                               Margin="0,0,10,0"/>
+                                    <TextBlock Text="{Binding Name}" 
+                                               VerticalAlignment="Center"/>
+                                </StackPanel>
+                            </DataTemplate>
+                        </ListBox.ItemTemplate>
+                        <ListBox.ContextMenu>
+                            <ContextMenu>
+                                <MenuItem Header="🗑️ Remove" Click="RemoveLocalFile_Click"/>
+                            </ContextMenu>
+                        </ListBox.ContextMenu>
+                    </ListBox>
+
+                    <StackPanel Grid.Row="2" 
+                                Orientation="Horizontal" 
+                                Margin="10"
+                                HorizontalAlignment="Center">
+                        <Button Content="Browse Files" 
+                                Click="BrowseFilesButton_Click"
+                                Margin="0,0,5,0"/>
+                        <Button Content="Browse Folder" 
+                                Click="BrowseFolderButton_Click"
+                                Margin="0,0,5,0"/>
+                        <Button Content="Clear All" 
+                                Click="ClearLocalFiles_Click"
+                                Background="#DC3545"/>
+                    </StackPanel>
+                </Grid>
+            </Border>
+
+            <!-- PS5 Files -->
+            <Border Grid.Column="2" 
+                    Background="#252526" 
+                    BorderBrush="#3E3E42" 
+                    BorderThickness="1" 
+                    CornerRadius="4">
+                <Grid>
+                    <Grid.RowDefinitions>
+                        <RowDefinition Height="Auto"/>
+                        <RowDefinition Height="Auto"/>
+                        <RowDefinition Height="*"/>
+                        <RowDefinition Height="Auto"/>
+                    </Grid.RowDefinitions>
+
+                    <Border Grid.Row="0" 
+                            Background="#2D2D30" 
+                            Padding="10"
+                            BorderBrush="#3E3E42"
+                            BorderThickness="0,0,0,1">
+                        <TextBlock Text="🎮 PS5 Files" 
+                                   FontSize="16" 
+                                   FontWeight="SemiBold"/>
+                    </Border>
+
+                    <StackPanel Grid.Row="1" 
+                                Orientation="Horizontal" 
+                                Margin="10"
+                                Background="#2D2D30">
+                        <TextBlock Text="Current Path:" 
+                                   VerticalAlignment="Center"
+                                   Margin="0,0,10,0"/>
+                        <TextBox x:Name="CurrentPathTextBox"
+                                 Text="/data"
+                                 Width="200"
+                                 VerticalAlignment="Center"
+                                 Margin="0,0,10,0"/>
+                        <Button Content="Go" 
+                                Click="GoButton_Click"
+                                Width="60"/>
+                    </StackPanel>
+
+                    <ListBox Grid.Row="2" 
+                             x:Name="PS5FilesListBox"
+                             BorderThickness="0"
+                             MouseDoubleClick="PS5FilesListBox_MouseDoubleClick">
+                        <ListBox.ContextMenu>
+                            <ContextMenu>
+                                <MenuItem Header="📝 Rename" Click="RenameMenuItem_Click"/>
+                                <MenuItem Header="📋 Copy" Click="CopyMenuItem_Click"/>
+                                <MenuItem Header="✂️ Move" Click="MoveMenuItem_Click"/>
+                                <Separator/>
+                                <MenuItem Header="🗑️ Delete" Click="DeleteMenuItem_Click"/>
+                            </ContextMenu>
+                        </ListBox.ContextMenu>
+                        <ListBox.ItemTemplate>
+                            <DataTemplate>
+                                <StackPanel Orientation="Horizontal" Margin="5">
+                                    <TextBlock Text="{Binding Icon}" 
+                                               FontSize="16" 
+                                               Margin="0,0,10,0"/>
+                                    <StackPanel>
+                                        <TextBlock Text="{Binding Name}" 
+                                                   FontWeight="SemiBold"/>
+                                        <TextBlock Text="{Binding SizeText}" 
+                                                   FontSize="11" 
+                                                   Foreground="#999999"/>
+                                    </StackPanel>
+                                </StackPanel>
+                            </DataTemplate>
+                        </ListBox.ItemTemplate>
+                    </ListBox>
+
+                    <StackPanel Grid.Row="3" 
+                                Margin="10">
+                        <TextBlock x:Name="StorageInfoText" 
+                                   Text="Storage: --" 
+                                   FontSize="12"
+                                   Foreground="#999999"
+                                   HorizontalAlignment="Center"/>
+                    </StackPanel>
+                </Grid>
+            </Border>
+
+            <!-- Log Panel -->
+            <Border Grid.Column="4" 
+                    Background="#252526" 
+                    BorderBrush="#3E3E42" 
+                    BorderThickness="1" 
+                    CornerRadius="4">
+                <Grid>
+                    <Grid.RowDefinitions>
+                        <RowDefinition Height="Auto"/>
+                        <RowDefinition Height="*"/>
+                        <RowDefinition Height="Auto"/>
+                    </Grid.RowDefinitions>
+
+                    <Border Grid.Row="0" 
+                            Background="#2D2D30" 
+                            Padding="10"
+                            BorderBrush="#3E3E42"
+                            BorderThickness="0,0,0,1">
+                        <TextBlock Text="📋 Debug Log" 
+                                   FontSize="16" 
+                                   FontWeight="SemiBold"/>
+                    </Border>
+
+                    <TextBox Grid.Row="1" 
+                             x:Name="LogTextBox"
+                             Text=""
+                             FontFamily="Consolas"
+                             FontSize="11"
+                             Foreground="#CCCCCC"
+                             Background="#1E1E1E"
+                             BorderThickness="0"
+                             Padding="10"
+                             TextWrapping="Wrap"
+                             IsReadOnly="True"
+                             VerticalScrollBarVisibility="Auto"
+                             HorizontalScrollBarVisibility="Auto"/>
+
+                    <StackPanel Grid.Row="2" 
+                                Orientation="Horizontal" 
+                                Margin="10"
+                                HorizontalAlignment="Center">
+                        <Button Content="📋 Copy Log"
+                                Click="CopyLogButton_Click"
+                                Margin="0,0,10,0"
+                                Background="#28A745"/>
+                        <Button Content="Clear Log"
+                                Click="ClearLogButton_Click"
+                                Background="#3E3E42"/>
+                    </StackPanel>
+                </Grid>
+            </Border>
+        </Grid>
+
+        <!-- Upload Progress -->
+        <Border Grid.Row="3" 
+                Background="#252526" 
+                BorderBrush="#3E3E42" 
+                BorderThickness="1" 
+                CornerRadius="4" 
+                Padding="15"
+                Margin="0,15,0,0"
+                x:Name="ProgressPanel"
+                Visibility="Collapsed">
+            <Grid>
+                <Grid.RowDefinitions>
+                    <RowDefinition Height="Auto"/>
+                    <RowDefinition Height="Auto"/>
+                    <RowDefinition Height="Auto"/>
+                    <RowDefinition Height="Auto"/>
+                    <RowDefinition Height="Auto"/>
+                    <RowDefinition Height="Auto"/>
+                    <RowDefinition Height="Auto"/>
+                </Grid.RowDefinitions>
+
+                <!-- Files Remaining Counter -->
+                <TextBlock Grid.Row="0" 
+                           x:Name="FilesRemainingText"
+                           Text="Files: 0 / 0 (0 remaining)"
+                           FontSize="13"
+                           FontWeight="SemiBold"
+                           Foreground="#FFC107"
+                           Margin="0,0,0,8"/>
+
+                <!-- Total Folder Progress -->
+                <TextBlock Grid.Row="1" 
+                           x:Name="TotalProgressText"
+                           Text="Total: 0 / 0 files"
+                           FontSize="14"
+                           FontWeight="SemiBold"
+                           Foreground="#28A745"
+                           Margin="0,0,0,5"/>
+
+                <ProgressBar Grid.Row="2" 
+                             x:Name="TotalProgressBar"
+                             Height="20"
+                             Minimum="0"
+                             Maximum="100"
+                             Value="0"
+                             Foreground="#17A2B8"
+                             Background="#2D2D30"
+                             BorderBrush="#3E3E42"
+                             Margin="0,0,0,10"/>
+
+                <!-- Current File -->
+                <TextBlock Grid.Row="3" 
+                           x:Name="UploadFileNameText"
+                           Text="Uploading: filename.bin"
+                           FontSize="13"
+                           Margin="0,0,0,5"/>
+
+                <ProgressBar Grid.Row="4" 
+                             x:Name="UploadProgressBar"
+                             Height="20"
+                             Minimum="0"
+                             Maximum="100"
+                             Value="0"
+                             Foreground="#28A745"
+                             Background="#2D2D30"
+                             BorderBrush="#3E3E42"/>
+
+                <!-- Speed and Progress -->
+                <Grid Grid.Row="5" Margin="0,8,0,0">
+                    <Grid.ColumnDefinitions>
+                        <ColumnDefinition Width="*"/>
+                        <ColumnDefinition Width="Auto"/>
+                    </Grid.ColumnDefinitions>
+
+                    <TextBlock Grid.Column="0" 
+                               x:Name="UploadSpeedText"
+                               Text="Speed: 0 MB/s | Avg: 0 MB/s"
+                               FontSize="12"
+                               Foreground="#999999"/>
+
+                    <TextBlock Grid.Column="1" 
+                               x:Name="UploadProgressText"
+                               Text="0 / 0 MB (0%)"
+                               FontSize="12"
+                               Foreground="#999999"/>
+                </Grid>
+
+                <!-- ETA -->
+                <TextBlock Grid.Row="6" 
+                           x:Name="UploadETAText"
+                           Text="ETA: Calculating..."
+                           FontSize="12"
+                           Foreground="#999999"
+                           Margin="0,5,0,0"/>
+            </Grid>
+        </Border>
+
+        <!-- Upload Buttons -->
+        <Grid Grid.Row="4" Margin="0,15,0,0">
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="*"/>
+                <ColumnDefinition Width="10"/>
+                <ColumnDefinition Width="150"/>
+            </Grid.ColumnDefinitions>
+            
+            <Button Grid.Column="0"
+                    x:Name="UploadButton"
+                    Content="⬆️ Upload to PS5"
+                    Click="UploadButton_Click"
+                    Height="45"
+                    FontSize="16"
+                    FontWeight="SemiBold"
+                    IsEnabled="False"/>
+            
+            <Button Grid.Column="2"
+                    x:Name="CancelButton"
+                    Content="❌ Cancel"
+                    Click="CancelButton_Click"
+                    Height="45"
+                    FontSize="16"
+                    FontWeight="SemiBold"
+                    Background="#DC3545"
+                    IsEnabled="False"/>
+        </Grid>
+    </Grid>
+</Window>
diff --git a/client/MainWindow.xaml.cs b/client/MainWindow.xaml.cs
new file mode 100644
index 0000000..44dbbf9
--- /dev/null
+++ b/client/MainWindow.xaml.cs
@@ -0,0 +1,1625 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Input;
+using System.Windows.Threading;
+using Microsoft.Win32;
+
+namespace PS5Upload
+{
+    public partial class MainWindow : Window
+    {
+        private PS5Protocol _protocol = new PS5Protocol();
+        private ObservableCollection<LocalFileItem> _localFiles = new ObservableCollection<LocalFileItem>();
+        private ObservableCollection<PS5FileItem> _ps5Files = new ObservableCollection<PS5FileItem>();
+        private string _currentPS5Path = "/data";
+        private CancellationTokenSource? _uploadCancellation;
+        private string _ps5IpAddress = "";
+        
+        // Parallel upload settings
+        private const int MaxParallelUploads = 6; // Optimal number for stable high-speed uploads
+        
+        // Total upload tracking
+        private int _totalFilesToUpload = 0;
+        private int _currentFileIndex = 0;
+        private long _totalBytesToUpload = 0;
+        private long _totalBytesUploaded = 0;
+        private int _completedFiles = 0;
+        private DateTime _uploadStartTime;
+        private readonly object _progressLock = new object();
+        
+        // Current file progress tracking (for largest active file)
+        private string _currentFileName = "";
+        private long _currentFileBytes = 0;
+        private long _currentFileTotalBytes = 0;
+        
+        // Real-time UI update timer
+        private DispatcherTimer _uiUpdateTimer;
+        private int _activeTaskCount = 0;
+
+        public MainWindow()
+        {
+            InitializeComponent();
+            LocalFilesListBox.ItemsSource = _localFiles;
+            PS5FilesListBox.ItemsSource = _ps5Files;
+            
+            // Initialize real-time UI update timer (500ms interval)
+            _uiUpdateTimer = new DispatcherTimer();
+            _uiUpdateTimer.Interval = TimeSpan.FromMilliseconds(500);
+            _uiUpdateTimer.Tick += UiUpdateTimer_Tick;
+            
+            Log("Application started");
+        }
+
+        private void UiUpdateTimer_Tick(object sender, EventArgs e)
+        {
+            // Update UI stats in real-time (called every 500ms)
+            int completed;
+            lock (_progressLock)
+            {
+                completed = _completedFiles;
+            }
+            UpdateUploadStats(completed, _activeTaskCount);
+        }
+
+        private void ClearLogButton_Click(object sender, RoutedEventArgs e)
+        {
+            LogTextBox.Clear();
+            Log("Log cleared");
+        }
+
+        private async void CopyLogButton_Click(object sender, RoutedEventArgs e)
+        {
+            try
+            {
+                // Copy log text asynchronously without selecting it in the UI
+                // This prevents the UI freeze that happens with Ctrl+A
+                string logContent = "";
+                
+                await Dispatcher.InvokeAsync(() =>
+                {
+                    logContent = LogTextBox.Text;
+                });
+                
+                // Copy to clipboard on a background thread
+                await Task.Run(() =>
+                {
+                    Dispatcher.Invoke(() =>
+                    {
+                        System.Windows.Clipboard.SetText(logContent);
+                    });
+                });
+                
+                Log("📋 Log copied to clipboard!");
+            }
+            catch (Exception ex)
+            {
+                Log($"❌ Failed to copy log: {ex.Message}");
+            }
+        }
+
+        private void UpdateUploadStats(int completedFiles, int activeTaskCount)
+        {
+            Dispatcher.Invoke(() =>
+            {
+                // Update files remaining counter
+                int remainingFiles = _totalFilesToUpload - completedFiles;
+                if (completedFiles > 0)
+                {
+                    FilesRemainingText.Text = $"Files: {completedFiles} / {_totalFilesToUpload} ({remainingFiles} remaining)";
+                }
+                else
+                {
+                    FilesRemainingText.Text = $"Files: 0 / {_totalFilesToUpload} ({_totalFilesToUpload} remaining)";
+                }
+                
+                // Update total progress
+                double totalPercent = _totalBytesToUpload > 0 ? (double)_totalBytesUploaded / _totalBytesToUpload * 100 : 0;
+                TotalProgressBar.Value = totalPercent;
+                
+                if (completedFiles > 0)
+                {
+                    TotalProgressText.Text = $"Total: {completedFiles} / {_totalFilesToUpload} files ({FormatFileSize(_totalBytesUploaded)} / {FormatFileSize(_totalBytesToUpload)})";
+                }
+                else
+                {
+                    // Real-time update without completed file count
+                    TotalProgressText.Text = $"Total: {FormatFileSize(_totalBytesUploaded)} / {FormatFileSize(_totalBytesToUpload)} ({totalPercent:F1}%)";
+                }
+                
+                // Calculate speed and ETA in real-time
+                var elapsed = DateTime.Now - _uploadStartTime;
+                double speed = elapsed.TotalSeconds > 0 ? _totalBytesUploaded / elapsed.TotalSeconds : 0;
+                long remaining = _totalBytesToUpload - _totalBytesUploaded;
+                TimeSpan eta = speed > 0 ? TimeSpan.FromSeconds(remaining / speed) : TimeSpan.Zero;
+                
+                // Update speed and ETA
+                UploadSpeedText.Text = $"Speed: {FormatFileSize((long)speed)}/s | {activeTaskCount} active";
+                UploadETAText.Text = $"ETA: {eta:mm\\:ss} | Elapsed: {elapsed:mm\\:ss}";
+                
+                if (activeTaskCount > 0)
+                {
+                    UploadFileNameText.Text = $"Uploading {activeTaskCount} files in parallel...";
+                }
+            });
+        }
+
+        private void Log(string message)
+        {
+            Dispatcher.Invoke(() =>
+            {
+                string timestamp = DateTime.Now.ToString("HH:mm:ss.fff");
+                LogTextBox.AppendText($"[{timestamp}] {message}\n");
+                LogTextBox.ScrollToEnd();
+            });
+        }
+
+        private async void ConnectButton_Click(object sender, RoutedEventArgs e)
+        {
+            ConnectButton.IsEnabled = false;
+            string ipAddress = IpAddressTextBox.Text.Trim();
+            
+            if (string.IsNullOrEmpty(ipAddress))
+            {
+                MessageBox.Show("Please enter PS5 IP address", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
+                ConnectButton.IsEnabled = true;
+                return;
+            }
+
+            _ps5IpAddress = ipAddress;
+            Log($"Connecting to PS5 at {ipAddress}...");
+
+            // Check if we should disconnect
+            if (_protocol.IsConnected)
+            {
+                Log("🔌 Disconnecting from PS5...");
+                _protocol.Disconnect();
+                
+                Dispatcher.Invoke(() =>
+                {
+                    ConnectButton.Content = "🔴 Disconnected";
+                    ConnectButton.Background = new System.Windows.Media.SolidColorBrush(System.Windows.Media.Colors.DarkRed);
+                    UploadButton.IsEnabled = false;
+                    _ps5Files.Clear();
+                });
+                
+                Log("✅ Disconnected from PS5");
+                
+                // Wait a moment then change back to Connect
+                await Task.Delay(1000);
+                Dispatcher.Invoke(() =>
+                {
+                    ConnectButton.Content = "🔵 Connect";
+                    ConnectButton.Background = new System.Windows.Media.SolidColorBrush(System.Windows.Media.Color.FromRgb(0, 122, 204));
+                });
+            }
+            else
+            {
+                // Connect
+                if (await _protocol.ConnectAsync(ipAddress))
+                {
+                    Log("✅ Connected to PS5 successfully");
+                    
+                    // Update UI to show connected status
+                    Dispatcher.Invoke(() =>
+                    {
+                        ConnectButton.Content = "� Disconnect";
+                        ConnectButton.Background = new System.Windows.Media.SolidColorBrush(System.Windows.Media.Colors.DarkGreen);
+                        UploadButton.IsEnabled = true;
+                    });
+                    
+                    await LoadPS5DirectoryAsync(_currentPS5Path);
+                }
+                else
+                {
+                    Log("❌ Failed to connect to PS5");
+                    MessageBox.Show("Failed to connect to PS5. Make sure the payload is running.", "Connection Error", MessageBoxButton.OK, MessageBoxImage.Error);
+                }
+            }
+
+            ConnectButton.IsEnabled = true;
+        }
+
+        private async Task LoadPS5DirectoryAsync(string path)
+        {
+            try
+            {
+                // Don't try to load directory if upload is in progress
+                if (_uploadCancellation != null && !_uploadCancellation.Token.IsCancellationRequested)
+                {
+                    Log("⚠️ Skipping directory load - upload in progress");
+                    return;
+                }
+                
+                // Ensure connection is active before loading directory
+                if (!_protocol.IsConnected)
+                {
+                    Log("⚠️ Connection lost, reconnecting...");
+                    if (!await _protocol.ConnectAsync(_ps5IpAddress))
+                    {
+                        MessageBox.Show("Failed to reconnect to PS5", "Connection Error", MessageBoxButton.OK, MessageBoxImage.Error);
+                        return;
+                    }
+                    Log("✅ Reconnected successfully");
+                }
+                var sw = System.Diagnostics.Stopwatch.StartNew();
+                
+                _currentPS5Path = path;
+                CurrentPathTextBox.Text = path;
+
+                var t1 = sw.ElapsedMilliseconds;
+                var entries = await _protocol.ListDirAsync(path);
+                var t2 = sw.ElapsedMilliseconds;
+                
+                // Build list first to avoid multiple UI updates
+                var items = new List<PS5FileItem>();
+                
+                if (path != "/")
+                {
+                    string parentPath = Path.GetDirectoryName(path);
+                    if (string.IsNullOrEmpty(parentPath))
+                        parentPath = "/";
+                    else
+                        parentPath = parentPath.Replace("\\", "/");
+                    
+                    items.Add(new PS5FileItem
+                    {
+                        Name = "..",
+                        FullPath = parentPath,
+                        Icon = "📁",
+                        IsDirectory = true,
+                        Size = 0
+                    });
+                }
+
+                foreach (var entry in entries)
+                {
+                    items.Add(new PS5FileItem
+                    {
+                        Name = entry.Name,
+                        FullPath = path + "/" + entry.Name,
+                        Icon = entry.IsDirectory ? "📁" : "📄",
+                        IsDirectory = entry.IsDirectory,
+                        Size = entry.Size
+                    });
+                }
+
+                // Sort: folders first, then files (both alphabetically)
+                var sortedItems = items.Where(i => i.Name == "..").ToList();
+                sortedItems.AddRange(items.Where(i => i.Name != ".." && i.IsDirectory).OrderBy(i => i.Name));
+                sortedItems.AddRange(items.Where(i => !i.IsDirectory).OrderBy(i => i.Name));
+
+                var t3 = sw.ElapsedMilliseconds;
+                
+                // Single UI update
+                _ps5Files.Clear();
+                foreach (var item in sortedItems)
+                {
+                    _ps5Files.Add(item);
+                }
+
+                var t4 = sw.ElapsedMilliseconds;
+                int entryCount = entries.Count();
+                Log("📂 Loaded " + entryCount.ToString() + " items (Total: " + t4.ToString() + "ms)");
+            }
+            catch (Exception ex)
+            {
+                // Only show error if we're actually connected (not during disconnect)
+                if (_protocol.IsConnected)
+                {
+                    Log($"❌ Failed to load directory: {ex.Message}");
+                    MessageBox.Show($"Failed to load directory: {ex.Message}", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
+                }
+            }
+        }
+
+        private void BrowseFilesButton_Click(object sender, RoutedEventArgs e)
+        {
+            var dialog = new OpenFileDialog
+            {
+                Multiselect = true,
+                Title = "Select files to upload"
+            };
+
+            if (dialog.ShowDialog() == true)
+            {
+                foreach (string file in dialog.FileNames)
+                {
+                    FileInfo info = new FileInfo(file);
+                    _localFiles.Add(new LocalFileItem
+                    {
+                        Name = info.Name,
+                        FullPath = file,
+                        Icon = "📄",
+                        IsDirectory = false,
+                        Size = info.Length
+                    });
+                }
+            }
+        }
+
+        private void BrowseFolderButton_Click(object sender, RoutedEventArgs e)
+        {
+            var dialog = new System.Windows.Forms.FolderBrowserDialog
+            {
+                Description = "Select folder to upload"
+            };
+
+            if (dialog.ShowDialog() == System.Windows.Forms.DialogResult.OK)
+            {
+                DirectoryInfo dirInfo = new DirectoryInfo(dialog.SelectedPath);
+                _localFiles.Add(new LocalFileItem
+                {
+                    Name = dirInfo.Name,
+                    FullPath = dialog.SelectedPath,
+                    Icon = "📁",
+                    IsDirectory = true,
+                    Size = 0
+                });
+            }
+        }
+
+        private void RemoveLocalFile_Click(object sender, RoutedEventArgs e)
+        {
+            if (LocalFilesListBox.SelectedItem is LocalFileItem selectedItem)
+            {
+                _localFiles.Remove(selectedItem);
+            }
+        }
+
+        private void ClearLocalFiles_Click(object sender, RoutedEventArgs e)
+        {
+            _localFiles.Clear();
+        }
+
+        private void LocalFilesListBox_RightClick(object sender, MouseButtonEventArgs e)
+        {
+            // Context menu is handled by XAML
+        }
+
+        private void LocalFilesListBox_DragEnter(object sender, DragEventArgs e)
+        {
+            if (e.Data.GetDataPresent(DataFormats.FileDrop))
+            {
+                e.Effects = DragDropEffects.Copy;
+            }
+        }
+
+        private void LocalFilesListBox_Drop(object sender, DragEventArgs e)
+        {
+            if (e.Data.GetDataPresent(DataFormats.FileDrop))
+            {
+                string[] files = (string[])e.Data.GetData(DataFormats.FileDrop);
+                foreach (string path in files)
+                {
+                    if (File.Exists(path))
+                    {
+                        FileInfo info = new FileInfo(path);
+                        _localFiles.Add(new LocalFileItem
+                        {
+                            Name = info.Name,
+                            FullPath = path,
+                            Icon = "📄",
+                            IsDirectory = false,
+                            Size = info.Length
+                        });
+                    }
+                    else if (Directory.Exists(path))
+                    {
+                        DirectoryInfo dirInfo = new DirectoryInfo(path);
+                        _localFiles.Add(new LocalFileItem
+                        {
+                            Name = dirInfo.Name,
+                            FullPath = path,
+                            Icon = "📁",
+                            IsDirectory = true,
+                            Size = 0
+                        });
+                    }
+                }
+            }
+        }
+
+        private async void UploadButton_Click(object sender, RoutedEventArgs e)
+        {
+            if (_localFiles.Count == 0)
+            {
+                MessageBox.Show("No files selected for upload", "Info", MessageBoxButton.OK, MessageBoxImage.Information);
+                return;
+            }
+
+            if (!_protocol.IsConnected)
+            {
+                MessageBox.Show("Not connected to PS5", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
+                return;
+            }
+
+            UploadButton.IsEnabled = false;
+            CancelButton.IsEnabled = true;
+            ProgressPanel.Visibility = Visibility.Visible;
+            _uploadCancellation = new CancellationTokenSource();
+
+            Log("========== UPLOAD STARTED ==========");
+            Log("Collecting files...");
+
+            // Collect all files to upload
+            var allFiles = new List<(string localPath, string remotePath)>();
+            foreach (var item in _localFiles)
+            {
+                if (item.IsDirectory)
+                {
+                    CollectFilesFromDirectory(item.FullPath, _currentPS5Path + "/" + item.Name, allFiles);
+                }
+                else
+                {
+                    allFiles.Add((item.FullPath, _currentPS5Path + "/" + item.Name));
+                }
+            }
+
+            _totalFilesToUpload = allFiles.Count;
+            _totalBytesToUpload = allFiles.Sum(f => new FileInfo(f.localPath).Length);
+            _totalBytesUploaded = 0;
+            _completedFiles = 0;
+            _currentFileIndex = 0;
+            _uploadStartTime = DateTime.Now;
+            Log($"📊 Total: {_totalFilesToUpload} files, {FormatFileSize(_totalBytesToUpload)}");
+
+            TotalProgressText.Text = $"Total: 0 / {_totalFilesToUpload} files ({FormatFileSize(0)} / {FormatFileSize(_totalBytesToUpload)})";
+            TotalProgressBar.Value = 0;
+
+            try
+            {
+                // First, create all necessary directories using main connection
+                Log("Creating directories...");
+                var directories = allFiles
+                    .Select(f => Path.GetDirectoryName(f.remotePath)?.Replace("\\", "/"))
+                    .Where(d => !string.IsNullOrEmpty(d) && d != _currentPS5Path)
+                    .Distinct()
+                    .OrderBy(d => d?.Length ?? 0)
+                    .ToList();
+
+                // Ensure connection is active before creating directories
+                if (!_protocol.IsConnected)
+                {
+                    Log("⚠️ Connection lost before directory creation, reconnecting...");
+                    if (!await _protocol.ConnectAsync(_ps5IpAddress))
+                    {
+                        throw new Exception("Failed to reconnect to PS5 before directory creation");
+                    }
+                    Log("✅ Reconnected successfully");
+                }
+                
+                foreach (var dir in directories)
+                {
+                    if (!string.IsNullOrEmpty(dir))
+                    {
+                        Log($"📁 Creating dir: {dir}");
+                        try
+                        {
+                            await _protocol.CreateDirAsync(dir);
+                        }
+                        catch (Exception ex)
+                        {
+                            Log($"⚠️ Failed to create dir {dir}: {ex.Message}, retrying...");
+                            // Try to reconnect and retry
+                            _protocol.Disconnect();
+                            await Task.Delay(500);
+                            if (await _protocol.ConnectAsync(_ps5IpAddress))
+                            {
+                                await _protocol.CreateDirAsync(dir);
+                            }
+                            else
+                            {
+                                throw new Exception($"Failed to create directory {dir} after reconnection");
+                            }
+                        }
+                    }
+                }
+                Log($"✅ Created {directories.Count} directories");
+                
+                // Ensure connection is still active after directory creation
+                if (!_protocol.IsConnected)
+                {
+                    Log("⚠️ Connection lost after directory creation, reconnecting...");
+                    if (!await _protocol.ConnectAsync(_ps5IpAddress))
+                    {
+                        throw new Exception("Failed to reconnect to PS5 after directory creation");
+                    }
+                    Log("✅ Reconnected successfully");
+                }
+                
+                // Start real-time UI updates
+                _uiUpdateTimer.Start();
+
+                // PARALLEL UPLOAD: Process files in batches using multiple connections
+                Log($"🚀 Starting parallel upload with {MaxParallelUploads} connections");
+                var fileQueue = new Queue<(string localPath, string remotePath)>(allFiles);
+                var activeTasks = new List<Task>();
+                var activeConnections = new List<PS5Protocol>();
+                var taskToFilePath = new Dictionary<Task, string>(); // Map tasks to file paths
+                var fileChunkCounts = new Dictionary<string, int>(); // Track how many chunks per file
+                var fileChunksCompleted = new Dictionary<string, int>(); // Track completed chunks per file
+                var completedFiles = new HashSet<string>(); // Track which files are fully complete
+
+                UploadFileNameText.Text = $"Parallel upload: {MaxParallelUploads} connections";
+
+                while (fileQueue.Count > 0 || activeTasks.Count > 0)
+                {
+                    if (_uploadCancellation.Token.IsCancellationRequested)
+                    {
+                        Log("⚠️ Upload cancelled by user");
+                        break;
+                    }
+
+                    // Start new tasks up to MaxParallelUploads
+                    while (fileQueue.Count > 0 && activeTasks.Count < MaxParallelUploads)
+                    {
+                        var (localPath, remotePath) = fileQueue.Dequeue();
+                        FileInfo fileInfo = new FileInfo(localPath);
+                        
+                        // For large files (>100MB), use chunked parallel upload for maximum speed
+                        const long ChunkThreshold = 100L * 1024L * 1024L; // 100MB - chunk earlier for better speed
+                        const long VeryLargeThreshold = 10L * 1024L * 1024L * 1024L; // 10GB
+                        const long MediumThreshold = 1024L * 1024L * 1024L; // 1GB
+                        if (fileInfo.Length > ChunkThreshold)
+                        {
+                            // Adaptive chunk count based on file size:
+                            // >10GB: 8 chunks (maximum parallelism with fire-and-forget)
+                            // 1-10GB: 8 chunks (maximum parallelism)
+                            // 100MB-1GB: 6 chunks (aggressive parallelism)
+                            int chunkCount;
+                            if (fileInfo.Length > VeryLargeThreshold)
+                                chunkCount = 8; // Maximum parallelism for huge files
+                            else if (fileInfo.Length > MediumThreshold)
+                                chunkCount = 8; // Maximum parallelism for large files
+                            else
+                                chunkCount = 6; // Aggressive parallelism for medium files
+                            
+                            // Split file into chunks for parallel upload
+                            long chunkSize = fileInfo.Length / chunkCount;
+                            Log($"📤 Starting CHUNKED upload: {Path.GetFileName(localPath)} ({FormatFileSize(fileInfo.Length)}) - {chunkCount} chunks");
+                            
+                            // Create all connections first, then start uploads in parallel
+                            var connections = new List<PS5Protocol>();
+                            var connectionTasks = new List<Task<PS5Protocol?>>();
+                            
+                            for (int i = 0; i < chunkCount; i++)
+                            {
+                                int chunkIndex = i;
+                                var connTask = Task.Run(async () =>
+                                {
+                                    var conn = new PS5Protocol();
+                                    if (await conn.ConnectAsync(_ps5IpAddress))
+                                    {
+                                        Log($"✅ Chunk {chunkIndex + 1}/{chunkCount} connected");
+                                        return conn;
+                                    }
+                                    return null;
+                                });
+                                connectionTasks.Add(connTask);
+                            }
+                            
+                            // Wait for all connections to complete
+                            var connResults = await Task.WhenAll(connectionTasks);
+                            
+                            // Track chunk count for this file
+                            fileChunkCounts[localPath] = chunkCount;
+                            fileChunksCompleted[localPath] = 0;
+                            
+                            // Start all uploads in parallel
+                            for (int i = 0; i < chunkCount; i++)
+                            {
+                                var conn = connResults[i];
+                                if (conn != null)
+                                {
+                                    long offset = i * chunkSize;
+                                    long size = (i == chunkCount - 1) ? (fileInfo.Length - offset) : chunkSize;
+                                    
+                                    lock (activeConnections)
+                                    {
+                                        activeConnections.Add(conn);
+                                    }
+                                    
+                                    var uploadTask = UploadFileChunkAsync(conn, localPath, remotePath, offset, size, _uploadCancellation.Token);
+                                    activeTasks.Add(uploadTask);
+                                    taskToFilePath[uploadTask] = localPath; // Map task to file
+                                }
+                            }
+                        }
+                        else
+                        {
+                            // Normal single-connection upload for small files
+                            Log($"📤 Starting upload: {Path.GetFileName(localPath)} (Queue: {fileQueue.Count}, Active: {activeTasks.Count})");
+                            var connection = new PS5Protocol();
+                            
+                            if (await connection.ConnectAsync(_ps5IpAddress))
+                            {
+                                Log($"✅ Connection {activeTasks.Count + 1} established");
+                                activeConnections.Add(connection);
+                                var task = UploadFileParallelAsync(connection, localPath, remotePath, _uploadCancellation.Token);
+                                activeTasks.Add(task);
+                                taskToFilePath[task] = localPath; // Map task to file
+                                fileChunkCounts[localPath] = 1; // Single chunk for small files
+                                fileChunksCompleted[localPath] = 0;
+                            }
+                            else
+                            {
+                                Log($"❌ Connection failed, requeueing {Path.GetFileName(localPath)}");
+                                // Connection failed, put file back in queue and wait
+                                fileQueue.Enqueue((localPath, remotePath));
+                                break;
+                            }
+                        }
+                    }
+
+                    if (activeTasks.Count > 0)
+                    {
+                        Log($"⏳ Waiting for task completion (Active: {activeTasks.Count})");
+                        // Wait for any task to complete
+                        var completedTask = await Task.WhenAny(activeTasks);
+                        Log($"✅ Task completed");
+                        
+                        // Await the task to catch any exceptions
+                        try
+                        {
+                            await completedTask;
+                            Log($"✅ Task awaited successfully");
+                        }
+                        catch (Exception ex)
+                        {
+                            Log($"❌ Task exception: {ex.Message}");
+                            Dispatcher.Invoke(() =>
+                            {
+                                UploadFileNameText.Text = $"Upload error: {ex.Message}";
+                            });
+                        }
+                        
+                        int taskIndex = activeTasks.IndexOf(completedTask);
+                        Log($"🔍 Task index: {taskIndex} (Total tasks: {activeTasks.Count}, Connections: {activeConnections.Count})");
+                        
+                        if (taskIndex >= 0 && taskIndex < activeConnections.Count)
+                        {
+                            Log($"🧹 Cleaning up task {taskIndex}");
+                            
+                            // Get the file path for this task
+                            string filePath = null;
+                            if (taskToFilePath.TryGetValue(completedTask, out filePath))
+                            {
+                                // Increment completed chunks for this file
+                                lock (_progressLock)
+                                {
+                                    fileChunksCompleted[filePath]++;
+                                    
+                                    // Check if all chunks for this file are complete
+                                    if (fileChunksCompleted[filePath] >= fileChunkCounts[filePath] && !completedFiles.Contains(filePath))
+                                    {
+                                        completedFiles.Add(filePath);
+                                        _completedFiles++;
+                                        Log($"✅ File {_completedFiles}/{_totalFilesToUpload} completed");
+                                    }
+                                }
+                                taskToFilePath.Remove(completedTask);
+                            }
+                            
+                            activeTasks.RemoveAt(taskIndex);
+                            var completedConn = activeConnections[taskIndex];
+                            activeConnections.RemoveAt(taskIndex);
+                            
+                            // Aggressively dispose connection immediately
+                            try
+                            {
+                                completedConn.Disconnect();
+                                completedConn.Dispose();
+                            }
+                            catch { }
+                        }
+                        else
+                        {
+                            Log($"⚠️ Task index mismatch - removing task anyway");
+                            // Task not found - remove it anyway
+                            activeTasks.Remove(completedTask);
+                        }
+                        
+                        // Update active task count for real-time UI updates
+                        _activeTaskCount = activeTasks.Count;
+                        
+                        // Update UI (will be updated in real-time by timer, but also update on completion)
+                        UpdateUploadStats(_completedFiles, activeTasks.Count);
+                    }
+                    else if (fileQueue.Count > 0)
+                    {
+                        Log($"⚠️ No active tasks but {fileQueue.Count} files remain - retrying...");
+                        // No active tasks but files remain - wait a bit and retry connections
+                        await Task.Delay(500);
+                    }
+                }
+                Log("🔄 Upload loop finished");
+                
+                // Stop real-time UI updates
+                _uiUpdateTimer.Stop();
+
+                // Cleanup any remaining connections (but NOT the main protocol connection)
+                Log($"🧹 Cleaning up {activeConnections.Count} remaining connections");
+                foreach (var conn in activeConnections.ToList())
+                {
+                    try
+                    {
+                        conn.Disconnect();
+                        conn.Dispose();
+                    }
+                    catch { }
+                }
+                activeConnections.Clear();
+                Log("✅ Cleanup complete");
+
+                if (!_uploadCancellation.Token.IsCancellationRequested)
+                {
+                    Log($"🎉 Upload completed! {_totalFilesToUpload} files, {FormatFileSize(_totalBytesUploaded)}");
+                    MessageBox.Show($"Upload completed!\n\n{_totalFilesToUpload} files uploaded\nTotal: {FormatFileSize(_totalBytesUploaded)}", "Success", MessageBoxButton.OK, MessageBoxImage.Information);
+                    _localFiles.Clear();
+                    
+                    // Reconnect main protocol after upload to ensure connection is active
+                    Log("🔄 Reconnecting to PS5 after upload...");
+                    try
+                    {
+                        // Disconnect first to clean up any stale connection
+                        _protocol.Disconnect();
+                        Log("🔌 Disconnected old connection");
+                        
+                        // Wait a bit for the server to clean up
+                        await Task.Delay(500);
+                        
+                        // Reconnect
+                        if (await _protocol.ConnectAsync(_ps5IpAddress))
+                        {
+                            Log("✅ Reconnected to PS5");
+                        }
+                        else
+                        {
+                            Log("❌ Reconnection failed");
+                            MessageBox.Show("Failed to reconnect to PS5. Please reconnect manually.", "Warning", MessageBoxButton.OK, MessageBoxImage.Warning);
+                            return;
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        Log($"❌ Reconnection error: {ex.Message}");
+                        MessageBox.Show($"Reconnection error: {ex.Message}", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
+                        return;
+                    }
+                    
+                    await LoadPS5DirectoryAsync(_currentPS5Path);
+                }
+                else
+                {
+                    Log("⚠️ Upload cancelled");
+                    MessageBox.Show("Upload cancelled by user", "Cancelled", MessageBoxButton.OK, MessageBoxImage.Warning);
+                    
+                    // Reconnect main protocol after cancellation to allow folder navigation
+                    Log("🔄 Reconnecting to PS5 after cancellation...");
+                    try
+                    {
+                        // Disconnect first to clean up
+                        _protocol.Disconnect();
+                        await Task.Delay(500);
+                        
+                        if (await _protocol.ConnectAsync(_ps5IpAddress))
+                        {
+                            Log("✅ Reconnected to PS5");
+                            await LoadPS5DirectoryAsync(_currentPS5Path);
+                        }
+                        else
+                        {
+                            Log("❌ Reconnection failed");
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        Log($"❌ Reconnection error: {ex.Message}");
+                    }
+                }
+            }
+            catch (OperationCanceledException)
+            {
+                Log("❌ Upload cancelled (OperationCanceledException)");
+                MessageBox.Show("Upload cancelled by user", "Cancelled", MessageBoxButton.OK, MessageBoxImage.Warning);
+                
+                // Reconnect main protocol after cancellation to allow folder navigation
+                Log("🔄 Reconnecting to PS5 after cancellation...");
+                try
+                {
+                    _protocol.Disconnect();
+                    await Task.Delay(500);
+                    
+                    if (await _protocol.ConnectAsync(_ps5IpAddress))
+                    {
+                        Log("✅ Reconnected to PS5");
+                        await LoadPS5DirectoryAsync(_currentPS5Path);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    Log($"❌ Reconnection error: {ex.Message}");
+                }
+            }
+            catch (Exception ex)
+            {
+                Log($"❌ Upload failed: {ex.Message}\n{ex.StackTrace}");
+                MessageBox.Show($"Upload failed: {ex.Message}", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
+            }
+            finally
+            {
+                Log("========== UPLOAD FINISHED ==========");
+                _uiUpdateTimer.Stop();
+                ProgressPanel.Visibility = Visibility.Collapsed;
+                UploadButton.IsEnabled = true;
+                CancelButton.IsEnabled = false;
+                _uploadCancellation?.Dispose();
+                _uploadCancellation = null;
+            }
+        }
+        
+        private async Task UploadFileChunkAsync(PS5Protocol connection, string localPath, string remotePath, long offset, long size, CancellationToken cancellationToken)
+        {
+            try
+            {
+                string fileName = Path.GetFileName(localPath);
+                Log($"⬆️ Uploading chunk {offset / (1024 * 1024 * 1024) + 1}: {fileName} @ {FormatFileSize(offset)}");
+                
+                bool success = await connection.UploadFileAsync(localPath, remotePath, null, cancellationToken, offset, size);
+                
+                if (success)
+                {
+                    Log($"✅ Chunk {offset / (1024 * 1024 * 1024) + 1} complete: {fileName}");
+                    lock (_progressLock)
+                    {
+                        _totalBytesUploaded += size;
+                    }
+                }
+                else
+                {
+                    Log($"❌ Chunk {offset / (1024 * 1024 * 1024) + 1} failed: {fileName}");
+                }
+            }
+            catch (Exception ex)
+            {
+                Log($"❌ Exception uploading chunk of {Path.GetFileName(localPath)}: {ex.Message}");
+            }
+        }
+        
+        private void CollectFilesFromDirectory(string localDir, string remoteDir, List<(string localPath, string remotePath)> files)
+        {
+            foreach (string file in Directory.GetFiles(localDir))
+            {
+                FileInfo info = new FileInfo(file);
+                files.Add((file, remoteDir + "/" + info.Name));
+            }
+            
+            foreach (string dir in Directory.GetDirectories(localDir))
+            {
+                DirectoryInfo info = new DirectoryInfo(dir);
+                CollectFilesFromDirectory(dir, remoteDir + "/" + info.Name, files);
+            }
+        }
+
+        private async Task UploadFileParallelAsync(PS5Protocol connection, string localPath, string remotePath, CancellationToken cancellationToken)
+        {
+            try
+            {
+                string fileName = Path.GetFileName(localPath);
+                FileInfo fileInfo = new FileInfo(localPath);
+                
+                Log($"⬆️ Uploading: {fileName}");
+                
+                // Progress reporting for per-file progress bar
+                var progress = new Progress<UploadProgress>(p =>
+                {
+                    double filePercent = p.TotalBytes > 0 ? (double)p.BytesSent / p.TotalBytes * 100 : 0;
+                    
+                    lock (_progressLock)
+                    {
+                        _currentFileName = fileName;
+                        _currentFileBytes = p.BytesSent;
+                        _currentFileTotalBytes = p.TotalBytes;
+                    }
+                    
+                    Dispatcher.Invoke(() =>
+                    {
+                        UploadProgressBar.Value = filePercent;
+                        UploadProgressText.Text = $"{FormatFileSize(p.BytesSent)} / {FormatFileSize(p.TotalBytes)} ({filePercent:F1}%)";
+                    });
+                    
+                    // Log progress periodically (every 40MB)
+                    if (p.BytesSent % (40 * 1024 * 1024) < 8 * 1024 * 1024 || p.BytesSent == p.TotalBytes)
+                    {
+                        Log($"📊 {fileName}: {FormatFileSize(p.BytesSent)}/{FormatFileSize(p.TotalBytes)} ({filePercent:F1}%) @ {FormatFileSize((long)p.SpeedBytesPerSecond)}/s");
+                    }
+                });
+
+                bool success = await connection.UploadFileAsync(localPath, remotePath, progress, cancellationToken);
+                
+                if (success)
+                {
+                    Log($"✅ Upload complete: {fileName}");
+                    lock (_progressLock)
+                    {
+                        _totalBytesUploaded += fileInfo.Length;
+                    }
+                }
+                else
+                {
+                    Log($"❌ Upload failed: {fileName}");
+                }
+            }
+            catch (Exception ex)
+            {
+                Log($"❌ Exception uploading {Path.GetFileName(localPath)}: {ex.Message}");
+            }
+        }
+
+        private void CancelButton_Click(object sender, RoutedEventArgs e)
+        {
+            _uploadCancellation?.Cancel();
+            CancelButton.IsEnabled = false;
+        }
+
+        private void GoButton_Click(object sender, RoutedEventArgs e)
+        {
+            string path = CurrentPathTextBox.Text.Trim();
+            if (!string.IsNullOrEmpty(path))
+            {
+                _ = LoadPS5DirectoryAsync(path);
+            }
+        }
+
+        private void PS5FilesListBox_MouseDoubleClick(object sender, MouseButtonEventArgs e)
+        {
+            if (PS5FilesListBox.SelectedItem is PS5FileItem item && item.IsDirectory)
+            {
+                _ = LoadPS5DirectoryAsync(item.FullPath);
+            }
+        }
+
+        private async void RenameMenuItem_Click(object sender, RoutedEventArgs e)
+        {
+            if (PS5FilesListBox.SelectedItem is PS5FileItem item)
+            {
+                var dialog = new Window
+                {
+                    Title = "Rename",
+                    Width = 400,
+                    Height = 150,
+                    WindowStartupLocation = WindowStartupLocation.CenterOwner,
+                    Owner = this,
+                    Background = new System.Windows.Media.SolidColorBrush(System.Windows.Media.Color.FromRgb(30, 30, 30))
+                };
+
+                var grid = new Grid { Margin = new Thickness(20) };
+                grid.RowDefinitions.Add(new RowDefinition { Height = GridLength.Auto });
+                grid.RowDefinitions.Add(new RowDefinition { Height = GridLength.Auto });
+                grid.RowDefinitions.Add(new RowDefinition { Height = GridLength.Auto });
+
+                var label = new TextBlock
+                {
+                    Text = "New name:",
+                    Foreground = System.Windows.Media.Brushes.White,
+                    Margin = new Thickness(0, 0, 0, 10)
+                };
+                Grid.SetRow(label, 0);
+
+                var textBox = new TextBox
+                {
+                    Text = item.Name,
+                    Margin = new Thickness(0, 0, 0, 15)
+                };
+                Grid.SetRow(textBox, 1);
+
+                var buttonPanel = new StackPanel
+                {
+                    Orientation = Orientation.Horizontal,
+                    HorizontalAlignment = HorizontalAlignment.Right
+                };
+                Grid.SetRow(buttonPanel, 2);
+
+                var okButton = new Button
+                {
+                    Content = "OK",
+                    Width = 80,
+                    Margin = new Thickness(0, 0, 10, 0)
+                };
+                okButton.Click += (s, args) => { dialog.DialogResult = true; dialog.Close(); };
+
+                var cancelButton = new Button
+                {
+                    Content = "Cancel",
+                    Width = 80
+                };
+                cancelButton.Click += (s, args) => { dialog.DialogResult = false; dialog.Close(); };
+
+                buttonPanel.Children.Add(okButton);
+                buttonPanel.Children.Add(cancelButton);
+
+                grid.Children.Add(label);
+                grid.Children.Add(textBox);
+                grid.Children.Add(buttonPanel);
+                dialog.Content = grid;
+
+                if (dialog.ShowDialog() == true && !string.IsNullOrWhiteSpace(textBox.Text))
+                {
+                    try
+                    {
+                        string newPath = Path.Combine(Path.GetDirectoryName(item.FullPath)?.Replace("\\", "/") ?? "", textBox.Text).Replace("\\", "/");
+                        await _protocol.RenameAsync(item.FullPath, newPath);
+                        Log($"✅ Renamed {item.Name} to {textBox.Text}");
+                        await LoadPS5DirectoryAsync(_currentPS5Path);
+                    }
+                    catch (Exception ex)
+                    {
+                        MessageBox.Show($"Rename failed: {ex.Message}", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
+                        Log($"❌ Rename failed: {ex.Message}");
+                    }
+                }
+            }
+        }
+
+        private async void CopyMenuItem_Click(object sender, RoutedEventArgs e)
+        {
+            if (PS5FilesListBox.SelectedItem is PS5FileItem item)
+            {
+                var dialog = new Window
+                {
+                    Title = "Copy To",
+                    Width = 500,
+                    Height = 150,
+                    WindowStartupLocation = WindowStartupLocation.CenterOwner,
+                    Owner = this,
+                    Background = new System.Windows.Media.SolidColorBrush(System.Windows.Media.Color.FromRgb(30, 30, 30))
+                };
+
+                var grid = new Grid { Margin = new Thickness(20) };
+                grid.RowDefinitions.Add(new RowDefinition { Height = GridLength.Auto });
+                grid.RowDefinitions.Add(new RowDefinition { Height = GridLength.Auto });
+                grid.RowDefinitions.Add(new RowDefinition { Height = GridLength.Auto });
+
+                var label = new TextBlock
+                {
+                    Text = "Destination path:",
+                    Foreground = System.Windows.Media.Brushes.White,
+                    Margin = new Thickness(0, 0, 0, 10)
+                };
+                Grid.SetRow(label, 0);
+
+                var pathPanel = new StackPanel
+                {
+                    Orientation = Orientation.Horizontal,
+                    Margin = new Thickness(0, 0, 0, 15)
+                };
+                Grid.SetRow(pathPanel, 1);
+
+                var textBox = new TextBox
+                {
+                    Text = _currentPS5Path + "/" + item.Name,
+                    Width = 350
+                };
+
+                var browseButton = new Button
+                {
+                    Content = "Browse...",
+                    Width = 80,
+                    Margin = new Thickness(10, 0, 0, 0)
+                };
+                browseButton.Click += async (s, args) =>
+                {
+                    var pathDialog = new Window
+                    {
+                        Title = "Select PS5 Folder",
+                        Width = 500,
+                        Height = 450,
+                        WindowStartupLocation = WindowStartupLocation.CenterOwner,
+                        Owner = dialog,
+                        Background = new System.Windows.Media.SolidColorBrush(System.Windows.Media.Color.FromRgb(30, 30, 30))
+                    };
+
+                    var pathGrid = new Grid { Margin = new Thickness(10) };
+                    pathGrid.RowDefinitions.Add(new RowDefinition { Height = GridLength.Auto });
+                    pathGrid.RowDefinitions.Add(new RowDefinition { Height = GridLength.Auto });
+                    pathGrid.RowDefinitions.Add(new RowDefinition { Height = new GridLength(1, GridUnitType.Star) });
+                    pathGrid.RowDefinitions.Add(new RowDefinition { Height = GridLength.Auto });
+
+                    var pathLabel = new TextBlock
+                    {
+                        Text = "Current path:",
+                        Foreground = System.Windows.Media.Brushes.White,
+                        Margin = new Thickness(0, 0, 0, 5)
+                    };
+                    Grid.SetRow(pathLabel, 0);
+
+                    var pathTextBox = new TextBox
+                    {
+                        Text = _currentPS5Path,
+                        IsReadOnly = true,
+                        Margin = new Thickness(0, 0, 0, 10)
+                    };
+                    Grid.SetRow(pathTextBox, 1);
+
+                    var listBox = new ListBox { Margin = new Thickness(0, 0, 0, 10) };
+                    Grid.SetRow(listBox, 2);
+
+                    var buttonPanel = new StackPanel
+                    {
+                        Orientation = Orientation.Horizontal,
+                        HorizontalAlignment = HorizontalAlignment.Right
+                    };
+                    Grid.SetRow(buttonPanel, 3);
+
+                    var selectCurrentButton = new Button { Content = "Select Current", Width = 100, Margin = new Thickness(0, 0, 10, 0) };
+                    var selectButton = new Button { Content = "Select Folder", Width = 100, Margin = new Thickness(0, 0, 10, 0) };
+                    var cancelButton = new Button { Content = "Cancel", Width = 80 };
+
+                    buttonPanel.Children.Add(selectCurrentButton);
+                    buttonPanel.Children.Add(selectButton);
+                    buttonPanel.Children.Add(cancelButton);
+
+                    pathGrid.Children.Add(pathLabel);
+                    pathGrid.Children.Add(pathTextBox);
+                    pathGrid.Children.Add(listBox);
+                    pathGrid.Children.Add(buttonPanel);
+                    pathDialog.Content = pathGrid;
+
+                    string currentBrowsePath = _currentPS5Path;
+
+                    async Task LoadFolders(string path)
+                    {
+                        listBox.Items.Clear();
+                        pathTextBox.Text = path;
+                        currentBrowsePath = path;
+
+                        try
+                        {
+                            // Add parent directory option if not at root
+                            if (path != "/" && path.Contains("/"))
+                            {
+                                listBox.Items.Add("..");
+                            }
+
+                            var dirs = await _protocol.ListDirAsync(path);
+                            foreach (var dir in dirs.Where(d => d.IsDirectory))
+                            {
+                                listBox.Items.Add(dir.Name);
+                            }
+                        }
+                        catch
+                        {
+                            MessageBox.Show("Failed to load folders from: " + path, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
+                        }
+                    }
+
+                    listBox.MouseDoubleClick += async (ss, ee) =>
+                    {
+                        if (listBox.SelectedItem != null)
+                        {
+                            string selected = listBox.SelectedItem.ToString();
+                            if (selected == "..")
+                            {
+                                // Go to parent directory
+                                int lastSlash = currentBrowsePath.TrimEnd('/').LastIndexOf('/');
+                                if (lastSlash > 0)
+                                {
+                                    await LoadFolders(currentBrowsePath.Substring(0, lastSlash));
+                                }
+                                else if (lastSlash == 0)
+                                {
+                                    await LoadFolders("/");
+                                }
+                            }
+                            else
+                            {
+                                // Navigate into folder
+                                string newPath = currentBrowsePath.TrimEnd('/') + "/" + selected;
+                                await LoadFolders(newPath);
+                            }
+                        }
+                    };
+
+                    selectCurrentButton.Click += (ss, aa) =>
+                    {
+                        textBox.Text = currentBrowsePath.TrimEnd('/') + "/" + item.Name;
+                        pathDialog.Close();
+                    };
+
+                    selectButton.Click += (ss, aa) =>
+                    {
+                        if (listBox.SelectedItem != null && listBox.SelectedItem.ToString() != "..")
+                        {
+                            string selected = listBox.SelectedItem.ToString();
+                            textBox.Text = currentBrowsePath.TrimEnd('/') + "/" + selected + "/" + item.Name;
+                            pathDialog.Close();
+                        }
+                    };
+
+                    cancelButton.Click += (ss, aa) => { pathDialog.Close(); };
+
+                    // Load initial folders
+                    await LoadFolders(_currentPS5Path);
+
+                    pathDialog.ShowDialog();
+                };
+
+                pathPanel.Children.Add(textBox);
+                pathPanel.Children.Add(browseButton);
+
+                var buttonPanel = new StackPanel
+                {
+                    Orientation = Orientation.Horizontal,
+                    HorizontalAlignment = HorizontalAlignment.Right
+                };
+                Grid.SetRow(buttonPanel, 2);
+
+                var okButton = new Button
+                {
+                    Content = "Copy",
+                    Width = 80,
+                    Margin = new Thickness(0, 0, 10, 0)
+                };
+                okButton.Click += (s, args) => { dialog.DialogResult = true; dialog.Close(); };
+
+                var cancelButton = new Button
+                {
+                    Content = "Cancel",
+                    Width = 80
+                };
+                cancelButton.Click += (s, args) => { dialog.DialogResult = false; dialog.Close(); };
+
+                buttonPanel.Children.Add(okButton);
+                buttonPanel.Children.Add(cancelButton);
+
+                grid.Children.Add(label);
+                grid.Children.Add(pathPanel);
+                grid.Children.Add(buttonPanel);
+                dialog.Content = grid;
+
+                if (dialog.ShowDialog() == true && !string.IsNullOrWhiteSpace(textBox.Text))
+                {
+                    try
+                    {
+                        await _protocol.CopyFileAsync(item.FullPath, textBox.Text);
+                        Log($"✅ Copied {item.Name} to {textBox.Text}");
+                        await LoadPS5DirectoryAsync(_currentPS5Path);
+                    }
+                    catch (Exception ex)
+                    {
+                        MessageBox.Show($"Copy failed: {ex.Message}", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
+                        Log($"❌ Copy failed: {ex.Message}");
+                    }
+                }
+            }
+        }
+
+        private async void MoveMenuItem_Click(object sender, RoutedEventArgs e)
+        {
+            if (PS5FilesListBox.SelectedItem is PS5FileItem item)
+            {
+                var dialog = new Window
+                {
+                    Title = "Move To",
+                    Width = 500,
+                    Height = 150,
+                    WindowStartupLocation = WindowStartupLocation.CenterOwner,
+                    Owner = this,
+                    Background = new System.Windows.Media.SolidColorBrush(System.Windows.Media.Color.FromRgb(30, 30, 30))
+                };
+
+                var grid = new Grid { Margin = new Thickness(20) };
+                grid.RowDefinitions.Add(new RowDefinition { Height = GridLength.Auto });
+                grid.RowDefinitions.Add(new RowDefinition { Height = GridLength.Auto });
+                grid.RowDefinitions.Add(new RowDefinition { Height = GridLength.Auto });
+
+                var label = new TextBlock
+                {
+                    Text = "Destination path:",
+                    Foreground = System.Windows.Media.Brushes.White,
+                    Margin = new Thickness(0, 0, 0, 10)
+                };
+                Grid.SetRow(label, 0);
+
+                var pathPanel = new StackPanel
+                {
+                    Orientation = Orientation.Horizontal,
+                    Margin = new Thickness(0, 0, 0, 15)
+                };
+                Grid.SetRow(pathPanel, 1);
+
+                var textBox = new TextBox
+                {
+                    Text = _currentPS5Path + "/" + item.Name,
+                    Width = 350
+                };
+
+                var browseButton = new Button
+                {
+                    Content = "Browse...",
+                    Width = 80,
+                    Margin = new Thickness(10, 0, 0, 0)
+                };
+                browseButton.Click += async (s, args) =>
+                {
+                    var pathDialog = new Window
+                    {
+                        Title = "Select PS5 Folder",
+                        Width = 500,
+                        Height = 450,
+                        WindowStartupLocation = WindowStartupLocation.CenterOwner,
+                        Owner = dialog,
+                        Background = new System.Windows.Media.SolidColorBrush(System.Windows.Media.Color.FromRgb(30, 30, 30))
+                    };
+
+                    var pathGrid = new Grid { Margin = new Thickness(10) };
+                    pathGrid.RowDefinitions.Add(new RowDefinition { Height = GridLength.Auto });
+                    pathGrid.RowDefinitions.Add(new RowDefinition { Height = GridLength.Auto });
+                    pathGrid.RowDefinitions.Add(new RowDefinition { Height = new GridLength(1, GridUnitType.Star) });
+                    pathGrid.RowDefinitions.Add(new RowDefinition { Height = GridLength.Auto });
+
+                    var pathLabel = new TextBlock
+                    {
+                        Text = "Current path:",
+                        Foreground = System.Windows.Media.Brushes.White,
+                        Margin = new Thickness(0, 0, 0, 5)
+                    };
+                    Grid.SetRow(pathLabel, 0);
+
+                    var pathTextBox = new TextBox
+                    {
+                        Text = _currentPS5Path,
+                        IsReadOnly = true,
+                        Margin = new Thickness(0, 0, 0, 10)
+                    };
+                    Grid.SetRow(pathTextBox, 1);
+
+                    var listBox = new ListBox { Margin = new Thickness(0, 0, 0, 10) };
+                    Grid.SetRow(listBox, 2);
+
+                    var buttonPanel = new StackPanel
+                    {
+                        Orientation = Orientation.Horizontal,
+                        HorizontalAlignment = HorizontalAlignment.Right
+                    };
+                    Grid.SetRow(buttonPanel, 3);
+
+                    var selectCurrentButton = new Button { Content = "Select Current", Width = 100, Margin = new Thickness(0, 0, 10, 0) };
+                    var selectButton = new Button { Content = "Select Folder", Width = 100, Margin = new Thickness(0, 0, 10, 0) };
+                    var cancelButton = new Button { Content = "Cancel", Width = 80 };
+
+                    buttonPanel.Children.Add(selectCurrentButton);
+                    buttonPanel.Children.Add(selectButton);
+                    buttonPanel.Children.Add(cancelButton);
+
+                    pathGrid.Children.Add(pathLabel);
+                    pathGrid.Children.Add(pathTextBox);
+                    pathGrid.Children.Add(listBox);
+                    pathGrid.Children.Add(buttonPanel);
+                    pathDialog.Content = pathGrid;
+
+                    string currentBrowsePath = _currentPS5Path;
+
+                    async Task LoadFolders(string path)
+                    {
+                        listBox.Items.Clear();
+                        pathTextBox.Text = path;
+                        currentBrowsePath = path;
+
+                        try
+                        {
+                            // Add parent directory option if not at root
+                            if (path != "/" && path.Contains("/"))
+                            {
+                                listBox.Items.Add("..");
+                            }
+
+                            var dirs = await _protocol.ListDirAsync(path);
+                            foreach (var dir in dirs.Where(d => d.IsDirectory))
+                            {
+                                listBox.Items.Add(dir.Name);
+                            }
+                        }
+                        catch
+                        {
+                            MessageBox.Show("Failed to load folders from: " + path, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
+                        }
+                    }
+
+                    listBox.MouseDoubleClick += async (ss, ee) =>
+                    {
+                        if (listBox.SelectedItem != null)
+                        {
+                            string selected = listBox.SelectedItem.ToString();
+                            if (selected == "..")
+                            {
+                                // Go to parent directory
+                                int lastSlash = currentBrowsePath.TrimEnd('/').LastIndexOf('/');
+                                if (lastSlash > 0)
+                                {
+                                    await LoadFolders(currentBrowsePath.Substring(0, lastSlash));
+                                }
+                                else if (lastSlash == 0)
+                                {
+                                    await LoadFolders("/");
+                                }
+                            }
+                            else
+                            {
+                                // Navigate into folder
+                                string newPath = currentBrowsePath.TrimEnd('/') + "/" + selected;
+                                await LoadFolders(newPath);
+                            }
+                        }
+                    };
+
+                    selectCurrentButton.Click += (ss, aa) =>
+                    {
+                        textBox.Text = currentBrowsePath.TrimEnd('/') + "/" + item.Name;
+                        pathDialog.Close();
+                    };
+
+                    selectButton.Click += (ss, aa) =>
+                    {
+                        if (listBox.SelectedItem != null && listBox.SelectedItem.ToString() != "..")
+                        {
+                            string selected = listBox.SelectedItem.ToString();
+                            textBox.Text = currentBrowsePath.TrimEnd('/') + "/" + selected + "/" + item.Name;
+                            pathDialog.Close();
+                        }
+                    };
+
+                    cancelButton.Click += (ss, aa) => { pathDialog.Close(); };
+
+                    // Load initial folders
+                    await LoadFolders(_currentPS5Path);
+
+                    pathDialog.ShowDialog();
+                };
+
+                pathPanel.Children.Add(textBox);
+                pathPanel.Children.Add(browseButton);
+
+                var buttonPanel = new StackPanel
+                {
+                    Orientation = Orientation.Horizontal,
+                    HorizontalAlignment = HorizontalAlignment.Right
+                };
+                Grid.SetRow(buttonPanel, 2);
+
+                var okButton = new Button
+                {
+                    Content = "Move",
+                    Width = 80,
+                    Margin = new Thickness(0, 0, 10, 0)
+                };
+                okButton.Click += (s, args) => { dialog.DialogResult = true; dialog.Close(); };
+
+                var cancelButton = new Button
+                {
+                    Content = "Cancel",
+                    Width = 80
+                };
+                cancelButton.Click += (s, args) => { dialog.DialogResult = false; dialog.Close(); };
+
+                buttonPanel.Children.Add(okButton);
+                buttonPanel.Children.Add(cancelButton);
+
+                grid.Children.Add(label);
+                grid.Children.Add(pathPanel);
+                grid.Children.Add(buttonPanel);
+                dialog.Content = grid;
+
+                if (dialog.ShowDialog() == true && !string.IsNullOrWhiteSpace(textBox.Text))
+                {
+                    try
+                    {
+                        await _protocol.RenameAsync(item.FullPath, textBox.Text);
+                        Log($"✅ Moved {item.Name} to {textBox.Text}");
+                        await LoadPS5DirectoryAsync(_currentPS5Path);
+                    }
+                    catch (Exception ex)
+                    {
+                        MessageBox.Show($"Move failed: {ex.Message}", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
+                        Log($"❌ Move failed: {ex.Message}");
+                    }
+                }
+            }
+        }
+
+        private async void DeleteMenuItem_Click(object sender, RoutedEventArgs e)
+        {
+            if (PS5FilesListBox.SelectedItem is PS5FileItem item)
+            {
+                var result = MessageBox.Show($"Delete {item.Name}?", "Confirm", MessageBoxButton.YesNo, MessageBoxImage.Question);
+                if (result == MessageBoxResult.Yes)
+                {
+                    try
+                    {
+                        if (item.IsDirectory)
+                        {
+                            await _protocol.DeleteDirAsync(item.FullPath);
+                        }
+                        else
+                        {
+                            await _protocol.DeleteFileAsync(item.FullPath);
+                        }
+                        await LoadPS5DirectoryAsync(_currentPS5Path);
+                    }
+                    catch (Exception ex)
+                    {
+                        MessageBox.Show($"Delete failed: {ex.Message}", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
+                    }
+                }
+            }
+        }
+
+        private string FormatFileSize(long bytes)
+        {
+            string[] sizes = { "B", "KB", "MB", "GB", "TB" };
+            double len = bytes;
+            int order = 0;
+            while (len >= 1024 && order < sizes.Length - 1)
+            {
+                order++;
+                len = len / 1024;
+            }
+            return $"{len:0.##} {sizes[order]}";
+        }
+    }
+
+    public class LocalFileItem
+    {
+        public string Name { get; set; } = "";
+        public string FullPath { get; set; } = "";
+        public string Icon { get; set; } = "";
+        public bool IsDirectory { get; set; }
+        public long Size { get; set; }
+        public string SizeFormatted => FormatSize(Size);
+
+        private string FormatSize(long bytes)
+        {
+            if (IsDirectory) return "";
+            string[] sizes = { "B", "KB", "MB", "GB", "TB" };
+            double len = bytes;
+            int order = 0;
+            while (len >= 1024 && order < sizes.Length - 1)
+            {
+                order++;
+                len = len / 1024;
+            }
+            return $"{len:0.##} {sizes[order]}";
+        }
+    }
+
+    public class PS5FileItem
+    {
+        public string Name { get; set; } = "";
+        public string FullPath { get; set; } = "";
+        public string Icon { get; set; } = "";
+        public bool IsDirectory { get; set; }
+        public long Size { get; set; }
+        public string SizeFormatted => FormatSize(Size);
+
+        private string FormatSize(long bytes)
+        {
+            if (IsDirectory) return "";
+            string[] sizes = { "B", "KB", "MB", "GB", "TB" };
+            double len = bytes;
+            int order = 0;
+            while (len >= 1024 && order < sizes.Length - 1)
+            {
+                order++;
+                len = len / 1024;
+            }
+            return $"{len:0.##} {sizes[order]}";
+        }
+    }
+}
diff --git a/client/PS5Upload.csproj b/client/PS5Upload.csproj
new file mode 100644
index 0000000..e36fdf8
--- /dev/null
+++ b/client/PS5Upload.csproj
@@ -0,0 +1,29 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>WinExe</OutputType>
+    <TargetFramework>net6.0-windows</TargetFramework>
+    <UseWPF>true</UseWPF>
+    <UseWindowsForms>true</UseWindowsForms>
+    <AssemblyName>PS5Upload</AssemblyName>
+    <RootNamespace>PS5Upload</RootNamespace>
+    <Version>1.0.0</Version>
+    <Authors>Manos</Authors>
+    <Description>High-Speed File Upload Tool for PS5</Description>
+    <Copyright>Copyright © 2026 Manos</Copyright>
+    <Nullable>enable</Nullable>
+    <PublishSingleFile>true</PublishSingleFile>
+    <SelfContained>true</SelfContained>
+    <RuntimeIdentifier>win-x64</RuntimeIdentifier>
+    <PublishReadyToRun>true</PublishReadyToRun>
+    <ApplicationIcon>ps5_logo_fixed.ico</ApplicationIcon>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Resource Include="ps5_logo.png" />
+    <None Include="ps5_logo.ico">
+      <Link>ps5_logo.ico</Link>
+    </None>
+  </ItemGroup>
+
+</Project>
diff --git a/client/Protocol.cs b/client/Protocol.cs
new file mode 100644
index 0000000..2ea7f1c
--- /dev/null
+++ b/client/Protocol.cs
@@ -0,0 +1,453 @@
+using System;
+using System.IO;
+using System.Net.Sockets;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace PS5Upload
+{
+    // Protocol commands
+    public enum Command : byte
+    {
+        Ping = 0x01,
+        ListStorage = 0x02,
+        ListDir = 0x03,
+        CreateDir = 0x04,
+        DeleteFile = 0x05,
+        DeleteDir = 0x06,
+        Rename = 0x07,
+        CopyFile = 0x08,
+        MoveFile = 0x09,
+        StartUpload = 0x10,
+        UploadChunk = 0x11,
+        EndUpload = 0x12,
+        Shutdown = 0xFF
+    }
+
+    // Protocol responses
+    public enum Response : byte
+    {
+        Ok = 0x01,
+        Error = 0x02,
+        Data = 0x03,
+        Ready = 0x04,
+        Progress = 0x05
+    }
+
+    public class PS5Protocol : IDisposable
+    {
+        private TcpClient? _client;
+        private NetworkStream? _stream;
+        private const int BufferSize = 32 * 1024 * 1024; // 32MB for maximum throughput
+
+        public bool IsConnected => _client?.Connected ?? false;
+
+        public async Task<bool> ConnectAsync(string ipAddress, int port = 9113)
+        {
+            try
+            {
+                _client = new TcpClient();
+                _client.ReceiveBufferSize = 64 * 1024 * 1024; // 64MB for maximum TCP throughput
+                _client.SendBufferSize = 64 * 1024 * 1024; // 64MB for maximum TCP throughput
+                _client.NoDelay = true;
+                _client.LingerState = new System.Net.Sockets.LingerOption(false, 0);
+
+                await _client.ConnectAsync(ipAddress, port);
+                _stream = _client.GetStream();
+                return true;
+            }
+            catch
+            {
+                return false;
+            }
+        }
+
+        public void Disconnect()
+        {
+            _stream?.Close();
+            _client?.Close();
+            _stream = null;
+            _client = null;
+        }
+
+        private async Task SendCommandAsync(Command cmd, byte[]? data = null)
+        {
+            if (_stream == null) throw new InvalidOperationException("Not connected");
+
+            byte[] header = new byte[5];
+            header[0] = (byte)cmd;
+            
+            uint dataLen = data != null ? (uint)data.Length : 0;
+            BitConverter.GetBytes(dataLen).CopyTo(header, 1);
+
+            await _stream.WriteAsync(header, 0, 5);
+            if (data != null && data.Length > 0)
+            {
+                await _stream.WriteAsync(data, 0, data.Length);
+            }
+        }
+
+        private async Task<(Response response, byte[] data)> ReceiveResponseAsync()
+        {
+            if (_stream == null) throw new InvalidOperationException("Not connected");
+
+            byte[] header = new byte[5];
+            await ReadExactAsync(header, 5);
+
+            Response response = (Response)header[0];
+            uint dataLen = BitConverter.ToUInt32(header, 1);
+
+            byte[] data = new byte[dataLen];
+            if (dataLen > 0)
+            {
+                await ReadExactAsync(data, (int)dataLen);
+            }
+
+            return (response, data);
+        }
+
+        private async Task ReadExactAsync(byte[] buffer, int count, int timeoutMs = 30000)
+        {
+            if (_stream == null) throw new InvalidOperationException("Not connected");
+
+            int offset = 0;
+            using var cts = new CancellationTokenSource(timeoutMs);
+            
+            try
+            {
+                while (offset < count)
+                {
+                    int read = await _stream.ReadAsync(buffer, offset, count - offset, cts.Token);
+                    if (read == 0) throw new IOException("Connection closed");
+                    offset += read;
+                }
+            }
+            catch (OperationCanceledException)
+            {
+                throw new TimeoutException("Read timeout");
+            }
+        }
+
+        public async Task<bool> PingAsync()
+        {
+            await SendCommandAsync(Command.Ping);
+            var (response, _) = await ReceiveResponseAsync();
+            return response == Response.Ok;
+        }
+
+        public async Task<StorageInfo[]> ListStorageAsync()
+        {
+            await SendCommandAsync(Command.ListStorage);
+            var (response, data) = await ReceiveResponseAsync();
+
+            if (response != Response.Data) return Array.Empty<StorageInfo>();
+
+            using var ms = new MemoryStream(data);
+            using var br = new BinaryReader(ms);
+
+            int count = br.ReadInt32();
+            var result = new StorageInfo[count];
+
+            for (int i = 0; i < count; i++)
+            {
+                ushort pathLen = br.ReadUInt16();
+                string path = Encoding.UTF8.GetString(br.ReadBytes(pathLen));
+                long total = br.ReadInt64();
+                long free = br.ReadInt64();
+
+                result[i] = new StorageInfo { Path = path, TotalBytes = total, FreeBytes = free };
+            }
+
+            return result;
+        }
+
+        public async Task<FileEntry[]> ListDirAsync(string path)
+        {
+            byte[] pathBytes = Encoding.UTF8.GetBytes(path + "\0");
+            await SendCommandAsync(Command.ListDir, pathBytes);
+            var (response, data) = await ReceiveResponseAsync();
+
+            if (response != Response.Data) return Array.Empty<FileEntry>();
+
+            using var ms = new MemoryStream(data);
+            using var br = new BinaryReader(ms);
+
+            int count = br.ReadInt32();
+            
+            // Handle empty directory
+            if (count <= 0) return Array.Empty<FileEntry>();
+            
+            var result = new FileEntry[count];
+
+            for (int i = 0; i < count; i++)
+            {
+                byte type = br.ReadByte();
+                ushort nameLen = br.ReadUInt16();
+                string name = Encoding.UTF8.GetString(br.ReadBytes(nameLen));
+                long size = br.ReadInt64();
+                long timestamp = br.ReadInt64();
+
+                // Clamp timestamp to valid DateTimeOffset range
+                DateTime dt;
+                try
+                {
+                    if (timestamp < -62135596800 || timestamp > 253402300799)
+                    {
+                        dt = DateTime.Now; // Use current time for invalid timestamps
+                    }
+                    else
+                    {
+                        dt = DateTimeOffset.FromUnixTimeSeconds(timestamp).DateTime;
+                    }
+                }
+                catch
+                {
+                    dt = DateTime.Now;
+                }
+
+                result[i] = new FileEntry
+                {
+                    Name = name,
+                    IsDirectory = type == 1,
+                    Size = size,
+                    Timestamp = dt
+                };
+            }
+
+            return result;
+        }
+
+        public async Task<bool> CreateDirAsync(string path)
+        {
+            byte[] pathBytes = Encoding.UTF8.GetBytes(path + "\0");
+            await SendCommandAsync(Command.CreateDir, pathBytes);
+            var (response, _) = await ReceiveResponseAsync();
+            return response == Response.Ok;
+        }
+
+        public async Task<bool> DeleteFileAsync(string path)
+        {
+            byte[] pathBytes = Encoding.UTF8.GetBytes(path + "\0");
+            await SendCommandAsync(Command.DeleteFile, pathBytes);
+            var (response, _) = await ReceiveResponseAsync();
+            return response == Response.Ok;
+        }
+
+        public async Task<bool> DeleteDirAsync(string path)
+        {
+            byte[] pathBytes = Encoding.UTF8.GetBytes(path + "\0");
+            await SendCommandAsync(Command.DeleteDir, pathBytes);
+            var (response, _) = await ReceiveResponseAsync();
+            return response == Response.Ok;
+        }
+
+        public async Task<bool> RenameAsync(string oldPath, string newPath)
+        {
+            byte[] oldBytes = Encoding.UTF8.GetBytes(oldPath + "\0");
+            byte[] newBytes = Encoding.UTF8.GetBytes(newPath + "\0");
+            byte[] data = new byte[oldBytes.Length + newBytes.Length];
+            Array.Copy(oldBytes, 0, data, 0, oldBytes.Length);
+            Array.Copy(newBytes, 0, data, oldBytes.Length, newBytes.Length);
+            
+            await SendCommandAsync(Command.Rename, data);
+            var (response, _) = await ReceiveResponseAsync();
+            return response == Response.Ok;
+        }
+
+        public async Task<bool> CopyFileAsync(string srcPath, string dstPath)
+        {
+            byte[] srcBytes = Encoding.UTF8.GetBytes(srcPath + "\0");
+            byte[] dstBytes = Encoding.UTF8.GetBytes(dstPath + "\0");
+            byte[] data = new byte[srcBytes.Length + dstBytes.Length];
+            Array.Copy(srcBytes, 0, data, 0, srcBytes.Length);
+            Array.Copy(dstBytes, 0, data, srcBytes.Length, dstBytes.Length);
+            
+            await SendCommandAsync(Command.CopyFile, data);
+            var (response, _) = await ReceiveResponseAsync();
+            return response == Response.Ok;
+        }
+
+        public async Task<bool> MoveFileAsync(string srcPath, string dstPath)
+        {
+            byte[] srcBytes = Encoding.UTF8.GetBytes(srcPath + "\0");
+            byte[] dstBytes = Encoding.UTF8.GetBytes(dstPath + "\0");
+            byte[] data = new byte[srcBytes.Length + dstBytes.Length];
+            Array.Copy(srcBytes, 0, data, 0, srcBytes.Length);
+            Array.Copy(dstBytes, 0, data, srcBytes.Length, dstBytes.Length);
+            
+            await SendCommandAsync(Command.MoveFile, data);
+            var (response, _) = await ReceiveResponseAsync();
+            return response == Response.Ok;
+        }
+
+        public async Task<bool> UploadFileAsync(string localPath, string remotePath, IProgress<UploadProgress>? progress = null, CancellationToken cancellationToken = default, long chunkOffset = 0, long chunkSize = 0)
+        {
+            FileInfo fileInfo = new FileInfo(localPath);
+            if (!fileInfo.Exists) return false;
+
+            // Determine actual upload size
+            long uploadSize = chunkSize > 0 ? chunkSize : fileInfo.Length;
+
+            // Send START_UPLOAD with optional chunk offset
+            byte[] pathBytes = Encoding.UTF8.GetBytes(remotePath);
+            byte[] startData = new byte[pathBytes.Length + 1 + 8 + 8]; // path + null + size + offset
+            Array.Copy(pathBytes, 0, startData, 0, pathBytes.Length);
+            BitConverter.GetBytes(fileInfo.Length).CopyTo(startData, pathBytes.Length + 1);
+            BitConverter.GetBytes(chunkOffset).CopyTo(startData, pathBytes.Length + 9);
+
+            await SendCommandAsync(Command.StartUpload, startData);
+            var (response, _) = await ReceiveResponseAsync();
+
+            if (response != Response.Ready) return false;
+
+            // Upload chunks - simple async approach
+            long totalSent = 0;
+            var startTime = DateTime.Now;
+            double avgSpeed = 0;
+
+            byte[] sendBuffer = new byte[5 + BufferSize];
+            sendBuffer[0] = (byte)Command.UploadChunk;
+            
+            using (FileStream fs = new FileStream(localPath, FileMode.Open, FileAccess.Read, FileShare.Read, BufferSize, FileOptions.SequentialScan))
+            {
+                // Seek to chunk offset if specified
+                if (chunkOffset > 0)
+                {
+                    fs.Seek(chunkOffset, SeekOrigin.Begin);
+                }
+                
+                int chunksSent = 0;
+                int bytesRead;
+                long bytesRemaining = uploadSize;
+                
+                while (bytesRemaining > 0 && (bytesRead = await fs.ReadAsync(sendBuffer, 5, (int)Math.Min(BufferSize, bytesRemaining), cancellationToken)) > 0)
+                {
+                    if (cancellationToken.IsCancellationRequested) return false;
+                    
+                    BitConverter.GetBytes((uint)bytesRead).CopyTo(sendBuffer, 1);
+                    
+                    if (_stream == null) return false;
+                    
+                    await _stream.WriteAsync(sendBuffer, 0, 5 + bytesRead, cancellationToken);
+                    
+                    totalSent += bytesRead;
+                    bytesRemaining -= bytesRead;
+                    chunksSent++;
+                    
+                    if (chunksSent % 5 == 0 || bytesRemaining == 0)
+                    {
+                        var elapsed = DateTime.Now - startTime;
+                        double currentSpeed = elapsed.TotalSeconds > 0 ? totalSent / elapsed.TotalSeconds : 0;
+                        avgSpeed = currentSpeed;
+                        
+                        TimeSpan eta = currentSpeed > 0 
+                            ? TimeSpan.FromSeconds(bytesRemaining / currentSpeed) 
+                            : TimeSpan.Zero;
+
+                        progress?.Report(new UploadProgress
+                        {
+                            BytesSent = chunkOffset + totalSent,
+                            TotalBytes = fileInfo.Length,
+                            SpeedBytesPerSecond = currentSpeed,
+                            AverageSpeedBytesPerSecond = avgSpeed,
+                            ElapsedTime = elapsed,
+                            EstimatedTimeRemaining = eta,
+                            CurrentFileName = fileInfo.Name
+                        });
+                    }
+                }
+            }
+
+            // Send END_UPLOAD - fire-and-forget for maximum speed
+            // Don't wait for response to avoid PS5 payload bottleneck
+            try
+            {
+                await SendCommandAsync(Command.EndUpload);
+                // Immediately return success without waiting for response
+                // This eliminates the PS5 response handling bottleneck
+                return true;
+            }
+            catch
+            {
+                return true; // Assume success if connection issues
+            }
+        }
+
+        public void Dispose()
+        {
+            Disconnect();
+        }
+    }
+
+    public class StorageInfo
+    {
+        public string Path { get; set; } = "";
+        public long TotalBytes { get; set; }
+        public long FreeBytes { get; set; }
+    }
+
+    public class FileEntry
+    {
+        public string Name { get; set; } = "";
+        public bool IsDirectory { get; set; }
+        public long Size { get; set; }
+        public DateTime Timestamp { get; set; }
+    }
+
+    public class UploadProgress
+    {
+        public long BytesSent { get; set; }
+        public long TotalBytes { get; set; }
+        public double SpeedBytesPerSecond { get; set; }
+        public double AverageSpeedBytesPerSecond { get; set; }
+        public TimeSpan ElapsedTime { get; set; }
+        public TimeSpan EstimatedTimeRemaining { get; set; }
+        public string CurrentFileName { get; set; } = "";
+        
+        // For folder progress
+        public int CurrentFileIndex { get; set; }
+        public int TotalFiles { get; set; }
+        public long TotalFolderBytes { get; set; }
+        public long TotalFolderBytesSent { get; set; }
+    }
+    
+    // High-speed parallel uploader using multiple connections
+    public class ParallelUploader : IDisposable
+    {
+        private readonly string _ipAddress;
+        private readonly int _port;
+        private readonly int _connectionCount;
+        private const int ChunkSize = 4 * 1024 * 1024; // 4MB chunks per connection
+        
+        public ParallelUploader(string ipAddress, int port = 9113, int connectionCount = 4)
+        {
+            _ipAddress = ipAddress;
+            _port = port;
+            _connectionCount = connectionCount;
+        }
+        
+        public async Task<bool> UploadFileAsync(string localPath, string remotePath, IProgress<UploadProgress>? progress = null, CancellationToken cancellationToken = default)
+        {
+            FileInfo fileInfo = new FileInfo(localPath);
+            if (!fileInfo.Exists) return false;
+            
+            // For small files, use single connection
+            if (fileInfo.Length < ChunkSize * 2)
+            {
+                using var protocol = new PS5Protocol();
+                if (!await protocol.ConnectAsync(_ipAddress, _port)) return false;
+                return await protocol.UploadFileAsync(localPath, remotePath, progress, cancellationToken);
+            }
+            
+            // For large files, use parallel connections
+            // This requires server support for chunked/parallel uploads
+            // For now, fall back to single connection
+            using var proto = new PS5Protocol();
+            if (!await proto.ConnectAsync(_ipAddress, _port)) return false;
+            return await proto.UploadFileAsync(localPath, remotePath, progress, cancellationToken);
+        }
+        
+        public void Dispose() { }
+    }
+}
diff --git a/client/build.bat b/client/build.bat
new file mode 100644
index 0000000..9dd25c0
--- /dev/null
+++ b/client/build.bat
@@ -0,0 +1,29 @@
+@echo off
+echo ================================================
+echo PS5 Upload Client - Building
+echo By Manos
+echo ================================================
+echo.
+
+echo [+] Building Windows GUI Client...
+dotnet publish -c Release -r win-x64 --self-contained true /p:PublishSingleFile=true /p:IncludeNativeLibrariesForSelfExtract=true
+
+if exist "bin\Release\net6.0-windows\win-x64\publish\PS5Upload.exe" (
+    echo.
+    echo ================================================
+    echo [+] SUCCESS! Built PS5Upload.exe
+    echo ================================================
+    echo.
+    echo Location: bin\Release\net6.0-windows\win-x64\publish\PS5Upload.exe
+    echo.
+    echo Copy PS5Upload.exe to any location and run it!
+) else (
+    echo.
+    echo ================================================
+    echo [-] BUILD FAILED
+    echo ================================================
+    echo.
+    echo Make sure .NET 6.0 SDK is installed:
+    echo https://dotnet.microsoft.com/download/dotnet/6.0
+    exit /b 1
+)
diff --git a/client/ps5_logo.ico b/client/ps5_logo.ico
new file mode 100644
index 0000000..8c39534
Binary files /dev/null and b/client/ps5_logo.ico differ
diff --git a/client/ps5_logo.png b/client/ps5_logo.png
new file mode 100644
index 0000000..a608c35
Binary files /dev/null and b/client/ps5_logo.png differ
diff --git a/client/ps5_logo_fixed.ico b/client/ps5_logo_fixed.ico
new file mode 100644
index 0000000..6e70dc5
Binary files /dev/null and b/client/ps5_logo_fixed.ico differ
diff --git a/payload/compile.sh b/payload/compile.sh
new file mode 100644
index 0000000..c0b44dc
--- /dev/null
+++ b/payload/compile.sh
@@ -0,0 +1,30 @@
+#!/bin/bash
+
+echo "================================================"
+echo "PS5 Upload Server - Compilation"
+echo "By Manos"
+echo "================================================"
+echo ""
+
+echo "[+] Compiling..."
+rm -f ps5_upload_server.elf
+/home/hackman/ps5sdk_copy/bin/prospero-clang -Wall -O3 -pthread -o ps5_upload_server.elf main.c
+
+if [ -f "ps5_upload_server.elf" ]; then
+    echo ""
+    echo "================================================"
+    echo "[+] SUCCESS! Compiled ps5_upload_server.elf"
+    echo "================================================"
+    echo ""
+    ls -lh ps5_upload_server.elf
+    file ps5_upload_server.elf
+    echo ""
+    echo "Upload to PS5 and run with elfldr"
+    echo "Server will listen on port 9113"
+else
+    echo ""
+    echo "================================================"
+    echo "[-] COMPILATION FAILED"
+    echo "================================================"
+    exit 1
+fi
diff --git a/payload/main.c b/payload/main.c
new file mode 100644
index 0000000..cf23a76
--- /dev/null
+++ b/payload/main.c
@@ -0,0 +1,875 @@
+/* PS5 Upload Server - Custom High-Speed Protocol
+ * By Manos
+ * Port: 9113
+ * Protocol: Custom binary for maximum speed
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+#include <arpa/inet.h>
+#include <sys/stat.h>
+#include <sys/statvfs.h>
+#include <fcntl.h>
+#include <dirent.h>
+#include <pthread.h>
+#include <time.h>
+#include <ifaddrs.h>
+
+#define SERVER_PORT 9113
+#define BUFFER_SIZE (8 * 1024 * 1024)
+#define MAX_PATH 2048
+#define DISK_WORKER_COUNT 4
+#define QUEUE_MAX_SIZE 32
+
+// Protocol commands
+#define CMD_PING 0x01
+#define CMD_LIST_STORAGE 0x02
+#define CMD_LIST_DIR 0x03
+#define CMD_CREATE_DIR 0x04
+#define CMD_DELETE_FILE 0x05
+#define CMD_DELETE_DIR 0x06
+#define CMD_RENAME 0x07
+#define CMD_COPY_FILE 0x08
+#define CMD_MOVE_FILE 0x09
+#define CMD_START_UPLOAD 0x10
+#define CMD_UPLOAD_CHUNK 0x11
+#define CMD_END_UPLOAD 0x12
+#define CMD_SHUTDOWN 0xFF
+
+// Protocol responses
+#define RESP_OK 0x01
+#define RESP_ERROR 0x02
+#define RESP_DATA 0x03
+#define RESP_READY 0x04
+#define RESP_PROGRESS 0x05
+
+typedef struct notify_request {
+    char useless1[45];
+    char message[3075];
+} notify_request_t;
+
+int sceKernelSendNotificationRequest(int, notify_request_t*, size_t, int);
+
+void send_notification(const char *msg) {
+    notify_request_t req;
+    memset(&req, 0, sizeof(req));
+    strncpy(req.message, msg, sizeof(req.message) - 1);
+    sceKernelSendNotificationRequest(0, &req, sizeof(req), 0);
+}
+
+typedef struct {
+    int sock;
+    FILE *upload_fp;
+    char upload_path[MAX_PATH];
+    uint64_t upload_size;
+    uint64_t upload_received;
+} client_session_t;
+
+// Disk write job for queue
+typedef struct write_job {
+    uint8_t *data;
+    size_t len;
+    FILE *fp;
+    struct write_job *next;
+} write_job_t;
+
+// Job queue (producer-consumer pattern)
+typedef struct {
+    write_job_t *head;
+    write_job_t *tail;
+    size_t count;
+    size_t max;
+    int closed;
+    pthread_mutex_t mutex;
+    pthread_cond_t not_empty;
+    pthread_cond_t not_full;
+} job_queue_t;
+
+// Global queue and workers
+static job_queue_t g_queue;
+static pthread_t g_workers[DISK_WORKER_COUNT];
+static int g_workers_initialized = 0;
+
+// Queue operations
+void queue_init(job_queue_t *q, size_t max) {
+    memset(q, 0, sizeof(*q));
+    q->max = max;
+    pthread_mutex_init(&q->mutex, NULL);
+    pthread_cond_init(&q->not_empty, NULL);
+    pthread_cond_init(&q->not_full, NULL);
+}
+
+int queue_push(job_queue_t *q, write_job_t *job) {
+    pthread_mutex_lock(&q->mutex);
+    while (!q->closed && q->count >= q->max) {
+        pthread_cond_wait(&q->not_full, &q->mutex);
+    }
+    if (q->closed) {
+        pthread_mutex_unlock(&q->mutex);
+        return -1;
+    }
+    job->next = NULL;
+    if (!q->tail) {
+        q->head = job;
+        q->tail = job;
+    } else {
+        q->tail->next = job;
+        q->tail = job;
+    }
+    q->count++;
+    pthread_cond_signal(&q->not_empty);
+    pthread_mutex_unlock(&q->mutex);
+    return 0;
+}
+
+write_job_t *queue_pop(job_queue_t *q) {
+    pthread_mutex_lock(&q->mutex);
+    while (!q->closed && q->count == 0) {
+        pthread_cond_wait(&q->not_empty, &q->mutex);
+    }
+    if (q->count == 0 && q->closed) {
+        pthread_mutex_unlock(&q->mutex);
+        return NULL;
+    }
+    write_job_t *job = q->head;
+    q->head = job->next;
+    if (!q->head) {
+        q->tail = NULL;
+    }
+    q->count--;
+    pthread_cond_signal(&q->not_full);
+    pthread_mutex_unlock(&q->mutex);
+    return job;
+}
+
+// Disk worker thread
+void *disk_worker(void *arg) {
+    (void)arg;
+    while (1) {
+        write_job_t *job = queue_pop(&g_queue);
+        if (!job) break;
+        
+        if (job->fp && job->data && job->len > 0) {
+            fwrite(job->data, 1, job->len, job->fp);
+            // No fflush here - let setvbuf handle buffering
+        }
+        
+        free(job->data);
+        free(job);
+    }
+    return NULL;
+}
+
+void init_workers() {
+    if (g_workers_initialized) return;
+    
+    queue_init(&g_queue, QUEUE_MAX_SIZE);
+    for (int i = 0; i < DISK_WORKER_COUNT; i++) {
+        pthread_create(&g_workers[i], NULL, disk_worker, NULL);
+    }
+    g_workers_initialized = 1;
+}
+
+// Send response - combined header+data in single send for speed
+void send_response(int sock, uint8_t response, const void *data, uint32_t data_len) {
+    // Combine header and data into single buffer for single send()
+    size_t total_len = 5 + data_len;
+    uint8_t *combined = malloc(total_len);
+    if (!combined) {
+        // Fallback to separate sends
+        uint8_t header[5];
+        header[0] = response;
+        memcpy(header + 1, &data_len, 4);
+        send(sock, header, 5, 0);
+        if (data && data_len > 0) {
+            send(sock, data, data_len, 0);
+        }
+        return;
+    }
+    
+    combined[0] = response;
+    memcpy(combined + 1, &data_len, 4);
+    if (data && data_len > 0) {
+        memcpy(combined + 5, data, data_len);
+    }
+    
+    send(sock, combined, total_len, 0);
+    free(combined);
+}
+
+// Send OK response
+void send_ok(int sock, const char *msg) {
+    uint32_t len = msg ? strlen(msg) : 0;
+    send_response(sock, RESP_OK, msg, len);
+}
+
+// Send error response
+void send_error(int sock, const char *msg) {
+    uint32_t len = msg ? strlen(msg) : 0;
+    send_response(sock, RESP_ERROR, msg, len);
+}
+
+// Recursive directory creation
+int mkdir_recursive(const char *path) {
+    char tmp[MAX_PATH];
+    char *p = NULL;
+    size_t len;
+
+    snprintf(tmp, sizeof(tmp), "%s", path);
+    len = strlen(tmp);
+    if (tmp[len - 1] == '/') {
+        tmp[len - 1] = 0;
+    }
+
+    for (p = tmp + 1; *p; p++) {
+        if (*p == '/') {
+            *p = 0;
+            if (mkdir(tmp, 0777) != 0 && errno != EEXIST) {
+                return -1;
+            }
+            chmod(tmp, 0777);
+            *p = '/';
+        }
+    }
+    if (mkdir(tmp, 0777) != 0 && errno != EEXIST) {
+        return -1;
+    }
+    chmod(tmp, 0777);
+    return 0;
+}
+
+// Recursive directory deletion
+int rmdir_recursive(const char *path) {
+    DIR *dir = opendir(path);
+    if (!dir) {
+        return -1;
+    }
+
+    struct dirent *entry;
+    char child[MAX_PATH];
+    while ((entry = readdir(dir)) != NULL) {
+        if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) {
+            continue;
+        }
+        snprintf(child, sizeof(child), "%s/%s", path, entry->d_name);
+
+        struct stat st;
+        if (stat(child, &st) != 0) {
+            continue;
+        }
+        if (S_ISDIR(st.st_mode)) {
+            rmdir_recursive(child);
+        } else {
+            unlink(child);
+        }
+    }
+    closedir(dir);
+    return rmdir(path);
+}
+
+// Handle PING
+void handle_ping(client_session_t *session) {
+    send_ok(session->sock, "PONG");
+}
+
+// Handle LIST_STORAGE
+void handle_list_storage(client_session_t *session) {
+    const char *mounts[] = {"/data", "/mnt/usb0", "/mnt/usb1", "/system", "/system_ex"};
+    int mount_count = 0;
+    
+    // Count available mounts
+    for (int i = 0; i < 5; i++) {
+        struct stat st;
+        if (stat(mounts[i], &st) == 0) {
+            mount_count++;
+        }
+    }
+    
+    // Build response
+    size_t buf_size = 4 + (mount_count * (2 + MAX_PATH + 16));
+    uint8_t *buffer = malloc(buf_size);
+    if (!buffer) {
+        send_error(session->sock, "Memory allocation failed");
+        return;
+    }
+    
+    uint8_t *ptr = buffer;
+    memcpy(ptr, &mount_count, 4);
+    ptr += 4;
+    
+    for (int i = 0; i < 5; i++) {
+        struct statvfs vfs;
+        if (statvfs(mounts[i], &vfs) == 0) {
+            uint16_t path_len = strlen(mounts[i]);
+            uint64_t total = (uint64_t)vfs.f_blocks * vfs.f_frsize;
+            uint64_t free = (uint64_t)vfs.f_bfree * vfs.f_frsize;
+            
+            memcpy(ptr, &path_len, 2);
+            ptr += 2;
+            memcpy(ptr, mounts[i], path_len);
+            ptr += path_len;
+            memcpy(ptr, &total, 8);
+            ptr += 8;
+            memcpy(ptr, &free, 8);
+            ptr += 8;
+        }
+    }
+    
+    send_response(session->sock, RESP_DATA, buffer, ptr - buffer);
+    free(buffer);
+}
+
+// Handle LIST_DIR - Optimized version using d_type only (no stat for dirs)
+void handle_list_dir(client_session_t *session, const char *path) {
+    DIR *dir = opendir(path);
+    if (!dir) {
+        int32_t count = 0;
+        send_response(session->sock, RESP_DATA, &count, 4);
+        return;
+    }
+    
+    size_t buf_size = 256 * 1024;
+    uint8_t *buffer = malloc(buf_size);
+    if (!buffer) {
+        closedir(dir);
+        int32_t count = 0;
+        send_response(session->sock, RESP_DATA, &count, 4);
+        return;
+    }
+    
+    uint8_t *ptr = buffer + 4;
+    int32_t entry_count = 0;
+    
+    struct dirent *entry;
+    char full_path[MAX_PATH];
+    
+    while ((entry = readdir(dir)) != NULL) {
+        if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) {
+            continue;
+        }
+        
+        uint16_t name_len = (uint16_t)strlen(entry->d_name);
+        size_t needed = 1 + 2 + name_len + 8 + 8;
+        
+        if ((size_t)(ptr - buffer) + needed > buf_size) {
+            break;
+        }
+        
+        // Determine type - use d_type if available, otherwise fall back to stat()
+        uint8_t type = 0;
+        if (entry->d_type == DT_DIR) {
+            type = 1;
+        } else if (entry->d_type == DT_UNKNOWN) {
+            // d_type not supported on this filesystem - use stat() as fallback
+            snprintf(full_path, sizeof(full_path), "%s/%s", path, entry->d_name);
+            struct stat st;
+            if (stat(full_path, &st) == 0 && S_ISDIR(st.st_mode)) {
+                type = 1;
+            }
+        }
+        // else: DT_REG or other = file (type = 0)
+        
+        uint64_t size = 0;      // Don't need file size for browsing
+        uint64_t timestamp = 0; // Don't need timestamp for browsing
+        
+        *ptr++ = type;
+        memcpy(ptr, &name_len, 2);
+        ptr += 2;
+        memcpy(ptr, entry->d_name, name_len);
+        ptr += name_len;
+        memcpy(ptr, &size, 8);
+        ptr += 8;
+        memcpy(ptr, &timestamp, 8);
+        ptr += 8;
+        
+        entry_count++;
+    }
+    
+    closedir(dir);
+    memcpy(buffer, &entry_count, 4);
+    send_response(session->sock, RESP_DATA, buffer, (uint32_t)(ptr - buffer));
+    free(buffer);
+}
+
+// Handle CREATE_DIR
+void handle_create_dir(client_session_t *session, const char *path) {
+    if (mkdir_recursive(path) == 0) {
+        send_ok(session->sock, "Directory created");
+    } else {
+        send_error(session->sock, "Failed to create directory");
+    }
+}
+
+// Handle DELETE_FILE
+void handle_delete_file(client_session_t *session, const char *path) {
+    if (unlink(path) == 0) {
+        send_ok(session->sock, "File deleted");
+    } else {
+        send_error(session->sock, "Failed to delete file");
+    }
+}
+
+// Handle DELETE_DIR
+void handle_delete_dir(client_session_t *session, const char *path) {
+    if (rmdir_recursive(path) == 0) {
+        send_ok(session->sock, "Directory deleted");
+    } else {
+        send_error(session->sock, "Failed to delete directory");
+    }
+}
+
+// Handle RENAME
+void handle_rename(client_session_t *session, const uint8_t *data, uint32_t data_len) {
+    const char *old_path = (const char *)data;
+    uint32_t old_len = strlen(old_path);
+    if (old_len + 2 > data_len) {
+        send_error(session->sock, "Invalid rename request");
+        return;
+    }
+    const char *new_path = (const char *)(data + old_len + 1);
+    
+    if (rename(old_path, new_path) == 0) {
+        send_ok(session->sock, "Renamed successfully");
+    } else {
+        send_error(session->sock, "Failed to rename");
+    }
+}
+
+// Handle COPY_FILE
+void handle_copy_file(client_session_t *session, const uint8_t *data, uint32_t data_len) {
+    const char *src = (const char *)data;
+    uint32_t src_len = strlen(src);
+    if (src_len + 2 > data_len) {
+        send_error(session->sock, "Invalid copy request");
+        return;
+    }
+    const char *dst = (const char *)(data + src_len + 1);
+    
+    int src_fd = open(src, O_RDONLY);
+    if (src_fd < 0) {
+        send_error(session->sock, "Cannot open source file");
+        return;
+    }
+    
+    int dst_fd = open(dst, O_WRONLY | O_CREAT | O_TRUNC, 0777);
+    if (dst_fd < 0) {
+        close(src_fd);
+        send_error(session->sock, "Cannot create destination file");
+        return;
+    }
+    
+    char *buf = malloc(BUFFER_SIZE);
+    if (!buf) {
+        close(src_fd);
+        close(dst_fd);
+        send_error(session->sock, "Memory allocation failed");
+        return;
+    }
+    
+    ssize_t n;
+    int success = 1;
+    while ((n = read(src_fd, buf, BUFFER_SIZE)) > 0) {
+        if (write(dst_fd, buf, n) != n) {
+            success = 0;
+            break;
+        }
+    }
+    
+    free(buf);
+    close(src_fd);
+    close(dst_fd);
+    chmod(dst, 0777);
+    
+    if (success) {
+        send_ok(session->sock, "File copied");
+    } else {
+        send_error(session->sock, "Failed to copy file");
+    }
+}
+
+// Handle MOVE_FILE
+void handle_move_file(client_session_t *session, const uint8_t *data, uint32_t data_len) {
+    const char *src = (const char *)data;
+    uint32_t src_len = strlen(src);
+    if (src_len + 2 > data_len) {
+        send_error(session->sock, "Invalid move request");
+        return;
+    }
+    const char *dst = (const char *)(data + src_len + 1);
+    
+    if (rename(src, dst) == 0) {
+        send_ok(session->sock, "File moved");
+    } else {
+        send_error(session->sock, "Failed to move file");
+    }
+}
+
+// Handle START_UPLOAD (with optional chunk offset for parallel upload)
+void handle_start_upload(client_session_t *session, const uint8_t *data, uint32_t data_len) {
+    if (session->upload_fp) {
+        fclose(session->upload_fp);
+        session->upload_fp = NULL;
+    }
+    
+    // Parse path, size, and optional offset
+    const char *path = (const char *)data;
+    uint32_t path_len = strlen(path);
+    if (path_len + 9 > data_len) {
+        send_error(session->sock, "Invalid upload request");
+        return;
+    }
+    
+    uint64_t file_size;
+    memcpy(&file_size, data + path_len + 1, 8);
+    
+    // Check for optional offset (for chunked parallel upload)
+    uint64_t chunk_offset = 0;
+    if (path_len + 17 <= data_len) {
+        memcpy(&chunk_offset, data + path_len + 9, 8);
+    }
+    
+    // Create parent directories
+    char parent[MAX_PATH];
+    strncpy(parent, path, sizeof(parent) - 1);
+    parent[sizeof(parent) - 1] = '\0';
+    char *last_slash = strrchr(parent, '/');
+    if (last_slash) {
+        *last_slash = '\0';
+        mkdir_recursive(parent);
+    }
+    
+    // Open file for writing (r+b for chunk mode, wb for normal)
+    if (chunk_offset > 0) {
+        // Chunk mode: open existing file or create if needed
+        session->upload_fp = fopen(path, "r+b");
+        if (!session->upload_fp) {
+            // File doesn't exist, create it with full size
+            session->upload_fp = fopen(path, "wb");
+            if (session->upload_fp) {
+                // CRITICAL: Allocate full file size before any chunk writes
+                // This ensures all chunks can write to their offsets without corruption
+                if (fseeko(session->upload_fp, file_size - 1, SEEK_SET) == 0) {
+                    // Write a single byte at the end to allocate the full size
+                    fputc(0, session->upload_fp);
+                    fflush(session->upload_fp);
+                }
+                fclose(session->upload_fp);
+                session->upload_fp = fopen(path, "r+b");
+            }
+        }
+        if (session->upload_fp) {
+            // Seek to chunk offset
+            fseeko(session->upload_fp, chunk_offset, SEEK_SET);
+        }
+    } else {
+        // Normal mode: create new file
+        session->upload_fp = fopen(path, "wb");
+    }
+    
+    if (!session->upload_fp) {
+        send_error(session->sock, "Cannot create file");
+        return;
+    }
+    
+    // Use HUGE buffer (8MB) for maximum write speed
+    setvbuf(session->upload_fp, NULL, _IOFBF, BUFFER_SIZE);
+    
+    strncpy(session->upload_path, path, sizeof(session->upload_path) - 1);
+    session->upload_size = file_size;
+    session->upload_received = chunk_offset;
+    
+    // Increase socket receive buffer for this upload session
+    int huge_buf = 8 * 1024 * 1024; // 8MB receive buffer
+    setsockopt(session->sock, SOL_SOCKET, SO_RCVBUF, &huge_buf, sizeof(huge_buf));
+    
+    send_response(session->sock, RESP_READY, NULL, 0);
+}
+
+// Handle UPLOAD_CHUNK
+void handle_upload_chunk(client_session_t *session, const uint8_t *data, uint32_t data_len) {
+    if (!session->upload_fp) {
+        send_error(session->sock, "No upload in progress");
+        return;
+    }
+    
+    // Direct write with periodic flush for stability
+    size_t written = fwrite(data, 1, data_len, session->upload_fp);
+    if (written != data_len) {
+        send_error(session->sock, "Write failed");
+        fclose(session->upload_fp);
+        session->upload_fp = NULL;
+        return;
+    }
+    
+    session->upload_received += written;
+    
+    // Flush every 32MB to prevent buffer overflow with multiple connections
+    if (session->upload_received % (32 * 1024 * 1024) < data_len) {
+        fflush(session->upload_fp);
+    }
+    // No response - zero blocking for maximum speed
+}
+
+// Handle END_UPLOAD
+void handle_end_upload(client_session_t *session) {
+    if (!session->upload_fp) {
+        send_error(session->sock, "No upload in progress");
+        return;
+    }
+    
+    fflush(session->upload_fp);
+    fclose(session->upload_fp);
+    session->upload_fp = NULL;
+    chmod(session->upload_path, 0777);
+    
+    send_ok(session->sock, "Upload complete");
+}
+
+// Handle client
+void *client_thread(void *arg) {
+    client_session_t *session = (client_session_t *)arg;
+    uint8_t *buffer = malloc(BUFFER_SIZE);
+    
+    if (!buffer) {
+        close(session->sock);
+        free(session);
+        return NULL;
+    }
+    
+    // Set socket timeout to prevent blocking forever (60 seconds)
+    struct timeval tv;
+    tv.tv_sec = 60;
+    tv.tv_usec = 0;
+    setsockopt(session->sock, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
+    
+    while (1) {
+        // Read command header (5 bytes: 1 cmd + 4 data_len)
+        uint8_t header[5];
+        ssize_t n = recv(session->sock, header, 5, MSG_WAITALL);
+        if (n != 5) {
+            break;
+        }
+        
+        uint8_t cmd = header[0];
+        uint32_t data_len;
+        memcpy(&data_len, header + 1, 4);
+        
+        // Read data if present
+        uint8_t *data = NULL;
+        if (data_len > 0) {
+            if (data_len > BUFFER_SIZE) {
+                send_error(session->sock, "Data too large");
+                break;
+            }
+            data = buffer;
+            ssize_t received = 0;
+            while (received < data_len) {
+                n = recv(session->sock, data + received, data_len - received, 0);
+                if (n <= 0) {
+                    break;
+                }
+                received += n;
+            }
+            if (received != data_len) {
+                break;
+            }
+        }
+        
+        // Handle command
+        switch (cmd) {
+            case CMD_PING:
+                handle_ping(session);
+                break;
+            case CMD_LIST_STORAGE:
+                handle_list_storage(session);
+                break;
+            case CMD_LIST_DIR:
+                if (data) {
+                    handle_list_dir(session, (const char *)data);
+                }
+                break;
+            case CMD_CREATE_DIR:
+                if (data) {
+                    handle_create_dir(session, (const char *)data);
+                }
+                break;
+            case CMD_DELETE_FILE:
+                if (data) {
+                    handle_delete_file(session, (const char *)data);
+                }
+                break;
+            case CMD_DELETE_DIR:
+                if (data) {
+                    handle_delete_dir(session, (const char *)data);
+                }
+                break;
+            case CMD_RENAME:
+                if (data) {
+                    handle_rename(session, data, data_len);
+                }
+                break;
+            case CMD_COPY_FILE:
+                if (data) {
+                    handle_copy_file(session, data, data_len);
+                }
+                break;
+            case CMD_MOVE_FILE:
+                if (data) {
+                    handle_move_file(session, data, data_len);
+                }
+                break;
+            case CMD_START_UPLOAD:
+                if (data) {
+                    handle_start_upload(session, data, data_len);
+                }
+                break;
+            case CMD_UPLOAD_CHUNK:
+                if (data) {
+                    handle_upload_chunk(session, data, data_len);
+                }
+                break;
+            case CMD_END_UPLOAD:
+                handle_end_upload(session);
+                break;
+            case CMD_SHUTDOWN:
+                send_ok(session->sock, "Shutting down");
+                free(buffer);
+                close(session->sock);
+                if (session->upload_fp) {
+                    fclose(session->upload_fp);
+                }
+                free(session);
+                exit(0);
+            default:
+                send_error(session->sock, "Unknown command");
+                break;
+        }
+    }
+    
+    free(buffer);
+    close(session->sock);
+    if (session->upload_fp) {
+        fclose(session->upload_fp);
+    }
+    free(session);
+    return NULL;
+}
+
+int main() {
+    // Initialize worker threads for async disk I/O
+    init_workers();
+    
+    int server_sock;
+    struct sockaddr_in server_addr;
+    
+    server_sock = socket(AF_INET, SOCK_STREAM, 0);
+    if (server_sock < 0) {
+        return 1;
+    }
+    
+    int opt = 1;
+    setsockopt(server_sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
+    
+    // Prevent SIGPIPE
+    int no_sigpipe = 1;
+    setsockopt(server_sock, SOL_SOCKET, SO_NOSIGPIPE, &no_sigpipe, sizeof(no_sigpipe));
+    
+    // 8MB buffers for sustained high throughput
+    int buf_size = 8 * 1024 * 1024;
+    setsockopt(server_sock, SOL_SOCKET, SO_RCVBUF, &buf_size, sizeof(buf_size));
+    setsockopt(server_sock, SOL_SOCKET, SO_SNDBUF, &buf_size, sizeof(buf_size));
+    
+    memset(&server_addr, 0, sizeof(server_addr));
+    server_addr.sin_family = AF_INET;
+    server_addr.sin_addr.s_addr = INADDR_ANY;
+    server_addr.sin_port = htons(SERVER_PORT);
+    
+    if (bind(server_sock, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) {
+        close(server_sock);
+        return 1;
+    }
+    
+    if (listen(server_sock, 10) < 0) {
+        close(server_sock);
+        return 1;
+    }
+    
+    // Get IP address
+    char ip_str[INET_ADDRSTRLEN] = "0.0.0.0";
+    struct ifaddrs *ifaddr, *ifa;
+    if (getifaddrs(&ifaddr) == 0) {
+        for (ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next) {
+            if (ifa->ifa_addr == NULL) continue;
+            if (ifa->ifa_addr->sa_family == AF_INET) {
+                struct sockaddr_in *addr = (struct sockaddr_in *)ifa->ifa_addr;
+                inet_ntop(AF_INET, &addr->sin_addr, ip_str, INET_ADDRSTRLEN);
+                if (strcmp(ip_str, "127.0.0.1") != 0) {
+                    break;
+                }
+            }
+        }
+        freeifaddrs(ifaddr);
+    }
+    
+    char msg[128];
+    snprintf(msg, sizeof(msg), "PS5 Upload Server v3.0: %s:%d - By Manos", ip_str, SERVER_PORT);
+    send_notification(msg);
+    
+    while (1) {
+        struct sockaddr_in client_addr;
+        socklen_t client_len = sizeof(client_addr);
+        
+        int client_sock = accept(server_sock, (struct sockaddr*)&client_addr, &client_len);
+        if (client_sock < 0) {
+            continue;
+        }
+        
+        // Aggressive TCP socket options for sustained high speed
+        setsockopt(client_sock, SOL_SOCKET, SO_NOSIGPIPE, &no_sigpipe, sizeof(no_sigpipe));
+        
+        // Increase buffers to 8MB for maximum throughput
+        int large_buf = 8 * 1024 * 1024;
+        setsockopt(client_sock, SOL_SOCKET, SO_RCVBUF, &large_buf, sizeof(large_buf));
+        setsockopt(client_sock, SOL_SOCKET, SO_SNDBUF, &large_buf, sizeof(large_buf));
+        
+        // TCP optimizations - TCP_NODELAY for immediate send
+        int nodelay = 1;
+        setsockopt(client_sock, IPPROTO_TCP, TCP_NODELAY, &nodelay, sizeof(nodelay));
+        
+        // NOTE: Removed TCP_NOPUSH - it was causing buffering delays!
+        
+        // Set keepalive to prevent connection drops
+        int keepalive = 1;
+        setsockopt(client_sock, SOL_SOCKET, SO_KEEPALIVE, &keepalive, sizeof(keepalive));
+        
+        client_session_t *session = malloc(sizeof(client_session_t));
+        if (!session) {
+            close(client_sock);
+            continue;
+        }
+        
+        memset(session, 0, sizeof(client_session_t));
+        session->sock = client_sock;
+        
+        pthread_t thread;
+        pthread_attr_t attr;
+        pthread_attr_init(&attr);
+        pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
+        
+        if (pthread_create(&thread, &attr, client_thread, session) != 0) {
+            close(client_sock);
+            free(session);
+        }
+        
+        pthread_attr_destroy(&attr);
+    }
+    
+    close(server_sock);
+    return 0;
+}
diff --git a/payload/ps5_upload_server.elf b/payload/ps5_upload_server.elf
new file mode 100644
index 0000000..0d994fc
Binary files /dev/null and b/payload/ps5_upload_server.elf differ
diff --git a/screenshots/screenshot1.png b/screenshots/screenshot1.png
new file mode 100644
index 0000000..2cf25ac
Binary files /dev/null and b/screenshots/screenshot1.png differ
diff --git a/screenshots/screenshot2.png b/screenshots/screenshot2.png
new file mode 100644
index 0000000..7014536
Binary files /dev/null and b/screenshots/screenshot2.png differ