fix: open folder because state.download_path is None in gui.py

Fully replace Aria2 with LibTorrent

.github/workflows/dev.yml

@@ -24,7 +24,7 @@ jobs:
     strategy:
       matrix:
         include:
-          - os: ubuntu-latest
+          - os: ubuntu-22.04
             artifact_name: SoftwareManager-dev-${{ github.sha }}-linux
             asset_name: SoftwareManager-dev-${{ github.sha }}-linux
           - os: windows-latest
@@ -44,30 +44,22 @@ jobs:
         uses: actions/checkout@v4
 
       - name: Set up Python
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v6
         with:
           python-version: ${{ env.PYTHON_VERSION }}
 
-      - name: Install system dependencies (Linux)
+      - name: Install uv
-        if: runner.os == 'Linux'
+        uses: astral-sh/setup-uv@v7
-        run: |
+        with:
-          sudo apt-get update
+          version: "0.9.7"
-          sudo apt-get install -y \
+          enable-cache: true
-            libxcb-xinerama0 \
-            libxkbcommon-x11-0 \
-            libxcb-cursor0 \
-            libxcb-keysyms1 \
-            libxcb-render-util0 \
-            libxcb-icccm4 \
-            libxcb-image0 \
-            libxcb-shape0 \
-            libxcb-util1
 
       - name: Install Python dependencies
         run: |
-          python -m pip install --upgrade pip
+          uv pip install -r requirements.txt
-          pip install -r requirements.txt
+          uv pip install pyinstaller backports.tarfile pillow
-          pip install pyinstaller backports.tarfile pillow
+        env:
+          UV_SYSTEM_PYTHON: 1
 
       - name: Generate version
         id: version
@@ -90,13 +82,6 @@ jobs:
           }
           EOF
 
-      - name: Download aria2c (Windows)
-        if: runner.os == 'Windows'
-        run: |
-          mkdir -p deps
-          C:\msys64\usr\bin\wget.exe https://github.com/aria2/aria2/releases/download/release-1.37.0/aria2-1.37.0-win-64bit-build1.zip
-          unzip -j aria2-1.37.0-win-64bit-build1.zip aria2-1.37.0-win-64bit-build1/aria2c.exe -d deps/
-
       - name: Build executable with PyInstaller (Windows)
         if: runner.os == 'Windows'
         shell: bash
@@ -105,7 +90,6 @@ jobs:
             --add-data "build_info.json;." \
             --add-data "build_info.json;core" \
             --add-data "build_info.json;core/interface" \
-            --add-data "deps/aria2c.exe;." \
             --add-data "core/interface/assets;core/interface/assets" \
             --icon "core/interface/assets/logo.png" \
             --exclude-module PyQt6 \
@@ -159,7 +143,7 @@ jobs:
   release:
     name: Create Release
     needs: build
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     if: success()
 
     steps:
@@ -172,7 +156,7 @@ jobs:
         run: |
           mkdir -p release
           SHORT_SHA="${{ needs.build.outputs.short_sha }}"
-          cp artifacts/ubuntu-latest-build/SoftwareManager-dev-*-linux release/SoftwareManager-dev-${SHORT_SHA}-linux
+          cp artifacts/ubuntu-22.04-build/SoftwareManager-dev-*-linux release/SoftwareManager-dev-${SHORT_SHA}-linux
           cp artifacts/windows-latest-build/SoftwareManager-dev-*-windows.exe release/SoftwareManager-dev-${SHORT_SHA}-windows.exe
           cp artifacts/macos-latest-build/SoftwareManager-dev-*-macos release/SoftwareManager-dev-${SHORT_SHA}-macos
           chmod +x release/SoftwareManager-dev-*-linux release/SoftwareManager-dev-*-macos
@@ -207,4 +191,4 @@ jobs:
             release/SoftwareManager-dev-${{ needs.build.outputs.short_sha }}-windows.exe
             release/SoftwareManager-dev-${{ needs.build.outputs.short_sha }}-macos
         env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

core/interface/dialogs/settings.py

@@ -12,7 +12,9 @@ from PySide6.QtWidgets import (
     QHBoxLayout,
     QSpinBox,
     QCheckBox,
-    )
+    QFileDialog,
+)
+import platform
 
 
 def settings_dialog(self):
@@ -20,7 +22,7 @@ def settings_dialog(self):
         consoleLog("Settings dialog opened")
         dialog = QDialog(self)
         dialog.setWindowTitle("Settings")
-        dialog.setFixedSize(800, 400)
+        dialog.setFixedSize(800, 550)
 
         dialog.setLayout(QVBoxLayout())
         dialog.layout().addWidget(QLabel("Settings"))
@@ -32,14 +34,16 @@ def settings_dialog(self):
         update_checkbox_layout = QHBoxLayout()
 
         # ignore updates checkbox
-        update_checkbox = QCheckBox()
+
-        update_checkbox_container.setLayout(update_checkbox_layout)
+        if platform.system() == "Windows":
-        update_checkbox_layout.addWidget(QLabel("Ignore Updates: "))
+            update_checkbox = QCheckBox()
-        update_checkbox_layout.addStretch()
+            update_checkbox_container.setLayout(update_checkbox_layout)
-        update_checkbox.setChecked(state.ignore_updates)
+            update_checkbox_layout.addWidget(QLabel("Ignore Updates: "))
-        update_checkbox.toggled.connect(lambda checked: setattr(state, 'ignore_updates', checked))
+            update_checkbox_layout.addStretch()
-        update_checkbox_layout.addWidget(update_checkbox)
+            update_checkbox.setChecked(state.ignore_updates)
-        dialog.layout().addWidget(update_checkbox_container)
+            update_checkbox.toggled.connect(lambda checked: setattr(state, 'ignore_updates', checked))
+            update_checkbox_layout.addWidget(update_checkbox)
+            dialog.layout().addWidget(update_checkbox_container)
 
         # auto-resume downloads checkbox
 
@@ -56,30 +60,20 @@ def settings_dialog(self):
         autoresume_layout.addWidget(autoresume_checkbox)
         dialog.layout().addWidget(autoresume_container)
 
-        ##################
-        # THREAD SETTING #
-        ##################
-        thread_box = QSpinBox()
-        thread_box.setMinimum(1)
-        thread_box.setMaximum(16)
-        thread_box.setValue(state.aria2_threads)
-        
 
-        # container for tight space
+        # transparent window checkbox
-        thread_container = QWidget()
+        transparent_window_container = QWidget()
-        thread_layout = QHBoxLayout()
+        transparent_window_layout = QHBoxLayout()
 
-        thread_layout.addWidget(QLabel("Threads:"))
+        transparent_window_checkbox = QCheckBox()
-        thread_layout.addWidget(thread_box)
+        transparent_window_container.setLayout(transparent_window_layout)
-        thread_container.setLayout(thread_layout)
+        transparent_window_layout.addWidget(QLabel("Window Transparency (requires restart) (Linux/MacOS only): "))
-        thread_container.setMaximumHeight(80)
-        
 
