# MoneyPrinterTurbo-Extended: a fork with better subtitles and local voices

> MoneyPrinterTurbo-Extended is a fork of the MoneyPrinterTurbo video generator that changes three things: subtitles are highlighted word by word in step with the text to speech, the stock footage is chosen by semantic similarity to the script rather than at random, and the voice comes from Chatterbox, a local text to speech model with voice cloning, so the pipeline does not need a paid speech API. The rest of the stack, a Streamlit interface and a FastAPI service, is inherited unchanged.

**Asad-Ismail/MoneyPrinterTurbo-Extended** — An extended improved implementation of Money printer turbo

- Repository: https://github.com/Asad-Ismail/MoneyPrinterTurbo-Extended
- Stars: 526 · Forks: 166
- Language: Python
- License: MIT
- Published: 2026-10-22 · Updated: 2026-10-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/asad-ismail-moneyprinterturbo-extended

## A fork that changes three things and inherits the rest

MoneyPrinterTurbo-Extended is an extended, improved implementation of MoneyPrinterTurbo, the script to video generator that turns a text script into a narrated video with stock footage and subtitles. The fork gives full credit to the original author and contributors, and it is MIT licensed, written in Python, with the last push on 2026-08-20 and no tagged releases, on a default branch called main.

The README is organised around what is different, and it is worth reading that section closely because it is short. There are three areas of change.

The first is the subtitle system. The fork highlights each word exactly when it is spoken, synchronised in real time with the word boundaries that come out of the text to speech engine, it works with wrapped text and complex subtitle layouts, and the highlight colour is configurable through the web interface. The second is video to text matching. Instead of picking clips at random, the fork analyses the script content to find relevant footage, matches video content to the meaning of the script with text similarity, and can optionally compare video thumbnails for sources such as Pexels.

The third is the voice. The fork bundles Chatterbox TTS as a completely free alternative to Azure TTS that runs locally, with the four advantages listed: no API costs and no rate limits, voice cloning from ten to sixty seconds of reference audio, word level timing that gives exact subtitle synchronisation with WhisperX, and configurable speech pacing through environment variables.

Everything else, the interface, the service, the video assembly, the configuration, comes from the original project, and the fork's own material does not describe changes to any of it.

## Why word level timing is the change that matters

The subtitle work is the most interesting of the three because it depends on the rest of the pipeline cooperating.

In a typical script to video tool, the voice is generated first and the subtitle file is produced afterwards by transcribing the audio, usually with a speech recognition model. The timing is therefore derived from the audio, and the highlight can only be as good as the transcript. The fork's approach is the other way round: Chatterbox produces word level timing as it synthesises the speech, and WhisperX is used to align, which means the highlight follows the actual pronunciation of each word rather than an estimate of it.

The result is a karaoke style effect where the current word lights up as it is spoken. The list of supported features under the heading says it works with wrapped text and complex subtitle layouts, which is the part that usually breaks first in a naive implementation, because a word that wraps across two lines has to be highlighted in two places.

The colour is configurable through the web interface, and that is the same interface where the voice settings live, so the whole look of a video is set in one place. The screenshots in the repository show the main interface and the voice settings panel, and the README explains that those settings are published for transparency and reproducibility.

For a viewer, the effect is what makes a generated video feel less like a slide show with narration, and for the developer it is the reason the fork exists at all, because the improvement is a change in the pipeline rather than a change in the interface.

## Cloning a voice, and what that implies

The Chatterbox integration is the part of the fork with the most obvious appeal and the most obvious risk, and the two are the same fact.

The appeal is stated plainly. No API costs, no rate limits, a voice cloned from ten to sixty seconds of reference audio, and automatic speed control. A creator who has been paying per character to a hosted speech service, or who has hit a rate limit during a batch render, gets a local model instead. The fine tuning is done through an environment variable with a small set of meaningful values, where a lower weight is a very slow delivery, 0.2 is the slow default, and 0.3 is normal speed, and a second variable forces CPU mode when the machine has no usable GPU.

