Speech models v1

Weights for the Transcribe tab's NVIDIA engines, downloaded by the app:

• Canary 1B v2 (NVIDIA, CC BY 4.0), 8-bit MLX conversion by Mediform — canary_*
• Nemotron 3.5 ASR Streaming 0.6B (NVIDIA, OpenMDW 1.1), 8-bit MLX conversion by mlx-community — nemotron_*

Redistributed unchanged; see canary_NOTICE.txt and nemotron_LICENSE.txt.

Image models — DreamShaper, SANA-Sprint, FLUX.2 klein (v1)

Image models for WhisperKit (v1)

Format conversions for the app's Image tab, nothing retrained. Built by the
scripts in ports/imagegen/; verification in ports/README.md.

Files	Contents	Licence
sd_text_encoder.mlmodelc.aar, sd_unet.mlmodelc.aar, sd_vae_decoder.mlmodelc.aar, clip_vocab.json, clip_merges.txt	DreamShaper 8 with ByteDance's Hyper-SD 4-step LoRA fused, Core ML for the Neural Engine (text encoder and UNet 8-bit palettized, VAE float16) and CLIP's tokenizer (convert_sd.py)	CreativeML OpenRAIL-M (DreamShaper 8, Stable Diffusion 1.5); CreativeML OpenRAIL++-M (Hyper-SD)
sana_gemma_q8.part{1,2}.safetensors, gemma_bpe.bin	Gemma 2 2B, SANA's prompt encoder, 8-bit for MLX, and its tokenizer as integer tables (export_sana_mlx.py)	Gemma Terms of Use and Prohibited Use Policy
sana_transformer.mlmodelc.aar, sana_extras.safetensors, sana_decoder_head.safetensors, sana_decoder_tail.mlmodelc.aar	SANA-Sprint 0.6B 1024 px: transformer (Core ML, 8-bit palettized), caption projection and fixed-schedule modulation, DC-AE decoder split between MLX and Core ML (convert_sana.py, export_sana_mlx.py)	Apache 2.0
flux_text_q8.part{1,2}.safetensors, flux_vocab.json, flux_merges.txt	Qwen3-4B, FLUX's prompt encoder — its first 27 of 36 layers — 8-bit for MLX, and its tokenizer (export_flux_mlx.py)	Apache 2.0
flux_transformer_q8.part{1,2,3}.safetensors, flux_vae.safetensors	FLUX.2 [klein] 4B transformer, 8-bit (bfloat16 scales), and the VAE decoder, float16 (export_flux_mlx.py)	Apache 2.0
safety_checker.mlmodelc.aar	Falconsai's nsfw_image_detection ViT, Core ML 8-bit palettized: the check every picture passes before it is shown (convert_safety.py)	Apache 2.0

Against each upstream diffusers pipeline with the same noise, the app's
Swift drew the same pictures: SANA-Sprint 32.7 / 28.1 dB and FLUX.2 klein
30.8 / 20.5 dB PSNR on the two reference prompts.

ACE-Step 1.5 — full-precision planner and encoders (v4)

ACE-Step 1.5 — full-precision planner and encoders for WhisperKit (v4)

Format conversions of ACE-Step 1.5 (MIT), nothing retrained. Built by
ports/acestep/convert_full.py. They replace the int8 planner, condition
encoder and hints of acestep-v2; its text encoder, audio decoder, silence
latent and tokenizer are unchanged.

File	Contents
ace_lm_bf16.part{1,2}.safetensors	The 1.7B planner (acestep-5Hz-lm-1.7B) exactly as published, bfloat16
ace_cond_f16.safetensors	Condition encoder: lyric and timbre stacks, text projection, float16
ace_hints_f16.safetensors	FSQ codebook (float32) and detokenizer (float16)
ace_xl_cond_f16.safetensors	The encoder tensors ACE-Step 1.5 XL retrained, float16

Against the int8 set, with the app's planner fix (build 1.2 (24)), seven
prompts at 81 s matched their own prompt at CLAP 0.594 against 0.551, by a
margin of 0.140 against 0.062.

Licence: MIT, as upstream.

Stable Audio 3 — MLX weights v2 (aligned for mapping)