-        # Dimensions
+        transparent_window_layout.addStretch()
-        thread_box.setFixedWidth(90)
+        transparent_window_checkbox.setChecked(state.window_transparency)
-        thread_box.setFixedHeight(30)
+        transparent_window_checkbox.toggled.connect(lambda checked: setattr(state, 'window_transparency', checked))
-
+        transparent_window_layout.addWidget(transparent_window_checkbox)
-        dialog.layout().addWidget(thread_container)
+        dialog.layout().addWidget(transparent_window_container)
 
         ##################
         # SERVER SETTING #
@@ -111,23 +105,14 @@ def settings_dialog(self):
         download_path.setText(state.download_path)
         dialog.layout().addWidget(download_path_container)
 
-        ##################
+        def browse_download_path():
-        # SPEED LIMITING #
+            dir_path = QFileDialog.getExistingDirectory(dialog, "Select Download Directory", state.download_path)
-        ##################
+            if dir_path:
+                download_path.setText(dir_path)
 
-        speed_limit_container = QWidget()
+        browse_button = QPushButton("📁")
-        speed_limit_layout = QHBoxLayout()
+        download_path_layout.addWidget(browse_button)
-
+        browse_button.clicked.connect(browse_download_path)
-        speed_limit_layout.addWidget(QLabel("Max Download Speed (KiB, 0 for unlimited): "))
-        speed_limit = QSpinBox()
-        speed_limit.setMinimum(0)
-        speed_limit.setMaximum(10000000)
-        speed_limit.setValue(state.speed_limit)
-        speed_limit_container.setLayout(speed_limit_layout)
-        speed_limit_layout.addWidget(speed_limit)
-        speed_limit.setFixedWidth(180)
-        speed_limit.setFixedHeight(30)
-        dialog.layout().addWidget(speed_limit_container)
 
         ###############
         # IMAGE PATH #
@@ -144,6 +129,83 @@ def settings_dialog(self):
         image_path.setText(state.image_path)
         dialog.layout().addWidget(image_path_container)
 
+        def browse_image_path():
+            file_path = QFileDialog.getOpenFileName(dialog, "Select Image File", state.image_path, "Image Files (*.png *.jpg)")[0]
+            if file_path:
+                image_path.setText(file_path)
+
+        browse_button = QPushButton("📁")
+        image_path_layout.addWidget(browse_button)
+        browse_button.clicked.connect(browse_image_path)
+
+        ##################
+        # SPEED LIMITING #
+        ##################
+
+        down_speed_limit_container = QWidget()
+        down_speed_limit_layout = QHBoxLayout()
+
+        down_speed_limit_layout.addWidget(QLabel("Max Download Speed (KiB, 0 for unlimited): "))
+        down_speed_limit = QSpinBox()
+        down_speed_limit.setMinimum(0)
+        down_speed_limit.setMaximum(10000000)
+        down_speed_limit.setValue(state.down_speed_limit)
+        down_speed_limit_container.setLayout(down_speed_limit_layout)
+        down_speed_limit_layout.addWidget(down_speed_limit)
+        down_speed_limit.setFixedWidth(180)
+        down_speed_limit.setFixedHeight(30)
+        dialog.layout().addWidget(down_speed_limit_container)
+        
+        up_speed_limit_container = QWidget()
+        up_speed_limit_layout = QHBoxLayout()
+
+        up_speed_limit_layout.addWidget(QLabel("Max Upload Speed (KiB, 0 for unlimited): "))
+        up_speed_limit = QSpinBox()
+        up_speed_limit.setMinimum(0)
+        up_speed_limit.setMaximum(10000000)
+        up_speed_limit.setValue(state.up_speed_limit)
+        up_speed_limit_container.setLayout(up_speed_limit_layout)
+        up_speed_limit_layout.addWidget(up_speed_limit)
+        up_speed_limit.setFixedWidth(180)
+        up_speed_limit.setFixedHeight(30)
+        dialog.layout().addWidget(up_speed_limit_container)
+
+        ######################
+        # CONNECTION CONFIGS #
+        ######################
+
+        max_connections_container = QWidget()
+        max_connections_layout = QHBoxLayout()
+
+        max_connections_layout.addWidget(QLabel("Max Connections: "))
+        max_connections = QSpinBox()
+        max_connections.setMinimum(0)
+        max_connections.setMaximum(10000000)
+        max_connections.setValue(state.max_connections)
+        max_connections_container.setLayout(max_connections_layout)
+        max_connections_layout.addWidget(max_connections)
+        max_connections.setFixedWidth(180)
+        max_connections.setFixedHeight(30)
+        dialog.layout().addWidget(max_connections_container)
+
+        ####################
+        # DOWNLOAD CONFIGS #
+        ####################
+
+        max_downloads_container = QWidget()
+        max_downloads_layout = QHBoxLayout()
+
+        max_downloads_layout.addWidget(QLabel("Max Downloads: "))
+        max_downloads = QSpinBox()
+        max_downloads.setMinimum(0)
+        max_downloads.setMaximum(10000000)
+        max_downloads.setValue(state.max_downloads)
+        max_downloads_container.setLayout(max_downloads_layout)
+        max_downloads_layout.addWidget(max_downloads)
+        max_downloads.setFixedWidth(180)
+        max_downloads.setFixedHeight(30)
+        dialog.layout().addWidget(max_downloads_container)
+
         ###############
         # SAVE/CANCEL #
         ###############
@@ -152,7 +214,7 @@ def settings_dialog(self):
 
         save_btn = QPushButton("Save")
         cancel_btn = QPushButton("Cancel")
-        save_btn.clicked.connect(lambda: save_settings(thread_box.value(), close_settings, api_url.text(), download_path.text(), speed_limit.value(), image_path.text()))
+        save_btn.clicked.connect(lambda: save_settings(close_settings, api_url.text(), download_path.text(), down_speed_limit.value(), up_speed_limit.value(), image_path.text(), None, max_connections.value(), max_downloads.value()))
 
         cancel_btn.clicked.connect(dialog.reject)
         layout.addWidget(cancel_btn)

core/interface/gui.py

@@ -1,12 +1,11 @@
 from PySide6 import QtWidgets
-from PySide6.QtCore import Qt, QTimer, QModelIndex, QAbstractTableModel, Signal, QEvent
+from PySide6.QtCore import Qt, QTimer, QModelIndex, QAbstractTableModel, Signal, QEvent, QSize
 from PySide6.QtWidgets import (
     QLineEdit,
     QTableView,
     QWidget,
     QVBoxLayout,
     QListWidget,
-    QToolBar,
     QLabel,
     QHBoxLayout,
     QComboBox,
@@ -16,39 +15,37 @@ from PySide6.QtWidgets import (
     QMessageBox,
     QTableWidget,
     QTextEdit,
-    QStyle,
-    QStyleOptionButton,
     QStyledItemDelegate,
-    QApplication,
+)
-    )
 
