v1.2.0

Fixed “Go to folder” button not opening the chapter output directory when only separate chapters were generated
Fix total character count
2026-07-18 21:50:28 +02:00 · 2025-10-20 03:57:16 +03:00 · 2025-10-20 03:51:27 +03:00 · 2025-10-20 03:35:20 +03:00 · 2025-10-20 03:21:27 +03:00 · 2025-10-20 02:29:16 +03:00
12 changed files with 1330 additions and 361 deletions
@@ -1,3 +1,31 @@
+# 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.
+- Improvements in code and documentation.
+
+# 1.1.8
+- Added `.md` (Markdown) file extension support by @brianxiadong in PR #75
+- Added new option `Configure silence between chapters` that lets you configure the silence between chapters, mentioned by @lfperez1982 in #79
+- Better indicators and options while displaying and managing the input and processing files.
+- Improved the markdown logic to better handle various markdown structures and cases.
+- Fixed subtitle splitting before commas by combining punctuation with preceding words.
+- Fixed save options not working correctly in queue mode, mentioned by @jborza in #78
+- Fixed `No Qt platform plugin could be initialized` error, mentioned by @sunrainxyz in #59
+- Fixed ordered list numbers not being included in EPUB content conversion. The numbers are now properly included in the converted content, mentioned by @jefro108 in #47
+- Potentially fixed subtitle generation stucks at 9:59:59, mentioned by @bolaykim in #73
+- Improvements in code and documentation.
+
 # 1.1.7
 - Added MPS GPU acceleration support for Silicon Mac, mentioned in https://github.com/denizsafak/abogen/issues/32#issuecomment-3155902040 by @jefro108. **Please read the [Mac](https://github.com/denizsafak/abogen?tab=readme-ov-file#mac) section in the documentation again, as it requires additional configuration.**
 - Added word-by-word karaoke highlighting feature by @robmckinnon in PR #65
@@ -7,7 +7,9 @@
 [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
 [![License: MIT](https://img.shields.io/badge/License-MIT-maroon.svg)](https://opensource.org/licenses/MIT)

-Abogen is a powerful text-to-speech conversion tool that makes it easy to turn ePub, PDF, or text 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).
+<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).

 <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">

@@ -89,14 +91,16 @@ pip3 install abogen
 pip3 uninstall torch 
 pip3 install --pre torch torchvision torchaudio --index-url https://download.pytorch.org/whl/nightly/rocm6.4
 ```
-> [!TIP]
-> If you get `WARNING: The script abogen-cli is installed in '/home/username/.local/bin' which is not on PATH.` error, run the following command to add it to your PATH:
->```bash
->echo "export PATH=\"/home/$USER/.local/bin:\$PATH\"" >> ~/.bashrc && source ~/.bashrc
->```

-> [!TIP]
-> If you get "No matching distribution found" error, try installing it on supported Python (3.10 to 3.12). You can use [pyenv](https://github.com/pyenv/pyenv) to manage multiple Python versions easily in Linux. Watch this [video](https://www.youtube.com/watch?v=MVyb-nI4KyI) by NetworkChuck for a quick guide.
+> See [How to fix "CUDA GPU is not available. Using CPU" warning?](#cuda-warning)
+
+> See [How  to fix "WARNING: The script abogen-cli is installed in '/home/username/.local/bin' which is not on PATH" error in Linux?](#path-warning)
+
+> 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.

@@ -107,10 +111,10 @@ If you installed using pip, you can simply run the following command to start Ab
 abogen
 ```
 > [!TIP]
-> If you installed 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.
+> 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, or text file (or use the built-in text editor)
+1) Drag and drop any ePub, PDF, text or markdown 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)
@@ -128,21 +132,27 @@ Here’s Abogen in action: in this demo, it processes ∼3,000 characters of tex

 | Options | Description |
 |---------|-------------|
