Kokoro TTS

Kokoro-82M est un modèle texte-vers-parole léger et non autorégressif basé sur StyleTTS 2 avec un vocodeur ISTFTNet. Il s'exécute entièrement sur le Neural Engine via CoreML, produisant une parole naturelle à 24 kHz à partir de texte en une seule passe avant.

Langues prises en charge

50 voix prédéfinies au total. Convention de nommage : [language_prefix][gender]_[name] — par ex., af_heart = femme américaine « Heart », if_sara = femme italienne « Sara ».

Référence des codes de voix

Chaque identifiant de voix Kokoro suit le même schéma : un préfixe de langue d'une lettre, un code de genre d'une lettre, un trait de soulignement, puis le nom de la voix. Utilisez le tableau ci-dessous pour associer votre langue cible au bon préfixe.

Tableau des préfixes de langue

Toutes les voix par langue

Anglais — Américain (af_*, am_*)

Femme: af_alloy, af_aoede, af_bella, af_heart (par défaut), af_jessica, af_kore, af_nicole, af_nova, af_river, af_sarah, af_sky
Homme: am_adam, am_echo, am_eric, am_fenrir, am_liam, am_michael, am_onyx, am_puck, am_santa

Anglais — Britannique (bf_*, bm_*)

Femme: bf_alice, bf_emma, bf_isabella, bf_lily
Homme: bm_daniel, bm_fable, bm_george, bm_lewis

Espagnol (ef_*, em_*)

Femme: ef_dora
Homme: em_alex, em_santa

Français (ff_*)

Femme: ff_siwis

Hindi (hf_*, hm_*)

Femme: hf_alpha, hf_beta
Homme: hm_omega, hm_psi

Italien (if_*, im_*)

Femme: if_sara
Homme: im_nicola

Japonais (jf_*, jm_*)

Femme: jf_alpha, jf_gongitsune, jf_nezumi, jf_tebukuro
Homme: jm_kumo

Coréen (kf_*)

Femme: kf_somi

Portugais — Brésilien (pf_*, pm_*)

Femme: pf_dora
Homme: pm_alex, pm_santa

Chinois — Mandarin (zf_*, zm_*)

Femme: zf_xiaobei, zf_xiaoni, zf_xiaoxiao, zf_xiaoyi
Homme: zm_yunjian, zm_yunxi, zm_yunxia, zm_yunyang

Architecture

Kokoro utilise un pipeline CoreML à 3 étapes. Pas de boucle d'échantillonnage — toutes les étapes sont des passes avant non autorégressives, avec une étape d'alignement côté Swift entre les étapes 1 et 2.

Pipeline à 3 étapes

Buckets de phonèmes (modèle de durée)

Le modèle de durée utilise des formes d'entrée énumérées. L'entrée est paddée jusqu'au plus petit bucket qui convient :

Buckets du décodeur

Modèles de décodeur à forme fixe pour différentes longueurs audio maximales (chaque trame = 600 échantillons à 24 kHz) :

Nécessite iOS 18+ / macOS 15+.

Phonémiseur

Le texte est converti en tokens de phonèmes via un pipeline à trois niveaux — tous sous licence Apache-2.0, sans dépendances GPL :

1. Recherche dans le dictionnaire — dictionnaires de prononciation anglais US et anglais britannique avec prise en charge des hétéronymes
2. Raccourcissement de suffixes — décomposition morphologique pour les suffixes connus (par ex. « -ing », « -tion »)
3. G2P BART — solution neuronale de repli graphème-vers-phonème utilisant un modèle CoreML encodeur-décodeur séparé pour les mots hors vocabulaire

Poids du modèle

Performance

Utilisation en CLI

speech kokoro "Hello, world!" --voice af_heart --output hello.wav

Options

Exemples

# Anglais avec la voix par défaut
speech kokoro "Hello, how are you today?" --output hello.wav

# Français
speech kokoro "Bonjour le monde" --voice ff_siwis --language fr --output bonjour.wav

# Japonais
speech kokoro "こんにちは世界" --voice jf_alpha --language ja --output konnichiwa.wav

# Lister les 50 voix
speech kokoro --list-voices

API Swift

import KokoroTTS
import AudioCommon

let tts = try await KokoroTTSModel.fromPretrained()
// Télécharge ~170 Mo à la première exécution

let audio = try tts.synthesize(text: "Hello world", voice: "af_heart")
// audio: [Float] — PCM mono 24 kHz

try WAVWriter.write(samples: audio, sampleRate: 24000, to: outputURL)

Compute Unit Override

fromPretrained(computeUnits:) selects which hardware runs the main CoreML model. The default (.all) lets Core ML prefer the Neural Engine, which is the fastest path on every supported device. Pass .cpuAndGPU to bypass the ANE as a fallback on platforms where the ANE compiler produces incorrect output for this model.

import CoreML
import KokoroTTS

// Default: ANE preferred
let tts = try await KokoroTTSModel.fromPretrained()

// Fallback: bypass the Neural Engine
let tts = try await KokoroTTSModel.fromPretrained(computeUnits: .cpuAndGPU)

Quand utiliser Kokoro

Licence

• Poids du modèle : Apache-2.0 (hexgrad/Kokoro-82M)
• Conversion CoreML : Apache-2.0 (aufklarer/Kokoro-82M-CoreML)
• Dictionnaires et G2P : Apache-2.0