-from PySide6.QtGui import QIcon, QAction, QCloseEvent, QImage, QPixmap
+from PySide6.QtGui import QIcon, QCloseEvent, QImage, QPixmap, QContextMenuEvent
 import darkdetect
 import threading
 import platform
 import requests as r
 import os
 import subprocess
+import libtorrent as lt
 import time
 import sys
 import json
-from core.utils.general.logs import consoleLog
+from core.utils.general.logs import consoleLog, remove_download_log
 from core.utils.general.wrappers import run_thread
 from core.utils.data.state import state
 from core.utils.network.download import download_selected
 from core.utils.network.update_checker import check_for_updates
-from core.utils.general.shutdown import closehelper
 from core.interface.utils.tabhelper import create_tab
 from core.interface.utils.searchhelper import return_pressed
 from core.interface.dialogs.settings import settings_dialog
-from core.network.aria2_integration import dlprogress
+from core.network.libtorrent_misc import cleanup_session
+from core.utils.general.shutdown import closehelper
 
 
 def download_update(latest_version):
     new_filename = f"SoftwareManager-dev-{latest_version.replace('-dev', '')}-windows.exe"
     url = f"https://github.com/KeksPirates/SoftwareManager/releases/latest/download/SoftwareManager-dev-{latest_version.replace('-dev', '')}-windows.exe"
 
-    consoleLog("Downloading update...", True)
+    print("Downloading update...", True)
     response = r.get(url, allow_redirects=True)
     with open(new_filename, "wb") as f:
         f.write(response.content)
@@ -93,8 +90,8 @@ class MainWindow(QtWidgets.QMainWindow, QWidget):
         if platform.system() == "Windows":
             try:
                 import ctypes
-                myappid = 'SoftwareManager.App.1'
+                appid = 'SoftwareManager'
-                ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(myappid)
+                ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(appid)
             except Exception as e:
                 consoleLog(f"Could not set app ID: {e}")
 
@@ -137,6 +134,7 @@ class MainWindow(QtWidgets.QMainWindow, QWidget):
         self.searchbar.returnPressed.connect(lambda: run_thread(threading.Thread(target=return_pressed, args=(self,)))) # Triggers data function thread on enter
 
         self.dlbutton = QtWidgets.QPushButton("Download")
+        self.dlbutton.setCursor(Qt.PointingHandCursor)
         self.libraryList = QListWidget()
 
         self.emptyResults = QLabel("No Results")
@@ -147,18 +145,21 @@ class MainWindow(QtWidgets.QMainWindow, QWidget):
         self.downloadList = QTableView()
         self.emptyLibrary = QLabel("No items in library.")
         self.emptyDownload = QLabel("No items in downloads.")
+        self.emptyDownload.setAlignment(Qt.AlignCenter)
 
         self.consoleLog = QTextEdit()
         self.progressbar = QProgressBar()
 
         # Table Widget for Item List
         self.qtablewidget = QTableWidget()
-
+        
         self.qtablewidget.setColumnCount(2)
         self.qtablewidget.setEditTriggers(QtWidgets.QAbstractItemView.NoEditTriggers)
         self.qtablewidget.verticalHeader().setVisible(False)
         self.qtablewidget.setHorizontalHeaderLabels(["Post Title", "Author"])
 
+        
+
         header = self.qtablewidget.horizontalHeader()
         header.setSectionResizeMode(0, QHeaderView.Stretch) 
         header.setSectionResizeMode(1, QHeaderView.Fixed)   
@@ -182,8 +183,8 @@ class MainWindow(QtWidgets.QMainWindow, QWidget):
                 self.headers = ["Action", "Name", "Status", "Progress", "Speed", "Size", "Total Size"]
 
             def rowCount(self, parent=QModelIndex()):
-                return len(state.downloads)
+                return len(state.active_downloads)
-
+            
             def columnCount(self, parent=QModelIndex()):
                 return len(self.headers)
 
@@ -193,59 +194,141 @@ class MainWindow(QtWidgets.QMainWindow, QWidget):
                 return None
 
             def data(self, index, role=Qt.DisplayRole):
-                col = index.column()
-                download = state.downloads[index.row()]
                 if role == Qt.DisplayRole:
                     col = index.column()
 
+                    if index.row() >= len(state.active_downloads) or index.row() < 0:
+                        return None
+                    
+                    magnet_link = list(state.active_downloads.keys())[index.row()]
+                    magnetdl = state.active_downloads[magnet_link]
+                    
+                    status = magnetdl.status()
+                    
                     if col == 0:
-                        return "▶︎" if download.is_paused else "⏸︎"
-                    elif col == 1:
-                        return download.name
-                    elif col == 2:
-                        return getattr(download, 'status', 'Downloading')
-                    elif col == 3:
-                        return f"{int(download.progress)}%"
-                    elif col == 4:
-                        return f"{download.download_speed_string()}"
-                    elif col == 5:
                         pass
+                    elif col == 1:
+                        return status.name if status.has_metadata else "Fetching metadata..."
+                    elif col == 2:
+                        if status.state == lt.torrent_status.downloading:
+                            return "Downloading"
+                        elif status.state == lt.torrent_status.seeding:
+                            return "Seeding"
+                        elif status.paused:
+                            return "Paused"
+                        else:
+                            return "Queued"
+                    elif col == 3:
+                        return f"{status.progress * 100:.1f}%"
+                    elif col == 4:
+                        speed_kbs = status.download_rate / 1024
+                        if speed_kbs > 1024:
+                            return f"{speed_kbs / 1024:.1f} MB/s"
+                        else:
+                            return f"{speed_kbs:.1f} kB/s"
+                    elif col == 5:
+                        downloaded_mb = status.total_wanted_done / (1024 * 1024)
+                        if downloaded_mb > 1024:
+                            return f"{downloaded_mb / 1024:.2f} GB"
+                        else:
+                            return f"{downloaded_mb:.1f} MB"
                     elif col == 6:
-                        return f"{download.total_length_string()}"
+                        total_mb = status.total_wanted / (1024 * 1024)
+                        if total_mb > 1024:
+                            return f"{total_mb / 1024:.2f} GB"
+                        else:
+                            return f"{total_mb:.1f} MB"
+                    elif col == 7:
+                        if status.download_rate > 0:
+                            bytes_left = status.total_wanted - status.total_wanted_done
+                            eta_seconds = bytes_left / status.download_rate
+                            
+                            if eta_seconds < 60:
+                                return f"{int(eta_seconds)}s"
+                            elif eta_seconds < 3600:
+                                minutes = int(eta_seconds / 60)
+                                seconds = int(eta_seconds % 60)
+                                return f"{minutes}m {seconds}s"
+                            else:
+                                hours = int(eta_seconds / 3600)
+                                minutes = int((eta_seconds % 3600) / 60)
+                                return f"{hours}h {minutes}m"
+                        else:
+                            return "∞" if status.paused else "Stalled"
+                
+                if role == Qt.UserRole and index.column() == 0:
+                    magnet_link = list(state.active_downloads.keys())[index.row()]
+                    magnetdl = state.active_downloads[magnet_link]
+                    return magnetdl.status().paused
                 
