Bark User Guide

Bark is a transformer-based text-to-audio model from Suno. You give it text, and it generates highly realistic, multilingual speech — plus things most speech models can't do: laughter, sighs, singing, music, sound effects, and background noise. It runs entirely on your own machine using pretrained model checkpoints that download automatically the first time you use them.

This guide shows you how to install Bark, generate your first audio, steer the voice and emotion of the output, work in 13 languages, and solve the problems people hit most often.

Note

Bark is a fully generative text-to-audio model, not a conventional text-to-speech engine. It converts text directly to audio with no intermediate phoneme step, so it can take creative liberties and occasionally deviate from your prompt. This is by design — see Why does the output differ from my prompt?.

1. Quick Start

Generate your first audio clip in three steps.

Step 1 — Install Bark

pip install git+https://github.com/suno-ai/bark.git

Caution

Do NOT run pip install bark. That installs a completely different, unrelated package that is not maintained by Suno. Always install from the GitHub URL above (or from a clone — see Installation).

Step 2 — Generate audio in Python

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

# Download and load all models (first run only — downloads several GB)
preload_models()

# Generate audio from text
text_prompt = "Hello, my name is Suno. And, uh — and I like pizza. [laughs]"
audio_array = generate_audio(text_prompt)

# Save the result to disk
write_wav("bark_generation.wav", SAMPLE_RATE, audio_array)

Done! bark_generation.wav written at 24 kHz.

Step 3 — Or generate from the command line

python -m bark --text "Hello, my name is Suno." --output_filename "example.wav"

Done! Output audio file is saved at: './example.wav'

Important

The first call to preload_models() (or the first CLI run) downloads the model checkpoints from Hugging Face into ~/.cache/suno/bark_v0. This is a one-time download of several gigabytes. Subsequent runs load from cache and start almost immediately.

Tip

All audio Bark produces is a NumPy array sampled at 24 kHz. Always use the exported SAMPLE_RATE constant (24000) when saving or playing audio so the pitch and speed are correct.

2. Installation

Requirements

Bark's core dependencies (torch, transformers, encodec, huggingface-hub, scipy, numpy, funcy, tqdm, tokenizers) are installed automatically.

Installation methods

pip + Git (recommended)

pip install git+https://github.com/suno-ai/bark.git

Clone and install

git clone https://github.com/suno-ai/bark
cd bark && pip install .

Hugging Face Transformers

Bark is also available inside the 🤗 Transformers library (v4.31.0+) with a different API:

pip install git+https://github.com/huggingface/transformers.git

See Using Bark through Hugging Face Transformers.

Warning

The package name on PyPI (suno-bark) is not the same as bark. Installing the plain bark package will pull in unrelated code. Use the Git install or a local clone.

Verify the installation

import bark
from bark import generate_audio, preload_models, SAMPLE_RATE
print("Bark imported OK — sample rate:", SAMPLE_RATE)

Bark imported OK — sample rate: 24000

3. Generating Audio

The single function you will use most is generate_audio().

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

audio_array = generate_audio("It was a dark and stormy night.")
write_wav("story.wav", SAMPLE_RATE, audio_array)

generate_audio() parameters

Tip

Lower the temperatures (e.g. text_temp=0.5, waveform_temp=0.5) when you want steadier, more predictable narration. Raise them toward 1.0 for more expressive, varied delivery.

Returning the full generation

Set output_full=True to receive both the generation data and the audio. The first element can be saved and reused as a voice prompt for consistency across clips (see Long-Form Audio).

full_generation, audio_array = generate_audio(
    "I will narrate the next several chapters.",
    output_full=True,
)

Note

By default generate_audio works best with about 13 seconds of spoken text per call. For longer content, chain calls — see Long-Form and Consistent Voices.

4. Command-Line Interface

Bark ships a small CLI invoked with python -m bark. It wraps generate_audio() and writes a .wav file.

python -m bark --text "Welcome to the show." --output_filename "intro.wav" --output_dir "./clips"

Done! Output audio file is saved at: './clips/intro.wav'

CLI options

Example: CLI with a voice preset

python -m bark \
  --text "I have a silky smooth voice." \
  --history_prompt "v2/en_speaker_1" \
  --output_filename "smooth.wav"

