Fun-ASR-Nano-2512 — LiteRT-LM

FunAudioLLM/Fun-ASR-Nano-2512 converted to the LiteRT-LM (.litertlm) format for on-device speech recognition with Google's LiteRT-LM runtime. Audio in, text out, one file.

On 2026-11-17 Fun-ASR-Nano-2512.litertlm was replaced with a file whose prefill/decode graph is rewritten for the GPU, with every weight unchanged. On this card, "this file" means the new file and "the previous file" the one it replaced. On a Galaxy S26, this file's language model decoded 51.45 and 51.43 tokens/s on the GPU in its two runs (the previous file: 26.75 and 26.76) and 21.43 to 22.66 tokens/s on the CPU in four runs, each after a 1,024-token prefill (LiteRT-LM v0.19.0, 2026-11-17; see Performance). This file was run only with LiteRT-LM 0.19.0 to 0.19.2; earlier runtimes were not tried with it.

Fun-ASR-Nano-2512 is Tongyi Lab's end-to-end speech recognition model. A SenseVoice SAN-M audio encoder (70 layers) and a 2-layer adaptor feed a Qwen3-0.6B language model, which writes the transcript. It covers Chinese (with 7 dialects and 26 regional accents), English and Japanese, and accepts hotwords in the prompt. License: Apache-2.0.

The file runs on LiteRT-LM's generic audio path. The runtime cuts 16 kHz PCM into 60 ms frames, runs the file's audio encoder, and puts the audio embeddings into a ChatML prompt. It needs no change to the runtime or the converter.

File Recipe Size
Fun-ASR-Nano-2512.litertlm LM int8 dynamic (weights) with an int8 embedding table, fp32 activations declared for the GPU · audio encoder fp16 weights, fp32 compute, 30.24 s window 1.26 GB
Section Content Size
tf_lite_audio_encoder_hw fbank + LFR front end, SAN-M encoder, adaptor 473 MB
tf_lite_prefill_decode Qwen3-0.6B, int8 622 MB
tf_lite_embedder token embedding table, int8 159 MB
HF_Tokenizer_Zlib Qwen3 tokenizer 2.1 MB
LlmMetadataProto prompt template, stop tokens, audio settings 1.7 KB

How to send audio

One message = one utterance of up to 30 s. The encoder reads a fixed 30.24 s window (504 frames of 960 samples at 16 kHz) and returns up to 63 embeddings. A longer clip in one message is cut by the runtime into several windows. On a 60.2 s test clip the model then transcribed only the first window's speech (WER 83/143).

Longer audio: split it and use a new conversation per piece. Cut the audio into pieces of at most 30 s (at pauses if you can), send each piece in a fresh conversation, and join the texts. On the same 60.2 s clip, cut at 30.24 s, this scored WER 10/143, the same as the original model on the whole clip (10/143). Sending the two pieces as two turns of one conversation scored 22/143: the second turn repeats the start of the first.

Prompt. A message with audio only gets the model's default instruction 语音转写: ("transcribe the speech") from the file's template. To change the task, put one of the model's own instructions in the same message as a text item; the template places it before the audio:

Task Text item
Transcribe (default, no text item needed) 语音转写:
Transcribe without inverse text normalization 语音转写,不进行文本规整:
Transcribe in a given language (中文, 英文, 日文) 语音转写成英文:
Hotwords see below

With the instruction that skips inverse text normalization, the 20 LibriSpeech clips (Mac CPU) scored English WER 17/448. The original model with the same instruction scored 16/448, and 16 of 20 transcripts are identical.

Hotwords use the full instruction below, with the words in the list:

请结合上下文信息,更加准确地完成语音转写任务。如果没有相关信息,我们会留空。


**上下文信息:**


热词列表:[Birket Foster, John Collier]
语音转写:

On a LibriSpeech clip with these two hotwords, the model wrote "John Collier" instead of "Joan Collier". The clip's WER went from 10/68 to 8/68 (the original model: 11/68 to 6/68). "Birket" still came out as "Burkett", as it does in the original model.

