[lalalune]

Adds Paradee-8M v1.0 as a native TTS in the fork, so Alpha Phone can ship Paradee instead of Kokoro-82M without ONNX. The model is sahilmahendrakar/Paradee-8M-v1.0 (Apache-2.0): 8.07M parameters, one voice (af_heart), 24 kHz, distilled from Kokoro-82M.

Upstream publishes Paradee as ONNX and as PyTorch weights. This PR uses the PyTorch weights:

• A converter turns them into a GGUF.
• The model's own Kokoro modules run on the existing tools/kokoro layers, which now take their widths from the tensors.
• The phase-locking filter is reimplemented natively.

Base is eliza/develop-pin-ea8b3f2 (7efee00, the gitlink on eliza develop).

What changes

1. tools/paradee/convert_paradee_pt_to_gguf.py and pins.json.

   • Before loading, the converter checks the size and sha256 of pytorch/text_side.pt, pytorch/decoder.pt, config.json and tokenizer.json. The pinned HF revision is c7f83f86; the v1.0 tag points at 8f34b01e, which differs only in README.md.
   • It loads with torch.load(weights_only=True) and folds weight_norm with torch._weight_norm.
   • Every state-dict key must be consumed. Only the unused ALBERT pooler is skipped.
   • The GGUF holds every width, both learned styles (32 and 16), the vocabulary and the phase-lock parameters. It also holds the input pins and the converter's git blob sha.
   • The F32 output (32 MB) is byte-reproducible: sha256 9a18ae71…3a254, enforced by --check-output.
   • F16 halves the file but fails the parity gate (end-to-end SNR 16–23 dB), so it is not pinned.

2. tools/kokoro: widths from the tensor shapes. The predictor, decoder and generator no longer hard-code 512/128/1024/514/1090/256. predictor_forward / decoder_forward / generator_forward take a config with the student-only options:

   • the asr_proj GELU MLP
   • the trained InstanceNorm affine
   • torch.round durations
   • a separate predictor style
   • a float64 harmonic source and a canonical source STFT
   • cancellation, stage outputs
   • opt-in faster kernels: per-tap SGEMM on Accelerate, register-tiled NEON conv on the portable/Android path, and a polynomial Snake. test-kokoro-layer-options checks them against the defaults.

   Kokoro-82M is unchanged bit for bit. kokoro-tts WAVs for three sentences at speed 1.0 and 1.3, with Accelerate and with KOKORO_FORCE_GGML, and the kokoro-stage-dump outputs are byte-identical before and after. The existing Kokoro tests pass.

3. tools/paradee: native Paradee.

   • paradee_lib, with the API the ABI work consumes:
     • paradee_load_model, paradee_sample_rate, paradee_synthesize_ids
     • paradee_phonemes_to_ids: adds the pads, rejects more than 510 symbols and any symbol outside the vocabulary
     • paradee_phonemes_to_symbol_ids: unpadded and unlimited, for chunkers
     • paradee_synthesize: struct form
   • The phase lock (paradee-phase-lock.cpp): STFT 1024/256, 2–8 kHz, voiced frames, 33-frame smoothing, radix-2 FFT. No ONNX.
   • The paradee-tts CLI.
   • LLAMA_BUILD_PARADEE (default ON, needs Kokoro) and the LLAMA_BUILD_MISAKI_G2P hook in the root and tools/ CMake. Both come before tools/omnivoice, so the fused library can fold them in.

4. Parity gate.

   • tools/dump_paradee_reference.py runs the pinned PyTorch reference: torch 2.14.0, kokoro 0.9.4, and paradee source 9c8b4d75 with the sha256 of each training script pinned.
   • Input is the misaki 0.9.4 phonemes of samples/sentences.txt, committed as a fixture.
   • The reference is deterministic. SineGen has no random phase and no noise, as in tools/kokoro, and runs in float64. The source STFT is canonical float64.

Results (5 sentences, macOS arm64)

Check	Result	Gate
integer durations	identical, all sentences	identical
bert, d, dur, F0, N, asr	max err ≤ 7e-6 × RMS	1e-3 × RMS
harmonic source (reference F0 in)	≤ 5e-7 × RMS	1e-3 × RMS
decoder output (reference asr/F0/N/source in)	≤ 3e-5 × RMS (118 dB)	1e-3 × RMS
phase lock alone vs phase_lock.lock() in float64	≤ 4e-9 (synthetic fixture: 3e-8)	1e-4
end-to-end waveform SNR vs reference	58–76 dB	≥ 35 dB
log-mel L1 (DTW) vs published seeded samples	native 0.538, reference 0.538	report only
whisper.cpp base.en WER	native 1.7%, published samples 1.7% (same transcripts)	report only

Notes:

• The acoustic stages are each fed the reference's inputs. The source integrates F0 over the whole utterance, so F0's float32 rounding (~1e-6 relative) would otherwise be charged to the source and decoder.
• The shipped float32 phase_lock.lock() differs from its own float64 evaluation by up to 1.1e-3, at bins where the source is nearly silent. The native lock is exactly that far from it and no further, so the 1e-4 gate is against float64.
• The distance to the published samples comes entirely from the reference itself: the samples use random noise, and their durations are off by one frame. The native output adds nothing measurable on top.

Single-thread speed. M4 Max, best of several runs, with the machine heavily loaded (load average 70–80):

Path	Realtime
Accelerate	up to ~32x
Portable NEON (the Android path)	up to ~14x
Kokoro arithmetic (PARADEE_EXACT_LAYERS=1)	~21x

The portable path was 1.8x before the tiled kernels. These figures are not a clean benchmark. Linux x86_64 was not measured: no Linux host or running Docker daemon was available.

Tests run

• Host build: -DGGML_METAL=OFF -DLLAMA_BUILD_TESTS=ON -DPARADEE_GGUF=… -DPARADEE_REF_DIR=…. ctest -R "kokoro|paradee" passes 10/10, both with Accelerate and with the portable path (-DKOKORO_NO_ACCELERATE).
• Android NDK r28 compile only, no device run:
  • arm64-v8a: paradee_lib, paradee-tts and the tests
  • x86_64 with LLAMA_BUILD_TOOLS=OFF: paradee_lib
• Not run: anything on a device or emulator. This PR does not touch tools/omnivoice.

Known issues, unchanged here

• kokoro_predictor_forward reads the predictor style at ref_s + 512, not ref_s[128:]. That is two voice rows further, and past the end of the voice pack for the longest inputs; with a 256-float ref_s file, kokoro-stage-dump output varies from run to run. Fixing it changes Kokoro's audio, so it needs its own PR and parity run. It is marked in the code.
• tests/test-chat.cpp does not build with LLAMA_BUILD_SERVER=OFF (mtmd.h not found). This is unrelated and pre-existing.

For the ABI work (claude/alpha-voice-ffi-v17)

That branch's contract double expects paradee_phonemes_to_ids to return unpadded ids and to drop unknown symbols. This header follows the agreed contract instead: it adds the pads and rejects unknown symbols. The chunker should call paradee_phonemes_to_symbol_ids, which is unpadded, unlimited, and rejects unknown symbols. The other names the bridge uses all exist here: PARADEE_MAX_INPUT_IDS, paradee_synth_options, paradee_audio, paradee_synthesize, PARADEE_E_CANCELLED, PARADEE_E_OOM.

AI disclosure: Claude Code wrote this change for the elizaOS maintainers, as part of moving Alpha Phone's voice to llama.cpp.

🤖 Generated with Claude Code

[lalalune]

Review fixes pushed in 1ef617d (rebased on the current base, which now has the ABI v17 bridge from #59):

• Bridge contract mismatch. The v17 FFI chunked with paradee_phonemes_to_ids, which this library pads, caps at 510 symbols and makes strict on unknown symbols. The bridge's test double did none of that, so the fake tests passed, but against the real paradee_lib: any text over 510 phonemes, and any text with a symbol outside the vocab, failed with INVALID_ARG, and the chunks carried embedded pads. Added paradee_phonemes_to_symbol_ids_lenient (unpadded, unlimited, drops and counts unknown symbols, which is what the ABI header documents), switched the bridge to it, and synced the contract header (including the status enum values) and the fake. Checked end to end with the real libelizainference.dylib built with tools: native misaki English G2P (misaki-g2p) for Paradee-8M, with agreement gate #63's misaki_g2p merged in: a ~32 s paragraph chunks and synthesizes, and text with an emoji and #%& synthesizes instead of failing.
• Speed bound. Durations scale with 1/speed, so a speed close to 0 made the frame count and decoder buffers unbounded. The library now accepts [0.25, 4] and the FFI clamps to that range, as the header now says.
• The loader bounds widths, rates, sample rate and phase-lock parameters read from the GGUF.
• paradee_phase_lock checked s for null only after copying from it.
• Configure no longer fails when LLAMA_BUILD_KOKORO=OFF. metal-transfer-validation.yml configures that way. Paradee is now skipped in that case.
• Tests added: lenient mapping, speed bounds, concurrent synthesis on one model, FFI speed clamp.

Re-verified on macOS arm64: ctest -R 'kokoro|paradee|eliza-inference' 12/12 pass (parity gate included). Kokoro-82M kokoro-tts/kokoro-stage-dump outputs are byte-identical to the pre-PR baseline. An ASan/UBSan run of the paradee and kokoro-layer tests is in progress.

🤖 Generated with Claude Code