Stable Audio 3 (Small-Music and Medium) — MLX weights for WhisperKit, v2

These files are format conversions of weights published by Stability AI at
https://huggingface.co/stabilityai/stable-audio-3-optimized. Nothing was
retrained or altered: the MLX .npz archives were rewritten as safetensors,
which is the only container MLX Swift can read, and the tokenizer and three
conditioner tensors were extracted from those same archives.

v2 contains the same tensors as sa3-small-weights-v1, rewritten so every
tensor starts on a 64-byte boundary (ports/stable-audio-3/align_weights.py).
The app maps these files instead of reading them into memory, which takes
Medium from 3.5 GB to about 0.6 GB while generating.

File	Contents
t5gemma_f16.safetensors	T5Gemma text encoder
dit_sm-music_f16.safetensors	Diffusion transformer, small-music
dit_medium_f16.part1/2.safetensors	Diffusion transformer, medium (sharded: 2.9 GB exceeds the 2 GB asset cap)
same_s_decoder_f32.safetensors	SAME-S audio decoder
sa3_conditioner_*.safetensors	Conditioner tensors from each DiT archive
t5gemma_tokenizer.model	SentencePiece tokenizer from the T5Gemma archive

Licensing

• Stable Audio 3 weights: Stability AI Community License (STABILITY_LICENSE.md).
• T5Gemma: Gemma Terms of Use — https://ai.google.dev/gemma/terms.

Both apply unchanged to these conversions. The Swift pipeline that loads them is
adapted from https://github.com/kellyvv/StableAudio3-IOS (MIT).

Stable Audio 3 Small-Music — MLX weights

Stable Audio 3 Small-Music — MLX weights for WhisperKit

These files are format conversions of weights published by Stability AI at
https://huggingface.co/stabilityai/stable-audio-3-optimized. Nothing was
retrained or altered: the MLX .npz archives were rewritten as safetensors,
which is the only container MLX Swift can read, and the tokenizer and three
conditioner tensors were extracted from those same archives.

File	Contents
t5gemma_f16.safetensors	T5Gemma text encoder
dit_sm-music_f16.safetensors	Diffusion transformer, small-music
same_s_decoder_f32.safetensors	SAME-S audio decoder
sa3_conditioner_sm-music.safetensors	Conditioner tensors from the DiT archive
t5gemma_tokenizer.model	SentencePiece tokenizer from the T5Gemma archive

Licensing

• Stable Audio 3 weights: Stability AI Community License (STABILITY_LICENSE.md).
• T5Gemma: Gemma Terms of Use — https://ai.google.dev/gemma/terms.

Both apply unchanged to these conversions. The Swift pipeline that loads them is
adapted from https://github.com/kellyvv/StableAudio3-IOS (MIT).

ACE-Step 1.5 — Neural Engine and XL weights (v3)

ACE-Step 1.5 — Neural Engine and XL weights for WhisperKit (v3)

Format conversions of ACE-Step 1.5 (MIT): https://huggingface.co/ACE-Step/Ace-Step1.5,
https://huggingface.co/ACE-Step/acestep-v15-xl-turbo and
https://huggingface.co/ACE-Step/acestep-5Hz-lm-4B. Nothing retrained.
These add to release acestep-v2, whose text encoder, condition encoder,
hints, audio decoder, silence latent and tokenizer every version still uses.

ACE-Step 1.5 on the Neural Engine

Built by ports/acestep/convert_neural_engine.py.

File	Contents
ace_dit_ane_c{0..3}.mlmodelc__*	The 2B turbo transformer's 24 layers as four compiled Core ML programs of six, float16. Asset names stand for paths: __ is /.
ace_dit_outer_f16.safetensors	What surrounds the layers — timestep embeddings, patch projections, conditioning projection, output norm — float16, run in MLX

Core ML runs fixed shapes on the Neural Engine, so each program carries one
function per length (384 to 5,760 positions, up to 7:40 rendered) and per
conditioning size (512 or 2,368 tokens), sharing one copy of the weights.
Padding is masked out of every attention. The sliding-window layers attend
in blocks of 128 queries against 384 keys instead of the whole sequence.
Against PyTorch float32 on real weights, one six-layer program agrees to
cosine 0.99999.

