★ Reading this for free? Get 25 structured AI courses + per-chapter AI tutor — the first chapter of every course free, no card.Start free in 30 secondsOr own every course: $149 once

Bark by Suno AI: Text-to-Audio Generation

Model released: April 2023 | Updated: November 2, 2026

Open-source generative model for speech, music, and sound effects. MIT license, 13 languages, 3-stage autoregressive transformer pipeline.

Bark Audio Generation Overview

•Type: Text-to-audio generative model (NOT an LLM)
•Creator: Suno AI | Released April 2023
•License: MIT (fully open source, commercial OK)
•Output: Speech, music, laughter, sound effects
•Languages: 13 (EN, ZH, FR, DE, HI, IT, JA, KO, PL, PT, RU, ES, TR)
•Sample Rate: 24kHz output
•Architecture: GPT-2-like autoregressive + EnCodec
•Install: pip install git+https://github.com/suno-ai/bark.git

Bark 3-Stage Audio Generation Pipeline

Text input flows through semantic token generation, coarse acoustic modeling, and fine acoustic synthesis to produce audio

👤
You
💻
Your ComputerAI Processing
👤
🌐
🏢
Cloud AI: You → Internet → Company Servers

Architecture: 3-Stage Autoregressive Pipeline

Bark uses a 3-stage autoregressive transformer pipeline inspired by AudioLM and VALL-E. Unlike traditional TTS systems that use a text-to-mel spectrogram followed by a vocoder, Bark operates entirely in the discrete token space using Meta's EnCodec for audio tokenization. Each stage is a separate GPT-2-style transformer model.

Stage 1: Semantic Tokens

Text input is converted to semantic tokens using a GPT-2-like autoregressive model. These tokens capture the linguistic content, prosody, and speaker identity.

Input: text + optional speaker history

Output: semantic token sequence

Stage 2: Coarse Acoustic

Semantic tokens are mapped to coarse EnCodec acoustic tokens. This stage determines the overall audio characteristics, timbre, and acoustic environment.

Input: semantic tokens

Output: first 2 EnCodec codebook levels

Stage 3: Fine Acoustic

Coarse tokens are refined to full EnCodec resolution (8 codebook levels). The fine acoustic model adds high-frequency detail and audio fidelity to the output.

Input: coarse acoustic tokens

Output: full 8-level EnCodec tokens, decoded to 24kHz audio

Key Technical Details

  • • Audio codec: Meta's EnCodec with 8 codebook levels at 24kHz
  • • Semantic encoder: Based on HuBERT-like self-supervised audio representation
  • • Generation: Autoregressive (token-by-token), not diffusion-based
  • • Speaker conditioning: Via speaker prompt embeddings (not fine-tuning)
  • • Non-speech sounds: Triggered by text tags like [laughter], [sighs], [music], [gasps]

Installation & Python Setup

Important: Bark is NOT on Ollama

Bark is a text-to-audio model, not a large language model. It cannot be installed via Ollama. You must install it as a Python package using pip. Bark is used through Python code, not a chat interface.

Bark is installed via pip directly from the GitHub repository or through HuggingFace Transformers. The installation pulls the model weights automatically on first use (~5GB download). You need Python 3.8+ and PyTorch installed.

Terminal
$pip install git+https://github.com/suno-ai/bark.git
Collecting bark Cloning https://github.com/suno-ai/bark.git Installing build dependencies... done Successfully installed bark-0.1.5 encodec-0.1.1 funcy-2.0
$python3 -c "from bark import SAMPLE_RATE, generate_audio, preload_models; preload_models(); print(f'Bark loaded. Sample rate: {SAMPLE_RATE}Hz')"
Downloading semantic model... done Downloading coarse model... done Downloading fine model... done Bark loaded. Sample rate: 24000Hz
$_
1

Install Python & PyTorch

Ensure Python 3.8+ and PyTorch with CUDA support are installed

$ pip install torch torchaudio --index-url https://download.pytorch.org/whl/cu118
2

Install Bark from GitHub

Clone and install Bark directly from Suno AI repository

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

Verify Installation (Python)

Test basic speech generation in Python

