# Bark Admin & Developer Guide

This guide covers Bark's architecture, configuration surface, deployment considerations, operations, security posture, and internals — everything an operator, architect, or contributor needs to run, integrate, embed, or extend the model. For end-user installation and usage, see the companion **[Bark User Guide](/guides/suno-ai/bark/user-guide/)**.

---

## 1. Executive Summary

**Bark** is an open-source, transformer-based **text-to-audio** model from Suno. Unlike conventional text-to-speech (TTS) systems, Bark is *fully generative*: it converts text directly into audio tokens — with no intermediate phoneme representation — and can produce speech, singing, music, sound effects, and nonverbal sounds across 13 languages.

| Attribute | Detail |
|---|---|
| Project type | Python library + small CLI (model inference) |
| Domain | Generative text-to-audio (TTS+) |
| Architecture | Three 80 M-parameter GPT-style transformers + EnCodec neural audio codec |
| Language | Python (≥ 3.8) |
| Core runtime | PyTorch 2.0+, Hugging Face `transformers`, `encodec` |
| Model delivery | Checkpoints auto-downloaded from Hugging Face Hub (`suno/bark`) |
| Output | NumPy audio array @ 24 kHz |
| License | MIT (commercial use permitted as of 2023-05-01) |
| Code size | ~50 KB of source across 8 Python files |