Notes:

  • Send 16 kHz mono PCM WAV. The runtime can also decode MP3 itself, but on 3 of 5 official MP3 samples its text differed from the text of the same audio decoded to WAV by ffmpeg.
  • The encoder takes the clip length from the last non-zero sample (the runtime passes no length), so digital silence at the very end is treated as padding. On the test clips this changed no transcript.
  • No timestamps: the checkpoint has no CTC decoder weights, so this file has no CTC branch.

Correctness

25 clips: the model's 5 example clips (zh, en, ja, ko, yue) and 20 LibriSpeech dev-clean clips (448 words). Reference = the original model in funasr 1.4.16, fp32, greedy decoding. All runs below use greedy decoding (top-k 1), one conversation per clip, and the audio encoder on the CPU.

Runtime LM backend Same text as the reference English WER
Reference: funasr, fp32 PyTorch — — 4.46 % (20/448)
LiteRT-LM 0.17.1 (Python), Apple M4 Max CPU 21/25 4.24 % (19/448)
LiteRT-LM 0.17.1 (Python), Apple M4 Max GPU (WebGPU over Metal) 24/25 4.46 % (20/448)
LiteRT-LM v0.16.1 CLI, Galaxy S26 (SM-S942Q) CPU 21/25 4.46 % (20/448)
LiteRT-LM v0.16.1 CLI, Galaxy S26 (SM-S942Q) GPU (OpenCL) 24/25 4.46 % (20/448)

No run produced an empty or looping output. With the encoder and the language model left in fp32, the runtime's text equals the reference on 25/25 clips, so the differences above come from quantization. On the CPU they are one surname's spelling ("Birket" on the Mac, "Burkett" on the S26, "Burkitt" in the reference), punctuation on two clips, and kana on the Korean example (the model card lists Chinese, English and Japanese for this model; the reference model also returns kana for that clip). On the GPU the only difference is the punctuation of one quote.

FLEURS test, 50 clips per language, same reference model and settings:

Language Metric This model (Mac CPU) Reference (funasr fp32)
English WER 5.48 % 5.13 %
Mandarin CER 6.86 % 6.86 %
Japanese CER 6.81 % 6.95 %

WER counts words after uppercasing and removing punctuation. CER counts characters after NFKC normalization and lowercasing, with all punctuation, separators and whitespace removed. Ground truth: FLEURS raw_transcription.

Everything above in this section was measured on earlier files. This file was compared with the previous file on the 25 clips on a Mac with litert-lm 0.19.2 (2026-11-15, greedy decoding, audio encoder on the CPU). With the language model on the CPU (1 thread), the two files gave the same text for all 25 clips, byte for byte (19/448 English word errors with both files). With the language model on the Mac GPU, the two files also gave the same text for all 25 clips (20/448 with both files).

Usage

Python (pip install litert-lm-api; this file answers on 0.19.0 to 0.19.2, the releases checked). On 2026-11-17 the block below was run as written on 0.19.2 on a Mac: once with this file and once with the previous file. Both runs printed the same text.

import os
import litert_lm
from litert_lm import Content, Contents, Message
from litert_lm.interfaces import CPU, GPU

engine = litert_lm.Engine("Fun-ASR-Nano-2512.litertlm", backend=GPU(), audio_backend=CPU())
sampler = litert_lm.SamplerConfig(top_k=1, top_p=1.0, temperature=0.0)

def transcribe(wav_path, instruction=None):
    items = [Content.AudioFile(os.path.abspath(wav_path))]  # 16 kHz mono WAV, up to 30 s
    if instruction:                                          # e.g. "语音转写,不进行文本规整:"
        items.insert(0, Content.Text(instruction))
    conv = engine.create_conversation(sampler_config=sampler, max_output_tokens=512)
    try:
        resp = conv.send_message(Message.user(Contents.of(items)))
    finally:
        conv.close()
    return "".join(part["text"] for part in resp["content"] if part["type"] == "text")

