Update renderer.js

use executableName only when it is available in electron-builder stable

.github/workflows/build-linux.yml

@@ -0,0 +1,76 @@
+name: Build Linux
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  build_x64:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+
+      - run: npm install
+        working-directory: simpliplay
+
+      - run: npx electron-builder --linux --x64
+        working-directory: simpliplay
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: linux-x64-snap
+          path: simpliplay/dist/*.snap
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: linux-x64-appimage
+          path: simpliplay/dist/*.AppImage
+
+  build_arm64:
+    runs-on: ubuntu-22.04-arm
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+
+      - name: Use ARM64 package.json
+        run: |
+          mv simpliplay/package.json simpliplay/package-unused.json
+          mv simpliplay/package-arm64-linux.json simpliplay/package.json
+
+      - run: npm install
+        working-directory: simpliplay
+
+      - run: npx electron-builder --linux AppImage --arm64
+        working-directory: simpliplay
+
+      - run: sudo apt-get update && sudo apt-get install --only-upgrade libgdk-pixbuf-2.0-0
+
+      - run: sudo snap install snapcraft --classic
+
+      - run: sudo snap install gnome-3-28-1804
+
+      - run: sudo snap install gtk-common-themes
+
+      - run: sudo snap install core22
+
+      - run: SNAPCRAFT_BUILD_ENVIRONMENT=host USE_SYSTEM_FPM=true npx electron-builder --linux snap --arm64
+        working-directory: simpliplay
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: linux-arm64-appimage
+          path: simpliplay/dist/*.AppImage
+          
+      - uses: actions/upload-artifact@v4
+        with:
+          name: linux-arm64-snap
+          path: simpliplay/dist/*.snap

.github/workflows/build-macos.yml

@@ -0,0 +1,41 @@
+name: Build macOS
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  build:
+    runs-on: macos-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 22
+
+      - name: Clean up caches
+        run: |
+          npm cache clean --force
+          rm -rf ~/Library/Caches/electron-builder
+        working-directory: simpliplay
+
+      - name: Install dependencies
+        run: npm install
+        working-directory: simpliplay
+
+      - name: Create DMGs
+        run: npx electron-builder --mac --x64 --arm64 --universal
+        working-directory: simpliplay
+
+      - name: Upload artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: builds
+          # Upload only the final signed DMGs
+          path: simpliplay/dist/*.dmg

.github/workflows/build-win.yml

@@ -0,0 +1,64 @@
+name: Build Windows
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  build-x64:
+    runs-on: windows-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 22
+
+      - name: Install dependencies
+        run: npm install
+        working-directory: simpliplay
+
+      - name: Build Windows (x64)
+        env:
+          CSC_IDENTITY_AUTO_DISCOVERY: false
+        run: npx electron-builder --win --x64
+        working-directory: simpliplay
+
+      - name: Upload artifacts (x64)
+        uses: actions/upload-artifact@v4
+        with:
+          name: builds-x64
+          path: simpliplay/dist/
+
+  build-arm64:
+    runs-on: windows-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 22
+
+      - name: Install dependencies
+        run: npm install
+        working-directory: simpliplay
+
+      - name: Build Windows (arm64)
+        env:
+          CSC_IDENTITY_AUTO_DISCOVERY: false
+        run: npx electron-builder --win --arm64
+        working-directory: simpliplay
+
+      - name: Upload artifacts (arm64)
+        uses: actions/upload-artifact@v4
+        with:
+          name: builds-arm64
+          path: simpliplay/dist/

.github/workflows/draft-release.yml

@@ -0,0 +1,129 @@
+name: Draft Release
+
+on:
+  workflow_dispatch:
+
+jobs:
+  create-draft-release:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Prepare folder
+        run: mkdir -p all-artifacts
+
+      - name: Poll for expected artifacts
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          set -e
+          echo "Polling (every 15 seconds) until all required artifacts are available..."
+
+          REQUIRED=("linux-x64-appimage" "linux-x64-snap" "linux-arm64-snap" "builds" "builds-x64" "builds-arm64")
+
+          while true; do
+            echo "⏳ Checking artifacts..."
+
+            rm -rf all-artifacts
+            mkdir -p all-artifacts
+
+            gh run download --dir all-artifacts || true
+
+            missing=0
+            for ARTIFACT in "${REQUIRED[@]}"; do
+              if [ ! -d "all-artifacts/$ARTIFACT" ]; then
+                echo "❌ Missing: $ARTIFACT"
+                missing=1
+              fi
+            done
+
+            if [ "$missing" -eq 0 ]; then
+              echo "✅ All required artifacts found."
+              break
+            fi
+
+            echo "🔁 Not all artifacts were found. Retrying in 15 seconds..."
+            sleep 15
+          done
+
+      - name: Extract ZIP files and prepare list of files to upload
+        run: |
+          set -e
+          echo "🔍 Extracting ZIP files and collecting allowed SimpliPlay files..."
+
+          find all-artifacts -type f -name '*.zip' | while read -r zipfile; do
+            extract_dir="${zipfile%.zip}"
+            echo "📦 Extracting $zipfile to $extract_dir"
+            unzip -o "$zipfile" -d "$extract_dir"
+          done
+
+          rm -f upload-files.txt
+          find all-artifacts -type f \( -iname '*.exe' -o -iname '*.dmg' -o -iname '*.AppImage' \) | grep 'SimpliPlay' > upload-files.txt
+
+          echo "Filtered files to upload:"
+          cat upload-files.txt
+
+      - name: Create empty draft release
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: "draft-${{ github.run_number }}"
+          draft: true
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Rename files if duplicates exist on release
+        id: rename
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          set -e
+          sanitize_filename() {
+            echo "$1" | tr ' ' '-'
+          }
+
+          release_tag="draft-${{ github.run_number }}"
+          existing_assets=$(gh release view "$release_tag" --json assets --jq '.assets[].name' || echo "")
+          echo "Existing assets on release $release_tag:"
+          echo "$existing_assets"
+
+          rm -f upload-files-renamed.txt
+          touch upload-files-renamed.txt
+
+          while IFS= read -r filepath; do
+            filename=$(basename "$filepath")
+            dirname=$(basename "$(dirname "$filepath")")
+
+            safe_filename=$(sanitize_filename "$filename")
+
+            if echo "$existing_assets" | grep -qx "$safe_filename"; then
+              extension="${filename##*.}"
+              name="${filename%.*}"
+              safe_name=$(sanitize_filename "$name")
+              newname="${safe_name}-${dirname}.${extension}"
+              echo "Renaming $filename to $newname because it exists in release"
+              cp "$filepath" "all-artifacts/$newname"
+              echo "all-artifacts/$newname" >> upload-files-renamed.txt
+            else
+              if [[ "$filename" != "$safe_filename" ]]; then
+                cp "$filepath" "all-artifacts/$safe_filename"
+                echo "all-artifacts/$safe_filename" >> upload-files-renamed.txt
+              else
+                echo "$filepath" >> upload-files-renamed.txt
+              fi
+            fi
+          done < upload-files.txt
+
+          echo "Final list of files to upload:"
+          cat upload-files-renamed.txt
+
+      - name: Upload assets to draft release
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          set -e
+          release_tag="draft-${{ github.run_number }}"
+          while IFS= read -r filepath; do
+            echo "Uploading $filepath"
+            gh release upload "$release_tag" "$filepath" --clobber
+          done < upload-files-renamed.txt

ADDONS.md

@@ -0,0 +1,6 @@
+# Addons
+Addons in SimpliPlay desktop are a new feature introduced in v2.0.4. They are simply regular JavaScript files with the `.simpliplay` extension.
+
+The process of loading an addon adds a script element with the src tag, along with other necessary info to distinguish it from a non-addon script tag.
+When you unload an addon, it removes this element, but any lasting effects created by the addon (such as changing the app's background color) will last until you restart the app (closing and opening it again).
+Non-lasting effects, like context menus (that use event listeners), will disappear upon unloading.

README.md

@@ -1,20 +1,30 @@
 # simpliplay-desktop
-The desktop version of SimpliPlay.
+The desktop version of SimpliPlay, a simple, cross-platform media player.
 
 ## simpliplay
 [Electron](https://electronjs.org) version of SimpliPlay for Windows, macOS, and Linux (x64 and ARM64).
 
 ## [simpliplay-lite](https://github.com/A-Star100/simpliplay-desktop/tree/lite)
 [Neutralinojs](https://neutralino.js.org) version of SimpliPlay (significantly smaller filesize) for Windows (x64 only), macOS, and Linux (both x64 and ARM64).
+> [!WARNING]
+> This version of SimpliPlay has been [officially discontinued](https://simpliplay.netlify.app/docs/blog/lite-ver-end) and **will not** receive any more security updates.
+> It is still stable and secure, but has not received a few patches (e.g, the infamous **[memory leak issue](https://github.com/A-Star100/simpliplay-desktop/issues/4)**) that the web version, Chrome extension, and main desktop version all have.
 
 ## [simpliplay-nwjs](https://github.com/A-Star100/simpliplay-desktop/tree/nwjs)
 [NW.js](https://nwjs.io) version of SimpliPlay for Windows, macOS, and Linux (x64 and ARM64).
-> [!WARNING]
+> [!IMPORTANT]
 > This version is an example NW.js configuration, it won't be used in production, but you can use it if you would like. Files in this version won't be updated, so refer to files from the Electron release for production usage.
 
+## [simpliplay-legacy](https://github.com/A-Star100/simpliplay-desktop/tree/legacy)
+[Legacy](https://simpliplay.netlify.app/legacy) version of SimpliPlay for Windows, macOS, and Linux (x64 and x86).
+> [!CAUTION]
+> This version uses a very old, legacy version of NW.js that supports Windows XP and macOS 10.6 or later.
+> Unless the main desktop version isn't supported on your operating system, **please don't use the legacy version**, it will open you up to **security issues** on newer devices!
 ___
 
 ## Setup
-Read the docs ([Electron - Quick Start](https://www.electronjs.org/docs/latest/tutorial/quick-start), [Neutralinojs - Your First App](https://neutralino.js.org/docs/getting-started/your-first-neutralinojs-app), [NW.js - Getting Started (For Users)](https://nwjs.readthedocs.io/en/latest/For%20Users/Getting%20Started/#write-nwjs-app))
-
+Read the docs ([Electron - Tutorial](https://www.electronjs.org/docs/latest/tutorial/tutorial-prerequisites), [Neutralinojs - Your First App](https://neutralino.js.org/docs/getting-started/your-first-neutralinojs-app), [NW.js - Getting Started (For Users)](https://nwjs.readthedocs.io/en/latest/For%20Users/Getting%20Started/#write-nwjs-app))
 
+## Mirrors
+Self-hosted mirror available [here](https://new-git.anirudhsevugan.me/anirudh/simpliplay-desktop/src/branch/main/).
+**The server may not always be up. If it isn't, you can contact me at: (personal at anirudhsevugan dot me)**.

simpliplay/README.txt

@@ -1 +1,11 @@
+Source code for SimpliPlay.
 
+--BUILD STUFF--
+SimpliPlay uses Electron Builder for desktop builds, but includes an example Electron Forge config that will work as expected but does not support native actions such as file picking from the explorer; the package.json uses electron-builder specific actions for that.
+
+--CI/CD--
+We now use CI/CD (specifically GitHub Actions, at one point CircleCI) for builds, but Linux ARM64 snaps in particular were annoying to get started with. After multiple attempts, it finally worked as expected (with a few really stupid workarounds required that shouldn't even be needed).
+
+--DEPENDENCIES--
+Other than Electron and Electron Builder, there is one more dependency called "Nothing".
+Its name is very self explanatory, isn't it?

simpliplay/index-es.html

@@ -0,0 +1,105 @@
+<!DOCTYPE html>
+<html lang="es">
+<head>
+  <!-- this is the Spanish version of SimpliPlay, you can find the translation status at https://crowdin.com/project/simpliplay -->
+  <script src="player-es.js"></script>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <meta http-equiv="Content-Security-Policy" content="
+  default-src 'self'; 
+  script-src 'self'; 
+  style-src 'self'; 
+  img-src 'self' data:; 
+  media-src * blob: file:; 
+  connect-src *;
+  font-src 'self'; 
+  object-src 'none'; 
+  child-src 'none'; 
+  form-action 'self';
+  worker-src 'self' blob:;
+">
+
+<link rel="icon" type="image/x-icon" href="images/favicon.ico">
+  <link rel="stylesheet" href="styles.css">
+  <script src="lib/dash.js"></script>
+  <script src="lib/hls.js"></script>
+  <!--<script src="lib/midi.js"></script>-->
+  <title>SimpliJuega</title>
+</head>
+
+<body>
+  
+  <h1>SimpliJuega</h1>
+  <div class="dialog-overlay" id="dialogOverlay">
+    <div class="dialog">
+      <p>Seleccione cómo desea cargar los medios:</p>
+      <button id="chooseFileBtn">Seleccionar un archivo</button>
+      <button id="enterUrlBtn">Introduzca una URL</button>
+      <button id="hideDialogBtn">Volver atrás</button>
+      <input type="file" id="fileInput" accept="video/*,audio/*">
+    </div>
+  </div>
+
+  <div class="dialog-overlay" id="urlDialogOverlay">
+    <div class="dialog">
+      <p>Introduzca la URL del medio:</p>
+      <input type="url" id="urlInput" placeholder="Introduzca aquí la URL del medio">
+      <button id="submitUrlBtn">Enviar</button>
+      <button id="cancelUrlBtn">Cancelar</button>
+    </div>
+  </div>
+
+  <div class="subtitles-overlay" id="subtitlesOverlay">
+    <div class="subtitles-dialog">
+      <p>Introduzca la URL de los subtítulos:</p>
+      <input type="url" id="subtitlesInput" placeholder="Introduzca aquí la URL de los subtítulos">
+      <button id="submitSubtitlesBtn">Enviar</button>
+      <button id="cancelSubtitlesBtn">Cancelar</button>
+    </div>
+  </div>
+
+  <video id="mediaPlayer" autoplay controls></video>
+
+<midi-player
+  src=""
+  sound-font visualizer="#myVisualizer"
+  id="midiplayer"
+  >
+</midi-player>
+<midi-visualizer type="piano-roll" id="myVisualizer"></midi-visualizer>
+
+  <div id="customControls">
+    <button id="playPauseBtn">Pausa</button>
+    <input type="range" id="seekBar" min="0" value="0" step="0.1">
+    <span id="timeDisplay">00:00 / 00:00</span>
+    <button id="volumeBtn">🔊</button>
+    <input type="range" id="volumeBar" min="0" max="1" step="0.1" value="1">
+    <button id="fullscreenBtn">⛶</button>
+    <button id="ccBtn">Añadir subtítulos</button>  <!-- CC button -->
+  </div>
+
+  <div class="gap-box"></div>
+  <button id="showDialogBtn">Reproduce más contenido multimedia</button>
+
+  <!-- Settings gear button -->
+  <button id="settingsBtn">⚙️</button>
+
+  <!-- Settings panel -->
+  <div class="dialog-overlay" id="settingsDialogOverlay">
+  <div id="settingsPanel">
+    <label for="autoplayCheckbox">Reproducción automática:</label>
+    <input type="checkbox" id="autoplayCheckbox" checked><br>
+    <label for="loopCheckbox">Bucle:</label>
+    <input type="checkbox" id="loopCheckbox"><br>
+    <label for="controlsCheckbox">Controles:</label>
+    <input type="checkbox" id="controlsCheckbox" checked><br>
+    <label for="controlsCheckbox">Colores vivos:</label>
+    <input type="checkbox" id="colorsCheckbox"><br>
+    <p class="settings-info"><em>La configuración solo se aplica a esta sesión.</em></p>
+    <button id="saveSettingsBtn">Guardar configuración</button>
+  </div>
+  </div>
+  <script src="./renderer.js"></script>
+</body>
+
+</html>

simpliplay/main-es.js

@@ -0,0 +1,462 @@
+const { app, BrowserWindow, Menu, MenuItem, shell, dialog, globalShortcut } = require('electron');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const { pathToFileURL } = require("url");
+const { checkForUpdate } = require('./updateChecker');
+let gpuAccel = "";
+let didRegisterShortcuts = false;
+let version = "2.1.3.0"
+
+if (process.platform === 'darwin') {
+  if (process.argv.includes('--use-gl')) {
+    app.commandLine.appendSwitch('disable-features', 'Metal');
+    app.commandLine.appendSwitch('use-gl', 'desktop');
+  } 
+}
+
+// random change just to make sure that snapcraft releases fixed version on new channel to delete arm64 versions
+
+let mainWindow;
+if (process.argv.includes('--disable-gpu')) {
+  app.disableHardwareAcceleration();
+  gpuAccel = "disabled";
+}
+
+// Handle file opening from Finder or File Explorer
+app.on('open-file', (event, filePath) => {
+  event.preventDefault();
+  openFile(filePath);
+});
+
+const openFile = (filePath) => {
+  app.whenReady().then(() => {
+    const fileURL = pathToFileURL(filePath).href;
+
+    if (mainWindow) {
+      if (mainWindow.webContents.isLoading()) {
+        mainWindow.webContents.once("did-finish-load", () => {
+          mainWindow.webContents.send("play-media", fileURL);
+        });
+      } else {
+        mainWindow.webContents.send("play-media", fileURL);
+      }
+    } else {
+      createWindow(() => {
+        mainWindow.webContents.send("play-media", fileURL);
+      });
+    }
+  });
+};
+
+
+const takeSnapshot = async () => {
+  if (!mainWindow) return;
+
+  try {
+    const image = await mainWindow.webContents.capturePage();
+    const png = image.toPNG();
+    const snapshotsDir = path.join(os.homedir(), 'simpliplay-snapshots');
+    fs.mkdirSync(snapshotsDir, { recursive: true });
+    const filePath = path.join(snapshotsDir, `snapshot-${Date.now()}.png`);
+    fs.writeFileSync(filePath, png);
+
+    const { response } = await dialog.showMessageBox(mainWindow, {
+      type: 'info',
+      title: 'Instantánea guardada',
+      message: `Instantánea guardada en:\n${filePath}`,
+      buttons: ['Vale', 'Abrir archivo'],
+      defaultId: 0,
+    });
+
+    if (response === 1) shell.openPath(filePath);
+  } catch (error) {
+    dialog.showErrorBox("Error de instantánea", `No se pudo capturar la instantánea: ${error.message}`);
+  }
+};
+
+const createWindow = (onReadyCallback) => {
+  if (!app.isReady()) {
+    app.whenReady().then(() => createWindow(onReadyCallback));
+    return;
+  }
+
+  if (mainWindow) mainWindow.close();
+
+  mainWindow = new BrowserWindow({
+    width: 1920,
+    height: 1080,
+    webPreferences: {
+      preload: path.join(__dirname, "preload.js"),
+      contextIsolation: true,
+      enableRemoteModule: false,
+      nodeIntegration: false, // Keep this false for security
+      sandbox: true,
+    },
+  });
+
+  mainWindow.loadFile("index.html");
+
+  if (process.platform === 'darwin') {
+    if (process.argv.includes('--use-gl')) {
+      mainWindow.webContents.on('did-finish-load', () => {
+        mainWindow.webContents.executeJavaScript("navigator.userAgent").then(ua => {
+          console.log("User Agent:", ua);
+        });
+
+        mainWindow.webContents.executeJavaScript("chrome.loadTimes ? chrome.loadTimes() : {}").then(loadTimes => {
+          console.log("GPU Info (legacy):", loadTimes);
+        });
+      });
+    }
+  }
+
+  mainWindow.once("ready-to-show", () => {
+
+  if (gpuAccel === "disabled") {
+      dialog.showMessageBox(mainWindow, {
+    type: 'warning',
+    buttons: ['Vale'],
+    defaultId: 0,
+    title: '¡Atención!',
+    message: "Desactivar la aceleración de la GPU reduce considerablemente el rendimiento y no es recomendable, pero si tienes curiosidad, no voy a impedírtelo.",
+  });
+  } 
+
+    if (onReadyCallback) onReadyCallback();
+  });
+
+  setupContextMenu();
+};
+
+
+// Set up context menu (prevents errors if `mainWindow` is undefined)
+const setupContextMenu = () => {
+  if (!mainWindow) return;
+
+  const contextMenu = new Menu();
+  contextMenu.append(new MenuItem({ label: 'Toma una instantánea', click: takeSnapshot }));
+  contextMenu.append(new MenuItem({ type: 'separator' }));
+  contextMenu.append(new MenuItem({ label: 'Inspeccionar', click: () => mainWindow.webContents.openDevTools() }));
+
+  mainWindow.webContents.on('context-menu', (event) => {
+    event.preventDefault();
+    contextMenu.popup({ window: mainWindow });
+  });
+};
+
+
+// Set up application menu
+const setupMenu = () => {
+  const menu = Menu.getApplicationMenu();
+  if (!menu) return;
+
+  const fileMenu = menu.items.find(item => item.label === 'File');
+  if (fileMenu && !fileMenu.submenu.items.some(item => item.label === 'Toma una instantánea')) {
+    fileMenu.submenu.append(new MenuItem({ label: 'Toma una instantánea', accelerator: 'CommandOrControl+Shift+S', click: takeSnapshot }));
+  }
+
+  const appMenu = menu.items.find(item => item.label === 'SimpliPlay');
+
+if (appMenu && !appMenu.submenu.items.some(item => item.label === 'Buscar actualizaciones')) {
+  const submenu = appMenu.submenu;
+  const separatorIndex = submenu.items.findIndex(item => item.type === 'separator');
+
+  const updateMenuItem = new MenuItem({
+    label: 'Buscar actualizaciones',
+    accelerator: 'CommandOrControl+Shift+U',
+    click: () => checkForUpdate(version)
+  });
+
+  if (separatorIndex === -1) {
+    // No separator found — just append
+    submenu.append(updateMenuItem);
+  } else {
+    // Insert right before the separator
+    submenu.insert(separatorIndex, updateMenuItem);
+  }
+}
+
+
+  const helpMenu = menu.items.find(item => item.label === 'Help');
+  if (helpMenu) {
+    const addMenuItem = (label, url) => {
+      if (!helpMenu.submenu.items.some(item => item.label === label)) {
+        helpMenu.submenu.append(new MenuItem({ label, click: () => shell.openExternal(url) }));
+      }
+    };
+
+    addMenuItem('Código fuente', 'https://github.com/A-Star100/simpliplay-desktop');
+    addMenuItem('Sitio web', 'https://simpliplay.netlify.app');
+    addMenuItem('Centro de ayuda', 'https://simpliplay.netlify.app/help');
+
+    // Check for Updates
+  if (!helpMenu.submenu.items.some(item => item.label === 'Buscar actualizaciones')) {
+    helpMenu.submenu.append(
+      new MenuItem({
+        label: 'Buscar actualizaciones',
+        accelerator: 'CommandOrControl+Shift+U',
+        click: () => checkForUpdate(version)
+      })
+    );
+  }
+
+    if (!helpMenu.submenu.items.some(item => item.label === 'Salir')) {
+      helpMenu.submenu.append(new MenuItem({ type: 'separator' }));
+      helpMenu.submenu.append(new MenuItem({ label: 'Salir', click: () => app.quit() }));
+    }
+  }
+
+const loadedAddons = new Map(); // key: addon filepath, value: MenuItem
+
+const newMenuItems = menu ? [...menu.items] : [];
+
+let addonsMenu;
+
+// Check if Add-ons menu already exists
+const existingAddonsMenuItem = newMenuItems.find(item => item.label === 'Add-ons');
+
+if (existingAddonsMenuItem) {
+  addonsMenu = existingAddonsMenuItem.submenu;
+} else {
+  addonsMenu = new Menu();
+
+  // "Load Add-on" menu item
+  addonsMenu.append(new MenuItem({
+    label: 'Cargar complemento',
+    accelerator: 'CommandOrControl+Shift+A',
+    click: async () => {
+      const result = await dialog.showOpenDialog(mainWindow, {
+        title: 'Cargar complemento',
+        filters: [{ name: 'JavaScript Files', extensions: ['simpliplay'] }],
+        properties: ['openFile'],
+      });
+
+      if (!result.canceled && result.filePaths.length > 0) {
+        const filePath = result.filePaths[0];
+        const fileName = path.basename(filePath);
+        const fileURL = pathToFileURL(filePath).href;
+
+        // Check if an addon with the same filename is already loaded
+        const alreadyLoaded = [...loadedAddons.keys()].some(
+          loadedPath => path.basename(loadedPath) === fileName
+        );
+
+        if (alreadyLoaded) {
+          await dialog.showMessageBox(mainWindow, {
+            type: 'error',
+            title: 'No se pudo cargar el complemento',
+            message: `Un complemento llamado "${fileName}" ya se ha cargado anteriormente.`,
+            buttons: ['Vale']
+          });
+          return;
+        }
+
+        if (!loadedAddons.has(filePath)) {
+          mainWindow.webContents.send('load-addon', fileURL);
+
+          const addonMenuItem = new MenuItem({
+            label: fileName,
+            type: 'checkbox',
+            checked: true,
+            click: (menuItem) => {
+              if (menuItem.checked) {
+                fs.access(filePath, (err) => {
+                  if (!err) {
+                      mainWindow.webContents.send('load-addon', fileURL);
+                  } else {
+                      dialog.showMessageBox(mainWindow, {
+                        type: 'error',
+                        title: 'No se pudo cargar el complemento',
+                        message: `El complemento "${fileName}" no se ha encontrado o ya no existe.`,
+                        buttons: ['Vale']
+                      }).then(() => {
+                        // Delay unchecking to ensure dialog closes first
+                      setTimeout(() => {
+                          menuItem.checked = false;
+                      }, 100);
+                      });
+                  }
+                });
+
+              } else {
+                mainWindow.webContents.send('unload-addon', fileURL);
+              }
+            }
+          });
+
+          if (!addonsMenu.items.some(item => item.type === 'separator')) {
+            addonsMenu.append(new MenuItem({ type: 'separator' }));
+          }
+
+          addonsMenu.append(addonMenuItem);
+          loadedAddons.set(filePath, addonMenuItem);
+
+          // Rebuild the menu after adding the new addon item
+          Menu.setApplicationMenu(Menu.buildFromTemplate(newMenuItems));
+        }
+      }
+    }
+  }));
+
+  // "About Addons" menu item (info dialog version)
+addonsMenu.append(new MenuItem({
+  label: 'Acerca de los complementos',
+  click: async () => {
+    const result = await dialog.showMessageBox(mainWindow, {
+      type: 'info',
+      buttons: ['De acuerdo'],
+      defaultId: 0,
+      title: 'Acerca de los complementos',
+      message: 'Los complementos pueden hacer casi cualquier cosa, desde añadir funciones al reproductor multimedia hasta añadir un juego completo dentro de la aplicación.',
+      detail: 'Los complementos son archivos JavaScript normales del lado del cliente con la extensión [.simpliplay].'
+    });
+
+    if (result.response === 0) {
+      console.log('El usuario hizo clic en Aceptar.');
+      // no need for dialog.closeDialog()
+    }
+  }
+}));
+
+
+  // Add the Add-ons menu only once here:
+  newMenuItems.push(new MenuItem({ label: 'Add-ons', submenu: addonsMenu }));
+
+  // Set the application menu after adding Add-ons menu
+  Menu.setApplicationMenu(Menu.buildFromTemplate(newMenuItems));
+}
+
+
+// Re-apply the full menu if you add newMenuItems outside of the if above
+//Menu.setApplicationMenu(Menu.buildFromTemplate(newMenuItems));
+
+
+  //Menu.setApplicationMenu(menu);
+};
+
+const setupShortcuts = () => {
+if (didRegisterShortcuts === false) {
+  globalShortcut.register('CommandOrControl+Q', () => {
+    const focusedWindow = BrowserWindow.getFocusedWindow(); // Get the currently focused window
+
+    if (!focusedWindow) return; // Do nothing if no window is focused
+
+    dialog.showMessageBox(focusedWindow, {
+      type: 'question',
+      buttons: ['Cancelar', 'Salir'],
+      defaultId: 1,
+      title: '¿Renunciar?',
+      message: '¿Estás seguro de que quieres salir de SimpliJuega?',
+    }).then(({ response }) => {
+      if (response === 1) app.quit();
+    });
+  });
+
+  globalShortcut.register('CommandOrControl+Shift+S', () => {
+
+    const focusedWindow = BrowserWindow.getFocusedWindow(); // Get the currently focused window
+
+    if (!focusedWindow) return; // Do nothing if no window is focused
+
+    takeSnapshot();
+  });
+
+  globalShortcut.register('CommandOrControl+S', () => {
+
+    const focusedWindow = BrowserWindow.getFocusedWindow(); // Get the currently focused window
+
+    if (!focusedWindow) return; // Do nothing if no window is focused
+
+    takeSnapshot();
+  });
+
+  // globalShortcut.register('CommandOrControl+Shift+S', takeSnapshot);
+  didRegisterShortcuts = true;
+}
+};
+
+function unregisterShortcuts() {
+  didRegisterShortcuts = false;
+  globalShortcut.unregisterAll();
+  console.log("Shortcuts unregistered");
+}
+
+app.whenReady().then(() => {
+  createWindow();
+  setupMenu();
+
+  
+  mainWindow?.on("focus", () => {
+    if (!didRegisterShortcuts) setupShortcuts();
+  });
+
+  mainWindow?.on("blur", unregisterShortcuts);
+
+  // Store but delay opening
+  const args = process.argv.slice(2);
+  const fileArg = args.find(isValidFileArg);
+
+  if (fileArg) {
+    app.whenReady().then(() => {
+      if (mainWindow) openFileSafely(fileArg);
+    });
+  }
+
+  app.on("open-file", (event, filePath) => {
+    event.preventDefault();
+    openFileSafely(filePath);
+  });
+
+  if (["win32", "linux"].includes(process.platform)) { 
+    if (!app.requestSingleInstanceLock()) {
+      app.quit();
+    } else {
+      app.on("second-instance", (event, argv) => {
+        const fileArg = argv.find(isValidFileArg);
+        if (fileArg) openFileSafely(fileArg);
+      });
+    }
+  }
+});
+
+let hasOpenedFile = false;
+
+function openFileSafely(filePath) {
+  if (!hasOpenedFile) {
+    hasOpenedFile = true;
+
+    const absPath = path.resolve(filePath); // ensure absolute path
+
+    if (mainWindow?.webContents) {
+        const winFileURL = pathToFileURL(filePath).href; // ✅ Convert and encode file path
+        mainWindow.webContents.send("play-media", winFileURL);
+    }
+
+    setTimeout(() => (hasOpenedFile = false), 1000);
+  }
+}
+
+function isValidFileArg(arg) {
+  if (!arg || arg.startsWith('-') || arg.includes('electron')) return false;
+
+  const resolvedPath = path.resolve(arg);
+  if (!fs.existsSync(resolvedPath)) return false;
+
+  // Reject known executable/script extensions
+  const badExtensions = ['.exe', '.bat', '.cmd', '.sh', '.msi', '.com', '.vbs', '.ps1', '.jar', '.scr'];
+  const ext = path.extname(resolvedPath).toLowerCase();
+
+  return !badExtensions.includes(ext);
+}
+
+app.on("window-all-closed", () => {
+  globalShortcut.unregisterAll();
+  app.quit();
+  /* once bug fixed replace above with:
+ if (process.platform !== 'darwin') app.quit() */
+});
+
+app.on("will-quit", () => {
+  globalShortcut.unregisterAll();
+});

