coder543/moss-tts-nano-100m-glade

MOSS-TTS Nano 100M for Glade

Core AI conversion of MOSS-TTS Nano and its small audio tokenizer. The native Swift text-to-speech pipeline includes the original SentencePiece BPE vocabulary and compiled normalization map, global/local autoregressive generation, and a causal 48 kHz stereo waveform decoder. The trained model covers 20 languages in one bundle. Ordinary text is accepted directly.

The runtime bundle is 322.4 MB (307.4 MiB). The optional original FP32 reference-audio encoder adds approximately 41.8 MB. There is no additional integer weight quantization: original BF16 language values are represented in FP16, codec transformers use FP16, and embeddings, tied output heads and codec boundary matrices retain FP32 storage. Reordered attention rows and shorter balanced reductions preserve the original matrices. Global LayerNorm is algebraically rescaled to avoid FP16 variance overflow while retaining the original effective epsilon.

Measurements

Release Glade runtime; one lane, seed 42, the same short English input and Kokoro Adam example conditioning. End-to-end timing includes tokenization, text planning, generation and waveform rendering. Model preparation and WAV writing are excluded. Each performance result is the median of three warm passes.

Device	Mode	Generated audio	Processing	RTFx
M3 MacBook Air, 16 GB, macOS 27.0.1	Offline	5.76 s	2.54 s	2.27×
M3 MacBook Air, 16 GB, macOS 27.0.1	Streaming	5.76 s	2.46 s	2.34×
iPhone 15 Pro Max, iOS 27.0.1	Offline, cached models	5.76 s	2.77 s	2.08×

Mac streaming delivered its first 1.28-second audio packet after 553 ms. The phone test used complete-unit delivery, so its first output arrived after the whole utterance. First observed preparation on the phone took 15.49 s; a later cached load took 0.36 s. These are observed preparations, not measurements made after deleting all OS caches.

Phone Instruments captured all 1,321 graph calls on ANE, with no target GPU activity: four global prefill calls, 72 global decode calls, 1,225 local decode calls and 20 waveform-codec calls. Mac synthesis scopes contained the same ANE prediction count per utterance and no target GPU intervals. CPU handles text, sampling, tied heads and boundary projections. Hardware intervals establish execution, not ALU occupancy or memory-bandwidth utilization.

The cached phone test reached a 0.83 GB process footprint peak. Task memory accounting includes GPU allocations and the neural ledger where applicable; clean mapped pages and compiler/service allocations are not a full resident-memory measurement. Details are in benchmark.json.

Numerical and speech checks

Against original FP32 computation, the ANE global hidden-state relative RMS error was 0.28%, the maximum across all seventeen cached local positions was 0.35%, and full-waveform codec error was 2.03%. The reference encoder's relative RMS error was 0.000524%, with all original reference codes matching. Fourteen multilingual/normalization cases produced exactly the upstream token IDs.

Cohere recovered the intended English test text exactly from the phone's generated audio. This is an intelligibility check, not a general speech-quality benchmark or qualification of every supported language. Sampling is stochastic, and Swift and PyTorch random generators do not promise identical audio for the same seed.

Bundle and use

• global.aimodel: twelve 768-wide GPT layers; 64-position prefill and one-position decode.
• local.aimodel: one local layer, run seventeen times for each 80 ms frame.
• codec/: four causal transformer groups, original FP32 codebooks and boundary projections.
• tokenizer.json, embeddings.json, embeddings.f32: native Swift tokenizer and tied tables.
• metadata.json: shapes, scheduling, sampling defaults and source provenance.
• voice-encoder/: optional reference-audio import through GladeMOSS; not needed for ordinary synthesis.

hf download coder543/moss-tts-nano-100m-glade --exclude 'voice-encoder/*' --local-dir ./moss-nano

import Glade

let backend = try MOSSNanoSynthesizer(bundle: MOSSNanoModelBundle(directory: directory))
try await backend.prepare()
let session = TTSSynthesisSession(backend)
let metrics = try await session.offline([TTSRequest(.text("Welcome to the glade."))]) { chunk in
  // Play or write chunk.audio using its native sample rate and channels.
}
try await backend.unload()

Online sessions deliver causal codec packets of up to 1.28 seconds, finish the admitted text unit, and wait for playback demand when enough audio is buffered. One lane is supported. Phased mode releases Core AI functions between complete units; it does not swap stages inside a unit.

Input is planned into units of at most 75 SentencePiece tokens with a 1,024-position context cache and a 375-frame/30-second generation ceiling per unit. Long input is divided into ordered units without dropping source text. Generation runouts report an error instead of silently treating unfinished speech as complete. Language is detected from text; the request language serves optional word alignment.

The optional MOSSNanoVoiceEncoder accepts mono or stereo references between 80 ms and 20 seconds, resamples to 48 kHz and duplicates mono into stereo without loudness normalization. It requires no transcript. Encoded conditioning can be cached with the audio fingerprint and codec revision, then passed as referenceCodes. No voice recording is included in this repository.

Sampling follows the actual upstream CLI resolver: text temperature 1, audio temperature 0.8, top-p 0.95, top-k 25 and repetition penalty 1.2, with sampling enabled. Defaults are stored in the bundle metadata.

Sources and licenses

Language source revision: 44502f80dbf9743528fa921cc544d662c685ebec. Audio tokenizer revision: 6aa02b01e445cc585582cf0ba480bc3ea6c8dd68. Upstream model/code licensing is Apache 2.0. SentencePiece and Darts-clone attribution and license texts are included. This bundle targets Core AI on macOS/iOS 27.