-| **Input Box** | Drag and drop `ePub`, `PDF`, or `.TXT` files (or use built-in text editor) |
+| **Input Box** | Drag and drop `ePub`, `PDF`, `.TXT` or `.MD` 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) |
-| **Output voice format** | `.WAV`, `.FLAC`, `.MP3`, `.OPUS (best compression)` and `M4B (with chapters)` (Special thanks to [@jborza](https://github.com/jborza) for chapter support in PR [#10](https://github.com/denizsafak/abogen/pull/10)) |
+| **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. |
 | **Save location** | `Save next to input file`, `Save to desktop`, or `Choose output folder` |

+> Special thanks to [@brianxiadong](https://github.com/brianxiadong) for adding markdown support in PR [#75](https://github.com/denizsafak/abogen/pull/75)
+
+> 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 `chapters + pages` from PDFs. |
+| **Chapter Control** | Select specific `chapters` from ePUBs or markdown files or `chapters + pages` from PDFs. |
 | **Save each chapter separately** | Save each chapter in e-books as a separate audio file. |
 | **Create a merged version** | Create a single audio file that combines all chapters. (If `Save each chapter separately` is disabled, this option will be the default behavior.) |
 | **Save in a project folder with metadata** | Save the converted items in a project folder with available metadata files. |
@@ -151,6 +161,7 @@ Here’s Abogen in action: in this demo, it processes ∼3,000 characters of tex
 |---------|-------------|
 | **Theme** | Change the application's theme using `System`, `Light`, or `Dark` options. |
 | **Configure max words per subtitle** | Configures the maximum number of words per subtitle entry. |
+| **Configure silence between chapters** | Configures the duration of silence between chapters (in seconds). |
 | **Configure max lines in log window** | Configures the maximum number of lines to display in the log window. |
 | **Separate chapters audio format** | Configures the audio format for separate chapters as `wav`, `flac`, `mp3`, or `opus`. |
 | **Create desktop shortcut** | Creates a shortcut on your desktop for easy access. |
@@ -166,27 +177,30 @@ Here’s Abogen in action: in this demo, it processes ∼3,000 characters of tex
 ## `Voice Mixer`
 <img title="Abogen Voice Mixer" src='https://raw.githubusercontent.com/denizsafak/abogen/refs/heads/main/demo/voice_mixer.png'>

-With voice mixer, you can create custom voices by mixing different voice models. You can adjust the weight of each voice and save your custom voice as a profile for future use. The voice mixer allows you to create unique and personalized voices. (Huge thanks to [@jborza](https://github.com/jborza) for making this possible through his contributions in [#5](https://github.com/denizsafak/abogen/pull/5))
+With voice mixer, you can create custom voices by mixing different voice models. You can adjust the weight of each voice and save your custom voice as a profile for future use. The voice mixer allows you to create unique and personalized voices.
+
+> Special thanks to [@jborza](https://github.com/jborza) for making this possible through his contributions in [#5](https://github.com/denizsafak/abogen/pull/5)

 ## `Queue Mode`
 <img title="Abogen queue mode" src='https://raw.githubusercontent.com/denizsafak/abogen/refs/heads/main/demo/queue.png'>

 Abogen supports **queue mode**, allowing you to add multiple files to a processing queue. This is useful if you want to convert several files in one batch.

- You can add text files (`.txt`) directly using the **Add files** button in the Queue Manager. To add PDF or EPUB files, use the input box in the main window and click the **Add to Queue** button.
+- You can add text files (`.txt`) directly using the **Add files** button in the Queue Manager. To add PDF, EPUB, or markdown files, use the input box in the main window and click the **Add to Queue** button.
 - Each file in the queue keeps the configuration settings that were active when it was added. Changing the main window configuration afterward does **not** affect files already in the queue.
 - You can view each file's configuration by hovering over them.

 Abogen will process each item in the queue automatically, saving outputs as configured.
+
 > Special thanks to [@jborza](https://github.com/jborza) for adding queue mode in PR [#35](https://github.com/denizsafak/abogen/pull/35)

 ## `About Chapter Markers`
-When you process ePUB or PDF files, Abogen converts them into text files stored in your cache directory. When you click "Edit," you're actually modifying these converted text files. In these text files, you'll notice tags that look like this:
+When you process ePUB, PDF or markdown files, Abogen converts them into text files stored in your cache directory. When you click "Edit," you're actually modifying these converted text files. In these text files, you'll notice tags that look like this:

 ```
 <<CHAPTER_MARKER:Chapter Title>>
 ```
-These are chapter markers. They are automatically added when you process ePUB or PDF files, based on the chapters you select. They serve an important purpose:
+These are chapter markers. They are automatically added when you process ePUB, PDF or markdown files, based on the chapters you select. They serve an important purpose:
 -  Allow you to split the text into separate audio files for each chapter
 -  Save time by letting you reprocess only specific chapters if errors occur, rather than the entire file

@@ -204,7 +218,7 @@ When you process the text file, Abogen will detect these markers automatically a
 ![Abogen Chapter Marker](https://raw.githubusercontent.com/denizsafak/abogen/refs/heads/main/demo/chapter_marker.png)

 ## `About Metadata Tags`
-Similar to chapter markers, it is possible to add metadata tags for `M4B` files. This is useful for audiobook players that support metadata, allowing you to add information like title, author, year, etc. Abogen automatically adds these tags when you process ePUB or PDF files, but you can also add them manually to your text files. Add metadata tags **at the beginning of your text file** like this:
+Similar to chapter markers, it is possible to add metadata tags for `M4B` files. This is useful for audiobook players that support metadata, allowing you to add information like title, author, year, etc. Abogen automatically adds these tags when you process ePUB, PDF or markdown files, but you can also add them manually to your text files. Add metadata tags **at the beginning of your text file** like this:
 ```
 <<METADATA_TITLE:Title>>
 <<METADATA_ARTIST:Author>>
@@ -228,8 +242,7 @@ Similar to chapter markers, it is possible to add metadata tags for `M4B` files.
 ```
 For a complete list of supported languages and voices, refer to Kokoro's [VOICES.md](https://huggingface.co/hexgrad/Kokoro-82M/blob/main/VOICES.md). To listen to sample audio outputs, see [SAMPLES.md](https://huggingface.co/hexgrad/Kokoro-82M/blob/main/SAMPLES.md).

-> [!NOTE]
-> Japanese audio may require additional configuration. Please check [#56](https://github.com/denizsafak/abogen/issues/56) for more information.
+> See [How to fix Japanese audio not working?](#japanese-audio-not-working)

 ## `MPV Config`
 I highly recommend using [MPV](https://mpv.io/installation/) to play your audio files, as it supports displaying subtitles even without a video track. Here's my `mpv.conf`:
@@ -277,12 +290,13 @@ Abogen launches automatically inside the container.
 - You can access it via a web browser at [http://localhost:5800](http://localhost:5800) or connect to it using a VNC client at `localhost:5900`.
 - You can use `/shared` directory to share files between your host and the container.
 - For later use, start it with `docker start abogen` and stop it with `docker stop abogen`.
+- Pass in `-e WEB_AUDIO="1"` for `docker run` to enable audio.

 Known issues:
- Audio preview is not working inside container (ALSA error).
+- Audio preview is not working inside container (ALSA error) if using a VNC client.
 - `Open cache directory` and `Open configuration directory` options in settings not working. (Tried pcmanfm, did not work with Abogen).

-(Special thanks to [@geo38](https://www.reddit.com/user/geo38/) from Reddit, who provided the Dockerfile and instructions in [this comment](https://www.reddit.com/r/selfhosted/comments/1k8x1yo/comment/mpe0bz8/).)
+> Special thanks to [@geo38](https://www.reddit.com/user/geo38/) from Reddit, who provided the Dockerfile and instructions in [this comment](https://www.reddit.com/r/selfhosted/comments/1k8x1yo/comment/mpe0bz8/).

 ## `Similar Projects`
 Abogen is a standalone project, but it is inspired by and shares some similarities with other projects. Here are a few:
@@ -305,8 +319,115 @@ If you encounter any issues while running Abogen, try launching it from the comm
 ```
 abogen-cli
 ```
+
+If you installed using the Windows installer `(WINDOWS_INSTALL.bat)`, go to `python_embedded/Scripts` and run:
+```
+abogen-cli.exe
+```
+
 This will start Abogen in command-line mode and display detailed error messages. Please open a new issue on the [Issues](https://github.com/denizsafak/abogen/issues) page with the error message and a description of your problem.

+## `Common Issues & Solutions`
+
+<details><summary><b>
+<a name="about-abogen">About the name "abogen"</a>
+</b></summary>
+
+> The name **"abogen"** comes from a shortened form of **"audiobook generator"**, which is the purpose of this project.  
+>
+> After releasing the project, I learned from [community feedback](https://news.ycombinator.com/item?id=44853064#44857237) that the prefix *"abo"* can unfortunately be understood as an ethnic slur in certain regions (particularly Australia and New Zealand). This was something I was not aware of when naming the project, as English is not my first language.  
+>
+> I want to make it clear that the name was chosen only for its technical meaning, with **no offensive intent**. I’m grateful to those who kindly pointed this out, as it helps ensure the project remains respectful and welcoming to everyone.  
+
+</details>
+
+<details><summary><b>
+<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.
+>
+> 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
+> ```
+> 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.
+
+</details>
+
+<details><summary><b>
+<a name="path-warning">How to fix "WARNING: The script abogen-cli is installed in '/home/username/.local/bin' which is not on PATH" error in Linux?</a>
+</b></summary>
+
+> Run the following command to add Abogen to your PATH:
+> ```bash
+> echo "export PATH=\"/home/$USER/.local/bin:\$PATH\"" >> ~/.bashrc && source ~/.bashrc
+> ```
+
+</details>
+
+<details><summary><b>
+<a name="no-matching-distribution-found">How to fix "No matching distribution found" error?<a>
+</b></summary>
+
+> Try installing Abogen on supported Python (3.10 to 3.12) versions. You can use [pyenv](https://github.com/pyenv/pyenv) to manage multiple Python versions easily in Linux. Watch this [video](https://www.youtube.com/watch?v=MVyb-nI4KyI) by NetworkChuck for a quick guide.
+
+</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 torch==2.8.0 torchaudio==2.8.0 torchvision==0.23.0
+> ```
+> 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>
+
+> Japanese audio may require additional configuration. 
+> I'm not sure about the exact solution, but it seems to be related to installing additional dependencies for Japanese support in Kokoro. Please check [#56](https://github.com/denizsafak/abogen/issues/56) for more information. 
+
+</details>
+
+<details><summary><b>
+<a name="use-uv-instead-of-pip">How to use "uv" instead of "pip"?</a>
+</b></summary>
+
+> Abogen needs "pip", because Kokoro uses pip to download voice models from HuggingFace Hub. If you want to use "uv" instead of "pip", you can use the following command to run Abogen:
+>
+> ```bash
+> uvx --with pip abogen
+> ```
+
+</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
@@ -331,7 +452,10 @@ Feel free to explore the code and make any changes you like.
 This project is available under the MIT License - see the [LICENSE](https://github.com/denizsafak/abogen/blob/main/LICENSE) file for details.
 [Kokoro](https://github.com/hexgrad/kokoro) is licensed under [Apache-2.0](https://github.com/hexgrad/kokoro/blob/main/LICENSE) which allows commercial use, modification, distribution, and private use.

+## `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]
 > 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.

-> 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, 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, content-creation, media-generation
@@ -139,10 +139,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
@@ -1 +1 @@
-1.1.7
+1.2.0
@@ -1,5 +1,4 @@
 import re
-import html
 import ebooklib
 import base64
 import fitz  # PyMuPDF for PDF support
@@ -21,11 +20,13 @@ from PyQt5.QtWidgets import (
    QMenu,
    QLabel,
 )
-from PyQt5.QtCore import Qt
-from abogen.utils import clean_text, calculate_text_length
+from PyQt5.QtCore import Qt, QThread, pyqtSignal
+from abogen.utils import clean_text, calculate_text_length, detect_encoding
 import os
 import logging  # Add logging
 import urllib.parse
+import markdown
+import textwrap

 # Setup logging
 logging.basicConfig(
@@ -39,22 +40,58 @@ class HandlerDialog(QDialog):
    _merge_chapters_at_end = True
    _save_as_project = False  # New class variable for save_as_project option
    
+    # Cache for processed book content to avoid reprocessing
+    # Key: (book_path, modification_time, file_type)
+    # Value: dict with content_texts, content_lengths, doc_content (for epub), markdown_toc (for markdown)
+    _content_cache = {}
+
+    class _LoaderThread(QThread):
+        """Minimal QThread that runs a callable and emits an error string on exception."""
+        error = pyqtSignal(str)
+
+        def __init__(self, target_callable):
+            super().__init__()
+            self._target = target_callable
+
+        def run(self):
+            try:
+                self._target()
+            except Exception as e:
+                self.error.emit(str(e))
+
+    @classmethod
+    def clear_content_cache(cls, book_path=None):
+        """Clear the content cache. If book_path is provided, only clear that book's cache."""
+        if book_path is None:
+            cls._content_cache.clear()
+            logging.info("Cleared all content cache")
+        else:
+            keys_to_remove = [key for key in cls._content_cache.keys() if key[0] == book_path]
+            for key in keys_to_remove:
+                del cls._content_cache[key]
+            if keys_to_remove:
+                logging.info(f"Cleared content cache for {os.path.basename(book_path)}")
+
    def __init__(self, book_path, file_type=None, checked_chapters=None, parent=None):
        super().__init__(parent)

        # Determine file type if not explicitly provided
-        self.file_type = file_type or (
-            "pdf" if book_path.lower().endswith(".pdf") else "epub"
-        )
+        if file_type:
+            self.file_type = file_type
+        elif book_path.lower().endswith(".pdf"):
+            self.file_type = "pdf"
+        elif book_path.lower().endswith((".md", ".markdown")):
+            self.file_type = "markdown"
+        else:
+            self.file_type = "epub"
        self.book_path = book_path

        # Extract book name from file path
        book_name = os.path.splitext(os.path.basename(book_path))[0]

        # Set window title based on file type and book name
-        self.setWindowTitle(
-            f'Select {"Chapters" if self.file_type == "epub" else "Pages"} - {book_name}'
-        )
+        item_type = "Chapters" if self.file_type in ["epub", "markdown"] else "Pages"
+        self.setWindowTitle(f'Select {item_type} - {book_name}')
        self.resize(1200, 900)
        self._block_signals = False  # Flag to prevent recursive signals
        # Configure window: remove help button and allow resizing
@@ -69,7 +106,12 @@ class HandlerDialog(QDialog):

        # Load the book based on file type
        try:
-            self.book = epub.read_epub(book_path) if self.file_type == "epub" else None
+            if self.file_type == "epub":
+                self.book = epub.read_epub(book_path)
+            elif self.file_type == "markdown":
+                self.book = None  # Markdown doesn't use ebooklib
+            else:
+                self.book = None
        except KeyError as e:
            logging.error(
                f"EPUB file is missing a referenced file: {e}. Skipping missing file."
@@ -100,6 +142,16 @@ class HandlerDialog(QDialog):
                logging.error(f"Failed to patch ebooklib for missing files: {patch_e}")
                raise e
        self.pdf_doc = fitz.open(book_path) if self.file_type == "pdf" else None
+        self.markdown_text = None
+        if self.file_type == "markdown":
+            try:
+                encoding = detect_encoding(book_path)
+                with open(book_path, "r", encoding=encoding, errors="replace") as f:
+                    self.markdown_text = f.read()
+            except Exception as e:
+                logging.error(f"Error reading markdown file: {e}")
+                self.markdown_text = ""
+        self.markdown_toc = []  # For storing parsed markdown TOC

        # Extract book metadata
        self.book_metadata = self._extract_book_metadata()
@@ -118,14 +170,11 @@ class HandlerDialog(QDialog):
        # Initialize checked_chapters set
        self.checked_chapters = set(checked_chapters) if checked_chapters else set()

-        # For storing content and lengths
+        # For storing content and lengths (will be filled by background loader)
        self.content_texts = {}
        self.content_lengths = {}

-        # Pre-process content based on file type
-        self._preprocess_content()
-
-        # Add "Information" item at the beginning of the tree
+        # Add a placeholder "Information" item so the tree isn't empty immediately
        info_item = QTreeWidgetItem(self.treeWidget, ["Information"])
        info_item.setData(0, Qt.UserRole, "info:bookinfo")
        info_item.setFlags(info_item.flags() & ~Qt.ItemIsUserCheckable)
@@ -133,8 +182,18 @@ class HandlerDialog(QDialog):
        font.setBold(True)
        info_item.setFont(0, font)

-        # Build tree based on file type
-        self._build_tree()
+        # Setup UI now so dialog appears immediately
+        self._setup_ui()
+
+        # Create a centered loading overlay and show it while background load runs
+        self._create_loading_overlay()
+        # Hide the main UI so only the overlay is visible initially
+        if getattr(self, 'splitter', None) is not None:
+            self.splitter.setVisible(False)
+        self._show_loading_overlay("Loading...")
+
+        # Start background loading of book content so the dialog opens immediately
+        self._start_background_load()

        # Hide expand/collapse decoration if there are no parent items
        has_parents = False
@@ -144,30 +203,123 @@ class HandlerDialog(QDialog):
                break
        self.treeWidget.setRootIsDecorated(has_parents)

-        # Setup UI (creates save_chapters_checkbox and other UI elements)
-        self._setup_ui()

-        # Run auto-check after UI is setup
-        if not self._are_provided_checks_relevant():
-            self._run_auto_check()

-        # Connect signals
-        self.treeWidget.currentItemChanged.connect(self.update_preview)
-        self.treeWidget.itemChanged.connect(self.handle_item_check)
-        self.treeWidget.itemChanged.connect(lambda _: self._update_checkbox_states())
-        self.treeWidget.itemDoubleClicked.connect(self.handle_item_double_click)
+    def _create_loading_overlay(self):
+        """Create a simple centered QLabel used as loading indicator.

-        # Select first item and expand all
-        self.treeWidget.expandAll()
-        if self.treeWidget.topLevelItemCount() > 0:
-            self.treeWidget.setCurrentItem(self.treeWidget.topLevelItem(0))
-            self.treeWidget.setFocus()
+        This label is added to the dialog's main layout above the splitter so
+        when the splitter is hidden only the text is visible.
+        """
+        try:
+            label = QLabel(self)
+            label.setAlignment(Qt.AlignCenter)
+            # larger plain text per request
+            label.setStyleSheet("font-size: 14pt;")
+            label.setVisible(False)
+            # insert at top of main layout if present, otherwise keep as child
+            try:
+                layout = self.layout()
+                if layout is not None:
+                    layout.insertWidget(0, label)
+            except Exception:
+                pass
+            self._loading_label = label
+        except Exception:
+            self._loading_label = None

-        # Update checkbox states
-        self._update_checkbox_states()
+    def _show_loading_overlay(self, text: str):
+        lbl = getattr(self, '_loading_label', None)
+        if lbl is None:
+            return
+        lbl.setText(text)
+        lbl.setVisible(True)
+
+    def _hide_loading_overlay(self):
+        lbl = getattr(self, '_loading_label', None)
+        if lbl is None:
+            return
+        lbl.setVisible(False)
+
+
+    def _start_background_load(self):
+        """Start a QThread that runs the preprocessing in background."""
+        # Start a minimal QThread which executes _preprocess_content
+        self._loader_thread = HandlerDialog._LoaderThread(self._preprocess_content)
+        self._loader_thread.finished.connect(self._on_load_finished)
+        self._loader_thread.error.connect(self._on_load_error)
+        # ensure thread instance is deleted when done
+        self._loader_thread.finished.connect(self._loader_thread.deleteLater)
+        self._loader_thread.start()
+
+    def _on_load_error(self, err_msg):
+        logging.error(f"Error loading book in background: {err_msg}")
+        if getattr(self, 'previewEdit', None) is not None:
+            self.previewEdit.setPlainText(f"Error loading book: {err_msg}")
+        if getattr(self, 'splitter', None) is not None:
+            self.splitter.setVisible(True)
+        self._hide_loading_overlay()
+
+    def _on_load_finished(self):
+        """Called in the main thread when background loading finished."""
+        # Build the tree now that content_texts/content_lengths/etc. are ready
+        try:
+            # Rebuild tree based on file type
+            self._build_tree()
+
+            # Run auto-check if no provided checks are relevant
+            if not self._are_provided_checks_relevant():
+                self._run_auto_check()
+
+            # Connect signals (after tree exists)
+            self.treeWidget.currentItemChanged.connect(self.update_preview)
+            self.treeWidget.itemChanged.connect(self.handle_item_check)
+            self.treeWidget.itemChanged.connect(lambda _: self._update_checkbox_states())
+            self.treeWidget.itemDoubleClicked.connect(self.handle_item_double_click)
+
+            # Expand and select first item
+            self.treeWidget.expandAll()
+            if self.treeWidget.topLevelItemCount() > 0:
+                self.treeWidget.setCurrentItem(self.treeWidget.topLevelItem(0))
+                self.treeWidget.setFocus()
+
+            # Update checkbox states
+            self._update_checkbox_states()
+
+            # Update preview for the current selection
+            current = self.treeWidget.currentItem()
+            self.update_preview(current)
+
+        except Exception as e:
+            logging.error(f"Error finalizing book load: {e}")
+        # Show the main UI and hide loading text
+        if getattr(self, 'splitter', None) is not None:
+            self.splitter.setVisible(True)
+        self._hide_loading_overlay()

    def _preprocess_content(self):
        """Pre-process content from the document"""
+        # Create cache key from file path, modification time, and file type
+        try:
+            mod_time = os.path.getmtime(self.book_path)
+        except Exception:
+            mod_time = 0
+        
+        cache_key = (self.book_path, mod_time, self.file_type)
+        
+        # Check if content is already cached
+        if cache_key in HandlerDialog._content_cache:
+            cached_data = HandlerDialog._content_cache[cache_key]
+            self.content_texts = cached_data['content_texts']
+            self.content_lengths = cached_data['content_lengths']
+            if 'doc_content' in cached_data:
+                self.doc_content = cached_data['doc_content']
+            if 'markdown_toc' in cached_data:
+                self.markdown_toc = cached_data['markdown_toc']
+            logging.info(f"Using cached content for {os.path.basename(self.book_path)}")
+            return
+        
+        # Process content if not cached
        if self.file_type == "epub":
            try:
                self._process_epub_content_nav()  # Use the new navigation-based method
@@ -178,9 +330,24 @@ class HandlerDialog(QDialog):
                )
                # Fallback to a simpler spine-based processing if nav fails
                self._process_epub_content_spine_fallback()
+        elif self.file_type == "markdown":
+            self._preprocess_markdown_content()
        else:
            self._preprocess_pdf_content()
        
+        # Cache the processed content
+        cache_data = {
+            'content_texts': self.content_texts,
+            'content_lengths': self.content_lengths,
+        }
+        if hasattr(self, 'doc_content'):
+            cache_data['doc_content'] = self.doc_content
+        if hasattr(self, 'markdown_toc'):
+            cache_data['markdown_toc'] = self.markdown_toc
+        
+        HandlerDialog._content_cache[cache_key] = cache_data
+        logging.info(f"Cached content for {os.path.basename(self.book_path)}")
+
    def _preprocess_pdf_content(self):
        """Pre-process all page contents from PDF document"""
        for page_num in range(len(self.pdf_doc)):
@@ -199,10 +366,78 @@ class HandlerDialog(QDialog):
            # (common in headers/footers like "- 42 -")
            text = re.sub(r"\s+[-–—]\s*\d+\s*[-–—]?\s*$", "", text, flags=re.MULTILINE)

-            page_id = f"page_{page_num+1}"
+            page_id = f"page_{page_num + 1}"
            self.content_texts[page_id] = text
            self.content_lengths[page_id] = calculate_text_length(text)
    
+
+    def _preprocess_markdown_content(self):
+        if not self.markdown_text:
+            return
+
+        # Generate TOC from the original (dedented) markdown BEFORE cleaning,
+        # so header ids/anchors are preserved for reliable position detection.
+        original_text = textwrap.dedent(self.markdown_text)
+        md = markdown.Markdown(extensions=['toc', 'fenced_code'])
+        html = md.convert(original_text)
+        self.markdown_toc = md.toc_tokens
+
+        # Use cleaned text for stored content/length calculations
+        cleaned_full_text = clean_text(original_text)
+
+        soup = BeautifulSoup(html, 'html.parser')
+        self.content_texts = {}
+        self.content_lengths = {}
+
+        if not self.markdown_toc:
+            chapter_id = "markdown_content"
+            self.content_texts[chapter_id] = cleaned_full_text
+            self.content_lengths[chapter_id] = calculate_text_length(cleaned_full_text)
+            return
+
+        all_headers = []
+        def flatten_toc(toc_list):
+            for header in toc_list:
+                all_headers.append(header)
+                if header.get('children'):
+                    flatten_toc(header['children'])
+        flatten_toc(self.markdown_toc)
+
+        header_positions = []
+        for header in all_headers:
+            header_id = header['id']
+            id_pattern = f'id="{header_id}"'
+            pos = html.find(id_pattern)
+            if pos != -1:
+                tag_start = html.rfind('<', 0, pos)
+                header_positions.append({
+                    'id': header_id,
+                    'start': tag_start,
+                    'name': header['name']
+                })
+        header_positions.sort(key=lambda x: x['start'])
+
+        for i, header_pos in enumerate(header_positions):
+            header_id = header_pos['id']
+            header_name = header_pos['name']
+            content_start = header_pos['start']
+            content_end = header_positions[i + 1]['start'] if i + 1 < len(header_positions) else len(html)
+            section_html = html[content_start:content_end]
+            section_soup = BeautifulSoup(section_html, 'html.parser')
+            header_tag = section_soup.find(attrs={'id': header_id})
+            if header_tag:
+                header_tag.decompose()
+            # Clean section text for storage/lengths
+            section_text = clean_text(section_soup.get_text()).strip()
+            chapter_id = header_id
+            if section_text:
+                full_content = f"{header_name}\n\n{section_text}"
+                self.content_texts[chapter_id] = full_content
+                self.content_lengths[chapter_id] = calculate_text_length(full_content)
+            else:
+                self.content_texts[chapter_id] = header_name
+                self.content_lengths[chapter_id] = calculate_text_length(header_name)
+
    def _process_epub_content_spine_fallback(self):
        """Fallback EPUB processing based purely on spine order."""
        logging.info("Using spine fallback for EPUB processing.")
@@ -235,9 +470,23 @@ class HandlerDialog(QDialog):
            html_content = self.doc_content.get(doc_href, "")
            if html_content:
                soup = BeautifulSoup(html_content, "html.parser")
+                
+                # Handle ordered lists by prepending numbers to list items
+                for ol in soup.find_all("ol"):
+                    # Get start attribute or default to 1
+                    start = int(ol.get("start", 1))
+                    for i, li in enumerate(ol.find_all("li", recursive=False)):
+                        # Insert the number at the beginning of the list item
+                        number_text = f"{start + i}) "
+                        if li.string:
+                            li.string.replace_with(number_text + li.string)
+                        else:
+                            li.insert(0, NavigableString(number_text))
+                
                # Remove sup and sub tags
                for tag in soup.find_all(["sup", "sub"]):
                    tag.decompose()
+                    
                text = clean_text(soup.get_text()).strip()
                if text:
                    self.content_texts[doc_href] = text
@@ -250,14 +499,14 @@ class HandlerDialog(QDialog):
                        title = h1.get_text(strip=True)

                    if not title:
-                        title = f"Untitled Chapter {i+1}"
+                        title = f"Untitled Chapter {i + 1}"
                    synthetic_toc.append(
                        (epub.Link(doc_href, title, doc_href), [])
                    )  # Wrap in tuple and empty list for compatibility

        # Replace book.toc with the synthetic one if it was empty or fallback was triggered
        if not self.book.toc or not hasattr(
-            self, "processed_nav_structure"
+                self, "processed_nav_structure"
        ):  # Check if nav processing failed
            self.book.toc = synthetic_toc
            logging.info(f"Generated synthetic TOC with {len(synthetic_toc)} entries.")
@@ -282,7 +531,7 @@ class HandlerDialog(QDialog):
                    item
                    for item in nav_items
                    if "nav" in item.get_name().lower()
-                    and item.get_name().lower().endswith((".xhtml", ".html"))
+                       and item.get_name().lower().endswith((".xhtml", ".html"))
                ),
                None,
            )
@@ -395,8 +644,8 @@ class HandlerDialog(QDialog):
        for item in self.book.get_items_of_type(ebooklib.ITEM_DOCUMENT):
            href = item.get_name()
            if href in doc_order or any(
-                href in nav_point.get("src", "")
-                for nav_point in nav_soup.find_all(["content", "a"])
+                    href in nav_point.get("src", "")
+                    for nav_point in nav_soup.find_all(["content", "a"])
            ):
                try:
                    html_content = item.get_content().decode("utf-8", errors="ignore")
@@ -541,10 +790,26 @@ class HandlerDialog(QDialog):
                slice_html = current_doc_html
            if slice_html.strip():
                slice_soup = BeautifulSoup(slice_html, "html.parser")
+                # Add line breaks after paragraphs and divs
                for tag in slice_soup.find_all(["p", "div"]):
                    tag.append("\n\n")
+                
+                # Handle ordered lists by prepending numbers to list items
+                for ol in slice_soup.find_all("ol"):
+                    # Get start attribute or default to 1
+                    start = int(ol.get("start", 1))
+                    for i, li in enumerate(ol.find_all("li", recursive=False)):
+                        # Insert the number at the beginning of the list item
+                        number_text = f"{start + i}) "
+                        if li.string:
+                            li.string.replace_with(number_text + li.string)
+                        else:
+                            li.insert(0, NavigableString(number_text))
+                
+                # Remove sup and sub tags that might contain footnotes
                for tag in slice_soup.find_all(["sup", "sub"]):
                    tag.decompose()
+                
                text = clean_text(slice_soup.get_text()).strip()
                if text:
                    self.content_texts[current_src] = text
@@ -620,13 +885,13 @@ class HandlerDialog(QDialog):
        return None, None

    def _parse_ncx_navpoint(
-        self,
-        nav_point,
-        ordered_entries,
-        doc_order,
-        doc_order_decoded,
-        tree_structure_list,
-        find_position_func,
+            self,
+            nav_point,
+            ordered_entries,
+            doc_order,
+            doc_order_decoded,
+            tree_structure_list,
+            find_position_func,
    ):
        nav_label = nav_point.find("navLabel")
        content = nav_point.find("content")
@@ -678,19 +943,19 @@ class HandlerDialog(QDialog):
                )

        if title and (
-            current_entry_node.get("has_content", False)
-            or current_entry_node["children"]
+                current_entry_node.get("has_content", False)
+                or current_entry_node["children"]
        ):
            tree_structure_list.append(current_entry_node)

    def _parse_html_nav_li(
-        self,
-        li_element,
-        ordered_entries,
-        doc_order,
-        doc_order_decoded,
-        tree_structure_list,
-        find_position_func,
+            self,
+            li_element,
+            ordered_entries,
+            doc_order,
+            doc_order_decoded,
+            tree_structure_list,
+            find_position_func,
    ):
        link = li_element.find("a", recursive=False)
        span_text = li_element.find("span", recursive=False)
@@ -838,8 +1103,8 @@ class HandlerDialog(QDialog):

        if self.file_type == "epub":
            if (
-                hasattr(self, "processed_nav_structure")
-                and self.processed_nav_structure
+                    hasattr(self, "processed_nav_structure")
+                    and self.processed_nav_structure
            ):
                self._build_epub_tree_from_nav(
                    self.processed_nav_structure, self.treeWidget
@@ -847,6 +1112,8 @@ class HandlerDialog(QDialog):
            else:
                logging.warning("Building EPUB tree using fallback book.toc.")
                self._build_epub_tree_fallback(self.book.toc, self.treeWidget)
+        elif self.file_type == "markdown":
+            self._build_markdown_tree()
        else:
            self._build_pdf_tree()

@@ -865,7 +1132,7 @@ class HandlerDialog(QDialog):
            self._update_item_checkbox_state(item)

    def _build_epub_tree_from_nav(
-        self, nav_nodes, parent_item, seen_content_hashes=None
+            self, nav_nodes, parent_item, seen_content_hashes=None
    ):
        if seen_content_hashes is None:
            seen_content_hashes = set()
@@ -878,9 +1145,9 @@ class HandlerDialog(QDialog):
            item.setData(0, Qt.UserRole, src)

            is_empty = (
-                src
-                and (src in self.content_texts)
-                and (not self.content_texts[src].strip())
+                    src
+                    and (src in self.content_texts)
+                    and (not self.content_texts[src].strip())
            )
            is_duplicate = False
            if src and src in self.content_texts and self.content_texts[src].strip():
@@ -935,7 +1202,7 @@ class HandlerDialog(QDialog):
            item.setData(0, Qt.UserRole, href)

            has_content = (
-                href and href in self.content_texts and self.content_texts[href].strip()
+                    href and href in self.content_texts and self.content_texts[href].strip()
            )

            if has_content or children:
@@ -993,7 +1260,7 @@ class HandlerDialog(QDialog):
                        if isinstance(page, int)
                        else self.pdf_doc.resolve_link(page)[0]
                    )
-                    page_id = f"page_{page_num+1}"
+                    page_id = f"page_{page_num + 1}"
                    # attach chapters on same page under original
                    if page_num in self.bookmark_items_map:
                        orig = self.bookmark_items_map[page_num]
@@ -1028,13 +1295,13 @@ class HandlerDialog(QDialog):
                    next_page = next_page_boundaries.get(page_num, len(self.pdf_doc))
                    for sub_page_num in range(page_num + 1, next_page):
                        if (
-                            sub_page_num in page_to_bookmark
-                            or sub_page_num in added_pages
+                                sub_page_num in page_to_bookmark
+                                or sub_page_num in added_pages
                        ):
                            continue

-                        page_id = f"page_{sub_page_num+1}"
-                        page_title = f"Page {sub_page_num+1}"
+                        page_id = f"page_{sub_page_num + 1}"
+                        page_title = f"Page {sub_page_num + 1}"

                        page_text = self.content_texts.get(page_id, "").strip()
                        if page_text:
@@ -1077,8 +1344,8 @@ class HandlerDialog(QDialog):
            parent_item = (
                self.bookmark_items_map[prev_nums[-1]] if prev_nums else self.treeWidget
            )
-            page_id = f"page_{page_num+1}"
-            title = f"Page {page_num+1}"
+            page_id = f"page_{page_num + 1}"
+            title = f"Page {page_num + 1}"
            text = self.content_texts.get(page_id, "").strip()
            if text:
                first = text.split("\n", 1)[0].strip()
@@ -1095,6 +1362,49 @@ class HandlerDialog(QDialog):
            else:
                page_item.setFlags(page_item.flags() & ~Qt.ItemIsUserCheckable)

+    def _build_markdown_tree(self):
+        """Build tree structure for markdown file based on parsed TOC."""
+        if not self.markdown_text:
+            return
+
+        if not self.markdown_toc:
+            # Handle case with no headers (single content block)
+            if self.content_texts:
+                chapter_id = list(self.content_texts.keys())[0]
+                title = "Content"
+                item = QTreeWidgetItem(self.treeWidget, [title])
+                item.setData(0, Qt.UserRole, chapter_id)
+                if self.content_lengths.get(chapter_id, 0) > 0:
+                    item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
+                    is_checked = chapter_id in self.checked_chapters
+                    item.setCheckState(0, Qt.Checked if is_checked else Qt.Unchecked)
+                else:
+                    item.setFlags(item.flags() & ~Qt.ItemIsUserCheckable)
+            return
+
+        def build_from_toc(toc_list, parent_item):
+            for header in toc_list:
+                title = header['name']
+                chapter_id = header['id']
+
+                item = QTreeWidgetItem(parent_item, [title])
+                item.setData(0, Qt.UserRole, chapter_id)
+
+                has_content = self.content_lengths.get(chapter_id, 0) > 0
+                has_children = bool(header.get('children'))
+
+                if has_content or has_children:
+                    item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
+                    is_checked = chapter_id in self.checked_chapters
+                    item.setCheckState(0, Qt.Checked if is_checked else Qt.Unchecked)
+                else:
+                    item.setFlags(item.flags() & ~Qt.ItemIsUserCheckable)
+
+                if has_children:
+                    build_from_toc(header['children'], item)
+
+        build_from_toc(self.markdown_toc, self.treeWidget)
+
    def _build_pdf_pages_tree(self):
        pages_item = QTreeWidgetItem(self.treeWidget, ["Pages"])
        pages_item.setFlags(pages_item.flags() & ~Qt.ItemIsUserCheckable)
@@ -1103,8 +1413,8 @@ class HandlerDialog(QDialog):
        pages_item.setFont(0, font)

        for page_num in range(len(self.pdf_doc)):
-            page_id = f"page_{page_num+1}"
-            page_title = f"Page {page_num+1}"
+            page_id = f"page_{page_num + 1}"
+            page_title = f"Page {page_num + 1}"

            page_text = self.content_texts.get(page_id, "").strip()
            if page_text:
@@ -1166,7 +1476,7 @@ class HandlerDialog(QDialog):
        buttons.accepted.connect(self.accept)
        buttons.rejected.connect(self.reject)

-        item_type = "chapters" if self.file_type == "epub" else "pages"
+        item_type = "chapters" if self.file_type in ["epub", "markdown"] else "pages"

        self.auto_select_btn = QPushButton(f"Auto-select {item_type}", self)
        self.auto_select_btn.clicked.connect(self.auto_select_chapters)
@@ -1214,7 +1524,7 @@ class HandlerDialog(QDialog):

        checkbox_text = (
            "Save each chapter separately"
-            if self.file_type == "epub"
+            if self.file_type in ["epub", "markdown"]
            else "Save each page separately"
        )
        self.save_chapters_checkbox = QCheckBox(checkbox_text, self)
@@ -1259,15 +1569,15 @@ class HandlerDialog(QDialog):

    def _update_checkbox_states(self):
        if (
-            not hasattr(self, "save_chapters_checkbox")
-            or not self.save_chapters_checkbox
+                not hasattr(self, "save_chapters_checkbox")
+                or not self.save_chapters_checkbox
        ):
            return

        if (
-            self.file_type == "pdf"
-            and hasattr(self, "has_pdf_bookmarks")
-            and not self.has_pdf_bookmarks
+                self.file_type == "pdf"
+                and hasattr(self, "has_pdf_bookmarks")
+                and not self.has_pdf_bookmarks
        ):
            self.save_chapters_checkbox.setEnabled(False)
            self.merge_chapters_checkbox.setEnabled(False)
@@ -1275,13 +1585,13 @@ class HandlerDialog(QDialog):

        checked_count = 0

-        if self.file_type == "epub":
+        if self.file_type in ["epub", "markdown"]:
            iterator = QTreeWidgetItemIterator(self.treeWidget)
            while iterator.value():
                item = iterator.value()
                if (
-                    item.flags() & Qt.ItemIsUserCheckable
-                    and item.checkState(0) == Qt.Checked
+                        item.flags() & Qt.ItemIsUserCheckable
+                        and item.checkState(0) == Qt.Checked
                ):
                    checked_count += 1
                    if checked_count >= 2:
@@ -1295,8 +1605,8 @@ class HandlerDialog(QDialog):
            while iterator.value():
                item = iterator.value()
                if (
-                    item.flags() & Qt.ItemIsUserCheckable
-                    and item.checkState(0) == Qt.Checked
+                        item.flags() & Qt.ItemIsUserCheckable
+                        and item.checkState(0) == Qt.Checked
                ):
                    parent = item.parent()
                    if parent and parent != self.treeWidget.invisibleRootItem():
@@ -1367,6 +1677,8 @@ class HandlerDialog(QDialog):

        if self.file_type == "epub":
            self._run_epub_auto_check()
+        elif self.file_type == "markdown":
+            self._run_markdown_auto_check()
        else:
            self._run_pdf_auto_check()

@@ -1394,7 +1706,41 @@ class HandlerDialog(QDialog):
                        if child.flags() & Qt.ItemIsUserCheckable:
                            child_src = child.data(0, Qt.UserRole)
                            child_has_content = (
-                                child_src and self.content_lengths.get(child_src, 0) > 0
+                                    child_src and self.content_lengths.get(child_src, 0) > 0
+                            )
+                            child_is_parent = child.childCount() > 0
+                            if child_has_content or child_is_parent:
+                                child.setCheckState(0, Qt.Checked)
+            else:
+                item.setCheckState(0, Qt.Unchecked)
+
+            iterator += 1
+
+    def _run_markdown_auto_check(self):
+        """Auto-select markdown chapters with significant content"""
+        iterator = QTreeWidgetItemIterator(self.treeWidget)
+        while iterator.value():
+            item = iterator.value()
+            if not (item.flags() & Qt.ItemIsUserCheckable):
+                iterator += 1
+                continue
+
+            identifier = item.data(0, Qt.UserRole)
+
+            # Select chapters with content > 500 characters or parent items
+            has_significant_content = identifier and self.content_lengths.get(identifier, 0) > 500
+            is_parent = item.childCount() > 0
+
+            if has_significant_content or is_parent:
+                item.setCheckState(0, Qt.Checked)
+                # Also check children if this is a parent
+                if is_parent:
+                    for i in range(item.childCount()):
+                        child = item.child(i)
+                        if child.flags() & Qt.ItemIsUserCheckable:
+                            child_identifier = child.data(0, Qt.UserRole)
+                            child_has_content = (
+                                    child_identifier and self.content_lengths.get(child_identifier, 0) > 0
                            )
                            child_is_parent = child.childCount() > 0
                            if child_has_content or child_is_parent:
@@ -1428,8 +1774,8 @@ class HandlerDialog(QDialog):
                continue

            if (
-                not identifier.startswith("page_")
-                or self.content_lengths.get(identifier, 0) > 0
+                    not identifier.startswith("page_")
+                    or self.content_lengths.get(identifier, 0) > 0
            ):
                item.setCheckState(0, Qt.Checked)

@@ -1540,7 +1886,7 @@ class HandlerDialog(QDialog):
            html_content += f"<p style='text-align: center; font-style: italic;'>By {authors_text}</p>"

        if self.book_metadata["publisher"] or self.book_metadata.get(
-            "publication_year"
+                "publication_year"
        ):
            pub_info = []
            if self.book_metadata["publisher"]:
@@ -1626,6 +1972,42 @@ class HandlerDialog(QDialog):
                    if "cover" in item.get_name().lower():
                        metadata["cover_image"] = item.get_content()
                        break
+        elif self.file_type == "markdown":
+            # Extract metadata from markdown frontmatter or first heading
+            if self.markdown_text:
+                # Try to extract YAML frontmatter
+                frontmatter_match = re.match(r'^---\s*\n(.*?)\n---\s*\n', self.markdown_text, re.DOTALL)
+                if frontmatter_match:
+                    try:
+                        frontmatter = frontmatter_match.group(1)
+                        # Simple YAML-like parsing for common fields
+                        title_match = re.search(r'^title:\s*(.+)$', frontmatter, re.MULTILINE | re.IGNORECASE)
+                        if title_match:
+                            metadata["title"] = title_match.group(1).strip().strip('"\'')
+
+                        author_match = re.search(r'^author:\s*(.+)$', frontmatter, re.MULTILINE | re.IGNORECASE)
+                        if author_match:
+                            metadata["authors"] = [author_match.group(1).strip().strip('"\'')]
+
+                        desc_match = re.search(r'^description:\s*(.+)$', frontmatter, re.MULTILINE | re.IGNORECASE)
+                        if desc_match:
+                            metadata["description"] = desc_match.group(1).strip().strip('"\'')
+
+                        date_match = re.search(r'^date:\s*(.+)$', frontmatter, re.MULTILINE | re.IGNORECASE)
+                        if date_match:
+                            date_str = date_match.group(1).strip().strip('"\'')
+                            year_match = re.search(r'\b(19|20)\d{2}\b', date_str)
+                            if year_match:
+                                metadata["publication_year"] = year_match.group(0)
+                    except Exception as e:
+                        logging.warning(f"Error parsing markdown frontmatter: {e}")
+
+                # Fallback: use first H1 header as title if no frontmatter title
+                if not metadata["title"] and self.markdown_toc:
+                    # Find the first level 1 header
+                    first_h1 = next((h for h in self.markdown_toc if h['level'] == 1), None)
+                    if first_h1:
+                        metadata["title"] = first_h1['name']
        else:
            pdf_info = self.pdf_doc.metadata
            if pdf_info:
@@ -1668,8 +2050,21 @@ class HandlerDialog(QDialog):
        return metadata

    def get_selected_text(self):
+        # If a background loader thread is running, wait for it to finish to
+        # preserve compatibility with callers that expect content to be ready
+        # when they create a HandlerDialog and immediately request selected text.
+        try:
+            if hasattr(self, '_loader_thread') and getattr(self, '_loader_thread') is not None:
+                # Wait for thread to finish (blocks until done)
+                if self._loader_thread.isRunning():
+                    self._loader_thread.wait()
+        except Exception:
+            pass
+
        if self.file_type == "epub":
            return self._get_epub_selected_text()
+        elif self.file_type == "markdown":
+            return self._get_markdown_selected_text()
        else:
            return self._get_pdf_selected_text()

@@ -1687,7 +2082,7 @@ class HandlerDialog(QDialog):
        authors_text = ", ".join(authors)
        album_artist = authors_text or "Unknown"
        year = (
-            metadata.get("publication_year") or current_year
+                metadata.get("publication_year") or current_year
        )  # Use publication year if available

        # Count chapters/pages
@@ -1709,6 +2104,43 @@ class HandlerDialog(QDialog):

        return "\n".join(metadata_tags)

+    def _get_markdown_selected_text(self):
+        """Get selected text from markdown chapters"""
+        all_checked_identifiers = set()
+        chapter_texts = []
+
+        # Add metadata tags at the beginning
+        metadata_tags = self._format_metadata_tags()
+
+        item_order_counter = 0
+        ordered_checked_items = []
+
+        iterator = QTreeWidgetItemIterator(self.treeWidget)
+        while iterator.value():
+            item = iterator.value()
+            item_order_counter += 1
+            if item.checkState(0) == Qt.Checked:
+                identifier = item.data(0, Qt.UserRole)
+
+                if identifier and identifier != "info:bookinfo":
+                    all_checked_identifiers.add(identifier)
+                    ordered_checked_items.append((item_order_counter, item, identifier))
+            iterator += 1
+
+        ordered_checked_items.sort(key=lambda x: x[0])
+
+        for order, item, identifier in ordered_checked_items:
+            text = self.content_texts.get(identifier)
+            if text and text.strip():
+                title = item.text(0)
+                # Remove leading dashes from title
+                title = re.sub(r"^\s*[-–—]\s*", "", title).strip()
+                marker = f"<<CHAPTER_MARKER:{title}>>"
+                chapter_texts.append(marker + "\n" + text)
+
+        full_text = metadata_tags + "\n\n" + "\n\n".join(chapter_texts)
+        return full_text, all_checked_identifiers
+
    def _get_epub_selected_text(self):
        all_checked_identifiers = set()
        chapter_texts = []
@@ -1753,7 +2185,7 @@ class HandlerDialog(QDialog):
        metadata_tags = self._format_metadata_tags()

        pdf_has_no_bookmarks = (
-            hasattr(self, "has_pdf_bookmarks") and not self.has_pdf_bookmarks
+                hasattr(self, "has_pdf_bookmarks") and not self.has_pdf_bookmarks
        )

        iterator = QTreeWidgetItemIterator(self.treeWidget)
@@ -1793,9 +2225,9 @@ class HandlerDialog(QDialog):
                    child = item.child(i)
                    child_id = child.data(0, Qt.UserRole)
                    if (
-                        child.checkState(0) == Qt.Checked
-                        and child_id
-                        and child_id not in included_text_ids
+                            child.checkState(0) == Qt.Checked
+                            and child_id
+                            and child_id not in included_text_ids
                    ):
                        checked_children.append((child, child_id))
                if parent_checked and parent_id and parent_id not in included_text_ids:
@@ -1824,9 +2256,9 @@ class HandlerDialog(QDialog):
            elif item.flags() & Qt.ItemIsUserCheckable:
                identifier = item.data(0, Qt.UserRole)
                if (
-                    identifier
-                    and identifier not in included_text_ids
-                    and item.checkState(0) == Qt.Checked
+                        identifier
+                        and identifier not in included_text_ids
+                        and item.checkState(0) == Qt.Checked
                ):
                    text = self.content_texts.get(identifier, "")
                    if text:
@@ -1896,9 +2328,9 @@ class HandlerDialog(QDialog):
            return

        if (
-            not item
-            or item.childCount() == 0
-            or not (item.flags() & Qt.ItemIsUserCheckable)
+                not item
+                or item.childCount() == 0
+                or not (item.flags() & Qt.ItemIsUserCheckable)
        ):
            return

@@ -1,14 +1,12 @@
 import os
 import re
 import time
-import chardet
-import charset_normalizer
 import hashlib  # For generating unique cache filenames
 from platformdirs import user_desktop_dir
 from PyQt5.QtCore import QThread, pyqtSignal, Qt, QTimer
 from PyQt5.QtWidgets import QCheckBox, QVBoxLayout, QDialog, QLabel, QDialogButtonBox
 import soundfile as sf
-from abogen.utils import clean_text, create_process, get_user_cache_path
+from abogen.utils import clean_text, create_process, get_user_cache_path, detect_encoding
 from abogen.constants import (
    LANGUAGE_DESCRIPTIONS,
    SAMPLE_VOICE_TEXTS,
@@ -30,20 +28,64 @@ def get_sample_voice_text(lang_code):
    return SAMPLE_VOICE_TEXTS.get(lang_code, SAMPLE_VOICE_TEXTS["a"])


-def detect_encoding(file_path):
-    with open(file_path, "rb") as f:
-        raw_data = f.read()
-    detected_encoding = None
-    for detectors in (charset_normalizer, chardet):
-        try:
-            result = detectors.detect(raw_data)["encoding"]
-        except Exception:
-            continue
-        if result is not None:
-            detected_encoding = result
-            break
-    encoding = detected_encoding if detected_encoding else "utf-8"
-    return encoding.lower()
+def sanitize_name_for_os(name, is_folder=True):
+    """
+    Sanitize a filename or folder name based on the operating system.
+    
+    Args:
+        name: The name to sanitize
+        is_folder: Whether this is a folder name (default: True)
+    
+    Returns:
+        Sanitized name safe for the current OS
+    """
+    if not name:
+        return "audiobook"
+    
+    system = platform.system()
+    
+    if system == "Windows":
+        # Windows illegal characters: < > : " / \ | ? *
+        # Also can't end with space or dot
+        sanitized = re.sub(r'[<>:"/\\|?*]', '_', name)
+        # Remove control characters (0-31)
+        sanitized = re.sub(r'[\x00-\x1f]', '_', sanitized)
+        # Remove trailing spaces and dots
+        sanitized = sanitized.rstrip('. ')
+        # Windows reserved names (CON, PRN, AUX, NUL, COM1-9, LPT1-9)
+        reserved = ['CON', 'PRN', 'AUX', 'NUL'] + \
+                   [f'COM{i}' for i in range(1, 10)] + \
+                   [f'LPT{i}' for i in range(1, 10)]
+        if sanitized.upper() in reserved or sanitized.upper().split('.')[0] in reserved:
+            sanitized = f"_{sanitized}"
+    elif system == "Darwin":  # macOS
+        # macOS illegal characters: : (colon is converted to / by the system)
+        # Also can't start with dot (hidden file) for folders typically
+        sanitized = re.sub(r'[:]', '_', name)
+        # Remove control characters
+        sanitized = re.sub(r'[\x00-\x1f]', '_', sanitized)
+        # Avoid leading dot for folders (creates hidden folders)
+        if is_folder and sanitized.startswith('.'):
+            sanitized = '_' + sanitized[1:]
+    else:  # Linux and others
+        # Linux illegal characters: / and null character
+        # Though / is illegal, most other chars are technically allowed
+        sanitized = re.sub(r'[/\x00]', '_', name)
+        # Remove other control characters for safety
+        sanitized = re.sub(r'[\x01-\x1f]', '_', sanitized)
+        # Avoid leading dot for folders (creates hidden folders)
+        if is_folder and sanitized.startswith('.'):
+            sanitized = '_' + sanitized[1:]
+    
+    # Ensure the name is not empty after sanitization
+    if not sanitized or sanitized.strip() == '':
+        sanitized = "audiobook"
+    
+    # Limit length to 255 characters (common limit across filesystems)
+    if len(sanitized) > 255:
+        sanitized = sanitized[:255].rstrip('. ')
+    
+    return sanitized


 class ChapterOptionsDialog(QDialog):
@@ -166,6 +208,7 @@ class ConversionThread(QThread):
        total_char_count,
        use_gpu=True,
        from_queue=False,
+        save_base_path=None,
    ):  # Add use_gpu parameter
        super().__init__()
        self._chapter_options_event = threading.Event()
@@ -187,6 +230,7 @@ class ConversionThread(QThread):
        self.total_char_count = total_char_count  # Use passed total character count
        self.processed_char_count = 0  # Initialize processed character count
        self.display_path = None  # Add variable for display path
+        self.save_base_path = save_base_path  # Store the save base path
        self.is_direct_text = (
            False  # Flag to indicate if input is from textbox rather than file
        )
@@ -194,6 +238,7 @@ class ConversionThread(QThread):
        self.waiting_for_user_input = False
        self.use_gpu = use_gpu  # Store the GPU setting
        self.max_subtitle_words = 50  # Default value, will be overridden from GUI
+        self.silence_duration = 2.0  # Default value, will be overridden from GUI

    def _stream_audio_in_chunks(
        self, segments, process_func, progress_prefix="Processing"
@@ -255,15 +300,27 @@ class ConversionThread(QThread):
            # Show configuration
            self.log_updated.emit("Configuration:")

+            # Determine input file and processing file
+            if getattr(self, "from_queue", False):
+                input_file = self.save_base_path or self.file_name
+                processing_file = self.file_name
+            else:
+                input_file = self.display_path if self.display_path else self.file_name
+                processing_file = self.file_name
+
+            # Normalize paths for consistent display (fixes Windows path separator issues)
+            input_file = os.path.normpath(input_file) if input_file else input_file
+            processing_file = os.path.normpath(processing_file) if processing_file else processing_file
+
+            self.log_updated.emit(f"- Input File: {input_file}")
+            if input_file != processing_file:
+                self.log_updated.emit(f"- Processing File: {processing_file}")
+
            # Use file_name for logs if from_queue, otherwise use display_path if available
            if getattr(self, "from_queue", False):
-                display_file = self.file_name
+                base_path = self.save_base_path or self.file_name  # Use save_base_path if available
            else:
-                display_file = (
-                    self.display_path if self.display_path else self.file_name
-                )
-
-            self.log_updated.emit(f"- Input File: {display_file}")
+                base_path = self.display_path if self.display_path else self.file_name

            # Use file size string passed from GUI
            if hasattr(self, "file_size_str"):
@@ -304,6 +361,12 @@ class ConversionThread(QThread):
                        f"- Separate chapters format: {separate_format}"
                    )

+            # If merge_at_end is True, display the silence duration
+            if getattr(self, "merge_chapters_at_end", True):
+                self.log_updated.emit(
+                    f"- Silence between chapters: {self.silence_duration} seconds"
+                )
+
            if self.save_option == "Choose output folder":
                self.log_updated.emit(
                    f"- Output folder: {self.output_folder or os.getcwd()}"
@@ -413,11 +476,14 @@ class ConversionThread(QThread):

            # Use file_name for logs if from_queue, otherwise use display_path if available
            if getattr(self, "from_queue", False):
-                base_path = self.file_name
+                base_path = self.save_base_path or self.file_name  # Use save_base_path if available
            else:
                base_path = self.display_path if self.display_path else self.file_name

            base_name = os.path.splitext(os.path.basename(base_path))[0]
+            # Sanitize base_name for folder/file creation based on OS
+            sanitized_base_name = sanitize_name_for_os(base_name, is_folder=True)
+            
            if self.save_option == "Save to Desktop":
                parent_dir = user_desktop_dir()
            elif self.save_option == "Save next to input file":
@@ -438,11 +504,11 @@ class ConversionThread(QThread):
            while True:
                suffix = f"_{counter}" if counter > 1 else ""
                chapters_out_dir_candidate = os.path.join(
-                    parent_dir, f"{base_name}{suffix}_chapters"
+                    parent_dir, f"{sanitized_base_name}{suffix}_chapters"
                )
                # Only check for files with allowed extensions (extension without dot, case-insensitive)
                clash = any(
-                    os.path.splitext(fname)[0] == f"{base_name}{suffix}"
+                    os.path.splitext(fname)[0] == f"{sanitized_base_name}{suffix}"
                    and os.path.splitext(fname)[1][1:].lower() in allowed_exts
                    for fname in os.listdir(parent_dir)
                )
@@ -462,7 +528,7 @@ class ConversionThread(QThread):
            # Prepare merged output file for incremental writing ONLY if merge_chapters_at_end is True
            if merge_chapters_at_end:
                out_dir = parent_dir
-                base_filepath_no_ext = os.path.join(out_dir, f"{base_name}{suffix}")
+                base_filepath_no_ext = os.path.join(out_dir, f"{sanitized_base_name}{suffix}")
                merged_out_path = f"{base_filepath_no_ext}.{self.output_format}"
                subtitle_entries = []
                current_time = 0.0
@@ -555,6 +621,13 @@ class ConversionThread(QThread):
                    merged_subtitle_path = (
                        os.path.splitext(merged_out_path)[0] + f".{file_extension}"
                    )
+                    # Default subtitle layout flags/strings so they exist regardless
+                    # of whether ASS-specific handling runs. This prevents runtime
+                    # errors when non-ASS formats (like SRT) are selected.
+                    is_centered = False
+                    is_narrow = False
+                    merged_subtitle_margin = ""
+                    merged_subtitle_alignment_tag = ""
                    if "ass" in subtitle_format:
                        merged_subtitle_file = open(
                            merged_subtitle_path,
@@ -618,6 +691,10 @@ class ConversionThread(QThread):
            # Instead of processing the whole text, process by chapter
            for chapter_idx, (chapter_name, chapter_text) in enumerate(chapters, 1):
                chapter_out_path = None
+                chapter_out_file = None
+                chapter_ffmpeg_proc = None
+                chapter_subtitle_file = None
+                chapter_subtitle_path = None
                if total_chapters > 1:
                    self.log_updated.emit(
                        (
@@ -641,8 +718,13 @@ class ConversionThread(QThread):
                    loaded_voice = self.voice
                # Prepare per-chapter output file if needed
                if save_chapters_separately and total_chapters > 1:
+                    # First pass: keep alphanumeric, spaces, hyphens, and underscores
                    sanitized = re.sub(r"[^\w\s\-]", "", chapter_name)
+                    # Replace multiple spaces/hyphens with single underscore
                    sanitized = re.sub(r"[\s\-]+", "_", sanitized).strip("_")
+                    # Apply OS-specific sanitization
+                    sanitized = sanitize_name_for_os(sanitized, is_folder=False)
+                    # Limit length (leaving room for the chapter number prefix)
                    MAX_LEN = 80
                    if len(sanitized) > MAX_LEN:
                        pos = sanitized[:MAX_LEN].rfind("_")
@@ -702,13 +784,20 @@ class ConversionThread(QThread):
                        chapter_subtitle_path = os.path.join(
                            chapters_out_dir, f"{chapter_filename}.{file_extension}"
                        )
+                        # Ensure these variables exist even when not using ASS so
+                        # later code can safely reference them.
+                        is_centered = False
+                        is_narrow = False
+                        chapter_subtitle_margin = ""
+                        chapter_subtitle_alignment_tag = ""
+                        # Open the chapter subtitle file for writing for both SRT and ASS
+                        chapter_subtitle_file = open(
+                            chapter_subtitle_path,
+                            "w",
+                            encoding="utf-8",
+                            errors="replace",
+                        )
                        if "ass" in subtitle_format:
-                            chapter_subtitle_file = open(
-                                chapter_subtitle_path,
-                                "w",
-                                encoding="utf-8",
-                                errors="replace",
-                            )
                            # Minimal ASS header
                            chapter_subtitle_file.write("[Script Info]\n")
                            chapter_subtitle_file.write("Title: Generated by Abogen\n")
@@ -736,22 +825,11 @@ class ConversionThread(QThread):
                            chapter_subtitle_alignment_tag = (
                                f"{{\\an5}}" if is_centered else ""
                            )
-                        else:
-                            chapter_subtitle_file = open(
-                                chapter_subtitle_path,
-                                "w",
-                                encoding="utf-8",
-                                errors="replace",
-                            )
                    else:
-                        chapter_subtitle_path = None
                        chapter_subtitle_file = None
                else:
-                    chapter_out_file = None
-                    chapter_out_path = None
-                    chapter_ffmpeg_proc = None
-                    chapter_subtitle_file = None
                    chapter_subtitle_path = None
+                    chapter_subtitle_file = None
                for result in tts(
                    chapter_text,
                    voice=loaded_voice,
@@ -917,6 +995,22 @@ class ConversionThread(QThread):
                    # Update progress more frequently (after each result)
                    self.progress_updated.emit(percent, etr_str)

+                # Add silence between chapters for merged output (except after the last chapter)
+                if merge_chapters_at_end and chapter_idx < total_chapters:
+                    silence_samples = int(self.silence_duration * 24000)  # Silence duration at 24,000 Hz
+                    silence_audio = self.np.zeros(silence_samples, dtype="float32")
+                    silence_bytes = silence_audio.tobytes()
+                    
+                    if merged_out_file:
+                        merged_out_file.write(silence_audio)
+                    elif ffmpeg_proc:
+                        ffmpeg_proc.stdin.write(silence_bytes)
+                    
+                    # Update timing for the silence
+                    current_time += self.silence_duration
+                    if chapter_out_file or chapter_ffmpeg_proc:
+                        chapter_current_time += self.silence_duration
+
                # Set chapter end time after processing
                if merge_chapters_at_end:
                    chapter_time["end"] = current_time
@@ -1023,11 +1117,12 @@ class ConversionThread(QThread):
                        merged_out_path,
                    )
            else:
-                # If not merging, just finish after chapters
+                # If not merging, report the folder that holds the chapter files
                self.progress_updated.emit(100, "00:00:00")
+                chapters_dir = os.path.abspath(chapters_out_dir or parent_dir)
                self.conversion_finished.emit(
-                    ("\nAll chapters saved.", "green"),
-                    None,
+                    (f"\nAll chapters saved to: {chapters_dir}", "green"),
+                    chapters_dir,
                )
        except Exception as e:
            # Cleanup ffmpeg subprocesses on error
@@ -1155,7 +1250,7 @@ class ConversionThread(QThread):
        m = int((t % 3600) // 60)
        s = int(t % 60)
        ms = int((t - int(t)) * 1000)
-        return f"{h:02}:{m:02}:{s:02},{ms:03}"
+        return f"{h:02d}:{m:02d}:{s:02d},{ms:03d}"

    def _ass_time(self, t):
        """Helper function to format time for ASS files"""
@@ -1163,7 +1258,7 @@ class ConversionThread(QThread):
        m = int((t % 3600) // 60)
        s = int(t % 60)
        cs = int((t - int(t)) * 100)  # Centiseconds for ASS format
-        return f"{h}:{m:02}:{s:02}.{cs:02}"
+        return f"{h:01d}:{m:02d}:{s:02d}.{cs:02d}"

    def _process_subtitle_tokens(
        self,
@@ -1176,13 +1271,16 @@ class ConversionThread(QThread):
        if not tokens_with_timestamps:
            return
        
+        processed_tokens = tokens_with_timestamps  # Use tokens directly
+
+        # Use processed_tokens instead of tokens_with_timestamps for the rest of the method
        if self.subtitle_mode == "Sentence + Highlighting":
            # Sentence-based processing with karaoke highlighting
            separator = r"[.!?]"
            current_sentence = []
            word_count = 0

-            for token in tokens_with_timestamps:
+            for token in processed_tokens:  # Updated to use processed_tokens
                current_sentence.append(token)
                word_count += 1

@@ -1230,13 +1328,18 @@ class ConversionThread(QThread):
                if end is None or end <= start or end <= 0:
                    subtitle_entries[-1] = (start, fallback_end_time, text)

-        elif self.subtitle_mode == "Sentence" or self.subtitle_mode == "Sentence + Comma":
+        elif self.subtitle_mode in ["Sentence", "Sentence + Comma", "Line"]:
            # Define separator pattern based on mode
-            separator = r"[.!?]" if self.subtitle_mode == "Sentence" else r"[.!?,]"
+            if self.subtitle_mode == "Line":
+                separator = r"\n"
+            elif self.subtitle_mode == "Sentence":
+                separator = r"[.!?]"
+            else:  # Sentence + Comma
+                separator = r"[.!?,]"
            current_sentence = []
            word_count = 0

-            for token in tokens_with_timestamps:
+            for token in processed_tokens:  # Updated to use processed_tokens
                current_sentence.append(token)
                word_count += 1

@@ -1286,25 +1389,7 @@ class ConversionThread(QThread):
            except (ValueError, IndexError):
                word_count = 1

-            # Combine punctuation with preceding words
-            processed_tokens = []
-            i = 0
-            while i < len(tokens_with_timestamps):
-                token = tokens_with_timestamps[i].copy()
-
-                # Look ahead for punctuation
-                while i + 1 < len(tokens_with_timestamps) and re.match(
-                    r"^[^\w\s]+$", tokens_with_timestamps[i + 1]["text"]
-                ):
-                    token["text"] += tokens_with_timestamps[i + 1]["text"]
-                    token["end"] = tokens_with_timestamps[i + 1]["end"]
-                    token["whitespace"] = tokens_with_timestamps[i + 1]["whitespace"]
-                    i += 1
-
-                processed_tokens.append(token)
-                i += 1
-
-            # Group words into subtitle entries
+            # Group words into subtitle entries (processed_tokens already has punctuation combined)
            for i in range(0, len(processed_tokens), word_count):
                group = processed_tokens[i : i + word_count]
                if group:
@@ -1321,6 +1406,7 @@ class ConversionThread(QThread):
                if end is None or end <= start or end <= 0:
                    subtitle_entries[-1] = (start, fallback_end_time, text)

+
    def cancel(self):
        self.cancel_requested = True
        self.should_cancel = True
@@ -85,7 +85,6 @@ from abogen.voice_profiles import load_profiles
 # Import ctypes for Windows-specific taskbar icon
 if platform.system() == "Windows":
    import ctypes
-    import winreg


 class DarkTitleBarEventFilter(QObject):
@@ -158,7 +157,7 @@ class InputBox(QLabel):
        self.setAlignment(Qt.AlignCenter)
        self.setAcceptDrops(True)
        self.setText(
-            "Drag and drop your file here or click to browse.\n(.txt, .epub, .pdf)"
+            "Drag and drop your file here or click to browse.\n(.txt, .epub, .pdf, .md)"
        )
        self.setStyleSheet(
            f"QLabel {{ {self.STYLE_DEFAULT} }} QLabel:hover {{ {self.STYLE_DEFAULT_HOVER} }}"
@@ -231,6 +230,8 @@ class InputBox(QLabel):
        size_str = self._human_readable_size(os.path.getsize(file_path))
        name = os.path.basename(file_path)
        char_count = 0
+        window = self.window()
+        cache = getattr(window, "_char_count_cache", None)

        def parse_size(size_str):
            # Use regex to extract the numeric part
@@ -250,38 +251,49 @@ class InputBox(QLabel):
            except Exception:
                return str(n)

-        if (
-            file_path.lower().endswith(".epub") or file_path.lower().endswith(".pdf")
-        ) and hasattr(self.window(), "selected_chapters"):
-            # EPUB or PDF: sum character counts for selected chapters
-            try:
+        doc_extensions = (".epub", ".pdf", ".md", ".markdown")
+        char_source_path = file_path
+        cached_char_count = None

-                book_path = file_path
-                dialog = HandlerDialog(
-                    book_path,
-                    checked_chapters=self.window().selected_chapters,
-                    parent=self.window(),
-                )
-                chapters_text, all_checked_hrefs = dialog.get_selected_text()
-                # Clean text before counting characters
-                cleaned_text = clean_text(chapters_text)
-                char_count = calculate_text_length(cleaned_text)
-            except Exception:
-                char_count = "N/A"
-        else:
+        if file_path.lower().endswith(doc_extensions):
+            selected_file_path = getattr(window, "selected_file", None)
+            if selected_file_path and os.path.exists(selected_file_path):
+                char_source_path = selected_file_path
+            else:
+                char_source_path = None
+
+        if cache is not None:
+            cached_char_count = cache.get(file_path)
+            if (
+                    cached_char_count is None
+                    and char_source_path
+                    and char_source_path != file_path
+            ):
+                cached_char_count = cache.get(char_source_path)
+
+        if cached_char_count is not None:
+            char_count = cached_char_count
+        elif char_source_path:
            try:
-                with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
+                with open(char_source_path, "r", encoding="utf-8", errors="ignore") as f:
                    text = f.read()
-                    # Clean text before counting characters
                    cleaned_text = clean_text(text)
                    char_count = calculate_text_length(cleaned_text)
            except Exception:
                char_count = "N/A"
+        else:
+            char_count = "N/A"
+
+        if cache is not None and isinstance(char_count, int):
+            cache[file_path] = char_count
+            if char_source_path and char_source_path != file_path:
+                cache[char_source_path] = char_count
+
        # Store numeric char_count on window
        try:
-            self.window().char_count = int(char_count)
+            window.char_count = int(char_count)
        except Exception:
-            self.window().char_count = 0
+            window.char_count = 0
        # embed icon at native size with word-wrap for the filename
        self.setText(
            f'<img src="data:image/png;base64,{img_data}"><br><span style="display: inline-block; max-width: 100%; word-break: break-all;"><b>{name}</b></span><br>Size: {size_str}<br>Characters: {format_num(char_count)}'
@@ -292,13 +304,13 @@ class InputBox(QLabel):
            f"QLabel {{ {self.STYLE_ACTIVE} }} QLabel:hover {{ {self.STYLE_ACTIVE_HOVER} }}"
        )
        self.clear_btn.show()
-        is_document = self.window().selected_file_type in ["epub", "pdf"]
+        is_document = window.selected_file_type in ["epub", "pdf", "md", "markdown"]
        self.chapters_btn.setVisible(is_document)
        if is_document:
-            chapter_count = len(self.window().selected_chapters)
-            file_type = self.window().selected_file_type
+            chapter_count = len(window.selected_chapters)
+            file_type = window.selected_file_type
            # Adjust button text based on file type
-            if file_type == "epub":
+            if file_type == "epub" or file_type == "md" or file_type == "markdown":
                self.chapters_btn.setText(f"Chapters ({chapter_count})")
            else:  # PDF - always use Pages
                self.chapters_btn.setText(f"Pages ({chapter_count})")
@@ -311,8 +323,8 @@ class InputBox(QLabel):

        # For epub/pdf files, show edit if we have a selected_file (temp txt)
        if (
-            self.window().selected_file_type in ["epub", "pdf"]
-            and self.window().selected_file
+                window.selected_file_type in ["epub", "pdf", "md", "markdown", "md", "markdown"]
+                and window.selected_file
        ):
            should_show_edit = True

@@ -320,13 +332,13 @@ class InputBox(QLabel):
        self.go_to_folder_btn.show()
        # Enable add to queue button only when file is accepted (input box is green)
        self.resizeEvent(None)
-        if hasattr(self.window(), "btn_add_to_queue"):
-            self.window().btn_add_to_queue.setEnabled(True)
+        if hasattr(window, "btn_add_to_queue"):
+            window.btn_add_to_queue.setEnabled(True)

        self.chapters_btn.adjustSize()
        # Reset the input_box_cleared_by_queue flag after setting file info
-        if hasattr(self.window(), "input_box_cleared_by_queue"):
-            self.window().input_box_cleared_by_queue = False
+        if hasattr(window, "input_box_cleared_by_queue"):
+            window.input_box_cleared_by_queue = False

    def set_error(self, message):
        self.setText(message)
@@ -345,7 +357,7 @@ class InputBox(QLabel):
            None  # Reset the displayed file path when clearing input
        )
        self.setText(
-            "Drag and drop your file here or click to browse.\n(.txt, .epub, .pdf)"
+            "Drag and drop your file here or click to browse.\n(.txt, .epub, .pdf, .md)"
        )
        self.setStyleSheet(
            f"QLabel {{ {self.STYLE_DEFAULT} }} QLabel:hover {{ {self.STYLE_DEFAULT_HOVER} }}"
@@ -381,9 +393,10 @@ class InputBox(QLabel):
            if urls:
                ext = urls[0].toLocalFile().lower()
                if (
-                    ext.endswith(".txt")
-                    or ext.endswith(".epub")
-                    or ext.endswith(".pdf")
+                        ext.endswith(".txt")
+                        or ext.endswith(".epub")
+                        or ext.endswith(".pdf")
+                        or ext.endswith((".md", ".markdown"))
                ):
                    event.acceptProposedAction()
                    # Set hover style based on current state
@@ -433,27 +446,33 @@ class InputBox(QLabel):
                )
                self.set_file_info(file_path)
                event.acceptProposedAction()
-            elif file_path.lower().endswith(".epub") or file_path.lower().endswith(
-                ".pdf"
-            ):
+            elif (file_path.lower().endswith(".epub")
+                  or file_path.lower().endswith(".pdf")
+                  or file_path.lower().endswith((".md", ".markdown"))):
+                # Determine file type
+                if file_path.lower().endswith(".epub"):
+                    file_type = "epub"
+                elif file_path.lower().endswith(".pdf"):
+                    file_type = "pdf"
+                else:
+                    file_type = "markdown"
+
                # Just store the file path but don't set the file info yet
-                win.selected_file_type = (
-                    "epub" if file_path.lower().endswith(".epub") else "pdf"
-                )
+                win.selected_file_type = file_type
                win.selected_book_path = file_path
                win.open_book_file(
                    file_path  # This will handle the dialog and setting file info
                )
                event.acceptProposedAction()
            else:
-                self.set_error("Please drop a .txt, .epub, or .pdf file.")
+                self.set_error("Please drop a .txt, .epub, .pdf, or .md file.")
                event.ignore()
        else:
            event.ignore()

    def on_chapters_clicked(self):
        win = self.window()
-        if win.selected_file_type in ["epub", "pdf"] and win.selected_book_path:
+        if win.selected_file_type in ["epub", "pdf", "md", "markdown"] and win.selected_book_path:
            # Call open_book_file which shows the dialog and updates selected_chapters
            if win.open_book_file(win.selected_book_path):
                # Refresh the info label and button text after dialog closes
@@ -465,7 +484,7 @@ class InputBox(QLabel):
    def on_edit_clicked(self):
        win = self.window()
        # For PDFs and EPUBs, use the temporary text file
-        if win.selected_file_type in ["epub", "pdf"] and win.selected_file:
+        if win.selected_file_type in ["epub", "pdf", "md", "markdown"] and win.selected_file:
            # Use the temporary .txt file that was generated
            win.open_textbox_dialog(win.selected_file)
        else:
@@ -477,15 +496,63 @@ class InputBox(QLabel):
        # win.selected_file holds the path to the text that is converted.
        file_to_check = win.selected_file

+        # If this is a converted document (epub/pdf/markdown) that was written to the
+        # user's cache directory, show a menu letting the user jump to either the
+        # processed (cached .txt) file or the original input file (epub/pdf/md).
+        try:
+            cache_dir = get_user_cache_path()
+        except Exception:
+            cache_dir = None
+
+        is_cached_doc = False
        if (
-            file_to_check
-            and os.path.exists(file_to_check)
-            and os.path.isfile(file_to_check)
+                file_to_check
+                and os.path.exists(file_to_check)
+                and os.path.isfile(file_to_check)
+                and cache_dir
        ):
-            folder_path = os.path.dirname(file_to_check)
-            QDesktopServices.openUrl(QUrl.fromLocalFile(folder_path))
+            # Consider it cached when the file is under the cache directory and is a .txt
+            if file_to_check.endswith('.txt') and os.path.commonpath([os.path.abspath(file_to_check), os.path.abspath(cache_dir)]) == os.path.abspath(cache_dir):
+                # Only treat as document-cache when original type was a document
+                if getattr(win, 'selected_file_type', None) in ['epub', 'pdf', 'md', 'markdown']:
+                    is_cached_doc = True
+
+        if is_cached_doc:
+            menu = QMenu(self)
+            act_processed = QAction("Go to processed file", self)
+
+            def open_processed():
+                folder_path = os.path.dirname(file_to_check)
+                QDesktopServices.openUrl(QUrl.fromLocalFile(folder_path))
+
+            act_processed.triggered.connect(open_processed)
+            menu.addAction(act_processed)
+
+            act_input = QAction("Go to input file", self)
+            # Prefer displayed_file_path (original input path) then selected_book_path
+            input_path = getattr(win, 'displayed_file_path', None) or getattr(win, 'selected_book_path', None)
+            if input_path and os.path.exists(input_path):
+                def open_input():
+                    folder_path = os.path.dirname(input_path)
+                    QDesktopServices.openUrl(QUrl.fromLocalFile(folder_path))
+
+                act_input.triggered.connect(open_input)
+            else:
+                act_input.setEnabled(False)
+
+            menu.addAction(act_input)
+            # Show the menu anchored to the button
+            menu.exec_(self.go_to_folder_btn.mapToGlobal(QPoint(0, self.go_to_folder_btn.height())))
        else:
-            QMessageBox.warning(win, "Error", "Converted file not found.")
+            if (
+                    file_to_check
+                    and os.path.exists(file_to_check)
+                    and os.path.isfile(file_to_check)
+            ):
+                folder_path = os.path.dirname(file_to_check)
+                QDesktopServices.openUrl(QUrl.fromLocalFile(folder_path))
+            else:
+                QMessageBox.warning(win, "Error", "Converted file not found.")


 class TextboxDialog(QDialog):
@@ -599,10 +666,10 @@ class TextboxDialog(QDialog):
            # This gives a better filename instead of the cache file path
            main_window = self.parent()
            if (
-                hasattr(main_window, "displayed_file_path")
-                and main_window.displayed_file_path
+                    hasattr(main_window, "displayed_file_path")
+                    and main_window.displayed_file_path
            ):
-                if main_window.selected_file_type in ["epub", "pdf"]:
+                if main_window.selected_file_type in ["epub", "pdf", "md", "markdown"]:
                    # Use the base name of the displayed file but change extension to .txt
                    base_name = os.path.splitext(main_window.displayed_file_path)[0]
                    initial_path = base_name + ".txt"
@@ -664,6 +731,8 @@ class abogen(QWidget):
        self.selected_chapters = set()
        self.last_opened_book_path = None  # Track the last opened book path
        self.last_output_path = None
+        self.char_count = 0
+        self._char_count_cache = {}
        # Only one of selected_profile_name or selected_voice should be set
        self.selected_profile_name = self.config.get("selected_profile_name")
        self.selected_voice = None
@@ -680,6 +749,9 @@ class abogen(QWidget):
        self.max_subtitle_words = self.config.get(
            "max_subtitle_words", 50
        )  # Default max words per subtitle
+        self.silence_duration = self.config.get(
+            "silence_duration", 2.0
+        )  # Default silence duration
        self.selected_format = self.config.get("selected_format", "wav")
        self.separate_chapters_format = self.config.get(
            "separate_chapters_format", "wav"
@@ -893,6 +965,7 @@ class abogen(QWidget):
        self.subtitle_combo.setToolTip(
            "Choose how subtitles will be generated:\n"
            "Disabled: No subtitles will be generated.\n"
+            "Line: Subtitles will be generated for each line.\n"
            "Sentence: Subtitles will be generated for each sentence.\n"
            "Sentence + Comma: Subtitles will be generated for each sentence and comma.\n"
            "Sentence + Highlighting: Subtitles with word-by-word karaoke highlighting.\n"
@@ -903,7 +976,7 @@ class abogen(QWidget):
                for lang in SUPPORTED_LANGUAGES_FOR_SUBTITLE_GENERATION
            )
        )
-        subtitle_options = ["Disabled", "Sentence", "Sentence + Comma", "Sentence + Highlighting"] + [
+        subtitle_options = ["Disabled", "Line", "Sentence", "Sentence + Comma", "Sentence + Highlighting"] + [
            f"{i} word" if i == 1 else f"{i} words" for i in range(1, 11)
        ]
        self.subtitle_combo.addItems(subtitle_options)
@@ -1155,16 +1228,21 @@ class abogen(QWidget):
            return
        try:
            file_path, _ = QFileDialog.getOpenFileName(
-                self, "Select File", "", "Supported Files (*.txt *.epub *.pdf)"
+                self, "Select File", "", "Supported Files (*.txt *.epub *.pdf *.md)"
            )
            if not file_path:
                return
-            if file_path.lower().endswith(".epub") or file_path.lower().endswith(
-                ".pdf"
-            ):
-                self.selected_file_type = (
-                    "epub" if file_path.lower().endswith(".epub") else "pdf"
-                )
+            if (file_path.lower().endswith(".epub")
+                    or file_path.lower().endswith(".pdf")
+                    or file_path.lower().endswith((".md", ".markdown"))):
+                # Determine file type
+                if file_path.lower().endswith(".epub"):
+                    self.selected_file_type = "epub"
+                elif file_path.lower().endswith(".pdf"):
+                    self.selected_file_type = "pdf"
+                else:
+                    self.selected_file_type = "markdown"
+
                self.selected_book_path = file_path
                # Don't set file info immediately, open_book_file will handle it after dialog is accepted
                if not self.open_book_file(file_path):
@@ -1183,14 +1261,18 @@ class abogen(QWidget):
    def open_book_file(self, book_path):
        # Clear selected chapters if this is a different book than the last one
        if (
-            not hasattr(self, "last_opened_book_path")
-            or self.last_opened_book_path != book_path
+                not hasattr(self, "last_opened_book_path")
+                or self.last_opened_book_path != book_path
        ):
            self.selected_chapters = set()
            self.last_opened_book_path = book_path

+        # HandlerDialog uses internal caching to avoid reprocessing the same book
        dialog = HandlerDialog(
-            book_path, checked_chapters=self.selected_chapters, parent=self
+            book_path,
+            file_type=getattr(self, 'selected_file_type', None),
+            checked_chapters=self.selected_chapters,
+            parent=self
        )
        dialog.setWindowModality(Qt.NonModal)
        dialog.setModal(False)
@@ -1201,10 +1283,18 @@ class abogen(QWidget):
                return False
            chapters_text, all_checked_hrefs = dialog.get_selected_text()
            if not all_checked_hrefs:
-                file_type = "pdf" if book_path.lower().endswith(".pdf") else "epub"
-                error_msg = (
-                    f"No {'pages' if file_type == 'pdf' else 'chapters'} selected."
-                )
+                # Determine file type for error message
+                if book_path.lower().endswith(".pdf"):
+                    file_type = "pdf"
+                    item_type = "pages"
+                elif book_path.lower().endswith((".md", ".markdown")):
+                    file_type = "markdown"
+                    item_type = "chapters"
+                else:
+                    file_type = "epub"
+                    item_type = "chapters"
+
+                error_msg = f"No {item_type} selected."
                self._show_error_message_box(f"{file_type.upper()} Error", error_msg)
                return False
            self.selected_chapters = all_checked_hrefs
@@ -1216,6 +1306,12 @@ class abogen(QWidget):
            if book_path.lower().endswith(".pdf"):
                self.pdf_has_bookmarks = getattr(dialog, "has_pdf_bookmarks", False)

+            cleaned_text = clean_text(chapters_text)
+            computed_char_count = calculate_text_length(cleaned_text)
+            self.char_count = computed_char_count
+            if isinstance(getattr(self, "_char_count_cache", None), dict):
+                self._char_count_cache[book_path] = computed_char_count
+
            # Use "abogen" prefix for cache files
            # Extract base name without extension
            base_name = os.path.splitext(os.path.basename(book_path))[0]
@@ -1300,6 +1396,8 @@ class abogen(QWidget):
            self.selected_file = tmp
            self.selected_book_path = book_path
            self.displayed_file_path = book_path
+            if isinstance(getattr(self, "_char_count_cache", None), dict):
+                self._char_count_cache[tmp] = computed_char_count
            # Only set file info if dialog was accepted
            self.input_box.set_file_info(book_path)
            return True
@@ -1322,9 +1420,9 @@ class abogen(QWidget):
            is_cache_file = get_user_cache_path() in file_path
        # Otherwise use selected_file if it's a txt file
        elif (
-            self.selected_file_type == "txt"
-            and self.selected_file
-            and os.path.exists(self.selected_file)
+                self.selected_file_type == "txt"
+                and self.selected_file
+                and os.path.exists(self.selected_file)
        ):
            editing = True
            edit_file = self.selected_file
@@ -1535,9 +1633,9 @@ class abogen(QWidget):
    def _get_queue_progress_format(self, value=None):
        """Return the progress bar format string for queue mode."""
        if (
-            hasattr(self, "queued_items")
-            and self.queued_items
-            and hasattr(self, "current_queue_index")
+                hasattr(self, "queued_items")
+                and self.queued_items
+                and hasattr(self, "current_queue_index")
        ):
            N = self.current_queue_index + 1
            M = len(self.queued_items)
@@ -1554,9 +1652,9 @@ class abogen(QWidget):
        self.progress_bar.setValue(value)
        # Show queue progress if in queue mode
        if (
-            hasattr(self, "queued_items")
-            and self.queued_items
-            and hasattr(self, "current_queue_index")
+                hasattr(self, "queued_items")
+                and self.queued_items
+                and hasattr(self, "current_queue_index")
        ):
            N = self.current_queue_index + 1
            M = len(self.queued_items)
@@ -1614,14 +1712,17 @@ class abogen(QWidget):

    def add_to_queue(self):
        # For epub/pdf, always use the converted txt file (selected_file)
-        if self.selected_file_type in ["epub", "pdf"]:
+        if self.selected_file_type in ["epub", "pdf", "md", "markdown"]:
            file_to_queue = self.selected_file
+            # Use the original file path for save location
+            save_base_path = self.displayed_file_path if self.displayed_file_path else file_to_queue
        else:
            file_to_queue = (
                self.displayed_file_path
                if self.displayed_file_path
                else self.selected_file
            )
+            save_base_path = file_to_queue  # For non-EPUB, it's the same
        
        if not file_to_queue:
            self.input_box.set_error("Please add a file.")
@@ -1641,21 +1742,24 @@ class abogen(QWidget):
            output_format=self.selected_format,
            total_char_count=self.char_count,
            replace_single_newlines=self.replace_single_newlines,
+            save_base_path=save_base_path,
        )

        # Prevent adding duplicate items to the queue
        for queued_item in self.queued_items:
            if (
-                queued_item.file_name == item_queue.file_name
-                and queued_item.lang_code == item_queue.lang_code
-                and queued_item.speed == item_queue.speed
-                and queued_item.voice == item_queue.voice
-                and queued_item.save_option == item_queue.save_option
-                and queued_item.output_folder == item_queue.output_folder
-                and queued_item.subtitle_mode == item_queue.subtitle_mode
-                and queued_item.output_format == item_queue.output_format
-                and getattr(queued_item, "replace_single_newlines", False)
-                == item_queue.replace_single_newlines
+                    queued_item.file_name == item_queue.file_name
+                    and queued_item.lang_code == item_queue.lang_code
+                    and queued_item.speed == item_queue.speed
+                    and queued_item.voice == item_queue.voice
+                    and queued_item.save_option == item_queue.save_option
+                    and queued_item.output_folder == item_queue.output_folder
+                    and queued_item.subtitle_mode == item_queue.subtitle_mode
+                    and queued_item.output_format == item_queue.output_format
+                    and getattr(queued_item, "replace_single_newlines", False)
+                    == item_queue.replace_single_newlines
+                    and getattr(queued_item, "save_base_path", None)
+                    == item_queue.save_base_path
            ):
                QMessageBox.warning(
                    self, "Duplicate Item", "This item is already in the queue."
@@ -1715,6 +1819,8 @@ class abogen(QWidget):
            self.replace_single_newlines = getattr(
                queued_item, "replace_single_newlines", False
            )
+            # Restore the original file path for save location
+            self.displayed_file_path = queued_item.save_base_path or queued_item.file_name
            self.start_conversion(from_queue=True)
        else:
            # Queue finished, reset index
@@ -1758,16 +1864,28 @@ class abogen(QWidget):
        if not self.selected_file:
            self.input_box.set_error("Please add a file.")
            return
+
+        # Ensure we honor the currently selected save option when not running from queue
+        if not from_queue:
+            current_option = self.save_combo.currentText()
+            self.save_option = current_option
+            self.config["save_option"] = current_option
+            # If user is not choosing a specific folder, clear any residual folder
+            if current_option != "Choose output folder":
+                self.selected_output_folder = None
+                self.config["selected_output_folder"] = None
+            save_config(self.config)
+
        prevent_sleep_start()
        self.is_converting = True
        self.convert_input_box_to_log()
        self.progress_bar.setValue(0)
        # Show queue progress if in queue mode
        if (
-            from_queue
-            and hasattr(self, "queued_items")
-            and self.queued_items
-            and hasattr(self, "current_queue_index")
+                from_queue
+                and hasattr(self, "queued_items")
+                and self.queued_items
+                and hasattr(self, "current_queue_index")
        ):
            N = self.current_queue_index + 1
            M = len(self.queued_items)
@@ -1830,6 +1948,7 @@ class abogen(QWidget):
                total_char_count=self.char_count,
                use_gpu=self.gpu_ok,
                from_queue=from_queue,
+                save_base_path=self.displayed_file_path,  # Pass the save base path (original file for EPUB)
            )  # Use gpu_ok status
            # Pass the displayed file path to the log_updated signal handler in ConversionThread
            self.conversion_thread.display_path = display_path
@@ -1837,6 +1956,8 @@ class abogen(QWidget):
            self.conversion_thread.file_size_str = file_size_str
            # Pass max_subtitle_words from config
            self.conversion_thread.max_subtitle_words = self.max_subtitle_words
+            # Pass silence_duration from config
+            self.conversion_thread.silence_duration = self.silence_duration
            # Pass replace_single_newlines setting
            self.conversion_thread.replace_single_newlines = (
                self.replace_single_newlines
@@ -1850,8 +1971,8 @@ class abogen(QWidget):
                "subtitle_format", "ass_centered_narrow"
            )
            # Pass chapter count for EPUB or PDF files
-            if self.selected_file_type in ["epub", "pdf"] and hasattr(
-                self, "selected_chapters"
+            if self.selected_file_type in ["epub", "pdf", "md", "markdown"] and hasattr(
+                    self, "selected_chapters"
            ):
                self.conversion_thread.chapter_count = len(self.selected_chapters)
                # Pass save_chapters_separately flag if available
@@ -1994,8 +2115,8 @@ class abogen(QWidget):

        # Only show finish_widget if queue is done
        if (
-            self.current_queue_index + 1 >= len(self.queued_items)
-            or not self.queued_items
+                self.current_queue_index + 1 >= len(self.queued_items)
+                or not self.queued_items
        ):
            # Queue finished, show finish screen
            self.controls_widget.hide()
@@ -2360,14 +2481,14 @@ class abogen(QWidget):
        def cleanup():
            # Only remove if not from cache AND it's a temp file from VoicePreviewThread
            if (
-                not from_cache
-                and hasattr(self, "preview_thread")
-                and hasattr(self.preview_thread, "temp_wav")
-                and self.preview_thread.temp_wav == temp_wav
+                    not from_cache
+                    and hasattr(self, "preview_thread")
+                    and hasattr(self.preview_thread, "temp_wav")
+                    and self.preview_thread.temp_wav == temp_wav
            ):
                try:
                    if os.path.exists(
-                        temp_wav
+                            temp_wav
                    ):  # Ensure it exists before trying to remove
                        os.remove(temp_wav)
                except Exception:
@@ -2441,8 +2562,8 @@ class abogen(QWidget):
                return
        try:
            if (
-                hasattr(self, "conversion_thread")
-                and self.conversion_thread.isRunning()
+                    hasattr(self, "conversion_thread")
+                    and self.conversion_thread.isRunning()
            ):
                if not hasattr(self, "_conversion_lock"):
                    self._conversion_lock = threading.Lock()
@@ -2529,9 +2650,9 @@ class abogen(QWidget):
    def cleanup_conversion_thread(self):
        # Stop conversion thread
        if (
-            hasattr(self, "conversion_thread")
-            and self.conversion_thread is not None
-            and self.conversion_thread.isRunning()
+                hasattr(self, "conversion_thread")
+                and self.conversion_thread is not None
+                and self.conversion_thread.isRunning()
        ):
            self.conversion_thread.cancel()
            self.conversion_thread.wait()
@@ -2566,8 +2687,8 @@ class abogen(QWidget):
        if dialog.exec_() == QDialog.Accepted:
            options = dialog.get_options()
            if (
-                hasattr(self, "conversion_thread")
-                and self.conversion_thread.isRunning()
+                    hasattr(self, "conversion_thread")
+                    and self.conversion_thread.isRunning()
            ):
                self.conversion_thread.set_chapter_options(options)
        else:
@@ -2587,8 +2708,8 @@ class abogen(QWidget):
                import winreg

                with winreg.OpenKey(
-                    winreg.HKEY_CURRENT_USER,
-                    r"Software\Microsoft\Windows\CurrentVersion\Themes\Personalize",
+                        winreg.HKEY_CURRENT_USER,
+                        r"Software\Microsoft\Windows\CurrentVersion\Themes\Personalize",
                ) as key:
                    value, _ = winreg.QueryValueEx(key, "AppsUseLightTheme")
                    return value == 0
@@ -2684,7 +2805,7 @@ class abogen(QWidget):

        # Main logic
        dark_mode = theme == "dark" or (
-            theme == "system" and is_windows and is_windows_dark_mode()
+                theme == "system" and is_windows and is_windows_dark_mode()
        )
        if dark_mode:
            app.setStyle("Fusion")
@@ -2720,7 +2841,7 @@ class abogen(QWidget):

        def get_dark_mode():
            return theme == "dark" or (
-                theme == "system" and is_windows and is_windows_dark_mode()
+                    theme == "system" and is_windows and is_windows_dark_mode()
            )

        app._dark_titlebar_event_filter = DarkTitleBarEventFilter(
@@ -2790,6 +2911,11 @@ class abogen(QWidget):
        max_words_action.triggered.connect(self.set_max_subtitle_words)
        menu.addAction(max_words_action)

+        # Add silence between chapters option
+        silence_action = QAction("Configure silence between chapters", self)
+        silence_action.triggered.connect(self.set_silence_between_chapters)
+        menu.addAction(silence_action)
+
        max_lines_action = QAction("Configure max lines in log window", self)
        max_lines_action.triggered.connect(self.set_max_log_lines)
        menu.addAction(max_lines_action)
@@ -2946,7 +3072,7 @@ class abogen(QWidget):
    def open_cache_directory(self):
        """Open the cache directory used by the program."""
        try:
-            # Get the cache directory path
+            # Get the abogen cache directory
            cache_dir = get_user_cache_path()

            # Create the directory if it doesn't exist
@@ -3255,8 +3381,8 @@ Categories=AudioVideo;Audio;Utility;

        # Reset flag to track if we should show "no updates" message
        show_result = (
-            hasattr(self, "_show_update_check_result")
-            and self._show_update_check_result
+                hasattr(self, "_show_update_check_result")
+                and self._show_update_check_result
        )
        self._show_update_check_result = False

@@ -3383,9 +3509,9 @@ Categories=AudioVideo;Audio;Utility;

            # If currently selected file is in the cache directory, clear the UI
            if (
-                self.selected_file
-                and os.path.dirname(self.selected_file) == cache_dir
-                and self.selected_file.endswith(".txt")
+                    self.selected_file
+                    and os.path.dirname(self.selected_file) == cache_dir
+                    and self.selected_file.endswith(".txt")
            ):
                self.input_box.clear_input()

@@ -3446,6 +3572,40 @@ Categories=AudioVideo;Audio;Utility;
                f"Maximum words per subtitle set to {value}.",
            )

+    def set_silence_between_chapters(self):
+        """Open a dialog to set the silence duration between chapters"""
+        from PyQt5.QtWidgets import QInputDialog, QDialog
+
+        current_value = self.config.get("silence_duration", 2.0)
+
+        dlg = QInputDialog(self)
+        dlg.setWindowTitle("Silence Duration (seconds)")
+        dlg.setLabelText(
+            "Enter the duration of silence\nbetween chapters (in seconds):"
+        )
+        dlg.setInputMode(QInputDialog.DoubleInput)
+        dlg.setDoubleDecimals(1)
+        dlg.setDoubleMinimum(0.0)
+        dlg.setDoubleMaximum(60.0)
+        dlg.setDoubleValue(current_value)
+        dlg.setDoubleStep(0.1)  # <-- set step to 0.1
+
+        if dlg.exec_() == QDialog.Accepted:
+            value = dlg.doubleValue()
+            # Round to one decimal to avoid floating-point representation noise
+            value = round(value, 1)
+
+            # Save the new value
+            self.silence_duration = value
+            self.config["silence_duration"] = value
+            save_config(self.config)
+
+            # Show confirmation (format with one decimal)
+            QMessageBox.information(
+                self,
+                "Setting Saved",
+                f"Silence duration between chapters set to {value:.1f} seconds.",
+            )
    def set_separate_chapters_format(self, fmt):
        """Set the format for separate chapters audio files."""
        self.separate_chapters_format = fmt
@@ -4,6 +4,33 @@ import sys
 import platform
 import atexit
 import signal
+
+# Qt platform plugin detection (fixes #59)
+try:
+    from PyQt5.QtCore import QLibraryInfo
+    plugins = QLibraryInfo.location(QLibraryInfo.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)
+except ImportError:
+    print("PyQt5 not installed.")
+
+# Set application ID for Windows taskbar icon
+if platform.system() == "Windows":
+    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 PyQt5.QtWidgets import QApplication
 from PyQt5.QtGui import QIcon
 from PyQt5.QtCore import qInstallMessageHandler, QtMsgType
@@ -72,13 +99,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()
@@ -140,7 +140,7 @@ class QueueManager(QDialog):
        instructions = QLabel(
            "<h2>How Queue Works?</h2>"
            "You can add text files (.txt) directly using the '<b>Add files</b>' button below. "
-            "To add PDF or EPUB files, use the input box in the main window and click the <b>'Add to Queue'</b> button. "
+            "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."
@@ -207,6 +207,8 @@ 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())
@@ -217,20 +219,36 @@ class QueueManager(QDialog):
            self.empty_overlay.hide()
        icon_provider = QFileIconProvider()
        for item in self.queue:
-            # Only show the file name, not the full path
-            file_name = item.file_name
-            display_name = file_name
-            import os
+            # 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
            
-            if os.path.sep in file_name:
-                display_name = os.path.basename(file_name)
-            # Get icon for the file
-            icon = icon_provider.icon(QFileInfo(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
+
+            if os.path.sep in display_file_path:
+                display_name = os.path.basename(display_file_path)
+            # Get icon for the display file
+            icon = icon_provider.icon(QFileInfo(display_file_path))
            list_item = QListWidgetItem()
            # Set tooltip with detailed info
            output_folder = getattr(item, "output_folder", "")
-            tooltip = (
-                f"<b>Path:</b> {file_name}<br>"
+            # 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'):
+                    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:
+                tooltip += f"<b>Processing File:</b> {processing_file_path}<br>"
+            tooltip += (
                f"<b>Language:</b> {getattr(item, 'lang_code', '')}<br>"
                f"<b>Speed:</b> {getattr(item, 'speed', '')}<br>"
                f"<b>Voice:</b> {getattr(item, 'voice', '')}<br>"
@@ -246,10 +264,14 @@ class QueueManager(QDialog):
            )
            list_item.setToolTip(tooltip)
            list_item.setIcon(icon)
-            list_item.setData(Qt.UserRole, file_name)
+            # Store both paths for context menu
+            list_item.setData(Qt.UserRole, {
+                '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(file_name, char_count)
+            widget = QueueListItemWidget(display_file_path, char_count)
            self.listwidget.addItem(list_item)
            self.listwidget.setItemWidget(list_item, widget)
        self.update_button_states()
@@ -372,6 +394,7 @@ 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
            for attr, value in current_attrs.items():
                setattr(item, attr, value)
            # Read file content and calculate total_char_count using calculate_text_length
@@ -405,6 +428,8 @@ 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, "save_base_path", None)
+                    == getattr(item, "save_base_path", None)
                ):
                    is_duplicate = True
                    break
@@ -473,42 +498,117 @@ class QueueManager(QDialog):
                from PyQt5.QtWidgets import QMessageBox

                item = selected_items[0]
-                file_path = item.data(Qt.UserRole)
+                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 q.file_name == file_path:
-                        if not os.path.exists(q.file_name):
+                    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(q.file_name))
+                        QDesktopServices.openUrl(QUrl.fromLocalFile(target_path))
                        break

            open_file_action.triggered.connect(open_file)
            menu.addAction(open_file_action)

            # Add Go to folder action
-            go_to_folder_action = QAction("Go to folder", self)
+            # 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)
+            if isinstance(paths, dict):
+                display_path = paths.get('display_path', '')
+                processing_path = paths.get('processing_path', '')
+            else:
+                display_path = paths
+                processing_path = paths

-            def go_to_folder():
-                from PyQt5.QtWidgets import QMessageBox
+            doc_exts = ('.md', '.markdown', '.pdf', '.epub')
+            is_document_input = (
+                isinstance(display_path, str) and display_path.lower().endswith(doc_exts)
+            ) or (
+                isinstance(processing_path, str) and processing_path.lower().endswith(doc_exts)
+            )

-                item = selected_items[0]
-                file_path = item.data(Qt.UserRole)
+            from PyQt5.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
+                if not p:
+                    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 q.file_name == file_path:
-                        if not os.path.exists(q.file_name):
-                            QMessageBox.warning(
-                                self, "File Not Found", f"The file does not exist."
-                            )
-                            return
-                        folder = os.path.dirname(q.file_name)
-                        if os.path.exists(folder):
-                            QDesktopServices.openUrl(QUrl.fromLocalFile(folder))
+                    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

-            go_to_folder_action.triggered.connect(go_to_folder)
-            menu.addAction(go_to_folder_action)
+                if not os.path.exists(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):
+                    QDesktopServices.openUrl(QUrl.fromLocalFile(folder))
+
+            if is_document_input:
+                processed_action = QAction("Go to processed file", self)
+                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'))
+                menu.addAction(input_action)
+            else:
+                # Default behavior for non-document inputs: single "Go to folder" action
+                go_to_folder_action = QAction("Go to folder", self)
+
+                def go_to_folder():
+                    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
+                            folder = os.path.dirname(target_path)
+                            if os.path.exists(folder):
+                                QDesktopServices.openUrl(QUrl.fromLocalFile(folder))
+                            break
+
+                go_to_folder_action.triggered.connect(go_to_folder)
+                menu.addAction(go_to_folder_action)

        elif len(selected_items) > 1:
            remove_action = QAction(f"Remove selected ({len(selected_items)})", self)
@@ -14,3 +14,4 @@ class QueuedItem:
    output_format: str
    total_char_count: int
    replace_single_newlines: bool = False
+    save_base_path: str = None
@@ -11,6 +11,23 @@ from threading import Thread
 warnings.filterwarnings("ignore")


+def detect_encoding(file_path):
+    import chardet
+    import charset_normalizer
+    with open(file_path, "rb") as f:
+        raw_data = f.read()
+    detected_encoding = None
+    for detectors in (charset_normalizer, chardet):
+        try:
+            result = detectors.detect(raw_data)["encoding"]
+        except Exception:
+            continue
+        if result is not None:
+            detected_encoding = result
+            break
+    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.
@@ -24,7 +24,8 @@ dependencies = [
    "pygame>=2.6.1",
    "charset_normalizer>=3.4.1",
    "chardet>=5.2.0",
-    "static_ffmpeg>=2.13"
+    "static_ffmpeg>=2.13",
+    "Markdown>=3.9"
 ]

 classifiers = [
Author	SHA1	Message	Date
Deniz Şafak	f5d1def330	v1.2.0	2025-10-20 03:57:16 +03:00
Deniz Şafak	4a28bfb859	Fixed “Go to folder” button not opening the chapter output directory when only separate chapters were generated	2025-10-20 03:51:27 +03:00
Deniz Şafak	4adda262c0	Fix total character count	2025-10-20 03:35:20 +03:00
Deniz Şafak	1d02802172	Add "How to fix "[WinError 1114]" error to readme	2025-10-20 03:21:27 +03:00
Deniz Şafak	28c0b2c401	Use a newer Python in Windows installer script	2025-10-20 02:29:16 +03:00
Deniz Şafak	1e89b566d1	Added a loading indicator to the book handler window	2025-10-20 01:17:14 +03:00
Deniz Şafak	ccb350fa08	Normalize platformpath	2025-10-19 17:17:40 +03:00
Deniz Şafak	42336145dd	Fixed taskbar icon not appearing correctly in Windows	2025-10-19 17:13:29 +03:00
Deniz Şafak	5d2da7e91c	Fixed book reprocessing issue	2025-10-19 16:37:34 +03:00
Deniz Şafak	e69195e6ef	Update changelog, fix wrong os import	2025-10-19 16:15:32 +03:00
Deniz Şafak	1520b971ac	Fixed `/` and `\` path display by normalizing paths	2025-10-19 16:02:36 +03:00
Deniz Şafak	d426bac87e	Fixed folder and filename sanitization to properly handle OS-specific illegal characters	2025-10-19 15:40:10 +03:00
Deniz Şafak	866746c5a1	Added `Line` option to subtitle generation modes	2025-10-08 00:18:39 +03:00
Deniz ŞafakandGitHub	58889d47b0	Merge pull request #94 from mleg/main Add `Line` option for subtitle generation Thank you, merged!	2025-10-08 00:13:40 +03:00
Deniz Şafak	ae148eb591	Update readme	2025-10-07 23:56:17 +03:00
Deniz Şafak	14ed98c316	Update readme	2025-10-07 23:52:58 +03:00
Deniz Şafak	eacbe05934	Fixed `cannot access local variable 'is_narrow'` error	2025-10-07 23:42:35 +03:00
Маслов Олег	e7fb89f137	Add `Line` option for subtitle generation	2025-10-05 16:00:49 +03:00
Deniz Şafak	033c809b95	Update changelog	2025-09-18 03:12:35 +03:00
Deniz Şafak	f492cc2506	v1.1.9	2025-09-18 03:11:52 +03:00
Deniz Şafak	495a50f666	Merge branch 'main' of https://github.com/denizsafak/abogen	2025-09-18 03:09:04 +03:00
Deniz Şafak	8c6e292f4f	Fixed markdown TOC generation	2025-09-18 03:08:30 +03:00
Deniz Şafak	1d8cb8eabd	Fixed the issue where spaces were deleted before punctuation marks	2025-09-18 02:37:58 +03:00
Deniz ŞafakandGitHub	a3ee95e83f	Update readme	2025-09-18 01:50:28 +03:00
Deniz ŞafakandGitHub	a98f75c1a9	Update readme	2025-09-17 23:07:36 +03:00
Deniz Şafak	f4f3a4c207	Update readme	2025-09-17 22:39:45 +03:00
Deniz Şafak	bcd76de0c2	Update changelog	2025-09-17 22:15:43 +03:00
Deniz Şafak	93c556a063	v1.1.8	2025-09-17 22:14:51 +03:00
Deniz Şafak	343ac29759	Update readme	2025-09-17 22:08:26 +03:00
Deniz ŞafakandGitHub	ce61b2e312	Merge pull request #83 from betsegaw/main Update readme to include instructions to enable audio when using the browser view in docker	2025-09-17 22:04:21 +03:00
Deniz Şafak	3d90bf94ac	Update readme	2025-09-17 22:03:09 +03:00
Deniz Şafak	de8cdfa278	Update readme and changelog	2025-09-17 22:01:14 +03:00
Deniz Şafak	9e9561988d	Fixed subtitle splitting before commas	2025-09-17 20:14:26 +03:00
Deniz Şafak	a074b8b0ad	Fixed ordered list numbers not being included in EPUB content conversion	2025-09-17 19:47:52 +03:00
Deniz Şafak	a2dc28f4d4	Fixed save options not working correctly, better indicators	2025-09-17 19:10:47 +03:00
Deniz Şafak	3b5c2ceb8f	Update conversion.py	2025-09-17 05:50:58 +03:00
Deniz Şafak	52a562039e	Potentially fixed subtitle generation stucks at 9:59:59	2025-09-17 05:50:07 +03:00
Deniz Şafak	6291f89ae9	Added new option `Configure silence between chapters`	2025-09-17 04:36:48 +03:00
Deniz Şafak	be36796d5d	Update readme	2025-09-17 03:39:19 +03:00
Deniz Şafak	219e2fc6ae	Improved the markdown logic	2025-09-17 03:32:13 +03:00
Deniz ŞafakandGitHub	196cd93008	Merge pull request #75 from brianxiadong/feat-markdown feat: Add Markdown File Support for Audiobook Generation	2025-09-17 03:30:08 +03:00
Betsegaw (Beta) TadeleandGitHub	4230db4c40	Update README.md	2025-09-16 00:16:17 -07:00
Deniz Şafak	6834d223c9	Fixed `No Qt platform plugin could be initialized` error	2025-09-14 21:48:08 +03:00
Xia Dong	67dbb0a8fb	feat: Add Markdown File Support for Audiobook Generation	2025-09-02 15:14:13 +08:00
@@ -1 +1 @@
 .1.7
 .2.0