-                if role == Qt.UserRole and col == 0:
-                    return download.is_paused
-
                 return None
 
             def toggle_pause_resume(self, row):
-                download = state.downloads[row]
+
-                if download.is_paused:
+                if row >= len(state.active_downloads) or row < 0:
-                    download.resume()
+                    return
+                    
+                magnet_link = list(state.active_downloads.keys())[row]
+                magnetdl = state.active_downloads[magnet_link]
+                status = magnetdl.status()
+                
+                if status.state == lt.torrent_status.seeding:
+                    save_path = magnetdl.save_path()
+                    if save_path and os.path.exists(save_path):
+                        if platform.system() == "Windows":
+                            os.startfile(os.path.normpath(save_path))
+                        elif platform.system() == "Linux":
+                            subprocess.Popen(["xdg-open", save_path])
+                        elif platform.system() == "Darwin":
+                            subprocess.Popen(["open", save_path])
+                    return
+                
+                if status.paused:
+                    magnetdl.resume()
+                    consoleLog(f"Resumed download: {status.name}", True)
                 else:
-                    download.pause()
+                    magnetdl.pause()
+                    consoleLog(f"Paused download: {status.name}", True)
+                
                 idx = self.index(row, 0)
-                self.dataChanged.emit(idx, idx, [Qt.DisplayRole, Qt.UserRole])
+                self.dataChanged.emit(idx, idx, [Qt.ItemDataRole.DisplayRole, Qt.ItemDataRole.UserRole])
 
         class PauseResumeDelegate(QStyledItemDelegate):
             clicked = Signal(int)
 
-            def paint(self, painter, option, index):
+            def setEditorData(self, editor, index):
-                if index.column() != 0:
+                button = editor.findChild(QtWidgets.QPushButton)
-                    super().paint(painter, option, index)
+                
-                    return
+                magnet_link = list(state.active_downloads.keys())[index.row()]
+                magnetdl = state.active_downloads[magnet_link]
+                status = magnetdl.status()
 
-                paused = index.data(Qt.UserRole)
+                if button:
+                    if status.state == lt.torrent_status.seeding:
+                        button.setText("📁")
+                    else:
+                        button.setText("▶︎" if status.paused else "⏸︎")
 
-                button = QStyleOptionButton()
+            def createEditor(self, parent, option, index):
-                button.rect = option.rect
+                magnet_link = list(state.active_downloads.keys())[index.row()]
-                button.text = "▶︎" if paused else "⏸︎"
+                magnetdl = state.active_downloads[magnet_link]
-                button.state = QStyle.State_Enabled
+                status = magnetdl.status()
-
-                QApplication.style().drawControl(
-                    QStyle.CE_PushButton, button, painter
-                )
 
+                widget = QWidget(parent)
+                widget.setStyleSheet("border: none;")
+                layout = QHBoxLayout(widget)
+                layout.setContentsMargins(0, 0, 0, 0)
+                if status.state == lt.torrent_status.seeding:
+                    btnPause = QtWidgets.QPushButton("📁")
+                else:
+                    btnPause = QtWidgets.QPushButton("▶︎" if status.paused else "⏸︎")
+                btnPause.setFixedSize(40, 30)
+                btnPause.clicked.connect(lambda: self.clicked.emit(index.row()))
+                layout.addStretch()
+                layout.addWidget(btnPause)
+                layout.addStretch()
+                widget.setLayout(layout)
+                return widget
             def editorEvent(self, event, model, option, index):
                 if index.column() == 0 and event.type() == QEvent.Type.MouseButtonPress:
                     self.clicked.emit(index.row())
@@ -265,12 +348,6 @@ class MainWindow(QtWidgets.QMainWindow, QWidget):
         def on_pause_resume_clicked(row):
             download_model.toggle_pause_resume(row)
 
-            download = state.downloads[row]
-            if download.is_paused:
-                download.pause()
-            else:
-                download.resume() 
-
         delegate = PauseResumeDelegate(self.downloadList)
         self.downloadList.setItemDelegateForColumn(0, delegate)
         delegate.clicked.connect(on_pause_resume_clicked)
@@ -283,13 +360,24 @@ class MainWindow(QtWidgets.QMainWindow, QWidget):
 
         # Tabs
         self.tabs = QTabWidget()
+        self.tabs = QTabWidget()
+        self.tabs.setStyleSheet("""
+            QTabBar::tab {
+                font-size: 11px;
+                padding: 2px 8px;
+                height: 25px;
+            }
+            QTabWidget::pane {
+                margin-top: -20px;
+            }
+        """)
 
         self.horizontal_layout = QHBoxLayout()
         self.horizontal_layout.addWidget(self.emptyResults, stretch=3)
         self.horizontal_layout.addWidget(self.qtablewidget)
 
         self.tab1 = create_tab("Search", self.searchbar, self.qtablewidget, self.tabs, self.dlbutton, self.horizontal_layout)
-        self.tab2 = create_tab("Library", self.emptyLibrary, self.libraryList, self.tabs, None, None)
+        # self.tab2 = create_tab("Library", self.emptyLibrary, self.libraryList, self.tabs, None, None)
         self.tab3 = create_tab("Downloads", self.emptyDownload, self.downloadList, self.tabs, None, None)
 
         if state.image_path is not None and os.path.exists(state.image_path):
@@ -306,45 +394,75 @@ class MainWindow(QtWidgets.QMainWindow, QWidget):
             y = self.height() - self.overlay_label.height() - offset_y
             self.overlay_label.move(x, y)
         
-
         # temporarily disabled
         # state.image_changed.connect(self.update_image_overlay)
 
-        containerLayout.addWidget(self.tabs)
+        
+        self.corner_widget = QWidget()
+        self.corner_layout = QHBoxLayout(self.corner_widget)
+        self.corner_layout.setContentsMargins(0, 0, 0, 0)
 
-        containerLayout.setAlignment(Qt.AlignmentFlag.AlignBottom)
-        toolbar = QToolBar("Main Toolbar")
-        self.addToolBar(toolbar)
-        toolbar.setLayoutDirection(Qt.RightToLeft)
 
         self.tracker_list = QComboBox()
         self.tracker_list.addItems(["rutracker", "uztracker", "m0nkrus"])
+        self.tracker_list.setCursor(Qt.CursorShape.PointingHandCursor)
         self.tracker_list.activated.connect(self.set_tracker)
+        self.corner_layout.addWidget(self.tracker_list)
 
+        self.settings_btn = QtWidgets.QToolButton()
+        self.settings_btn.setIconSize(QSize(21, 21))
+        self.settings_btn.setStyleSheet("background: transparent;")
         if darkdetect.isDark():
-            settings_action = QAction(QIcon(get_asset_path("settings_white.png")), "Settings", self)
+            self.settings_btn.setIcon(QIcon(get_asset_path("settings_white.png")))
         else:
-            settings_action = QAction(QIcon(get_asset_path("settings_black.png")), "Settings", self)
+            self.settings_btn.setIcon(QIcon(get_asset_path("settings_black.png")))
+        self.settings_btn.setToolTip("Settings")
+        self.settings_btn.setCursor(Qt.CursorShape.PointingHandCursor)
+        self.settings_btn.clicked.connect(lambda: settings_dialog(self))
+        
+        self.corner_layout.addWidget(self.settings_btn)
 
-        settings_action.triggered.connect(lambda: settings_dialog(self))
+        self.tab_wrapper = QWidget()
-        toolbar.addAction(settings_action)
+        self.tab_layout = QVBoxLayout()
-        toolbar.addWidget(self.tracker_list)
+        self.tab_layout.setContentsMargins(0, 0, 0, 0)
+        self.tab_layout.setSpacing(0)
+        
 
-        toolbar.setMovable(False)
+        self.tab_bar_layout = QHBoxLayout()
+        self.tab_bar_layout.setContentsMargins(0, 0, 0, 0)
+        self.tab_bar_layout.setSpacing(0)
+
+        self.tab_bar_layout.addWidget(self.tabs.tabBar(), stretch=0)
+        self.tab_bar_layout.addStretch()
+        self.tab_bar_layout.addWidget(self.corner_widget, stretch=0)
+
+        self.tab_layout.addLayout(self.tab_bar_layout)
+        self.tab_layout.addWidget(self.tabs)
+        
+
+        self.tab_wrapper.setLayout(self.tab_layout)
+        
+
+        containerLayout.addWidget(self.tab_wrapper)
+        containerLayout.setAlignment(Qt.AlignmentFlag.AlignTop)
 
-        # self.progressbar.setValue(0)
         self.consoleLog.setReadOnly(True)
         self.consoleLog.setFixedHeight(150)
         containerLayout.addWidget(self.consoleLog)
 
-        self.progress_timer = QTimer()
-        self.progress_timer.timeout.connect(lambda: run_thread(threading.Thread(target=self.update_progress)))
-        self.progress_timer.start(1000)
-
         self.download_timer = QTimer()
-        self.download_timer.timeout.connect(lambda: run_thread(threading.Thread(target=self.download_list_update)))
+        self.download_timer.timeout.connect(self.download_list_update)
         self.download_timer.start(500)
 
+        self.active_timer = QTimer()
+        self.active_timer.timeout.connect(self.show_empty_downloads)
+        self.active_timer.start(500)
+
+        self.context_menu = QtWidgets.QMenu(self)
+        self.context_menu.addAction("Open Containing Folder", self.openFolderAction)
+        self.context_menu.addAction("Copy Magnet URI", self.copyMagnetURIAction)
+        self.context_menu.addAction("Cancel Download", self.cancelDownload)
+
     @staticmethod
     def add_log(text):
         if MainWindow._instance:
@@ -367,6 +485,11 @@ class MainWindow(QtWidgets.QMainWindow, QWidget):
         if self.download_model:
             self.download_model.layoutAboutToBeChanged.emit()
             self.download_model.layoutChanged.emit()
+            for row in range(self.download_model.rowCount()):
+                idx = self.download_model.index(row, 0)
+                self.downloadList.closePersistentEditor(idx)
+                self.downloadList.openPersistentEditor(idx)
+        
 
     def closeEvent(self, event: QCloseEvent):
         closehelper()
@@ -375,18 +498,21 @@ class MainWindow(QtWidgets.QMainWindow, QWidget):
     def set_tracker(self, _):
         state.tracker = self.tracker_list.currentText()
 
-    def update_progress(self):
-        progress = dlprogress()
-        self.progressbar.setValue(progress)
-
     def show_empty_results(self, show: bool):
         if show:
             self.qtablewidget.hide()
             self.emptyResults.show()
         else:
-            self.emptyResults.hide()
             self.qtablewidget.show()
+            self.emptyResults.hide()
 
+    def show_empty_downloads(self):
+        if len(state.active_downloads) > 0:
+            self.emptyDownload.hide()
+            self.downloadList.show()
+        else:
+            self.emptyDownload.show()
+            self.downloadList.hide()
 
     # thank you claude
     def resizeEvent(self, event):
@@ -394,6 +520,65 @@ class MainWindow(QtWidgets.QMainWindow, QWidget):
         table_width = self.qtablewidget.viewport().width()
         self.qtablewidget.setColumnWidth(1, int(table_width * 0.3))
 
+    def contextMenuEvent(self, event: QContextMenuEvent):
+        if self.downloadList.underMouse():
+            pos = self.downloadList.viewport().mapFromGlobal(event.globalPos())
+            index = self.downloadList.indexAt(pos)
+            
+            if index.isValid():
+                row = index.row()
+                self._context_menu_row = row
+                self.context_menu.exec(event.globalPos())
+        else:
+            super().contextMenuEvent(event)
 
+    def openFolderAction(self):
+        if not hasattr(self, '_context_menu_row'):
+            return
+        
+        row = self._context_menu_row
+        if row < 0 or row >= len(state.active_downloads):
+            return
+        
+        magnet_link = list(state.active_downloads.keys())[row]
+        magnetdl = state.active_downloads[magnet_link]
 
-    
+        download_path = magnetdl.save_path()
+        
+        if download_path and os.path.exists(download_path):
+            if platform.system() == "Windows":
+                os.startfile(os.path.normpath(download_path))
+            elif platform.system() == "Linux":
+                subprocess.Popen(["xdg-open", download_path])
+            elif platform.system() == "Darwin":
+                subprocess.Popen(["open", download_path])
+
+    def copyMagnetURIAction(self):
+        if not hasattr(self, '_context_menu_row'):
+            return
+        
+        row = self._context_menu_row
+        if row < 0 or row >= len(state.active_downloads):
+            return
+        
+        magnet_link = list(state.active_downloads.keys())[row]
+        
+        clipboard = QtWidgets.QApplication.clipboard()
+        clipboard.setText(magnet_link)
+
+    def cancelDownload(self):
+        if not hasattr(self, '_context_menu_row'):
+            return
+        
+        row = self._context_menu_row
+        if row < 0 or row >= len(state.active_downloads):
+            return
+        
+        magnet_link = list(state.active_downloads.keys())[row]
+        magnetdl = state.active_downloads[magnet_link]
+
+        confirm = QMessageBox.question(self, "Cancel Download", f"Are you sure you want to cancel the download of '{magnetdl.status().name}'?", QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No)
+        if confirm == QMessageBox.StandardButton.Yes:
+            del state.active_downloads[magnet_link]
+            remove_download_log(magnet_link)
+            consoleLog(f"Cancelled download: {magnetdl.status().name}", True)

core/interface/utils/tabhelper.py

@@ -12,6 +12,6 @@ def create_tab(title, searchbar, software_list, tabs, dlbutton, layout2):
         layout.addWidget(software_list)
     if dlbutton:
         layout.addWidget(dlbutton)
