Upload 96 files

.gitattributes

@@ -33,3 +33,19 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+backgrounds/bussiness_room.jpeg filter=lfs diff=lfs merge=lfs -text
+characters/black_haired_girl.png filter=lfs diff=lfs merge=lfs -text
+characters/bussinessman.png filter=lfs diff=lfs merge=lfs -text
+characters/pink_haired_girl.png filter=lfs diff=lfs merge=lfs -text
+llm/dolphin.gguf filter=lfs diff=lfs merge=lfs -text
+outputs/dream_chat_engine_preview.jpg filter=lfs diff=lfs merge=lfs -text
+outputs/kokoro_sample.wav filter=lfs diff=lfs merge=lfs -text
+outputs/kokoro_test.wav filter=lfs diff=lfs merge=lfs -text
+outputs/tts/am_michael_1781378852989.wav filter=lfs diff=lfs merge=lfs -text
+outputs/tts/am_michael_1781378862368.wav filter=lfs diff=lfs merge=lfs -text
+outputs/tts/am_michael_1781378874715.wav filter=lfs diff=lfs merge=lfs -text
+outputs/tts/am_michael_1781378894011.wav filter=lfs diff=lfs merge=lfs -text
+outputs/tts/am_michael_1781378899096.wav filter=lfs diff=lfs merge=lfs -text
+outputs/tts/am_michael_1781378909364.wav filter=lfs diff=lfs merge=lfs -text
+outputs/tts/am_michael_1781378932377.wav filter=lfs diff=lfs merge=lfs -text
+outputs/tts/am_michael_1781379206195.wav filter=lfs diff=lfs merge=lfs -text

dream_chat_engine/README.md

@@ -0,0 +1,9 @@
+# Dream Chat Engine
+
+A small Python visual chat engine with a RenPy-like script flow.
+
+Run the demo from the project root:
+
+```powershell
+python dream_chat_engine/demo.py
+```

dream_chat_engine/__init__.py

@@ -0,0 +1,17 @@
+"""A tiny RenPy-like visual chat engine for Python games."""
+
+from .actions import Ask, Generate, GeneratedReply, Hide, Say, SetBackground, Show
+from .config import EngineConfig
+from .engine import DreamChatEngine
+
+__all__ = [
+    "Ask",
+    "DreamChatEngine",
+    "EngineConfig",
+    "Generate",
+    "GeneratedReply",
+    "Hide",
+    "Say",
+    "SetBackground",
+    "Show",
+]

dream_chat_engine/actions.py

@@ -0,0 +1,68 @@
+"""Script actions used by Dream Chat Engine demos and games."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Callable, Iterable, Literal, Sequence
+
+AssetPath = str | Path
+Position = Literal["left", "center", "right"] | float
+InputRule = Literal["any", "letters"]
+DialogueHistory = list[dict[str, str]]
+ReplyProducer = Callable[[dict[str, str], DialogueHistory], str | Iterable[str]]
+
+
+@dataclass(frozen=True)
+class SetBackground:
+    image: AssetPath
+
+
+@dataclass(frozen=True)
+class Show:
+    name: str
+    image: AssetPath
+    position: Position = "center"
+    tag: str | None = None
+
+
+@dataclass(frozen=True)
+class Hide:
+    tag: str
+
+
+@dataclass(frozen=True)
+class Say:
+    speaker: str
+    text: str
+
+
+@dataclass(frozen=True)
+class GeneratedReply:
+    text: str
+    actions: Sequence[Any] = ()
+    variables: dict[str, str] = field(default_factory=dict)
+
+
+ReplyPostprocessor = Callable[
+    [str, dict[str, str], DialogueHistory],
+    str | GeneratedReply,
+]
+
+
+@dataclass(frozen=True)
+class Generate:
+    speaker: str
+    producer: ReplyProducer
+    postprocess: ReplyPostprocessor | None = None
+
+
+@dataclass(frozen=True)
+class Ask:
+    variable: str
+    prompt: str
+    speaker: str = "Stranger"
+    response_speaker: str | None = None
+    max_chars: int | None = None
+    input_rule: InputRule = "any"
+    min_chars: int = 0

dream_chat_engine/assets.py

@@ -0,0 +1,54 @@
+"""Asset loading helpers for backgrounds and character sprites."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Iterable
+
+from PIL import Image
+
+
+class AssetNotFoundError(FileNotFoundError):
+    """Raised when an asset cannot be resolved from the project folders."""
+
+
+class AssetManager:
+    def __init__(self, project_root: str | Path) -> None:
+        self.project_root = Path(project_root).resolve()
+        self.characters_dir = self.project_root / "characters"
+        self.backgrounds_dir = self.project_root / "backgrounds"
+
+    def load_background(self, asset: str | Path) -> Image.Image:
+        path = self.resolve(asset, (self.backgrounds_dir, self.project_root))
+        return Image.open(path).convert("RGBA")
+
+    def load_character(self, asset: str | Path) -> Image.Image:
+        path = self.resolve(asset, (self.characters_dir, self.project_root))
+        image = Image.open(path).convert("RGBA")
+        return self._crop_alpha(image)
+
+    def resolve(self, asset: str | Path, roots: Iterable[Path]) -> Path:
+        asset_path = Path(asset)
+        if asset_path.is_absolute() and asset_path.exists():
+            return asset_path
+
+        candidates: list[Path] = []
+        for root in roots:
+            candidates.append(root / asset_path)
+            if asset_path.suffix:
+                continue
+            candidates.extend(sorted(root.glob(f"{asset_path.name}.*")))
+
+        for candidate in candidates:
+            if candidate.exists() and candidate.is_file():
+                return candidate.resolve()
+
+        searched = ", ".join(str(root) for root in roots)
+        raise AssetNotFoundError(f"Could not find asset {asset!r} in {searched}.")
+
+    @staticmethod
+    def _crop_alpha(image: Image.Image) -> Image.Image:
+        bbox = image.getbbox()
+        if bbox is None:
+            return image
+        return image.crop(bbox)

dream_chat_engine/character.py

@@ -0,0 +1,17 @@
+"""Runtime character sprite model."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from PIL import Image
+
+from .actions import Position
+
+
+@dataclass
+class CharacterSprite:
+    tag: str
+    name: str
+    image: Image.Image
+    position: Position = "center"

dream_chat_engine/config.py

@@ -0,0 +1,37 @@
+"""Configuration values for the Dream Chat Engine window and renderer."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass
+class EngineConfig:
+    title: str = "Dream Chat Engine"
+    width: int = 1280
+    height: int = 720
+    min_width: int = 800
+    min_height: int = 450
+    fps: int = 30
+
+    text_speed: float = 42.0
+    max_input_chars: int = 240
+
+    character_max_height_ratio: float = 0.92
+    character_max_width_ratio: float = 0.46
+
+    dialogue_margin: int = 24
+    dialogue_height: int = 188
+    dialogue_radius: int = 8
+    dialogue_alpha: int = 205
+    dialogue_padding_x: int = 30
+    dialogue_padding_y: int = 18
+
+    name_font_size: int = 28
+    text_font_size: int = 30
+    prompt_font_size: int = 23
+    line_spacing: int = 8
+
+    auto_advance: bool = False
+    end_speaker: str = "Demo"
+    end_message: str | None = "End of demo."

dream_chat_engine/demo.py

@@ -0,0 +1,38 @@
+"""Hardcoded demo game for Dream Chat Engine."""
+
+from __future__ import annotations
+
+from pathlib import Path
+import sys
+
+PROJECT_ROOT = Path(__file__).resolve().parents[1]
+if str(PROJECT_ROOT) not in sys.path:
+    sys.path.insert(0, str(PROJECT_ROOT))
+
+from dream_chat_engine import Ask, DreamChatEngine, EngineConfig, Hide, Say, SetBackground, Show
+
+
+def build_script():
+    return [
+        SetBackground("bussiness_room.jpeg"),
+        Show("Mira", "pink_haired_girl.png", position="left", tag="mira"),
+        Say("Mira", "Hey. You made it. The room, the textbox, and the sprite layer are all live."),
+        Show("Mr. Vale", "bussinessman.png", position="right", tag="vale"),
+        Say("Mr. Vale", "Characters are loaded from the characters folder and kept flush with the bottom of the screen."),
+        Say("Mira", "The text prints itself out, but a click or the space bar can hurry it along."),
+        Ask("first_reply", "What do you say back?"),
+        Say("Mr. Vale", "Good. That reply was typed freely, stored, and then played as a Stranger line."),
+        Hide("vale"),
+        Show("Nyx", "black_haired_girl.png", position="center", tag="nyx"),
+        Say("Nyx", "That is enough for a first test. Drop more actions into demo.py and it becomes a tiny visual novel."),
+    ]
+
+
+def main() -> None:
+    config = EngineConfig(title="Dream Chat Engine Demo")
+    engine = DreamChatEngine(build_script(), project_root=PROJECT_ROOT, config=config)
+    engine.run()
+
+
+if __name__ == "__main__":
+    main()

dream_chat_engine/dialogue.py

