Spark-X2.6-4B — LiteRT-LM

This repository is a conversion of XHToken/Spark-X2.6-4B to LiteRT-LM (.litertlm), made with litert-torch 0.9.3 for LiteRT-LM 0.19.0: on a Mac Studio (Apple M4 Max) GPU the int4 file decodes at 91.2 tok/s (1,024-token prompt, 256 generated tokens, 2026-10-31).

Spark-X2.6-4B is the SparkLLM Team's 4.11B-parameter dense decoder, the first model of the Spark-X2.6 series. Its model card says it builds on Spark-X2.5-4B, keeps its architecture and gains its capability from improved post-training. That architecture has 36 layers, hidden size 2560, 16 query and 4 KV heads of 256, three sliding-window (512) layers per full-attention layer, per-head sigmoid gates on the attention output, exact-GELU gated MLPs and a 131,072-entry tied vocabulary. It is a reasoning model: it thinks inside <think>…</think> before it answers. These files carry that: the prompt template opens the thought the way the vendor's chat template does, and the files declare a thought channel, so LiteRT-LM keeps the reasoning out of the answer. Apache-2.0.

All three files declare fp32 GPU activations. The int4 file also uses LiteRT-LM's GPU composite ops for the KV-cache writes and the attention products, with its weights unchanged (see Conversion notes); the two int8 files keep the graph as exported (the kv2048 one with its cache cut). The numbers for these files were measured with LiteRT-LM 0.19.0; earlier releases were not tested with these files.

On a GPU (a Mac, for example), use Spark-X2.6-4B_int4.litertlm: it decodes 91.2 tok/s on the Mac GPU, the int8 file 49.8, and scores GSM8K 89 against the bf16 model's 90. On the Mac GPU the int8 file scores 93 but decodes 45 % slower. On a CPU, use Spark-X2.6-4B_int8.litertlm: on the CPU the int4 file gave an empty third answer in our 3-turn conversation check in 3 of 8 conversations (4 processes, 2 conversations each, all at the runtime's default, which drops each turn's thought from the KV cache before the next turn; the same check passes on the GPU), and the int8 file scores GSM8K 90 on the CPU (bf16 90) and passes the check (one process, both conversations). On a CPU with reasoning_effort low, use Spark-X2.6-4B_int8-kv2048.litertlm: it decodes at ×1.49 the int8 file's speed on the Galaxy S26 CPU and ×1.40 on the Mac CPU (side by side) and scores GSM8K 93 at low (bf16 92); its 2,048 tokens must hold prompt, thought and answer, so it is not for the default effort's 3,584-token budget. On a Galaxy S26, use the int8 file on the CPU (5.3 tok/s; at low, the kv2048 file, 8.2) and stream long replies (see Known runtime issues); we have no GPU row for this model on that phone (see Performance).

Correctness