-    tab.setLayout(layout) 
+    tab.setLayout(layout)
     tabs.addTab(tab, title) 
     return tab

core/network/aria2_integration.py

@@ -1,109 +0,0 @@
-import aria2p
-import subprocess
-from core.utils.data.state import state
-from core.utils.general.logs import update_download_completed_by_hash
-from core.utils.general.logs import consoleLog
-from plyer import notification
-import socket
-import time
-import sys
-
-def run_aria2p():
-
-    state.aria2 = aria2p.API(
-        aria2p.Client(
-            host="http://localhost",
-            port=6800,
-            secret=""
-        )
-    )
-    
-    return state.aria2
-
-
-def aria2server():
-    download_path = state.download_path
-    speed_limit = state.speed_limit
-
-    cmd = [
-        "aria2c",
-        "--enable-rpc",
-        "--disable-ipv6", # added this since it caused problems with vpns
-        "--rpc-listen-all",
-        "--rpc-listen-port=6800",
-        f"--dir={download_path}",
-        f"--max-download-limit={speed_limit * 1024}",
-        "-x", str(state.aria2_threads),
-        "-s", str(state.aria2_threads),
-    ]
-    
-    aria2server = subprocess.Popen(
-        cmd,
-        stdout=subprocess.DEVNULL,
-        stderr=subprocess.DEVNULL,
-        creationflags=subprocess.CREATE_NO_WINDOW if sys.platform == 'win32' else 0
-    )
-
-    max_checks = 50
-    for check in range(max_checks):
-        try:
-            sock = socket.socket()
-            sock.settimeout(0.1)
-            sock.connect(("localhost", 6800))
-            sock.close()
-            break
-        except(ConnectionRefusedError, socket.timeout):
-            time.sleep(0.1)
-    else:
-        raise RuntimeError("Aria2 Server failed to start")
-
-    consoleLog("Aria2 Server started")
-    return aria2server
-
-def dlprogress():
-    try:
-        state.downloads = [download for download in state.aria2.get_downloads() if not download.is_metadata]
-        downloads = state.downloads
-        if downloads:
-            for download in downloads:
-                progress = download.progress_string(0)
-                progress_int = int(progress.strip('%'))
-                return progress_int
-        return 0
-    except:
-        return 0
-
-def send_notification(shutdown_event):
-    notified = set()
-    while not shutdown_event.is_set():
-        try:
-            for d in state.aria2.get_downloads():
-                if d.is_metadata:
-                    continue
-                if d.progress == 100 and d.gid not in notified:
-                    notification.notify(
-                        title="Download finished",
-                        message=f"{d.name} has finished downloading.",
-                        timeout=4
-                    )
-                    notified.add(d.gid)
-            state.downloads = [d for d in state.aria2.get_downloads() if d.is_active and not d.is_metadata]
-        except Exception:
-            pass
-        time.sleep(5)
-
-def update_log(shutdown_event):
-    updated = set()
-    while not shutdown_event.is_set():
-        try:
-            for d in state.aria2.get_downloads():
-                if d.is_metadata:
-                    continue
-                if d.progress == 100 and d.gid not in updated:
-                    consoleLog(f"Marking {d.name} as completed")
-                    update_download_completed_by_hash(d.info_hash, True)
-                    updated.add(d.gid)
-            state.downloads = [d for d in state.aria2.get_downloads() if d.is_active and not d.is_metadata]
-        except Exception:
-            pass
-        time.sleep(5)

core/network/aria2_wrapper.py

@@ -1,18 +0,0 @@
-from .aria2_integration import run_aria2p
-from core.utils.data.state import state
-from core.utils.general.logs import consoleLog
-
-def start_client():
-    global aria2
-    aria2 = run_aria2p()
-    consoleLog("Started Aria2p")
-
-def add_magnet(uri):
-    if uri is not None and uri.startswith("magnet:?"):  
-        aria2.add_magnet(uri)
-        consoleLog("Magnet URI added to Aria2")
-    else:
-        consoleLog(f"Invalid Magnet Link: {uri}")
-
-
-

core/network/libtorrent_int.py

@@ -0,0 +1,103 @@
+import time
+from core.utils.general.wrappers import run_thread
+import threading
+import libtorrent as lt
+from core.utils.data.state import state
+from core.utils.general.logs import consoleLog
+
+
+global loop_running
+loop_running = False
+
+def init_session():
+    if state.dl_session is not None:
+        return
+
+    state.dl_session = lt.session()
+
+    settings = {
+        "upload_rate_limit": state.up_speed_limit,
+        "download_rate_limit": state.down_speed_limit,
+        "enable_dht": True,
+        "enable_lsd": True,
+        "enable_upnp": True,
+        "enable_natpmp": True,
+        "dht_bootstrap_nodes": "router.bittorrent.com:6881,dht.transmissionbt.com:6881",
+        "connections_limit": state.max_connections,
+        "active_downloads": state.max_downloads
+    }
+
+    
+
+    state.dl_session.apply_settings(settings)
+
+    consoleLog("Initialized Session")
+
+
+def add_download(magnet_uri, dl_path=state.download_path):
+
+    if state.active_downloads is None:
+        state.active_downloads = {}
+
+    init_session()
+
+    if magnet_uri in state.active_downloads:
+        consoleLog("Skipping, download already running...")
+        return
+
+
+    magnetdl = lt.parse_magnet_uri(magnet_uri)
+    magnetdl.save_path = dl_path
+
+    download = state.dl_session.add_torrent(magnetdl)
+    state.active_downloads[magnet_uri] = download
+    consoleLog(f"Added {magnet_uri} to downloads")
+
+    run_thread(threading.Thread(target=dl_status_loop))
+
+
+
+def dl_status_loop():
+    global loop_running
+    if loop_running == True:
+        return
+    
+    loop_running = True
+    completed_set = set()
+    
+    if not state.active_downloads:
+        consoleLog("No active downloads")
+        loop_running = False
+        return
+    
+    while state.active_downloads:
+        for magnet_uri, magnetdl in list(state.active_downloads.items()):
+            status = magnetdl.status()
+            
+            if status.state == lt.torrent_status.seeding and magnet_uri not in completed_set:
+                consoleLog(f"Download completed: {status.name}")
+                
+                completed_set.add(magnet_uri)
+        
+        if not state.active_downloads:
+            loop_running = False
+            break
+        
+        time.sleep(1)
+    
+    loop_running = False
+
+def update_settings():
+
+    if state.dl_session is None:
+        return
+
+    settings = {
+        "upload_rate_limit": state.up_speed_limit,
+        "download_rate_limit": state.down_speed_limit,
+        "connections_limit": state.max_connections,
+        "active_downloads": state.max_downloads
+    }
+
+    state.dl_session.apply_settings(settings)
+

core/network/libtorrent_misc.py

