ilintar/moss-tts-local-gguf

MOSS-TTS-Local-Transformer-v1.5 — GGUF

GGUF weights for MOSS-TTS-Local-Transformer-v1.5 (48 kHz stereo text-to-speech / voice cloning), converted for use with openmoss — a standalone C++/GGML runtime (CUDA + Vulkan + CPU).

Source models:

• backbone: https://huggingface.co/OpenMOSS-Team/MOSS-TTS-Local-Transformer-v1.5
• codec: https://huggingface.co/OpenMOSS-Team/MOSS-Audio-Tokenizer-v2

License: Apache-2.0, per the source models.

Files

File	Size	Notes
moss-tts-local-1.5-q8_0.gguf	4.65 GB	Q8_0 backbone with f16 token embeddings — recommended
moss-tts-local-1.5-q8_0.extras.gguf	4.46 GB	sidecar: audio embeddings, local transformer, MOSS-Audio-Tokenizer-v2

Both files are required and must sit next to each other — the runtime derives the sidecar path from the backbone path by replacing .gguf with .extras.gguf.

Usage

./moss-tts-cli \
    --model moss-tts-local-1.5-q8_0.gguf \
    --text "Hello, world!" \
    --language English \
    --output out.wav

Voice cloning:

./moss-tts-cli \
    --model moss-tts-local-1.5-q8_0.gguf \
    --text "This sentence will be spoken in the cloned voice." \
    --reference speaker.wav \
    --output out.wav

Output is 48 kHz stereo, unlike the 24 kHz mono of the delay-pattern MOSS-TTS models.

How this differs from MOSS-TTS (delay pattern)

	MOSS-TTS-v1.5	MOSS-TTS-Local-Transformer-v1.5
Backbone	Qwen3-8B, hidden 4096	Qwen3-4B, hidden 2560
Codebooks	32, delay-pattern scheduled	12, emitted per frame
Multi-codebook scheme	delay pattern	1-layer local ("depth") transformer
Codec	MOSS-Audio-Tokenizer (24 kHz mono)	MOSS-Audio-Tokenizer-v2 (48 kHz stereo)
Frame rate	12.5 Hz	12.5 Hz

Conversion

python scripts/convert_hf_to_gguf.py \
    --moss-tts OpenMOSS-Team/MOSS-TTS-Local-Transformer-v1.5 \
    --codec    OpenMOSS-Team/MOSS-Audio-Tokenizer-v2 \
    --output   moss-tts-local-1.5.gguf

llama-quantize --token-embedding-type f16 \
    moss-tts-local-1.5.gguf moss-tts-local-1.5-q8_0.gguf Q8_0

The converter drops two sets of tied duplicates that the checkpoint stores twice (text_lm_head ≡ transformer.embed_tokens, and audio_lm_heads[i] ≡ audio_embeddings[i]), saving ~0.42 B parameters.

Verification

The port was checked against the reference PyTorch implementation:

• Prompt tokenization — the 69 token ids for a sample prompt match processor.build_user_message(...) exactly, id for id. (The prompt must be tokenized segment-by-segment; encoding it as one string merges "." + "\n" into a single token and shifts everything downstream.)

• Local transformer — fed the reference's own backbone hidden state, the GGML implementation reproduces all 12 codebook indices exactly, greedily.

• Full pipeline, greedy — the Q8_0 model reproduces all 12 of the reference's frame-0 codes. The f16 model differs on exactly one codebook whose top-1/top-2 logit margin is 0.009, i.e. a numerical tie.

• Codec round-trip — 0.995 envelope correlation on both channels at 5 s, 40 s and 120 s, with no degradation in the second half (the per-stage sliding-window attention is correct).

• Intelligibility — generated samples were transcribed by an audio-capable LLM (Gemma 4 E4B) and came back word-for-word correct:

  Prompt text	Transcription
  "The quick brown fox jumps over the lazy dog."	exact
  "Once again, pangram-style text remains the simplest way to exercise a speech synthesis system end to end."	exact
  "This sentence should be spoken in the cloned voice."	exact

  A 120 s codec round-trip of Chinese reference speech also transcribed correctly, confirming the chunked sliding-window attention preserves intelligibility over long inputs.

Speaker similarity under voice cloning was spot-checked but not rigorously verified — the LLM-as-judge used for it was too inconsistent to support a claim either way.