$ python3 -c "from bark import generate_audio, preload_models; preload_models(); print('Bark ready!')"
4

Generate Your First Audio

Run a complete speech generation example

$ python3 -c "from bark import generate_audio, SAMPLE_RATE; import scipy; audio = generate_audio('Hello, I am Bark! [laughs]'); scipy.io.wavfile.write('output.wav', SAMPLE_RATE, audio)"
5

Use Speaker Presets

Generate with a specific speaker voice preset

$ python3 -c "from bark import generate_audio, SAMPLE_RATE; import scipy; audio = generate_audio('Bonjour le monde!', history_prompt='v2/fr_speaker_1'); scipy.io.wavfile.write('french.wav', SAMPLE_RATE, audio)"
6

Optional: Use via HuggingFace Transformers

Alternative installation through Transformers library

$ pip install transformers scipy

Complete Python Usage Example

from bark import SAMPLE_RATE, generate_audio, preload_models
import scipy
import numpy as np

# Load all 3 model stages into memory
preload_models()

# Basic speech generation
text = "Hello, my name is Bark. [laughs] I can generate speech, music, and sound effects!"
audio_array = generate_audio(text)
scipy.io.wavfile.write("hello.wav", SAMPLE_RATE, audio_array)

# Use a specific speaker preset
audio_array = generate_audio(
    "This is a different voice speaking.",
    history_prompt="v2/en_speaker_6"
)
scipy.io.wavfile.write("speaker6.wav", SAMPLE_RATE, audio_array)

# Generate in another language (Japanese)
audio_jp = generate_audio(
    "こんにちは世界",
    history_prompt="v2/ja_speaker_0"
)
scipy.io.wavfile.write("japanese.wav", SAMPLE_RATE, audio_jp)

# Generate with non-speech sounds
audio_mixed = generate_audio(
    "[clears throat] Welcome to the show! [music] And now, our feature presentation."
)
scipy.io.wavfile.write("mixed.wav", SAMPLE_RATE, audio_mixed)

# Long-form generation (segment by segment)
sentences = [
    "This is the first sentence of a longer passage.",
    "Bark works best with shorter text segments.",
    "Each segment is generated independently and concatenated."
]
audio_segments = [generate_audio(s) for s in sentences]
full_audio = np.concatenate(audio_segments)
scipy.io.wavfile.write("longform.wav", SAMPLE_RATE, full_audio)

VRAM & Hardware Requirements

Bark's memory requirements depend on the model size and whether you use GPU or CPU mode. Suno's README says the full version needs around 12GB of VRAM to hold everything on the GPU at once; the small models (SUNO_USE_SMALL_MODELS=True) should fit into 8GB; and with CPU offloading (SUNO_OFFLOAD_CPU=True) cards down to about 2GB work, more slowly. CPU-only mode is possible but significantly slower.

System Requirements

▸
Operating System
Windows 10/11, macOS 12+, Ubuntu 20.04+
▸
RAM
8GB minimum (CPU mode), 16GB recommended
▸
Storage
5GB for model weights + workspace
▸
GPU
NVIDIA GPU: ~12GB for the full models, 8GB with small models, ~2GB with CPU offload (Suno README)
▸
CPU
4+ cores; CPU-only mode is significantly slower than GPU (Suno README)

VRAM needed, GB (Suno README figures)

Bark full models (GPU)12 VRAM (GB)
12
Bark small models (GPU)8 VRAM (GB)
8
Bark with CPU offload2 VRAM (GB)
2

Environment Variables for Optimization

# Use small model (saves VRAM, slightly lower quality)
export SUNO_USE_SMALL_MODELS=True

# Force CPU mode (no GPU required, but slow)
export SUNO_OFFLOAD_CPU=True

# Enable half precision on GPU (reduces VRAM ~40%)
export SUNO_ENABLE_MPS=True  # for Apple Silicon Macs

# Custom cache directory for model weights
export XDG_CACHE_HOME=/path/to/cache

Supported Languages & Speaker Presets

