abliter8-ai/Roo-Voice_MOSS_TTS_LT_mlx4

Roo-Voice · MOSS-TTS-Local-Transformer · MLX 4-bit

Roo's voice — that signature baritone with the estuary accent that stands the hair up on the back of your neck — as a 4-bit MLX model that runs on Apple Silicon. Same voice, lighter footprint: load it, and Roo can whisper to you all day long.

A 4-bit MLX quantization of a full-model supervised fine-tune of MOSS-TTS-Local-Transformer, trained on Roo's own recordings and specialised on his single voice. It is the smaller sibling of the MLX 8-bit release — ~1.3 GB lighter, and in listening it holds the voice.

What actually makes the voice — read this

This is a reference-conditioned model, and both halves matter:

• The fine-tune is what makes it Roo. The base model has never heard this speaker — a base model plus any reference clip will not give you Roo's baritone or his estuary accent. That voice lives in the weights, put there by the supervised fine-tune on his recordings.
• The reference completes the delivery. reference.wav (bundled) conditions the fine-tuned model at inference and is required to produce the voice.

So the product is this fine-tune + reference.wav, together — neither the base model with a reference, nor this checkpoint without one, reproduces Roo. It is not a text-only model, and it is not a generic voice-cloner: swap in a different reference and you are not getting Roo, because the accent and timbre are the fine-tune's, not the clip's.

What it is

Voice	Single speaker — Roo (baritone, estuary accent), 24 kHz mono
Format	MLX, 4-bit affine weights, group size 32, BF16 retained
Runtime	mlx-audio on Apple Silicon
Weights	model.safetensors ≈ 2.4 GB (repo ≈ 2.3 GB)
Source	Full-model SFT (not LoRA/adapter); 556 tensors
Base	OpenMOSS-Team/MOSS-TTS-Local-Transformer @ 12aa734e4f11a7b3fdf4eb0ad2aa2029675ffc2e
Audio codec	OpenMOSS-Team/MOSS-Audio-Tokenizer @ 3cd226ba2947efa357ef453bcad111b6eafba782 (fetched by mlx-audio)

The transformer layers are true 4-bit; the text-embedding table and the audio codec are kept at higher precision by design (they set the size floor and carry the fidelity), which is why the repo is ~2.3 GB rather than half the 8-bit size.

Which quantization should I use?

Machine	Recommended release
Apple Silicon (this repo)	4-bit — smallest; or MLX 8-bit for the largest quality headroom
NVIDIA GPU	int8 / int4 (transformers + bitsandbytes), or the GGUF via llama.cpp
AMD / NVIDIA / CPU (one file)	GGUF Q4_K_M via llama.cpp (Vulkan / ROCm / CUDA)
Full precision	bf16

Usage

import mlx.core as mx
from mlx_audio.tts.utils import load_model

model = load_model("./")  # this repo

mx.random.seed(42)
result = None
for r in model.generate(
    text="After the last dance class, I parked the car beside the garden wall.",
    ref_audio="reference.wav",          # REQUIRED — conditions the fine-tuned Roo voice
    mode="generation",
    max_tokens=4096,
    n_vq_for_inference=32,
    text_temperature=1.0, text_top_p=0.95, text_top_k=50, text_repetition_penalty=1.0,
    audio_temperature=1.0, audio_top_p=0.95, audio_top_k=50, audio_repetition_penalty=1.1,
):
    result = r
# result.audio -> 24 kHz mono float

Decoding contract for this voice: seed 42, temperature 1.0, top-k 50, top-p 0.95, repetition penalty 1.1, 32 RVQ codebooks.

Limitations

• Reference-conditioned — the bundled reference.wav must ride along; there is no text-only path.
• Single voice by design (this is Roo, not a multi-speaker system).
• 4-bit quantization: a slightly larger quality delta vs the FP32/BF16 source than 8-bit is possible; in A/B listening this build held Roo's voice. On Apple Silicon it runs at the same speed as the 8-bit (generation is codec-bound, not weight-bound) — the win here is size, not throughput.

Provenance & license

Quantized/exported form of an accepted single-speaker MOSS-TTS Local supervised fine-tune. The base model and audio codec are Apache-2.0 (OpenMOSS); weights derived from them are redistributed here under the same license.