• 8 short questions with one right answer each (two arithmetic questions, a capital, a translation, a decimal comparison, an opposite, the days of a week and a rhyme; Mac, LiteRT-LM 0.19.0 Python API, one process per question, greedy, thinking on, 2,048 output tokens): int4 CPU 8/8, GPU 8/8; int8 CPU 8/8, GPU 8/8. Every thought closed, every answer was a clean final answer.
• On phones, the same 8 questions with the same settings (the LiteRT-LM 0.19.0 Android wheel from PyPI): Galaxy S26 CPU, int8: 8/8, each prompt rendered to the same bytes as on the Mac.
• Multi-turn (3 turns, greedy: plant a fact, do arithmetic, recall the fact; the same conversation run twice per process on one engine, both times at the runtime's default, which drops each turn's thought from the KV cache before the next turn): int4 passes on the GPU. On the CPU the int4 file passed both conversations in its first process; in each of 3 more fresh processes one of the two conversations answered turns 1 and 2 right and then gave an empty third answer right after its thought (3 of 8 conversations; the bf16 model's answer at that point is more than 17 logits ahead of every stop token, so this is not a near tie in the model). int8 passes on the GPU and on the CPU (one process each, both conversations).
• Spark-X2.6-4B_int8-kv2048.litertlm (CPU, reasoning_effort low, 1,792 output tokens): the 8 questions 8/8 and the multi-turn check passed on the Mac and on a Pixel 11 Pro, each prompt rendered to the same bytes on both.
• Tokenizer: the tokenizer section is the upstream tokenizer.json, byte for byte. With these bytes LiteRT-LM encodes 234 of 234 probe rows (every added token alone and mid-string, a role-marker turn, Latin-1 / Extended-A, emoji, CJK, digits, whitespace) to the same ids as the tokenizers library.
• Chat template: for system, user and assistant messages the files' template renders byte-identically to the vendor's chat_template.jinja: 54 renders (three conversation shapes × generation prompt on / off × thinking unset / on / off × reasoning_effort unset / high / low), in transformers and in LiteRT-LM 0.19.0.

Accuracy — GSM8K

GSM8K, the first 100 test questions, greedy, thinking on, a 0-shot chain-of-thought prompt that asks for the answer as #### <number>, 3,584 output tokens (the int4 and int8 files' KV cache holds 4,096), one conversation per question. The LiteRT-LM rows ran on a Mac (LiteRT-LM 0.19.0 Python API), the reference with transformers on the Mac (MPS) and the vendor chat template. The answer is read from the text after the thought, or from the thought when the model did not finish within the 3,584 tokens; the same rule for every row.

Question by question against bf16: int4 84 both right, 6 right only in bf16, 5 right only in int4; int8 (GPU) 89 / 1 / 4; int8 (CPU) 86 / 4 / 4.

With reasoning_effort low and 1,792 output tokens (the int4 and int8 files at their 4,096-token KV cache, the kv2048 file at 2,048; the same answer rule): bf16 92 (4 unfinished), int4 GPU 89 (8), int8 CPU 94 (5), int8-kv2048 CPU 93 (4).

Usage

pip install litert-lm==0.19.0
litert-lm run ./Spark-X2.6-4B_int4.litertlm --backend gpu --thinking true --prompt "What is the capital of France? Answer in one word."
litert-lm run ./Spark-X2.6-4B_int8.litertlm --backend cpu --thinking true --prompt "What is the capital of France? Answer in one word."

Python, with the vendor's thinking levels (reasoning_effort high is the default, low asks for a shorter thought, and thinking off renders the vendor's no-think prompt):

import litert_lm

engine = litert_lm.Engine("Spark-X2.6-4B_int4.litertlm", backend=litert_lm.Backend.GPU(), max_num_tokens=4096)
conversation = engine.create_conversation(extra_context={"reasoning_effort": "low"})
reply = conversation.send_message("How many prime numbers are smaller than 30?", max_output_tokens=3584)
print(reply["channels"]["thought"])
print(reply["content"][0]["text"])

• Give it a generous output budget (3,584 tokens for math). The model thinks before it answers; cut off mid-thought it gives no final answer.
• Spark-X2.6-4B_int8-kv2048.litertlm: backend=litert_lm.Backend.CPU(), max_num_tokens=2048, extra_context={"reasoning_effort": "low"}, max_output_tokens=1792 (prompt and output share the 2,048 tokens; this card's prompts are under 256). litert-lm run has no flag for the effort, so use the Python API.
• litert-lm run writes its compile caches next to the model file by default: 2.08 GB in two files beside the int4 file after the GPU command above (a 2.06 GB weight cache and a 24 MB program cache), 4.13 GB in one file beside the int8 file after the CPU one. --cache no turns that off.
• create_conversation(thinking_config=litert_lm.ThinkingConfig(enable_thinking=False)) renders the vendor's no-think prompt (<｜start▁of▁sentence｜><|Bot|></think>).
• The template is the vendor's plain-chat part: a default system block (<|System|>, "you are a helpful assistant.", the thinking_effort instruction while thinking is on, then your system prompt), every message wrapped in <｜start▁of▁sentence｜> … <｜end▁of▁sentence｜>, generation prompt <｜start▁of▁sentence｜><|Bot|><think>; stop token <｜end▁of▁sentence｜>. Tool-call formatting is not carried. KV cache 4,096 tokens (2,048 in the kv2048 file; the original's 1M context does not apply here), six prefill sizes (1024, 256, 64, 16, 4, 1) — six rather than eleven because every exported prefill size takes engine memory whether or not it is called.
• The vendor's recommended sampling is temperature 1.0 / top-p 0.95; the numbers on this card are greedy.

Performance

Every row: prefill of 1,024 tokens, then 256 decoded tokens, with the context set to 2,048 tokens; 3 runs per process, at least two processes per file, and the value is the mean over processes. LiteRT-LM 0.19.0 from PyPI.

Mac Studio (Apple M4 Max, 128 GB, macOS 27.0), litert-lm benchmark <file> -p 1024 -d 256 --max-num-tokens 2048 --runs 3 --backend <cpu|gpu> --cache no (one warm-up run, then the mean of 3):