ACE-Step 1.5 XL

Built by ports/acestep/convert_large.py. Int8 projections (group size 64),
float16 otherwise; parts because a release asset is capped at 2 GB.

File	Contents
ace_xl_decoder_q8.part{1..3}.safetensors	The 4B XL turbo transformer: 32 layers, width 2,560
ace_xl_cond_q8.safetensors	The condition-encoder tensors XL retrained — its two input embeddings and norms, the timbre token and the text projection. The other 192 encoder tensors are bit-identical to the 2B's and are read from ace_cond_q8
ace_lm4b_q8.part{1..3}.safetensors	The 4B planner (acestep-5Hz-lm-4B)

Licence: MIT, as upstream.

ACE-Step 1.5 — MLX weights v2 (per stage, mapped)

ACE-Step 1.5 — MLX weights for WhisperKit (v2)

Format conversions of https://huggingface.co/ACE-Step/Ace-Step1.5 (MIT).
Nothing retrained. Built by ports/acestep/convert_weights.py in this repo.

One file per pipeline stage, so the app maps only the stage that is running:

File	Contents
ace_qwen_f16.safetensors	Qwen3-Embedding-0.6B text encoder, float16
ace_cond_q8.safetensors	Condition encoder: lyric and timbre stacks, text projection
ace_decoder_q8.safetensors	Diffusion transformer, 24 layers
ace_vae_f16.safetensors	Oobleck VAE decoder, 48 kHz stereo (upsampling weights stored as in × taps × out)
ace_silence_full.safetensors	Silence latent, 10 minutes at 25 Hz, frames-first
ace_vocab.json, ace_merges.txt	Qwen3 byte-level BPE (shared by the text encoder and the planner)
ace_lm_q8.safetensors	The 1.7B planner (acestep-5Hz-lm-1.7B), int8
ace_hints_q8.safetensors	FSQ codebook and detokenizer: planner tokens to the 25 Hz guide

In the _q8 files, 2-D projections are int8 (group size 64) and everything
else is float16. Every tensor starts on a 64-byte boundary.

Why this precision. Against the float32 pipeline over eight steps, final
latent cosine: 0.983 as shipped. The text encoder stays float16 because at
int8 it was the largest single source of drift (0.960). The transformers stay
at int8 because below it the output degrades audibly (velocity cosine: 6-bit
0.9826, 4-bit 0.7465).

The planner writes each song out as five music tokens per second before
the diffusion transformer renders it. Without it the transformer often ended
songs early and left the rest silent; with it, requested lengths are filled.

What is omitted. The FSQ audio encoder side (it turns supplied audio
into tokens; here the planner supplies them) and the VAE encoder.

Licence: MIT, as upstream.

ACE-Step 1.5 — int8 MLX weights

ACE-Step 1.5 — int8 MLX weights for WhisperKit

Format conversions of https://huggingface.co/ACE-Step/Ace-Step1.5 (MIT).
Nothing retrained: the projection matrices are quantized to int8 with group
size 64, everything else is fp16, and the layout is rearranged for MLX.

File	Contents
ace_dit_q8.part1/2.safetensors	Diffusion transformer, 24 layers (sharded: 2.69 GB exceeds the 2 GB asset cap)
ace_qwen_q8.safetensors	Qwen3-Embedding-0.6B text encoder
ace_vae_f16.safetensors	Oobleck VAE decoder, 48 kHz stereo
ace_silence.safetensors	Silence latent bed, 60 s at 25 Hz

Why int8 and not smaller. Measured against the fp32 reference on the same
input, cosine similarity of the predicted velocity: int8 0.9989, 6-bit 0.9826,
4-bit/group-32 0.8583, 4-bit/group-64 0.7465. Below 8 bits the output degrades
audibly, so int8 is the floor.

What is omitted. The 1.7B planner (3.71 GB) is not included: its hints are
optional and the generation path passes none. The FSQ tokenizer and
detokenizer are also absent — they condition on supplied audio rather than
produce it, and this is the text-only path.

Licence: MIT, as upstream.