simpliplay/main.js

@@ -3,9 +3,25 @@ const path = require('path');
 const fs = require('fs');
 const os = require('os');
 const { pathToFileURL } = require("url");
+const { checkForUpdate } = require('./updateChecker');
+let gpuAccel = "";
 let didRegisterShortcuts = false;
+let version = "2.1.4.0"
+
+if (process.platform === 'darwin') {
+  if (process.argv.includes('--use-gl')) {
+    app.commandLine.appendSwitch('disable-features', 'Metal');
+    app.commandLine.appendSwitch('use-gl', 'desktop');
+  } 
+}
+
+// random change just to make sure that snapcraft releases fixed version on new channel to delete arm64 versions
 
 let mainWindow;
+if (process.argv.includes('--disable-gpu')) {
+  app.disableHardwareAcceleration();
+  gpuAccel = "disabled";
+}
 
 // Handle file opening from Finder or File Explorer
 app.on('open-file', (event, filePath) => {
@@ -15,25 +31,25 @@ app.on('open-file', (event, filePath) => {
 
 const openFile = (filePath) => {
   app.whenReady().then(() => {
+    const fileURL = pathToFileURL(filePath).href;
+
     if (mainWindow) {
-      const fileURL = pathToFileURL(filePath).href; // ✅ Convert and encode file path
       if (mainWindow.webContents.isLoading()) {
         mainWindow.webContents.once("did-finish-load", () => {
           mainWindow.webContents.send("play-media", fileURL);
         });
       } else {
-        const fileURL = pathToFileURL(filePath).href; // ✅ Convert and encode file path
         mainWindow.webContents.send("play-media", fileURL);
       }
     } else {
       createWindow(() => {
-        const fileURL = pathToFileURL(filePath).href; // ✅ Convert and encode file path
         mainWindow.webContents.send("play-media", fileURL);
       });
     }
   });
 };
 
+
 const takeSnapshot = async () => {
   if (!mainWindow) return;
 
@@ -81,13 +97,39 @@ const createWindow = (onReadyCallback) => {
 
   mainWindow.loadFile("index.html");
 
+  if (process.platform === 'darwin') {
+    if (process.argv.includes('--use-gl')) {
+      mainWindow.webContents.on('did-finish-load', () => {
+        mainWindow.webContents.executeJavaScript("navigator.userAgent").then(ua => {
+          console.log("User Agent:", ua);
+        });
+
+        mainWindow.webContents.executeJavaScript("chrome.loadTimes ? chrome.loadTimes() : {}").then(loadTimes => {
+          console.log("GPU Info (legacy):", loadTimes);
+        });
+      });
+    }
+  }
+
   mainWindow.once("ready-to-show", () => {
+
+  if (gpuAccel === "disabled") {
+      dialog.showMessageBox(mainWindow, {
+    type: 'warning',
+    buttons: ['Ok'],
+    defaultId: 0,
+    title: 'Warning!',
+    message: "Disabling GPU acceleration greatly decreases performance and is not recommended, but if you're curious, I don't wanna stop you.",
+  });
+  } 
+
     if (onReadyCallback) onReadyCallback();
   });
 
   setupContextMenu();
 };
 
+
 // Set up context menu (prevents errors if `mainWindow` is undefined)
 const setupContextMenu = () => {
   if (!mainWindow) return;
@@ -103,6 +145,7 @@ const setupContextMenu = () => {
   });
 };
 
+
 // Set up application menu
 const setupMenu = () => {
   const menu = Menu.getApplicationMenu();
@@ -113,6 +156,28 @@ const setupMenu = () => {
     fileMenu.submenu.append(new MenuItem({ label: 'Take a Snapshot', accelerator: 'CommandOrControl+Shift+S', click: takeSnapshot }));
   }
 
+  const appMenu = menu.items.find(item => item.label === 'SimpliPlay');
+
+if (appMenu && !appMenu.submenu.items.some(item => item.label === 'Check for Updates')) {
+  const submenu = appMenu.submenu;
+  const separatorIndex = submenu.items.findIndex(item => item.type === 'separator');
+
+  const updateMenuItem = new MenuItem({
+    label: 'Check for Updates',
+    accelerator: 'CommandOrControl+Shift+U',
+    click: () => checkForUpdate(version)
+  });
+
+  if (separatorIndex === -1) {
+    // No separator found — just append
+    submenu.append(updateMenuItem);
+  } else {
+    // Insert right before the separator
+    submenu.insert(separatorIndex, updateMenuItem);
+  }
+}
+
+
   const helpMenu = menu.items.find(item => item.label === 'Help');
   if (helpMenu) {
     const addMenuItem = (label, url) => {
@@ -125,13 +190,158 @@ const setupMenu = () => {
     addMenuItem('Website', 'https://simpliplay.netlify.app');
     addMenuItem('Help Center', 'https://simpliplay.netlify.app/help');
 
+    // Check for Updates
+  if (!helpMenu.submenu.items.some(item => item.label === 'Check for Updates')) {
+    helpMenu.submenu.append(
+      new MenuItem({
+        label: 'Check for Updates',
+        accelerator: 'CommandOrControl+Shift+U',
+        click: () => checkForUpdate(version)
+      })
+    );
+  }
+
     if (!helpMenu.submenu.items.some(item => item.label === 'Quit')) {
       helpMenu.submenu.append(new MenuItem({ type: 'separator' }));
       helpMenu.submenu.append(new MenuItem({ label: 'Quit', click: () => app.quit() }));
     }
   }
 
-  Menu.setApplicationMenu(menu);
+const loadedAddons = new Map(); // key: addon filepath, value: MenuItem
+
+const newMenuItems = menu ? [...menu.items] : [];
+
+let addonsMenu;
+
+// Check if Add-ons menu already exists
+const existingAddonsMenuItem = newMenuItems.find(item => item.label === 'Add-ons');
+
+if (existingAddonsMenuItem) {
+  addonsMenu = existingAddonsMenuItem.submenu;
+} else {
+  addonsMenu = new Menu();
+
+  // "Load Add-on" menu item
+  addonsMenu.append(new MenuItem({
+    label: 'Load Add-on',
+    accelerator: 'CommandOrControl+Shift+A',
+    click: async () => {
+      const result = await dialog.showOpenDialog(mainWindow, {
+        title: 'Load Add-on',
+        filters: [{ name: 'JavaScript Files', extensions: ['simpliplay'] }],
+        properties: ['openFile'],
+      });
+
+      if (!result.canceled && result.filePaths.length > 0) {
+        const filePath = result.filePaths[0];
+        const fileName = path.basename(filePath);
+        const fileURL = pathToFileURL(filePath).href;
+
+        // Check if an addon with the same filename is already loaded
+        const alreadyLoaded = [...loadedAddons.keys()].some(
+          loadedPath => path.basename(loadedPath) === fileName
+        );
+
+        if (alreadyLoaded) {
+          await dialog.showMessageBox(mainWindow, {
+            type: 'error',
+            title: 'Could not load addon',
+            message: `An add-on named "${fileName}" has already been loaded before.`,
+            buttons: ['OK']
+          });
+          return;
+        }
+
+        if (!loadedAddons.has(filePath)) {
+          mainWindow.webContents.send('load-addon', fileURL);
+
+          const addonMenuItem = new MenuItem({
+            label: fileName,
+            type: 'checkbox',
+            checked: true,
+            click: (menuItem) => {
+              if (menuItem.checked) {
+                fs.access(filePath, (err) => {
+                  if (!err) {
+                      mainWindow.webContents.send('load-addon', fileURL);
+                  } else {
+                      dialog.showMessageBox(mainWindow, {
+                        type: 'error',
+                        title: 'Could not load addon',
+                        message: `The add-on "${fileName}" could not be found or doesn't exist anymore.`,
+                        buttons: ['OK']
+                      }).then(() => {
+                        // Delay unchecking to ensure dialog closes first
+                      setTimeout(() => {
+                          menuItem.checked = false;
+                      }, 100);
+                      });
+                  }
+                });
+
+              } else {
+                mainWindow.webContents.send('unload-addon', fileURL);
+              }
+            }
+          });
+
+          
+
+          if (!addonsMenu.items.some(item => item.type === 'separator')) {
+            addonsMenu.append(new MenuItem({ type: 'separator' }));
+          }
+
+          addonsMenu.append(addonMenuItem);
+          loadedAddons.set(filePath, addonMenuItem);
+
+          // Rebuild the menu after adding the new addon item
+          Menu.setApplicationMenu(Menu.buildFromTemplate(newMenuItems));
+        }
+      }
+    }
+  }));
+
+// "About Addons" menu item (info dialog version)
+addonsMenu.append(new MenuItem({
+  label: 'About Addons',
+  click: async () => {
+    const result = await dialog.showMessageBox(mainWindow, {
+      type: 'info',
+      buttons: ['OK'],
+      defaultId: 0,
+      title: 'About Addons',
+      message: 'Addons can do almost anything from adding features to the media player to adding an entire game within the app!',
+      detail: 'Addons are regular, client-side JavaScript files with the [.simpliplay] extension.'
+    });
+
+    if (result.response === 0) {
+      console.log('User clicked OK');
+      // no need for dialog.closeDialog()
+    }
+  }
+}));
+
+  // "Store" menu item (info dialog version)
+addonsMenu.append(new MenuItem({
+  label: 'Store',
+  click: () => {
+    shell.openExternal("https://simpliplay.netlify.app/addons/")
+  }
+}));
+
+  // Add the Add-ons menu only once here:
+  newMenuItems.push(new MenuItem({ label: 'Add-ons', submenu: addonsMenu }));
+
+  // Set the application menu after adding Add-ons menu
+  Menu.setApplicationMenu(Menu.buildFromTemplate(newMenuItems));
+}
+
+
+// Re-apply the full menu if you add newMenuItems outside of the if above
+//Menu.setApplicationMenu(Menu.buildFromTemplate(newMenuItems));
+
+
+  //Menu.setApplicationMenu(menu);
 };
 
 const setupShortcuts = () => {
@@ -185,8 +395,15 @@ app.whenReady().then(() => {
   createWindow();
   setupMenu();
 
+  
+  mainWindow?.on("focus", () => {
+    if (!didRegisterShortcuts) setupShortcuts();
+  });
+
+  mainWindow?.on("blur", unregisterShortcuts);
+
   // Store but delay opening
-  const args = process.argv.slice(1);
+  const args = process.argv.slice(2);
   const fileArg = args.find(isValidFileArg);
 
   if (fileArg) {
@@ -195,12 +412,6 @@ app.whenReady().then(() => {
     });
   }
 
-  mainWindow?.on("focus", () => {
-    if (!didRegisterShortcuts) setupShortcuts();
-  });
-
-  mainWindow?.on("blur", unregisterShortcuts);
-
   app.on("open-file", (event, filePath) => {
     event.preventDefault();
     openFileSafely(filePath);
@@ -224,6 +435,8 @@ function openFileSafely(filePath) {
   if (!hasOpenedFile) {
     hasOpenedFile = true;
 
+    const absPath = path.resolve(filePath); // ensure absolute path
+
     if (mainWindow?.webContents) {
         const winFileURL = pathToFileURL(filePath).href; // ✅ Convert and encode file path
         mainWindow.webContents.send("play-media", winFileURL);
@@ -234,7 +447,16 @@ function openFileSafely(filePath) {
 }
 
 function isValidFileArg(arg) {
-  return arg && !arg.startsWith('-') && !arg.includes('electron') && fs.existsSync(arg);
+  if (!arg || arg.startsWith('-') || arg.includes('electron')) return false;
+
+  const resolvedPath = path.resolve(arg);
+  if (!fs.existsSync(resolvedPath)) return false;
+
+  // Reject known executable/script extensions
+  const badExtensions = ['.exe', '.bat', '.cmd', '.sh', '.msi', '.com', '.vbs', '.ps1', '.jar', '.scr'];
+  const ext = path.extname(resolvedPath).toLowerCase();
+
+  return !badExtensions.includes(ext);
 }
 
 app.on("window-all-closed", () => {

simpliplay/package-arm64-linux.json

@@ -0,0 +1,124 @@
+{
+  "name": "SimpliPlay",
+  "version": "2.1.4",
+  "description": "SimpliPlay - The mission to make media playback accessible on every device, anywhere, anytime.",
+  "main": "./main.js",
+  "scripts": {
+    "test": "echo Hello World from SimpliPlay!!!",
+    "start": "electron-forge start",
+    "package": "electron-builder --dir",
+    "make": "electron-builder"
+  },
+  "author": "Anirudh Sevugan",
+  "build": {
+    "npmRebuild": false,
+    "appId": "com.anirudhsevugan.simpliPlay",
+    "productName": "SimpliPlay",
+    "directories": {
+      "output": "dist"
+    },
+    "snap": {
+      "confinement": "strict",
+      "grade": "stable",
+      "summary": "A cross-platform, simple media player.",
+      "description": "The mission to make media playback accessible on every platform, anywhere, anytime.",
+      "base": "core22"
+    },
+    "mac": {
+      "target": [
+        "dmg"
+      ],
+      "icon": "icon.icns"
+    },
+    "win": {
+      "target": "nsis",
+      "icon": "icon.ico"
+    },
+    "linux": {
+      "target": ["snap", "AppImage"],
+      "icon": "icon.png",
+      "executableName": "SimpliPlay",
+      "synopsis": "The mission to make media playback accessible anywhere, anytime.",
+      "artifactName": "SimpliPlay-${arch}-linux.${ext}"
+    },
+    "fileAssociations": [
+      {
+        "ext": "mp4",
+        "name": "MP4 Video",
+        "role": "Viewer"
+      },
+      {
+        "ext": "webm",
+        "name": "WebM Video",
+        "role": "Viewer"
+      },
+      {
+        "ext": "m4v",
+        "name": "M4V Video",
+        "role": "Viewer"
+      },
+      {
+        "ext": "m4a",
+        "name": "M4A Audio",
+        "role": "Viewer"
+      },
+      {
+        "ext": "ogv",
+        "name": "OGV Video",
+        "role": "Viewer"
+      },
+      {
+        "ext": "mp3",
+        "name": "MP3 Audio",
+        "role": "Viewer"
+      },
+      {
+        "ext": "aac",
+        "name": "AAC Audio",
+        "role": "Viewer"
+      },
+      {
+        "ext": "wav",
+        "name": "WAV Audio",
+        "role": "Viewer"
+      },
+      {
+        "ext": "ogg",
+        "name": "OGG Audio",
+        "role": "Viewer"
+      },
+      {
+        "ext": "flac",
+        "name": "FLAC Audio",
+        "role": "Viewer"
+      },
+      {
+        "ext": "opus",
+        "name": "Opus Audio",
+        "role": "Viewer"
+      },
+      {
+        "ext": "mkv",
+        "name": "MKV Video",
+        "role": "Viewer"
+      },
+      {
+        "ext": "mov",
+        "name": "QuickTime Movie",
+        "role": "Viewer"
+      }
+    ]
+  },
+  "nsis": {
+    "oneClick": false,
+    "installerIcon": "icon.ico",
+    "uninstallerIcon": "icon.ico",
+    "uninstallDisplayName": "simpliplay-uninstaller",
+    "license": "LICENSE.md",
+    "allowToChangeInstallationDirectory": true
+  },
+  "devDependencies": {
+    "electron": "^38.1.0",
+    "electron-builder": "^26.0.12"
+  }
+}

simpliplay/package.json

@@ -1,7 +1,7 @@
 {
   "name": "SimpliPlay",
-  "version": "1.0.7",
-  "description": "SimpliPlay - The mission to make media playback accessible on every device, anywhere, anytime.",
+  "version": "2.1.4",
+  "description": "The mission to make media playback accessible on every platform, anywhere, anytime.",
   "main": "./main.js",
   "scripts": {
     "test": "echo Hello World from SimpliPlay!!!",
@@ -17,21 +17,42 @@
     "directories": {
       "output": "dist"
     },
+    "snap": {
+      "confinement": "strict",
+      "grade": "stable",
+      "summary": "A cross-platform, simple media player.",
+      "description": "The mission to make media playback accessible on every platform, anywhere, anytime."
+    },
+    "nsis": {
+      "oneClick": false,
+      "installerIcon": "icon.ico",
+      "uninstallerIcon": "icon.ico",
+      "uninstallDisplayName": "simpliplay-uninstaller",
+      "allowToChangeInstallationDirectory": true
+    },
     "mac": {
       "target": [
         "dmg"
       ],
-      "icon": "icon.icns"
+      "icon": "icon.icns",
+      "artifactName": "SimpliPlay-${arch}-darwin.${ext}",
+      "identity": "-"
     },
     "win": {
-      "target": "nsis",
-      "icon": "icon.ico"
+      "target": [
+        {
+          "target": "nsis",
+          "arch": ["x64", "arm64"]
+        }
+      ],
+      "artifactName": "SimpliPlay-${arch}-win-setup.${ext}"
     },
     "linux": {
-      "target": "flatpak",
+      "target": ["snap", "AppImage"],
       "icon": "icon.png",
       "executableName": "SimpliPlay",
-      "synopsis": "The mission to make media playback accessible anywhere, anytime."
+      "synopsis": "The mission to make media playback accessible anywhere, anytime.",
+      "artifactName": "SimpliPlay-${arch}-linux.${ext}"
     },
     "fileAssociations": [
       {
@@ -84,6 +105,11 @@
         "name": "FLAC Audio",
         "role": "Viewer"
       },
+      {
+        "ext": "opus",
+        "name": "Opus Audio",
+        "role": "Viewer"
+      },
       {
         "ext": "mkv",
         "name": "MKV Video",
@@ -97,7 +123,7 @@
     ]
   },
   "devDependencies": {
-    "electron": "^36.2.0",
-    "electron-builder": "^25.1.8"
+    "electron": "^38.1.0",
+    "electron-builder": "^26.0.12"
   }
 }

simpliplay/player-es.js

@@ -0,0 +1,411 @@
+document.addEventListener('DOMContentLoaded', () => {
+
+    const dialogOverlay = document.getElementById('dialogOverlay');
+    const chooseFileBtn = document.getElementById('chooseFileBtn');
+    const enterUrlBtn = document.getElementById('enterUrlBtn');
+    const fileInput = document.getElementById('fileInput');
+    const mediaPlayer = document.getElementById('mediaPlayer');
+    const playPauseBtn = document.getElementById('playPauseBtn');
+    const seekBar = document.getElementById('seekBar');
+    const timeDisplay = document.getElementById('timeDisplay');
+    const volumeBar = document.getElementById('volumeBar');
+    const settingsBtn = document.getElementById('settingsBtn');
+    const settingsPanel = document.getElementById('settingsPanel');
+    const autoplayCheckbox = document.getElementById('autoplayCheckbox');
+    const loopCheckbox = document.getElementById('loopCheckbox');
+    const saveSettingsBtn = document.getElementById('saveSettingsBtn');
+    const urlDialogOverlay = document.getElementById('urlDialogOverlay');
+    const settingsDialogOverlay = document.getElementById('settingsDialogOverlay');
+    const urlInput = document.getElementById('urlInput');
+    const submitUrlBtn = document.getElementById('submitUrlBtn');
+    const cancelUrlBtn = document.getElementById('cancelUrlBtn');
+    const ccBtn = document.getElementById('ccBtn'); // CC button
+    const volumeBtn = document.getElementById("volumeBtn")
+    const subtitlesOverlay = document.getElementById('subtitlesOverlay');
+    const subtitlesInput = document.getElementById('subtitlesInput');
+    const submitSubtitlesBtn = document.getElementById('submitSubtitlesBtn');
+    const cancelSubtitlesBtn = document.getElementById('cancelSubtitlesBtn');
+    const customControls = document.getElementById('customControls');
+    let hls = null
+    let player = null
+    window.hls = hls; 
+    window.dash = player;
+
+    async function detectStreamType(url) {
+  try {
+    const response = await fetch(url, { method: 'HEAD' });
+    const contentType = response.headers.get('Content-Type') || '';
+
+    const isHLS = url.toLowerCase().endsWith('.m3u8') ||
+      contentType.includes('application/vnd.apple.mpegurl') ||
+      contentType.includes('application/x-mpegURL');
+
+    const isDASH = url.toLowerCase().endsWith('.mpd') ||
+      contentType.includes('application/dash+xml');
+
+    return { isHLS, isDASH, contentType };
+  } catch (err) {
+    console.error("Failed to detect stream type:", err);
+    return { isHLS: false, isDASH: false, contentType: null };
+  }
+}
+
+    // Update media volume when the slider is moved
+  volumeBar.addEventListener("input", function () {
+    mediaPlayer.volume = volumeBar.value;
+  });
+
+  // Sync slider with media volume (in case it's changed programmatically)
+  mediaPlayer.addEventListener("volumechange", function () {
+    volumeBar.value = mediaPlayer.volume;
+    if (mediaPlayer.muted || mediaPlayer.volume === 0) {
+      volumeBtn.textContent = "🔇";
+    } else {
+      volumeBtn.textContent = "🔊";
+    }
+  });
+
+// Function to add subtitles dynamically (e.g., after URL input)
+function addSubtitles(url) {
+  // Remove any existing subtitle tracks
+  const existingTracks = mediaPlayer.getElementsByTagName('track');
+  for (let track of existingTracks) {
+    track.remove();
+  }
+
+  // Create a new track for subtitles
+  const track = document.createElement('track');
+  track.kind = 'subtitles';
+  track.label = 'Español';
+  track.srclang = 'es';
+  track.src = url;
+
+  // Append the new track
+  mediaPlayer.appendChild(track);
+
+  // Optionally, enable subtitles by default
+  track.track.mode = 'showing'; // Enable subtitles by default
+}
+
+// Handle submit subtitle URL
+function clearSubtitles() {
+  const tracks = mediaPlayer.getElementsByTagName('track');
+  for (let i = tracks.length - 1; i >= 0; i--) {
+    tracks[i].remove();
+  }
+}
+
+// Use this function when a new video is loaded
+
+submitSubtitlesBtn.addEventListener('click', () => {
+  const subtitleUrl = subtitlesInput.value;
+  if (subtitleUrl) {
+    addSubtitles(subtitleUrl);
+    subtitlesOverlay.style.display = 'none';
+    subtitlesInput.value = '';
+  }
+});
+
+
+
+    let autoplayEnabled = true;
+    let loopEnabled = false;
+
+    // Handle submit URL button in custom dialog
+submitUrlBtn.addEventListener('click', async () => {
+  let url = urlInput.value;
+
+  // Check if URL is a valid URL and doesn't contain "http" or "https"
+  if (url && !url.startsWith('http') && !url.startsWith('https')) {
+    // Assuming it's a URL and needs the protocol added
+    url = 'http://' + url;  // You can also choose 'https://' if preferred
+  }
+
+const { isHLS, isDASH } = await detectStreamType(url);
+  
+
+  if (url) {
+    clearSubtitles();
+    if (hls !== null) {
+      hls.destroy()
+      hls = null
+      window.hls = hls
+    }
+    if (player !== null) {
+      player.reset()
+      player = null
+      window.dash = player
+    }
+    if (url.toLowerCase().endsWith('.m3u8') || url.toLowerCase().endsWith('.m3u') || isHLS) {
+      // HLS stream
+      if (Hls.isSupported()) {
+        mediaPlayer.style.display = 'flex'; // Hide the native video player
+        hls = new Hls();
+        window.hls = hls
+        mediaPlayer.pause();
+        hls.loadSource(url);
+        hls.attachMedia(mediaPlayer);
+        hls.on(Hls.Events.MANIFEST_PARSED, function() {
+          if (autoplayCheckbox.checked) {
+            mediaPlayer.play();
+          }
+          urlInput.value = "";
+          customControls.style.display = 'flex';
+        });
+        window.hls = hls
+      } else {
+        alert("Your device doesn't support HLS.");
+        customControls.style.display = 'flex';
+        urlInput.value = "";
+      }
+    } else if (url.toLowerCase().endsWith('.mpd') || isDASH) {
+      mediaPlayer.style.display = 'flex'; // Hide the native video player
+      mediaPlayer.pause();
+      player = dashjs.MediaPlayer().create();
+      window.dash = player
+      // MPEG-DASH stream
+      player.initialize(mediaPlayer, url, true);
+      customControls.style.display = 'flex';
+      urlInput.value = "";
+      if (autoplayCheckbox.checked) {
+        mediaPlayer.play();
+      }
+      window.dash = player
+    } else {
+      mediaPlayer.style.display = 'flex'; // Hide the native video player
+      mediaPlayer.pause();
+      mediaPlayer.src = url;
+      customControls.style.display = 'flex';
+      urlInput.value = "";
+      if (autoplayCheckbox.checked) {
+        mediaPlayer.play();
+      }
+    }
+    urlDialogOverlay.style.display = 'none';
+    dialogOverlay.style.display = 'none';
+  }
+});
+
+
+
+    // Handle CC button to show subtitle modal
+    ccBtn.addEventListener('click', () => {
+      subtitlesOverlay.style.display = 'block';
+    });
+
+
+
+    // Handle cancel subtitle modal
+    cancelSubtitlesBtn.addEventListener('click', () => {
+      subtitlesOverlay.style.display = 'none';
+    });
+
+
+    // Show the dialog on page load
+    window.onload = function () {
+      dialogOverlay.style.display = 'block';
+    };
+
+
+
+    // Handle "Choose a File" button
+    chooseFileBtn.addEventListener('click', () => {
+      fileInput.click();
+    });
+
+    mediaPlayer.addEventListener("volumechange", function () {
+      if (mediaPlayer.muted) {
+        volumeBtn.textContent = "🔇"
+      } else if (mediaPlayer.volume === 0) {
+        volumeBtn.textContent = "🔊"
+      }
+    });
+    
+
+
+   
+    let previousObjectURL = null; // Store the last Object URL
+
+    fileInput.addEventListener('change', (event) => {
+      if (hls !== null) {
+        hls.destroy()
+        hls = null
+        window.hls = hls
+      }
+      if (player !== null) {
+        player.reset()
+        player = null
+        window.dash = player
+      }
+        const file = event.target.files[0];
+        if (!file) return;
+    
+        clearSubtitles(); // Remove any previously loaded subtitles
+    
+        // Revoke the previous Object URL if it exists
+        if (previousObjectURL) {
+            URL.revokeObjectURL(previousObjectURL);
+        }
+    
+        // Create a new Object URL for the selected file
+        const fileURL = URL.createObjectURL(file);
+        mediaPlayer.src = fileURL;
+        mediaPlayer.load();
+        if (autoplayCheckbox.checked) {
+        mediaPlayer.play();
+        }
+    
+        // Store the new Object URL for future cleanup
+        previousObjectURL = fileURL;
+    
+        // Hide dialog after selecting a file
+        dialogOverlay.style.display = 'none';
+    });
+    
+
+    // Handle "Enter a URL" button
+    enterUrlBtn.addEventListener('click', () => {
+      urlDialogOverlay.style.display = 'block';
+    });
+
+    // Handle cancel button in URL dialog
+    cancelUrlBtn.addEventListener('click', () => {
+      urlDialogOverlay.style.display = 'none';
+    });
+
+    // Handle custom play/pause button
+playPauseBtn.addEventListener('click', () => {
+  if (mediaPlayer.paused) {
+    mediaPlayer.play();
+    playPauseBtn.textContent = 'Pausa';
+  } else {
+    mediaPlayer.pause();
+    playPauseBtn.textContent = 'Jugar';
+  }
+});
+
+// Sync button with the video player when it is paused manually
+mediaPlayer.addEventListener('pause', () => {
+  playPauseBtn.textContent = 'Jugar';
+});
+
+// Sync button with the video player when it is played
+mediaPlayer.addEventListener('play', () => {
+  playPauseBtn.textContent = 'Pausa';
+});
+
+// Volume button toggling mute/unmute
+volumeBtn.addEventListener('click', () => {
+  if (mediaPlayer.muted || mediaPlayer.volume == 0) {
+    mediaPlayer.muted = false;
+    volumeBtn.textContent = '🔊'; // Unmute icon
+  } else {
+    mediaPlayer.muted = true;
+    volumeBtn.textContent = '🔇'; // Mute icon
+  }
+});
+
+
+// Handle URL input on Enter key
+urlInput.addEventListener('keydown', (e) => {
+  if (e.key === 'Enter') {
+    submitUrlBtn.click();
+  }
+});
+
+// Handle Subtitles input on Enter key
+subtitlesInput.addEventListener('keydown', (e) => {
+  if (e.key === 'Enter') {
+    submitSubtitlesBtn.click();
+  }
+});
+
+// Handle URL submission
+
+
+    // Update seek bar and time display
+    mediaPlayer.addEventListener('timeupdate', () => {
+      seekBar.max = mediaPlayer.duration || 0;
+      seekBar.value = mediaPlayer.currentTime;
+      const current = formatTime(mediaPlayer.currentTime);
+      const total = formatTime(mediaPlayer.duration);
+      timeDisplay.textContent = `${current} / ${total}`;
+    });
+
+    // Seek media
+    seekBar.addEventListener('input', () => {
+      mediaPlayer.currentTime = seekBar.value;
+    });
+
+    // Handle volume
+    volumeBar.addEventListener('input', () => {
+      mediaPlayer.volume = volumeBar.value;
+      if (volumeBar.value == 0 || mediaPlayer.volume == 0) {
+        volumeBtn.textContent = "🔇";
+      } else {
+        volumeBtn.textContent = "🔊";
+      }
+    });
+
+    // Show settings panel
+    settingsBtn.addEventListener('click', () => {
+      settingsDialogOverlay.style.display = 'block';
+      settingsPanel.style.display = 'block';
+    });
+
+    saveSettingsBtn.addEventListener('click', () => {
+      autoplayEnabled = autoplayCheckbox.checked;
+      loopEnabled = loopCheckbox.checked;
+      mediaPlayer.autoplay = autoplayEnabled;
+      mediaPlayer.loop = loopEnabled;
+      
+      const controlsEnabled = document.getElementById('controlsCheckbox').checked;
+      const colorsEnabled = document.getElementById('colorsCheckbox').checked;
+      mediaPlayer.controls = controlsEnabled;
+      if (colorsEnabled) {
+        mediaPlayer.style.filter = "contrast(1.1) saturate(1.15) brightness(1.03)";
+      } else {
+        mediaPlayer.style.filter = "";
+      }
+
+      settingsPanel.style.display = 'none';
+      settingsDialogOverlay.style.display = 'none';
+    });
+    
+
+// End of first event listener for DOM content loaded
+
+    // Format time
+    function formatTime(time) {
+      const minutes = Math.floor(time / 60) || 0;
+      const seconds = Math.floor(time % 60) || 0;
+      return `${minutes}:${seconds.toString().padStart(2, '0')}`;
+    }
+
+    const showDialogBtn = document.getElementById('showDialogBtn');
+    const hideDialogBtn = document.getElementById('hideDialogBtn');
+    const fullscreenBtn = document.getElementById('fullscreenBtn');
+
+    // Show dialog
+    showDialogBtn.addEventListener('click', () => {
+      dialogOverlay.style.display = 'block';
+    });
+
+    // Hide dialog
+    hideDialogBtn.addEventListener('click', () => {
+      dialogOverlay.style.display = 'none';
+    });
+
+    // Fullscreen functionality
+    fullscreenBtn.addEventListener('click', () => {
+      if (!document.fullscreenElement) {
+        mediaPlayer.requestFullscreen();
+      } else {
+        document.exitFullscreen();
+      }
+    });
+
+
+// End of code and second event listener for DOM content loaded
+
+});

simpliplay/player.js

@@ -28,6 +28,27 @@ document.addEventListener('DOMContentLoaded', () => {
     const customControls = document.getElementById('customControls');
     let hls = null
     let player = null
+    window.hls = hls; 
+    window.dash = player;
+
+    async function detectStreamType(url) {
+  try {
+    const response = await fetch(url, { method: 'HEAD' });
+    const contentType = response.headers.get('Content-Type') || '';
+
+    const isHLS = url.toLowerCase().endsWith('.m3u8') ||
+      contentType.includes('application/vnd.apple.mpegurl') ||
+      contentType.includes('application/x-mpegURL');
+
+    const isDASH = url.toLowerCase().endsWith('.mpd') ||
+      contentType.includes('application/dash+xml');
+
+    return { isHLS, isDASH, contentType };
+  } catch (err) {
+    console.error("Failed to detect stream type:", err);
+    return { isHLS: false, isDASH: false, contentType: null };
+  }
+}
 
     // Update media volume when the slider is moved
   volumeBar.addEventListener("input", function () {
@@ -44,36 +65,83 @@ document.addEventListener('DOMContentLoaded', () => {
     }
   });
 
-// Function to add subtitles dynamically (e.g., after URL input)
-function addSubtitles(url) {
-  // Remove any existing subtitle tracks
+async function addSubtitles(url) {
+  // Remove existing tracks and revoke any previous blob URLs
   const existingTracks = mediaPlayer.getElementsByTagName('track');
-  for (let track of existingTracks) {
+  for (let i = existingTracks.length - 1; i >= 0; i--) {
+    const track = existingTracks[i];
+    if (track.src.startsWith('blob:')) URL.revokeObjectURL(track.src);
     track.remove();
   }
 
-  // Create a new track for subtitles
+  // Fetch subtitle content
+  let text = '';
+  try {
+    const res = await fetch(url);
+    text = await res.text();
+  } catch (err) {
+    console.error('Failed to fetch subtitles:', err);
+    return;
+  }
+
+  // Detect format
+  const firstLine = text.split(/\r?\n/)[0].trim();
+  const format = firstLine.startsWith('WEBVTT') || url.toLowerCase().endsWith('.vtt') ? 'vtt' : 'srt';
+
+  // Determine track source
+  let trackSrc = url;
+  if (format === 'srt') {
+    // Convert SRT → VTT
+    text = 'WEBVTT\n\n' + text
+      .replace(/\r+/g, '')
+      .replace(/^\s+|\s+$/g, '')
+      .split('\n')
+      .map(line => line.replace(/(\d+):(\d+):(\d+),(\d+)/g, '$1:$2:$3.$4'))
+      .join('\n');
+
+    // Create Blob URL for converted subtitles
+    const blob = new Blob([text], { type: 'text/vtt' });
+    trackSrc = URL.createObjectURL(blob);
+  }
+
+  // Create and append track
   const track = document.createElement('track');
   track.kind = 'subtitles';
   track.label = 'English';
   track.srclang = 'en';
-  track.src = url;
-
-  // Append the new track
+  track.src = trackSrc;
+  track.default = true;
   mediaPlayer.appendChild(track);
 
-  // Optionally, enable subtitles by default
-  track.track.mode = 'showing'; // Enable subtitles by default
+  // Force enable immediately
+  setTimeout(() => {
+    for (let t of mediaPlayer.textTracks) t.mode = 'disabled';
+    track.track.mode = 'showing';
+  }, 50);
 }
 
-// Handle submit subtitle URL
+
+
+/*// Handle submit subtitle URL
 function clearSubtitles() {
   const tracks = mediaPlayer.getElementsByTagName('track');
   for (let i = tracks.length - 1; i >= 0; i--) {
     tracks[i].remove();
   }
+}*/
+
+function clearSubtitles() {
+  const tracks = mediaPlayer.getElementsByTagName('track');
+  for (let i = tracks.length - 1; i >= 0; i--) {
+    const track = tracks[i];
+    if (track.src.startsWith('blob:')) {
+      URL.revokeObjectURL(track.src); // free memory leaks from SRT to VTT converted subtitles
+    }
+    track.remove();
+  }
 }
 
+
 // Use this function when a new video is loaded
 
 submitSubtitlesBtn.addEventListener('click', () => {
@@ -91,7 +159,7 @@ submitSubtitlesBtn.addEventListener('click', () => {
     let loopEnabled = false;
 
     // Handle submit URL button in custom dialog
-submitUrlBtn.addEventListener('click', () => {
+submitUrlBtn.addEventListener('click', async () => {
   let url = urlInput.value;
 
   // Check if URL is a valid URL and doesn't contain "http" or "https"
@@ -99,6 +167,8 @@ submitUrlBtn.addEventListener('click', () => {
     // Assuming it's a URL and needs the protocol added
     url = 'http://' + url;  // You can also choose 'https://' if preferred
   }
+
+const { isHLS, isDASH } = await detectStreamType(url);
   
 
   if (url) {
@@ -106,16 +176,19 @@ submitUrlBtn.addEventListener('click', () => {
     if (hls !== null) {
       hls.destroy()
       hls = null
+      window.hls = hls
     }
     if (player !== null) {
       player.reset()
       player = null
+      window.dash = player
     }
-    if (url.toLowerCase().endsWith('.m3u8') || url.toLowerCase().endsWith('.m3u')) {
+    if (url.toLowerCase().endsWith('.m3u8') || url.toLowerCase().endsWith('.m3u') || isHLS) {
       // HLS stream
       if (Hls.isSupported()) {
         mediaPlayer.style.display = 'flex'; // Hide the native video player
         hls = new Hls();
+        window.hls = hls
         mediaPlayer.pause();
         hls.loadSource(url);
         hls.attachMedia(mediaPlayer);
@@ -126,15 +199,17 @@ submitUrlBtn.addEventListener('click', () => {
           urlInput.value = "";
           customControls.style.display = 'flex';
         });
+        window.hls = hls
       } else {
         alert("Your device doesn't support HLS.");
         customControls.style.display = 'flex';
         urlInput.value = "";
       }
-    } else if (url.toLowerCase().endsWith('.mpd')) {
+    } else if (url.toLowerCase().endsWith('.mpd') || isDASH) {
       mediaPlayer.style.display = 'flex'; // Hide the native video player
       mediaPlayer.pause();
       player = dashjs.MediaPlayer().create();
+      window.dash = player
       // MPEG-DASH stream
       player.initialize(mediaPlayer, url, true);
       customControls.style.display = 'flex';
@@ -142,6 +217,7 @@ submitUrlBtn.addEventListener('click', () => {
       if (autoplayCheckbox.checked) {
         mediaPlayer.play();
       }
+      window.dash = player
     } else {
       mediaPlayer.style.display = 'flex'; // Hide the native video player
       mediaPlayer.pause();
@@ -196,15 +272,18 @@ submitUrlBtn.addEventListener('click', () => {
 
    
     let previousObjectURL = null; // Store the last Object URL
+    window.objectURL = previousObjectURL
 
     fileInput.addEventListener('change', (event) => {
       if (hls !== null) {
         hls.destroy()
         hls = null
+        window.hls = hls
       }
       if (player !== null) {
         player.reset()
         player = null
+        window.dash = player
       }
         const file = event.target.files[0];
         if (!file) return;
@@ -214,7 +293,13 @@ submitUrlBtn.addEventListener('click', () => {
         // Revoke the previous Object URL if it exists
         if (previousObjectURL) {
             URL.revokeObjectURL(previousObjectURL);
+            window.objectURL = previousObjectURL
         }
+
+        // Revoke previous file picker Object URL
+    if (window.previousDropURL) {
+        URL.revokeObjectURL(window.previousDropURL);
+    }
     
         // Create a new Object URL for the selected file
         const fileURL = URL.createObjectURL(file);
@@ -226,6 +311,7 @@ submitUrlBtn.addEventListener('click', () => {
     
         // Store the new Object URL for future cleanup
         previousObjectURL = fileURL;
+        fileInput.value = "";
     
         // Hide dialog after selecting a file
         dialogOverlay.style.display = 'none';

simpliplay/preload.js

@@ -2,9 +2,9 @@ const { contextBridge, ipcRenderer } = require("electron");
 
 contextBridge.exposeInMainWorld("electron", {
   receive: (channel, callback) => {
-    const validChannels = ["play-media"]; // ✅ Only allow specific, safe channels
+    const validChannels = ["play-media", "load-addon", "unload-addon"];
     if (validChannels.includes(channel)) {
-      ipcRenderer.removeAllListeners(channel); // ✅ Prevent duplicate listeners
+      ipcRenderer.removeAllListeners(channel); // Prevent multiple callbacks
       ipcRenderer.on(channel, (_event, ...args) => callback(...args));
     }
   },

simpliplay/renderer.js

@@ -16,6 +16,103 @@ function loadMedia(fileURL) {
   }
 }
 
+window.addEventListener('DOMContentLoaded', () => {
+const dropArea = document.createElement('div');
+dropArea.style.position = 'fixed';
+dropArea.style.top = '0';
+dropArea.style.left = '0';
+dropArea.style.width = '100vw';
+dropArea.style.height = '100vh';
+dropArea.style.display = 'none'; // hidden by default
+dropArea.style.zIndex = '0';     // behind everything
+dropArea.style.opacity = '0';    // invisible
+document.body.appendChild(dropArea);
+
+let dragCounter = 0; // track nested dragenter/dragleave events
+
+
+window.addEventListener('dragenter', (e) => {
+    if (e.dataTransfer.types.includes('Files')) {
+        dragCounter++;
+        e.preventDefault();
+        e.stopPropagation();
+    }
+});
+
+window.addEventListener('dragleave', (e) => {
+    if (e.dataTransfer.types.includes('Files')) {
+        dragCounter--;
+        if (dragCounter <= 0) dragCounter = 0;
+        e.preventDefault();
+        e.stopPropagation();
+    }
+});
+
+window.addEventListener('dragover', (e) => {
+    if (e.dataTransfer.types.includes('Files')) {
+        e.preventDefault(); // allow drop
+        e.stopPropagation();
+    }
+});
+
+
+let previousDropURL = null; // Store last Object URL
+window.previousDropURL = previousDropURL
+
+window.addEventListener('drop', e => {
+    e.preventDefault();
+    e.stopPropagation();
+
+    const file = e.dataTransfer.files[0];
+    if (!file) return;
+
+    // Destroy existing HLS/DASH instances if they exist
+    if (window.hls) {
+        window.hls.destroy();
+        window.hls = null;
+    }
+    if (window.dash) {
+        window.dash.reset();
+        window.dash = null;
+    }
+
+    // Clear previously loaded subtitles
+    const tracks = mediaElement.getElementsByTagName('track');
+    for (let i = tracks.length - 1; i >= 0; i--) {
+        tracks[i].remove();
+    }
+
+    // Revoke previous Object URL
+    if (previousDropURL) {
+        URL.revokeObjectURL(previousDropURL);
+        window.previousDropURL = previousDropURL;
+    }
+
+    // Revoke previous file picker Object URL
+    if (window.objectURL) {
+        URL.revokeObjectURL(window.objectURL);
+    }
+
+    // Create a new Object URL
+    const fileURL = URL.createObjectURL(file);
+    mediaElement.src = fileURL;
+
+    mediaElement.load();
+      // Autoplay if checkbox is checked
+    if (autoplayCheckbox.checked) {
+        mediaElement.play().catch(err => console.warn(err));
+    }
+
+    // Store for future cleanup
+    previousDropURL = fileURL;
+
+    // Hide file dialog if applicable
+    if (dialogOverlay) dialogOverlay.style.display = 'none';
+});
+
+
+});
+
 // Handle submit subtitle URL
 function clearSubtitles() {
   const tracks = mediaElement.getElementsByTagName('track');
@@ -34,13 +131,70 @@ function isSafeURL(fileURL) {
   }
 }
 
+// Load addon script dynamically
+function loadAddon(fileURL) {
+  // Avoid duplicate scripts
+  if (document.querySelector(`script[data-addon="${fileURL}"]`)) return;
 
-// ✅ Listen for "play-media" event from main process securely
+  const script = document.createElement('script');
+  script.src = fileURL;
+  script.type = 'text/javascript';
+  script.async = false; // optional, depends on your needs
+  script.setAttribute('data-addon', fileURL);
+
+  document.head.appendChild(script);
+
+  console.log(`addon loaded: ${fileURL}`)
+  alert("Addon loaded successfully");
+}
+
+// Unload addon script by removing the <script> tag
+function unloadAddon(fileURL) {
+  const script = document.querySelector(`script[data-addon="${fileURL}"]`);
+  if (script) {
+    script.remove();
+    console.log(`addon unloaded: ${fileURL}`)
+    alert("Addon unloaded successfully");
+  } else {
+    console.warn(`No addon script found for: ${fileURL}`);
+  }
+}
+
+
+// ✅ Listen for events from main process securely
 window.electron.receive("play-media", (fileURL) => {
   if (isSafeURL(fileURL)) {
     clearSubtitles()
+    if (window.hls) {
+      window.hls.destroy()
+      window.hls = null
+    }
+    if (window.dash) {
+      window.dash.reset()
+      window.dash = null
+    }
     loadMedia(fileURL);
   } else {
     console.warn("Blocked unsafe media URL:", fileURL);
   }
 });
+
+// Listen for load-addon message
+window.electron.receive("load-addon", (fileURL) => {
+  if (isSafeURL(fileURL)) {
+    loadAddon(fileURL);
+  } else {
+    console.warn("Blocked unsafe script URL:", fileURL);
+    alert("There was an issue loading your addon: it may be unsafe");
+  }
+});
+
+// Listen for unload-addon message
+window.electron.receive("unload-addon", (fileURL) => {
+    unloadAddon(fileURL);
+});
+
+
+
+
+

simpliplay/updateChecker.js

@@ -0,0 +1,83 @@
+const https = require('https');
+const { URL } = require('url');
+const { dialog, shell } = require('electron');
+
+const latestReleaseUrl = 'https://github.com/A-Star100/simpliplay-desktop/releases/latest/';
+
+function fetchRedirectLocation(url) {
+  return new Promise((resolve, reject) => {
+    https.get(url, (res) => {
+      if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+        resolve(res.headers.location);
+      } else {
+        reject(new Error(`Expected redirect but got status code: ${res.statusCode}`));
+      }
+    }).on('error', reject);
+  });
+}
+
+function normalizeVersion(version) {
+  return version.trim().replace(/[^\d\.]/g, '');
+}
+
+function compareVersions(v1, v2) {
+  const a = v1.split('.').map(Number);
+  const b = v2.split('.').map(Number);
+  const len = Math.max(a.length, b.length);
+
+  for (let i = 0; i < len; i++) {
+    const num1 = a[i] || 0;
+    const num2 = b[i] || 0;
+    if (num1 > num2) return 1;
+    if (num1 < num2) return -1;
+  }
+  return 0;
+}
+
+/**
+ * Checks for update and shows native dialog if update is available.
+ * @param {string} currentVersion 
+ */
+async function checkForUpdate(currentVersion) {
+  try {
+    const redirectUrl = await fetchRedirectLocation(latestReleaseUrl);
+
+    const urlObj = new URL(redirectUrl);
+    const parts = urlObj.pathname.split('/');
+
+    const releaseTag = parts[parts.length - 1];
+    const versionMatch = releaseTag.match(/release-([\d\.]+)/);
+    if (!versionMatch) {
+      throw new Error(`Could not parse version from release tag: ${releaseTag}`);
+    }
+    const latestVersion = normalizeVersion(versionMatch[1]);
+
+    const cmp = compareVersions(latestVersion, currentVersion);
+
+    if (cmp > 0) {
+      const result = dialog.showMessageBoxSync({
+        type: 'info',
+        buttons: ['Download', 'Later'],
+        defaultId: 0,
+        cancelId: 1,
+        title: 'Update Available',
+        message: `A new version (${latestVersion}) is available. Would you like to download it?`,
+      });
+
+      if (result === 0) {
+        shell.openExternal("https://simpliplay.netlify.app/#download-options");
+      }
+    } else {
+      dialog.showMessageBoxSync({
+        type: 'info',
+        buttons: ['OK'],
+        title: "You're up to date!",
+        message: `You are using the latest version (${currentVersion}).`,
+      });
+    }
+  } catch (err) {
+    dialog.showErrorBox('Could not check for update.', err.message);
+  }
+}
+
+module.exports = { checkForUpdate };