YouTube Summarizer Tauri

This is a local-first desktop app for summarizing YouTube videos with Ollama.

It uses:

• Tauri for the desktop shell
• a bundled Python backend for transcript/audio processing in release builds
• Ollama on localhost for summarization and translation
• SQLite for local history

Migration State

This folder is the standalone Tauri version of the app. The repository snapshot this was created from did not contain an active Electron runtime, package.json, preload script or Electron main process; the actual app behavior was already represented by a static HTML/CSS/JS frontend, a Tauri 2 Rust shell and Python backend helpers. The migration work here keeps that behavior and design intact inside ytsummarizer_tauri so it can be built and run without depending on files outside this folder.

What It Does

Given a YouTube URL, the app can:

• fetch a transcript via the YouTube transcript API or via Whisper
• generate an English summary with a local Ollama model
• optionally translate that summary into German and Japanese
• store the results locally so they can be reopened later

Local-Only Behavior

This repository is intentionally reset to a clean publishable state:

• no Discord webhook integration
• no remote PHP/MySQL sync
• no bundled production data or pre-filled database
• runtime data is stored in the OS app data directory, not in the repo

End User Requirements

If you ship a built installer, the user should only need:

• Ollama installed locally
• the Ollama model they want to use pulled locally

Notes:

• The installer is designed to bundle the backend helper plus ffmpeg / ffprobe.
• Whisper model weights are not bundled; the selected Whisper model is downloaded on first use and then cached locally.

Developer Requirements

For development in this repo you still need:

• Python 3.8+
• Rust/Cargo
• FFmpeg in PATH
• Ollama running locally on http://localhost:11434

Python dependencies are listed in requirements.txt.

Run In Development

macOS/Linux:

./run.sh

Windows:

run.bat

Or directly:

python3 -m venv venv
source venv/bin/activate
pip install -r requirements.txt
cargo run --manifest-path src-tauri/Cargo.toml

The app prefers a bundled backend executable when one is present under src-tauri/resources/backend, and otherwise falls back to the local Python environment for development.

Build A Shippable Bundle

1. Make sure the build machine has Python, Rust/Cargo, and ffmpeg / ffprobe available on PATH.
2. Run:

python3 tools/prepare_bundle.py

3. Then build the installer:

cargo tauri build

What tools/prepare_bundle.py does:

• installs PyInstaller into the current Python environment
• builds a single-file backend executable from backend_cli.py
• copies that executable into src-tauri/resources/backend
• copies ffmpeg and ffprobe from the build machine into src-tauri/resources/ffmpeg

Build once on each target OS you want to ship. For Windows 10, build on Windows.

Build On GitHub Actions

A Windows build workflow from the original repository can be pointed at this folder by running the same commands from ytsummarizer_tauri.

It should run on windows-latest, install ffmpeg and NSIS, prepare the bundled Python backend with tools/prepare_bundle.py, build an NSIS installer, and upload the result as a workflow artifact named windows-installer.

Notes

• If Python is not on your PATH for development, set YTS_PYTHON to the interpreter you want the Tauri backend to use.
• If you want to test a prebuilt backend executable during development, set YTS_BACKEND_BIN to its full path.
• If ffmpeg or ffprobe are not on PATH during bundle prep, set YTS_FFMPEG and YTS_FFPROBE to their full paths before running tools/prepare_bundle.py.
• Generated thumbnails and the SQLite database are created on first run in the app's local data directory.