Warning

The --silent and --output_full flags use Python's type=bool parsing, which treats any non-empty value as True. That means --silent False actually enables silent mode, because the string "False" is truthy. To leave these flags off, simply omit them. Pass --silent True (or --silent anything) to turn the flag on.

5. Choosing a Voice (Voice Presets)

By default Bark picks a voice that fits your text, and it can pick a different one each run. To get a consistent, known voice, pass a voice preset via history_prompt.

audio_array = generate_audio(
    "Today I will tell you about the exercise regimen of the common sloth.",
    history_prompt="v2/en_speaker_1",
)

Available presets

Bark bundles 100+ speaker presets. Preset names follow these patterns:

{lang} is one of the 13 supported language codes (en, de, es, fr, hi, it, ja, ko, pl, pt, ru, tr, zh). The bundled presets live in bark/assets/prompts/ (originals) and bark/assets/prompts/v2/ (v2).

Tip

Prefer the v2/ presets — they are better engineered to follow your text with a consistent voice. For example, use v2/en_speaker_6 rather than en_speaker_6.

Note

Bark matches the tone, pitch, emotion, and prosody of a preset, and tries to preserve music and ambient characteristics. It does not currently support custom voice cloning from your own recordings.

Using your own saved prompt

A history_prompt can also be a path to a .npz file you previously saved (see Long-Form and Consistent Voices):

audio_array = generate_audio("Continuing the story...", history_prompt="my_voice.npz")

6. Long-Form and Consistent Voices

A single generate_audio call targets ~13 seconds of audio. To produce longer content with a stable voice, generate the first segment with output_full=True, save that generation as a prompt, and feed it back into the next segment.

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

sentences = [
    "Chapter one. The morning began quietly.",
    "By noon, everything had changed.",
    "And so the adventure truly began.",
]

# Generate the first segment and capture its full generation
full_generation, first_audio = generate_audio(sentences[0], output_full=True)

# Reuse that generation as the voice prompt for the remaining segments
pieces = [first_audio]
for line in sentences[1:]:
    audio = generate_audio(line, history_prompt=full_generation)
    pieces.append(audio)

# Concatenate and save
combined = np.concatenate(pieces)
write_wav("long_form.wav", SAMPLE_RATE, combined)

Saving a voice for later

Use save_as_prompt() to persist a full generation to a .npz file you can reuse across sessions:

from bark import save_as_prompt

full_generation, audio = generate_audio("My narrator voice.", output_full=True)
save_as_prompt("narrator.npz", full_generation)

# Later, in another script:
audio2 = generate_audio("Picking up where we left off.", history_prompt="narrator.npz")

Important

save_as_prompt() requires the file path to end in .npz and the generation to contain the keys semantic_prompt, coarse_prompt, and fine_prompt — exactly the dict you get from output_full=True. Passing anything else raises an assertion error.

Tip

Worked examples of long-form generation, voice consistency, and running on CPU live in the repository's notebooks/ folder: long_form_generation.ipynb, use_small_models_on_cpu.ipynb, and memory_profiling_bark.ipynb.

7. Expressive Audio: Sounds, Music, and Emphasis

Because Bark generates audio rather than reading text literally, you can embed special cues directly in your text to produce nonverbal sounds, singing, and emphasis.

Nonverbal and special tokens

# Speech with nonverbal sounds
generate_audio("I can't believe it [laughs] — that's incredible!")

# Singing
generate_audio("♪ In the jungle, the mighty jungle, the lion barks tonight ♪")

# Emphasis and a hesitation
generate_audio("This is REALLY important... so listen carefully.")

Note

This list is not exhaustive — Bark can produce many nonverbal sounds, and new working patterns are discovered regularly. The community shares effective prompts in the project's Discord #audio-prompts channel.

Generating music

Bark doesn't strictly distinguish speech from music. To nudge it toward singing, wrap lyrics in music notes (♪). Results vary — Bark may still choose to speak lyrics rather than sing them.

Tip

For dedicated text-to-music generation, Bark is not the right tool. Suno's music models live on the Suno web app, separate from this repository.

8. Foreign Languages

Bark automatically detects the language from your input text — you don't specify it explicitly.

