ilintar/moss-soundeffect-gguf

MOSS-SoundEffect-v2.0 — GGUF

GGUF weights for MOSS-SoundEffect-v2.0 (text → sound effect, 48 kHz mono), converted for use with openmoss — a standalone C++/GGML runtime (CUDA + Vulkan + CPU).

Source model: https://huggingface.co/OpenMOSS-Team/MOSS-SoundEffect-v2.0

License: Apache-2.0, per the source model.

Unlike the MOSS-TTS models, this one is not autoregressive and emits no audio codes. A 30-block Wan-style diffusion transformer predicts a velocity field in the latent space of a continuous DAC VAE; a Euler solver integrates it from noise, and the VAE decoder turns the result into a waveform. A Qwen3-1.7B text encoder supplies the conditioning.

Files

File	Size	Notes
moss-soundeffect-2.0.gguf	4.07 GB	Qwen3-1.7B text encoder, f16 — do not quantize (see below)
moss-soundeffect-2.0.extras.gguf	1.67 GB	sidecar: the DiT (Q8_0 projections) + the DAC VAE decoder

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-soundeffect-2.0.gguf \
    --text "a dog barking twice" \
    --seconds 5 --steps 100 --vk-f32 \
    --output out.wav

moss-tts-cli dispatches on the architecture recorded in the GGUF, so the same binary handles this model and the MOSS-TTS families. The sampling flags (--temperature, --top-k, …) do not apply here; these do:

Flag	Default	Notes
--seconds F	10.0	Output duration, capped at 30
--steps N	100	Solver steps. Each costs two DiT passes unless --cfg-scale 1
--cfg-scale F	4.0	Classifier-free guidance. 1.0 skips the unconditional pass and halves the work
--sigma-shift F	5.0	Flow-match schedule shift
--negative-prompt S	empty	Empty is what the model was trained with, and needs no encoder pass
--seed N	0	0 is a valid seed here, not a "random" sentinel

Generation cost is independent of --seconds: the model always denoises a full 30 s of latent and the waveform is cropped afterwards. On a Radeon 8060S (Vulkan), 100 steps takes about 90 s regardless of the requested duration.

--vk-f32 is recommended on Vulkan

It sets GGML_VK_DISABLE_F16, which stops the ggml Vulkan backend accumulating the text encoder's matmuls in f16. That default costs the conditioning about 3% relative error, and the diffusion transformer cross-attends to it on all ~200 forward passes. Measured against an fp32 PyTorch reference, from an identical starting latent:

	text conditioning	final latent	correlation
with --vk-f32	1.7e-3	1.5e-2	0.99988
without	3.3e-2	1.7e-1	0.9985

It costs nothing measurable — the weights stay f16 in memory either way, so only shader compute precision changes.

Do not quantize the backbone

The backbone is a plain Qwen3-1.7B GGUF, so llama-quantize will happily process it, but the result is materially worse. This model consumes the encoder's hidden state directly as a continuous conditioning vector rather than turning logits into tokens, so quantization error propagates straight into the generation instead of being absorbed by sampling:

backbone	text conditioning	final latent	correlation
f16 (shipped)	1.7e-3	1.5e-2	0.99988
Q8_0	2.7e-2	1.8e-1	0.984

For scale: the same latent shifted by 0.74 s correlates at 0.90, and unrelated noise at 0.06. 0.984 is a noticeably different generation.

f16 rather than the source's bf16 is not a compromise here. bf16 has 7 mantissa bits against f16's 10, so every bf16 weight is exactly representable in f16 as long as its exponent fits — and across all 2.03 B text-encoder weights, none overflow, only 0.157% land in f16's subnormal range, and just 1578 flush to zero. The measured bf16 → f16 round-trip error is 4.7e-9, five orders of magnitude below the 1.7e-3 that compute precision costs.

The sidecar is a different matter and is quantized here. Q8_0 on the DiT's projection matrices halves it, 2.98 GB to 1.67 GB, and costs almost nothing: the 100-step waveform envelope correlates at 0.999994 with the f16 sidecar. The modulation path, the output head and the whole VAE decoder are deliberately kept at f16/f32 — the head's LayerNorm amplifies error reaching it by roughly 50x, and three of the VAE's Snake reciprocals overflow f16 outright.

If you want the exact f16 sidecar, regenerate it with the converter:

python scripts/convert_hf_to_gguf.py \
    --moss-tts OpenMOSS-Team/MOSS-SoundEffect-v2.0 \
    --output moss-soundeffect-2.0.gguf \
    --sidecar-only --sidecar-dtype f16

Prompting

Prompts are short descriptions of a sound. The runtime appends " duration: <X>s" for you, matching the training convention — the duration is conveyed textually, which is why it costs nothing to generate.

Examples that work well:

a dog barking twice
heavy rain on a tin roof
a single glass shattering on stone