print(transcribe("clip.wav"))

Kotlin (LiteRT-LM Android/JVM API):

val engine = Engine(EngineConfig(
    modelPath = "/path/to/Fun-ASR-Nano-2512.litertlm",
    backend = Backend.GPU(),        // or Backend.CPU()
    audioBackend = Backend.CPU(),   // the audio encoder runs on the CPU
    cacheDir = context.cacheDir.path,
))
engine.initialize()

// One conversation per utterance (up to 30 s).
val text = engine.createConversation(ConversationConfig(
    samplerConfig = SamplerConfig(topK = 1, topP = 1.0, temperature = 0.0),
    maxOutputToken = 512,
)).use { conversation ->
    conversation.sendMessage(Contents.of(Content.AudioFile("/path/to/clip.wav"))).toString()
}

On Android the GPU backend also needs <uses-native-library android:name="libOpenCL.so" android:required="false"/> inside <application> in the app manifest.

CLI (litert_lm_advanced_main, built from the LiteRT-LM v0.16.1 tag; the command used for the Galaxy S26 rows under Correctness, measured on earlier files):

./litert_lm_advanced_main --backend=gpu --audio_backend=cpu --sampler_backend=cpu \
    --model_path=Fun-ASR-Nano-2512.litertlm --max_num_tokens=2048 --max_output_tokens=512 \
    --input_prompt='[audio:/path/to/clip.wav]'

Keep audio_backend on the CPU. The language model runs on the CPU or the GPU.

If you download this file with the litert-lm command-line tool (PyPI litert-lm, not the litert_lm_advanced_main program above) and it stops right after the download with no error message of its own (a bus error; exit status 138 on a Mac) or with an error log that contains too large for file size, the downloaded file may be incomplete. The litert-lm CLI (0.14.0 to 0.19.2, and litert-lm-nightly 0.20.0.dev20261112) can keep an incomplete download in ~/.litert-lm/cache/huggingface/litert-community/Fun-ASR-Nano-2512/ and uses it again on later runs without checking its size. Delete that file and run the command again (after an import, run the import again). This was measured with other models' files, not with this one.

If you downloaded Fun-ASR-Nano-2512.litertlm with the litert-lm CLI's --from-huggingface-repo before it was replaced on 2026-11-17 (12:04 UTC), delete it from ~/.litert-lm/cache/huggingface/litert-community/Fun-ASR-Nano-2512/, then run your command again (after an import, run the import again). Without deleting it, the litert-lm CLI (0.14.0 to 0.19.2) keeps running the previous file: it uses a file it finds there without checking it against this repo. The previous file stays at revision a3ca7c2.

Performance

This file's speed was measured on 2026-11-17 on a Galaxy S26 (GPU and CPU) and on a Pixel 11 Pro (GPU), in the next three subsections. It was not measured on a Mac or on the Pixel 11 Pro's CPU. On the Galaxy S26 the GPU is the faster backend for this file's language model: it decoded 51.45 and 51.43 tok/s and prefilled 653 and 656 tok/s on the GPU, against 21.43 to 22.66 tok/s and 458 to 503 tok/s on the CPU in the same workload. The Galaxy S26 table under "Earlier files", where the CPU decoded faster than the GPU (31.6 against 26.3 tok/s), was measured on an earlier file with LiteRT-LM v0.16.1 and a 256-token prefill.