# Korean — detected automatically
generate_audio("추석은 내가 가장 좋아하는 명절이다.")

# German
generate_audio("Der Dreißigjährige Krieg war ein verheerender Konflikt.")

Supported languages

Note

English quality is best at the moment; other languages continue to improve. Because language is auto-detected, you can deliberately mix a non-English voice preset with English text to get an accented English voice — for example, a German history prompt with English text usually yields English audio with a German accent.

Tip

To pin the accent/voice for a given language, combine auto-detection with a matching v2/{lang}_speaker_{n} preset, e.g. history_prompt="v2/de_speaker_3" for German.

9. Running on Limited Hardware

Bark runs on modest GPUs and even CPU-only machines if you enable the right options. These are controlled by environment variables, set before importing Bark.

Low-VRAM recipe (down to ~2 GB)

import os
os.environ["SUNO_OFFLOAD_CPU"] = "True"
os.environ["SUNO_USE_SMALL_MODELS"] = "True"

from bark import generate_audio, preload_models, SAMPLE_RATE
preload_models()
audio_array = generate_audio("Running on a small GPU.")

Important

Set these environment variables before the from bark import ... line. They are read when the bark.generation module is first imported; setting them afterward has no effect within the same process.

Tip

On Apple Silicon, set SUNO_ENABLE_MPS=True. Note that the EnCodec audio codec step does not support MPS and automatically falls back to CPU — this is expected.

Warning

If no GPU is detected, Bark prints No GPU being used. Careful, inference might be very slow! and runs on CPU. CPU inference works but can be many times slower than GPU.

10. Using Bark Through Hugging Face Transformers

Bark is also integrated into the 🤗 Transformers library (v4.31.0+), which offers a different, model-object-style API.

from transformers import AutoProcessor, BarkModel

processor = AutoProcessor.from_pretrained("suno/bark")
model = BarkModel.from_pretrained("suno/bark")

voice_preset = "v2/en_speaker_6"
inputs = processor("Hello, my dog is cute", voice_preset=voice_preset)

audio_array = model.generate(**inputs)
audio_array = audio_array.cpu().numpy().squeeze()

Save the result with the model's own sample rate:

import scipy
sample_rate = model.generation_config.sample_rate
scipy.io.wavfile.write("bark_out.wav", rate=sample_rate, data=audio_array)

Note

The Transformers integration is a separate code path from this repository's bark package. Use whichever fits your stack. For full details, see the Bark page in the Transformers docs.

11. Troubleshooting

Error: history prompt not found

• Cause: You passed a history_prompt preset name that isn't one of the bundled presets (e.g. a typo, or a name outside the {lang}_speaker_{0–9} / v2/... / announcer set).
• Solution: Use a valid preset name (see Choosing a Voice), or pass a path to a real .npz file.
• Prevention: Stick to the documented preset patterns; remember preset names are case-sensitive and use the v2/ prefix for v2 voices.

Error: history prompt format unrecognized

• Cause: The history_prompt value was neither a .npz path, a known preset name, nor a valid generation dict.
• Solution: Pass a string ending in .npz, a preset name, or the dict returned by generate_audio(..., output_full=True).
• Prevention: Reuse the exact full_generation dict from output_full=True, or save it with save_as_prompt() and pass that file path.

Error: extra keys found: {...} / missing keys: {...}

• Cause: A model checkpoint doesn't match the expected model architecture (corrupt, partial, or wrong-version download).
• Solution: Force a fresh download by clearing the cache directory ~/.cache/suno/bark_v0 (or call preload_models(force_reload=True)), then retry.
• Prevention: Let the first run complete its download fully before interrupting.

Warning: warning, text too long, lopping of last X%

• Cause: Your text exceeds the model's ~256-token text window for a single call, so the end is truncated.
• Solution: Split long text into shorter segments and chain them — see Long-Form and Consistent Voices.
• Prevention: Keep each generate_audio call to roughly one or two sentences (~13 seconds of speech).

Problem: Checkpoint fails to load on newer PyTorch (weights-only error)