Bark supports 13 languages, each with 10 speaker presets (speaker_0 through speaker_9). Speaker presets control voice characteristics like pitch, speaking rate, and timbre. Note that these are NOT voice clones of real people -- they are learned speaker embeddings from the training data.

LanguagePreset PrefixStatus (Suno README)Notes
Englishv2/en_speaker_0-9SupportedSuno: "English quality is best for the time being"
Chinese (Simplified)v2/zh_speaker_0-9SupportedMandarin Chinese
Frenchv2/fr_speaker_0-9Supportedv2/fr_speaker_0 is one of the 10 French presets
Germanv2/de_speaker_0-9SupportedStandard German
Hindiv2/hi_speaker_0-9SupportedDevanagari script
Italianv2/it_speaker_0-9Supported
Japanesev2/ja_speaker_0-9SupportedKanji, hiragana and katakana input
Koreanv2/ko_speaker_0-9SupportedHangul input
Polishv2/pl_speaker_0-9Supported
Portuguesev2/pt_speaker_0-9Supported
Russianv2/ru_speaker_0-9SupportedCyrillic input
Spanishv2/es_speaker_0-9Supported
Turkishv2/tr_speaker_0-9Supported

Non-Speech Sound Tags

Bark can generate non-verbal sounds when you include special tags in your text prompt:

• [laughter] - generates laughter

• [laughs] - shorter laugh variant

• [sighs] - generates a sigh

• [gasps] - generates a gasp

• [clears throat] - throat clearing sound

• [music] - generates music

• ... - hesitation/pause

• CAPITALIZED - emphasis

Audio Quality & MOS Benchmarks

Speech quality is usually reported as a Mean Opinion Score (MOS), where human listeners rate naturalness on a 1-5 scale. Suno has not published a MOS, or any other quality score, for Bark, and this site has not run a listening test, so any single MOS figure you see quoted for Bark is not from its makers. What Suno does say: English is its best language, output varies between runs of the same prompt, and the model can add laughter, music and other non-speech sounds that conventional TTS cannot.

MOS Score Context

  • • 5.0: Indistinguishable from real human speech
  • • 4.0-4.5: High quality, minor artifacts occasionally (commercial systems)
  • • 3.5-4.0: Good quality, some noticeable artifacts
  • • 3.0-3.5: Acceptable quality, clear synthesis artifacts
  • • Below 3.0: Low quality, robotic sounding

What the README documents

  • • 13 supported languages, detected automatically from the text
  • • 100+ speaker presets across those languages
  • • Non-speech cues such as [laughter], [sighs], [music] and [MAN]/[WOMAN]
  • • About 13 seconds of speech per generate_audio call

What it does not publish

  • • No MOS or word-error-rate scores
  • • No per-language quality ranking beyond “English is best”
  • • No speed table; only “roughly real-time” on enterprise GPUs

Audio Output Specifications

• Sample rate: 24,000 Hz (24kHz)

• Bit depth: 32-bit float (numpy array)

• Channels: Mono

• Codec: EnCodec-based token decoding

• Max segment: ~13 seconds per generation

• Speed (GPU): roughly real-time on enterprise GPUs with PyTorch nightly (Suno); slower on consumer and older cards

• Speed (CPU): “significantly slower” (Suno); small models help

• Output format: numpy array (save as WAV/MP3 via scipy/librosa)

Non-Speech Audio: Music & Sound Effects

One of Bark's most distinctive features is its ability to generate non-speech audio alongside speech. By including special tags in text prompts, Bark can produce laughter, sighs, music snippets, and other sound effects. This is a direct result of its generative training on diverse audio data, not a separate model.

Terminal
$python3 generate_music.py
from bark import generate_audio, SAMPLE_RATE import scipy # Music generation via text prompt audio = generate_audio("♪ [music] A gentle piano melody plays softly ♪") scipy.io.wavfile.write("music_sample.wav", SAMPLE_RATE, audio) # Output: 24kHz WAV file with generated music (~13s max)
$python3 generate_effects.py
# Sound effects with speech audio = generate_audio( "[clears throat] Good morning everyone! [laughter] " "Today is going to be a great day... [sighs] " "or maybe not. [gasps] What was that noise?" ) scipy.io.wavfile.write("effects_demo.wav", SAMPLE_RATE, audio) # Non-speech sounds are generated inline with speech
$_

