Text-to-Audio Model

Run Bark locally: 12GB for the full stack, 2GB if you squeeze

Suno's open text-to-audio model talks, laughs, and hums. It is small enough to fit almost any card — the real question was never whether it fits, but how fast and how many at once.

Bark · self-hosted

Bark is not a conventional TTS system. There are no phonemes, no duration predictor, no vocoder pipeline — instead it is a GPT-style autoregressive chain: a semantic model compresses text into semantic tokens, a coarse model predicts the first two EnCodec codebooks, and a non-causal fine model fills in the remaining codebooks before EnCodec decodes everything to a 24kHz mono waveform. Three transformer stages at 300M parameters each (80M each in the small variant), plus the EnCodec decoder. A side effect of that architecture is that Bark will happily generate laughter, sighs, throat-clearing, background music, and ambient noise — write `[laughs]`, `[sighs]`, or `♪` in your text and it fires. Thirteen languages are officially supported including Simplified Chinese, with 100+ speaker presets shipped alongside, all under the MIT licence and cleared for commercial use.

One thing needs saying up front: upstream is frozen. The last substantive code commit to suno-ai/bark landed in September 2023, the README was touched once in April 2024, no release has ever been cut, and 269 issues sit open. Suno itself moved on to its commercial music product. That does not make Bark dead — MIT weights cannot be recalled, and Hugging Face's `BarkModel` is maintained as part of the transformers trunk, where Flash Attention 2, SDPA, and `enable_cpu_offload()` all arrived *after* upstream went quiet. The suno/bark and suno/bark-small checkpoints still pull roughly 95,000 downloads a month between them. Use the transformers path; do not wait for the original repo to move. Official Bark has never supported voice cloning — that capability lives only in the community fork serp-ai/bark-with-voice-clone.

The "about 12GB of VRAM" line in the README scares people off, but it describes the native library holding every fp32 submodel resident simultaneously. On the transformers path, Hugging Face measured on a single TITAN RTX 24GB: with no optimisation at 256 new tokens, peak memory was 5025MB at 10.48 seconds per clip; adding CPU offload and BetterTransformer brought it to 2040.7MB; adding fp16 on top left just 1010.4MB at 8.10 seconds — 80% less memory and 23% faster. Bark's memory floor is absurdly low, which means your money goes to throughput, not capacity: batch 8 with fp16 runs around 0.78 samples/sec, and on an A100 with Flash Attention 2 at batch 16 and 400 semantic tokens you get 17x the throughput. Renting a card by the second and stopping when the job finishes beats buying one by a wide margin.

01 —

The variants and what each one costs in VRAM

Same weights, but how you run them swings memory by an order of magnitude

Version	Parameters	VRAM	Context	Notes
suno/bark (v2 large)	3 × 300M + EnCodec	~12GB fully resident via native lib; 4.49GB transformers checkpoint, ~2.2GB in fp16	256-token text cap / ~13s per generation	The full-quality version. Best results for Chinese and for non-verbal audio effects. ~37.7k downloads/month.
suno/bark-small	3 × 80M + EnCodec	1.68GB fp32 weights, ~0.85GB fp16; fits 8GB cards via `SUNO_USE_SMALL_MODELS`	256-token text cap / ~13s per generation	Noticeably faster, slightly lower quality — and it out-downloads the large model (~57.9k/month), which tells you what people actually run.
Native lib + OFFLOAD_CPU + SMALL_MODELS	3 × 80M	As low as ~2GB; officially supports cards under 4GB	256-token text cap / ~13s per generation	The fallback for old cards, free Colab tiers, or pure CPU. You pay for it in constant shuffling of submodels between VRAM and system RAM.
transformers + fp16 + CPU offload	3 × 300M	1010.4MB measured peak (TITAN RTX 24GB, 256 new tokens)	256-token text cap / ~13s per generation	Cuts memory 80% while also cutting latency 23%. The optimum for single-clip generation.
transformers + fp16 + Flash Attention 2	3 × 300M	~4198.8MB at batch 8; batch 16 needs Ampere or newer	256-token text cap / ~13s per generation	The production choice for batching — up to 17x throughput on an A100 at batch 16, 400 semantic tokens. Volta cards like the V100 cannot use FA2 and fall back to plain fp16.
serp-ai/bark-with-voice-clone	3 × 300M (community fork)	Same as suno/bark	256-token text cap / ~13s per generation	Official Bark does not clone voices. If you need a specific target timbre, this fork is the only route — and it is still being maintained.