Each run prefills 1,024 tokens and generates 256 tokens, three times in one process (three iterations), with a text prompt (language model only) and a context of 2,048 tokens. The program is litert_lm_advanced_main built from the LiteRT-LM v0.19.0 source (commit 771b06e1; the tag's own commit after it changes only Package.swift and README.md), run with --backend=gpu or --backend=cpu and --async=false --benchmark --benchmark_prefill_tokens=1024 --benchmark_decode_tokens=256 --num_iterations=3 --max_num_tokens=2048. Each run is a new process. Each value in the tables is one run's mean of iterations 2–3, so it leaves out iteration 1, the first pass after the engine starts. Four runs went in the order previous, this, this, previous: runs 1 and 2 are the first pair, runs 4 and 3 the second. Each ratio below is this file's value divided by the previous file's value in the same pair.

Galaxy S26 — GPU (2026-11-17)

Samsung Galaxy S26 (SM-S942Q, Snapdragon SM8850), language model on the GPU (OpenCL):

Run File Prefill, 1,024 tokens Decode Time to first token
1 previous 493.92 tok/s 26.75 tok/s 2.18 s
2 this 653.18 tok/s 51.45 tok/s 1.59 s
3 this 656.04 tok/s 51.43 tok/s 1.58 s
4 previous 600.20 tok/s 26.76 tok/s 1.75 s

Decode is ×1.924 in the first pair and ×1.922 in the second. Prefill is ×1.322 and ×1.093. Run 1 lifts the first prefill ratio: during it the GPU driver's thermal level rose to 6, which limits the GPU clock to 826 MHz, and its iteration 2 prefilled 406.69 tok/s (its iterations 1 and 3: 596.88 and 581.15 tok/s). In runs 2–4 that level reached 1 at most. In iteration 1 alone, the prefill ratios are ×1.090 and ×1.095. Every run started at Android's thermal status 0. A system app (Google Play services) was in the foreground when each run started.

Both files also transcribed two clips on this phone, the model's Chinese example clip and one LibriSpeech clip, with the audio encoder on the CPU, the language model on the GPU and greedy decoding (--audio_backend=cpu --sampler_top_k=1). The two files returned the same text for each clip: 开饭时间早上九点至下午五点。 and "Mr Quilter is the apostle of the middle classes, and we are glad to welcome his gospel."

Galaxy S26 — CPU (2026-11-17)

The same phone, language model on the CPU (4 threads, the program's default). Two sets of four runs were made. In each set one more run of this file came first as a warm-up and is not counted.

Set Run File Prefill, 1,024 tokens Decode Time to first token
1 1 previous 442.13 tok/s 20.13 tok/s 2.38 s
1 2 this 479.11 tok/s 21.69 tok/s 2.21 s
1 3 this 457.66 tok/s 21.43 tok/s 2.29 s
1 4 previous 451.96 tok/s 21.74 tok/s 2.32 s
2 1 previous 483.80 tok/s 22.89 tok/s 2.16 s
2 2 this 502.60 tok/s 22.66 tok/s 2.09 s
2 3 this 494.56 tok/s 22.32 tok/s 2.12 s
2 4 previous 481.26 tok/s 22.61 tok/s 2.18 s

On the CPU this file decoded 1.0 % to 1.4 % slower than the previous file in each pair (the first set's first pair is read on iteration 1, see below). Two runs of this file in one set differ by about as much: 1.2 % and 1.5 %. This file prefilled 1.3 % to 3.9 % faster. In the second set the prefill ratios are ×1.039 and ×1.028 and the decode ratios ×0.990 and ×0.987, so this file decoded 1.0 % and 1.3 % slower, less than the 1.5 % between this file's own two runs in that set (22.32 against 22.66 tok/s). During this file's two runs the phone limited the CPU's big cores (cpufreq policy6) to a lower maximum frequency (1.75 GHz at the lowest) than during the previous file's two runs (1.86 GHz), which works against this file. Every run of the second set started at Android's thermal status 0.

In the first set, runs 1 and 2 started at Android's thermal status 1 and runs 3 and 4 at 0. During run 1, a run of the previous file, the phone limited the big cores to 1.50 GHz at the lowest, against 1.75 GHz in the other three runs. The ratios are prefill ×1.084 and ×1.013 and decode ×1.077 and ×0.986. The first pair's ratios favour this file because run 1 was limited more, so they are not read as a gain; iteration 1 of the same two runs gives prefill ×1.013 and decode ×0.989. In the second pair, where both runs were limited to 1.75 GHz, this file decoded 1.4 % slower than the previous file, which is more than the 1.2 % between this file's own two runs in that set (21.43 against 21.69 tok/s). The second set was run for that reason.

In all eight runs iteration 1 was faster than iterations 2–3: prefill 727 to 755 tok/s and decode 27.5 to 29.4 tok/s. Every run started with no limit on the CPU's frequency, and the phone set one during the run. A system app (Google Play services) was in the foreground when each run started.

Pixel 11 Pro — GPU (2026-11-17)

Pixel 11 Pro, language model on the GPU:

Run File Prefill, 1,024 tokens Decode Time to first token
1 previous 494.94 tok/s 12.24 tok/s 2.16 s
2 this 536.19 tok/s 14.54 tok/s 1.98 s
3 this 538.44 tok/s 14.37 tok/s 1.97 s
4 previous 501.85 tok/s 11.56 tok/s 2.13 s

Decode is ×1.188 in the first pair and ×1.244 in the second. Prefill is ×1.083 and ×1.073. Android's thermal status stayed at 0 in all four runs. The two clips of the Galaxy S26 GPU subsection, run the same way on this phone, gave the same two texts with both files.

Earlier files — Mac and Galaxy S26

litert-lm benchmark (litert-lm 0.17.1), Apple M4 Max, -p <P> -d 256 --runs 3 --cache no, text prompt (language model only), one reading per configuration, at least 300 s of rest before each GPU reading. Measured with a background load average of 5.8–16.0 (1-minute, at the start of each measurement); not a quiet machine.

Backend Prefill, p=256 Prefill, p=512 Decode TTFT (p=256) Init
GPU (WebGPU over Metal) 3,091 tok/s 6,170 tok/s 143.0 tok/s 0.10 s 1.1 s
CPU 1,027 tok/s 1,350 tok/s 48.9 tok/s 0.48 s 2.1 s

Init is the Init time the CLI prints; that value includes both Init Total and the phases inside it, so it counts engine creation twice (LiteRT-LM #4057).

The prefill signatures are 512, 128 and 32 tokens. At p=256 the runtime runs one padded 512-token call on the GPU and two 128-token calls on the CPU, so the p=512 column shows the GPU's unpadded rate.

End to end on the Mac (audio in, text out; engine loaded once, one conversation per clip, the 25 clips above, 217.5 s of audio): 0.37 s per clip with the language model on the GPU (real-time factor 0.046), 0.68 s on the CPU (0.091). The audio encoder alone takes 164 ms per 30.24 s window (8 threads). With the runtime cache from earlier runs in place, creating the engine took 0.1 s (CPU) / 0.2 s (GPU), and the first clip 1.45 s / 0.51 s.

Galaxy S26 (SM-S942Q, Snapdragon SM8850), litert_lm_advanced_main built from the LiteRT-LM v0.16.1 tag, --benchmark --benchmark_prefill_tokens=256 --benchmark_decode_tokens=256, text prompt (language model only), one reading per backend, CPU uncapped and SKIN below 40 °C before each run:

Backend Prefill (256) Decode TTFT Peak memory (25-clip run)
GPU (OpenCL) 386 tok/s 26.3 tok/s 0.70 s 2,233 MB
CPU 331 tok/s 31.6 tok/s 0.80 s 2,411 MB

With the engine loaded once (a Kotlin app on LiteRT-LM Android 0.17.1, language model and audio encoder on the CPU), the three official samples took 1.03 s (5.6 s of Chinese), 1.24 s (7.2 s of English) and 1.42 s (7.2 s of Japanese) from sendMessage to the text; engine load 0.64 s with the runtime cache present. No such measurement was made with the language model on the GPU.

Sample app (Android): android/ — one app for this model and two other models (Qwen3-ASR-1.7B, Fun-ASR-Nano-2512, Confucius4-R2T2): a model picker, hold-to-talk up to 30 s and three FLEURS clips, with a device check. Galaxy S26, language model and audio encoder on the CPU (4 threads), the 6.4 s English clip in 1.19 s, the 9.7 s Mandarin clip in 1.95 s and the 11.0 s Japanese clip in 1.83 s; a 9 s microphone recording in 1.44 s with no character error, measured by the app's device check on 2026-10-10 (CPU at its full clock); the app uses LiteRT-LM Android 0.17.1, which was not tried with this file.

Conversion notes

Converted with litert-torch 0.9.4 (audio encoder) and 0.9.3 (language model), ai-edge-quantizer 0.9.0 / 0.8.0, litert-lm-builder 0.16.1 and transformers 5.14.1, with the converter scripts of hf-to-litertlm. Source: the tensors of FunAudioLLM/Fun-ASR-Nano-2512-vllm, which equal the official model.pt bit for bit.

  • Audio encoder = one graph from raw PCM. The Kaldi fbank, the 7-frame low-frame-rate stacking (LFR), the 70-layer SAN-M encoder and the adaptor are exported together: audio f32 [1, 504, 960] → features f32 [1, 63, 1024] + mask uint8 [1, 63]. The runtime keeps the embeddings up to the last non-zero mask entry, so the graph decides how many tokens a clip gets. In fp32 the graph's features match the original model's within cos ≥ 0.99999 on 23 of 25 clips. The other two clips end in digital silence and lose one 60 ms feature frame (see Notes above); their transcripts are unchanged.
  • fp16 encoder weights. With the weights cast to fp16 (compute stays fp32), the encoder plus an fp32 language model gives the reference text on 25/25 clips (worst cosine 0.9999983 against the fp32 encoder). Int8 dynamic weights on the encoder's linear layers changed 6 of 25 transcripts (English WER 17/448), so this file does not use them.
  • Language model. Int8 dynamic weights with an int8 embedding table, stored as a separate embedder section. An int4 variant (blockwise, 978 MB file) matched the reference on 14/25 clips with English WER 17/448. It is not shipped.
  • fp32 activations on the GPU. With the GPU's default fp16 activations the language model emits only ! tokens, also for a text-only prompt. The prefill/decode section therefore declares prefer_activation_type: fp32, which LiteRT-LM applies when the app sets no activation type. The CPU transcripts are the same with and without it.
  • Prompt contract in metadata. The ChatML template, the default instruction 语音转写:, the stop tokens (<|im_end|>, <|endoftext|>) and the audio settings (16 kHz, one channel, 960-sample frames, no mel extraction in the runtime) are stored in the file.

2026-11-17 — GPU graph (weights unchanged)

The prefill/decode graph of Fun-ASR-Nano-2512.litertlm now has the GPU form: 28 odml.cache_update composites for the KV cache and 56 attention composites. The previous file had neither; a check of its graph counted 56 DYNAMIC_UPDATE_SLICE and 56 BATCH_MATMUL ops instead. The prefill lengths (32, 128 and 512 tokens), the KV-cache length (2,048) and the weight quantization read the same before and after.

Only the prefill/decode graph section differs from the previous file: it went from 25,199,392 B to 25,551,464 B. The six other sections (metadata, tokenizer, embedder graph, audio encoder and the two weight sections) have the same size and sha256 as in the previous file. The whole file went from sha256 4ef61e7e… (1,255,948,288 B) to 21d63a68… (1,256,292,352 B).

With litert-lm 0.19.0, 0.19.1 and 0.19.2 on a Mac (2026-11-15), on the CPU and on the GPU, this file and the previous file both transcribed two test clips, to the same text byte for byte. The Mac comparison on 25 clips is under Correctness and the phone runs are under Performance.

Apart from this entry, the comparison with the previous file under Correctness and the three 2026-11-17 subsections of Performance, this card's measurements of this model were made with earlier files.

Known issues

  • The audio encoder does not run on the GPU. On the Mac the GPU delegate does not take three of its op types (DEQUANTIZE, PAD, SELECT_V2) and the conversation fails to start. Keep audio_backend on the CPU.
  • One message holds at most 30.24 s of audio. Split longer audio and use one conversation per piece (see above).
  • MP3 decoded by the runtime can give different text than the same audio as WAV; send WAV.
  • Quantization changes a few transcripts slightly: a surname's spelling and some punctuation (see Correctness).
  • No timestamps or CTC output.
  • From the second turn of a conversation on, LiteRT-LM puts the previous answer's stop token into the KV cache with a zero embedding, because this file holds the embedding table in its own section and the decoder takes embeddings, so later answers in a conversation can differ from the answer the model gives to the same messages in one prompt (read in the source of LiteRT-LM 0.16.0, 0.18.1 and 0.19.1; measured with 0.18.1 on WeVisOne-VL-2B and Qwen2.5-Coder-1.5B-Instruct, not on this file). One question per conversation avoids it, as does a new conversation that starts with the earlier messages and the new question.
  • From a conversation preface (the system message, initial messages, tools and extra context a conversation is created with) that has tools and no messages, LiteRT-LM renders this file's chat template with an empty message list, and the template reads messages[0] without checking that the list is non-empty, so the render fails with Failed to apply template: undefined value. This happens in two places: when the preface is prefilled at creation (prefillPrefaceOnInit = true in Kotlin, prefillPrefaceOnInit: true on the web, SetPrefillPrefaceOnInit(true) in C++; the default is false), where creating the conversation fails with that error, and in the preface render (renderPrefaceIntoString() in Kotlin and Swift, RenderPrefaceIntoString() in C++, litert_lm_conversation_render_preface_to_string in the C API). The same happens with extra context (such as enable_thinking) and no messages, and in the preface render with an empty preface (run in the runtime on one Qwen3 template; the other templates rendered with minijinja 2.14 and jinja2). Read in the source of LiteRT-LM 0.17.0, 0.18.1 and main; measured with LiteRT-LM 0.18.1 (the litert-lm package from PyPI) through its C API on this file's template text. The default path, where the first message is rendered together with the preface, is not affected: the Python API and the CLI of 0.18.1 expose neither the flag nor the preface render, and Google AI Edge Gallery sets neither (its source as read on 2026-10-25). A system message or any initial message in the conversation config avoids it.
  • On LiteRT-LM 0.18.1 and 0.19.1, once a message fails because it does not fit in the context window, every later message in that conversation fails as well (the next one with Task failed with state: 7). Start a new conversation after such an error. This was measured with other models' files, not with this one.

Known runtime issues

External weights (since 2026-10-30). In Fun-ASR-Nano-2512.litertlm, the weights sit in TFLiteWeights sections at the end of the file (LiteRT's external weights) instead of inside the model graph. On Android, the GPU path needs LiteRT-LM 0.19.0 or later: the GPU engine of the v0.18.0 and v0.18.1 Android builds crashes (SIGSEGV) on such a file (LiteRT-LM#3986). The earlier file with the weights inside the graph stays at revision a5ab745.

License and changes

Distributed under the Apache License 2.0, the license declared by the base model. The official model repository has no LICENSE file; its model card metadata declares Apache-2.0. The LICENSE file here is the Apache-2.0 text from FunAudioLLM/Fun-ASR-Nano-2512-vllm. NOTICE names the base model (Tongyi Lab / FunAudioLLM) and Qwen3-0.6B (Alibaba Cloud, Apache-2.0).

Changes from the original work: weights converted from the PyTorch checkpoint to LiteRT flatbuffers; the language model quantized to int8 and the audio encoder weights cast to fp16; the audio front end, encoder and adaptor exported as one graph; the prompt format stored as LiteRT-LM metadata. No CTC decoder is included (the checkpoint has no CTC decoder weights).

Other ports of this model exist for MLX (mlx-community), ONNX (sherpa-onnx, csukuangfj) and llama.cpp (the official GGUF files).

Downloads last month
414
Inference Providers NEW
This model isn't deployed by any Inference Provider. 🙋 Ask for provider support

Model tree for litert-community/Fun-ASR-Nano-2512

Quantized
(18)
this model

Collections including litert-community/Fun-ASR-Nano-2512