Honest Note on Music Generation

Bark can generate short music snippets and musical sounds, but it is not a dedicated music generation model. For high-quality music generation, dedicated models like Meta's MusicGen, Riffusion, or Suno's own v3 music platform are significantly better. Bark's music capability is best used for short intros, background ambiance, and mixed speech+music content.

Local TTS Alternatives Comparison

Bark is one of several open-source TTS options for local deployment. Each has distinct strengths. Bark excels at non-speech audio and multilingual generation, while alternatives like Piper TTS offer real-time speed and XTTS v2 provides voice cloning. Here is an honest comparison:

ModelStrongest atVoice cloningRuns onLicence
Bark (Suno)Speech plus laughter, music and other sounds; 13 languagesNo (speaker presets only)GPU: ~12GB full, 8GB small models (Suno)MIT
Coqui XTTS v2Multilingual voice cloning from a short reference clipYesGPU recommendedCoqui Public Model License (non-commercial)
Piper TTSFast, lightweight offline speechNoCPU, including Raspberry PiMIT
WhisperSpeechOpen TTS built by inverting WhisperYesGPU recommendedMIT
StyleTTS 2Very natural single-speaker EnglishLimitedGPU recommendedMIT (code)

No common quality score exists across these projects, so this table compares what each is built for rather than ranking them.

When to Choose Bark

Bark is a good choice when:

  • • You need non-speech sounds (laughter, music, effects)
  • • You need multilingual support (13 languages)
  • • You want MIT license for commercial use
  • • You are building prototypes or short-form content

Consider alternatives when:

  • • You need real-time streaming (use Piper TTS)
  • • You need voice cloning (use XTTS v2)
  • • You need studio-quality 44.1kHz output
  • • You need long-form consistent narration

Local TTS Model Selection Guide

Choose the right open-source TTS model based on your requirements: speed, quality, voice cloning, or non-speech audio

💻

Local AI

  • ✓100% Private
  • ✓$0 Monthly Fee
  • ✓Works Offline
  • ✓Unlimited Usage
☁️

Cloud AI

  • ✗Data Sent to Servers
  • ✗$20-100/Month
  • ✗Needs Internet
  • ✗Usage Limits

Honest Limitations

Known Limitations (March 2026)

1.
24kHz output only. Bark outputs at 24,000 Hz, below CD quality (44.1kHz) and broadcast standards. Not suitable for professional audio production without upsampling.
2.
No real-time streaming. Each generation takes 4-10 seconds on GPU. Not suitable for live applications, voice assistants, or real-time communication.
3.
Audio hallucinations. Bark can produce unexpected sounds, repeated words, or audio artifacts. Quality varies between generations even with the same input.
4.
Limited voice control. Only 10 preset speakers per language. No fine-grained control over pitch, speed, or emotion intensity compared to newer models.
5.
~13 second max per generation. Long-form content must be generated in segments and concatenated, which can cause voice inconsistency across segments.
6.
No active development. The Bark repository has not seen major updates since mid-2023. Newer models (XTTS v2, StyleTTS 2) have surpassed it in quality for speech-only use cases.

Where Bark Still Excels (2026)

  • • Non-speech audio generation -- few other open-source models can generate laughter, sighs, and music from text
  • • Multilingual breadth -- 13 languages with speaker presets out of the box
  • • MIT license -- fully permissive for commercial use, no restrictions
  • • Simplicity -- 3 lines of Python to generate audio, easy to integrate
  • • Historical significance -- pioneered the text-to-audio generative approach that influenced later models

Research Background & Technical Foundation

Bark's architecture draws from several influential research directions in neural audio generation. The 3-stage pipeline approach was inspired by AudioLM (Borsos et al., 2023), while the codec-based tokenization uses Meta's EnCodec. The autoregressive generation follows the GPT-2 paradigm applied to audio tokens.

Key Research Influences

Frequently Asked Questions

What is Bark and how does it differ from traditional TTS models?