The risk is that voice cloning is a consent question. Cloning a voice from a reference recording is a technique that makes it possible to produce speech in a person's voice without their involvement, and the fork's own documentation says to ensure the reference audio is clear and from a single speaker, which is advice about quality rather than about permission. The tooling is neutral; the use is not. A clone of your own voice is straightforward, and a clone of a voice that belongs to someone else who has not agreed to it is a different act, and the fact that the model runs on your own machine changes nothing about that.

The same reasoning applies to the footage. Semantic matching to stock video from sources such as Pexels makes the output more relevant, and stock licences usually allow reuse with attribution, but the licence covers the clip, not the video that the clip ends up in. A reader of this fork should decide these questions before generating anything, rather than after.

## The install, the two interfaces, and the dependency list

The installation is a conda environment plus a second clone for the speech model:

```bash
# 1. Clone and setup
git clone https://github.com/Asad-Ismail/MoneyPrinterTurbo-Extended.git
cd MoneyPrinterTurbo-Extended
conda env create -f environment.yml
conda activate MoneyPrinterTurbo

# 2. Install Chatterbox TTS (voice cloning)
git clone https://github.com/resemble-ai/chatterbox.git
cd chatterbox && pip install -e . && cd ..
```

There is a separate CUDA setup script for the cases where the container or the environment does not have the right libraries, and the README documents a specific failure, a missing cuDNN 8.x library, with a manual fix that pins a version of the cuDNN package. The web interface is started with a shell script and opens on port 8501, which is the Streamlit default.

The requirements file is the clearest description of what the pipeline actually does, and it is a long one. MoviePy 2.1.2 assembles the video, Streamlit 1.45.0 is the web interface, edge-tts and the Azure Cognitive Services speech package are the hosted speech options, faster-whisper is the transcription and alignment model, FastAPI with Uvicorn is the service, and there is a Redis client, which suggests caching of some kind in the API path. The script side is a wide spread of providers: OpenAI, google.generativeai, dashscope, and g4f, the last of which is a multi provider frontend. Then the matching side, with sentence-transformers and scikit-learn for the text similarity, and transformers with torch and pillow, which the requirements file marks as the image similarity dependencies for the optional thumbnail analysis.

The two interfaces are the webui/ directory and a main.py API, and the compose file runs both, with the web interface on 8501 and the API on 8080, sharing the project directory as a volume so that generated files and the configuration file are visible from the host.

## The container, and the ImageMagick policy it removes

The Dockerfile is where the interesting decision sits, and it is not a Python one.

The base image is python:3.11-slim-bullseye, the working directory is set to the project path, the environment variable PYTHONPATH points at it, and the system dependencies installed with apt are git, ImageMagick and ffmpeg, the last of which is the video encoder and the first of which is the image processor used for the frames and the thumbnails.

The step worth reading is the one that patches ImageMagick's security policy. The Dockerfile runs a sed command against /etc/ImageMagick-6/policy.xml that deletes the line disabling the path pattern, which is the rule that stops ImageMagick from reading and writing files at arbitrary paths. The comment above it says it is there to fix a security policy for ImageMagick, and in practice it is done because the tool needs to write or read image files in paths that the default policy blocks, such as mounted volumes.

That change is the kind of thing that is easy to copy from a Dockerfile without reading it, and it removes a defence against a class of image processing abuse in a container that also has the host project directory mounted. It is not a reason to avoid the project, but it is a reason to understand it, and to check where the storage directory lives before running the container with a host mount.

The rest of the image is conventional: the requirements file is copied before the rest of the source so that the dependency layer is cached, the install uses no cache directory, the port 8501 is exposed, and the container starts the Streamlit application with the browser address, CORS and usage statistics settings passed as arguments.

The compose file has a small detail that is easy to miss and useful to know, which is the volume anchor. The common volumes are defined once as an anchor and reused by both services, so the web interface and the API see the same files without repeating the mapping.

## The prompt the project publishes, and the questions it raises

One section of the README is unusual enough to be worth describing in detail, because it publishes the prompt that the project uses to drive a language model.