> [!NOTE]
> Bark is explicitly a **research and demo** model. It is not designed for guaranteed, deterministic, studio-grade TTS. Operators integrating it into products should plan for output variance and apply the responsible-use safeguards discussed in [Security & Responsible Use](#6-security--responsible-use).

### What's in scope for an operator

There is **no server, database, API service, or persistent state** in this repository. Bark is a stateless inference library: it loads model weights into memory, runs a forward pass, and returns an array. "Operating" Bark means managing the Python environment, the model cache, GPU/CPU resources, and the few environment-variable knobs — not running a service.

---

## 2. Architecture

### 2.1 The generation pipeline

Bark turns text into audio through a four-stage pipeline. The three learned stages are GPT-style transformers; the final stage is a neural codec decoder.

```
   text (str)
      │
      ▼
┌──────────────────────────┐
│ 1. Text → Semantic       │   GPT (causal), 80M params
│    generate_text_semantic│   BERT-tokenized input + semantic history
└──────────────────────────┘
      │  semantic tokens (vocab 10,000)
      ▼
┌──────────────────────────┐
│ 2. Semantic → Coarse     │   GPT (causal), 80M params
│    generate_coarse       │   first 2 EnCodec codebooks
└──────────────────────────┘
      │  coarse codes (2 × 1,024)
      ▼
┌──────────────────────────┐
│ 3. Coarse → Fine         │   FineGPT (non-causal), 80M params
│    generate_fine         │   all 8 EnCodec codebooks
└──────────────────────────┘
      │  fine codes (8 × 1,024)
      ▼
┌──────────────────────────┐
│ 4. Codec Decode          │   EnCodec 24 kHz decoder
│    codec_decode          │   tokens → waveform
└──────────────────────────┘
      │
      ▼
   audio array @ 24 kHz (np.ndarray)
```

This mirrors the design described in the model card and is inspired by [AudioLM](https://arxiv.org/abs/2209.03143) and [Vall-E](https://arxiv.org/abs/2301.02111), using a quantized audio representation from [EnCodec](https://github.com/facebookresearch/encodec). The transformer implementation is adapted from Andrej Karpathy's [nanoGPT](https://github.com/karpathy/nanoGPT).

### 2.2 Model inventory

| Stage | Model class | Attention | Parameters | Output vocab |
|---|---|---|---|---|
| Text → semantic | `GPT` | Causal | 80 M | 10,000 |
| Semantic → coarse | `GPT` | Causal | 80 M | 2 × 1,024 |
| Coarse → fine | `FineGPT` | Non-causal | 80 M | 6 × 1,024 |
| Codec decode | EnCodec 24 kHz | — | (pretrained) | waveform |

The text and coarse stages share the same `GPT` architecture (`bark/model.py`); the fine stage uses `FineGPT` (`bark/model_fine.py`), a subclass of `GPT` that predicts multiple codebooks with non-causal attention. EnCodec is loaded from the `encodec` package and set to a target bandwidth of 6.0.

### 2.3 Public Python API surface

The top-level package (`bark/__init__.py`) re-exports the user-facing API:

```python
from .api import generate_audio, text_to_semantic, semantic_to_waveform, save_as_prompt
from .generation import SAMPLE_RATE, preload_models
```

| Function | Module | Role |
|---|---|---|
| `generate_audio(text, history_prompt, text_temp, waveform_temp, silent, output_full)` | `api.py` | End-to-end: text → audio. Orchestrates the full pipeline. |
| `text_to_semantic(text, history_prompt, temp, silent)` | `api.py` | Stage 1 wrapper (enables KV caching). |
| `semantic_to_waveform(semantic_tokens, history_prompt, temp, silent, output_full)` | `api.py` | Stages 2–4 wrapper (coarse → fine @ temp 0.5 → codec). |
| `save_as_prompt(filepath, full_generation)` | `api.py` | Persist a generation dict to a `.npz` voice prompt. |
| `preload_models(...)` | `generation.py` | Download & load all four models. |
| `SAMPLE_RATE` | `generation.py` | `24000`. |

### 2.4 Low-level generation API

For fine control, `bark.generation` exposes the per-stage functions directly. These carry sampling parameters not surfaced by `generate_audio`:

| Function | Notable parameters (defaults) |
|---|---|
| `generate_text_semantic` | `temp=0.7`, `top_k=None`, `top_p=None`, `min_eos_p=0.2`, `max_gen_duration_s=None`, `allow_early_stop=True`, `use_kv_caching=False` |
| `generate_coarse` | `temp=0.7`, `top_k`, `top_p`, `max_coarse_history=630` (min 60, max 630), `sliding_window_len=60`, `use_kv_caching=False` |
| `generate_fine` | `temp=0.5`, `silent=True` |
| `codec_decode` | `fine_tokens` |
| `load_model` | `use_gpu=True`, `use_small=False`, `force_reload=False`, `model_type="text"` |
| `load_codec_model` | `use_gpu=True`, `force_reload=False` |
| `clean_models` | `model_key=None` (frees a model or all models from memory) |

> [!TIP]
> `top_k` and `top_p` sampling are available on the lower-level `generate_text_semantic` / `generate_coarse` functions but are **not** exposed through `generate_audio`. To use nucleus or top-k sampling, call the stage functions directly and chain them, or replicate the orchestration in `api.py`.

### 2.5 Model loading and memory management

Models are held in module-level global dictionaries (`models`, `models_devices`) in `bark/generation.py` and **lazy-loaded** on first use. Each generation function calls `preload_models()` if its required model isn't already resident.

- `load_model()` resolves the checkpoint path, downloads from Hugging Face if absent, loads the state dict (stripping the `_orig_mod.` compile prefix), validates keys, and moves the model to the chosen device.
- `_grab_best_device()` selects `cuda` → `mps` (only if `SUNO_ENABLE_MPS`) → `cpu`.
- When `SUNO_OFFLOAD_CPU` is set, models live on CPU and are moved to the GPU only during their forward pass, then back — trading speed for VRAM.
- `clean_models()` deletes models from the global cache, clears the CUDA cache, and runs garbage collection.

> [!IMPORTANT]
> Because models are process-global singletons, a single process serves all generations from one loaded copy. To run Bark in a long-lived service, call `preload_models()` once at startup and reuse the process; do not reload per request.

---

## 3. Requirements

| Component | Requirement |
|---|---|
| Python | ≥ 3.8 |
| PyTorch | 2.0+ recommended; tested with CUDA 11.7 and CUDA 12.0 |
| GPU (optional) | CUDA GPU; ~12 GB VRAM for full models |
| Apple Silicon | Supported via MPS (`SUNO_ENABLE_MPS=True`); EnCodec step falls back to CPU |
| Disk | Several GB for cached checkpoints |
| Network | Outbound HTTPS to Hugging Face Hub for first-run model download |

### Dependency manifest (`pyproject.toml`)

**Runtime dependencies:** `boto3`, `encodec`, `funcy`, `huggingface-hub>=0.14.1`, `numpy`, `scipy`, `tokenizers`, `torch`, `tqdm`, `transformers`.

**Dev/optional (`[dev]`):** `bandit`, `black`, `codecov`, `flake8`, `hypothesis`, `isort`, `jupyter`, `mypy`, `nbconvert`, `nbformat`, `pydocstyle`, `pylint`, `pytest`, `pytest-cov`.

Build backend is `setuptools`. Package data bundles the voice presets: `assets/prompts/*.npz` and `assets/prompts/v2/*.npz`.

> [!NOTE]
> `boto3` is declared as a runtime dependency but is not referenced in the core inference code paths shown here; it may be unused or reserved for an optional download path. Operators building minimal images can test removing it but should validate against their workflow.

---

## 4. Configuration Mastery

Bark has **no configuration file**. Its entire configurable surface is: (1) environment variables, (2) function arguments, and (3) module-level constants. There are no YAML/JSON/TOML runtime config files and no CLI config file.

### 4.1 Environment variables

| Variable | Read in | Default | Effect |
|---|---|---|---|
| `SUNO_USE_SMALL_MODELS` | `generation.py` | `False` | Load smaller checkpoint variants (`*_small`). Fits ~8 GB VRAM, faster, slightly lower quality. |
| `SUNO_ENABLE_MPS` | `generation.py` | `False` | Allow Apple Silicon MPS as a device (codec still on CPU). |
| `SUNO_OFFLOAD_CPU` | `generation.py` | `False` | Keep models on CPU, move to GPU only during forward pass. Large VRAM savings. |
| `XDG_CACHE_HOME` | `generation.py` | `~/.cache` | Base directory for the model cache (`<base>/suno/bark_v0`). |
| `HF_HOME` | (via `huggingface_hub`) | HF default | Standard Hugging Face cache relocation (per project FAQ). |

Boolean parsing is via `_cast_bool_env_var()`, which treats `"true"`, `"1"`, `"t"` (case-insensitive) as `True` and everything else as `False`.

> [!IMPORTANT]
> These environment variables are evaluated **at import time** of `bark.generation`. Set them before the first `import bark` / `from bark import ...` in the process. Changing them afterward has no effect on already-imported globals (`USE_SMALL_MODELS`, `GLOBAL_ENABLE_MPS`, `OFFLOAD_CPU`).

### 4.2 Model cache layout

```text
$XDG_CACHE_HOME/suno/bark_v0/      # default: ~/.cache/suno/bark_v0
    text.pt        coarse.pt       fine.pt        # small variants
    text_2.pt      coarse_2.pt     fine_2.pt      # full variants
```

Checkpoints are downloaded from the Hugging Face repo `suno/bark` via `hf_hub_download`. The mapping lives in `REMOTE_MODEL_PATHS`:

| Logical model | Small file | Full file |
|---|---|---|
| Text | `text.pt` | `text_2.pt` |
| Coarse | `coarse.pt` | `coarse_2.pt` |
| Fine | `fine.pt` | `fine_2.pt` |

### 4.3 `preload_models()` granular control

`preload_models()` accepts per-stage GPU/small flags, letting you mix placement — for example, run the lightweight stages on GPU and offload others:

```python
preload_models(
    text_use_gpu=True,  text_use_small=False,
    coarse_use_gpu=True, coarse_use_small=False,
    fine_use_gpu=True,   fine_use_small=False,
    codec_use_gpu=True,  force_reload=False,
)
```

### 4.4 Model constants (`bark/generation.py`)

These are not runtime-configurable but define model behavior and are useful for capacity planning and integration:

| Constant | Value | Meaning |
|---|---|---|
| `SAMPLE_RATE` | `24000` | Output audio sample rate (Hz). |
| `CONTEXT_WINDOW_SIZE` | `1024` | Transformer block size. |
| `SEMANTIC_RATE_HZ` | `49.9` | Semantic token rate. |
| `SEMANTIC_VOCAB_SIZE` | `10000` | Semantic vocabulary size. |
| `CODEBOOK_SIZE` | `1024` | EnCodec codebook size. |
| `N_COARSE_CODEBOOKS` | `2` | Codebooks produced by the coarse stage. |
| `N_FINE_CODEBOOKS` | `8` | Total codebooks after the fine stage. |
| `COARSE_RATE_HZ` | `75` | Coarse token rate. |
| `TEXT_ENCODING_OFFSET` | `10048` | Offset applied to BERT token IDs. |

Text input is tokenized with `bert-base-multilingual-cased` and truncated to **256 tokens** per call (longer text is lopped with a warning), which is why single-call output tops out at ~13–14 seconds.

---

## 5. Operations

Bark is a library, so "operations" centers on the host environment and resources rather than a running service.

### 5.1 Deployment patterns

=== "Embedded library"

    Import Bark directly into a Python application. Call `preload_models()` once at startup; reuse the process for all requests. Best for batch pipelines and notebooks.

=== "Inference microservice"

    Wrap `generate_audio()` in a thin web framework (FastAPI/Flask). Load models once at boot, then serialize requests onto the single in-memory model copy. Bark itself provides **no** server.

=== "Hugging Face Transformers"

    Use `BarkModel`/`AutoProcessor` from `transformers` (v4.31.0+) instead of this package — a separate, well-integrated code path with the same checkpoints.

### 5.2 First-run / pre-warming checklist

- [ ] Confirm Python ≥ 3.8 and a PyTorch build matching your CUDA version.
- [ ] Set environment variables (`SUNO_USE_SMALL_MODELS`, `SUNO_OFFLOAD_CPU`, `SUNO_ENABLE_MPS`, cache location) **before** importing Bark.
- [ ] Run `preload_models()` once to download checkpoints into the cache (several GB; needs outbound HTTPS to Hugging Face).
- [ ] Generate a short test clip and verify the `.wav` plays at 24 kHz.
- [ ] In a service, verify models stay resident across requests (no per-request reload).

### 5.3 Resource sizing

| Configuration | Approx. VRAM | Notes |
|---|---|---|
| Full models, all on GPU | ~12 GB | Best quality, real-time on enterprise GPUs + PyTorch nightly. |
| Small models (`SUNO_USE_SMALL_MODELS=True`) | ~8 GB | Faster, slightly lower quality. |
| Offload + small | down to ~2 GB | `SUNO_OFFLOAD_CPU=True` + small models; slower due to CPU↔GPU transfers. |
| CPU only | system RAM | Works (10× speed-up over old code), but much slower than GPU. |

> [!TIP]
> On PyTorch 2.0+, Bark automatically uses flash attention (`torch.nn.functional.scaled_dot_product_attention`) when available, significantly improving GPU throughput. On older PyTorch it logs a warning and falls back to a manual attention implementation.

### 5.4 Logging

Bark uses the standard `logging` module (`logger = logging.getLogger(__name__)`). Notable messages:

| Level | Message | Meaning |
|---|---|---|
| WARNING | `No GPU being used. Careful, inference might be very slow!` | Running on CPU. |
| WARNING | `torch version does not support flash attention...` | Upgrade PyTorch for speed. |
| WARNING | `warning, text too long, lopping of last X%` | Input exceeded 256 tokens. |
| INFO | `{model_type} model not found, downloading into ...` | First-run checkpoint download. |
| INFO | `model loaded: {n}M params, {loss} loss` | Checkpoint loaded successfully. |

Configure verbosity via standard `logging` configuration in the host application.

### 5.5 Memory hygiene

- Call `clean_models()` to free all loaded models (or a specific `model_key`) and reclaim VRAM.
- Each generation function clears the CUDA cache after running (`_clear_cuda_cache()`).
- Inference runs under `torch.inference_mode()` + `torch.no_grad()` + autocast (bfloat16 on supported CUDA GPUs) for memory efficiency.

---

## 6. Security & Responsible Use

### 6.1 Trust boundaries

| Surface | Risk | Mitigation |
|---|---|---|
| Model checkpoints | Loaded via `torch.load` (pickle-based). Untrusted checkpoints can execute arbitrary code. | Only load checkpoints from the official `suno/bark` Hugging Face repo or sources you trust. |
| `history_prompt` `.npz` files | Loaded via `np.load`. | Treat user-supplied `.npz` prompt files as untrusted input; validate provenance. |
| Network | First run downloads from Hugging Face over HTTPS. | Pre-stage the cache in air-gapped deployments. |
| Generated audio | Realistic synthetic speech (potential misuse). | See responsible use below. |

> [!CAUTION]
> Bark loads model and prompt files with Python's pickle machinery (`torch.load`, `np.load`). Loading a maliciously crafted `.pt` or `.npz` file can execute arbitrary code. Restrict model/prompt sources to trusted origins, especially in multi-tenant or user-upload scenarios.

> [!NOTE]
> PyTorch 2.6+ tightened `torch.load` to default `weights_only=True` as a security hardening measure. This is *good* for security but currently breaks Bark's bundled checkpoint loader (issues [#656](https://github.com/suno-ai/bark/issues/656), [#626](https://github.com/suno-ai/bark/issues/626)). Operators must choose a compatible PyTorch version or apply the issue workarounds — and should understand they are loading pickle-backed checkpoints when they do.

### 6.2 Responsible use

Per the project's own disclaimer and model card:

- Bark is a **research** model; Suno takes no responsibility for generated output. Use at your own risk and act responsibly.
- Any text-to-audio model has **dual-use** potential. While Bark does not straightforwardly clone known voices, synthetic audio can be misused.
- Suno releases a **detection classifier** (in the repository's `notebooks/` section, e.g. `fake_classifier.ipynb`) to identify Bark-generated audio with high accuracy. Consider integrating detection where provenance matters.

> [!WARNING]
> If you deploy Bark in a product, surface a clear disclaimer that audio is AI-generated and implement abuse safeguards appropriate to your context (consent, watermarking/detection, content policies).

### 6.3 No secrets, no auth

Bark has no authentication, no API keys, and no secrets management — it is an offline inference library. The only external call is the (anonymous) Hugging Face model download.

---

## 7. Repository Structure & Internals

### 7.1 Layout

```text
bark/
  __init__.py        # Public API re-exports
  __main__.py        # `python -m bark` entry → cli()
  api.py             # High-level orchestration (generate_audio, etc.)
  cli.py             # argparse CLI wrapper
  generation.py      # Model loading, env config, all generation stages, codec
  model.py           # GPT, GPTConfig, attention, blocks (nanoGPT-derived)
  model_fine.py      # FineGPT, FineGPTConfig, non-causal attention
  assets/prompts/    # 100+ bundled voice presets (.npz), incl. v2/
notebooks/           # long_form_generation, use_small_models_on_cpu,
                     # memory_profiling_bark, fake_classifier
setup.py             # setuptools shim
pyproject.toml       # Project metadata, deps, packaging
model-card.md        # Model details, architecture table, broader implications
README.md            # Usage and FAQ
LICENSE              # MIT
```

### 7.2 Module reference

| Module | Key contents |
|---|---|
| `api.py` | `text_to_semantic`, `semantic_to_waveform`, `generate_audio`, `save_as_prompt`. The pipeline orchestration layer; thin wrappers over `generation.py`. |
| `generation.py` | The heart of Bark: env-var config, `REMOTE_MODEL_PATHS`, device selection, `load_model`/`load_codec_model`/`preload_models`/`clean_models`, `generate_text_semantic`/`generate_coarse`/`generate_fine`, `codec_decode`, `InferenceContext`, prompt validation (`_load_history_prompt`, `ALLOWED_PROMPTS`). |
| `model.py` | `GPT` and `GPTConfig`, plus `LayerNorm`, `CausalSelfAttention` (with KV caching + flash attention), `MLP`, `Block`. Adapted from nanoGPT. |
| `model_fine.py` | `FineGPT` (subclass of `GPT`) and `FineGPTConfig`, `NonCausalSelfAttention`, `FineBlock` — predicts the 8 fine codebooks. |
| `cli.py` | `cli()` — argparse front end mapping flags to `generate_audio`. |

### 7.3 Class hierarchy

| Class | Base | Defined in |
|---|---|---|
| `GPTConfig` | dataclass | `model.py` |
| `GPT` | `nn.Module` | `model.py` |
| `LayerNorm`, `CausalSelfAttention`, `MLP`, `Block` | `nn.Module` | `model.py` |
| `FineGPTConfig` | `GPTConfig` | `model_fine.py` |
| `FineGPT` | `GPT` | `model_fine.py` |
| `NonCausalSelfAttention`, `FineBlock` | `nn.Module` | `model_fine.py` |
| `InferenceContext` | context manager | `generation.py` |

`GPTConfig` defaults: `block_size=1024`, `input_vocab_size=10048`, `output_vocab_size=10048`, `n_layer=12`, `n_head=12`, `n_embd=768`, `dropout=0.0`, `bias=True`. `FineGPTConfig` adds `n_codes_total=8`, `n_codes_given=1`.

### 7.4 Notable implementation details

- **KV caching:** `CausalSelfAttention.forward` accepts `past_kv`/`use_cache` for incremental decoding; `generate_text_semantic` and `generate_coarse` enable it via `use_kv_caching=True` (set automatically by the high-level `api.py` wrappers).
- **Merged context:** `GPT.forward(merge_context=True)` sums the first two 256-token segments (encoded text + semantic history) before the transformer — a Bark-specific input layout (`256 + 256 + 1` tokens).
- **Sliding window (coarse):** `generate_coarse` decodes in windows (`sliding_window_len=60`) bounded by `max_coarse_history` (60–630), enforcing the codebook interleaving via `N_COARSE_CODEBOOKS`.
- **Non-causal fine stage:** `FineGPT` predicts codebooks 2–8 with bidirectional attention over a 1024-token buffer, looping with 512-token strides.
- **Prompt validation:** `_load_history_prompt` accepts a `.npz` path, a preset name (validated against `ALLOWED_PROMPTS`), or a dict; arrays are shape/range-checked before use.

---

## 8. Code Quality & Conventions

| Aspect | Observation |
|---|---|
| Style | Black, line length 100 (`[tool.black]`). isort, flake8, pylint, mypy, pydocstyle available as dev deps. |
| Security linting | `bandit` is a declared dev dependency. |
| Testing | `pytest`, `pytest-cov`, `hypothesis` declared as dev deps. No test suite is present in the analyzed source tree; examples live in `notebooks/`. |
| Docstrings | Public API functions are docstringed with args/returns; lower-level functions are lighter. |
| Provenance | Transformer code transparently credits nanoGPT. |
| Globals | Model state held in module-level globals — simple and effective for single-process inference, but not thread-safe for concurrent reloads. |

> [!NOTE]
> The codebase is deliberately small and readable (~50 KB, 8 files). It is an *inference* reference implementation, not a production-hardened service — error handling is minimal (e.g. the CLI catches all exceptions and prints a friendly message).

---

## 9. Potential Improvements

These are observations from the source, offered for contributors and operators — not defects in normal use.

| Area | Observation | Suggestion |
|---|---|---|
| CLI boolean flags | `--silent`/`--output_full` use `type=bool`, so any non-empty value (including `False`) parses as `True`. | Switch to `action="store_true"` so the flags behave as expected. |
| PyTorch 2.6 compatibility | Checkpoint loading breaks under `weights_only=True` default. | Update the loader to register safe globals or load with explicit `weights_only=False` for trusted checkpoints. |
| License metadata drift | `README.md` states **MIT** (twice, dated 2023-05-01); `pyproject.toml` has a stale `# Apache 2.0` comment above `license = {file = "LICENSE"}`. | Remove the misleading comment to match the MIT `LICENSE`. |
| Unused dependency | `boto3` is a declared runtime dependency not referenced in core paths. | Confirm necessity; drop if unused to slim installs. |
| Thread safety | Module-global model dicts are not guarded for concurrent access. | Add locking or document single-threaded model management for services. |
| Top-k/top-p exposure | Nucleus/top-k sampling exists only on low-level functions. | Surface these through `generate_audio` for easier tuning. |

---

## 10. Quick Reference

### Entry points

| Entry | Invocation |
|---|---|
| Library | `from bark import generate_audio, preload_models, SAMPLE_RATE` |
| CLI | `python -m bark --text "..."` |
| Transformers | `from transformers import BarkModel, AutoProcessor` |

### Environment variables

| Variable | Default | Effect |
|---|---|---|
| `SUNO_USE_SMALL_MODELS` | `False` | Small models (~8 GB VRAM). |
| `SUNO_OFFLOAD_CPU` | `False` | CPU offload (low VRAM). |
| `SUNO_ENABLE_MPS` | `False` | Apple Silicon GPU. |
| `XDG_CACHE_HOME` / `HF_HOME` | `~/.cache` / HF default | Cache relocation. |

### Pipeline functions

| Function | Stage |
|---|---|
| `generate_text_semantic` | text → semantic |
| `generate_coarse` | semantic → coarse codes |
| `generate_fine` | coarse → fine codes |
| `codec_decode` | codes → waveform |

### Key facts

| Fact | Value |
|---|---|
| Models | 3 × 80 M GPT + EnCodec codec |
| Sample rate | 24,000 Hz |
| Text window | 256 tokens (~13 s output) |
| Tokenizer | `bert-base-multilingual-cased` |
| Checkpoint source | HF `suno/bark` |
| Cache | `~/.cache/suno/bark_v0` |
| Min Python | 3.8 |
| License | MIT |

### Errors raised

| Exception | Message | Cause |
|---|---|---|
| `ValueError` | `history prompt not found` | Unknown preset name. |
| `ValueError` | `history prompt format unrecognized` | Bad `history_prompt` type. |
| `ValueError` | `extra keys found: {...}` | Checkpoint/architecture mismatch. |
| `ValueError` | `missing keys: {...}` | Checkpoint/architecture mismatch. |

---

_Generated June 2026 from suno-ai/bark at f4f32d4. AI-generated documentation. The library is checked by sampling (three repositories so far); this guide was not individually reviewed. Verify against the project before relying on it. Unofficial; not affiliated with or reviewed by the project._