@@ -0,0 +1,155 @@
+"""Dialogue and keyboard-input state."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass
+class DialogueState:
+    text_speed: float
+    mode: str = "idle"
+    speaker: str = ""
+    full_text: str = ""
+    visible_text: str = ""
+    prompt: str = ""
+    input_text: str = ""
+    caret_index: int = 0
+    awaiting_stream: bool = False
+    _loading_elapsed: float = 0.0
+    _revealed_chars: float = 0.0
+
+    def start_say(self, speaker: str, text: str) -> None:
+        self.mode = "say"
+        self.speaker = speaker
+        self.full_text = text
+        self.visible_text = ""
+        self.prompt = ""
+        self.input_text = ""
+        self.caret_index = 0
+        self.awaiting_stream = False
+        self._loading_elapsed = 0.0
+        self._revealed_chars = 0.0
+
+    def start_stream(self, speaker: str) -> None:
+        self.start_say(speaker, "")
+        self.awaiting_stream = True
+
+    def start_loading(self, speaker: str) -> None:
+        self.mode = "loading"
+        self.speaker = speaker
+        self.full_text = ""
+        self.visible_text = "."
+        self.prompt = ""
+        self.input_text = ""
+        self.caret_index = 0
+        self.awaiting_stream = True
+        self._loading_elapsed = 0.0
+        self._revealed_chars = 0.0
+
+    def start_input(self, speaker: str, prompt: str) -> None:
+        self.mode = "input"
+        self.speaker = speaker
+        self.full_text = ""
+        self.visible_text = ""
+        self.prompt = prompt
+        self.input_text = ""
+        self.caret_index = 0
+        self.awaiting_stream = False
+        self._loading_elapsed = 0.0
+        self._revealed_chars = 0.0
+
+    def update(self, delta_seconds: float) -> None:
+        if self.mode == "loading":
+            self._loading_elapsed += delta_seconds
+            phase = int(self._loading_elapsed / 0.36) % 4
+            self.visible_text = "." * phase
+            return
+
+        if self.mode != "say" or self.is_complete:
+            return
+
+        self._revealed_chars = min(
+            len(self.full_text),
+            self._revealed_chars + self.text_speed * delta_seconds,
+        )
+        self.visible_text = self.full_text[: int(self._revealed_chars)]
+
+    @property
+    def is_complete(self) -> bool:
+        return (
+            self.mode == "say"
+            and not self.awaiting_stream
+            and self.visible_text == self.full_text
+        )
+
+    def reveal_all(self) -> None:
+        if self.mode == "say":
+            self.visible_text = self.full_text
+            self._revealed_chars = float(len(self.full_text))
+
+    def append_stream_text(self, text: str) -> None:
+        if self.mode == "say" and text:
+            self.full_text += text
+
+    def finish_stream(self) -> None:
+        self.awaiting_stream = False
+
+    def insert_text(self, text: str, max_chars: int) -> None:
+        if self.mode != "input" or not text:
+            return
+        allowed = "".join(ch for ch in text if ch >= " " and ch != "\x7f")
+        if not allowed:
+            return
+        remaining = max_chars - len(self.input_text)
+        if remaining <= 0:
+            return
+        allowed = allowed[:remaining]
+        self.input_text = (
+            self.input_text[: self.caret_index]
+            + allowed
+            + self.input_text[self.caret_index :]
+        )
+        self.caret_index += len(allowed)
+
+    def backspace(self) -> None:
+        if self.mode == "input" and self.caret_index > 0:
+            self.input_text = (
+                self.input_text[: self.caret_index - 1]
+                + self.input_text[self.caret_index :]
+            )
+            self.caret_index -= 1
+
+    def delete(self) -> None:
+        if self.mode == "input" and self.caret_index < len(self.input_text):
+            self.input_text = (
+                self.input_text[: self.caret_index]
+                + self.input_text[self.caret_index + 1 :]
+            )
+
+    def move_caret(self, amount: int) -> None:
+        if self.mode == "input":
+            self.caret_index = max(0, min(len(self.input_text), self.caret_index + amount))
+
+    def move_caret_home(self) -> None:
+        if self.mode == "input":
+            self.caret_index = 0
+
+    def move_caret_end(self) -> None:
+        if self.mode == "input":
+            self.caret_index = len(self.input_text)
+
+    def display_input_with_caret(self) -> str:
+        return (
+            self.input_text[: self.caret_index]
+            + "|"
+            + self.input_text[self.caret_index :]
+        )
+
+    def submit_input(self) -> str:
+        response = self.input_text.strip()
+        self.mode = "idle"
+        self.prompt = ""
+        self.input_text = ""
+        self.caret_index = 0
+        return response

dream_chat_engine/engine.py

@@ -0,0 +1,399 @@
+"""Window loop and script runner for Dream Chat Engine."""
+
+from __future__ import annotations
+
+import queue
+import threading
+import time
+import tkinter as tk
+from collections import OrderedDict
+from pathlib import Path
+from typing import Any, Sequence
+
+from PIL import Image, ImageTk
+
+from .actions import Ask, Generate, GeneratedReply, Hide, Say, SetBackground, Show
+from .assets import AssetManager
+from .character import CharacterSprite
+from .config import EngineConfig
+from .dialogue import DialogueState
+from .renderer import SceneRenderer
+
+ScriptAction = SetBackground | Show | Hide | Say | Generate | Ask
+
+
+class DreamChatEngine:
+    def __init__(
+        self,
+        script: Sequence[ScriptAction],
+        project_root: str | Path,
+        config: EngineConfig | None = None,
+        voice_manager: object | None = None,
+    ) -> None:
+        self.script = list(script)
+        self.config = config or EngineConfig()
+        self.assets = AssetManager(project_root)
+        self.dialogue = DialogueState(text_speed=self.config.text_speed)
+        self.renderer = SceneRenderer(self.config)
+        self.voice_manager = voice_manager
+        self.background: Image.Image | None = None
+        self.characters: OrderedDict[str, CharacterSprite] = OrderedDict()
+        self.variables: dict[str, str] = {}
+        self.history: list[dict[str, str]] = []
+
+        self._index = 0
+        self._active_ask: Ask | None = None
+        self._generation_queue: queue.Queue[dict[str, Any]] | None = None
+        self._generation_thread: threading.Thread | None = None
+        self._speech_handle: Any | None = None
+        self._demo_finished = False
+        self._last_tick = time.perf_counter()
+
+        self._root: tk.Tk | None = None
+        self._canvas: tk.Canvas | None = None
+        self._photo: ImageTk.PhotoImage | None = None
+
+    def run(self) -> None:
+        self._root = tk.Tk()
+        self._root.title(self.config.title)
+        self._root.geometry(f"{self.config.width}x{self.config.height}")
+        self._root.minsize(self.config.min_width, self.config.min_height)
+
+        self._canvas = tk.Canvas(self._root, highlightthickness=0, bg="black")
+        self._canvas.pack(fill=tk.BOTH, expand=True)
+        self._canvas.focus_set()
+
+        self._root.bind("<Key>", self._on_key)
+        self._root.bind("<Button-1>", self._on_click)
+        self._canvas.bind("<Button-1>", self._on_click)
+
+        self._advance_script()
+        self._tick()
+        self._root.mainloop()
+
+    def _tick(self) -> None:
+        now = time.perf_counter()
+        delta = now - self._last_tick
+        self._last_tick = now
+        self.dialogue.update(delta)
+        self._drain_generation_queue()
+        self._maybe_auto_advance()
+        self._render()
+
+        if self._root is not None:
+            delay_ms = max(1, int(1000 / self.config.fps))
+            self._root.after(delay_ms, self._tick)
+
+    def _render(self) -> None:
+        if self._canvas is None:
+            return
+
+        width = max(1, self._canvas.winfo_width())
+        height = max(1, self._canvas.winfo_height())
+        if width <= 1 or height <= 1:
+            width, height = self.config.width, self.config.height
+
+        frame = self.renderer.compose(
+            (width, height),
+            self.background,
+            self.characters.values(),
+            self.dialogue,
+        )
+        self._photo = ImageTk.PhotoImage(frame)
+        self._canvas.delete("all")
+        self._canvas.create_image(0, 0, anchor=tk.NW, image=self._photo)
+
+    def _advance_script(self) -> None:
+        self._active_ask = None
+        self._speech_handle = None
+
+        while self._index < len(self.script):
+            action = self.script[self._index]
+            self._index += 1
+
+            if isinstance(action, SetBackground):
+                self.background = self.assets.load_background(action.image)
+                continue
+
+            if isinstance(action, Show):
+                tag = action.tag or action.name
+                self.characters[tag] = CharacterSprite(
+                    tag=tag,
+                    name=action.name,
+                    image=self.assets.load_character(action.image),
+                    position=action.position,
+                )
+                continue
+
+            if isinstance(action, Hide):
+                self.characters.pop(action.tag, None)
+                continue
+
+            if isinstance(action, Say):
+                speaker = self._format(action.speaker)
+                text = self._format(action.text)
+                self.dialogue.start_say(speaker, text)
+                self._record_line(speaker, text)
+                self._speech_handle = self._speak(speaker, text)
+                return
+
+            if isinstance(action, Generate):
+                self._start_generated_reply(action)
+                return
+
+            if isinstance(action, Ask):
+                self._active_ask = action
+                self.dialogue.start_input(
+                    self._format(action.speaker),
+                    self._format(action.prompt),
+                )
+                return
+
+        if self.config.end_message is not None and not self._demo_finished:
+            self._demo_finished = True
+            self.dialogue.start_say(self.config.end_speaker, self.config.end_message)
+        else:
+            self.close()
+
+    def _on_click(self, _event: tk.Event) -> None:
+        if self.dialogue.mode == "input":
+            return
+        self._continue_or_skip()
+
+    def _on_key(self, event: tk.Event) -> None:
+        keysym = event.keysym
+
+        if self.dialogue.mode == "input":
+            self._handle_input_key(event)
+            return
+
+        if keysym in {"space", "Return"}:
+            self._continue_or_skip()
+
+    def _continue_or_skip(self) -> None:
+        if self.config.auto_advance or self.dialogue.mode == "loading":
+            return
+        if not self._speech_is_done():
+            return
+        if self.dialogue.mode != "say":
+            return
+
+        if not self.dialogue.is_complete:
+            self.dialogue.reveal_all()
+            return
+
+        self._advance_script()
+
+    def _handle_input_key(self, event: tk.Event) -> None:
+        keysym = event.keysym
+
+        if keysym == "Return":
+            self._submit_input()
+        elif keysym == "BackSpace":
+            self.dialogue.backspace()
+        elif keysym == "Delete":
+            self.dialogue.delete()
+        elif keysym == "Left":
+            self.dialogue.move_caret(-1)
+        elif keysym == "Right":
+            self.dialogue.move_caret(1)
+        elif keysym == "Home":
+            self.dialogue.move_caret_home()
+        elif keysym == "End":
+            self.dialogue.move_caret_end()
+        elif event.char:
+            self._insert_input_text(event.char)
+
+    def _insert_input_text(self, text: str) -> None:
+        max_chars = self.config.max_input_chars
+        if self._active_ask is not None and self._active_ask.max_chars is not None:
+            max_chars = self._active_ask.max_chars
+
+        if self._active_ask is not None and self._active_ask.input_rule == "letters":
+            text = "".join(ch for ch in text if ch.isalpha())
+
+        self.dialogue.insert_text(text, max_chars)
+
+    def _submit_input(self) -> None:
+        if self._active_ask is None:
+            return
+
+        response = self.dialogue.submit_input()
+        if len(response) < self._active_ask.min_chars:
+            self.dialogue.start_input(
+                self._format(self._active_ask.speaker),
+                self._format(self._active_ask.prompt),
+            )
+            return
+
+        if not response:
+            response = "..."
+
+        self.variables[self._active_ask.variable] = response
+        response_speaker = self._active_ask.response_speaker or self._active_ask.speaker
+        speaker = self._format(response_speaker)
+        self.dialogue.start_say(speaker, response)
+        self._record_line(speaker, response)
+        self._speech_handle = self._speak(speaker, response)
+        self._active_ask = None
+
+    def _start_generated_reply(self, action: Generate) -> None:
+        speaker = self._format(action.speaker)
+        self.dialogue.start_loading(speaker)
+        self._speech_handle = None
+        self._generation_queue = queue.Queue()
+
+        variables = dict(self.variables)
+        history = [dict(item) for item in self.history]
+
+        def worker() -> None:
+            try:
+                reply = action.producer(variables, history)
+                if isinstance(reply, str):
+                    raw_text = reply
+                else:
+                    raw_text = "".join(str(chunk) for chunk in reply if chunk)
+
+                generated = self._postprocess_generated(action, raw_text, variables, history)
+                prepared_audio = self._prepare_speech(speaker, generated.text)
+                self._generation_queue.put(
+                    {
+                        "text": generated.text,
+                        "actions": list(generated.actions),
+                        "variables": dict(generated.variables),
+                        "prepared_audio": prepared_audio,
+                    }
+                )
+            except Exception as exc:
+                self._generation_queue.put(
+                    {
+                        "text": f"I must pause. {exc}",
+                        "actions": [],
+                        "variables": {},
+                        "prepared_audio": None,
+                    }
+                )
+
+        self._generation_thread = threading.Thread(target=worker, daemon=True)
+        self._generation_thread.start()
+
+    def _drain_generation_queue(self) -> None:
+        if self._generation_queue is None:
+            return
+
+        try:
+            payload = self._generation_queue.get_nowait()
+        except queue.Empty:
+            return
+
+        speaker = self.dialogue.speaker
+        text = str(payload.get("text") or "").strip()
+        if not text:
+            text = "We will discuss that in due time."
+
+        self.variables.update(payload.get("variables") or {})
+        self.insert_actions(payload.get("actions") or [])
+
+        self.dialogue.start_say(speaker, text)
+        self._record_line(speaker, text)
+        self._speech_handle = self._speak(
+            speaker,
+            text,
+            prepared_audio=payload.get("prepared_audio"),
+        )
+        self._generation_queue = None
+        self._generation_thread = None
+
+    def _postprocess_generated(
+        self,
+        action: Generate,
+        raw_text: str,
+        variables: dict[str, str],
+        history: list[dict[str, str]],
+    ) -> GeneratedReply:
+        text = raw_text.strip()
+        if action.postprocess is None:
+            return GeneratedReply(text=text)
+
+        processed = action.postprocess(text, variables, history)
+        if isinstance(processed, GeneratedReply):
+            return processed
+        return GeneratedReply(text=str(processed).strip())
+
+    def insert_actions(self, actions: Sequence[ScriptAction]) -> None:
+        if not actions:
+            return
+        self.script[self._index : self._index] = list(actions)
+
+    def _maybe_auto_advance(self) -> None:
+        if not self.config.auto_advance:
+            return
+        if self.dialogue.mode != "say":
+            return
+        if not self.dialogue.is_complete:
+            return
+        if not self._speech_is_done():
+            return
+        self._advance_script()
+
+    def _record_line(self, speaker: str, text: str) -> None:
+        self.history.append({"speaker": speaker, "text": text})
+
+    def _prepare_speech(self, speaker: str, text: str) -> Any | None:
+        if self.voice_manager is None:
+            return None
+        prepare = getattr(self.voice_manager, "prepare", None)
+        if prepare is None:
+            return None
+        try:
+            return prepare(speaker, text)
+        except Exception:
+            return None
+
+    def _speak(self, speaker: str, text: str, prepared_audio: Any | None = None) -> Any | None:
+        if self.voice_manager is None:
+            return None
+        speak = getattr(self.voice_manager, "speak", None)
+        if speak is None:
+            return None
+        try:
+            return speak(speaker, text, prepared_audio=prepared_audio)
+        except Exception:
+            return None
+
+    def _speech_is_done(self) -> bool:
+        if self._speech_handle is None:
+            return True
+        is_done = getattr(self._speech_handle, "is_done", None)
+        if is_done is not None:
+            try:
+                return bool(is_done())
+            except Exception:
+                return True
+        done = getattr(self._speech_handle, "done", None)
+        if done is not None:
+            return bool(done)
+        return True
+
+    def close(self) -> None:
+        if self.voice_manager is not None:
+            stop = getattr(self.voice_manager, "stop", None)
+            if stop is not None:
+                try:
+                    stop()
+                except Exception:
+                    pass
+        if self._root is not None:
+            self._root.destroy()
+            self._root = None
+
+    def _format(self, value: str) -> str:
+        try:
+            return value.format_map(_SafeVariables(self.variables))
+        except (KeyError, ValueError):
+            return value
+
+
+class _SafeVariables(dict[str, str]):
+    def __missing__(self, key: str) -> str:
+        return "{" + key + "}"

dream_chat_engine/renderer.py

@@ -0,0 +1,272 @@
+"""Pillow renderer used by the Tkinter window."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from pathlib import Path
+
+from PIL import Image, ImageDraw, ImageFont
+
+from .actions import Position
+from .character import CharacterSprite
+from .config import EngineConfig
+from .dialogue import DialogueState
+
+
+class SceneRenderer:
+    def __init__(self, config: EngineConfig) -> None:
+        self.config = config
+        self._stage_cache_key: tuple[object, ...] | None = None
+        self._stage_cache_image: Image.Image | None = None
+        self._font_cache: dict[tuple[int, bool], ImageFont.ImageFont] = {}
+
+    def compose(
+        self,
+        size: tuple[int, int],
+        background: Image.Image | None,
+        characters: Iterable[CharacterSprite],
+        dialogue: DialogueState,
+    ) -> Image.Image:
+        width, height = size
+        frame = self._stage(size, background, tuple(characters)).copy()
+        self._draw_dialogue(frame, dialogue)
+        return frame.convert("RGB")
+
+    def _stage(
+        self,
+        size: tuple[int, int],
+        background: Image.Image | None,
+        characters: tuple[CharacterSprite, ...],
+    ) -> Image.Image:
+        width, height = size
+        key = (
+            width,
+            height,
+            id(background),
+            tuple((char.tag, id(char.image), char.position) for char in characters),
+        )
+        if key == self._stage_cache_key and self._stage_cache_image is not None:
+            return self._stage_cache_image
+
+        frame = Image.new("RGBA", size, (19, 21, 26, 255))
+        if background is not None:
+            frame.alpha_composite(self._cover(background, size), (0, 0))
+
+        for character in characters:
+            self._paste_character(frame, character)
+
+        self._stage_cache_key = key
+        self._stage_cache_image = frame
+        return frame
+
+    def _cover(self, image: Image.Image, size: tuple[int, int]) -> Image.Image:
+        width, height = size
+        scale = max(width / image.width, height / image.height)
+        new_size = (max(1, int(image.width * scale)), max(1, int(image.height * scale)))
+        resized = image.resize(new_size, Image.Resampling.LANCZOS)
+        left = (resized.width - width) // 2
+        top = (resized.height - height) // 2
+        return resized.crop((left, top, left + width, top + height))
+
+    def _paste_character(self, frame: Image.Image, character: CharacterSprite) -> None:
+        width, height = frame.size
+        max_height = int(height * self.config.character_max_height_ratio)
+        max_width = int(width * self.config.character_max_width_ratio)
+        scale = min(max_height / character.image.height, max_width / character.image.width)
+        new_size = (
+            max(1, int(character.image.width * scale)),
+            max(1, int(character.image.height * scale)),
+        )
+        sprite = character.image.resize(new_size, Image.Resampling.LANCZOS)
+        anchor_x = self._position_to_x(character.position, width)
+        left = int(anchor_x - sprite.width / 2)
+        left = max(-sprite.width // 3, min(width - sprite.width * 2 // 3, left))
+        top = height - sprite.height
+        frame.alpha_composite(sprite, (left, top))
+
+    @staticmethod
+    def _position_to_x(position: Position, width: int) -> float:
+        if isinstance(position, float):
+            return width * position
+        if position == "left":
+            return width * 0.28
+        if position == "right":
+            return width * 0.72
+        return width * 0.5
+
+    def _draw_dialogue(self, frame: Image.Image, dialogue: DialogueState) -> None:
+        if dialogue.mode not in {"say", "input", "loading"}:
+            return
+
+        draw = ImageDraw.Draw(frame, "RGBA")
+        width, height = frame.size
+        margin = min(self.config.dialogue_margin, max(8, width // 30))
+        panel_height = min(self.config.dialogue_height, height - margin * 2)
+        left = margin
+        top = height - panel_height - margin
+        right = width - margin
+        bottom = height - margin
+
+        draw.rounded_rectangle(
+            (left, top, right, bottom),
+            radius=self.config.dialogue_radius,
+            fill=(0, 0, 0, self.config.dialogue_alpha),
+        )
+
+        name_font = self._font(self.config.name_font_size, bold=True)
+        text_font = self._font(self.config.text_font_size, bold=False)
+        prompt_font = self._font(self.config.prompt_font_size, bold=False)
+        pad_x = self.config.dialogue_padding_x
+        pad_y = self.config.dialogue_padding_y
+        text_left = left + pad_x
+        text_right = right - pad_x
+        name_y = top + pad_y
+        body_y = name_y + self.config.name_font_size + 14
+
+        if dialogue.speaker:
+            draw.text((text_left, name_y), dialogue.speaker, font=name_font, fill=(142, 220, 255, 255))
+
+        if dialogue.mode == "input":
+            if dialogue.prompt:
+                prompt_bottom = self._draw_wrapped(
+                    draw,
+                    dialogue.prompt,
+                    prompt_font,
+                    (232, 237, 243, 235),
+                    (text_left, body_y, text_right, bottom - 62),
+                )
+            else:
+                prompt_bottom = body_y
+            self._draw_wrapped(
+                draw,
+                dialogue.display_input_with_caret(),
+                text_font,
+                (255, 255, 255, 255),
+                (text_left, prompt_bottom + 12, text_right, bottom - pad_y),
+            )
+            return
+
+        if dialogue.mode == "loading":
+            self._draw_wrapped(
+                draw,
+                dialogue.visible_text,
+                text_font,
+                (255, 255, 255, 255),
+                (text_left, body_y, text_right, bottom - pad_y),
+            )
+            return
+
+        self._draw_wrapped(
+            draw,
+            dialogue.visible_text,
+            text_font,
+            (255, 255, 255, 255),
+            (text_left, body_y, text_right, bottom - pad_y),
+        )
+
+        if dialogue.is_complete and not self.config.auto_advance:
+            indicator_font = self._font(24, bold=True)
+            draw.text((right - 48, bottom - 42), ">", font=indicator_font, fill=(255, 255, 255, 220))
+
+    def _draw_wrapped(
+        self,
+        draw: ImageDraw.ImageDraw,
+        text: str,
+        font: ImageFont.ImageFont,
+        fill: tuple[int, int, int, int],
+        box: tuple[int, int, int, int],
+    ) -> int:
+        left, top, right, bottom = box
+        line_height = self._line_height(font) + self.config.line_spacing
+        lines = self._wrap_text(draw, text, font, max(1, right - left))
+        max_lines = max(1, (bottom - top) // line_height)
+        if len(lines) > max_lines:
+            lines = lines[-max_lines:]
+
+        y = top
+        for line in lines:
+            if y + line_height > bottom + self.config.line_spacing:
+                break
+            draw.text((left, y), line, font=font, fill=fill)
+            y += line_height
+        return y
+
+    def _wrap_text(
+        self,
+        draw: ImageDraw.ImageDraw,
+        text: str,
+        font: ImageFont.ImageFont,
+        max_width: int,
+    ) -> list[str]:
+        if not text:
+            return [""]
+
+        lines: list[str] = []
+        for raw_line in text.splitlines() or [""]:
+            words = raw_line.split(" ")
+            current = ""
+            for word in words:
+                candidate = word if not current else f"{current} {word}"
+                if self._text_width(draw, candidate, font) <= max_width:
+                    current = candidate
+                    continue
+                if current:
+                    lines.append(current)
+                current = self._break_long_word(draw, word, font, max_width, lines)
+            lines.append(current)
+        return lines
+
+    def _break_long_word(
+        self,
+        draw: ImageDraw.ImageDraw,
+        word: str,
+        font: ImageFont.ImageFont,
+        max_width: int,
+        lines: list[str],
+    ) -> str:
+        current = ""
+        for char in word:
+            candidate = current + char
+            if self._text_width(draw, candidate, font) <= max_width:
+                current = candidate
+            else:
+                if current:
+                    lines.append(current)
+                current = char
+        return current
+
+    @staticmethod
+    def _text_width(draw: ImageDraw.ImageDraw, text: str, font: ImageFont.ImageFont) -> int:
+        bbox = draw.textbbox((0, 0), text, font=font)
+        return bbox[2] - bbox[0]
+
+    @staticmethod
+    def _line_height(font: ImageFont.ImageFont) -> int:
+        bbox = font.getbbox("Ag")
+        return bbox[3] - bbox[1]
+
+    def _font(self, size: int, bold: bool) -> ImageFont.ImageFont:
+        key = (size, bold)
+        if key in self._font_cache:
+            return self._font_cache[key]
+
+        font_names = (
+            ("segoeuib.ttf", "arialbd.ttf") if bold else ("segoeui.ttf", "arial.ttf")
+        )
+        candidates: list[str | Path] = []
+        windows_fonts = Path("C:/Windows/Fonts")
+        for name in font_names:
+            candidates.append(name)
+            candidates.append(windows_fonts / name)
+
+        for candidate in candidates:
+            try:
+                font = ImageFont.truetype(str(candidate), size=size)
+                self._font_cache[key] = font
+                return font
+            except OSError:
+                continue
+
+        font = ImageFont.load_default()
+        self._font_cache[key] = font
+        return font

kokoro/README.md

@@ -0,0 +1,117 @@
+---
+license: apache-2.0
+language:
+- en
+base_model:
+- yl4579/StyleTTS2-LJSpeech
+pipeline_tag: text-to-speech
+---
+**Kokoro** is an open-weight TTS model with 82 million parameters. Despite its lightweight architecture, it delivers comparable quality to larger models while being significantly faster and more cost-efficient. With Apache-licensed weights, Kokoro can be deployed anywhere from production environments to personal projects.
+
+<audio controls><source src="https://huggingface.co/hexgrad/Kokoro-82M/resolve/main/samples/HEARME.wav" type="audio/wav"></audio>
+
+🐈 **GitHub**: https://github.com/hexgrad/kokoro
+
+🚀 **Demo**: https://hf.co/spaces/hexgrad/Kokoro-TTS
+
+> [!NOTE]
+> As of April 2025, the market rate of Kokoro served over API is **under $1 per million characters of text input**, or under $0.06 per hour of audio output. (On average, 1000 characters of input is about 1 minute of output.) Sources: [ArtificialAnalysis/Replicate at 65 cents per M chars](https://artificialanalysis.ai/text-to-speech/model-family/kokoro#price) and [DeepInfra at 80 cents per M chars](https://deepinfra.com/hexgrad/Kokoro-82M).
+>
+> This is an Apache-licensed model, and Kokoro has been deployed in numerous projects and commercial APIs. We welcome the deployment of the model in real use cases.
+
+> [!CAUTION]
+> Fake websites like kokorottsai_com (snapshot: https://archive.ph/nRRnk) and kokorotts_net (snapshot: https://archive.ph/60opa) are likely scams masquerading under the banner of a popular model.
+>
+> Any website containing "kokoro" in its root domain (e.g. kokorottsai_com, kokorotts_net) is **NOT owned by and NOT affiliated with this model page or its author**, and attempts to imply otherwise are red flags.
+
+- [Releases](#releases)
+- [Usage](#usage)
+- [EVAL.md](https://huggingface.co/hexgrad/Kokoro-82M/blob/main/EVAL.md) ↗️
+- [SAMPLES.md](https://huggingface.co/hexgrad/Kokoro-82M/blob/main/SAMPLES.md) ↗️
+- [VOICES.md](https://huggingface.co/hexgrad/Kokoro-82M/blob/main/VOICES.md) ↗️
+- [Model Facts](#model-facts)
+- [Training Details](#training-details)
+- [Creative Commons Attribution](#creative-commons-attribution)
+- [Acknowledgements](#acknowledgements)
+
+### Releases
+
+| Model | Published | Training Data | Langs & Voices | SHA256 |
+| ----- | --------- | ------------- | -------------- | ------ |
+| **v1.0** | **2025 Jan 27** | **Few hundred hrs** | [**8 & 54**](https://huggingface.co/hexgrad/Kokoro-82M/blob/main/VOICES.md) | `496dba11` |
+| [v0.19](https://huggingface.co/hexgrad/kLegacy/tree/main/v0.19) | 2024 Dec 25 | <100 hrs | 1 & 10 | `3b0c392f` |
+
+| Training Costs | v0.19 | v1.0 | **Total** |
+| -------------- | ----- | ---- | ----- |
+| in A100 80GB GPU hours | 500 | 500 | **1000** |
+| average hourly rate | $0.80/h | $1.20/h | **$1/h** |
+| in USD | $400 | $600 | **$1000** |
+
+### Usage
+You can run this basic cell on [Google Colab](https://colab.research.google.com/). [Listen to samples](https://huggingface.co/hexgrad/Kokoro-82M/blob/main/SAMPLES.md). For more languages and details, see [Advanced Usage](https://github.com/hexgrad/kokoro?tab=readme-ov-file#advanced-usage).
+```py
+!pip install -q kokoro>=0.9.2 soundfile
+!apt-get -qq -y install espeak-ng > /dev/null 2>&1
+from kokoro import KPipeline
+from IPython.display import display, Audio
+import soundfile as sf
+import torch
+pipeline = KPipeline(lang_code='a')
+text = '''
+[Kokoro](/kˈOkəɹO/) is an open-weight TTS model with 82 million parameters. Despite its lightweight architecture, it delivers comparable quality to larger models while being significantly faster and more cost-efficient. With Apache-licensed weights, [Kokoro](/kˈOkəɹO/) can be deployed anywhere from production environments to personal projects.
+'''
+generator = pipeline(text, voice='af_heart')
+for i, (gs, ps, audio) in enumerate(generator):
+    print(i, gs, ps)
+    display(Audio(data=audio, rate=24000, autoplay=i==0))
+    sf.write(f'{i}.wav', audio, 24000)
+```
+Under the hood, `kokoro` uses [`misaki`](https://pypi.org/project/misaki/), a G2P library at https://github.com/hexgrad/misaki
+
+### Model Facts
+
+**Architecture:**
+- StyleTTS 2: https://arxiv.org/abs/2306.07691
+- ISTFTNet: https://arxiv.org/abs/2203.02395
+- Decoder only: no diffusion, no encoder release
+
+**Architected by:** Li et al @ https://github.com/yl4579/StyleTTS2
+
+**Trained by**: `@rzvzn` on Discord
+
+**Languages:** Multiple
+
+**Model SHA256 Hash:** `496dba118d1a58f5f3db2efc88dbdc216e0483fc89fe6e47ee1f2c53f18ad1e4`
+
+### Training Details
+
+**Data:** Kokoro was trained exclusively on **permissive/non-copyrighted audio data** and IPA phoneme labels. Examples of permissive/non-copyrighted audio include:
+- Public domain audio
+- Audio licensed under Apache, MIT, etc
+- Synthetic audio<sup>[1]</sup> generated by closed<sup>[2]</sup> TTS models from large providers<br/>
+[1] https://copyright.gov/ai/ai_policy_guidance.pdf<br/>
+[2] No synthetic audio from open TTS models or "custom voice clones"
+
+**Total Dataset Size:** A few hundred hours of audio
+
+**Total Training Cost:** About $1000 for 1000 hours of A100 80GB vRAM
+
+### Creative Commons Attribution
+
+The following CC BY audio was part of the dataset used to train Kokoro v1.0.
+
+| Audio Data | Duration Used | License | Added to Training Set After |
+| ---------- | ------------- | ------- | --------------------------- |
+| [Koniwa](https://github.com/koniwa/koniwa) `tnc` | <1h | [CC BY 3.0](https://creativecommons.org/licenses/by/3.0/deed.ja) | v0.19 / 22 Nov 2024 |
+| [SIWIS](https://datashare.ed.ac.uk/handle/10283/2353) | <11h | [CC BY 4.0](https://datashare.ed.ac.uk/bitstream/handle/10283/2353/license_text) | v0.19 / 22 Nov 2024 |
+
+### Acknowledgements
+
+- 🛠️ [@yl4579](https://huggingface.co/yl4579) for architecting StyleTTS 2.
+- 🏆 [@Pendrokar](https://huggingface.co/Pendrokar) for adding Kokoro as a contender in the TTS Spaces Arena.
+- 📊 Thank you to everyone who contributed synthetic training data.
+- ❤️ Special thanks to all compute sponsors.
+- 👾 Discord server: https://discord.gg/QuGxSWBfQy
+- 🪽 Kokoro is a Japanese word that translates to "heart" or "spirit". It is also the name of an [AI in the Terminator franchise](https://terminator.fandom.com/wiki/Kokoro).
+
+<img src="https://static0.gamerantimages.com/wordpress/wp-content/uploads/2024/08/terminator-zero-41-1.jpg" width="400" alt="kokoro" />

kokoro/VOICES.md

@@ -0,0 +1,161 @@
+# Voices
+
+- 🇺🇸 [American English](#american-english): 11F 9M
+- 🇬🇧 [British English](#british-english): 4F 4M
+- 🇯🇵 [Japanese](#japanese): 4F 1M
+- 🇨🇳 [Mandarin Chinese](#mandarin-chinese): 4F 4M
+- 🇪🇸 [Spanish](#spanish): 1F 2M
+- 🇫🇷 [French](#french): 1F
+- 🇮🇳 [Hindi](#hindi): 2F 2M
+- 🇮🇹 [Italian](#italian): 1F 1M
+- 🇧🇷 [Brazilian Portuguese](#brazilian-portuguese): 1F 2M
+
+For each voice, the given grades are intended to be estimates of the **quality and quantity** of its associated training data, both of which impact overall inference quality.
+
+Subjectively, voices will sound better or worse to different people.
+
+Support for non-English languages may be absent or thin due to weak G2P and/or lack of training data. Some languages are only represented by a small handful or even just one voice (French).
+
+Most voices perform best on a "goldilocks range" of 100-200 tokens out of ~500 possible. Voices may perform worse at the extremes:
+- **Weakness** on short utterances, especially less than 10-20 tokens. Root cause could be lack of short-utterance training data and/or model architecture. One possible inference mitigation is to bundle shorter utterances together.
+- **Rushing** on long utterances, especially over 400 tokens. You can chunk down to shorter utterances or adjust the `speed` parameter to mitigate this.
+
+**Target Quality**
+- How high quality is the reference voice? This grade may be impacted by audio quality, artifacts, compression, & sample rate.
+- How well do the text labels match the audio? Text/audio misalignment (e.g. from hallucinations) will lower this grade.
+
+**Training Duration**
+- How much audio was seen during training? Smaller durations result in a lower overall grade.
+- 10 hours <= **HH hours** < 100 hours
+- 1 hour <= H hours < 10 hours
+- 10 minutes <= MM minutes < 100 minutes
+- 1 minute <= _M minutes_ 🤏 < 10 minutes
+
+### American English
+
+- `lang_code='a'` in [`misaki[en]`](https://github.com/hexgrad/misaki)
+- espeak-ng `en-us` fallback
+
+| Name | Traits | Target Quality | Training Duration | Overall Grade | SHA256 |
+| ---- | ------ | -------------- | ----------------- | ------------- | ------ |
+| **af\_heart** | 🚺❤️ | | | **A** | `0ab5709b` |
+| af_alloy | 🚺 | B | MM minutes | C | `6d877149` |
+| af_aoede | 🚺 | B | H hours | C+ | `c03bd1a4` |
+| af_bella | 🚺🔥 | **A** | **HH hours** | **A-** | `8cb64e02` |
+| af_jessica | 🚺 | C | MM minutes | D | `cdfdccb8` |
+| af_kore | 🚺 | B | H hours | C+ | `8bfbc512` |
+| af_nicole | 🚺🎧 | B | **HH hours** | B- | `c5561808` |
+| af_nova | 🚺 | B | MM minutes | C | `e0233676` |
+| af_river | 🚺 | C | MM minutes | D | `e149459b` |
+| af_sarah | 🚺 | B | H hours | C+ | `49bd364e` |
+| af_sky | 🚺 | B | _M minutes_ 🤏 | C- | `c799548a` |
+| am_adam | 🚹 | D | H hours | F+ | `ced7e284` |
+| am_echo | 🚹 | C | MM minutes | D | `8bcfdc85` |
+| am_eric | 🚹 | C | MM minutes | D | `ada66f0e` |
+| am_fenrir | 🚹 | B | H hours | C+ | `98e507ec` |
+| am_liam | 🚹 | C | MM minutes | D | `c8255075` |
+| am_michael | 🚹 | B | H hours | C+ | `9a443b79` |
+| am_onyx | 🚹 | C | MM minutes | D | `e8452be1` |
+| am_puck | 🚹 | B | H hours | C+ | `dd1d8973` |
+| am_santa | 🚹 | C | _M minutes_ 🤏 | D- | `7f2f7582` |
+
+### British English
+
+- `lang_code='b'` in [`misaki[en]`](https://github.com/hexgrad/misaki)
+- espeak-ng `en-gb` fallback
+
+| Name | Traits | Target Quality | Training Duration | Overall Grade | SHA256 |
+| ---- | ------ | -------------- | ----------------- | ------------- | ------ |
+| bf_alice | 🚺 | C | MM minutes | D | `d292651b` |
+| bf_emma | 🚺 | B | **HH hours** | B- | `d0a423de` |
+| bf_isabella | 🚺 | B | MM minutes | C | `cdd4c370` |
+| bf_lily | 🚺 | C | MM minutes | D | `6e09c2e4` |
+| bm_daniel | 🚹 | C | MM minutes | D | `fc3fce4e` |
+| bm_fable | 🚹 | B | MM minutes | C | `d44935f3` |
+| bm_george | 🚹 | B | MM minutes | C | `f1bc8122` |
+| bm_lewis | 🚹 | C | H hours | D+ | `b5204750` |
+
+### Japanese
+
+- `lang_code='j'` in [`misaki[ja]`](https://github.com/hexgrad/misaki)
+- Total Japanese training data: H hours
+
+| Name | Traits | Target Quality | Training Duration | Overall Grade | SHA256 | CC BY |
+| ---- | ------ | -------------- | ----------------- | ------------- | ------ | ----- |
+| jf_alpha | 🚺 | B | H hours | C+ | `1bf4c9dc` | |
+| jf_gongitsune | 🚺 | B | MM minutes | C | `1b171917` | [gongitsune](https://github.com/koniwa/koniwa/blob/master/source/tnc/tnc__gongitsune.txt) |
+| jf_nezumi | 🚺 | B | _M minutes_ 🤏 | C- | `d83f007a` | [nezuminoyomeiri](https://github.com/koniwa/koniwa/blob/master/source/tnc/tnc__nezuminoyomeiri.txt) |
+| jf_tebukuro | 🚺 | B | MM minutes | C | `0d691790` | [tebukurowokaini](https://github.com/koniwa/koniwa/blob/master/source/tnc/tnc__tebukurowokaini.txt) |
+| jm_kumo | 🚹 | B | _M minutes_ 🤏 | C- | `98340afd` | [kumonoito](https://github.com/koniwa/koniwa/blob/master/source/tnc/tnc__kumonoito.txt) |
+
+### Mandarin Chinese
+
+- `lang_code='z'` in [`misaki[zh]`](https://github.com/hexgrad/misaki)
+- Total Mandarin Chinese training data: H hours
+
+| Name | Traits | Target Quality | Training Duration | Overall Grade | SHA256 |
+| ---- | ------ | -------------- | ----------------- | ------------- | ------ |
+| zf_xiaobei | 🚺 | C | MM minutes | D | `9b76be63` |
+| zf_xiaoni | 🚺 | C | MM minutes | D | `95b49f16` |
+| zf_xiaoxiao | 🚺 | C | MM minutes | D | `cfaf6f2d` |
+| zf_xiaoyi | 🚺 | C | MM minutes | D | `b5235dba` |
+| zm_yunjian | 🚹 | C | MM minutes | D | `76cbf8ba` |
+| zm_yunxi | 🚹 | C | MM minutes | D | `dbe6e1ce` |
+| zm_yunxia | 🚹 | C | MM minutes | D | `bb2b03b0` |
+| zm_yunyang | 🚹 | C | MM minutes | D | `5238ac22` |
+
+### Spanish
+
+- `lang_code='e'` in [`misaki[en]`](https://github.com/hexgrad/misaki)
+- espeak-ng `es`
+
+| Name | Traits | SHA256 |
+| ---- | ------ | ------ |
+| ef_dora | 🚺 | `d9d69b0f` |
+| em_alex | 🚹 | `5eac53f7` |
+| em_santa | 🚹 | `aa8620cb` |
+
+### French
+
+- `lang_code='f'` in [`misaki[en]`](https://github.com/hexgrad/misaki)
+- espeak-ng `fr-fr`
+- Total French training data: <11 hours
+
+| Name | Traits | Target Quality | Training Duration | Overall Grade | SHA256 | CC BY |
+| ---- | ------ | -------------- | ----------------- | ------------- | ------ | ----- |
+| ff_siwis | 🚺 | B | <11 hours | B- | `8073bf2d` | [SIWIS](https://datashare.ed.ac.uk/handle/10283/2353) |
+
+### Hindi
+
+- `lang_code='h'` in [`misaki[en]`](https://github.com/hexgrad/misaki)
+- espeak-ng `hi`
+- Total Hindi training data: H hours
+
+| Name | Traits | Target Quality | Training Duration | Overall Grade | SHA256 |
+| ---- | ------ | -------------- | ----------------- | ------------- | ------ |
+| hf_alpha | 🚺 | B | MM minutes | C | `06906fe0` |
+| hf_beta | 🚺 | B | MM minutes | C | `63c0a1a6` |
+| hm_omega | 🚹 | B | MM minutes | C | `b55f02a8` |
+| hm_psi | 🚹 | B | MM minutes | C | `2f0f055c` |
+
+### Italian
+
+- `lang_code='i'` in [`misaki[en]`](https://github.com/hexgrad/misaki)
+- espeak-ng `it`
+- Total Italian training data: H hours
+
+| Name | Traits | Target Quality | Training Duration | Overall Grade | SHA256 |
+| ---- | ------ | -------------- | ----------------- | ------------- | ------ |
+| if_sara | 🚺 | B | MM minutes | C | `6c0b253b` |
+| im_nicola | 🚹 | B | MM minutes | C | `234ed066` |
+
+### Brazilian Portuguese
+
+- `lang_code='p'` in [`misaki[en]`](https://github.com/hexgrad/misaki)
+- espeak-ng `pt-br`
+
+| Name | Traits | SHA256 |
+| ---- | ------ | ------ |
+| pf_dora | 🚺 | `07e4ff98` |
+| pm_alex | 🚹 | `cf0ba8c5` |
+| pm_santa | 🚹 | `d4210316` |

kokoro/config.json

@@ -0,0 +1,150 @@
+{
+  "istftnet": {
+    "upsample_kernel_sizes": [20, 12],
+    "upsample_rates": [10, 6],
+    "gen_istft_hop_size": 5,
+    "gen_istft_n_fft": 20,
+    "resblock_dilation_sizes": [
+      [1, 3, 5],
+      [1, 3, 5],
+      [1, 3, 5]
+    ],
+    "resblock_kernel_sizes": [3, 7, 11],
+    "upsample_initial_channel": 512
+  },
+  "dim_in": 64,
+  "dropout": 0.2,
+  "hidden_dim": 512,
+  "max_conv_dim": 512,
+  "max_dur": 50,
+  "multispeaker": true,
+  "n_layer": 3,
+  "n_mels": 80,
+  "n_token": 178,
+  "style_dim": 128,
+  "text_encoder_kernel_size": 5,
+  "plbert": {
+    "hidden_size": 768,
+    "num_attention_heads": 12,
+    "intermediate_size": 2048,
+    "max_position_embeddings": 512,
+    "num_hidden_layers": 12,
+    "dropout": 0.1
+  },
+  "vocab": {
+    ";": 1,
+    ":": 2,
+    ",": 3,
+    ".": 4,
+    "!": 5,
+    "?": 6,
+    "—": 9,
+    "…": 10,
+    "\"": 11,
+    "(": 12,
+    ")": 13,
+    "“": 14,
+    "”": 15,
+    " ": 16,
+    "\u0303": 17,
+    "ʣ": 18,
+    "ʥ": 19,
+    "ʦ": 20,
+    "ʨ": 21,
+    "ᵝ": 22,
+    "\uAB67": 23,
+    "A": 24,
+    "I": 25,
+    "O": 31,
+    "Q": 33,
+    "S": 35,
+    "T": 36,
+    "W": 39,
+    "Y": 41,
+    "ᵊ": 42,
+    "a": 43,
+    "b": 44,
+    "c": 45,
+    "d": 46,
+    "e": 47,
+    "f": 48,
+    "h": 50,
+    "i": 51,
+    "j": 52,
+    "k": 53,
+    "l": 54,
+    "m": 55,
+    "n": 56,
+    "o": 57,
+    "p": 58,
+    "q": 59,
+    "r": 60,
+    "s": 61,
+    "t": 62,
+    "u": 63,
+    "v": 64,
+    "w": 65,
+    "x": 66,
+    "y": 67,
+    "z": 68,
+    "ɑ": 69,
+    "ɐ": 70,
+    "ɒ": 71,
+    "æ": 72,
+    "β": 75,
+    "ɔ": 76,
+    "ɕ": 77,
+    "ç": 78,
+    "ɖ": 80,
+    "ð": 81,
+    "ʤ": 82,
+    "ə": 83,
+    "ɚ": 85,
+    "ɛ": 86,
+    "ɜ": 87,
+    "ɟ": 90,
+    "ɡ": 92,
+    "ɥ": 99,
+    "ɨ": 101,
+    "ɪ": 102,
+    "ʝ": 103,
+    "ɯ": 110,
+    "ɰ": 111,
+    "ŋ": 112,
+    "ɳ": 113,
+    "ɲ": 114,
+    "ɴ": 115,
+    "ø": 116,
+    "ɸ": 118,
+    "θ": 119,
+    "œ": 120,
+    "ɹ": 123,
+    "ɾ": 125,
+    "ɻ": 126,
+    "ʁ": 128,
+    "ɽ": 129,
+    "ʂ": 130,
+    "ʃ": 131,
+    "ʈ": 132,
+    "ʧ": 133,
+    "ʊ": 135,
+    "ʋ": 136,
+    "ʌ": 138,
+    "ɣ": 139,
+    "ɤ": 140,
+    "χ": 142,
+    "ʎ": 143,
+    "ʒ": 147,
+    "ʔ": 148,
+    "ˈ": 156,
+    "ˌ": 157,
+    "ː": 158,
+    "ʰ": 162,
+    "ʲ": 164,
+    "↓": 169,
+    "→": 171,
+    "↗": 172,
+    "↘": 173,
+    "ᵻ": 177
+  }
+}

kokoro/kokoro-v1_0.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:496dba118d1a58f5f3db2efc88dbdc216e0483fc89fe6e47ee1f2c53f18ad1e4
+size 327212226

kokoro/requirements.txt

@@ -0,0 +1,5 @@
+# Use Python 3.10, 3.11, or 3.12. Kokoro 0.9.4 is not published for Python 3.13+.
+kokoro>=0.9.4
+soundfile>=0.12.1
+misaki[ja]>=0.9.4
+misaki[zh]>=0.9.4

kokoro/sample.py

@@ -0,0 +1,368 @@
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+from pathlib import Path
+
+REPO_ID = "hexgrad/Kokoro-82M"
+SAMPLE_RATE = 24000
+
+ROOT = Path(__file__).resolve().parent
+ASSET_DIR = ROOT
+CONFIG_FILE = ASSET_DIR / "config.json"
+MODEL_FILE = ASSET_DIR / "kokoro-v1_0.pth"
+VOICE_DIR = ASSET_DIR / "voices"
+
+LANG_NAMES = {
+    "a": "American English",
+    "b": "British English",
+    "e": "Spanish",
+    "f": "French",
+    "h": "Hindi",
+    "i": "Italian",
+    "j": "Japanese",
+    "p": "Brazilian Portuguese",
+    "z": "Mandarin Chinese",
+}
+
+LANG_ALIASES = {
+    "auto": "auto",
+    "a": "a",
+    "en-us": "a",
+    "us": "a",
+    "american": "a",
+    "b": "b",
+    "en-gb": "b",
+    "gb": "b",
+    "british": "b",
+    "e": "e",
+    "es": "e",
+    "spanish": "e",
+    "f": "f",
+    "fr": "f",
+    "fr-fr": "f",
+    "french": "f",
+    "h": "h",
+    "hi": "h",
+    "hindi": "h",
+    "i": "i",
+    "it": "i",
+    "italian": "i",
+    "j": "j",
+    "ja": "j",
+    "japanese": "j",
+    "p": "p",
+    "pt": "p",
+    "pt-br": "p",
+    "portuguese": "p",
+    "brazilian-portuguese": "p",
+    "z": "z",
+    "zh": "z",
+    "zh-cn": "z",
+    "mandarin": "z",
+    "chinese": "z",
+}
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Generate WAV audio with local Kokoro-82M model and voices."
+    )
+    parser.add_argument(
+        "text_args",
+        nargs="*",
+        help="Text to synthesize. If omitted, uses --text, --text-file, stdin, or a short sample.",
+    )
+    parser.add_argument("-t", "--text", help="Text to synthesize.")
+    parser.add_argument("--text-file", type=Path, help="UTF-8 text file to synthesize.")
+    parser.add_argument(
+        "-v",
+        "--voice",
+        default="af_heart",
+        help="Voice name, .pt path, or comma-separated blend. Example: af_heart or af_heart,af_bella",
+    )
+    parser.add_argument(
+        "-o",
+        "--output",
+        type=Path,
+        default=Path("kokoro_sample.wav"),
+        help="Output WAV path.",
+    )
+    parser.add_argument("--speed", type=float, default=1.0, help="Speech speed multiplier.")
+    parser.add_argument(
+        "-l",
+        "--lang",
+        default="auto",
+        help="Language code or alias. Default auto-infers from the first voice letter.",
+    )
+    parser.add_argument(
+        "--device",
+        choices=["auto", "cpu", "cuda", "mps"],
+        default="auto",
+        help="Torch device to use.",
+    )
+    parser.add_argument(
+        "--split-pattern",
+        default=r"\n+",
+        help="Regex used to split text into sections before synthesis.",
+    )
+    parser.add_argument(
+        "--gap",
+        type=float,
+        default=0.12,
+        help="Seconds of silence to insert between generated chunks.",
+    )
+    parser.add_argument("--list-voices", action="store_true", help="Print local voices and exit.")
+    parser.add_argument("--verbose", action="store_true", help="Print generated chunks and phonemes.")
+    return parser.parse_args()
+
+
+def require_assets() -> None:
+    missing = [p for p in (CONFIG_FILE, MODEL_FILE, VOICE_DIR) if not p.exists()]
+    if missing:
+        formatted = "\n".join(f"  - {p}" for p in missing)
+        raise SystemExit(f"Missing Kokoro asset(s):\n{formatted}")
+
+
+def require_python_version() -> None:
+    if not ((3, 10) <= sys.version_info[:2] < (3, 13)):
+        version = ".".join(map(str, sys.version_info[:3]))
+        raise SystemExit(
+            "Kokoro's current PyPI runtime requires Python 3.10, 3.11, or 3.12.\n"
+            f"You are running Python {version}. Use Python 3.12 for this script."
+        )
+
+
+def available_voices() -> list[str]:
+    if not VOICE_DIR.exists():
+        return []
+    return sorted(path.stem for path in VOICE_DIR.glob("*.pt"))
+
+
+def print_voices() -> None:
+    voices = available_voices()
+    print(f"{len(voices)} local voices in {VOICE_DIR}:")
+    for code, language in LANG_NAMES.items():
+        group = [voice for voice in voices if voice.startswith(code)]
+        if group:
+            print(f"\n{code} - {language}")
+            print("  " + ", ".join(group))
+
+
+def resolve_voice_files(voice_arg: str) -> list[Path]:
+    voices = [part.strip() for part in voice_arg.split(",") if part.strip()]
+    if not voices:
+        raise SystemExit("No voice was provided.")
+
+    resolved: list[Path] = []
+    for voice in voices:
+        candidate = Path(voice).expanduser()
+        if candidate.suffix == ".pt":
+            if candidate.exists():
+                resolved.append(candidate.resolve())
+                continue
+            local_by_name = VOICE_DIR / candidate.name
+            if local_by_name.exists():
+                resolved.append(local_by_name)
+                continue
+
+        local = VOICE_DIR / f"{voice}.pt"
+        if local.exists():
+            resolved.append(local)
+            continue
+
+        raise SystemExit(f"Unknown voice '{voice}'. Run `python kokoro/sample.py --list-voices`.")
+
+    return resolved
+
+
+def normalize_lang(value: str) -> str:
+    key = (value or "auto").lower()
+    lang = LANG_ALIASES.get(key, key)
+    if lang != "auto" and lang not in LANG_NAMES:
+        valid = ", ".join(sorted(LANG_NAMES))
+        raise SystemExit(f"Unknown language '{value}'. Valid codes: {valid}, or auto.")
+    return lang
+
+
+def infer_lang(voice_files: list[Path], requested: str) -> str:
+    lang = normalize_lang(requested)
+    if lang != "auto":
+        return lang
+
+    inferred = {path.stem[0].lower() for path in voice_files if path.stem}
+    inferred &= set(LANG_NAMES)
+    if len(inferred) == 1:
+        return next(iter(inferred))
+    if len(inferred) > 1:
+        langs = ", ".join(sorted(inferred))
+        raise SystemExit(f"Voice blend spans languages ({langs}); pass --lang explicitly.")
+    raise SystemExit("Could not infer language from voice name; pass --lang explicitly.")
+
+
+def read_text(args: argparse.Namespace) -> str:
+    parts: list[str] = []
+    if args.text:
+        parts.append(args.text)
+    if args.text_file:
+        parts.append(args.text_file.read_text(encoding="utf-8"))
+    if args.text_args:
+        parts.append(" ".join(args.text_args))
+    if parts:
+        return "\n".join(parts)
+    if not sys.stdin.isatty():
+        return sys.stdin.read()
+    return "Kokoro is ready to generate speech with any local voice."
+
+
+def same_path(entry: str, target: Path) -> bool:
+    try:
+        return Path(entry or ".").resolve() == target
+    except OSError:
+        return False
+
+
+def import_runtime():
+    # The local asset directory is named "kokoro", so temporarily remove it
+    # and its parent from sys.path to avoid shadowing the installed package.
+    removed: list[tuple[int, str]] = []
+    for index, entry in reversed(list(enumerate(sys.path))):
+        if same_path(entry, ROOT) or same_path(entry, ROOT.parent):
+            removed.append((index, entry))
+            sys.path.pop(index)
+
+    try:
+        import numpy as np
+        import soundfile as sf
+        import torch
+        from kokoro import KModel, KPipeline
+    except Exception as exc:
+        install = (
+            "Missing Kokoro runtime dependency.\n"
+            "Install Python packages with:\n"
+            "  python -m pip install -r kokoro/requirements.txt\n\n"
+            "Use Python 3.10, 3.11, or 3.12. Python 3.13+ is too new for Kokoro's current PyPI package.\n"
+            "For Japanese/Chinese voices, requirements.txt includes the misaki extras."
+        )
+        raise RuntimeError(install) from exc
+    finally:
+        for index, entry in sorted(removed):
+            sys.path.insert(index, entry)
+
+    return np, sf, torch, KModel, KPipeline
+
+
+def select_device(torch, requested: str) -> str:
+    if requested == "cuda" and not torch.cuda.is_available():
+        raise SystemExit("CUDA was requested, but torch.cuda.is_available() is false.")
+    if requested == "mps":
+        has_mps = hasattr(torch.backends, "mps") and torch.backends.mps.is_available()
+        if not has_mps:
+            raise SystemExit("MPS was requested, but torch.backends.mps.is_available() is false.")
+        if os.environ.get("PYTORCH_ENABLE_MPS_FALLBACK") != "1":
+            raise SystemExit("Set PYTORCH_ENABLE_MPS_FALLBACK=1 before using --device mps.")
+    if requested != "auto":
+        return requested
+    if torch.cuda.is_available():
+        return "cuda"
+    has_mps = hasattr(torch.backends, "mps") and torch.backends.mps.is_available()
+    if has_mps and os.environ.get("PYTORCH_ENABLE_MPS_FALLBACK") == "1":
+        return "mps"
+    return "cpu"
+
+
+def load_voice_tensor(torch, voice_files: list[Path]):
+    packs = [torch.load(str(path), weights_only=True) for path in voice_files]
+    if len(packs) == 1:
+        return packs[0]
+    return torch.mean(torch.stack(packs), dim=0)
+
+
+def language_dependency_hint(lang: str, exc: Exception) -> RuntimeError:
+    suffix = ""
+    if lang in {"e", "f", "h", "i", "p"}:
+        suffix = "\nInstall espeak-ng and make sure it is available on PATH."
+    elif lang == "j":
+        suffix = "\nInstall Japanese support with: python -m pip install \"misaki[ja]>=0.9.4\""
+    elif lang == "z":
+        suffix = "\nInstall Chinese support with: python -m pip install \"misaki[zh]>=0.9.4\""
+    return RuntimeError(f"Failed to initialize {LANG_NAMES.get(lang, lang)} pipeline.{suffix}")
+
+
+def synthesize(args: argparse.Namespace) -> None:
+    require_assets()
+    require_python_version()
+    voice_files = resolve_voice_files(args.voice)
+    lang = infer_lang(voice_files, args.lang)
+    text = read_text(args).strip()
+    if not text:
+        raise SystemExit("No text to synthesize.")
+
+    np, sf, torch, KModel, KPipeline = import_runtime()
+    device = select_device(torch, args.device)
+    voice_tensor = load_voice_tensor(torch, voice_files)
+
+    model = KModel(repo_id=REPO_ID, config=str(CONFIG_FILE), model=str(MODEL_FILE))
+    model = model.to(device).eval()
+
+    try:
+        pipeline = KPipeline(lang_code=lang, repo_id=REPO_ID, model=model)
+    except Exception as exc:
+        raise language_dependency_hint(lang, exc) from exc
+
+    audios = []
+    generator = pipeline(
+        text,
+        voice=voice_tensor,
+        speed=args.speed,
+        split_pattern=args.split_pattern,
+    )
+
+    for index, result in enumerate(generator):
+        if args.verbose:
+            print(f"[{index}] {result.graphemes}")
+            print(f"    phonemes: {result.phonemes}")
+        audio = result.audio
+        if audio is None:
+            continue
+        if hasattr(audio, "detach"):
+            audio = audio.detach().cpu().numpy()
+        audios.append(np.asarray(audio, dtype=np.float32))
+
+    if not audios:
+        raise SystemExit("Kokoro did not generate any audio. Check the text and language.")
+
+    if len(audios) == 1 or args.gap <= 0:
+        merged = np.concatenate(audios)
+    else:
+        silence = np.zeros(max(0, int(SAMPLE_RATE * args.gap)), dtype=np.float32)
+        chunks = []
+        for index, audio in enumerate(audios):
+            if index:
+                chunks.append(silence)
+            chunks.append(audio)
+        merged = np.concatenate(chunks)
+
+    output = args.output.expanduser()
+    output.parent.mkdir(parents=True, exist_ok=True)
+    sf.write(str(output), merged, SAMPLE_RATE)
+
+    voice_names = ",".join(path.stem for path in voice_files)
+    print(f"Wrote {output} using voice={voice_names}, lang={lang}, device={device}")
+
+
+def main() -> None:
+    args = parse_args()
+    if args.list_voices:
+        require_assets()
+        print_voices()
+        return
+    try:
+        synthesize(args)
+    except RuntimeError as exc:
+        raise SystemExit(str(exc)) from exc
+
+
+if __name__ == "__main__":
+    main()

kokoro/voices/af_alloy.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6d877149dd8b348fbad12e5845b7e43d975390e9f3b68a811d1d86168bef5aa3
+size 523425

kokoro/voices/af_aoede.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c03bd1a4c3716c2d8eaa3d50022f62d5c31cfbd6e15933a00b17fefe13841cc4
+size 523425

kokoro/voices/af_bella.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8cb64e02fcc8de0327a8e13817e49c76c945ecf0052ceac97d3081480e8e48d6
+size 523425

kokoro/voices/af_heart.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0ab5709b8ffab19bfd849cd11d98f75b60af7733253ad0d67b12382a102cb4ff
+size 523425

kokoro/voices/af_jessica.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cdfdccb8cc975aa34ee6b89642963b0064237675de0e41a30ae64cc958dd4e87
+size 523435

kokoro/voices/af_kore.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8bfbc512321c3db49dff984ac675fa5ac7eaed5a96cc31104d3a9080e179d69d
+size 523420

kokoro/voices/af_nicole.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c5561808bcf5250fe8c5f5de32caf2d94f27e57e95befdb098c5c85991d4c5da
+size 523430

kokoro/voices/af_nova.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e0233676ddc21908c37a1f102f6b88a59e4e5c1bd764983616eb9eda629dbcd2
+size 523420

kokoro/voices/af_river.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e149459bd9c084416b74756b9bd3418256a8b839088abb07d463730c369dab8f
+size 523425

kokoro/voices/af_sarah.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:49bd364ea3be9eb3e9685e8f9a15448c4883112a7c0ff7ab139fa4088b08cef9
+size 523425

kokoro/voices/af_sky.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c799548aed06e0cb0d655a85a01b48e7f10484d71663f9a3045a5b9362e8512c
+size 523351

kokoro/voices/am_adam.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ced7e284aba12472891be1da3ab34db84cc05cc02b5889535796dbf2d8b0cb34
+size 523420

kokoro/voices/am_echo.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8bcfdc852bc985fb45c396c561e571ffb9183930071f962f1b50df5c97b161e8
+size 523420

kokoro/voices/am_eric.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ada66f0eefff34ec921b1d7474d7ac8bec00cd863c170f1c534916e9b8212aae
+size 523420

kokoro/voices/am_fenrir.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:98e507eca1db08230ae3b6232d59c10aec9630022d19accac4f5d12fcec3c37a
+size 523430

kokoro/voices/am_liam.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c82550757ddb31308b97f30040dda8c2d609a9e2de6135848d0a948368138518
+size 523420

kokoro/voices/am_michael.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9a443b79a4b22489a5b0ab7c651a0bcd1a30bef675c28333f06971abbd47bd37
+size 523435

kokoro/voices/am_onyx.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e8452be16cd0f6da7b4579eaf7b1e4506e92524882053d86d72b96b9a7fed584
+size 523420

kokoro/voices/am_puck.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dd1d8973f4ce4b7d8ae407c77a435f485dabc052081b80ea75c4f30b84f36223
+size 523420

kokoro/voices/am_santa.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7f2f7582fa2b1f160e90aafe6d0b442a685e773608b6667e545d743b073e97a7
+size 523425

kokoro/voices/bf_alice.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d292651b6af6c0d81705c2580dcb4463fccc0ff7b8d618a471dbb4e45655b3f3
+size 523425

kokoro/voices/bf_emma.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d0a423deabf4a52b4f49318c51742c54e21bb89bbbe9a12141e7758ddb5da701
+size 523420

kokoro/voices/bf_isabella.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cdd4c37003805104d1d08fb1e05855c8fb2c68de24ca6e71f264a30aaa59eefd
+size 523440

kokoro/voices/bf_lily.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6e09c2e481e2d53004d7e5ae7d3a325369e130a6f45c35a6002de75084be9285
+size 523420

kokoro/voices/bm_daniel.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fc3fce4e9c12ed4dbc8fa9680cfe51ee190a96444ce7c3ad647549a30823fc5d
+size 523430

kokoro/voices/bm_fable.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d44935f3135257a9064df99f007fc1342ff1aa767552b4a4fa4c3b2e6e59079c
+size 523425

kokoro/voices/bm_george.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f1bc812213dc59774769e5c80004b13eeb79bd78130b11b2d7f934542dab811b
+size 523430

kokoro/voices/bm_lewis.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b5204750dcba01029d2ac9cec17aec3b20a6d64073c579d694a23cb40effbd0e
+size 523425

kokoro/voices/ef_dora.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d9d69b0f8a2b87a345f269d89639f89dfbd1a6c9da0c498ae36dd34afcf35530
+size 523420