It asks for a content package for a five minute video, with topic selection criteria that are stated explicitly: the topic must have high current interest and search volume, it must appeal broadly across areas such as productivity, health, personal finance and psychology, it must be grounded in mainstream scientific consensus, and it must be safe and non-controversial, focused on foundational and actionable knowledge. The deliverables are then four: three distinct clickable title options with the stated goal of a high click through rate, a full script of eight hundred to nine hundred words with sentence structure optimised for text to speech, a set of Pexels video search keywords organised by script concept and output as one comma separated line, and a search optimised description with ten to fifteen hashtags.

Publishing the prompt is the right thing to do, and it makes the tool's behaviour legible instead of mysterious. It also makes the intent plain, and the intent is a machine for producing a large volume of content that is engineered to be clicked. That is a legitimate market, and it is also a behaviour that video platforms are increasingly explicit about, and a creator using this pipeline is the party who has to think about whether their output survives a policy review.

Two practical risks come with the same tool. The first is cost and key exposure, since the requirements pull in several hosted providers and a Redis client, and a fork's configuration file holds credentials for them. The second is the volume of machine generated uploads, which is a property of the tool rather than of the fork, and which is where the difference between a creator making a few videos and a spam operation becomes visible to a platform.

The repository also carries a CHANGELOG, a test directory, a notebooks directory, a prompts.txt file, a reference_audio/ directory for the cloning samples and a resource/ directory, and the api.sh script, so the pieces of the pipeline are all visible. What the project does not offer is a versioned release, so pin a commit and keep your own notes, because this fork is being changed without tags.

## Conclusion

MoneyPrinterTurbo-Extended fits a creator who already runs MoneyPrinterTurbo and wants the three specific improvements it adds, especially the word level subtitle synchronisation and a local voice option that removes both the cost and the rate limit of a hosted speech service. It is the wrong tool if you need a supported product, since the project publishes no releases, and the wrong tool for content you do not have the rights to, because the stock footage comes from sources such as Pexels and the voice is cloned from a reference recording that the person in it may not have consented to. Before you deploy it, read the ImageMagick policy change in the Dockerfile, which relaxes a default restriction, decide where your API keys live, since the requirements pull in OpenAI, Azure speech, Gemini, Dashscope and a Redis client, and check what your video platform's policy says about generated voice and reused footage before you publish.

## FAQ

### What does MoneyPrinterTurbo-Extended add to MoneyPrinterTurbo?

Three things. The subtitle system highlights each word exactly when it is spoken, synchronised with the word boundaries from the text to speech engine, and works with wrapped text and configurable highlight colours. The stock footage is chosen by semantic search and text similarity to the script, with optional thumbnail analysis. And the voice comes from Chatterbox TTS running locally, with cloning from ten to sixty seconds of reference audio and word level timing through WhisperX.

### How do I install MoneyPrinterTurbo-Extended?

Clone the repository, create the conda environment with the environment.yml file and activate it, then clone the chatterbox repository and install it in editable mode with pip. The web interface is started with the webui.sh script and opens on port 8501, and there is a setup_cuda_env.sh script for CUDA library problems, including a missing cuDNN 8.x library.

### Does MoneyPrinterTurbo-Extended need paid API services?

Not for the voice. Chatterbox TTS runs locally, so the README lists no API costs and no rate limits as its advantages over Azure TTS. The rest of the pipeline does depend on hosted providers, since the requirements include the OpenAI, google.generativeai, dashscope and g4f packages alongside edge-tts and the Azure speech package, and a Redis client appears in the API path.

### What interfaces does MoneyPrinterTurbo-Extended run?

A Streamlit web interface on port 8501 and a FastAPI service on port 8080, which the compose file runs as two services from the same Dockerfile, sharing the project directory as a volume. The container image is based on python:3.11-slim-bullseye with ImageMagick and ffmpeg installed.

## Sources

- [Asad-Ismail/MoneyPrinterTurbo-Extended on GitHub](https://github.com/Asad-Ismail/MoneyPrinterTurbo-Extended)
- [Issues](https://github.com/Asad-Ismail/MoneyPrinterTurbo-Extended/issues)
- [License: MIT](https://github.com/Asad-Ismail/MoneyPrinterTurbo-Extended/blob/main/LICENSE)
- [README](https://github.com/Asad-Ismail/MoneyPrinterTurbo-Extended/blob/main/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/asad-ismail-moneyprinterturbo-extended