Bark is a text-to-audio generative model by Suno AI, released in April 2023 under the MIT license. Unlike traditional TTS models that only produce speech, Bark can generate speech, music, laughter, sighs, and other sound effects from text prompts. It uses a 3-stage autoregressive transformer pipeline (semantic tokens, coarse acoustic tokens, fine acoustic tokens) based on EnCodec, rather than the vocoder approach used by most TTS systems.

What hardware do I need to run Bark locally?

Per Suno's README, the full version of Bark needs around 12GB of VRAM to hold everything on the GPU at once. Setting SUNO_USE_SMALL_MODELS=True loads smaller models that should fit into 8GB, and with CPU offloading enabled even ~2GB cards work, more slowly. Bark also runs on CPU only, much more slowly. An NVIDIA GPU with CUDA support is strongly recommended for practical generation speeds.

Is Bark available on Ollama?

No, Bark is NOT available on Ollama. Ollama is designed for large language models (LLMs), not audio generation models. Bark is installed as a Python package via pip: 'pip install git+https://github.com/suno-ai/bark.git'. It can also be used through the HuggingFace Transformers library. You interact with Bark through Python code, not through a chat interface.

What languages does Bark support?

Bark supports approximately 13 languages: English, Chinese (Simplified), French, German, Hindi, Italian, Japanese, Korean, Polish, Portuguese, Russian, Spanish, and Turkish. Each language has multiple speaker presets (e.g., v2/en_speaker_0 through v2/en_speaker_9 for English). Language quality varies, with English having the most robust support.

Can Bark clone voices?

Bark does not perform traditional voice cloning. Instead, it uses speaker embeddings (voice presets) to generate speech in different speaker styles. You can select from built-in presets like v2/en_speaker_0 through v2/en_speaker_9, each producing a distinct voice. While the community has experimented with custom speaker embeddings, Bark was not designed as a voice cloning tool.

What are Bark's main limitations in 2026?

Bark has several notable limitations: it outputs audio at 24kHz (not studio-quality 44.1kHz or 48kHz), it does not support real-time streaming, it has limited fine-grained voice control compared to newer models, and it can sometimes hallucinate audio artifacts or produce unexpected sounds. For long-form content, generation must be done in segments. Newer alternatives like XTTS v2 and Piper TTS may be better for specific use cases.

Resources & Further Reading

Official Resources

Related Research

Alternative TTS Models

Audio Processing Tools

  • Audacity

    Free audio editing (post-process Bark output)

  • Librosa

    Python audio analysis library

  • FFmpeg

    Audio format conversion and upsampling

  • PyTorch Audio

    Audio processing with PyTorch

Community & Support

Related on LocalAimaster

Build Real AI on Your Machine

RAG, agents, NLP, vision, and MLOps - chapters across 25 courses that take you from reading about AI to building AI.

Explore the Learning PathSee pricing
Reading now
Join the discussion

Related Guides

Continue your local AI journey with these comprehensive guides

View All Local AI Guides
🎯
AI Learning Path

Go from reading about AI to building with AI

25 structured courses. Hands-on projects. Runs on your machine. Start free.

Start freeBrowse courses first
Or own it for life — Lifetime $149 $599, pay once
Training your whole team? Get a team quote →
Barsha Mohapatra

Written by

Barsha Mohapatra

Founder and Editor, Local AI Master · Founder, Little AI Master

Founder of Little AI Master and the editor behind every course and guide on Local AI Master. Years of tutoring students taught her where AI education actually fails.

About BarshaLinkedInLittle AI Master
📅 Published: 2025-09-29🔄 Last Updated: November 2, 2026✓ Manually Reviewed
More on AI Models Directory
See the full AI Models Directory guide.
📚
Free · no account required

Grab the AI Starter Kit — career roadmap, cheat sheet, setup guide

No spam. Unsubscribe with one click.

🎯
AI Learning Path

Found your model? Now build something with it.

25 hands-on courses — RAG, agents, fine-tuning — all running locally. First chapter free, no card.

Start freeBrowse courses first
Or own it for life — Lifetime $149 $599, pay once
Training your whole team? Get a team quote →
Free Tools & Calculators