StyleTTS 2 on Mac: Install, License, and When to Skip It

Short answer: StyleTTS 2 is a 2023 research text to speech model that represents speaking style as a latent variable and samples it with a diffusion model, and you can run it on an Apple Silicon Mac through the official Python repository or the MIT-licensed styletts2 package on PyPI. There is no official Mac app, the repository's install instructions include an apt-get line for Linux, and the reference inference path depends on a GPL-licensed phonemizer. Murmur does not run StyleTTS 2. If you want a packaged Mac app, you would use one of the models Murmur actually ships, and this guide is honest about where that trade makes sense.

Search results for StyleTTS 2 mix the paper, the GitHub repository, two Hugging Face checkpoint repositories, a third-party fork, and a PyPI package. Those are not the same artifact, and their licenses are not the same either. This guide uses only the pages listed in the sources block, all opened on 2026-10-19, and it separates what the project states from what a Mac user has to do to get a WAV file.

What StyleTTS 2 is, and what style diffusion means

The paper describes StyleTTS 2 as a text to speech model that models style as a latent random variable and uses diffusion to sample the style that fits the input text. That is the core idea behind the name. Older style transfer systems usually need a reference recording to copy a speaking style from. StyleTTS 2 can generate a suitable style without reference speech, then still accept a reference clip when you want to steer timbre or prosody. The paper says this gives the model the diversity of a diffusion model while keeping the inference step efficient.

The second half of the design is adversarial training. The authors use a large pre-trained speech language model, WavLM, as a discriminator, and pair it with differentiable duration modeling so the whole pipeline trains end to end. The result is a 24 kHz model. The paper reports that it surpasses human recordings on the single-speaker LJSpeech dataset and matches them on the multispeaker VCTK dataset in listening tests with native English speakers, and that a LibriTTS-trained version outperforms earlier public models on zero-shot speaker adaptation. Those are the authors' evaluation results on those datasets. They are not a promise about your script, your microphone, or your listeners.

It helps to be precise about what the model is not. StyleTTS 2 is an acoustic model with a style encoder, a diffusion module, and a neural vocoder, not a language model that predicts speech tokens. The repository README does not publish a parameter count, so this article does not invent one. The PyPI package returns audio at 24 kHz by default, which matches the sample rate the README names for the LJSpeech checkpoint.

The two pretrained checkpoints and what each one is for

The official README links two pretrained downloads, both hosted on Hugging Face under the author's account. They serve different jobs, and choosing the wrong one is a common source of disappointment.

The missing model card matters for a commercial decision. When a Hugging Face page says no model card, you cannot read a license field there. The only license statements you can rely on are in the GitHub README and the LICENSE file, plus the author's clarification in issue #37. If your legal review needs a checkpoint license document, ask the author or your counsel rather than assuming the repository license covers the weights.

The LibriTTS checkpoint is the one people usually want for cloning, because the paper's zero-shot adaptation result comes from LibriTTS training. The README is also clear that the demo needs the separate reference audio archive. Downloading the checkpoint alone and running the multispeaker notebook without that archive is an incomplete setup.

License: the code, the checkpoints, and the phonemizer are three different things

The repository LICENSE file is the MIT License, copyright 2023 Aaron (Yinghao) Li. That covers the source code in the repository. The README adds a separate section for the pretrained models. For the pre-trained models, it asks you to use only voices whose speakers granted permission to have their voice cloned, either directly or by license, or otherwise to publicly announce that the voices are synthesized. The README says these terms apply when you use the pre-trained models and the voices are not in the training set. The author explained in issue #37 that these rules were added for the NeurIPS 2023 ethics review and are aimed at the pretrained weights, not at code or at a model you train yourself. That is a meaningful distinction, but it is also a bespoke restriction rather than a standard OSI license.

The phonemizer is the part that surprises people. The README states that inference depends on a GPL-licensed package, so the importable inference code is not included directly in the repository. The GPL-licensed fork linked from the README, NeuralVox/StyleTTS2, is GPL-3.0 and says the license comes from Phonemizer. If you plan to redistribute a product that bundles that code, the GPL obligations are a real engineering constraint, not a footnote. The README also points to a fully MIT-licensed PyPI package that uses gruut instead of phonemizer, and it warns that the result is lower quality because of a mismatch between the two phonemizers.

So there are three practical routes. Use the original repository for research or training, accept that its inference path needs a GPL package, and keep that code separate from anything you ship under a non-GPL license. Use the NeuralVox fork if you want an importable API and a streaming experiment, and treat the whole thing as GPL-3.0. Use the PyPI package if a permissive license matters more than the last increment of pronunciation quality. None of this is legal advice. Read the actual license files and talk to counsel before you ship.

On consent, the README attaches terms to the pre-trained models, which many hobby projects do not. Only clone voices you own or have written permission to use. A local model removes the upload step, not the permission requirement. The open source model license checklist is a useful second pass before you put output into a commercial project.

Installing StyleTTS 2 on macOS, following the README and the issues

Pick the route before you type commands. The original repository is for training and fine-tuning as well as inference, and its install steps lean on Linux, with an apt-get line for espeak-ng. The PyPI package is inference only and prunes the training dependencies. If you only want to synthesize a few lines, the PyPI route is shorter. If you want to fine-tune or read the training code, clone the repository.

These are the repository's own prerequisites, copied from the README:

git clone https://github.com/yl4579/StyleTTS2.git cd StyleTTS2 pip install -r requirements.txt

StyleTTS 2 README, Pre-requisites section, checked 2026-10-19

