# Parakeet TDT v2 vs v3 ASR Models: Key Differences in FluidAudio

> Discover the key differences between Parakeet TDT v2 and v3 ASR models in FluidAudio. Learn about multilingual support, blank token IDs, and decoder architecture to choose the right model.

- Repository: [Fluid Inference/fluidaudio](https://github.com/fluidinference/fluidaudio)
- Tags: deep-dive
- Published: 2026-03-02

---

**Parakeet TDT v3 is a multilingual ASR model supporting 25 European languages with a blank token ID of 8192 and a dedicated duration head, while v2 is an English-only variant using blank token ID 1024 and relies on a thin compatibility wrapper around the v3 decoder.**

When working with the fluidinference/fluidaudio library for automatic speech recognition, selecting between the Parakeet TDT v2 and v3 models determines your language coverage and initialization requirements. Both models share the same 0.6 billion parameter architecture, but differ significantly in multilingual capabilities and token configuration. Understanding these distinctions ensures you configure the correct `TdtConfig` blank token ID for your specific model version.

## Language Support and Model Scope

### Parakeet TDT v2: English-Only Transcription

The **Parakeet TDT v2** model is an English-only ASR system that was the first TDT (Token-and-Duration Transducer) model added to the FluidAudio library. According to the model documentation in **[`Documentation/Models.md`](https://github.com/fluidinference/fluidaudio/blob/main/Documentation/Models.md)**, this variant supports transcription exclusively for English audio and marked the initial introduction of the TDT architecture to the codebase.

### Parakeet TDT v3: Multilingual Default

The **Parakeet TDT v3** model expands coverage to **25 European languages**, making it the default ASR model for batch transcription in FluidAudio. As documented in **[`Documentation/Models.md`](https://github.com/fluidinference/fluidaudio/blob/main/Documentation/Models.md)**, this version provides full multilingual support while maintaining the same 0.6 billion parameter count as v2. The library uses v3 as the standard pipeline for all batch transcription tasks unless specifically configured otherwise.

## Token-Blank ID and Configuration Adaptation

The most critical technical difference between Parakeet TDT v2 and v3 lies in the **blank token ID** used during CTC-style decoding. This value determines which token index represents the blank symbol in the transducer output.

The v3 model uses the standard TDT blank token ID **8192**, defined as the first token after the 8192 regular vocabulary tokens. This default is hardcoded in **[`TdtConfig.swift`](https://github.com/fluidinference/fluidaudio/blob/main/TdtConfig.swift)** at lines 15-18:

```swift
public struct TdtConfig {
    public static let `default` = TdtConfig(
        // ... other parameters ...
        blankId: 8192  // Standard v3 blank token
    )
}

```

In contrast, v2 models were trained with a non-standard **blank ID of 1024**. Rather than duplicating the entire decoder implementation, FluidAudio provides a thin wrapper in **[`TdtDecoderV2.swift`](https://github.com/fluidinference/fluidaudio/blob/main/TdtDecoderV2.swift)** (lines 55-64) that adapts the `ASRConfig` by swapping the blank ID before delegating all decoding work to the v3 decoder:

```swift
private static func adaptConfigForV2(_ config: ASRConfig) -> ASRConfig {
    let tdt = config.tdtConfig
    guard tdt.blankId != 1024 else { return config }

    let adaptedTdt = TdtConfig(
        includeTokenDuration: tdt.includeTokenDuration,
        maxSymbolsPerStep: tdt.maxSymbolsPerStep,
        durationBins: tdt.durationBins,
        blankId: 1024,                         // ← v2‑specific blank ID
        boundarySearchFrames: tdt.boundarySearchFrames,
        maxTokensPerChunk: tdt.maxTokensPerChunk,
        consecutiveBlankLimit: tdt.consecutiveBlankLimit
    )
    return ASRConfig(sampleRate: config.sampleRate, tdtConfig: adaptedTdt)
}

```

## Duration Head and Decoding Architecture

The **Parakeet TDT v3** implements a full Token-and-Duration Transducer where the joint network predicts both a token and a duration bin simultaneously. As noted in the source comments within **[`TdtDecoderV3.swift`](https://github.com/fluidinference/fluidaudio/blob/main/TdtDecoderV3.swift)** (lines 45-46), this architecture includes a dedicated duration head with five explicit duration bins that map directly to frame advances during decoding.

The **v2** model shares the underlying joint-network architecture but does not require a separate duration-head implementation. Because the `TdtDecoderV2` wrapper simply reuses the v3 decoder after adapting the configuration's blank ID, it inherits the same duration prediction capabilities while maintaining compatibility with the v2-specific tokenization scheme.

## Loading and Using the Models

### Loading the Default v3 Model

To load the multilingual v3 model, use the default `TdtConfig` which automatically sets the correct blank token ID:

```swift
import FluidAudio

let modelURL = URL(string: "https://huggingface.co/FluidInference/parakeet-tdt-0.6b-v3-coreml")!
let asrConfig = ASRConfig(
    sampleRate: 44_100,
    tdtConfig: .default          // uses blankId = 8192 (v3)
)

let asr = try FluidAudioASR(modelURL: modelURL, config: asrConfig)
let transcript = try await asr.transcribe(audioURL: audioFileURL)
print(transcript.text)   // Multilingual output

```

### Loading a v2 Model with Custom Configuration

For the English-only v2 model, you must explicitly override the blank token ID to 1024:

```swift
import FluidAudio

let modelURL = URL(string: "https://huggingface.co/FluidInference/parakeet-tdt-0.6b-v2-coreml")!

// Override the blank token ID for v2 models
let v2TdtConfig = TdtConfig(blankId: 1024)   // v2‑specific
let asrConfig = ASRConfig(sampleRate: 44_100, tdtConfig: v2TdtConfig)

let asr = try FluidAudioASR(modelURL: modelURL, config: asrConfig)
let transcript = try await asr.transcribe(audioURL: audioFileURL)
print(transcript.text)   // English‑only output

```

### Using the Command-Line Interface

The FluidAudio CLI automatically detects the model version and selects the appropriate decoder:

```bash

# v3 (default) – multilingual transcription

fluid-audio-cli transcribe --model parakeet-tdt-0.6b-v3-coreml audio.wav

# v2 – English only (CLI detects the 1024 blank ID automatically)

fluid-audio-cli transcribe --model parakeet-tdt-0.6b-v2-coreml audio.wav

```

The CLI implementation in **[`Sources/FluidAudioCLI/Commands/Parakeet/ParakeetEouCommand.swift`](https://github.com/fluidinference/fluidaudio/blob/main/Sources/FluidAudioCLI/Commands/Parakeet/ParakeetEouCommand.swift)** inspects the model metadata and instantiates `TdtDecoderV2` when it detects a blank ID of 1024.

## Summary

- **Parakeet TDT v3** supports 25 European languages and uses **blank token ID 8192**, making it the default multilingual ASR pipeline in FluidAudio.
- **Parakeet TDT v2** is English-only and uses **blank token ID 1024**, requiring configuration adaptation via `TdtDecoderV2`.
- Both models share the same 0.6 billion parameter architecture and joint-network implementation, differing only in language coverage and tokenization conventions.
- The **[`TdtDecoderV2.swift`](https://github.com/fluidinference/fluidaudio/blob/main/TdtDecoderV2.swift)** wrapper transparently handles v2 compatibility by rewriting the config's blank ID before delegating to the v3 decoder.
- Unit tests in **[`Tests/FluidAudioTests/TdtDecoderV2Tests.swift`](https://github.com/fluidinference/fluidaudio/blob/main/Tests/FluidAudioTests/TdtDecoderV2Tests.swift)** validate the blank-ID adaptation logic (8192 → 1024) without modifying other configuration parameters.

## Frequently Asked Questions

### Can I use Parakeet TDT v2 for non-English audio?

No. According to the documentation in **[`Documentation/Models.md`](https://github.com/fluidinference/fluidaudio/blob/main/Documentation/Models.md)**, v2 is strictly an English-only model. For multilingual transcription covering 25 European languages, you must use the Parakeet TDT v3 model.

### Do I need to implement separate decoding logic for v2 and v3?

No. The FluidAudio library handles this transparently. While v3 uses `TdtDecoderV3` directly, v2 runs through **`TdtDecoderV2`**, which is a thin wrapper that adapts the configuration's blank ID to 1024 and then delegates all decoding work to the v3 decoder implementation.

### What is the performance difference between v2 and v3?

There is no performance difference in terms of speed or accuracy for supported languages. Both models utilize the same 0.6 billion parameter architecture and identical duration head implementations. The primary distinction is language coverage and the blank token convention.

### How does the FluidAudio CLI detect which model version I'm using?

The CLI inspects the model's metadata during initialization. If the metadata reports a blank token ID of 1024, the system automatically selects `TdtDecoderV2` to handle the configuration adaptation. For the standard blank ID of 8192, it uses the default v3 decoding path.