Bark

Last reviewed Aug 26, 2026 · 883 words

Bark is not a text-to-speech engine in the sense that Piper or Kokoro are; it is a text-to-audio model, and that distinction decides whether you will be happy with it. Give it "[laughs] I can't believe it worked" and it laughs, then speaks. Wrap a line in music notes and it sings, badly, with something like an accompaniment. Ask it to read a 2,000-word article and you hit the model's hard limit of roughly 13 seconds of audio per generation, plus a voice that drifts between chunks. Suno released it under MIT in 2023, it sits at 39,247 GitHub stars, and the full models want a CUDA GPU with about 12 GB of VRAM. I run it for sound design and expressive one-liners. For anything that has to read paragraphs reliably, I run something else.

13 seconds is a model limit, not a setting

Bark's three-stage transformer (text to semantic tokens, semantic to coarse acoustic tokens, coarse to fine) was trained on short clips, and the semantic stage caps output at about 13 to 14 seconds. Longer prompts get cut off mid-word. The workaround everyone lands on is splitting text into sentences, generating each with the same speaker preset, and concatenating with a short silence:

import numpy as np
from bark import SAMPLE_RATE, generate_audio, preload_models
from scipy.io.wavfile import write as write_wav

preload_models()
sentences = ["First sentence.", "Second one, [sighs] slightly tired."]
pieces = []
for s in sentences:
    pieces.append(generate_audio(s, history_prompt="v2/en_speaker_6"))
    pieces.append(np.zeros(int(0.25 * SAMPLE_RATE)))
write_wav("out.wav", SAMPLE_RATE, np.concatenate(pieces))

Output is 24 kHz mono. Expect each clip to take a few seconds on a modern GPU and minutes on CPU, so a 5-minute narration is a coffee break, not an API call.

The bracket tokens are the actual product

Everything that makes Bark worth running lives inside square brackets and music notes. [laughter], [laughs], [sighs], [gasps], [clears throat], [music], and ♪ around lyrics all steer the model; capitalised words get emphasis and ... produces a hesitation. None of this exists in a conventional TTS engine, and it is why Bark still gets pulled out for game dialogue, podcast stings, and prototypes of characters who need to sound like they have lungs. The README is candid that some prompts produce non-speech sounds, music, or nothing recognisable at all. That is not a bug you can file; it is the sampling distribution, and re-rolling the seed is the fix.

Same preset, different voice: the consistency problem

history_prompt="v2/en_speaker_6" selects one of the shipped presets, numbered 0 through 9 for each of the 13 supported languages. Presets keep the timbre in the same neighbourhood, but every generation is a sample, so tone, pace, and sometimes accent move between runs. For a single expressive clip that is charming. For a 40-clip narration it means auditioning takes and discarding a third of them. Bark does not officially support cloning a voice from your own sample, and the community forks that add it produce results ranging from fine to haunted. If voice consistency is the requirement, Kokoro gives you the same voice every time on a fraction of the hardware.

VRAM: 12 GB full, small models under 8, CPU if you must

Two environment variables change the hardware bill:

export SUNO_USE_SMALL_MODELS=True   # smaller text/coarse/fine models, lower quality
export SUNO_OFFLOAD_CPU=True        # keep only the active stage on the GPU

With both set, an 8 GB card works and the fine stage still sounds acceptable; the small text model is where quality falls off, with more mangled words and more prompts that wander. CPU-only works and is how I first tried it, but budget around 10x real time with the small models, and treat the catalogue's 8 GB of system RAM as a real floor rather than a suggestion. First run downloads the checkpoints from Hugging Face into ~/.cache/suno/bark_v0, several gigabytes, so do it on a machine with disk to spare.

Where it stands in 2026

The repository has been quiet since 2023; there is no release cadence to track and no server component to expose. It installs with pip install git+https://github.com/suno-ai/bark.git into a Python environment, and the catalogue's "Jupyter Notebook" language tag is honest about how it is mostly used. Against ElevenLabs the argument is price and privacy: unlimited generations on hardware you own, no script leaving the building. Against the newer local models, the argument is narrower. Piper reads paragraphs on a Raspberry Pi; Kokoro reads them well on a laptop CPU; Bark is the one that laughs.

What I'd do

Install it in its own venv on a machine with a 12 GB card, generate with v2/en_speaker_6 and the sentence-splitting loop above, and use it for what it is uniquely good at: nonverbal sounds, sung fragments, character lines that need emotion. For narration, podcasts, or anything a listener will sit through for more than a minute, put Kokoro or Piper in the pipeline and keep Bark for the stings. If you have one GPU and one weekend, that second setup is the one that ships.