The int8-kv2048 row was measured in one session interleaved with the int8 file (int8, kv2048, kv2048, int8), which read 350 tok/s prefill and 18.1 tok/s decode there.

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).

Galaxy S26 (SM-S942Q, Snapdragon, Adreno; Android 16), the litert-lm-api 0.19.0 Android wheel from PyPI, Benchmark(model, backend, prefill_tokens=1024, decode_tokens=256, max_num_tokens=2048), 3 runs per process on one engine; a process's value is the mean of runs 2 and 3 (run 1 is the first use); CPU runs started from an unthrottled phone:

The int8-kv2048 row was measured in one session interleaved with the int8 file (int8, kv2048, kv2048, int8; 2 processes each), which read 101 tok/s prefill, 5.5 tok/s decode and 10.4 s TTFT there.

No Galaxy S26 GPU row: our test stops a run at the first reading of MemAvailable (the kernel's estimate, in /proc/meminfo, of the memory available to new work without swapping) under 1,000,000 KiB (read every 0.25 s). The int8 file's GPU engine build (context 2,048) was stopped there twice, at 987,700 and 959,672 KiB; the int4 file before the GPU graph rewrite, at the 4,096-token context these files are exported with, was stopped four times, at 939,996 to 988,316 KiB (at context 2,048 it ran, 8.6 tok/s decode); the int4 file in this repository, at the 4,096-token context, was stopped there twice, at 967,012 and 803,796 KiB. Pixel 8a (8 GB of RAM): the int8 file's CPU benchmark run did not finish within the runtime's 10-minute limit (DEADLINE_EXCEEDED; the phone was swapping). iPhone 18 Pro: our app could not create the int8 file's engine (its XNNPACK cache file could not be memory-mapped, and on Metal "Could not mmap file"); the app is signed without the increased-memory-limit entitlement, and whether that is the cause was not tested. The int4 file was not run on either phone.

No NPU file. We also compiled this model for the Galaxy S26 NPU (Qualcomm HTP, ahead of time for SM8850, QAIRT 2.47): the compiled model's context did not load on the phone (the runtime logged a context size estimate of 3,820,573,952 bytes and error 1002, QNN's memory-allocation error; QAIRT 2.47's HTP documentation gives 3.75 GB of usable address space per DSP session), so there is no NPU file.

Conversion notes

Converted with litert-torch 0.9.3 / transformers 5.14.1 / ai-edge-quantizer 0.8.0, released wheels; files packed with the litert-lm 0.19.0 CLI (reproduction scripts: hf-to-litertlm).

• The vendor modeling code is patched for export, not re-implemented (the patch of the Spark-X2.5 conversion; X2.6 ships the same modeling_spark.py). modeling_spark.py computes attention through its own eager function and ignores config._attn_implementation; the export copy dispatches through the registered attention interface (so litert-torch's transposed KV cache is used), threads the per-call kwargs, declares the attention-backend capability flags, and applies the per-head sigmoid output gate in the interface's layout. In eager mode the patched file is bit-identical to the vendor file (max |Δlogit| 0.0 on 24 random tokens).
• The think opener is pre-filled by the template and the thought channel is declared in the metadata. No start token in the metadata: the tokenizer declares <｜start▁of▁sentence｜> as BOS but never prepends it (add_bos_token: false), and the template writes its own.
• int4 keeps the embedding table in its own section. The vocabulary is tied; asking int4 for the output layer and int8 for the embedding would make the quantizer copy the 131,072-row table once per signature. The int8 file needs no split.
• GPU graph (int4 file). After the export, the int4 file's KV-cache writes and attention products of every signature are rewritten as LiteRT-LM's GPU composite ops (odml.cache_update, odml.runtime_bmm) with tools/gpu_graph/gpu_graph_retrofit.py from hf-to-litertlm (--decomp exporter --mask add_bcast, plus the band-mask extension the sliding-window layers need, dory_work/retrofit_gpu.py in the same repository); every weight buffer is byte-equal to the export's. Mac GPU decode against the same file without the rewrite: ×1.72 (53 → 91 tok/s); CPU speed did not change measurably; GSM8K gave the same verdict on every one of the 100 questions with and without the rewrite. The int8 file keeps the exported graph: it is the file we recommend for the CPU, and the same rewrite of the int8 weights changed nothing measurable on the Mac CPU (18.1 vs 17.6 tok/s; the two processes of each file, 18.4 / 17.8 and 17.8 / 17.4, overlap).
• kv2048 file. The int8 file unpacked, the cache length of every signature rewritten from 4,096 to 2,048 with tools/gpu_graph/cache_variant.py from hf-to-litertlm (the tensor shapes and the constants that carry it; no re-export), max_num_tokens set to 2,048, and packed again with the 0.19.0 CLI; every weight buffer is byte-equal to the int8 file's.
• GPU activations are declared fp32 in the files (prefer_activation_type = "fp32"). LiteRT-LM runs the text decoder with fp16 activations on the GPU by default, and on this 36-layer decoder that costs reasoning accuracy: the same int8 weights scored GSM8K 79 with fp16 GPU activations forced and 93 with fp32 declared (bf16 90). fp32 activations take more GPU memory: on the Galaxy S26 the int8 file's weights (context 2,048) built an fp16-activation GPU engine at 6.94–6.96 GB of the GPU driver's page pool (and was then stopped by the same memory limit within its first runs, twice), while the fp32 build passed 7.46–7.70 GB and was stopped by our memory limit before it finished, twice (see Performance).
• Tokenizer: the upstream tokenizer.json, byte for byte (the exporter's own copy marks <unk> as special, which the upstream file does not; replaced).
• Quantization at export time (int4 block scales floored at 2^-14; none needed it here); no other post-processing of the weights.

Known runtime issues

On litert-lm 0.18.1 and 0.19.0, a blocking send_message that is still generating after 10 minutes fails with DEADLINE_EXCEEDED (a fixed timeout with no setting), and the generation it leaves running can crash the process. For long thinking on a slow backend, lower max_output_tokens or use the streaming send_message_async, which has no such limit. On the Galaxy S26 CPU a full 3,584-token reply of this model takes longer than 10 minutes (decode 5.3 tok/s), so stream there.

Later answers in a conversation can differ from the answer the model gives to the same messages in one prompt. With thinking off, 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 Spark-X2.6-4B_int4.litertlm holds the embedding table in its own section and the decoder takes embeddings (read in the source of LiteRT-LM 0.16.0 to 0.18.1; measured with 0.18.1 on WeVisOne-VL-2B and Qwen2.5-Coder-1.5B-Instruct, not on this file). With thinking on, the runtime rebuilds the cache from the re-rendered history at each turn, so the second turn is free of it when the conversation opens with a user message; the same source shows a zero embedding at another token from the third turn on (not measured). The two int8 files have no embedder section (the decoder looks the tokens up itself) and are not affected. One question per conversation avoids both, as does a new conversation that starts with the earlier messages and the new question.

An answer whose last punctuation mark is a token of its own, such as a . or ? after a word, can arrive without that mark. On LiteRT-LM releases before 0.17.0 (read in the source of 0.10.1 to 0.16.1) the cause is this: these files carry <｜end▁of▁sentence｜> with each of 13 characters in front (12 punctuation marks and a space) as stop sequences next to <｜end▁of▁sentence｜> alone, so the runtime holds the mark back to see whether <｜end▁of▁sentence｜> follows, and when the answer ends there the held mark is never written. From LiteRT-LM 0.17.0 on (read in the source of 0.17.0 to 0.18.1) all three files still drop all 13: the mark and <｜end▁of▁sentence｜> complete two stop sequences at the same token, <｜end▁of▁sentence｜> alone and the one with the mark, the runtime records the one that comes later in the file's stop list (for <｜end▁of▁sentence｜> alone, its first entry when the file lists it twice), and it writes the held mark only when that is <｜end▁of▁sentence｜> alone. Not measured on these files: this follows from the runtime's source read with these files' stop list and tokenizer; the drop on releases before 0.17.0 was seen with LiteRT-LM 0.16.1 on a Galaxy S26, on another bundle with punctuated stop sequences.

License and changes

Distributed under Apache-2.0 (inherited from the base model; the upstream LICENSE file is included). Changes from the original work: weights converted from safetensors bf16 to LiteRT flatbuffers and quantized as described above; in the int4 file, the attention's KV-cache writes and products rewritten as LiteRT-LM GPU composite ops (weights unchanged); in the kv2048 file, the KV cache shortened to 2,048 tokens (weights unchanged); fp32 GPU activations declared; tokenizer and chat template repackaged into the .litertlm files (thinking pre-fill and thought-channel metadata as described); tool-calling template branches not carried. No training or fine-tuning. This conversion was made independently of the SparkLLM Team.