Automating Manga Translations: My Journey to a Seamless Reading Experience

Video demo:

The Struggle: Why I Needed This

Have you ever found a manga so niche and obscure that it never gets an official English translation? That was me—desperately searching for ways to read some intimate manga that wasn’t available on MangaDex, probably due to copyright issues.
At first, I took the long road: hunting down raw Japanese sources, screenshotting pages, and running them through an image translator. It worked… but barely. The process was slow and frustrating, completely breaking my immersion. Instead of enjoying the story, I was stuck waiting for machine translations to process each page. The experience was, in a word, disruptive.
Then it hit me—I already had Suwayomi, a manga server that supports multiple sources and allows local file management. Why not build my own translation pipeline?

---

Finding a Better Way

My first attempt was to look for an existing solution. I found a closed-source iOS app that seemed promising, but when I saw their $15/month paywall, I immediately bailed. (In case you’re curious, here’s the link.)
That led me to GitHub, where I stumbled upon this amazing project. The demo results blew me away, and I knew I had to dive in and make it work for my setup.

---

The First Steps: Getting the Basics Running

The GitHub project offered two installation options: Docker and local Python. Initially, I tried Docker, but it wasn’t the best fit:

• It lacked the level of automation I wanted.

• Configuring dependencies and mounting volumes felt like extra hassle.

• It didn’t automatically trigger translations when new files appeared.

So, I switched to the Python local version, which integrated smoothly with Suwayomi. Now, I just needed a way to automate the process.

The first version of my script was simple:

1. Scan the INPUT_FOLDER for new chapters.

2. Run the manga translator command.

3. Save the output in a matching OUTPUT_FOLDER.

Command to run the translator manually:

python -m manga_translator local -v -i ../suwayomi/data/downloads/mangas/Rawkuma\ \(JA\)/Grapara\!\ Raw/Chapter\ 13/ --output ../suwayomi/data/translated/Grapara\!\ Raw\ translated/Chapter\ 13/ --use-gpu --config-file examples/config-example.json

Batch script to handle multiple chapters:

python batch-script.py --input ../suwayomi/data/downloads/mangas/Rawkuma\ \(JA\)/Grapara\!\ Raw/ --output ../suwayomi/data/translated/Grapara\!\ Raw\ translated/ --config examples/config-example.json

This worked, but there was one big problem: it wasn’t fully automated. I had to manually re-run the script every time a new chapter arrived. Clearly, there had to be a better way.

---

Automating the Pipeline: Watching for New Manga Chapters

I started exploring file-watching solutions and tested various Linux tools like inotify and watchdog. However, they didn’t track entire directories the way I needed. I wanted a script that:

• Monitors INPUT_FOLDER (and subfolders) for new content.
• Triggers translation automatically when a new chapter appears.
• Maintains the same folder structure in OUTPUT_FOLDER.

Enter Python watchdog library – a game-changer. With it, I wrote a script that:

1. Watches the manga download directory.
2. Detects when a new chapter folder appears.
3. Extracts the relative path and mirrors it in the output directory.

Here’s the script:

import os
import time
import subprocess
from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler

# ===== Configuration =====
INPUT_ROOT = "../suwayomi/data/downloads/mangas/Rawkuma (JA)"
OUTPUT_ROOT = "../suwayomi/data/translated"
CONFIG_FILE = "examples/config-example.json"
# ==========================

class TranslationHandler(FileSystemEventHandler):
    def on_created(self, event):
        if event.is_directory:
            print(f"Detected new folder: {event.src_path}")
            self.process_new_folder(event.src_path)

    def process_new_folder(self, input_path):
        # Get relative path from input root
        relative_path = os.path.relpath(input_path, INPUT_ROOT)
        dest_path = os.path.join(OUTPUT_ROOT, relative_path)
        
        # Create output directory if it doesn't exist
        os.makedirs(dest_path, exist_ok=True)

        command = [
            "python", "-m", "manga_translator", "local",
            "-v",
            "-i", input_path,
            "--dest", dest_path,
            "--config-file", CONFIG_FILE,
            "--use-gpu"
        ]

        try:
            print(f"Starting translation for: {relative_path}")
            result = subprocess.run(command, check=True, capture_output=True, text=True)
            print(f"Successfully translated: {relative_path}\n")
            print("Output:", result.stdout)
        except subprocess.CalledProcessError as e:
            print(f"Error translating {relative_path}:")
            print("Error:", e.stderr)
            print("Command executed:", ' '.join(command))

def main():
    # Validate paths
    if not os.path.isdir(INPUT_ROOT):
        raise ValueError(f"Input folder does not exist: {INPUT_ROOT}")
    os.makedirs(OUTPUT_ROOT, exist_ok=True)

    # Set up folder observer
    event_handler = TranslationHandler()
    observer = Observer()
    observer.schedule(event_handler, INPUT_ROOT, recursive=True)
    observer.start()

    try:
        print(f"Watching directory tree: {INPUT_ROOT}")
        print(f"Mirroring structure to: {OUTPUT_ROOT}")
        print("Press Ctrl+C to stop monitoring...")
        while True:
            time.sleep(1)
    except KeyboardInterrupt:
        observer.stop()
    observer.join()

if __name__ == "__main__":
    main()

---

Running It as a Background Service

I wanted the script to run 24/7 without manually starting it each time. So, I set it up as a systemd service.

1. Created a new service file:

sudo nano /etc/systemd/system/manga-trans.service

2. Added this configuration:

[Unit]
Description=Manga translation for Suwayomi
After=network.target

[Service]
User=phuchoang2603
Group=phuchoang2603
WorkingDirectory=/DATA/AppData/manga-image-translator
ExecStart=/bin/bash -c "source /home/phuchoang2603/miniforge3/etc/profile.d/conda.sh && conda activate manga-trans && python batch-script.py"

[Install]
WantedBy=multi-user.target

3. Enabled and started the service:

sudo systemctl daemon-reload
sudo systemctl enable manga-trans.service
sudo systemctl start manga-trans.service

Now, it runs in the background automatically whenever I download a new manga chapter. No more waiting, no more manual intervention—just seamless reading.

---

Final Thoughts

This setup has completely transformed how I read untranslated manga. No more hunting down translation sites, no more manual screenshots, and no more waiting. Now, whenever a new chapter drops, it gets translated instantly, ready for me to enjoy.

If you’re in the same boat, I highly recommend trying this out. Let me know if you have any improvements or questions!