Nemotron 3.5 ASR overview: multilingual audio across 40 language-locales is transcribed by a cache-aware FastConformer-RNNT model with language-ID prompting into punctuated text with an automatic language tag
[!Note]
This model is the multilingual extension of nvidia/nemotron-speech-streaming-en-0.6b, adding language-ID prompt conditioning to support transcription across 40 language-locales from a single model.
Nemotron 3.5 ASR is a multilingual, streaming Automatic Speech Recognition (ASR) model engineered to deliver high-quality multilingual transcription across both low-latency streaming and high-throughput batch workloads. Developed by NVIDIA, this 600M parameter model transcribes speech into text with native support for punctuation and capitalization, and offers runtime flexibility with configurable chunk sizes, including 80ms, 160ms, 320ms, 560ms, and 1120ms.
By leveraging a state-of-the-art Cache-Aware FastConformer-RNNT architecture, the model eliminates redundant overlapping computations common in traditional "buffered" streaming. This allows it to process only new audio chunks while reusing cached encoder context, significantly improving computational efficiency and minimizing end-to-end delay without sacrificing accuracy.
It was trained on a massive ASR dataset and is engineered to perform across diverse and challenging acoustic conditions.
This model is ready for commercial use.
License/Terms of Use
Governing Terms: Use of the model is governed by the OpenMDW-1.1 license.
Deployment Geography
Global
Use Case
This model is for transcription of multilingual audio.
🌍 Single Multilingual Model: Transcribes 40 language-locales from one model through language-ID prompt conditioning, with optional automatic language detection.
⚡ Native Streaming Architecture: Cache-aware design enables efficient processing of continuous audio streams, designed and optimized for low-latency voice agent applications.
💰 Improved Operational Efficiency: Delivers superior throughput compared to traditional buffered streaming approaches. This allows for a higher number of parallel streams within the same GPU memory constraints, directly reducing operational costs for production environments.
🎛️ Dynamic Runtime Flexibility: Choose the optimal operating point on the latency-accuracy Pareto curve at inference time. No re-training is required to adjust for different use-case requirements.
📝 Punctuation & Capitalization: Built-in support for punctuation and capitalization in output text.
Supported Languages
The model supports 40 language-locales in total, across three tiers:
Transcription-ready (19 locales): highest-accuracy ASR, ready out of the box.
Broad-coverage (13 locales): production ASR across an additional 13 locales.
Adaptation-ready (8 locales): recognized by the tokenizer; fine-tune on in-domain data to unlock full transcription.
Tier
Languages (locales)
Transcription-ready (19 locales)
English (en-US, en-GB), Spanish (es-US, es-ES), French (fr-FR, fr-CA), Italian (it-IT), Portuguese (pt-BR, pt-PT), Dutch (nl-NL), German (de-DE), Turkish (tr-TR), Russian (ru-RU), Arabic (ar-AR), Hindi (hi-IN), Japanese (ja-JP), Korean (ko-KR), Vietnamese (vi-VN), Ukrainian (uk-UA)
Broad-coverage (13 locales)
Polish (pl-PL), Swedish (sv-SE), Czech (cs-CZ), Norwegian Bokmål (nb-NO), Danish (da-DK), Bulgarian (bg-BG), Finnish (fi-FI), Croatian (hr-HR), Slovak (sk-SK), Mandarin (zh-CN), Hungarian (hu-HU), Romanian (ro-RO), Estonian (et-EE)
Adaptation-ready (8 locales)
Greek (el-GR), Lithuanian (lt-LT), Latvian (lv-LV), Maltese (mt-MT), Slovenian (sl-SI), Hebrew (he-IL), Thai (th-TH), Norwegian Nynorsk (nn-NO)
Note: Transcription-ready and broad-coverage locales (32 total) produce ASR transcription out of the box; adaptation-ready locales require fine-tuning on in-domain data to enable full transcription. The model supports uppercase and lowercase letters, punctuation, spaces, and apostrophes.
Note: We would recommend Nemotron ASR Streaming (English) model for English-only transcription use cases. For all other transcription ready locales, we recommend Nemotron 3.5 ASR to leverage its expanded multilingual capabilities.
[!Tip]
Automatic language detection / language tagging: When run with target_lang=auto, the model detects the spoken language and emits the corresponding language code/tag in the output following the terminal punctuation. This lets a single deployment transcribe mixed-language traffic and automatically label each utterance with its detected language — no separate language-ID component required.
Model Architecture
Architecture Type: FastConformer-CacheAware-RNNT with Prompt
This model consists of a cache-aware streaming Parakeet (FastConformer) encoder with an RNN-T decoder and language-ID prompt conditioning. It is based on the Cache-Aware [1] FastConformer [2] architecture with 24 encoder layers and an RNNT (Recurrent Neural Network Transducer) decoder. The cache-aware streaming design enables efficient processing of audio in chunks while maintaining context from previous frames. Unlike buffered inference, this model maintains caches for all encoder self-attention and convolution layers. This enables reuse of hidden states at every streaming step, where cached activations eliminate redundant computations. As a result, there are no overlapping computations; each processed frame is strictly non-overlapping. This model leverages prompts to guide the transcription process, enabling language-specific transcription from a single ASR model through language ID conditioning.
Nemotron 3.5 ASR architecture: FastConformer encoder and language-ID encoding are concatenated, projected, and fed to the RNNT decoder
The language-ID prompt is fused with the acoustic representation as follows:
FastConformer encoder processes audio into an acoustic embedding of shape (D=512, T).
Language Encoding expands a 128-dim one-hot language vector across the time axis → (K=128, T), broadcasting the language identity to every frame.
Concatenation along the feature axis → fused tensor (D + K, T).
Projection layer maps the fused features to the RNNT decoder.
ASR performance is measured using Word Error Rate (WER) on the FLEURS test sets. Accuracy stays strong across both modes and improves as the chunk size grows, while remaining competitive even at the lowest-latency 80ms setting. Full tables are in Performance.
FLEURS average WER vs streaming chunk size (LangID vs Auto-detect)
FLEURS WER by language: LangID vs Auto-detect at 320ms chunk
Note: Japanese and Korean are measured using Character Error Rate (CER) rather than WER, as is standard for these languages.
Throughput & Efficiency
Despite being roughly half the size (0.6B vs. 1.1B), Nemotron 3.5 ASR serves far more concurrent streams at far lower latency than the Parakeet RNNT 1.1B multilingual model, which runs on buffered streaming. The cache-aware streaming design avoids the redundant recomputation of buffered inference, so a single H100 can sustain dramatically higher concurrency at every chunk size — directly lowering the cost per stream in production. At the lowest-latency 80ms setting, Nemotron sustains ~17× more concurrent streams (240 vs. 14); at the 1120ms setting it sustains 6× more (2,400 vs. 400). The latency-vs-concurrency curves tell the same story: Nemotron (solid green) holds low final-token latency well past 1,000 parallel requests, while Parakeet RNNT 1.1B (dashed blue) saturates after only a few hundred.
Concurrent streams supported on a single H100: Nemotron ASR streaming vs Parakeet RNNT, across chunk sizes
Median final-token latency vs number of parallel requests on a single H100, Nemotron vs Parakeet RNNT across chunk sizes
Measured on a single NVIDIA H100. Throughput is the number of real-time streams sustainable in parallel; latency is the median final-token latency at a given level of concurrency.
Explore more from NVIDIA
For documentation, deployment guides, enterprise-ready APIs, and the latest open models—including Nemotron and other cutting-edge speech, translation, and generative AI—visit the NVIDIA Developer Portal at developer.nvidia.com.
Join the community to access tools, support, and resources to accelerate your development with NVIDIA's NeMo, Speech NIM, and foundation models.
To train, fine-tune or perform inference with this model, you will need to install NVIDIA NeMo[4]. We recommend you install it after you've installed Cython and latest PyTorch version.
This is a prompt-conditioned multilingual model: pass the target language with target_lang (e.g. en-US, es-ES, de-DE), or use target_lang=auto for automatic language detection.
bash
1cd NeMo
2python examples/asr/asr_cache_aware_streaming/speech_to_text_cache_aware_streaming_infer.py \3model_path=<model_path>\4dataset_manifest=<dataset_manifest>\5batch_size=<batch_size>\6target_lang=<lang_id>\#language key (e.g. en-US) or "auto" for automatic language detection7att_context_size="[56,13]"\#set the second value to the desired right context from {0,1,3,6,13}8strip_lang_tags=true \#true: remove the detected language tag from the text; false: keep it in the output9output_path=<output_folder>
strip_lang_tags controls how the detected language tag is handled in the output. The model appends a language tag (e.g. <en-US>) after the transcript's terminal punctuation:
strip_lang_tags=false (keep): the tag is left in the output, so you can read the detected language directly from each utterance — useful for mixed-language traffic and language labeling.
strip_lang_tags=true (remove): the tag is stripped, leaving only the clean transcript text — useful when you only need the spoken words.
Setting up Streaming Configuration
Latency is defined by the att_context_size param, where att_context_size = {num_frames_left_context, num_frame_right_context}, all measured in 80ms frames:
[56, 0]: Chunk size = 1 (1 × 80ms = 0.08s)
[56, 1]: Chunk size = 2 (2 × 80ms = 0.16s)
[56, 3]: Chunk size = 4 (4 × 80ms = 0.32s)
[56, 6]: Chunk size = 7 (7 × 80ms = 0.56s)
[56, 13]: Chunk size = 14 (14 × 80ms = 1.12s)
Here, chunk size = current frame + right context; each chunk is processed in non-overlapping fashion.
Input(s):
Input Type(s): Audio, Lang ID
Input Format(s): wav, string
Input Parameters: One-Dimensional (1D) for audio and One-Dimensional (1D) for Lang ID
Other Properties Related to Input: Maximum Length in seconds specific to GPU Memory, No Pre-Processing Needed, Mono channel is required.
By leveraging NVIDIA’s hardware (e.g. GPU cores) and software frameworks (e.g., CUDA libraries), the model achieves faster training and inference times compared to CPU-only solutions.
Output
Output Type(s): Text String in Input Language
Output Format(s): String
Output Parameters: One-Dimensional (1D)
Other Properties Related to Output: No Maximum Character Length, transcribe punctuation and capitalization.
By leveraging NVIDIA’s hardware (e.g. GPU cores) and software frameworks (e.g., CUDA libraries), the model achieves faster training and inference times compared to CPU-only solutions.
The integration of foundation and fine-tuned models into AI systems requires additional testing using use-case-specific data to ensure safe and effective deployment. Following the V-model methodology, iterative testing and validation at both unit and system levels are essential to mitigate risks, meet technical and functional requirements, and ensure compliance with safety and ethical standards before deployment.
Model Version(s):
nemotron-3.5-asr-streaming-0.6b-v1
Training and Evaluation Datasets:
Training Datasets
It was trained on speech data across 40 language-locales. The training data is a dynamic blend of public and proprietary internal datasets normalized to have spoken forms in text with punctuation and capitalization, including:
NVIDIA Riva multilingual ASR training set (Proprietary)
The model was evaluated on multilingual ASR benchmarks:
FLEURS
Mozilla Common Voice (MCV)
Multilingual LibriSpeech (MLS)
NVIDIA internal multilingual evaluation sets
** Data Collection Method by dataset
Human
** Labeling Method by dataset
Human
Performance
ASR performance is measured using the Word Error Rate (WER). The tables below report WER (%) on the FLEURS test sets across configurable streaming chunk sizes, in two modes:
Language Input (LangID): the target language is provided to the model.
Auto-detect: the model automatically detects the spoken language.
Note: Japanese, Korean, and Mandarin are evaluated using Character Error Rate (CER) rather than WER, as is standard for these languages.
Note on text normalization: WER/CER are computed after text normalization that aligns the reference and hypothesis (e.g., casing, punctuation, numerals, and formatting conventions). Normalization is not perfect across all 40 language-locales, and residual mismatches between normalized text can inflate the reported error rates — actual transcription quality may be somewhat better than the numbers suggest.
Transcription-ready (19 locales)
Languages are ordered by accuracy (lowest WER first).
Language
Language Input (LangID)
Auto-detect
80ms
160ms
320ms
560ms
1.12s
80ms
160ms
320ms
560ms
1.12s
Spanish (es-US, es-ES)
4.87
4.64
4.39
4.26
4.11
5.04
4.82
4.48
4.34
4.13
Italian (it-IT)
5.23
4.85
4.83
4.41
4.25
5.28
4.89
4.84
4.47
4.32
Portuguese (pt-BR, pt-PT)
6.29
6.10
5.81
5.65
5.48
6.41
6.19
5.82
5.57
5.47
Hindi (hi-IN)
8.13
7.97
7.41
7.05
6.81
11.47
10.83
9.88
9.26
8.23
Korean (ko-KR)
7.59
7.70
7.27
7.18
7.12
8.31
8.18
7.81
7.49
7.30
English (en-US, en-GB)
9.43
8.88
8.27
7.99
7.91
9.72
9.34
8.84
8.80
8.84
German (de-DE)
9.81
9.21
8.83
8.42
8.31
9.90
9.37
8.87
8.58
8.22
French (fr-FR, fr-CA)
10.97
10.60
9.79
9.45
9.03
11.03
10.60
9.84
9.46
9.02
Russian (ru-RU)
10.84
10.73
9.87
9.60
9.17
12.47
12.09
11.01
10.57
10.03
Turkish (tr-TR)
12.34
12.33
12.05
11.34
11.17
12.61
12.28
11.93
11.51
11.32
Vietnamese (vi-VN)
13.41
12.87
12.29
11.78
11.18
13.59
13.02
12.40
12.02
11.22
Dutch (nl-NL)
14.03
13.43
12.17
11.97
11.46
14.09
13.80
12.62
12.24
11.70
Japanese (ja-JP)
13.87
12.90
12.22
11.91
11.48
14.97
13.85
13.00
12.38
11.66
Arabic (ar-AR)
13.17
12.65
12.55
12.13
12.03
13.47
12.85
12.67
12.18
12.06
Ukrainian (uk-UA)
15.70
15.21
14.55
13.67
13.07
18.81
17.96
16.79
15.60
14.59
Average
10.38
10.00
9.49
9.12
8.84
11.14
10.67
10.05
9.63
9.21
Broad-coverage (13 locales)
Languages are ordered by accuracy (lowest WER first).
Language
Language Input (LangID)
Auto-detect
80ms
160ms
320ms
560ms
1.12s
80ms
160ms
320ms
560ms
1.12s
Polish (pl-PL)
19.88
18.92
17.48
16.61
15.15
22.65
21.63
20.05
18.52
16.55
Norwegian Bokmål (nb-NO)
20.43
20.07
18.90
18.44
18.10
20.91
20.19
19.29
18.76
18.01
Finnish (fi-FI)
21.19
20.57
20.05
18.94
18.34
21.61
20.88
20.40
19.36
18.72
Mandarin (zh-CN)
20.56
20.22
20.03
19.51
19.28
22.45
21.07
20.59
20.40
19.87
Czech (cs-CZ)
24.18
23.20
22.41
21.04
20.41
25.81
25.12
23.68
22.55
21.45
Bulgarian (bg-BG)
24.50
23.58
22.80
21.70
20.53
28.28
27.22
25.54
24.05
21.84
Slovak (sk-SK)
25.08
24.14
23.73
22.51
21.28
27.59
26.06
25.61
24.15
22.68
Swedish (sv-SE)
25.61
24.85
23.63
22.72
22.17
26.28
25.56
24.18
23.57
22.53
Croatian (hr-HR)
27.92
27.09
25.79
24.92
23.97
32.13
31.20
29.65
28.95
27.46
Romanian (ro-RO)
31.52
30.93
29.04
27.77
25.90
34.22
33.26
30.97
29.84
26.88
Estonian (et-EE)
29.95
29.66
28.59
27.37
26.35
30.58
30.09
28.72
28.03
27.19
Danish (da-DK)
32.62
31.51
30.00
28.92
27.49
33.15
31.77
30.22
29.33
27.81
Hungarian (hu-HU)
32.70
32.03
30.92
29.72
28.68
33.40
32.39
31.49
30.20
29.18
Average
25.86
25.14
24.11
23.09
22.13
27.62
26.65
25.41
24.44
23.09
Adaptation-ready languages (fine-tune to enable)
These 8 language-locales are recognized by the tokenizer but are not tuned for production transcription out of the box: Greek (el-GR), Hebrew (he-IL), Lithuanian (lt-LT), Slovenian (sl-SI), Latvian (lv-LV), Maltese (mt-MT), Thai (th-TH), and Norwegian Nynorsk (nn-NO). Fine-tuning on in-domain data is recommended to bring them to production quality.
Check our blog post of how to fine-tune Nemotron 3.5 ASR to improve these languages, including before/after results.
Ethical Considerations
NVIDIA believes Trustworthy AI is a shared responsibility and we have established policies and practices to enable development for a wide array of AI applications. When downloaded or used in accordance with our terms of service, developers should work with their internal model team to ensure this model meets requirements for the relevant industry and use case and addresses unforeseen product misuse.
Please report model quality, risk, security vulnerabilities or NVIDIA AI Concerns here.