02 —

Which card to rent

Bark is a sub-billion-parameter model. Spend on throughput, not on VRAM you will never touch.

Auditioning voices, tuning prompts, running bark-small
Tesla V100 32GB$0.188/GPU-hour
The cheapest tier available, and 32GB swallows full Bark without thinking; Volta cannot do Flash Attention 2, but single-clip auditioning never needed it.
Full suno/bark resident with fp16 batch generation
RTX 3090 24GB$0.193/GPU-hour
Ampere unlocks Flash Attention 2, and 24GB gives you double headroom over the 12GB worst case — the best price-performance point on the entire rate card.
High-throughput pipelines of a thousand-plus clips
RTX 4090 24GB$0.540/GPU-hour
Ada plus FA2 plus batch 16. Autoregressive decoding leans on per-core speed, so the 4090 clears far more samples per second than older cards with identical VRAM.
Bark, Whisper, and the cloning fork all resident on one box
RTX A6000 48GB$0.817/GPU-hour
48GB keeps recognition, synthesis, and post-processing models loaded simultaneously, eliminating the load-unload churn between stages.

03 —

Four steps to your first waveform

Bare machine to playable wav, usually inside ten minutes

01
Boot a box and install the right package
Start an RTX 3090 from a PyTorch prebuilt image and SSH in. One trap to know: the package named `bark` on PyPI is a completely different project — installing it leaves you very confused. You must install from GitHub. Bark is verified on PyTorch 2.0+ with CUDA 11.7 and 12.0.
```
pip install git+https://github.com/suno-ai/bark.git  # NOT pip install bark
```
02
The leanest native path
Two environment variables govern memory. `SUNO_USE_SMALL_MODELS` swaps in the 80M models, `SUNO_OFFLOAD_CPU` pushes idle submodels back to system RAM, and together they land around 2GB. Output is always 24kHz mono, and bracketed tags trigger non-verbal audio.
```
SUNO_USE_SMALL_MODELS=True SUNO_OFFLOAD_CPU=True python -c "from bark import SAMPLE_RATE, generate_audio, preload_models; preload_models(); import scipy.io.wavfile as w; w.write('out.wav', SAMPLE_RATE, generate_audio('Hello, this is a Bark test. [laughs]'))"
```
03
Production path: transformers + fp16 + FA2
Skip the native library once you are generating at volume. Load `BarkModel` in half precision with Flash Attention 2 attached — audio quality is essentially unchanged while both memory and latency drop. If memory is still tight, append `model.enable_cpu_offload()`; all three optimisations stack.
```
model = BarkModel.from_pretrained('suno/bark', torch_dtype=torch.float16, attn_implementation='flash_attention_2').to('cuda')
```
04
Lock the voice, stitch long audio
Without a `voice_preset`, Bark rolls a random speaker on every call and your narration drifts between sentences. Pin it with a `v2/` preset. The ~13-second ceiling per generation is architectural, so long-form means splitting on sentence boundaries, generating each piece, and concatenating — always passing the same preset to keep the timbre consistent.
```
inputs = processor('Welcome to this episode.', voice_preset='v2/en_speaker_6')
```

What 1,000 clips actually costs