The README says Python 3.7 or newer. The PyPI package is narrower and says Python 3.9 or 3.10 because of other library dependencies, though its classifiers list newer versions too. Create a dedicated virtual environment or Conda environment either way. The requirements file includes torch, torchaudio, transformers, accelerate, librosa, nltk, pydub, and a direct Git dependency on resemble-ai/monotonic_align, which is not a stack you want to install into system Python.

Then comes the macOS gap. The README's demo instructions say:

pip install phonemizer sudo apt-get install espeak-ng

StyleTTS 2 README, Pre-requisites section, checked 2026-10-19

The second command is Debian and Ubuntu syntax, not macOS. In issue #114 the maintainer tells a Mac user to install espeak through Homebrew if they only want inference, and a contributor suggests setting PHONEMIZER_ESPEAK_PATH to the installation and PHONEMIZER_ESPEAK_LIBRARY to the binary when the Python package cannot find it. Other commenters in the same thread say Homebrew's espeak did not work for them and used MacPorts instead, so treat Homebrew as the first thing to try, not a guarantee. That thread is the closest thing to official macOS guidance in the project, and it is a comment thread, not a documented support statement.

The PyPI route is one command plus a short script. The package page documents this pattern:

pip install styletts2 from styletts2 import tts my_tts = tts.StyleTTS2() out = my_tts.inference("Hello there, I am now a python package.", output_wav_file="test.wav")

PyPI styletts2 0.1.6 project description, checked 2026-10-19

The same page lists a macOS-specific failure: an ImportError caused by an incompatible architecture for pycrfsuite, which comes in through gruut. Its suggested fix is to install python-crfsuite from conda-forge in a Conda environment, or to add a different phoneme converter through the abstraction in phoneme.py. If you hit that error on pip alone, the Conda route is the one the package author documents.

Metal acceleration is not in the main branch. The macOS and Metal tracking issue is #114, opened in November 2023 and still open. Users report that MPS is detected but not usable, and later comments describe local branches that made it work. In February 2026 a contributor opened pull request #358 with an inference script that keeps the text encoder on CPU because MPS does not support pack_padded_sequence, runs the other modules on MPS, and adds an optional fp16 decoder. The PR reports faster inference than CPU on an M2 MacBook Air. It is open, not merged. Treat MPS as an experiment you maintain yourself, not a supported feature you can rely on for a deadline.

If you stay on CPU, the README has one relevant note: high-pitched background noise on some older GPUs is a floating point difference, and doing inference on CPUs avoids it. That does not tell you how fast CPU inference will be on your Mac. Time a representative paragraph before you plan a long session.

What can go wrong

• Phonemizer cannot find espeak on macOS. The README installs it with apt, which does not exist on a Mac. Use the Homebrew path and the environment variables described in issue #114.
• The PyPI package fails at import with a pycrfsuite architecture error. The package page recommends installing python-crfsuite from conda-forge or swapping the phoneme converter.
• MPS is detected but not usable. The main branch has no Apple Silicon GPU support, and the open PR that adds it is not merged.
• The multispeaker demo fails because reference_audio.zip was never downloaded and unzipped under the demo folder.
• Long text is not handled cleanly by the demo notebooks. The NeuralVox fork notes that only its multispeaker tab supports long text and points to a splitting workaround.
• The GPL phonemizer makes redistribution a licensing decision, not just a packaging decision.
• Non-English training is limited by PL-BERT. The README says the English PL-BERT probably does not work well for other languages and points to a multilingual replacement.
• Training can produce NaN loss or run out of memory. The README ties both to batch size and max_len and recommends specific workarounds.
• The DDP path for second stage training is documented as not working, and the repository asks for help rather than claiming a fix.

Should you run it yourself?

Use this table as a first filter. It is about fit, not about which model sounds best, because quality depends on the checkpoint, the reference audio, and your script.

Run it yourself if the research pipeline is the point, if you need to fine-tune on your own licensed recordings, or if you specifically want the LibriTTS zero-shot behavior and can own the GPL and consent questions. Skip it if you want a supported Metal path, a clean commercial license without reading three documents, or a finished editor. The studio versus DIY comparison covers that trade in more detail.

Where Murmur fits, and where it does not

Murmur is a local voice studio for Apple Silicon and Intel Macs running macOS 15 or later. Kokoro is bundled, so the first voice works without a model download, and the app handles scripts, multiple speakers, takes, and export in one place. It also ships Chatterbox Turbo, Chatterbox Multilingual, Qwen3-TTS Base, Voice Design, SparkTTS, Fish Audio S2 Pro, Breeze TTS 2, and OmniVoice. StyleTTS 2 is not on that list, and no setting in the app will make it appear.

The Kokoro connection is worth stating carefully, because it is often overstated. The Kokoro model card lists StyleTTS 2 as its architecture, names the StyleTTS 2 paper, and lists yl4579/StyleTTS2-LJSpeech as its base model. It also says the released model is decoder only, with no diffusion and no encoder release. So Kokoro descends from the StyleTTS 2 line, but it is not the diffusion model described in the paper, and it is not a drop-in replacement for the LibriTTS checkpoint. If you want the actual StyleTTS 2 style sampling behavior, use the actual project.

Murmur costs $49 one-time, with a free plan and a 3-day Pro trial, and a 7-day refund policy. It is not the right choice if you need Windows, live streaming, speech to text, or cloud collaboration. It is the right choice if you want local generation, a fixed price, and an app that manages the model stack for you. The Kokoro on Mac guide covers the bundled model, and the local TTS model guide compares the wider field.

Frequently asked questions