@@ -0,0 +1,60 @@
+from core.utils.data.state import state
+from core.utils.general.logs import update_download_completed_by_hash
+from core.utils.general.logs import consoleLog
+from plyer import notification
+import libtorrent as lt
+import time
+
+
+def cleanup_session():
+    if state.dl_session is not None:
+        for magnetdl in state.active_downloads.values():
+            if hasattr(magnetdl, 'pause'):  # Check it's a handle
+                magnetdl.pause()
+        
+        del state.dl_session
+        state.dl_session = None
+        state.active_downloads.clear()
+
+
+
+
+def send_notification(shutdown_event):
+    notified = set()
+    while not shutdown_event.is_set():
+        try:
+            for magnet_uri, magnetdl in list(state.active_downloads.items()):
+                if isinstance(magnetdl, dict):
+                    continue
+                
+                status = magnetdl.status()
+                
+                if status.state == lt.torrent_status.seeding and magnet_uri not in notified:
+                    notification.notify(
+                        title="Download finished",
+                        message=f"{status.name} has finished downloading.",
+                        timeout=4
+                    )
+                    notified.add(magnet_uri)
+        except Exception:
+            pass
+        time.sleep(5)
+
+def update_log(shutdown_event):
+    updated = set()
+    while not shutdown_event.is_set():
+        try:
+            for magnet_uri, magnetdl in list(state.active_downloads.items()):
+                if isinstance(magnetdl, dict):
+                    continue
+                
+                status = magnetdl.status()
+                
+                if status.state == lt.torrent_status.seeding and magnet_uri not in updated:
+                    consoleLog(f"Marking {status.name} as completed")
+                    info_hash = str(status.info_hash)
+                    update_download_completed_by_hash(info_hash, True)
+                    updated.add(magnet_uri)
+        except Exception:
+            pass
+        time.sleep(5)

core/network/libtorrent_wrapper.py

@@ -0,0 +1,12 @@
+from core.utils.general.logs import consoleLog
+from core.network.libtorrent_int import add_download
+
+def add_magnet(uri):
+    if uri is not None and uri.startswith("magnet:?"):  
+        add_download(uri)
+        consoleLog("Magnet URI added to LibTorrent")
+    else:
+        consoleLog(f"Invalid Magnet Link: {uri}")
+
+
+

core/utils/config/config.py

@@ -6,8 +6,19 @@ from core.utils.data.state import state
 def create_config():
     config = configparser.ConfigParser()
 
-    config["General"] = {"debug": True, "api_url": f"{state.api_url}", "aria2_threads": f"{state.aria2_threads}", "download_path": f"{state.download_path}", f"speed_limit": f"{state.speed_limit}", 
+    config["General"] = {
-                         "ignore_updates": f"{state.ignore_updates}", "image_path": f"{state.image_path}", "autoresume": f"{state.autoresume}"}
+        "debug": True,
+        "api_url": f"{state.api_url}",
+        "download_path": f"{state.download_path}",
+        "download_speed_limit": f"{state.down_speed_limit}",
+        "upload_speed_limit": f"{state.up_speed_limit}", 
+        "ignore_updates": f"{state.ignore_updates}",
+        "image_path": f"{state.image_path}",
+        "autoresume": f"{state.autoresume}",
+        "max_connections": f"{state.max_connections}",
+        "max_downloads": f"{state.max_downloads}",
+        "window_transparency": f"{state.window_transparency}",
+    }
 
     if platform.system() == "Windows":
         config_dir = os.environ.get("APPDATA", os.path.expanduser("~\\AppData\\Roaming"))
@@ -40,11 +51,14 @@ def read_config():
 
     state.debug = config.getboolean("General", "debug", fallback=state.debug)
     state.api_url = config.get("General", "api_url", fallback=state.api_url)
-    state.aria2_threads = config.getint("General", "aria2_threads", fallback=state.aria2_threads)
     state.download_path = config.get("General", "download_path", fallback=state.download_path)
-    state.speed_limit = config.getint("General", "speed_limit", fallback=state.speed_limit)
+    state.down_speed_limit = config.getint("General", "download_speed_limit", fallback=state.down_speed_limit)
+    state.up_speed_limit = config.getint("General", "upload_speed_limit", fallback=state.up_speed_limit)
     state.ignore_updates = config.getboolean("General", "ignore_updates", fallback=state.ignore_updates)
     state.image_path = config.get("General", "image_path", fallback=state.image_path)
     state.autoresume = config.getboolean("General", "autoresume", fallback=state.autoresume)
+    state.max_connections = config.getint("General", "max_connections", fallback=state.max_connections)
+    state.max_downloads = config.getint("General", "max_downloads", fallback=state.max_downloads)
+    state.window_transparency = config.getboolean("General", "window_transparency", fallback=state.window_transparency)
 
-    create_config()
+    create_config()

core/utils/config/settings.py

@@ -1,33 +1,29 @@
+from core.network.libtorrent_int import update_settings
 from core.utils.data.state import state
-from core.utils.general.shutdown import kill_aria2server
+from core.utils.general.logs import consoleLog
 from .config import create_config
 
-def restart_aria2c():
-    import main # had to do this because of circle import :(
-    import signal
-    import atexit
-    kill_aria2server()
-    state.aria2process.wait()
-    state.aria2process = main.run_aria2server()
-    signal.signal(signal.SIGINT, main.keyboardinterrupthandler)
-    atexit.unregister(kill_aria2server)
-    atexit.register(kill_aria2server)
 
-def save_settings(thread_count=None, close=lambda: None, apiurl=None, download_path=None, speed_limit=None, image_path=None, autoresume=None):
+def save_settings(close=lambda: None, apiurl=None, download_path=None, down_speed_limit=None, up_speed_limit=None, image_path=None, autoresume=None, max_connections=None, max_downloads=None):
-    if thread_count is not None:
-        state.aria2_threads = thread_count
     if apiurl is not None:
         state.api_url = apiurl
     if download_path is not None:
         state.download_path = download_path
-    if speed_limit is not None:
+    if down_speed_limit is not None:
-        state.speed_limit = speed_limit
+        state.down_speed_limit = down_speed_limit
+    if up_speed_limit is not None:
+        state.up_speed_limit = up_speed_limit
     if image_path is not None:
         state.image_path = image_path
     if autoresume is not None:
         state.autoresume = autoresume
+    if max_connections is not None:
+        state.max_connections = max_connections
+    if max_downloads is not None:
+        state.max_downloads = max_downloads
     
-    
+
+    update_settings()
+    consoleLog("Saved Settings")
     create_config()
-    restart_aria2c()
     close()

core/utils/data/state.py

@@ -11,7 +11,6 @@ class AppState(QObject):
         self.post_titles: List[str] = []
         self.post_urls: List[str] = []
         self.post_author: List[str] = []
-        self.downloads: List[str] = []
         self.version: str = "dev"
         self._image_path: str = ""
         self.ignore_updates: bool = False
@@ -20,12 +19,14 @@ class AppState(QObject):
         self.tracker: str = "rutracker"
         self.api_url: str = "https://api.michijackson.xyz"
         self.download_path: str = str(Path.home() / "Downloads")