Say you need 1,000 clips of roughly 13 seconds each on an RTX 3090 24GB ($0.193/GPU-hour), using transformers with fp16 plus BetterTransformer at batch 8. At the 0.78 samples/sec Hugging Face measured on a comparable 24GB card: 1000 ÷ 0.78 ≈ 1,282 seconds ≈ 0.36 hours, and 0.36 × $0.193 ≈ $0.069. Add roughly five minutes to pull weights and warm up (0.083 hours × $0.193 ≈ $0.016) and you land at about $0.085 total — under a dime. The line item that actually deserves attention is storage: 4.5GB of weights at $0.414/GB-month runs $1.86 for a month, more than twenty times the compute. So stop the instance when the job ends and destroy the volume, re-pulling weights next run (inbound is not billed). The 1,000 finished 24kHz WAVs come to about 624MB, which at $0.0081/GB egress is roughly $0.005 — noise. Compute is metered per second and billing stops the moment the instance does, with no minimum and no setup fee.

04 —

Frequently Asked Questions

How much VRAM does Bark really need — is 12GB a hard floor?

No. The 12GB figure describes the native library pinning every fp32 submodel in VRAM at once. Through transformers with fp16 and CPU offload, measured peak usage was 1010.4MB; bark-small with `SUNO_USE_SMALL_MODELS` sits comfortably on an 8GB card; both environment flags together get you to about 2GB. VRAM is effectively not the constraint, which is why either the $0.188/GPU-hour Tesla V100 32GB or the $0.193/GPU-hour RTX 3090 24GB on NexGPU leaves you enormous headroom.

Is Bark still worth using, and is the project still maintained?

Upstream suno-ai/bark is frozen — last substantive commit September 2023, no release ever cut, and Suno's attention has moved to its commercial music product. But the weights went out under MIT and cannot be withdrawn, Hugging Face's `BarkModel` ships and evolves with the transformers trunk (Flash Attention 2 support landed after the freeze), and the two checkpoints still see about 95,000 downloads a month combined. If what you want is generative audio that laughs, sighs, and carries background texture rather than clean broadcast narration, it remains the most interesting MIT-licensed option around. Rent a card by the second on NexGPU and settle the question in one evening for less than the cost of a meeting.

Can Bark clone a voice? How do I reproduce my own timbre?

Official Bark explicitly does not support custom voice cloning — you get 100+ preset speakers and random voices. Cloning requires the community fork serp-ai/bark-with-voice-clone, which is still actively maintained. That path adds an encoding step and somewhat higher memory use, so the practical move is to spin up an RTX A6000 48GB on NexGPU ($0.817/GPU-hour), run the fork and stock Bark side by side, and decide from the actual output.

Why is Bark capped at 13 seconds, and how do I make longer audio?

It is architectural: text input is truncated at 256 tokens, and one `generate_audio` call corresponds to roughly 13–14 seconds of speech. Long-form means splitting on sentence boundaries, generating piece by piece, and concatenating — exactly what the repo's long_form_generation notebook demonstrates. The critical detail is passing the same `v2/` preset to every segment, or the voice drifts. That segmented workload batches beautifully, so an RTX 4090 24GB on NexGPU ($0.540/GPU-hour) can knock out an entire episode in one session.

How good is Bark at non-English languages?

Thirteen languages are officially supported, including Simplified Chinese with ten dedicated presets (`v2/zh_speaker_0` through `v2/zh_speaker_9`). Honestly, non-English stability trails English — you will hit occasional mispronunciations, and tags like `[laughs]` behave best on English text. It rewards sampling several presets and seeds and picking the good take, and that generate-many-keep-one workflow is precisely where per-second billing pays off: on NexGPU the meter stops the moment you stop the instance.

Should I rent an H100 or H200 to run Bark?

No. All three Bark stages together are under a billion parameters, while H100 SXM 80GB runs $3.582/GPU-hour and H200 141GB runs $6.660/GPU-hour — most of that memory and compute would idle, and autoregressive decoding cannot saturate cards like those anyway. The same job on an RTX 3090 24GB costs $0.193/GPU-hour, close to a twentyfold difference. NexGPU carries 75 GPU models across 2,498 cards in 51 countries and regions, so leave the H100s to the training runs that need them and put Bark on cheap Ampere.

Start building on NexGPU

Enterprise R&D team or solo developer — either way, your first job can be running in minutes.