• Cause: PyTorch 2.6+ changed torch.load to default to weights_only=True, which can reject Bark's checkpoint format. Reported in issues #656 and #626.
• Solution: Use a PyTorch version known to work with Bark (2.0–2.5), or apply the workaround discussed in the linked issues.
• Prevention: Pin your torch version in your environment when relying on Bark's bundled loader.

Problem: Where are models downloaded, and how do I change it?

• Cause: Bark caches models under ~/.cache/suno/bark_v0, derived from the Hugging Face cache. Reported as a question in #341.
• Solution: Set the standard Hugging Face cache environment variable (HF_HOME) — or XDG_CACHE_HOME — before importing Bark to relocate downloads. See How do I change the model download location?.
• Prevention: Set the cache location once in your environment so all runs share the same model files.

Problem: Audio sounds low-fidelity, like an old phone call

• Cause: Bark generates audio from scratch and is not constrained to studio-quality speech; outputs vary in fidelity.
• Solution: Try a different (or v2/) voice preset, lower the temperatures for steadier output, and regenerate — results vary per run.
• Prevention: Use v2/ presets and moderate temperatures for the most consistent quality.

Problem: Generation is extremely slow

• Cause: Running on CPU, or on a GPU without the optimizations.
• Solution: Use a CUDA-capable GPU, upgrade to a recent PyTorch (2.0+) for flash attention, and/or enable SUNO_USE_SMALL_MODELS=True.
• Prevention: Confirm a GPU is detected — if you see No GPU being used, Bark is on CPU.

Problem: ModuleNotFoundError or dependency conflicts during install

• Cause: A broken Python build or conflicting torch/torchvision versions (e.g. issues #543, #292).
• Solution: Install Bark in a fresh virtual environment and let it resolve its own dependency set.
• Prevention: Avoid mixing Bark into an environment with pinned, incompatible torch versions.

12. Frequently Asked Questions

Q: How do I change where models are downloaded and cached?

Bark uses Hugging Face to download and store models, defaulting to ~/.cache/suno/bark_v0. Set the standard Hugging Face environment variable HF_HOME (or XDG_CACHE_HOME) before importing Bark to relocate the cache. See the Hugging Face environment variables docs.

Q: Why does the output differ from my prompt?

Bark is a GPT-style generative model. Like other generative models, it may take creative liberties, producing higher-variance output than traditional text-to-speech. Lower the temperatures (text_temp, waveform_temp) for steadier results.

Q: What voices are supported?

100+ speaker presets across the 13 supported languages, plus a special announcer voice. Bark can also generate unique random voices that fit your text. It does not currently support custom voice cloning.

Q: Why is output limited to about 13–14 seconds?

Bark's architecture and context window are optimized for generations of roughly this length. For longer audio, chain calls using a saved history prompt — see Long-Form and Consistent Voices.

Q: How much VRAM do I need?

The full models need about 12 GB of GPU memory to hold everything at once. Smaller cards — down to ~2 GB — work by combining SUNO_OFFLOAD_CPU=True and SUNO_USE_SMALL_MODELS=True.

Q: Can Bark generate music?

Bark can produce singing and musical sounds (wrap lyrics in ♪), but it is a text-to-audio model, not a dedicated music generator. For music, use Suno's music models on the web app.

Q: Can I use Bark commercially?

Yes. As of the 2023-05-01 update Bark is released under the MIT License, which permits commercial use. Pretrained checkpoints are provided for inference and commercial use.

Q: Does Bark do voice cloning?

No. Bark matches the tone, pitch, and prosody of a built-in preset, but it does not currently support cloning a voice from your own audio.

Q: How do I keep the same voice across multiple clips?

Generate the first clip with output_full=True, then pass the returned generation (or a .npz saved with save_as_prompt()) as the history_prompt for subsequent clips.

13. Quick Reference

Top-level API (from bark import ...)

CLI

python -m bark --text "..." [--output_filename NAME] [--output_dir DIR] \
  [--history_prompt PRESET_OR_PATH] [--text_temp 0.7] [--waveform_temp 0.7] \
  [--silent] [--output_full]

Environment variables

Text cues

[laughter] [laughs] [sighs] [music] [gasps] [clears throat] · — / ... pauses · ♪ lyrics ♪ · CAPS emphasis · [MAN] / [WOMAN] speaker bias

Key facts