-        self.speed_limit: int = 0
+        self.up_speed_limit: int = 0
-        self.aria2process: Optional[Any] = None
+        self.down_speed_limit: int = 0
-        self.aria2: Any = None
+        self.max_connections: int = 200
-        self.aria2p: Any = None
+        self.max_downloads: int = 10
-        self.aria2_threads: int = 4
         self.settings_path: str = None
+        self.dl_session: Any = None
+        self.active_downloads: List[str] = {}
+        self.window_transparency: bool = False
 
     @property
     def image_path(self) -> str:

core/utils/general/logs.py

@@ -41,6 +41,30 @@ def add_download_log(title, url, magnet_uri, completed) -> DownloadList:
     
     return download_list
 
+def remove_download_log(magnet_uri) -> DownloadList:
+    downloads_file = os.path.join(state.settings_path, "downloads.json")
+    
+    if os.path.exists(downloads_file) and os.path.getsize(downloads_file) > 0:
+        try:
+            with open(downloads_file, "r") as file:
+                existing_data = json.load(file)
+                downloads = [Download(**d) for d in existing_data.get("data", [])]
+        except json.JSONDecodeError:
+            downloads = []
+    else:
+        downloads = []
+
+    magnet_link = (magnet_uri or "").strip()
+    downloads = [d for d in downloads if (getattr(d, 'magnet_uri', None) or "").strip() != magnet_link and (getattr(d, 'url', None) or "").strip() != magnet_link]
+
+    consoleLog(f"Removed {magnet_link} from Log File")
+
+    download_list = DownloadList(data=downloads, count=len(downloads))
+    with open(downloads_file, "w") as file:
+        json.dump(asdict(download_list), file, indent=4)
+    
+    return download_list
+
 def update_download_completed(magnet_uri, completed) -> DownloadList:
     downloads_file = os.path.join(state.settings_path, "downloads.json")
     
@@ -176,4 +200,4 @@ def consoleLog(text, printAnyways = False):
         pass
     
     if state.debug or printAnyways:
-        print(f"[{current_time}] {text}")
+        print(f"[{current_time}] {text}")

core/utils/general/shutdown.py

@@ -1,30 +1,9 @@
-from core.utils.data.state import state
-from core.utils.general.logs import consoleLog
 import threading
-import psutil
+from core.network.libtorrent_misc import cleanup_session
-import sys
+from core.utils.general.wrappers import run_thread
-
 
 shutdown_event = threading.Event()
 
-def kill_aria2server():
-    if sys.platform.startswith("win"):
-        process = "aria2c.exe"
-    else:
-        process = "aria2c"
-
-    if state.aria2process:
-        state.aria2process.kill()
-        consoleLog("Killed Aria2")
-            
-    try:
-        for proc in psutil.process_iter():
-            if proc.name() == process:
-                proc.kill()
-                consoleLog(f"Killed Aria2c (PID {proc.pid})")
-    except psutil.NoSuchProcess:
-        pass
-
 def closehelper():
-    shutdown_event.set()
+    run_thread(threading.Thread(target=cleanup_session))
-    kill_aria2server()
+    shutdown_event.set()

core/utils/network/download.py

@@ -2,8 +2,7 @@ from core.utils.data.state import state
 from core.utils.general.logs import consoleLog
 from core.utils.data.tracker import get_item_url
 from core.utils.data.tracker import get_magnet_link
-from core.network.aria2_wrapper import start_client
+from core.network.libtorrent_wrapper import add_download
-from core.network.aria2_wrapper import add_magnet
 from core.utils.general.wrappers import run_thread
 from core.utils.general.logs import add_download_log
 
@@ -21,13 +20,12 @@ def run_download(item, posts, post_titles):
     post_url = get_item_url(item, posts, post_titles)
     consoleLog(f"Selected URL: {post_url}")
     magnet_uri = get_magnet_link(post_url)
-    start_client()
+
     add_download_log(item, post_url, magnet_uri, False)
-    add_magnet(magnet_uri)
+    add_download(magnet_uri)
 
 def run_download_direct(magnet_uri):
-    start_client()
+    add_download(magnet_uri)    
-    add_magnet(magnet_uri)    
 
 
 

main.py

@@ -1,44 +1,40 @@
 from core.interface.gui import MainWindow
 from core.utils.data.state import state
 from core.utils.general.logs import consoleLog
-from core.network.aria2_integration import aria2server
+from core.network.libtorrent_misc import send_notification, update_log
-from core.network.aria2_integration import send_notification, update_log
 from core.utils.general.logs import get_download_logs
 from core.utils.general.shutdown import closehelper, shutdown_event
 from core.utils.general.wrappers import run_thread
 from core.utils.general.loghandler import split_data, check_completed
 from core.utils.config.config import read_config
 from PySide6 import QtWidgets
+from PySide6.QtCore import Qt
 import qdarktheme
-import darkdetect
 import threading
+import platform
 import signal
 import argparse
 import sys
 
 
 parser = argparse.ArgumentParser()
-parser.add_argument("--debug", action="store_true") 
+parser.add_argument("--debug", action="store_true")
 args = parser.parse_args()
 
 def run_gui():
-    app = QtWidgets.QApplication([])
+    app = QtWidgets.QApplication.instance() or QtWidgets.QApplication(sys.argv)
-    if darkdetect.isDark:
+    qdarktheme.setup_theme("auto")
-        app.setStyleSheet(qdarktheme.load_stylesheet("dark"))
-    else:
-        app.setStyleSheet(qdarktheme.load_stylesheet("light"))
     widget = MainWindow()
+    
+    if state.window_transparency and platform.system() != "Windows":
+        widget.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground)
+        qdarktheme.setup_theme("auto", custom_colors={"background": "#00000000"})
 
     from core.utils.general.logs import set_main_window
     set_main_window(widget)
-
     widget.show()
     sys.exit(app.exec())
 
-def run_aria2server():
-    aria2process = aria2server()
-    return aria2process
-
 def keyboardinterrupthandler(signum, frame):
     closehelper()
 
@@ -48,8 +44,6 @@ if __name__ == "__main__":
     count, downloads = split_data(logs)
     if args.debug:
         state.debug = args.debug # override of read_config
-    consoleLog("Starting Aria2 Server")
-    state.aria2process = run_aria2server()
     signal.signal(signal.SIGINT, keyboardinterrupthandler)
     run_thread(threading.Thread(target=send_notification, args=(shutdown_event,), daemon=True))
     consoleLog("Started send_notification thread")

requirements.txt

@@ -1,10 +1,11 @@
 requests==2.32.2
 PySide6==6.10.1
 beautifulsoup4==4.13.5
-darkdetect==0.8.0
+darkdetect==0.7.1
-aria2p==0.12.1
 pyinstaller==6.15.0
-pyqtdarktheme==0.1.7
+PyQtDarkTheme-fork==2.3.4
 aiohttp==3.13.0
 plyer==2.1.0
 psutil==7.1.0
+libtorrent==2.0.11
+libtorrent-windows-dll==0.0.3