Update changelog

Optimize regex compilation and eliminate busy-wait loops

CHANGELOG.md

@@ -1,3 +1,52 @@
+# 1.2.4
+- **Subtitle generation is now available for all languages!** Abogen now supports subtitle generation for non-English languages using audio duration-based timing. Available modes include `Line`, `Sentence`, and `Sentence + Comma`. (Note: Word-level subtitle modes remain English-only due to Kokoro's timestamp token limitations.)
+- New option: **"Use spaCy for sentence segmentation"** You can now use [spaCy](https://spacy.io/) to automatically detect sentence boundaries and produce cleaner, more readable subtitles. Quick summary:
+    - **What it does:** Splits text into natural sentences so subtitle entries read better and align more naturally with speech.
+    - **Why this helps:** The previous punctuation-based splitting could break sentences incorrectly at common abbreviations (e.g. "Mr.", "Dr.", "Prof.") or initials, producing wrong subtitle breaks. spaCy avoids those false splits by using linguistic rules to detect real sentence boundaries.
+    - **For Non-English:** spaCy runs **before** audio generation to create better sentence chunks for TTS.
+    - **For English:** spaCy runs **during** subtitle generation to find accurate sentence breaks after TTS.
+    - **Note:** spaCy segmentation is only applied when subtitle mode is `Sentence` or `Sentence + Comma`. When turned off, it falls back to simple punctuation-based splitting.
+- New option: **Pre-download models and voices for offline use** You can now pre-download all required Kokoro models, voices, and spaCy language models using this option in the settings menu. Allowing you to use Abogen completely offline without any internet connection.
+- Added support for `.` separator in timestamps (e.g. `HH:MM:SS.ms`) for timestamp-based text files.
+- Optimized regex compilation and eliminated busy-wait loops.
+- Possibly fixed `Silent truncation of long paragraphs` issue mentioned in [#91](https://github.com/denizsafak/abogen/issues/91) by [@xklzlxr](https://github.com/xklzlxr)
+- Fixed unused regex patterns and variable naming conventions.
+- Improvements in code and documentation.
+
+# 1.2.3
+- Same as 1.2.2, re-released to fix an issue with subtitle timing when using timestamp-based text files.
+
+# 1.2.2
+- **You can now voice your subtitle files!** Simply add `.srt`, `.ass` or `.vtt` files to generate timed audio. Alternatively, add a text file with timestamps in `HH:MM:SS` or `HH:MM:SS,ms` format to generate audio that matches the timestamps. See [here](https://github.com/denizsafak/abogen?tab=readme-ov-file#about-timestamp-based-text-files) for detailed instructions.
+    - New option: **"Use silent gaps between subtitles"**: Prevents unnecessary audio speed-up by letting speech continue into the silent gaps between subtitles.
+    - New option: **"Subtitle speed adjustment method"**: Choose how to speed up audio when needed:
+        - **TTS Regeneration (better quality):** Re-generates the audio at a faster speed for more natural sound.
+        - **FFmpeg Time-stretch (better speed):** Quickly speeds up the generated audio.
+- Added support for embedding cover images in M4B files. Abogen now automatically extracts cover images from EPUB and PDF files. You can also manually specify a cover image using the `<<METADATA_COVER_PATH:path>>` tag in your text file. (To prevent MPV from showing the cover image, you can add `audio-display=no` to your MPV config file.)
+- Fixed `[WinError 1114] A dynamic link library (DLL) initialization routine failed` error on Windows, pre-loading PyTorch DLLs before initializing PyQt6 to avoid DLL initialization errors, mentioned in #98 by @ephr0n.
+- Potential fix for `CUDA GPU is not available` issue, by ensuring PyTorch is installed correctly with CUDA support on Windows using the installer script.
+- Improvements in code and documentation.
+
+# 1.2.1
+- Upgraded Abogen's interface from PyQt5 to PyQt6 for better compatibility and long-term support.
+- Added tooltip indicators in queue manager to display book handler options (`Save chapters separately` and `Merge chapters at the end`) for queued items.
+- Added `Open processed file` and `Open input file` options for items in the queue manager, instead of just `Open file` option.
+- Added loading gif animation to book handler window.
+- Fixed light theme slider colors in voice mixer for better visibility (for non-Windows users).
+- Fixed subtitle word-count splitting logic for more accurate segmentation.
+- Improvements in code and documentation.
+
+# 1.2.0
+- Added `Line` option to subtitle generation modes, allowing subtitles to be generated based on line breaks in the text, by @mleg in #94.
+- Added a loading indicator to the book handler window for better user experience during book preprocessing.
+- Fixed `cannot access local variable 'is_narrow'` error when subtitle format `SRT` was selected, mentioned by @Kinasa0096 in #88.
+- Fixed folder and filename sanitization to properly handle OS-specific illegal characters (Windows, Linux, macOS), ensuring compatibility across all platforms when creating chapter folders and files.
+- Fixed `/` and `\` path display by normalizing paths.
+- Fixed book reprocessing issue where books were being processed every time the chapters window was opened, improving performance when reopening the same book.
+- Fixed taskbar icon not appearing correctly in Windows.
+- Fixed “Go to folder” button not opening the chapter output directory when only separate chapters were generated.
+- Improvements in code and documentation.
+
 # 1.1.9
 - Fixed the issue where spaces were deleted before punctuation marks while generating subtitles.
 - Fixed markdown TOC generation breaks when "Replace single newlines" is enabled.

README.md

@@ -9,7 +9,7 @@
 
 <a href="https://trendshift.io/repositories/14433" target="_blank"><img src="https://trendshift.io/api/badge/repositories/14433" alt="denizsafak%2Fabogen | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>
 
-Abogen is a powerful text-to-speech conversion tool that makes it easy to turn ePub, PDF, text or markdown files into high-quality audio with matching subtitles in seconds. Use it for audiobooks, voiceovers for Instagram, YouTube, TikTok, or any project that needs natural-sounding text-to-speech, using [Kokoro-82M](https://huggingface.co/hexgrad/Kokoro-82M).
+Abogen is a powerful text-to-speech conversion tool that makes it easy to turn ePub, PDF, text, markdown, or subtitle files into high-quality audio with matching subtitles in seconds. Use it for audiobooks, voiceovers for Instagram, YouTube, TikTok, or any project that needs natural-sounding text-to-speech, using [Kokoro-82M](https://huggingface.co/hexgrad/Kokoro-82M).
 
 <img title="Abogen Main" src='https://raw.githubusercontent.com/denizsafak/abogen/refs/heads/main/demo/abogen.png' width="380"> <img title="Abogen Processing" src='https://raw.githubusercontent.com/denizsafak/abogen/refs/heads/main/demo/abogen2.png' width="380">
 
@@ -42,7 +42,8 @@ python -m venv venv
 venv\Scripts\activate
 
 # For NVIDIA GPUs:
-pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu128
+# We need to use an older version of PyTorch (2.8.0) until this issue is fixed: https://github.com/pytorch/pytorch/issues/166628
+pip install torch==2.8.0+cu128 torchvision==0.23.0+cu128 torchaudio==2.8.0 --index-url https://download.pytorch.org/whl/cu128
 
 # For AMD GPUs:
 # Not supported yet, because ROCm is not available on Windows. Use Linux if you have AMD GPU.
@@ -98,6 +99,8 @@ pip3 install --pre torch torchvision torchaudio --index-url https://download.pyt
 
 > See [How to fix "No matching distribution found" error?](#no-matching-distribution-found)
 
+> See [How to fix "[WinError 1114] A dynamic link library (DLL) initialization routine failed" error?](#WinError-1114)
+
 > See [How to use "uv" instead of "pip"?](#use-uv-instead-of-pip)
 
 > Special thanks to [@hg000125](https://github.com/hg000125) for his contribution in [#23](https://github.com/denizsafak/abogen/issues/23). AMD GPU support is possible thanks to his work.
@@ -112,7 +115,7 @@ abogen
 > If you installed Abogen using the Windows installer `(WINDOWS_INSTALL.bat)`, It should have created a shortcut in the same folder, or your desktop. You can run it from there. If you lost the shortcut, Abogen is located in `python_embedded/Scripts/abogen.exe`. You can run it from there directly.
 
 ## `How to use?`
-1) Drag and drop any ePub, PDF, text or markdown file (or use the built-in text editor)
+1) Drag and drop any ePub, PDF, text, markdown, or subtitle file (or use the built-in text editor)
 2) Configure the settings:
     - Set speech speed
     - Select a voice (or create a custom voice using voice mixer)
@@ -130,13 +133,13 @@ Here’s Abogen in action: in this demo, it processes ∼3,000 characters of tex
 
 | Options | Description |
 |---------|-------------|
-| **Input Box** | Drag and drop `ePub`, `PDF`, `.TXT` or `.MD` files (or use built-in text editor) |
+| **Input Box** | Drag and drop `ePub`, `PDF`, `.TXT`, `.MD`, `.SRT`, `.ASS` or `.VTT` files (or use built-in text editor) |
 | **Queue options** | Add multiple files to a queue and process them in batch, with individual settings for each file. See [Queue mode](#queue-mode) for more details. |
 | **Speed** | Adjust speech rate from `0.1x` to `2.0x` |
 | **Select Voice** | First letter of the language code (e.g., `a` for American English, `b` for British English, etc.), second letter is for `m` for male and `f` for female. |
 | **Voice mixer** | Create custom voices by mixing different voice models with a profile system. See [Voice Mixer](#voice-mixer) for more details. |
 | **Voice preview** | Listen to the selected voice before processing. |
-| **Generate subtitles** | `Disabled`, `Sentence`, `Sentence + Comma`, `Sentence + Highlighting`, `1 word`, `2 words`, `3 words`, etc. (Represents the number of words in each subtitle entry) |
+| **Generate subtitles** | `Disabled`, `Line`, `Sentence`, `Sentence + Comma`, `Sentence + Highlighting`, `1 word`, `2 words`, `3 words`, etc. (Represents the number of words in each subtitle entry) |
 | **Output voice format** | `.WAV`, `.FLAC`, `.MP3`, `.OPUS (best compression)` and `M4B (with chapters)` |
 | **Output subtitle format** | Configures the subtitle format as `SRT (standard)`, `ASS (wide)`, `ASS (narrow)`, `ASS (centered wide)`, or `ASS (centered narrow)`. |
 | **Replace single newlines with spaces** | Replaces single newlines with spaces in the text. This is useful for texts that have imaginary line breaks. |
@@ -146,6 +149,8 @@ Here’s Abogen in action: in this demo, it processes ∼3,000 characters of tex
 
 > Special thanks to [@jborza](https://github.com/jborza) for chapter support in PR [#10](https://github.com/denizsafak/abogen/pull/10)
 
+> Special thanks to [@mleg](https://github.com/mleg) for adding `Line` option in subtitle generation in PR [#94](https://github.com/denizsafak/abogen/pull/94)
+
 | Book handler options | Description |
 |---------|-------------|
 | **Chapter Control** | Select specific `chapters` from ePUBs or markdown files or `chapters + pages` from PDFs. |
@@ -164,8 +169,12 @@ Here’s Abogen in action: in this demo, it processes ∼3,000 characters of tex
 | **Open config directory** | Opens the directory where the configuration file is stored. |
 | **Open cache directory** | Opens the cache directory where converted text files are stored. |
 | **Clear cache files** | Deletes cache files created during the conversion or preview. |
-| **Check for updates at startup** | Automatically checks for updates when the program starts. |
+| **Use silent gaps between subtitles** | Prevents unnecessary audio speed-up by letting speech continue into the silent gaps between subtitle etries. In short, it ignores the end times in subtitle entries and uses the silent space until the beginning of the next subtitle entry. When disabled, it speeds up the audio to fit the exact time interval specified in the subtitle. (for subtitle files). |
+| **Subtitle speed adjustment method** | Choose how to speed up audio when needed: `TTS Regeneration (better quality)` re-generates the audio at a faster speed, while `FFmpeg Time-stretch (better speed)` quickly speeds up the generated audio. (for subtitle files). |
+| **Use spaCy for sentence segmentation** | When this option is enabled, Abogen uses [spaCy](https://spacy.io/) to detect sentence boundaries more accurately, instead of using punctuation marks (like periods, question marks, etc.) to split sentences, which could incorrectly cut off phrases like "Mr." or "Dr.". With spaCy, sentences are divided more accurately. For non-English text, spaCy runs **before** audio generation to create sentence chunks. For English text, spaCy runs **during** subtitle generation to improve timing and readability. spaCy is only used when subtitle mode is `Sentence` or `Sentence + Comma`. If you prefer the old punctuation splitting method, you can turn this option off. |
+| **Pre-download models and voices for offline use** | Opens a window that displays the available models and voices. Click `Download all` button to download all required models and voices, allowing you to use Abogen completely offline without any internet connection. |
 | **Disable Kokoro's internet access** | Prevents Kokoro from downloading models or voices from HuggingFace Hub, useful for offline use. |
+| **Check for updates at startup** | Automatically checks for updates when the program starts. |
 | **Reset to default settings** | Resets all settings to their default values. |
 
 > Special thanks to [@robmckinnon](https://github.com/robmckinnon) for adding Sentence + Highlighting feature in PR [#65](https://github.com/denizsafak/abogen/pull/65)
@@ -223,7 +232,30 @@ Similar to chapter markers, it is possible to add metadata tags for `M4B` files.
 <<METADATA_ALBUM_ARTIST:Album Artist>>
 <<METADATA_COMPOSER:Narrator>>
 <<METADATA_GENRE:Audiobook>>
+<<METADATA_COVER_PATH:path/to/cover.jpg>>
 ```
+> Note: `METADATA_COVER_PATH` is used to embed a cover image into the generated M4B file. Abogen automatically extracts the cover from EPUB and PDF files and adds this tag for you.
+
+## `About Timestamp-based Text Files`
+Similar to converting subtitle files to audio, Abogen can automatically detect text files that contain timestamps in `HH:MM:SS`, `HH:MM:SS,ms` or `HH:MM:SS.ms` format. When timestamps are found inside your text file, Abogen will ask if you want to use them for audio timing. This is useful for creating timed narrations, scripts, or transcripts where you need exact control over when each segment is spoken.
+
+Format your text file like this:
+```
+00:00:00
+This is the first segment of text.
+
+00:00:15
+This is the second segment, starting at 15 seconds.
+
+00:00:45
+And this is the third segment, starting at 45 seconds.
+```
+
+**Important notes:**
+- Timestamps must be in `HH:MM:SS`, `HH:MM:SS,ms` or `HH:MM:SS.ms` format (e.g., `00:05:30` for 5 minutes 30 seconds, or `00:05:30.500` for 5 minutes 30.5 seconds)
+- Milliseconds are optional and provide precision up to 1/1000th of a second
+- Text before the first timestamp (if any) will automatically start at `00:00:00`
+- When using timestamps, the subtitle generation mode setting is ignored
 
 ## `Supported Languages`
 ```
@@ -246,6 +278,7 @@ I highly recommend using [MPV](https://mpv.io/installation/) to play your audio
 # --- MPV Settings ---
 save-position-on-quit
 keep-open=yes
+audio-display=no
 # --- Subtitle ---
 sub-ass-override=no
 sub-margin-y=50
@@ -341,14 +374,20 @@ This will start Abogen in command-line mode and display detailed error messages.
 <a name="cuda-warning">How to fix "CUDA GPU is not available. Using CPU" warning?</a>
 </b></summary>
 
-> This message means PyTorch couldn't use your GPU. On Windows, Abogen supports NVIDIA GPUs with CUDA. AMD GPUs are supported only on Linux. Abogen will still run on the CPU, but it will be slower.
+> This message means PyTorch could not use your GPU and has fallen back to the CPU. On Windows, Abogen only supports NVIDIA GPUs with CUDA. AMD GPUs are not supported on Windows (they are only supported on Linux with ROCm). Abogen will still work on the CPU, but processing will be slower compared to a supported GPU.
 >
 > If you have a compatible NVIDIA GPU on Windows and still see this warning:
 > Open your terminal in the Abogen folder (the folder that contains `python_embedded`) and type:
 > ```bash
-> python_embedded\python.exe -m pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu128
+> python_embedded\python.exe -m pip install --force-reinstall torch==2.8.0+cu128 torchvision==0.23.0+cu128 torchaudio==2.8.0 --index-url https://download.pytorch.org/whl/cu128
 > ```
-> If you have an AMD GPU, use Linux and follow the Linux/ROCm [instructions](#how-to-install-). If you want to keep running on CPU, no action is required, but performance will just be reduced. See [#32](https://github.com/denizsafak/abogen/issues/32) for more details.
+>
+> If this does not resolve the issue and you are using an older NVIDIA GPU that does not support CUDA 12.8, you can try installing an older version of PyTorch that supports your GPU. For example, for CUDA 12.6, run:
+> ```bash
+> python_embedded\python.exe -m pip install --force-reinstall torch==2.8.0+cu126 torchvision==0.23.0+cu126 torchaudio==2.8.0 --index-url https://download.pytorch.org/whl/cu126
+> ```
+> 
+> If you have an AMD GPU, you need to use Linux and follow the Linux/ROCm [instructions](#linux). If you want to keep running on CPU, no action is required, but performance will just be reduced. See [#32](https://github.com/denizsafak/abogen/issues/32) for more details.
 
 </details>
 
@@ -371,6 +410,22 @@ This will start Abogen in command-line mode and display detailed error messages.
 
 </details>
 
+<details><summary><b>
+<a name="WinError-1114">How to fix "[WinError 1114] A dynamic link library (DLL) initialization routine failed" error?</a>
+</b></summary>
+
+> I faced this error when trying to run Abogen in a virtual Windows machine without GPU support. Here's how I fixed it:
+> If you installed Abogen using the Windows installer `(WINDOWS_INSTALL.bat)`, go to Abogen's folder (that contains `python_embedded`), open your terminal there and run:
+> ```bash
+> python_embedded\python.exe -m pip install --force-reinstall torch==2.8.0+cu128 torchvision==0.23.0+cu128 torchaudio==2.8.0 --index-url https://download.pytorch.org/whl/cu128
+> ```
+> If you installed Abogen using pip, open your terminal in the virtual environment and run:
+> ```bash
+> pip install torch==2.8.0 torchaudio==2.8.0 torchvision==0.23.0
+> ```
+
+</details>
+
 <details><summary><b>
 <a name="japanese-audio-not-working">How to fix Japanese audio not working?</a>
 </b></summary>
@@ -392,6 +447,22 @@ This will start Abogen in command-line mode and display detailed error messages.
 
 </details>
 
+<details><summary><b>
+<a name="use-uv-instead-of-pip">How to uninstall Abogen?</a>
+</b></summary>
+
+> - From the settings menu, go to `Open configuration directory` and delete the directory.
+> - From the settings menu, go to `Open cache directory` and delete the directory.
+> - If you installed Abogen using pip, type:
+>```bash
+>pip uninstall abogen # uninstalls abogen
+>pip cache purge # removes pip cache
+>```
+> - If you installed Abogen using the Windows installer (WINDOWS_INSTALL.bat), just remove the folder that contains Abogen. It installs everything inside `python_embedded` folder, no other directories are created.
+> - If you installed espeak-ng, you need to remove it separately.
+
+</details>
+
 ## `Contributing`
 I welcome contributions! If you have ideas for new features, improvements, or bug fixes, please fork the repository and submit a pull request.
 ### For developers and contributors
@@ -407,6 +478,7 @@ Feel free to explore the code and make any changes you like.
 
 ## `Credits`
 - Abogen uses [Kokoro](https://github.com/hexgrad/kokoro) for its high-quality, natural-sounding text-to-speech synthesis. Huge thanks to the Kokoro team for making this possible.
+- Thanks to the [spaCy](https://spacy.io/) project for its sentence-segmentation tools, which help Abogen produce cleaner, more natural sentence segmentation.
 - Thanks to [@wojiushixiaobai](https://github.com/wojiushixiaobai) for [Embedded Python](https://github.com/wojiushixiaobai/Python-Embed-Win64) packages. These modified packages include pip pre-installed, enabling Abogen to function as a standalone application without requiring users to separately install Python in Windows.
 - Thanks to creators of [EbookLib](https://github.com/aerkalov/ebooklib), a Python library for reading and writing ePub files, which is used for extracting text from ePub files.
 - Special thanks to the [PyQt](https://www.riverbankcomputing.com/software/pyqt/) team for providing the cross-platform GUI toolkit that powers Abogen's interface.
@@ -419,7 +491,7 @@ This project is available under the MIT License - see the [LICENSE](https://gith
 ## `Star History`
 [![Star History Chart](https://api.star-history.com/svg?repos=denizsafak/abogen&type=Date)](https://www.star-history.com/#denizsafak/abogen&Date)
 
-> [!IMPORTANT]
+> [!NOTE]
-> Subtitle generation currently works only for English. This is because Kokoro provides timestamp tokens only for English text. If you want subtitles in other languages, please request this feature in the [Kokoro project](https://github.com/hexgrad/kokoro). For more technical details, see [this line](https://github.com/hexgrad/kokoro/blob/6d87f4ae7abc2d14dbc4b3ef2e5f19852e861ac2/kokoro/pipeline.py#L383) in the Kokoro's code.
+> Abogen supports subtitle generation for all languages. However, word-level subtitle modes (e.g., "1 word", "2 words", "3 words", etc.) are only available for English because [Kokoro provides timestamp tokens only for English text](https://github.com/hexgrad/kokoro/blob/6d87f4ae7abc2d14dbc4b3ef2e5f19852e861ac2/kokoro/pipeline.py#L383). For non-English languages, Abogen uses a duration-based fallback that supports sentence-level and comma-based subtitle modes ("Line", "Sentence", "Sentence + Comma"). If you need word-level subtitles for other languages, please request that feature in the [Kokoro project](https://github.com/hexgrad/kokoro).
 
-> Tags: audiobook, kokoro, text-to-speech, TTS, audiobook generator, audiobooks, text to speech, audiobook maker, audiobook creator, audiobook generator, voice-synthesis, text to audio, text to audio converter, text to speech converter, text to speech generator, text to speech software, text to speech app, epub to audio, pdf to audio, markdown to audio, content-creation, media-generation
+> Tags: audiobook, kokoro, text-to-speech, TTS, audiobook generator, audiobooks, text to speech, audiobook maker, audiobook creator, audiobook generator, voice-synthesis, text to audio, text to audio converter, text to speech converter, text to speech generator, text to speech software, text to speech app, epub to audio, pdf to audio, markdown to audio, subtitle to audio, srt to audio, ass to audio, vtt to audio, webvtt to audio, content-creation, media-generation

WINDOWS_INSTALL.bat

@@ -8,9 +8,6 @@ cd /d "%~dp0"
 :: Japanese: "ja"
 set MISAKI_LANG=en
 
-:: Set PyTorch CUDA version
-set CUDA_VERSION=128
-
 :::
 :::      _    ____   ___   ____  _____ _   _ 
 :::     / \  | __ ) / _ \ / ___|| ____| \ | |
@@ -139,10 +136,10 @@ if exist "%VERSION_FILE%" (
 REM Python embedded download configuration for different architectures
 if "%PROCESSOR_ARCHITECTURE%"=="x86" (
     set PYTHON_EMBEDDED_FILE=%PROJECTFOLDER%\python_embedded_win32.zip
-    set PYTHON_EMBEDDED_URL=https://github.com/wojiushixiaobai/Python-Embed-Win64/releases/download/3.12.8/python-3.12.8-embed-win32.zip
+    set PYTHON_EMBEDDED_URL=https://github.com/wojiushixiaobai/Python-Embed-Win64/releases/download/3.12.12/python-3.12.12-embed-win32.zip
 ) else (
     set PYTHON_EMBEDDED_FILE=%PROJECTFOLDER%\python_embedded_amd64.zip
-    set PYTHON_EMBEDDED_URL=https://github.com/wojiushixiaobai/Python-Embed-Win64/releases/download/3.12.8/python-3.12.8-embed-amd64.zip
+    set PYTHON_EMBEDDED_URL=https://github.com/wojiushixiaobai/Python-Embed-Win64/releases/download/3.12.12/python-3.12.12-embed-amd64.zip
 )
 
 :: Check if Python exists
@@ -281,8 +278,10 @@ if /I "%IS_NVIDIA%"=="true" (
     for /f %%i in ('%PYTHON_CONSOLE_PATH% -c "from torch.cuda import is_available; print(is_available())"') do set cuda_available=%%i
 
     if "%cuda_available%"=="False" (
-        echo Installing PyTorch with CUDA %CUDA_VERSION% support...
+        echo "Installing PyTorch with CUDA (12.8) support..."
-        %PYTHON_CONSOLE_PATH% -m pip install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cu%CUDA_VERSION% --no-warn-script-location
+        :: We need to use an older version of PyTorch (2.8.0) until this issue is fixed: https://github.com/pytorch/pytorch/issues/166628
+        :: Solution mentioned by @mazenemam19 in #99:
+        %PYTHON_CONSOLE_PATH% -m pip install torch==2.8.0+cu128 torchvision==0.23.0+cu128 torchaudio==2.8.0 --index-url https://download.pytorch.org/whl/cu128 --no-warn-script-location
         echo.
         if errorlevel 1 (
             echo Failed to install PyTorch.
@@ -305,8 +304,10 @@ if /I "%IS_NVIDIA%"=="true" (
     if errorlevel 2 (
         echo Skipping PyTorch installation.
     ) else (
-        echo Installing PyTorch with CUDA %CUDA_VERSION% support...
+        echo "Installing PyTorch with CUDA (12.8) support..."
-        %PYTHON_CONSOLE_PATH% -m pip install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cu%CUDA_VERSION% --no-warn-script-location
+        :: We need to use an older version of PyTorch (2.8.0) until this issue is fixed: https://github.com/pytorch/pytorch/issues/166628
+        :: Solution mentioned by @mazenemam19 in #99:
+        %PYTHON_CONSOLE_PATH% -m pip install torch==2.8.0+cu128 torchvision==0.23.0+cu128 torchaudio==2.8.0 --index-url https://download.pytorch.org/whl/cu128 --no-warn-script-location
         if errorlevel 1 (
             echo Failed to install PyTorch.
             pause

abogen/Dockerfile

@@ -12,8 +12,10 @@ RUN apt-get update \
         python3 \
         python3-venv \
         python3-pip \
-        python3-pyqt5 \
+        python3-pyqt6 \
         espeak-ng \
+        libxcb-cursor0 \
+        libgl1 \
  && apt-get clean \
  && rm -rf /var/lib/apt/lists/*
 

abogen/VERSION

@@ -1 +1 @@
-1.1.9
+1.2.4

abogen/constants.py

@@ -2,9 +2,7 @@ from abogen.utils import get_version
 
 # Program Information
 PROGRAM_NAME = "abogen"
-PROGRAM_DESCRIPTION = (
+PROGRAM_DESCRIPTION = "Generate audiobooks from EPUBs, PDFs, text and subtitles with synchronized captions."
-    "Generate audiobooks from EPUBs, PDFs and text with synchronized captions."
-)
 GITHUB_URL = "https://github.com/denizsafak/abogen"
 VERSION = get_version()
 
@@ -44,6 +42,7 @@ SUPPORTED_SOUND_FORMATS = [
 SUPPORTED_SUBTITLE_FORMATS = [
     "srt",
     "ass",
+    "vtt",
 ]
 
 # Supported input formats
@@ -51,6 +50,9 @@ SUPPORTED_INPUT_FORMATS = [
     "epub",
     "pdf",
     "txt",
+    "srt",
+    "ass",
+    "vtt",
 ]
 
 # Supported languages for subtitle generation
@@ -59,10 +61,7 @@ SUPPORTED_INPUT_FORMATS = [
 # Please refer to: https://github.com/hexgrad/kokoro/blob/6d87f4ae7abc2d14dbc4b3ef2e5f19852e861ac2/kokoro/pipeline.py
 # 383 English processing (unchanged)
 # 384 if self.lang_code in 'ab':
-SUPPORTED_LANGUAGES_FOR_SUBTITLE_GENERATION = [
+SUPPORTED_LANGUAGES_FOR_SUBTITLE_GENERATION = list(LANGUAGE_DESCRIPTIONS.keys())
-    "a",
-    "b",
-]
 
 # Voice and sample text constants
 VOICES_INTERNAL = [
@@ -148,6 +147,7 @@ COLORS = {
     "BLUE_BORDER_HOVER": "#6ab0de",
     "YELLOW_BACKGROUND": "rgba(255, 221, 51, 0.40)",
     "GREY_BACKGROUND": "rgba(128, 128, 128, 0.15)",
+    "GREY_BORDER": "#808080",
     "RED_BACKGROUND": "rgba(232, 78, 60, 0.15)",
     "RED_BG": "rgba(232, 78, 60, 0.10)",
     "RED_BG_HOVER": "rgba(232, 78, 60, 0.15)",

abogen/main.py

@@ -1,26 +1,65 @@
-from json import load
 import os
 import sys
 import platform
 import atexit
 import signal
 
+# Fix PyTorch DLL loading issue ([WinError 1114]) on Windows before importing PyQt6
+if platform.system() == "Windows":
+    import ctypes
+    from importlib.util import find_spec
+
+    try:
+        if (
+            (spec := find_spec("torch"))
+            and spec.origin
+            and os.path.exists(
+                dll_path := os.path.join(os.path.dirname(spec.origin), "lib", "c10.dll")
+            )
+        ):
+            ctypes.CDLL(os.path.normpath(dll_path))
+    except Exception:
+        pass
+
 # Qt platform plugin detection (fixes #59)
 try:
-    from PyQt5.QtCore import QLibraryInfo
+    from PyQt6.QtCore import QLibraryInfo
-    plugins = QLibraryInfo.location(QLibraryInfo.PluginsPath)
+
-    platform_dir = os.path.join(plugins, "platforms")
+    # Get the path to the plugins directory
+    plugins = QLibraryInfo.path(QLibraryInfo.LibraryPath.PluginsPath)
+
+    # Normalize path to use the OS-native separators and absolute path
+    platform_dir = os.path.normpath(os.path.join(plugins, "platforms"))
+
+    # Ensure we work with an absolute path for clarity
+    platform_dir = os.path.abspath(platform_dir)
+
     if os.path.isdir(platform_dir):
         os.environ["QT_QPA_PLATFORM_PLUGIN_PATH"] = platform_dir
         print("QT_QPA_PLATFORM_PLUGIN_PATH set to:", platform_dir)
     else:
-        print("PyQt5 platform plugins not found at", platform_dir)
+        print("PyQt6 platform plugins not found at", platform_dir)
 except ImportError:
-    print("PyQt5 not installed.")
+    print("PyQt6 not installed.")
 
-from PyQt5.QtWidgets import QApplication
+# Set application ID for Windows taskbar icon
-from PyQt5.QtGui import QIcon
+if platform.system() == "Windows":
-from PyQt5.QtCore import qInstallMessageHandler, QtMsgType
+    try:
+        from abogen.constants import PROGRAM_NAME, VERSION
+        import ctypes
+
+        app_id = f"{PROGRAM_NAME}.{VERSION}"
+        ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(app_id)
+    except Exception as e:
+        print("Warning: failed to set AppUserModelID:", e)
+
+from PyQt6.QtWidgets import QApplication
+from PyQt6.QtGui import QIcon
+from PyQt6.QtCore import (
+    QLibraryInfo,
+    qInstallMessageHandler,
+    QtMsgType,
+)
 
 # Add the directory to Python path
 sys.path.insert(0, os.path.join(os.path.dirname(__file__)))
@@ -69,10 +108,12 @@ if platform.system() == "Darwin" and platform.processor() == "arm":
 
 # Custom message handler to filter out specific Qt warnings
 def qt_message_handler(mode, context, message):
+    # In PyQt6, the mode is an enum, so we compare with the enum members
     if "Wayland does not support QWindow::requestActivate()" in message:
         return  # Suppress this specific message
     if "setGrabPopup called with a parent, QtWaylandClient" in message:
         return
+
     if mode == QtMsgType.QtWarningMsg:
         print(f"Qt Warning: {message}")
     elif mode == QtMsgType.QtCriticalMsg:
@@ -86,13 +127,6 @@ def qt_message_handler(mode, context, message):
 # Install the custom message handler
 qInstallMessageHandler(qt_message_handler)
 
-# Set application ID for Windows taskbar icon
-if platform.system() == "Windows":
-    import ctypes
-
-    app_id = f"{PROGRAM_NAME}.{VERSION}"
-    ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(app_id)
-
 # Handle Wayland on Linux GNOME
 if platform.system() == "Linux":
     xdg_session = os.environ.get("XDG_SESSION_TYPE", "").lower()
@@ -117,13 +151,13 @@ def main():
     # Set the .desktop name on Linux
     if platform.system() == "Linux":
         try:
-            app.setDesktopFileName("abogen.desktop")
+            app.setDesktopFileName("abogen")
         except AttributeError:
             pass
 
     ex = abogen()
     ex.show()
-    sys.exit(app.exec_())
+    sys.exit(app.exec())
 
 
 if __name__ == "__main__":

abogen/predownload_gui.py

@@ -0,0 +1,590 @@
+"""
+Pre-download dialog and worker for Abogen
+
+This module consolidates pre-download logic for Kokoro voices and model
+and spaCy language models. The code favors clarity, avoids duplication,
+and handles optional dependencies gracefully.
+"""
+
+from typing import List, Optional, Tuple
+import importlib
+import importlib.util
+
+from PyQt6.QtWidgets import (
+    QDialog,
+    QVBoxLayout,
+    QHBoxLayout,
+    QLabel,
+    QPushButton,
+    QSpacerItem,
+    QSizePolicy,
+)
+from PyQt6.QtCore import QThread, pyqtSignal
+
+from abogen.constants import COLORS, VOICES_INTERNAL
+from abogen.spacy_utils import SPACY_MODELS
+import abogen.hf_tracker
+
+
+# Helpers
+def _unique_sorted_models() -> List[str]:
+    """Return a sorted list of unique spaCy model package names."""
+    return sorted(set(SPACY_MODELS.values()))
+
+
+def _is_package_installed(pkg_name: str) -> bool:
+    """Return True if a package with the given name can be imported (site-packages)."""
+    try:
+        return importlib.util.find_spec(pkg_name) is not None
+    except Exception:
+        return False
+
+
+# NOTE: explicit HF cache helper removed; we use try_to_load_from_cache in-scope where needed
+
+
+class PreDownloadWorker(QThread):
+    """Worker thread to download required models/voices.
+
+    Emits human-readable messages via `progress`. Uses `category_done` to indicate
+    a category (voices/model/spacy) finished successfully. Emits `error` on exception
+    and `finished` after all work completes.
+    """
+
+    # Emit (category, status, message)
+    progress = pyqtSignal(str, str, str)
+    category_done = pyqtSignal(str)
+    finished = pyqtSignal()
+    error = pyqtSignal(str)
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self._cancelled = False
+        # repo and filenames used for Kokoro model
+        self._repo_id = "hexgrad/Kokoro-82M"
+        self._model_files = ["kokoro-v1_0.pth", "config.json"]
+        # Track download success per category
+        self._voices_success = False
+        self._model_success = False
+        self._spacy_success = False
+        # Suppress HF tracker warnings during downloads
+        self._original_emitter = abogen.hf_tracker.show_warning_signal_emitter
+
+    def cancel(self) -> None:
+        self._cancelled = True
+
+    def run(self) -> None:
+        # Suppress HF tracker warnings during downloads
+        abogen.hf_tracker.show_warning_signal_emitter = None
+        try:
+            self._download_kokoro_voices()
+            if self._cancelled:
+                return
+            if self._voices_success:
+                self.category_done.emit("voices")
+
+            self._download_kokoro_model()
+            if self._cancelled:
+                return
+            if self._model_success:
+                self.category_done.emit("model")
+
+            self._download_spacy_models()
+            if self._cancelled:
+                return
+            if self._spacy_success:
+                self.category_done.emit("spacy")
+
+            self.finished.emit()
+        except Exception as exc:  # pragma: no cover - best-effort reporting
+            self.error.emit(str(exc))
+        finally:
+            # Restore original emitter
+            abogen.hf_tracker.show_warning_signal_emitter = self._original_emitter
+
+    # Kokoro voices
+    def _download_kokoro_voices(self) -> None:
+        self._voices_success = True
+        try:
+            from huggingface_hub import hf_hub_download, try_to_load_from_cache
+        except Exception:
+            self.progress.emit(
+                "voice", "warning", "huggingface_hub not installed, skipping voices..."
+            )
+            self._voices_success = False
+            return
+
+        voice_list = VOICES_INTERNAL
+        for idx, voice in enumerate(voice_list, start=1):
+            if self._cancelled:
+                self._voices_success = False
+                return
+            filename = f"voices/{voice}.pt"
+            if try_to_load_from_cache(repo_id=self._repo_id, filename=filename):
+                self.progress.emit(
+                    "voice",
+                    "installed",
+                    f"{idx}/{len(voice_list)}: {voice} already present",
+                )
+                continue
+            self.progress.emit(
+                "voice", "downloading", f"{idx}/{len(voice_list)}: {voice}..."
+            )
+            try:
+                hf_hub_download(repo_id=self._repo_id, filename=filename)
+                self.progress.emit("voice", "downloaded", f"{voice} downloaded")
+            except Exception as exc:
+                self.progress.emit(
+                    "voice", "warning", f"could not download {voice}: {exc}"
+                )
+                self._voices_success = False
+
+    # Kokoro model
+    def _download_kokoro_model(self) -> None:
+        self._model_success = True
+        try:
+            from huggingface_hub import hf_hub_download, try_to_load_from_cache
+        except Exception:
+            self.progress.emit(
+                "model", "warning", "huggingface_hub not installed, skipping model..."
+            )
+            self._model_success = False
+            return
+        for fname in self._model_files:
+            if self._cancelled:
+                self._model_success = False
+                return
+            category = "config" if fname == "config.json" else "model"
+            if try_to_load_from_cache(repo_id=self._repo_id, filename=fname):
+                self.progress.emit(
+                    category, "installed", f"file {fname} already present"
+                )
+                continue
+            self.progress.emit(category, "downloading", f"file {fname}...")
+            try:
+                hf_hub_download(repo_id=self._repo_id, filename=fname)
+                self.progress.emit(category, "downloaded", f"file {fname} downloaded")
+            except Exception as exc:
+                self.progress.emit(
+                    category, "warning", f"could not download file {fname}: {exc}"
+                )
+                self._model_success = False
+
+    # spaCy models
+    def _download_spacy_models(self) -> None:
+        """Download spaCy models. Prefer missing models provided by parent.
+
+        Parent dialog will populate _spacy_models_missing during checking.
+        """
+        self._spacy_success = True
+        # Determine which models to process: prefer parent-provided missing list to avoid
+        # re-checking everything; otherwise use the full unique list.
+        parent = self.parent()
+        models_to_process: List[str] = _unique_sorted_models()
+        try:
+            if (
+                parent is not None
+                and hasattr(parent, "_spacy_models_missing")
+                and parent._spacy_models_missing
+            ):
+                models_to_process = list(dict.fromkeys(parent._spacy_models_missing))
+        except Exception:
+            pass
+
+        # If spaCy is not available to run the CLI, skip gracefully
+        try:
+            import spacy.cli as _spacy_cli
+        except Exception:
+            self.progress.emit(
+                "spacy", "warning", "spaCy not available, skipping spaCy models..."
+            )
+            self._spacy_success = False
+            return
+
+        for idx, model_name in enumerate(models_to_process, start=1):
+            if self._cancelled:
+                self._spacy_success = False
+                return
+            if _is_package_installed(model_name):
+                self.progress.emit(
+                    "spacy",
+                    "installed",
+                    f"{idx}/{len(models_to_process)}: {model_name} already installed",
+                )
+                continue
+            self.progress.emit(
+                "spacy",
+                "downloading",
+                f"{idx}/{len(models_to_process)}: {model_name}...",
+            )
+            try:
+                _spacy_cli.download(model_name)
+                self.progress.emit("spacy", "downloaded", f"{model_name} downloaded")
+            except Exception as exc:
+                self.progress.emit(
+                    "spacy", "warning", f"could not download {model_name}: {exc}"
+                )
+                self._spacy_success = False
+
+
+class PreDownloadDialog(QDialog):
+    """Dialog to show and control pre-download process."""
+
+    VOICE_PREFIX = "Kokoro voices: "
+    MODEL_PREFIX = "Kokoro model: "
+    CONFIG_PREFIX = "Kokoro config: "
+    SPACY_PREFIX = "spaCy models: "
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle("Pre-download Models and Voices")
+        self.setMinimumWidth(500)
+        self.worker: Optional[PreDownloadWorker] = None
+        self.has_missing = False
+        self._spacy_models_checked: List[tuple] = []
+        self._spacy_models_missing: List[str] = []
+        self._status_worker = None
+
+        # Map keywords to (label, prefix) - labels filled after UI creation
+        self.status_map = {
+            "voice": (None, self.VOICE_PREFIX),
+            "spacy": (None, self.SPACY_PREFIX),
+            "model": (None, self.MODEL_PREFIX),
+            "config": (None, self.CONFIG_PREFIX),
+        }
+
+        self.category_map = {
+            "voices": ["voice"],
+            "model": ["model", "config"],
+            "spacy": ["spacy"],
+        }
+
+        self._setup_ui()
+        self._start_status_check()
+
+    def _setup_ui(self) -> None:
+        layout = QVBoxLayout(self)
+        layout.setSpacing(0)
+        layout.setContentsMargins(15, 0, 15, 15)
+
+        desc = QLabel(
+            "You can pre-download all required models and voices for offline use.\n"
+            "This includes Kokoro voices, Kokoro model (and config), and spaCy models."
+        )
+        desc.setWordWrap(True)
+        layout.addWidget(desc)
+
+        # Status rows
+        status_layout = QVBoxLayout()
+        status_title = QLabel("<b>Current Status:</b>")
+        status_layout.addWidget(status_title)
+
+        self.voices_status = QLabel(self.VOICE_PREFIX + "⏳ Checking...")
+        row = QHBoxLayout()
+        row.addWidget(self.voices_status)
+        row.addStretch()
+        status_layout.addLayout(row)
+
+        self.model_status = QLabel(self.MODEL_PREFIX + "⏳ Checking...")
+        row = QHBoxLayout()
+        row.addWidget(self.model_status)
+        row.addStretch()
+        status_layout.addLayout(row)
+
+        self.config_status = QLabel(self.CONFIG_PREFIX + "⏳ Checking...")
+        row = QHBoxLayout()
+        row.addWidget(self.config_status)
+        row.addStretch()
+        status_layout.addLayout(row)
+
+        self.spacy_status = QLabel(self.SPACY_PREFIX + "⏳ Checking...")
+        row = QHBoxLayout()
+        row.addWidget(self.spacy_status)
+        row.addStretch()
+        status_layout.addLayout(row)
+
+        # register labels
+        self.status_map["voice"] = (self.voices_status, self.VOICE_PREFIX)
+        self.status_map["model"] = (self.model_status, self.MODEL_PREFIX)
+        self.status_map["config"] = (self.config_status, self.CONFIG_PREFIX)
+        self.status_map["spacy"] = (self.spacy_status, self.SPACY_PREFIX)
+
+        layout.addLayout(status_layout)
+
+        layout.addItem(
+            QSpacerItem(0, 20, QSizePolicy.Policy.Minimum, QSizePolicy.Policy.Fixed)
+        )
+
+        # Buttons
+        button_row = QHBoxLayout()
+        button_row.setSpacing(10)
+        self.download_btn = QPushButton("Download all")
+        self.download_btn.setMinimumWidth(100)
+        self.download_btn.setMinimumHeight(35)
+        self.download_btn.setEnabled(False)
+        self.download_btn.clicked.connect(self._start_download)
+        button_row.addWidget(self.download_btn)
+
+        self.close_btn = QPushButton("Close")
+        self.close_btn.setMinimumWidth(100)
+        self.close_btn.setMinimumHeight(35)
+        self.close_btn.clicked.connect(self._handle_close)
+        button_row.addWidget(self.close_btn)
+
+        layout.addLayout(button_row)
+        self.adjustSize()
+
+    # Status checking worker
+    class StatusCheckWorker(QThread):
+        voices_checked = pyqtSignal(bool, list)
+        model_checked = pyqtSignal(bool)
+        config_checked = pyqtSignal(bool)
+        spacy_model_checking = pyqtSignal(str)
+        spacy_model_result = pyqtSignal(str, bool)
+        spacy_checked = pyqtSignal(bool, list)
+
+        def run(self):
+            parent = self.parent()
+            if parent is None:
+                return
+
+            voices_ok, missing_voices = parent._check_kokoro_voices()
+            self.voices_checked.emit(voices_ok, missing_voices)
+
+            model_ok = parent._check_kokoro_model()
+            self.model_checked.emit(model_ok)
+
+            config_ok = parent._check_kokoro_config()
+            self.config_checked.emit(config_ok)
+
+            # Check spaCy models by package name to detect site-package installs
+            unique = _unique_sorted_models()
+            missing: List[str] = []
+            for name in unique:
+                self.spacy_model_checking.emit(name)
+                ok = _is_package_installed(name)
+                self.spacy_model_result.emit(name, ok)
+                if not ok:
+                    missing.append(name)
+            parent._spacy_models_missing = missing
+            self.spacy_checked.emit(len(missing) == 0, missing)
+
+    def _start_status_check(self) -> None:
+        self._status_worker = self.StatusCheckWorker(self)
+        self._status_worker.voices_checked.connect(self._update_voices_status)
+        self._status_worker.model_checked.connect(self._update_model_status)
+        self._status_worker.config_checked.connect(self._update_config_status)
+        self._status_worker.spacy_model_checking.connect(self._spacy_model_checking)
+        self._status_worker.spacy_model_result.connect(self._spacy_model_result)
+        self._status_worker.spacy_checked.connect(self._update_spacy_status)
+
+        # These are initialized in __init__ to keep consistent object state
+
+        # Set checking visual state
+        for lbl in (
+            self.voices_status,
+            self.model_status,
+            self.config_status,
+            self.spacy_status,
+        ):
+            lbl.setStyleSheet(f"color: {COLORS['ORANGE']};")
+
+        self.spacy_status.setText(self.SPACY_PREFIX + "⏳ Checking...")
+        self._status_worker.start()
+
+    # UI update callbacks
+    def _spacy_model_checking(self, name: str) -> None:
+        self.spacy_status.setText(f"{self.SPACY_PREFIX}Checking {name}...")
+
+    def _spacy_model_result(self, name: str, ok: bool) -> None:
+        self._spacy_models_checked.append((name, ok))
+        if not ok and name not in self._spacy_models_missing:
+            self._spacy_models_missing.append(name)
+        checked = len(self._spacy_models_checked)
+        missing_count = len(self._spacy_models_missing)
+        if missing_count:
+            self.spacy_status.setText(
+                f"{self.SPACY_PREFIX}{checked} checked, {missing_count} missing..."
+            )
+        else:
+            self.spacy_status.setText(f"{self.SPACY_PREFIX}{checked} checked...")
+
+    def _update_voices_status(self, ok: bool, missing: List[str]) -> None:
+        if ok:
+            self._set_status("voice", "✓ Downloaded", COLORS["GREEN"])
+        else:
+            self.has_missing = True
+            if missing:
+                self._set_status(
+                    "voice", f"✗ Missing {len(missing)} voices", COLORS["RED"]
+                )
+            else:
+                self._set_status("voice", "✗ Not downloaded", COLORS["RED"])
+
+    def _update_model_status(self, ok: bool) -> None:
+        if ok:
+            self._set_status("model", "✓ Downloaded", COLORS["GREEN"])
+        else:
+            self.has_missing = True
+            self._set_status("model", "✗ Not downloaded", COLORS["RED"])
+
+    def _update_config_status(self, ok: bool) -> None:
+        if ok:
+            self._set_status("config", "✓ Downloaded", COLORS["GREEN"])
+        else:
+            self.has_missing = True
+            self._set_status("config", "✗ Not downloaded", COLORS["RED"])
+
+    def _update_spacy_status(self, ok: bool, missing: List[str]) -> None:
+        if ok:
+            self._set_status("spacy", "✓ Downloaded", COLORS["GREEN"])
+        else:
+            self.has_missing = True
+            if missing:
+                self._set_status(
+                    "spacy", f"✗ Missing {len(missing)} model(s)", COLORS["RED"]
+                )
+            else:
+                self._set_status("spacy", "✗ Not downloaded", COLORS["RED"])
+        self.download_btn.setEnabled(self.has_missing)
+
+    def _set_status(self, key: str, text: str, color: str) -> None:
+        lbl, prefix = self.status_map.get(key, (None, ""))
+        if not lbl:
+            return
+        lbl.setText(prefix + text)
+        lbl.setStyleSheet(f"color: {color};")
+
+    # Helper checks
+    def _check_kokoro_voices(self) -> Tuple[bool, List[str]]:
+        """Return (ok, missing_list) for Kokoro voices check."""
+        missing = []
+        try:
+            from huggingface_hub import try_to_load_from_cache
+
+            for voice in VOICES_INTERNAL:
+                if not try_to_load_from_cache(
+                    repo_id="hexgrad/Kokoro-82M", filename=f"voices/{voice}.pt"
+                ):
+                    missing.append(voice)
+        except Exception:
+            # If HF missing, report all as missing
+            return False, list(VOICES_INTERNAL)
+        return (len(missing) == 0), missing
+
+    def _check_kokoro_model(self) -> bool:
+        try:
+            from huggingface_hub import try_to_load_from_cache
+
+            return (
+                try_to_load_from_cache(
+                    repo_id="hexgrad/Kokoro-82M", filename="kokoro-v1_0.pth"
+                )
+                is not None
+            )
+        except Exception:
+            return False
+
+    def _check_kokoro_config(self) -> bool:
+        try:
+            from huggingface_hub import try_to_load_from_cache
+
+            return (
+                try_to_load_from_cache(
+                    repo_id="hexgrad/Kokoro-82M", filename="config.json"
+                )
+                is not None
+            )
+        except Exception:
+            return False
+
+    def _check_spacy_models(self) -> bool:
+        unique = _unique_sorted_models()
+        missing = [m for m in unique if not _is_package_installed(m)]
+        self._spacy_models_missing = missing
+        return len(missing) == 0
+
+    # Download control
+    def _start_download(self) -> None:
+        self.download_btn.setEnabled(False)
+        self.download_btn.setText("Downloading...")
+        # mark the start of downloads; this triggers the labels
+        self._on_progress("system", "starting", "Processing, please wait...")
+        self.worker = PreDownloadWorker(self)
+        self.worker.progress.connect(self._on_progress)
+        self.worker.category_done.connect(self._on_category_done)
+        self.worker.finished.connect(self._on_download_finished)
+        self.worker.error.connect(self._on_download_error)
+        self.worker.start()
+
+    def _on_progress(self, category: str, status: str, message: str) -> None:
+        """Map worker (category, status, message) to UI label updates.
+
+        Status is one of: 'downloading', 'installed', 'downloaded', 'warning', 'starting'.
+        Category is one of: 'voice', 'model', 'spacy', 'config', or 'system'.
+        """
+        try:
+            # If the category targets a specific label, update directly
+            if category in self.status_map:
+                lbl, prefix = self.status_map[category]
+                if not lbl:
+                    return
+                # Compose message and set color based on status token
+                full_text = prefix + message
+                if len(full_text) > 60:
+                    display_text = full_text[:57] + "..."
+                    lbl.setText(display_text)
+                    lbl.setToolTip(full_text)
+                else:
+                    lbl.setText(full_text)
+                    lbl.setToolTip("")  # Clear tooltip if not needed
+                if status == "downloading":
+                    lbl.setStyleSheet(f"color: {COLORS['ORANGE']};")
+                elif status in ("installed", "downloaded"):
+                    lbl.setStyleSheet(f"color: {COLORS['GREEN']};")
+                elif status == "warning":
+                    lbl.setStyleSheet(f"color: {COLORS['RED']};")
+                elif status == "error":
+                    lbl.setStyleSheet(f"color: {COLORS['RED']};")
+                return
+
+            # System-level messages
+            if category == "system":
+                if status == "starting":
+                    for k in self.status_map:
+                        lbl, prefix = self.status_map[k]
+                        if lbl:
+                            lbl.setText(prefix + "Processing, please wait...")
+                            lbl.setStyleSheet(f"color: {COLORS['ORANGE']};")
+                # other system statuses don't require action
+                return
+        except Exception:
+            # Do not let UI thread crash on unexpected worker message
+            pass
+
+    def _on_category_done(self, category: str) -> None:
+        for key in self.category_map.get(category, []):
+            self._set_status(key, "✓ Downloaded", COLORS["GREEN"])
+
+    def _on_download_finished(self) -> None:
+        self.has_missing = False
+        self.download_btn.setText("Download all")
+        self.download_btn.setEnabled(False)
+
+    def _on_download_error(self, error_msg: str) -> None:
+        self.download_btn.setText("Download all")
+        self.download_btn.setEnabled(True)
+        for key in self.status_map:
+            self._set_status(key, f"✗ Error - {error_msg}", COLORS["RED"])
+
+    def _handle_close(self) -> None:
+        if self.worker and self.worker.isRunning():
+            self.worker.cancel()
+            self.worker.wait(2000)
+        self.accept()
+
+    def closeEvent(self, event) -> None:
+        if self.worker and self.worker.isRunning():
+            self.worker.cancel()
+            self.worker.wait(2000)
+        super().closeEvent(event)

abogen/queue_manager_gui.py

@@ -2,7 +2,7 @@
 # button to remove an item from the queue
 # button to clear the queue
 
-from PyQt5.QtWidgets import (
+from PyQt6.QtWidgets import (
     QDialog,
     QVBoxLayout,
     QHBoxLayout,
@@ -14,18 +14,20 @@ from PyQt5.QtWidgets import (
     QLabel,
     QWidget,
     QSizePolicy,
+    QAbstractItemView,
 )
-from PyQt5.QtCore import QFileInfo, Qt
+from PyQt6.QtCore import QFileInfo, Qt
 from abogen.constants import COLORS
 from copy import deepcopy
-from PyQt5.QtGui import QFontMetrics
+from PyQt6.QtGui import QFontMetrics
 
 
 class ElidedLabel(QLabel):
-    def __init__(self, text, parent=None):
+    def __init__(self, text):
-        super().__init__(text, parent)
+        super().__init__(text)
         self._full_text = text
-        self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
+        self.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Preferred)
+        self.setTextFormat(Qt.TextFormat.PlainText)
 
     def setText(self, text):
         self._full_text = text
@@ -34,7 +36,9 @@ class ElidedLabel(QLabel):
 
     def resizeEvent(self, event):
         metrics = QFontMetrics(self.font())
-        elided = metrics.elidedText(self._full_text, Qt.ElideRight, self.width())
+        elided = metrics.elidedText(
+            self._full_text, Qt.TextElideMode.ElideRight, self.width()
+        )
         super().setText(elided)
         super().resizeEvent(event)
 
@@ -53,8 +57,12 @@ class QueueListItemWidget(QWidget):
         name_label = ElidedLabel(os.path.basename(file_name))
         char_label = QLabel(f"Chars: {char_count}")
         char_label.setStyleSheet(f"color: {COLORS['LIGHT_DISABLED']};")
-        char_label.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
+        char_label.setAlignment(
-        char_label.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Preferred)
+            Qt.AlignmentFlag.AlignRight | Qt.AlignmentFlag.AlignVCenter
+        )
+        char_label.setSizePolicy(
+            QSizePolicy.Policy.Minimum, QSizePolicy.Policy.Preferred
+        )
         layout.addWidget(name_label, 1)
         layout.addWidget(char_label, 0)
         self.setLayout(layout)
@@ -67,17 +75,23 @@ class DroppableQueueListWidget(QListWidget):
         self.setAcceptDrops(True)
         # Overlay for drag hover
         self.drag_overlay = QLabel("", self)
-        self.drag_overlay.setAlignment(Qt.AlignCenter)
+        self.drag_overlay.setAlignment(Qt.AlignmentFlag.AlignCenter)
         self.drag_overlay.setStyleSheet(
             f"border:2px dashed {COLORS['BLUE_BORDER_HOVER']}; border-radius:5px; padding:20px; background:{COLORS['BLUE_BG_HOVER']};"
         )
         self.drag_overlay.setVisible(False)
-        self.drag_overlay.setAttribute(Qt.WA_TransparentForMouseEvents, True)
+        self.drag_overlay.setAttribute(
+            Qt.WidgetAttribute.WA_TransparentForMouseEvents, True
+        )
 
     def dragEnterEvent(self, event):
         if event.mimeData().hasUrls():
             for url in event.mimeData().urls():
-                if url.isLocalFile() and url.toLocalFile().lower().endswith(".txt"):
+                file_path = url.toLocalFile().lower()
+                if url.isLocalFile() and (
+                    file_path.endswith(".txt")
+                    or file_path.endswith((".srt", ".ass", ".vtt"))
+                ):
                     self.drag_overlay.resize(self.size())
                     self.drag_overlay.setVisible(True)
                     event.acceptProposedAction()
@@ -88,7 +102,11 @@ class DroppableQueueListWidget(QListWidget):
     def dragMoveEvent(self, event):
         if event.mimeData().hasUrls():
             for url in event.mimeData().urls():
-                if url.isLocalFile() and url.toLocalFile().lower().endswith(".txt"):
+                file_path = url.toLocalFile().lower()
+                if url.isLocalFile() and (
+                    file_path.endswith(".txt")
+                    or file_path.endswith((".srt", ".ass", ".vtt"))
+                ):
                     event.acceptProposedAction()
                     return
         event.ignore()
@@ -103,7 +121,11 @@ class DroppableQueueListWidget(QListWidget):
             file_paths = [
                 url.toLocalFile()
                 for url in event.mimeData().urls()
-                if url.isLocalFile() and url.toLocalFile().lower().endswith(".txt")
+                if url.isLocalFile()
+                and (
+                    url.toLocalFile().lower().endswith(".txt")
+                    or url.toLocalFile().lower().endswith((".srt", ".ass", ".vtt"))
+                )
             ]
             if file_paths:
                 self.parent_dialog.add_files_from_paths(file_paths)
@@ -132,34 +154,38 @@ class QueueManager(QDialog):
         layout.setSpacing(12)  # set spacing between widgets in main layout
         # list of queued items
         self.listwidget = DroppableQueueListWidget(self)
-        self.listwidget.setSelectionMode(QListWidget.ExtendedSelection)
+        self.listwidget.setSelectionMode(
+            QAbstractItemView.SelectionMode.ExtendedSelection
+        )
         self.listwidget.setAlternatingRowColors(True)
-        self.listwidget.setContextMenuPolicy(Qt.CustomContextMenu)
+        self.listwidget.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
         self.listwidget.customContextMenuRequested.connect(self.show_context_menu)
         # Add informative instructions at the top
         instructions = QLabel(
             "<h2>How Queue Works?</h2>"
-            "You can add text files (.txt) directly using the '<b>Add files</b>' button below. "
+            "You can add text and subtitle files (.txt, .srt, .ass, .vtt) directly using the '<b>Add files</b>' button below. "
             "To add PDF, EPUB or markdown files, use the input box in the main window and click the <b>'Add to Queue'</b> button. "
             "Each file in the queue keeps the configuration settings active when it was added. "
             "Changing the main window configuration afterward <b>does not</b> affect files already in the queue. "
             "You can view each file's configuration by hovering over them."
         )
-        instructions.setAlignment(Qt.AlignLeft)
+        instructions.setAlignment(Qt.AlignmentFlag.AlignLeft)
         instructions.setWordWrap(True)
         instructions.setStyleSheet("margin-bottom: 8px;")
         layout.addWidget(instructions)
         # Overlay label for empty queue
         self.empty_overlay = QLabel(
-            "Drag and drop your text files here or use the 'Add files' button.",
+            "Drag and drop your text or subtitle files here or use the 'Add files' button.",
             self.listwidget,
         )
-        self.empty_overlay.setAlignment(Qt.AlignCenter)
+        self.empty_overlay.setAlignment(Qt.AlignmentFlag.AlignCenter)
         self.empty_overlay.setStyleSheet(
             f"color: {COLORS['LIGHT_DISABLED']}; background: transparent; padding: 20px;"
         )
         self.empty_overlay.setWordWrap(True)
-        self.empty_overlay.setAttribute(Qt.WA_TransparentForMouseEvents, True)
+        self.empty_overlay.setAttribute(
+            Qt.WidgetAttribute.WA_TransparentForMouseEvents, True
+        )
         self.empty_overlay.hide()
         # add queue items to the list
         self.process_queue()
@@ -192,7 +218,10 @@ class QueueManager(QDialog):
         self.listwidget.currentItemChanged.connect(self.update_button_states)
         self.listwidget.itemSelectionChanged.connect(self.update_button_states)
 
-        buttons = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel, self)
+        buttons = QDialogButtonBox(
+            QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel,
+            self,
+        )
         buttons.accepted.connect(self.accept)
         buttons.rejected.connect(self.reject)
 
@@ -207,9 +236,10 @@ class QueueManager(QDialog):
 
     def process_queue(self):
         """Process the queue items."""
+        import os
+
         self.listwidget.clear()
         if not self.queue:
-            self.empty_overlay.resize(self.listwidget.size())
             self.empty_overlay.show()
             self.update_button_states()
             return
@@ -220,10 +250,21 @@ class QueueManager(QDialog):
             # Determine display file path (prefer save_base_path for original file)
             display_file_path = getattr(item, "save_base_path", None) or item.file_name
             processing_file_path = item.file_name
-            
+
+            # Normalize paths for consistent display (fixes Windows path separator issues)
+            display_file_path = (
+                os.path.normpath(display_file_path)
+                if display_file_path
+                else display_file_path
+            )
+            processing_file_path = (
+                os.path.normpath(processing_file_path)
+                if processing_file_path
+                else processing_file_path
+            )
+
             # Only show the file name, not the full path
             display_name = display_file_path
-            import os
 
             if os.path.sep in display_file_path:
                 display_name = os.path.basename(display_file_path)
@@ -235,13 +276,19 @@ class QueueManager(QDialog):
             # For plain .txt inputs we don't need to show a separate processing file
             show_processing = True
             try:
-                if isinstance(display_file_path, str) and display_file_path.lower().endswith('.txt'):
+                if isinstance(
+                    display_file_path, str
+                ) and display_file_path.lower().endswith(".txt"):
                     show_processing = False
             except Exception:
                 show_processing = True
 
             tooltip = f"<b>Input File:</b> {display_file_path}<br>"
-            if show_processing and processing_file_path and processing_file_path != display_file_path:
+            if (
+                show_processing
+                and processing_file_path
+                and processing_file_path != display_file_path
+            ):
                 tooltip += f"<b>Processing File:</b> {processing_file_path}<br>"
             tooltip += (
                 f"<b>Language:</b> {getattr(item, 'lang_code', '')}<br>"
@@ -255,15 +302,28 @@ class QueueManager(QDialog):
                 f"<b>Subtitle Mode:</b> {getattr(item, 'subtitle_mode', '')}<br>"
                 f"<b>Output Format:</b> {getattr(item, 'output_format', '')}<br>"
                 f"<b>Characters:</b> {getattr(item, 'total_char_count', '')}<br>"
-                f"<b>Replace Single Newlines:</b> {getattr(item, 'replace_single_newlines', False)}"
+                f"<b>Replace Single Newlines:</b> {getattr(item, 'replace_single_newlines', False)}<br>"
+                f"<b>Use Silent Gaps:</b> {getattr(item, 'use_silent_gaps', False)}<br>"
+                f"<b>Speed Method:</b> {getattr(item, 'subtitle_speed_method', 'tts')}"
             )
+            # Add book handler options if present
+            save_chapters_separately = getattr(item, "save_chapters_separately", None)
+            merge_chapters_at_end = getattr(item, "merge_chapters_at_end", None)
+            if save_chapters_separately is not None:
+                tooltip += f"<br><b>Save chapters separately:</b> {'Yes' if save_chapters_separately else 'No'}"
+                # Only show merge option if saving chapters separately
+                if save_chapters_separately and merge_chapters_at_end is not None:
+                    tooltip += f"<br><b>Merge chapters at the end:</b> {'Yes' if merge_chapters_at_end else 'No'}"
             list_item.setToolTip(tooltip)
             list_item.setIcon(icon)
             # Store both paths for context menu
-            list_item.setData(Qt.UserRole, {
+            list_item.setData(
-                'display_path': display_file_path,
+                Qt.ItemDataRole.UserRole,
-                'processing_path': processing_file_path
+                {
-            })
+                    "display_path": display_file_path,
+                    "processing_path": processing_file_path,
+                },
+            )
             # Use custom widget for display
             char_count = getattr(item, "total_char_count", 0)
             widget = QueueListItemWidget(display_file_path, char_count)
@@ -275,7 +335,7 @@ class QueueManager(QDialog):
         items = self.listwidget.selectedItems()
         if not items:
             return
-        from PyQt5.QtWidgets import QMessageBox
+        from PyQt6.QtWidgets import QMessageBox
 
         # Remove by index to ensure correct mapping
         rows = sorted([self.listwidget.row(item) for item in items], reverse=True)
@@ -285,10 +345,10 @@ class QueueManager(QDialog):
                 self,
                 "Confirm Remove",
                 f"Are you sure you want to remove {len(rows)} selected items from the queue?",
-                QMessageBox.Yes | QMessageBox.No,
+                QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
-                QMessageBox.No,
+                QMessageBox.StandardButton.No,
             )
-            if reply != QMessageBox.Yes:
+            if reply != QMessageBox.StandardButton.Yes:
                 return
         for row in rows:
             if 0 <= row < len(self.queue):
@@ -297,17 +357,17 @@ class QueueManager(QDialog):
         self.update_button_states()
 
     def clear_queue(self):
-        from PyQt5.QtWidgets import QMessageBox
+        from PyQt6.QtWidgets import QMessageBox
 
         if len(self.queue) > 1:
             reply = QMessageBox.question(
                 self,
                 "Confirm Clear Queue",
                 f"Are you sure you want to clear {len(self.queue)} items from the queue?",
-                QMessageBox.Yes | QMessageBox.No,
+                QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
-                QMessageBox.No,
+                QMessageBox.StandardButton.No,
             )
-            if reply != QMessageBox.Yes:
+            if reply != QMessageBox.StandardButton.Yes:
                 return
         self.queue.clear()
         self.listwidget.clear()
@@ -357,6 +417,19 @@ class QueueManager(QDialog):
             attrs["replace_single_newlines"] = getattr(
                 parent, "replace_single_newlines", False
             )
+            # use_silent_gaps
+            attrs["use_silent_gaps"] = getattr(parent, "use_silent_gaps", False)
+            # subtitle_speed_method
+            attrs["subtitle_speed_method"] = getattr(
+                parent, "subtitle_speed_method", "tts"
+            )
+            # book handler options
+            attrs["save_chapters_separately"] = getattr(
+                parent, "save_chapters_separately", None
+            )
+            attrs["merge_chapters_at_end"] = getattr(
+                parent, "merge_chapters_at_end", None
+            )
         else:
             # fallback: empty values
             attrs = {
@@ -373,11 +446,13 @@ class QueueManager(QDialog):
                     "replace_single_newlines",
                 ]
             }
+            attrs["save_chapters_separately"] = None
+            attrs["merge_chapters_at_end"] = None
         return attrs
 
     def add_files_from_paths(self, file_paths):
         from abogen.utils import calculate_text_length
-        from PyQt5.QtWidgets import QMessageBox
+        from PyQt6.QtWidgets import QMessageBox
         import os
 
         current_attrs = self.get_current_attributes()
@@ -389,9 +464,14 @@ class QueueManager(QDialog):
 
             item = QueueItem()
             item.file_name = file_path
-            item.save_base_path = file_path  # For .txt files, processing and save paths are the same
+            item.save_base_path = (
+                file_path  # For .txt files, processing and save paths are the same
+            )
             for attr, value in current_attrs.items():
                 setattr(item, attr, value)
+            # Override subtitle_mode to "Disabled" for subtitle files
+            if file_path.lower().endswith((".srt", ".ass", ".vtt")):
+                item.subtitle_mode = "Disabled"
             # Read file content and calculate total_char_count using calculate_text_length
             try:
                 with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
@@ -423,8 +503,16 @@ class QueueManager(QDialog):
                     == getattr(item, "total_char_count", None)
                     and getattr(queued_item, "replace_single_newlines", False)
                     == getattr(item, "replace_single_newlines", False)
+                    and getattr(queued_item, "use_silent_gaps", False)
+                    == getattr(item, "use_silent_gaps", False)
+                    and getattr(queued_item, "subtitle_speed_method", "tts")
+                    == getattr(item, "subtitle_speed_method", "tts")
                     and getattr(queued_item, "save_base_path", None)
                     == getattr(item, "save_base_path", None)
+                    and getattr(queued_item, "save_chapters_separately", None)
+                    == getattr(item, "save_chapters_separately", None)
+                    and getattr(queued_item, "merge_chapters_at_end", None)
+                    == getattr(item, "merge_chapters_at_end", None)
                 ):
                     is_duplicate = True
                     break
@@ -442,12 +530,15 @@ class QueueManager(QDialog):
         self.update_button_states()
 
     def add_more_files(self):
-        from PyQt5.QtWidgets import QFileDialog
+        from PyQt6.QtWidgets import QFileDialog
         from abogen.utils import calculate_text_length  # import the function
 
-        # Only allow .txt files
+        # Allow .txt, .srt, .ass, and .vtt files
         files, _ = QFileDialog.getOpenFileNames(
-            self, "Select .txt files", "", "Text Files (*.txt)"
+            self,
+            "Select text or subtitle files",
+            "",
+            "Supported Files (*.txt *.srt *.ass *.vtt)",
         )
         if not files:
             return
@@ -472,9 +563,9 @@ class QueueManager(QDialog):
             self.clear_button.setEnabled(bool(self.queue))
 
     def show_context_menu(self, pos):
-        from PyQt5.QtWidgets import QMenu, QAction
+        from PyQt6.QtWidgets import QMenu
-        from PyQt5.QtGui import QDesktopServices
+        from PyQt6.QtGui import QAction, QDesktopServices
-        from PyQt5.QtCore import QUrl
+        from PyQt6.QtCore import QUrl
         import os
 
         global_pos = self.listwidget.viewport().mapToGlobal(pos)
@@ -486,75 +577,129 @@ class QueueManager(QDialog):
             remove_action.triggered.connect(self.remove_item)
             menu.addAction(remove_action)
 
-            # Add Open file action
+            # Get paths for determining if it's a document input
-            open_file_action = QAction("Open file", self)
-
-            def open_file():
-                from PyQt5.QtWidgets import QMessageBox
-
-                item = selected_items[0]
-                paths = item.data(Qt.UserRole)
-                if isinstance(paths, dict):
-                    file_path = paths.get('display_path', paths.get('processing_path', ''))
-                else:
-                    file_path = paths  # Fallback for old format
-                
-                # Find the queue item
-                for q in self.queue:
-                    if (getattr(q, "save_base_path", None) == file_path or 
-                        q.file_name == file_path):
-                        target_path = getattr(q, "save_base_path", None) or q.file_name
-                        if not os.path.exists(target_path):
-                            QMessageBox.warning(
-                                self, "File Not Found", f"The file does not exist."
-                            )
-                            return
-                        QDesktopServices.openUrl(QUrl.fromLocalFile(target_path))
-                        break
-
-            open_file_action.triggered.connect(open_file)
-            menu.addAction(open_file_action)
-
-            # Add Go to folder action
-            # If the queued item represents a converted document (markdown, pdf, epub)
-            # show two actions: Go to processed file (the cached .txt) and Go to input file (original source)
             item = selected_items[0]
-            paths = item.data(Qt.UserRole)
+            paths = item.data(Qt.ItemDataRole.UserRole)
             if isinstance(paths, dict):
-                display_path = paths.get('display_path', '')
+                display_path = paths.get("display_path", "")
-                processing_path = paths.get('processing_path', '')
+                processing_path = paths.get("processing_path", "")
             else:
                 display_path = paths
                 processing_path = paths
 
-            doc_exts = ('.md', '.markdown', '.pdf', '.epub')
+            doc_exts = (".md", ".markdown", ".pdf", ".epub")
             is_document_input = (
-                isinstance(display_path, str) and display_path.lower().endswith(doc_exts)
+                isinstance(display_path, str)
+                and display_path.lower().endswith(doc_exts)
             ) or (
-                isinstance(processing_path, str) and processing_path.lower().endswith(doc_exts)
+                isinstance(processing_path, str)
+                and processing_path.lower().endswith(doc_exts)
             )
 
-            from PyQt5.QtWidgets import QMessageBox
+            # Add Open file action(s)
+            def open_file_by_path(path_label: str):
+                from PyQt6.QtWidgets import QMessageBox
+
+                p = display_path if path_label == "display" else processing_path
+                if not p:
+                    QMessageBox.warning(
+                        self, "File Not Found", "Path is not available."
+                    )
+                    return
+
+                # Find the queue item and resolve the target path
+                target_path = None
+                for q in self.queue:
+                    if (
+                        getattr(q, "save_base_path", None) == display_path
+                        or q.file_name == display_path
+                    ):
+                        if path_label == "display":
+                            target_path = (
+                                getattr(q, "save_base_path", None) or q.file_name
+                            )
+                        else:
+                            target_path = q.file_name
+                        break
+                    if (
+                        getattr(q, "save_base_path", None) == processing_path
+                        or q.file_name == processing_path
+                    ):
+                        if path_label == "display":
+                            target_path = (
+                                getattr(q, "save_base_path", None) or q.file_name
+                            )
+                        else:
+                            target_path = q.file_name
+                        break
+
+                # Fallback to the raw path if resolution failed
+                if not target_path:
+                    target_path = p
+
+                if not os.path.exists(target_path):
+                    QMessageBox.warning(
+                        self, "File Not Found", f"The file does not exist."
+                    )
+                    return
+                QDesktopServices.openUrl(QUrl.fromLocalFile(target_path))
+
+            if is_document_input:
+                # For documents, show two open options
+                open_processed_action = QAction("Open processed file", self)
+                open_processed_action.triggered.connect(
+                    lambda: open_file_by_path("processing")
+                )
+                menu.addAction(open_processed_action)
+
+                open_input_action = QAction("Open input file", self)
+                open_input_action.triggered.connect(
+                    lambda: open_file_by_path("display")
+                )
+                menu.addAction(open_input_action)
+            else:
+                # For plain text files, show single open option
+                open_file_action = QAction("Open file", self)
+                open_file_action.triggered.connect(lambda: open_file_by_path("display"))
+                menu.addAction(open_file_action)
+
+            # Add Go to folder action
+            # If the queued item represents a converted document (markdown, pdf, epub)
+            # show two actions: Go to processed file (the cached .txt) and Go to input file (original source)
+
+            from PyQt6.QtWidgets import QMessageBox
 
             def open_folder_for(path_label: str):
                 # path_label should be either 'display' or 'processing'
-                p = display_path if path_label == 'display' else processing_path
+                p = display_path if path_label == "display" else processing_path
                 if not p:
-                    QMessageBox.warning(self, "File Not Found", "Path is not available.")
+                    QMessageBox.warning(
+                        self, "File Not Found", "Path is not available."
+                    )
                     return
                 # If the stored path is the display path (original) but the actual file may be
                 # stored on the queue object differently, try to resolve via the queue entry.
                 target_path = None
                 for q in self.queue:
-                    if getattr(q, 'save_base_path', None) == display_path or q.file_name == display_path:
+                    if (
-                        if path_label == 'display':
+                        getattr(q, "save_base_path", None) == display_path
-                            target_path = getattr(q, 'save_base_path', None) or q.file_name
+                        or q.file_name == display_path
+                    ):
+                        if path_label == "display":
+                            target_path = (
+                                getattr(q, "save_base_path", None) or q.file_name
+                            )
                         else:
                             target_path = q.file_name
                         break
-                    if getattr(q, 'save_base_path', None) == processing_path or q.file_name == processing_path:
+                    if (
-                        if path_label == 'display':
+                        getattr(q, "save_base_path", None) == processing_path
-                            target_path = getattr(q, 'save_base_path', None) or q.file_name
+                        or q.file_name == processing_path
+                    ):
+                        if path_label == "display":
+                            target_path = (
+                                getattr(q, "save_base_path", None) or q.file_name
+                            )
                         else:
                             target_path = q.file_name
                         break
@@ -563,7 +708,11 @@ class QueueManager(QDialog):
                     target_path = p
 
                 if not os.path.exists(target_path):
-                    QMessageBox.warning(self, "File Not Found", f"The file does not exist: {target_path}")
+                    QMessageBox.warning(
+                        self,
+                        "File Not Found",
+                        f"The file does not exist: {target_path}",
+                    )
                     return
                 folder = os.path.dirname(target_path)
                 if os.path.exists(folder):
@@ -571,11 +720,13 @@ class QueueManager(QDialog):
 
             if is_document_input:
                 processed_action = QAction("Go to processed file", self)
-                processed_action.triggered.connect(lambda: open_folder_for('processing'))
+                processed_action.triggered.connect(
+                    lambda: open_folder_for("processing")
+                )
                 menu.addAction(processed_action)
 
                 input_action = QAction("Go to input file", self)
-                input_action.triggered.connect(lambda: open_folder_for('display'))
+                input_action.triggered.connect(lambda: open_folder_for("display"))
                 menu.addAction(input_action)
             else:
                 # Default behavior for non-document inputs: single "Go to folder" action
@@ -583,15 +734,22 @@ class QueueManager(QDialog):
 
                 def go_to_folder():
                     item = selected_items[0]
-                    paths = item.data(Qt.UserRole)
+                    paths = item.data(Qt.ItemDataRole.UserRole)
                     if isinstance(paths, dict):
-                        file_path = paths.get('display_path', paths.get('processing_path', ''))
+                        file_path = paths.get(
+                            "display_path", paths.get("processing_path", "")
+                        )
                     else:
                         file_path = paths  # Fallback for old format
                     # Find the queue item
                     for q in self.queue:
-                        if (getattr(q, "save_base_path", None) == file_path or q.file_name == file_path):
+                        if (
-                            target_path = getattr(q, "save_base_path", None) or q.file_name
+                            getattr(q, "save_base_path", None) == file_path
+                            or q.file_name == file_path
+                        ):
+                            target_path = (
+                                getattr(q, "save_base_path", None) or q.file_name
+                            )
                             if not os.path.exists(target_path):
                                 QMessageBox.warning(
                                     self, "File Not Found", f"The file does not exist."
@@ -613,7 +771,7 @@ class QueueManager(QDialog):
         clear_action = QAction("Clear Queue", self)
         clear_action.triggered.connect(self.clear_queue)
         menu.addAction(clear_action)
-        menu.exec_(global_pos)
+        menu.exec(global_pos)
 
     def accept(self):
         # Accept: keep changes
@@ -621,7 +779,7 @@ class QueueManager(QDialog):
 
     def reject(self):
         # Cancel: restore original queue
-        from PyQt5.QtWidgets import QMessageBox
+        from PyQt6.QtWidgets import QMessageBox
 
         # Warn if user changed a lot (e.g., more than 1 items difference)
         original_count = len(self._original_queue)
@@ -631,19 +789,19 @@ class QueueManager(QDialog):
                 self,
                 "Confirm Cancel",
                 f"Are you sure you want to cancel and discard all changes?",
-                QMessageBox.Yes | QMessageBox.No,
+                QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
-                QMessageBox.No,
+                QMessageBox.StandardButton.No,
             )
-            if reply != QMessageBox.Yes:
+            if reply != QMessageBox.StandardButton.Yes:
                 return
         self.queue.clear()
         self.queue.extend(deepcopy(self._original_queue))
         super().reject()
 
     def keyPressEvent(self, event):
-        from PyQt5.QtCore import Qt
+        from PyQt6.QtCore import Qt
 
-        if event.key() == Qt.Key_Delete:
+        if event.key() == Qt.Key.Key_Delete:
             self.remove_item()
         else:
             super().keyPressEvent(event)

abogen/queued_item.py

@@ -14,4 +14,8 @@ class QueuedItem:
     output_format: str
     total_char_count: int
     replace_single_newlines: bool = False
+    use_silent_gaps: bool = False
+    subtitle_speed_method: str = "tts"
     save_base_path: str = None
+    save_chapters_separately: bool = None
+    merge_chapters_at_end: bool = None

abogen/spacy_utils.py

@@ -0,0 +1,155 @@
+"""
+Lazy-loaded spaCy utilities for sentence segmentation.
+"""
+
+# Cached spaCy module and models (lazy loaded)
+_spacy = None
+_nlp_cache = {}
+
+# Language code to spaCy model mapping
+SPACY_MODELS = {
+    "a": "en_core_web_sm",  # American English
+    "b": "en_core_web_sm",  # British English
+    "e": "es_core_news_sm",  # Spanish
+    "f": "fr_core_news_sm",  # French
+    "i": "it_core_news_sm",  # Italian
+    "p": "pt_core_news_sm",  # Brazilian Portuguese
+    "z": "zh_core_web_sm",  # Mandarin Chinese
+    "j": "ja_core_news_sm",  # Japanese
+    "h": "xx_sent_ud_sm",  # Hindi (multi-language model)
+}
+
+
+def _load_spacy():
+    """Lazy load spaCy module."""
+    global _spacy
+    if _spacy is None:
+        try:
+            import spacy
+
+            _spacy = spacy
+        except ImportError:
+            return None
+    return _spacy
+
+
+def get_spacy_model(lang_code, log_callback=None):
+    """
+    Get or load a spaCy model for the given language code.
+    Downloads the model automatically if not available.
+
+    Args:
+        lang_code: Language code (a, b, e, f, etc.)
+        log_callback: Optional function to log messages
+
+    Returns:
+        Loaded spaCy model or None if unavailable
+    """
+
+    def log(msg, is_error=False):
+        # Prefer GUI log callback when provided to avoid spamming stdout.
+        if log_callback:
+            color = "red" if is_error else "grey"
+            try:
+                log_callback((msg, color))
+            except Exception:
+                # Fallback to printing if callback misbehaves
+                print(msg)
+        else:
+            print(msg)
+
+    # Check if model is cached
+    if lang_code in _nlp_cache:
+        return _nlp_cache[lang_code]
+
+    # Check if language is supported
+    model_name = SPACY_MODELS.get(lang_code)
+    if not model_name:
+        log(f"\nspaCy: No model mapping for language '{lang_code}'...")
+        return None
+
+    # Lazy load spaCy
+    spacy = _load_spacy()
+    if spacy is None:
+        log("\nspaCy: Module not installed, falling back to default segmentation...")
+        return None
+
+    # Try to load the model
+    try:
+        log(f"\nLoading spaCy model '{model_name}'...")
+        nlp = spacy.load(
+            model_name,
+            disable=["ner", "parser", "tagger", "lemmatizer", "attribute_ruler"],
+        )
+        # Enable sentence segmentation only
+        if "sentencizer" not in nlp.pipe_names:
+            nlp.add_pipe("sentencizer")
+        _nlp_cache[lang_code] = nlp
+        return nlp
+    except OSError:
+        # Model not found, attempt download
+        log(f"\nspaCy: Downloading model '{model_name}'...")
+        try:
+            from spacy.cli import download
+
+            download(model_name)
+            # Retry loading
+            nlp = spacy.load(
+                model_name,
+                disable=["ner", "parser", "tagger", "lemmatizer", "attribute_ruler"],
+            )
+            if "sentencizer" not in nlp.pipe_names:
+                nlp.add_pipe("sentencizer")
+            _nlp_cache[lang_code] = nlp
+            log(f"spaCy model '{model_name}' downloaded and loaded")
+            return nlp
+        except Exception as e:
+            log(
+                f"\nspaCy: Failed to download model '{model_name}': {e}...",
+                is_error=True,
+            )
+            return None
+    except Exception as e:
+        log(f"\nspaCy: Error loading model '{model_name}': {e}...", is_error=True)
+        return None
+
+
+def segment_sentences(text, lang_code, log_callback=None):
+    """
+    Segment text into sentences using spaCy.
+
+    Args:
+        text: Text to segment
+        lang_code: Language code
+        log_callback: Optional function to log messages
+
+    Returns:
+        List of sentence strings, or None if spaCy unavailable
+    """
+    nlp = get_spacy_model(lang_code, log_callback)
+    if nlp is None:
+        return None
+
+    # Ensure spaCy can handle large texts by adjusting max_length if necessary
+    try:
+        text_len = len(text or "")
+        if text_len and hasattr(nlp, "max_length") and text_len > nlp.max_length:
+            # increase a bit beyond the text length to be safe
+            nlp.max_length = text_len + 1000
+    except Exception:
+        pass
+
+    # Process text and extract sentences
+    doc = nlp(text)
+    return [sent.text.strip() for sent in doc.sents if sent.text.strip()]
+
+
+def is_spacy_available():
+    """Check if spaCy can be imported."""
+    return _load_spacy() is not None
+
+
+def clear_cache():
+    """Clear the model cache to free memory."""
+    global _nlp_cache
+    _nlp_cache.clear()

abogen/utils.py

@@ -10,10 +10,18 @@ from threading import Thread
 
 warnings.filterwarnings("ignore")
 
+# Pre-compile frequently used regex patterns for better performance
+_WHITESPACE_PATTERN = re.compile(r"[^\S\n]+")
+_MULTIPLE_NEWLINES_PATTERN = re.compile(r"\n{3,}")
+_SINGLE_NEWLINE_PATTERN = re.compile(r"(?<!\n)\n(?!\n)")
+_CHAPTER_MARKER_PATTERN = re.compile(r"<<CHAPTER_MARKER:.*?>>")
+_METADATA_PATTERN = re.compile(r"<<METADATA_[^:]+:[^>]*>>")
+
 
 def detect_encoding(file_path):
     import chardet
     import charset_normalizer
+
     with open(file_path, "rb") as f:
         raw_data = f.read()
     detected_encoding = None
@@ -28,6 +36,7 @@ def detect_encoding(file_path):
     encoding = detected_encoding if detected_encoding else "utf-8"
     return encoding.lower()
 
+
 def get_resource_path(package, resource):
     """
     Get the path to a resource file, with fallback to local file system.
@@ -126,13 +135,16 @@ def clean_text(text, *args, **kwargs):
     cfg = load_config()
     replace_single_newlines = cfg.get("replace_single_newlines", False)
     # Collapse all whitespace (excluding newlines) into single spaces per line and trim edges
-    lines = [re.sub(r"[^\S\n]+", " ", line).strip() for line in text.splitlines()]
+    # Use pre-compiled pattern for better performance
+    lines = [_WHITESPACE_PATTERN.sub(" ", line).strip() for line in text.splitlines()]
     text = "\n".join(lines)
     # Standardize paragraph breaks (multiple newlines become exactly two) and trim overall whitespace
-    text = re.sub(r"\n{3,}", "\n\n", text).strip()
+    # Use pre-compiled pattern for better performance
+    text = _MULTIPLE_NEWLINES_PATTERN.sub("\n\n", text).strip()
     # Optionally replace single newlines with spaces, but preserve double newlines
     if replace_single_newlines:
-        text = re.sub(r"(?<!\n)\n(?!\n)", " ", text)
+        # Use pre-compiled pattern for better performance
+        text = _SINGLE_NEWLINE_PATTERN.sub(" ", text)
     return text
 
 
@@ -241,38 +253,42 @@ def save_config(config):
 
 
 def calculate_text_length(text):
-    # Ignore chapter markers
+    # Use pre-compiled patterns for better performance
-    text = re.sub(r"<<CHAPTER_MARKER:.*?>>", "", text)
+    # Ignore chapter markers and metadata patterns in a single pass
-    # Ignore metadata patterns
+    text = _CHAPTER_MARKER_PATTERN.sub("", text)
-    text = re.sub(r"<<METADATA_[^:]+:[^>]*>>", "", text)
+    text = _METADATA_PATTERN.sub("", text)
-    # Ignore newlines
+    # Ignore newlines and leading/trailing spaces
-    text = text.replace("\n", "")
+    text = text.replace("\n", "").strip()
-    # Ignore leading/trailing spaces
-    text = text.strip()
     # Calculate character count
     char_count = len(text)
     return char_count
 
 
 def get_gpu_acceleration(enabled):
+    """
+    Check GPU acceleration availability.
+
+    Note: On Windows, torch DLLs must be pre-loaded in main.py before PyQt6
+    to avoid DLL initialization errors.
+    """
     try:
         import torch
         from torch.cuda import is_available as cuda_available
 
         if not enabled:
             return "GPU available but using CPU.", False
-        
+
         # Check for Apple Silicon MPS
         if platform.system() == "Darwin" and platform.processor() == "arm":
             if torch.backends.mps.is_available():
                 return "MPS GPU available and enabled.", True
             else:
                 return "MPS GPU not available on Apple Silicon. Using CPU.", False
-        
+
         # Check for CUDA
         if cuda_available():
             return "CUDA GPU available and enabled.", True
-        
+
         # Gather CUDA diagnostic info if not available
         try:
             cuda_devices = torch.cuda.device_count()

abogen/voice_formula_gui.py

@@ -1,6 +1,6 @@
 import json
 import os
-from PyQt5.QtWidgets import (
+from PyQt6.QtWidgets import (
     QDialog,
     QVBoxLayout,
     QCheckBox,
@@ -22,12 +22,11 @@ from PyQt5.QtWidgets import (
     QFileDialog,
     QSplitter,
     QMenu,
-    QAction,
-    QComboBox,
     QApplication,
+    QComboBox,
 )
-from PyQt5.QtCore import Qt, QTimer, QPoint, QRect, QSize
+from PyQt6.QtCore import Qt, QTimer, QPoint, QRect, QSize
-from PyQt5.QtGui import QPixmap, QIcon
+from PyQt6.QtGui import QPixmap, QIcon, QAction
 from abogen.constants import (
     VOICES_INTERNAL,
     SUPPORTED_LANGUAGES_FOR_SUBTITLE_GENERATION,
@@ -91,7 +90,7 @@ class FlowLayout(QLayout):
         return len(self._item_list)
 
     def expandingDirections(self):
-        return Qt.Orientations(Qt.Orientation(0))
+        return Qt.Orientation(0)
 
     def hasHeightForWidth(self):
         return True
@@ -132,10 +131,14 @@ class FlowLayout(QLayout):
         for item in self._item_list:
             style = self.parentWidget().style() if self.parentWidget() else QStyle()
             layout_spacing_x = style.layoutSpacing(
-                QSizePolicy.PushButton, QSizePolicy.PushButton, Qt.Horizontal
+                QSizePolicy.ControlType.PushButton,
+                QSizePolicy.ControlType.PushButton,
+                Qt.Orientation.Horizontal,
             )
             layout_spacing_y = style.layoutSpacing(
-                QSizePolicy.PushButton, QSizePolicy.PushButton, Qt.Vertical
+                QSizePolicy.ControlType.PushButton,
+                QSizePolicy.ControlType.PushButton,
+                Qt.Orientation.Vertical,
             )
             space_x = spacing if spacing >= 0 else layout_spacing_x
             space_y = spacing if spacing >= 0 else layout_spacing_y
@@ -163,7 +166,7 @@ class VoiceMixer(QWidget):
         super().__init__()
         self.voice_name = voice_name
         self.setFixedWidth(VOICE_MIXER_WIDTH)
-        self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
+        self.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding)
 
         # TODO Set CSS for rounded corners
         # self.setObjectName("VoiceMixer")
@@ -173,7 +176,7 @@ class VoiceMixer(QWidget):
 
         # Name label at the top
         name = voice_name
-        layout.addWidget(QLabel(name), alignment=Qt.AlignCenter)
+        layout.addWidget(QLabel(name), alignment=Qt.AlignmentFlag.AlignCenter)
 
         # Voice name label with gender icon
         is_female = self.voice_name in VOICES_INTERNAL and self.voice_name[1] == "f"
@@ -181,7 +184,9 @@ class VoiceMixer(QWidget):
         # Icons layout (flag and gender)
         icons_layout = QHBoxLayout()
         icons_layout.setSpacing(3)
-        icons_layout.setAlignment(Qt.AlignCenter)  # Center the icons horizontally
+        icons_layout.setAlignment(
+            Qt.AlignmentFlag.AlignCenter
+        )  # Center the icons horizontally
 
         # Flag icon
         flag_icon_path = get_resource_path(
@@ -194,11 +199,21 @@ class VoiceMixer(QWidget):
         gender_label = QLabel()
         flag_pixmap = QPixmap(flag_icon_path)
         flag_label.setPixmap(
-            flag_pixmap.scaled(16, 16, Qt.KeepAspectRatio, Qt.SmoothTransformation)
+            flag_pixmap.scaled(
+                16,
+                16,
+                Qt.AspectRatioMode.KeepAspectRatio,
+                Qt.TransformationMode.SmoothTransformation,
+            )
         )
         gender_pixmap = QPixmap(gender_icon_path)
         gender_label.setPixmap(
-            gender_pixmap.scaled(16, 16, Qt.KeepAspectRatio, Qt.SmoothTransformation)
+            gender_pixmap.scaled(
+                16,
+                16,
+                Qt.AspectRatioMode.KeepAspectRatio,
+                Qt.TransformationMode.SmoothTransformation,
+            )
         )
         icons_layout.addWidget(flag_label)
         icons_layout.addWidget(gender_label)
@@ -210,7 +225,7 @@ class VoiceMixer(QWidget):
         self.checkbox = QCheckBox()
         self.checkbox.setChecked(initial_status)
         self.checkbox.stateChanged.connect(self.toggle_inputs)
-        layout.addWidget(self.checkbox, alignment=Qt.AlignCenter)
+        layout.addWidget(self.checkbox, alignment=Qt.AlignmentFlag.AlignCenter)
 
         # Spinbox and slider
         self.spin_box = QDoubleSpinBox()
@@ -219,26 +234,16 @@ class VoiceMixer(QWidget):
         self.spin_box.setDecimals(2)
         self.spin_box.setValue(initial_weight)
 
-        self.slider = QSlider(Qt.Vertical)
+        self.slider = QSlider(Qt.Orientation.Vertical)
         self.slider.setRange(0, 100)
         self.slider.setValue(int(initial_weight * 100))
-        self.slider.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Expanding)
+        self.slider.setSizePolicy(
+            QSizePolicy.Policy.Fixed, QSizePolicy.Policy.Expanding
+        )
         self.slider.setFixedWidth(SLIDER_WIDTH)
 
-        # Fix slider in Windows
+        # Apply slider styling after widget is added to window (see showEvent)
-        if platform.system() == "Windows":
+        self._slider_style_applied = False
-            appstyle = QApplication.instance().style().objectName().lower()
-            if appstyle != "windowsvista":
-                # Set custom groove color for disabled state using COLORS["GREY_BACKGROUND"]
-                self.slider.setStyleSheet(
-                    f"""
-                    QSlider::groove:vertical:disabled {{
-                        background: {COLORS.get("GREY_BACKGROUND")};
-                        width: 4px;
-                        border-radius: 4px;
-                    }}
-                """
-                )
 
         # Connect controls
         self.slider.valueChanged.connect(lambda val: self.spin_box.setValue(val / 100))
@@ -249,23 +254,67 @@ class VoiceMixer(QWidget):
         # Layout for slider and labels
         slider_layout = QVBoxLayout()
         slider_layout.addWidget(self.spin_box)
-        slider_layout.addWidget(QLabel("1", alignment=Qt.AlignCenter))
+        slider_layout.addWidget(QLabel("1", alignment=Qt.AlignmentFlag.AlignCenter))
 
         slider_center_layout = QHBoxLayout()
-        slider_center_layout.addWidget(self.slider, alignment=Qt.AlignHCenter)
+        slider_center_layout.addWidget(
+            self.slider, alignment=Qt.AlignmentFlag.AlignHCenter
+        )
         slider_center_layout.setContentsMargins(0, 0, 0, 0)
 
         slider_center_widget = QWidget()
         slider_center_widget.setLayout(slider_center_layout)
 
         slider_layout.addWidget(slider_center_widget, stretch=1)
-        slider_layout.addWidget(QLabel("0", alignment=Qt.AlignCenter))
+        slider_layout.addWidget(QLabel("0", alignment=Qt.AlignmentFlag.AlignCenter))
         slider_layout.setStretch(2, 1)
 
         layout.addLayout(slider_layout, stretch=1)
         self.setLayout(layout)
         self.toggle_inputs()
 
+    def showEvent(self, event):
+        super().showEvent(event)
+        # Apply slider styling once when widget is shown and has access to parent
+        if not self._slider_style_applied:
+            self._slider_style_applied = True
+
+            # Fix slider in Windows
+            if platform.system() == "Windows":
+                appstyle = QApplication.instance().style().objectName().lower()
+                if appstyle != "windowsvista":
+                    # Set custom groove color for disabled state using COLORS["GREY_BACKGROUND"]
+                    self.slider.setStyleSheet(
+                        f"""
+                        QSlider::groove:vertical:disabled {{
+                            background: {COLORS.get("GREY_BACKGROUND")};
+                            width: 4px;
+                            border-radius: 4px;
+                        }}
+                    """
+                    )
+            else:
+                # Apply same fix for Light theme on non-Windows systems
+                # Get theme from parent window's config
+                parent_window = self.window()
+                theme = "system"
+                while parent_window:
+                    if hasattr(parent_window, "config"):
+                        theme = parent_window.config.get("theme", "system")
+                        break
+                    parent_window = parent_window.parent()
+
+                if theme == "light":
+                    self.slider.setStyleSheet(
+                        f"""
+                        QSlider::groove:vertical:disabled {{
+                            background: {COLORS.get("GREY_BACKGROUND")};
+                            width: 4px;
+                            border-radius: 4px;
+                        }}
+                    """
+                    )
+
     def toggle_inputs(self):
         is_enabled = self.checkbox.isChecked()
         self.spin_box.setEnabled(is_enabled)
@@ -307,9 +356,11 @@ class HoverLabel(QLabel):
             """
         )
         # Make sure the entire button is clickable, not just the text
-        self.delete_button.setFocusPolicy(Qt.NoFocus)
+        self.delete_button.setFocusPolicy(Qt.FocusPolicy.NoFocus)
-        self.delete_button.setAttribute(Qt.WA_TransparentForMouseEvents, False)
+        self.delete_button.setAttribute(
-        self.delete_button.setCursor(Qt.PointingHandCursor)
+            Qt.WidgetAttribute.WA_TransparentForMouseEvents, False
+        )
+        self.delete_button.setCursor(Qt.CursorShape.PointingHandCursor)
         self.delete_button.hide()
 
     def resizeEvent(self, event):
@@ -357,7 +408,7 @@ class VoiceFormulaDialog(QDialog):
         if parent is not None and hasattr(parent, "subtitle_combo"):
             self.subtitle_combo = parent.subtitle_combo
         # Create main container layout with profile section and mixer section
-        splitter = QSplitter(Qt.Horizontal)
+        splitter = QSplitter(Qt.Orientation.Horizontal)
         # Profile section
         profile_widget = QWidget()
         profile_layout = QVBoxLayout(profile_widget)
@@ -371,8 +422,8 @@ class VoiceFormulaDialog(QDialog):
         profile_layout.addLayout(header_layout)
         # Profile list
         self.profile_list = QListWidget()
-        self.profile_list.setSelectionMode(QListWidget.SingleSelection)
+        self.profile_list.setSelectionMode(QListWidget.SelectionMode.SingleSelection)
-        self.profile_list.setSelectionBehavior(QListWidget.SelectRows)
+        self.profile_list.setSelectionBehavior(QListWidget.SelectionBehavior.SelectRows)
         self.profile_list.setStyleSheet(
             "QListWidget::item:selected { background: palette(highlight); color: palette(highlighted-text); }"
         )
@@ -388,7 +439,7 @@ class VoiceFormulaDialog(QDialog):
             idx = list(profiles.keys()).index(self.current_profile)
             self.profile_list.setCurrentRow(idx)
         profile_layout.addWidget(self.profile_list)
-        self.profile_list.setContextMenuPolicy(Qt.CustomContextMenu)
+        self.profile_list.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
         self.profile_list.customContextMenuRequested.connect(
             self.show_profile_context_menu
         )
@@ -409,7 +460,9 @@ class VoiceFormulaDialog(QDialog):
 
         self.setWindowTitle("Voice Mixer")
         self.setWindowFlags(
-            Qt.Window | Qt.WindowCloseButtonHint | Qt.WindowMaximizeButtonHint
+            Qt.WindowType.Window
+            | Qt.WindowType.WindowCloseButtonHint
+            | Qt.WindowType.WindowMaximizeButtonHint
         )
         self.setMinimumSize(MIN_WINDOW_WIDTH, MIN_WINDOW_HEIGHT)
         self.resize(INITIAL_WINDOW_WIDTH, INITIAL_WINDOW_HEIGHT)
@@ -468,21 +521,25 @@ class VoiceFormulaDialog(QDialog):
 
         # Separator
         separator = QFrame()
-        separator.setFrameShadow(QFrame.Sunken)
+        separator.setFrameShadow(QFrame.Shadow.Sunken)
         mixer_layout.addWidget(separator)
 
         # Voice list scroll area
         self.scroll_area = QScrollArea()
         self.scroll_area.setWidgetResizable(True)
-        self.scroll_area.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded)
+        self.scroll_area.setHorizontalScrollBarPolicy(
-        self.scroll_area.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
+            Qt.ScrollBarPolicy.ScrollBarAsNeeded
+        )
+        self.scroll_area.setVerticalScrollBarPolicy(
+            Qt.ScrollBarPolicy.ScrollBarAsNeeded
+        )
         self.scroll_area.viewport().installEventFilter(self)
 
         self.voice_list_widget = QWidget()
         self.voice_list_layout = QHBoxLayout()
         self.voice_list_widget.setLayout(self.voice_list_layout)
         self.voice_list_widget.setSizePolicy(
-            QSizePolicy.Expanding, QSizePolicy.Expanding
+            QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding
         )
         self.scroll_area.setWidget(self.voice_list_widget)
         mixer_layout.addWidget(self.scroll_area, stretch=1)
@@ -497,6 +554,9 @@ class VoiceFormulaDialog(QDialog):
         ok_button.setDefault(True)
         ok_button.setFocus()
 
+        # Connect buttons
+        clear_all_button.clicked.connect(self.clear_all_voices)
+        ok_button.clicked.connect(self.accept)
         # Connect buttons
         clear_all_button.clicked.connect(self.clear_all_voices)
         ok_button.clicked.connect(self.accept)
@@ -533,7 +593,7 @@ class VoiceFormulaDialog(QDialog):
 
     def keyPressEvent(self, event):
         # Bind Delete key to delete_profile when a profile is selected
-        if event.key() == Qt.Key_Delete and self.profile_list.hasFocus():
+        if event.key() == Qt.Key.Key_Delete and self.profile_list.hasFocus():
             item = self.profile_list.currentItem()
             if item:
                 self.delete_profile(item)
@@ -562,10 +622,12 @@ class VoiceFormulaDialog(QDialog):
                 self,
                 "Unsaved Changes",
                 msg,
-                QMessageBox.Save | QMessageBox.Discard | QMessageBox.Cancel,
+                QMessageBox.StandardButton.Save
-                QMessageBox.Save,
+                | QMessageBox.StandardButton.Discard
+                | QMessageBox.StandardButton.Cancel,
+                QMessageBox.StandardButton.Save,
             )
-            if ret == QMessageBox.Save:
+            if ret == QMessageBox.StandardButton.Save:
                 # Save all using stored states
                 profiles = load_profiles()
                 for i in dirty_indices:
@@ -590,7 +652,7 @@ class VoiceFormulaDialog(QDialog):
                 self.update_profile_save_buttons()
                 self.update_profile_list_colors()
                 return True
-            elif ret == QMessageBox.Discard:
+            elif ret == QMessageBox.StandardButton.Discard:
                 # Discard all modifications
                 self._profile_states.clear()
                 for i in dirty_indices:
@@ -612,17 +674,19 @@ class VoiceFormulaDialog(QDialog):
         else:
             # Fallback to original logic for 0 or 1 dirty profile
             box = QMessageBox(self)
-            box.setIcon(QMessageBox.Warning)
+            box.setIcon(QMessageBox.Icon.Warning)
             box.setWindowTitle("Unsaved Changes")
             box.setText(
                 "You have unsaved changes in your profile. Do you want to save the changes?"
             )
             box.setStandardButtons(
-                QMessageBox.Save | QMessageBox.Discard | QMessageBox.Cancel
+                QMessageBox.StandardButton.Save
+                | QMessageBox.StandardButton.Discard
+                | QMessageBox.StandardButton.Cancel
             )
-            box.setDefaultButton(QMessageBox.Save)
+            box.setDefaultButton(QMessageBox.StandardButton.Save)
-            ret = box.exec_()
+            ret = box.exec()
-            if ret == QMessageBox.Save:
+            if ret == QMessageBox.StandardButton.Save:
                 for i in range(self.profile_list.count()):
                     item = self.profile_list.item(i)
                     name = item.text().lstrip("*")
@@ -636,7 +700,7 @@ class VoiceFormulaDialog(QDialog):
                 if hasattr(parent, "populate_profiles_in_voice_combo"):
                     parent.populate_profiles_in_voice_combo()
                 return True
-            elif ret == QMessageBox.Discard:
+            elif ret == QMessageBox.StandardButton.Discard:
                 profiles = load_profiles()
                 for i in range(self.profile_list.count()):
                     item = self.profile_list.item(i)
@@ -717,7 +781,7 @@ class VoiceFormulaDialog(QDialog):
         return voice_mixer
 
     def handle_voice_checkbox(self, voice_mixer, state):
-        if state == Qt.Checked:
+        if state == Qt.CheckState.Checked.value:
             self.last_enabled_voice = voice_mixer.voice_name
         self.update_weighted_sums()
 
@@ -767,7 +831,9 @@ class VoiceFormulaDialog(QDialog):
                     f'<b><span style="color:{COLORS.get("BLUE")}">{name}: {percentage:.1f}%</span></b>',
                     name,
                 )
-                voice_label.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
+                voice_label.setSizePolicy(
+                    QSizePolicy.Policy.Preferred, QSizePolicy.Policy.Preferred
+                )
                 voice_label.delete_button.clicked.connect(
                     lambda _, vn=name: self.disable_voice_by_name(vn)
                 )
@@ -787,7 +853,7 @@ class VoiceFormulaDialog(QDialog):
             mixer.checkbox.setChecked(False)
 
     def eventFilter(self, source, event):
-        if source is self.scroll_area.viewport() and event.type() == event.Wheel:
+        if source is self.scroll_area.viewport() and event.type() == event.Type.Wheel:
             # Skip if over an enabled slider
             if any(
                 mixer.slider.underMouse() and mixer.slider.isEnabled()
@@ -890,10 +956,10 @@ class VoiceFormulaDialog(QDialog):
             self,
             "Invalid Profiles",
             msg,
-            QMessageBox.Yes | QMessageBox.Cancel,
+            QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.Cancel,
-            QMessageBox.Yes,
+            QMessageBox.StandardButton.Yes,
         )
-        if reply == QMessageBox.Yes:
+        if reply == QMessageBox.StandardButton.Yes:
             for i, name in reversed(zero):
                 self.profile_list.takeItem(i)
                 delete_profile(name)
@@ -980,8 +1046,8 @@ class VoiceFormulaDialog(QDialog):
         super().closeEvent(event)
 
     def _parse_rgba_to_qcolor(self, rgba_str):
-        from PyQt5.QtCore import Qt
+        from PyQt6.QtCore import Qt
-        from PyQt5.QtGui import QColor
+        from PyQt6.QtGui import QColor
 
         """Helper to convert 'rgba(R,G,B,A_float)' string to QColor."""
         match = re.match(r"rgba\((\d+),\s*(\d+),\s*(\d+),\s*([\d.]+)\)", rgba_str)
@@ -1136,9 +1202,12 @@ class VoiceFormulaDialog(QDialog):
                     msg += f"\nThis will overwrite an existing profile."
                 msg += "\nContinue?"
                 reply = QMessageBox.question(
-                    self, "Import Profile", msg, QMessageBox.Yes | QMessageBox.No
+                    self,
+                    "Import Profile",
+                    msg,
+                    QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
                 )
-                if reply != QMessageBox.Yes:
+                if reply != QMessageBox.StandardButton.Yes:
                     return
                 profiles.update(imported_profiles)
                 save_profiles(profiles)
@@ -1153,9 +1222,12 @@ class VoiceFormulaDialog(QDialog):
                     msg += f"\n{len(collisions)} profile(s) will be overwritten."
                 msg += "\nContinue?"
                 reply = QMessageBox.question(
-                    self, "Import Profiles", msg, QMessageBox.Yes | QMessageBox.No
+                    self,
+                    "Import Profiles",
+                    msg,
+                    QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
                 )
-                if reply != QMessageBox.Yes:
+                if reply != QMessageBox.StandardButton.Yes:
                     return
                 profiles.update(imported_profiles)
                 save_profiles(profiles)
@@ -1196,7 +1268,7 @@ class VoiceFormulaDialog(QDialog):
         menu.addAction(dup_act)
         menu.addAction(export_act)
         menu.addAction(delete_act)
-        act = menu.exec_(self.profile_list.viewport().mapToGlobal(pos))
+        act = menu.exec(self.profile_list.viewport().mapToGlobal(pos))
         if act == rename_act:
             self.rename_profile(item)
         elif act == delete_act:
@@ -1323,9 +1395,9 @@ class VoiceFormulaDialog(QDialog):
             self,
             "Delete Profile",
             f"Delete profile '{name}'?",
-            QMessageBox.Yes | QMessageBox.No,
+            QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
         )
-        if reply == QMessageBox.Yes:
+        if reply == QMessageBox.StandardButton.Yes:
             delete_profile(name)
             row = self.profile_list.row(item)
             self.profile_list.takeItem(row)
@@ -1378,7 +1450,7 @@ class VoiceFormulaDialog(QDialog):
                 self.profile_list.setItemWidget(item, widget)
 
     def update_profile_list_colors(self):
-        from PyQt5.QtCore import Qt
+        from PyQt6.QtCore import Qt
 
         profiles = load_profiles()
         for i in range(self.profile_list.count()):
@@ -1386,13 +1458,14 @@ class VoiceFormulaDialog(QDialog):
             name = item.text().lstrip("*")
             if self._virtual_new_profile and name == "New profile":
                 color = self._parse_rgba_to_qcolor(COLORS.get("YELLOW_BACKGROUND"))
-                item.setData(Qt.BackgroundRole, color)
+                item.setData(Qt.ItemDataRole.BackgroundRole, color)
             elif item.text().startswith("*"):
                 color = self._parse_rgba_to_qcolor(COLORS.get("YELLOW_BACKGROUND"))
-                item.setData(Qt.BackgroundRole, color)
+                item.setData(Qt.ItemDataRole.BackgroundRole, color)
             else:
                 item.setData(
-                    Qt.BackgroundRole, self.profile_list.palette().base().color()
+                    Qt.ItemDataRole.BackgroundRole,
+                    self.profile_list.palette().base().color(),
                 )
                 weights = profiles.get(name, {}).get("voices", [])
                 total = 0
@@ -1406,7 +1479,7 @@ class VoiceFormulaDialog(QDialog):
                             total += entry[1]
                 if total == 0:
                     color = self._parse_rgba_to_qcolor(COLORS.get("RED_BACKGROUND"))
-                    item.setData(Qt.BackgroundRole, color)
+                    item.setData(Qt.ItemDataRole.BackgroundRole, color)
         self.update_profile_save_buttons()
 
     def preview_current_mix(self):

pyproject.toml

@@ -13,7 +13,7 @@ license = "MIT"
 requires-python = ">=3.10, <3.13"
 keywords = ["audiobook", "epub", "pdf", "text-to-speech", "subtitle", "tts", "kokoro", "accessibility", "book-converter", "voice-synthesis", "multilingual", "chapter-management", "subtitles", "content-creation", "media-generation"]
 dependencies = [
-    "PyQt5>=5.15.11",
+    "PyQt6>=6.10.0",
     "kokoro>=0.9.4",
     "misaki[zh]>=0.9.4",
     "ebooklib>=0.19",
@@ -25,7 +25,8 @@ dependencies = [
     "charset_normalizer>=3.4.1",
     "chardet>=5.2.0",
     "static_ffmpeg>=2.13",
-    "Markdown>=3.9"
+    "Markdown>=3.9",
+    "spacy>=3.8.7"
 ]
 
 classifiers = [