From e38b29ea66e38a21c1e54e8639b22a063f1a0b49 Mon Sep 17 00:00:00 2001
From: Arjun Arihant <66896303+arjun-arihant@users.noreply.github.com>
Date: Thu, 19 Feb 2026 19:24:32 +0530
Subject: [PATCH 1/3] Add WebUI and Docker support for KittenTTS

Add a kitten-themed web interface and Docker setup:

WebUI:
- FastAPI backend with /api/generate, /api/models, /api/voices endpoints
- Modern HTML/CSS/JS frontend with dark/light mode support
- Model selection (Mini, Micro, Nano, Nano INT8)
- Voice selection with 8 voice options (Bella, Jasper, Luna, Bruno, Rosie, Hugo, Kiki, Leo)
- Speed control slider (0.5x - 2.0x)
- Audio playback with WAV download
- Responsive design with subtle cat-themed styling
- Entry point script (run_webui.py) on port 7860

Docker:
- Multi-stage Dockerfile based on python:3.12-slim
- Installs espeak-ng for phonemization
- Exposes port 7860
- .dockerignore for build optimization

Documentation:
- Add WebUI section with conda and pip setup instructions
- Add Docker Usage section with build/run/stop commands
---
 .dockerignore              |  41 +++
 Dockerfile                 |  23 ++
 README.md                  |  83 +++++-
 run_webui.py               |  24 ++
 webui/__init__.py          |   3 +
 webui/server.py            | 235 ++++++++++++++++
 webui/static/app.js        | 158 +++++++++++
 webui/static/favicon.svg   |  16 ++
 webui/static/style.css     | 532 +++++++++++++++++++++++++++++++++++++
 webui/templates/index.html | 102 +++++++
 10 files changed, 1216 insertions(+), 1 deletion(-)
 create mode 100644 .dockerignore
 create mode 100644 Dockerfile
 create mode 100644 run_webui.py
 create mode 100644 webui/__init__.py
 create mode 100644 webui/server.py
 create mode 100644 webui/static/app.js
 create mode 100644 webui/static/favicon.svg
 create mode 100644 webui/static/style.css
 create mode 100644 webui/templates/index.html

diff --git a/.dockerignore b/.dockerignore
new file mode 100644
index 0000000..85eacda
--- /dev/null
+++ b/.dockerignore
@@ -0,0 +1,41 @@
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+
+.git/
+.gitignore
+.github/
+
+venv/
+.venv/
+env/
+.env
+
+*.egg-info/
+dist/
+build/
+.eggs/
+
+*.wav
+*.mp3
+*.ogg
+
+models/
+cache/
+.huggingface/
+
+.idea/
+.vscode/
+*.swp
+*.swo
+
+.pytest_cache/
+.mypy_cache/
+.coverage
+htmlcov/
+
+.DS_Store
+Thumbs.db
+
+*.log
diff --git a/Dockerfile b/Dockerfile
new file mode 100644
index 0000000..81e90b0
--- /dev/null
+++ b/Dockerfile
@@ -0,0 +1,23 @@
+FROM python:3.12-slim
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    espeak-ng \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+RUN pip install --no-cache-dir \
+    fastapi>=0.104.0 \
+    uvicorn>=0.24.0 \
+    python-multipart>=0.0.6
+
+COPY . .
+
+EXPOSE 7860
+
+ENV PYTHONUNBUFFERED=1
+
+CMD ["python", "run_webui.py"]
diff --git a/README.md b/README.md
index a3e3955..2f4739b 100644
--- a/README.md
+++ b/README.md
@@ -80,10 +80,91 @@ Works literally everywhere. Needs python3.12. We recommend using conda.
 
 
 
+## WebUI
+
+KittenTTS includes a cute kitten-themed web interface for easy text-to-speech generation.
+
+### Quick Start with Conda (Recommended)
+
+```bash
+# Create and activate a conda environment
+conda create -n kittentts python=3.12 -y
+conda activate kittentts
+
+# Install KittenTTS
+pip install https://github.com/KittenML/KittenTTS/releases/download/0.8/kittentts-0.8.0-py3-none-any.whl
+
+# Install additional WebUI dependencies
+pip install fastapi uvicorn python-multipart
+
+# Run the WebUI
+python run_webui.py
+```
+
+### Quick Start with pip
+
+```bash
+# Install additional dependencies
+pip install fastapi uvicorn python-multipart
+
+# Run the WebUI
+python run_webui.py
+```
+
+Open your browser and navigate to `http://localhost:7860`
+
+### Features
+
+- **4 Models**: Choose from Mini, Micro, Nano, and Nano INT8 variants
+- **8 Voices**: Select from Bella, Jasper, Luna, Bruno, Rosie, Hugo, Kiki, and Leo
+- **Speed Control**: Adjust speech speed from 0.5x to 2.0x
+- **Dark/Light Mode**: Toggle between themes with automatic system detection
+- **Audio Download**: Save generated audio as WAV files
+
+### Command Line Options
+
+```bash
+python run_webui.py --host 0.0.0.0 --port 7860
+```
+
+## Docker Usage
+
+Run KittenTTS WebUI in a containerized environment.
+
+### Build the Image
+
+```bash
+docker build -t kittentts-webui .
+```
+
+### Run the Container
+
+```bash
+docker run -d -p 7860:7860 -v ~/.cache/huggingface:/root/.cache/huggingface kittentts-webui
+```
+
+The `-v` flag mounts the Hugging Face cache directory to persist downloaded models between container restarts.
+
+### Access the WebUI
+
+Open `http://localhost:7860` in your browser.
+
+### Stop the Container
+
+```bash
+# List running containers to find the container ID
+docker ps
+
+# Stop the container
+docker stop <container_id>
+```
+
+Or if you ran without `-d` (detached mode), press `Ctrl+C` in the terminal to stop.
+
 ## Checklist 
 
 - [x] Release a preview model
 - [ ] Release the fully trained model weights
 - [ ] Release mobile SDK 
-- [ ] Release web version 
+- [ ] Release web version
 
diff --git a/run_webui.py b/run_webui.py
new file mode 100644
index 0000000..39c2936
--- /dev/null
+++ b/run_webui.py
@@ -0,0 +1,24 @@
+#!/usr/bin/env python3
+"""Entry point for KittenTTS WebUI."""
+
+import argparse
+from webui.server import run_server
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="KittenTTS WebUI - A cute kitten-themed text-to-speech interface"
+    )
+    parser.add_argument(
+        "--host", type=str, default="0.0.0.0", help="Host to bind to (default: 0.0.0.0)"
+    )
+    parser.add_argument(
+        "--port", type=int, default=7860, help="Port to bind to (default: 7860)"
+    )
+    args = parser.parse_args()
+
+    run_server(host=args.host, port=args.port)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/webui/__init__.py b/webui/__init__.py
new file mode 100644
index 0000000..bf9fc8b
--- /dev/null
+++ b/webui/__init__.py
@@ -0,0 +1,3 @@
+from .server import create_app, run_server
+
+__all__ = ["create_app", "run_server"]
diff --git a/webui/server.py b/webui/server.py
new file mode 100644
index 0000000..0533f79
--- /dev/null
+++ b/webui/server.py
@@ -0,0 +1,235 @@
+import io
+import base64
+import tempfile
+from typing import Optional
+from pathlib import Path
+
+import numpy as np
+import soundfile as sf
+from fastapi import FastAPI, HTTPException, BackgroundTasks
+from fastapi.responses import HTMLResponse, JSONResponse, FileResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+
+MODELS = {
+    "kitten-tts-mini": "KittenML/kitten-tts-mini-0.8",
+    "kitten-tts-micro": "KittenML/kitten-tts-micro-0.8",
+    "kitten-tts-nano": "KittenML/kitten-tts-nano-0.8-fp32",
+    "kitten-tts-nano-int8": "KittenML/kitten-tts-nano-0.8-int8",
+}
+
+VOICE_ALIASES = {
+    "Bella": "expr-voice-2-f",
+    "Jasper": "expr-voice-2-m",
+    "Luna": "expr-voice-3-f",
+    "Bruno": "expr-voice-3-m",
+    "Rosie": "expr-voice-4-f",
+    "Hugo": "expr-voice-4-m",
+    "Kiki": "expr-voice-5-f",
+    "Leo": "expr-voice-5-m",
+}
+
+VOICES = [
+    {
+        "id": "Bella",
+        "name": "Bella",
+        "gender": "female",
+        "description": "Warm & gentle",
+    },
+    {
+        "id": "Jasper",
+        "name": "Jasper",
+        "gender": "male",
+        "description": "Clear & professional",
+    },
+    {"id": "Luna", "name": "Luna", "gender": "female", "description": "Soft & melodic"},
+    {
+        "id": "Bruno",
+        "name": "Bruno",
+        "gender": "male",
+        "description": "Deep & resonant",
+    },
+    {
+        "id": "Rosie",
+        "name": "Rosie",
+        "gender": "female",
+        "description": "Bright & cheerful",
+    },
+    {
+        "id": "Hugo",
+        "name": "Hugo",
+        "gender": "male",
+        "description": "Confident & steady",
+    },
+    {
+        "id": "Kiki",
+        "name": "Kiki",
+        "gender": "female",
+        "description": "Playful & energetic",
+    },
+    {"id": "Leo", "name": "Leo", "gender": "male", "description": "Friendly & warm"},
+]
+
+MODEL_INFO = [
+    {
+        "id": "kitten-tts-mini",
+        "name": "Mini",
+        "params": "80M",
+        "size": "80MB",
+        "description": "Highest quality, larger model",
+    },
+    {
+        "id": "kitten-tts-micro",
+        "name": "Micro",
+        "params": "40M",
+        "size": "41MB",
+        "description": "Balanced quality & speed",
+    },
+    {
+        "id": "kitten-tts-nano",
+        "name": "Nano",
+        "params": "15M",
+        "size": "56MB",
+        "description": "Lightweight & fast",
+    },
+    {
+        "id": "kitten-tts-nano-int8",
+        "name": "Nano (INT8)",
+        "params": "15M",
+        "size": "19MB",
+        "description": "Smallest, quantized",
+    },
+]
+
+loaded_models = {}
+
+
+class GenerateRequest(BaseModel):
+    text: str
+    model: str = "kitten-tts-mini"
+    voice: str = "Bella"
+    speed: float = 1.0
+
+
+class GenerateResponse(BaseModel):
+    audio_base64: str
+    sample_rate: int
+    duration: float
+
+
+def get_model(model_id: str):
+    if model_id not in MODELS:
+        raise ValueError(f"Unknown model: {model_id}")
+
+    if model_id not in loaded_models:
+        from kittentts import KittenTTS
+
+        repo_id = MODELS[model_id]
+        loaded_models[model_id] = KittenTTS(repo_id)
+
+    return loaded_models[model_id]
+
+
+def create_app() -> FastAPI:
+    app = FastAPI(
+        title="KittenTTS WebUI",
+        description="A cute kitten-themed text-to-speech web interface",
+        version="1.0.0",
+    )
+
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    static_dir = Path(__file__).parent / "static"
+    if static_dir.exists():
+        app.mount("/static", StaticFiles(directory=str(static_dir)), name="static")
+
+    @app.get("/", response_class=HTMLResponse)
+    async def index():
+        template_path = Path(__file__).parent / "templates" / "index.html"
+        if template_path.exists():
+            return HTMLResponse(content=template_path.read_text(encoding="utf-8"))
+        raise HTTPException(status_code=404, detail="Template not found")
+
+    @app.get("/api/models")
+    async def get_models():
+        return {"models": MODEL_INFO}
+
+    @app.get("/api/voices")
+    async def get_voices():
+        return {"voices": VOICES}
+
+    @app.get("/api/health")
+    async def health_check():
+        return {"status": "healthy", "loaded_models": list(loaded_models.keys())}
+
+    @app.post("/api/generate", response_model=GenerateResponse)
+    async def generate_audio(request: GenerateRequest):
+        if not request.text.strip():
+            raise HTTPException(status_code=400, detail="Text cannot be empty")
+
+        if request.speed < 0.25 or request.speed > 3.0:
+            raise HTTPException(
+                status_code=400, detail="Speed must be between 0.25 and 3.0"
+            )
+
+        try:
+            model = get_model(request.model)
+
+            voice_id = VOICE_ALIASES.get(request.voice, request.voice)
+
+            audio = model.generate(
+                text=request.text, voice=voice_id, speed=request.speed
+            )
+
+            if isinstance(audio, np.ndarray):
+                audio_array = audio
+            else:
+                audio_array = np.array(audio)
+
+            if audio_array.ndim > 1:
+                audio_array = audio_array.squeeze()
+
+            sample_rate = 24000
+            duration = len(audio_array) / sample_rate
+
+            buffer = io.BytesIO()
+            sf.write(buffer, audio_array, sample_rate, format="WAV")
+            buffer.seek(0)
+            audio_base64 = base64.b64encode(buffer.read()).decode("utf-8")
+
+            return GenerateResponse(
+                audio_base64=audio_base64,
+                sample_rate=sample_rate,
+                duration=round(duration, 2),
+            )
+
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=str(e))
+
+    @app.get("/favicon.ico")
+    async def favicon():
+        return FileResponse(
+            Path(__file__).parent / "static" / "favicon.svg", media_type="image/svg+xml"
+        )
+
+    return app
+
+
+def run_server(host: str = "0.0.0.0", port: int = 7860):
+    import uvicorn
+
+    app = create_app()
+    print(f"\n🐱 KittenTTS WebUI starting at http://{host}:{port}")
+    print("Press Ctrl+C to stop\n")
+    uvicorn.run(app, host=host, port=port)
+
+
+if __name__ == "__main__":
+    run_server()
diff --git a/webui/static/app.js b/webui/static/app.js
new file mode 100644
index 0000000..a510948
--- /dev/null
+++ b/webui/static/app.js
@@ -0,0 +1,158 @@
+const models = [
+    { id: 'kitten-tts-mini', name: 'Mini', params: '80M', size: '80MB', description: 'Highest quality, larger model' },
+    { id: 'kitten-tts-micro', name: 'Micro', params: '40M', size: '41MB', description: 'Balanced quality & speed' },
+    { id: 'kitten-tts-nano', name: 'Nano', params: '15M', size: '56MB', description: 'Lightweight & fast' },
+    { id: 'kitten-tts-nano-int8', name: 'Nano (INT8)', params: '15M', size: '19MB', description: 'Smallest, quantized' }
+];
+
+const voices = [
+    { id: 'Bella', name: 'Bella', gender: 'female', description: 'Warm & gentle' },
+    { id: 'Jasper', name: 'Jasper', gender: 'male', description: 'Clear & professional' },
+    { id: 'Luna', name: 'Luna', gender: 'female', description: 'Soft & melodic' },
+    { id: 'Bruno', name: 'Bruno', gender: 'male', description: 'Deep & resonant' },
+    { id: 'Rosie', name: 'Rosie', gender: 'female', description: 'Bright & cheerful' },
+    { id: 'Hugo', name: 'Hugo', gender: 'male', description: 'Confident & steady' },
+    { id: 'Kiki', name: 'Kiki', gender: 'female', description: 'Playful & energetic' },
+    { id: 'Leo', name: 'Leo', gender: 'male', description: 'Friendly & warm' }
+];
+
+const pawIcon = `<svg width="20" height="20" viewBox="0 0 24 24" fill="currentColor"><path d="M12 10c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm-6 0c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm12 0c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm-6 6c-2.2 0-4 1.8-4 4h8c0-2.2-1.8-4-4-4zm-6-10c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm12 0c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2z"/></svg>`;
+
+function init() {
+    initializeTheme();
+    populateModels();
+    populateVoices();
+    setupEventListeners();
+}
+
+function initializeTheme() {
+    const savedTheme = localStorage.getItem('kitten-tts-theme');
+    const prefersDark = window.matchMedia('(prefers-color-scheme: dark)').matches;
+    const theme = savedTheme || (prefersDark ? 'dark' : 'light');
+    setTheme(theme);
+}
+
+function setTheme(theme) {
+    document.documentElement.setAttribute('data-theme', theme);
+    localStorage.setItem('kitten-tts-theme', theme);
+    updateThemeIcon(theme);
+}
+
+function updateThemeIcon(theme) {
+    const btn = document.getElementById('themeToggle');
+    btn.innerHTML = theme === 'dark' ? '☀️' : '🌙';
+    btn.setAttribute('aria-label', theme === 'dark' ? 'Switch to light mode' : 'Switch to dark mode');
+}
+
+function toggleTheme() {
+    const current = document.documentElement.getAttribute('data-theme');
+    setTheme(current === 'dark' ? 'light' : 'dark');
+}
+
+function populateModels() {
+    const select = document.getElementById('modelSelect');
+    select.innerHTML = models.map(m => 
+        `<option value="${m.id}">${m.name} (${m.size}) - ${m.description}</option>`
+    ).join('');
+}
+
+function populateVoices() {
+    const select = document.getElementById('voiceSelect');
+    select.innerHTML = voices.map(v => 
+        `<option value="${v.id}">${v.name} (${v.gender === 'female' ? '♀' : '♂'}) - ${v.description}</option>`
+    ).join('');
+}
+
+function setupEventListeners() {
+    document.getElementById('themeToggle').addEventListener('click', toggleTheme);
+    document.getElementById('speedSlider').addEventListener('input', updateSpeedDisplay);
+    document.getElementById('generateBtn').addEventListener('click', handleGenerate);
+}
+
+function updateSpeedDisplay() {
+    const slider = document.getElementById('speedSlider');
+    document.getElementById('speedValue').textContent = `${slider.value}x`;
+}
+
+function showLoading(show) {
+    const btn = document.getElementById('generateBtn');
+    const btnText = document.getElementById('btnText');
+    const spinner = document.getElementById('btnSpinner');
+    
+    btn.disabled = show;
+    btnText.style.display = show ? 'none' : 'inline';
+    spinner.style.display = show ? 'inline-block' : 'none';
+}
+
+function showError(message) {
+    const el = document.getElementById('errorMessage');
+    el.textContent = message;
+    el.classList.add('visible');
+    setTimeout(() => el.classList.remove('visible'), 5000);
+}
+
+function showOutput(audioBase64, duration) {
+    const section = document.getElementById('outputSection');
+    const audio = document.getElementById('audioPlayer');
+    const durationEl = document.getElementById('audioDuration');
+    const downloadBtn = document.getElementById('downloadBtn');
+    
+    audio.src = `data:audio/wav;base64,${audioBase64}`;
+    durationEl.textContent = `Duration: ${duration}s`;
+    
+    const blob = base64ToBlob(audioBase64, 'audio/wav');
+    const url = URL.createObjectURL(blob);
+    downloadBtn.href = url;
+    downloadBtn.download = `kitten-tts-${Date.now()}.wav`;
+    
+    section.classList.add('visible');
+    section.scrollIntoView({ behavior: 'smooth', block: 'nearest' });
+}
+
+function base64ToBlob(base64, mimeType) {
+    const byteChars = atob(base64);
+    const byteNumbers = new Array(byteChars.length);
+    for (let i = 0; i < byteChars.length; i++) {
+        byteNumbers[i] = byteChars.charCodeAt(i);
+    }
+    const byteArray = new Uint8Array(byteNumbers);
+    return new Blob([byteArray], { type: mimeType });
+}
+
+async function handleGenerate() {
+    const text = document.getElementById('textInput').value.trim();
+    const model = document.getElementById('modelSelect').value;
+    const voice = document.getElementById('voiceSelect').value;
+    const speed = parseFloat(document.getElementById('speedSlider').value);
+    
+    if (!text) {
+        showError('Please enter some text to generate speech.');
+        return;
+    }
+    
+    showLoading(true);
+    document.getElementById('errorMessage').classList.remove('visible');
+    
+    try {
+        const response = await fetch('/api/generate', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ text, model, voice, speed })
+        });
+        
+        const data = await response.json();
+        
+        if (!response.ok) {
+            throw new Error(data.detail || 'Generation failed');
+        }
+        
+        showOutput(data.audio_base64, data.duration);
+    } catch (error) {
+        showError(error.message || 'An error occurred during generation.');
+        console.error('Generation error:', error);
+    } finally {
+        showLoading(false);
+    }
+}
+
+document.addEventListener('DOMContentLoaded', init);
diff --git a/webui/static/favicon.svg b/webui/static/favicon.svg
new file mode 100644
index 0000000..8b0284b
--- /dev/null
+++ b/webui/static/favicon.svg
@@ -0,0 +1,16 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64">
+  <defs>
+    <linearGradient id="grad" x1="0%" y1="0%" x2="100%" y2="100%">
+      <stop offset="0%" style="stop-color:#e8a87c;stop-opacity:1" />
+      <stop offset="100%" style="stop-color:#d4956a;stop-opacity:1" />
+    </linearGradient>
+  </defs>
+  <circle cx="32" cy="32" r="30" fill="url(#grad)"/>
+  <g fill="#fff">
+    <ellipse cx="22" cy="22" rx="6" ry="8"/>
+    <ellipse cx="42" cy="22" rx="6" ry="8"/>
+    <ellipse cx="16" cy="36" rx="5" ry="7"/>
+    <ellipse cx="48" cy="36" rx="5" ry="7"/>
+    <ellipse cx="32" cy="42" rx="10" ry="8"/>
+  </g>
+</svg>
diff --git a/webui/static/style.css b/webui/static/style.css
new file mode 100644
index 0000000..0ae504d
--- /dev/null
+++ b/webui/static/style.css
@@ -0,0 +1,532 @@
+:root {
+    --bg-primary: #faf8f5;
+    --bg-secondary: #ffffff;
+    --bg-tertiary: #f5f0e8;
+    --text-primary: #2d2a26;
+    --text-secondary: #6b6560;
+    --text-muted: #9a9590;
+    --accent-primary: #e8a87c;
+    --accent-secondary: #d4956a;
+    --accent-light: #f5d5c0;
+    --border-color: #e8e0d5;
+    --shadow-sm: 0 2px 4px rgba(45, 42, 38, 0.05);
+    --shadow-md: 0 4px 12px rgba(45, 42, 38, 0.08);
+    --shadow-lg: 0 8px 24px rgba(45, 42, 38, 0.12);
+    --radius-sm: 8px;
+    --radius-md: 12px;
+    --radius-lg: 20px;
+    --transition: 0.2s ease;
+}
+
+[data-theme="dark"] {
+    --bg-primary: #1a1815;
+    --bg-secondary: #252220;
+    --bg-tertiary: #2d2a26;
+    --text-primary: #f5f0e8;
+    --text-secondary: #b5ada0;
+    --text-muted: #7a7570;
+    --accent-primary: #e8a87c;
+    --accent-secondary: #f0b88c;
+    --accent-light: #3d3530;
+    --border-color: #3d3835;
+    --shadow-sm: 0 2px 4px rgba(0, 0, 0, 0.2);
+    --shadow-md: 0 4px 12px rgba(0, 0, 0, 0.25);
+    --shadow-lg: 0 8px 24px rgba(0, 0, 0, 0.35);
+}
+
+* {
+    margin: 0;
+    padding: 0;
+    box-sizing: border-box;
+}
+
+html {
+    font-size: 16px;
+}
+
+body {
+    font-family: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+    background: var(--bg-primary);
+    color: var(--text-primary);
+    min-height: 100vh;
+    line-height: 1.5;
+    transition: background var(--transition), color var(--transition);
+}
+
+.container {
+    max-width: 800px;
+    margin: 0 auto;
+    padding: 2rem 1.5rem;
+}
+
+header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    margin-bottom: 2.5rem;
+    padding-bottom: 1.5rem;
+    border-bottom: 1px solid var(--border-color);
+}
+
+.logo {
+    display: flex;
+    align-items: center;
+    gap: 0.75rem;
+}
+
+.logo-icon {
+    width: 48px;
+    height: 48px;
+    background: linear-gradient(135deg, var(--accent-primary), var(--accent-secondary));
+    border-radius: var(--radius-md);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-size: 1.5rem;
+    box-shadow: var(--shadow-md);
+}
+
+.logo-text h1 {
+    font-size: 1.5rem;
+    font-weight: 700;
+    letter-spacing: -0.02em;
+    background: linear-gradient(135deg, var(--accent-primary), var(--accent-secondary));
+    -webkit-background-clip: text;
+    -webkit-text-fill-color: transparent;
+    background-clip: text;
+}
+
+.logo-text span {
+    font-size: 0.75rem;
+    color: var(--text-muted);
+    font-weight: 500;
+    letter-spacing: 0.05em;
+    text-transform: uppercase;
+}
+
+.theme-toggle {
+    width: 44px;
+    height: 44px;
+    border: 1px solid var(--border-color);
+    border-radius: var(--radius-md);
+    background: var(--bg-secondary);
+    cursor: pointer;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-size: 1.25rem;
+    transition: all var(--transition);
+    color: var(--text-secondary);
+}
+
+.theme-toggle:hover {
+    background: var(--bg-tertiary);
+    border-color: var(--accent-primary);
+    color: var(--accent-primary);
+}
+
+main {
+    display: flex;
+    flex-direction: column;
+    gap: 1.5rem;
+}
+
+.card {
+    background: var(--bg-secondary);
+    border: 1px solid var(--border-color);
+    border-radius: var(--radius-lg);
+    padding: 1.5rem;
+    box-shadow: var(--shadow-sm);
+    transition: all var(--transition);
+}
+
+.card:hover {
+    box-shadow: var(--shadow-md);
+}
+
+.card-header {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    margin-bottom: 1rem;
+    padding-bottom: 0.75rem;
+    border-bottom: 1px solid var(--border-color);
+}
+
+.card-header h2 {
+    font-size: 0.875rem;
+    font-weight: 600;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+    color: var(--text-secondary);
+}
+
+.card-header::before {
+    content: "";
+    width: 4px;
+    height: 16px;
+    background: linear-gradient(180deg, var(--accent-primary), var(--accent-secondary));
+    border-radius: 2px;
+}
+
+.form-group {
+    margin-bottom: 1.25rem;
+}
+
+.form-group:last-child {
+    margin-bottom: 0;
+}
+
+label {
+    display: block;
+    font-size: 0.8125rem;
+    font-weight: 500;
+    color: var(--text-secondary);
+    margin-bottom: 0.5rem;
+}
+
+select, input[type="range"] {
+    width: 100%;
+}
+
+select {
+    appearance: none;
+    background: var(--bg-tertiary);
+    border: 1px solid var(--border-color);
+    border-radius: var(--radius-sm);
+    padding: 0.75rem 2.5rem 0.75rem 1rem;
+    font-size: 0.9375rem;
+    font-weight: 500;
+    color: var(--text-primary);
+    cursor: pointer;
+    background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='16' height='16' viewBox='0 0 24 24' fill='none' stroke='%236b6560' stroke-width='2' stroke-linecap='round' stroke-linejoin='round'%3E%3Cpath d='m6 9 6 6 6-6'/%3E%3C/svg%3E");
+    background-repeat: no-repeat;
+    background-position: right 0.75rem center;
+    transition: all var(--transition);
+}
+
+select:hover {
+    border-color: var(--accent-primary);
+}
+
+select:focus {
+    outline: none;
+    border-color: var(--accent-primary);
+    box-shadow: 0 0 0 3px var(--accent-light);
+}
+
+textarea {
+    width: 100%;
+    min-height: 150px;
+    background: var(--bg-tertiary);
+    border: 1px solid var(--border-color);
+    border-radius: var(--radius-sm);
+    padding: 1rem;
+    font-size: 0.9375rem;
+    font-family: inherit;
+    color: var(--text-primary);
+    resize: vertical;
+    transition: all var(--transition);
+    line-height: 1.6;
+}
+
+textarea::placeholder {
+    color: var(--text-muted);
+}
+
+textarea:hover {
+    border-color: var(--accent-primary);
+}
+
+textarea:focus {
+    outline: none;
+    border-color: var(--accent-primary);
+    box-shadow: 0 0 0 3px var(--accent-light);
+}
+
+.settings-row {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+    gap: 1.25rem;
+}
+
+.speed-container {
+    display: flex;
+    flex-direction: column;
+    gap: 0.5rem;
+}
+
+.speed-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+}
+
+.speed-value {
+    font-size: 0.875rem;
+    font-weight: 600;
+    color: var(--accent-primary);
+    background: var(--accent-light);
+    padding: 0.25rem 0.75rem;
+    border-radius: var(--radius-sm);
+}
+
+input[type="range"] {
+    -webkit-appearance: none;
+    appearance: none;
+    height: 6px;
+    background: var(--bg-tertiary);
+    border-radius: 3px;
+    cursor: pointer;
+}
+
+input[type="range"]::-webkit-slider-thumb {
+    -webkit-appearance: none;
+    appearance: none;
+    width: 20px;
+    height: 20px;
+    background: linear-gradient(135deg, var(--accent-primary), var(--accent-secondary));
+    border-radius: 50%;
+    cursor: pointer;
+    box-shadow: var(--shadow-sm);
+    transition: transform var(--transition);
+}
+
+input[type="range"]::-webkit-slider-thumb:hover {
+    transform: scale(1.1);
+}
+
+input[type="range"]::-moz-range-thumb {
+    width: 20px;
+    height: 20px;
+    background: linear-gradient(135deg, var(--accent-primary), var(--accent-secondary));
+    border-radius: 50%;
+    cursor: pointer;
+    border: none;
+    box-shadow: var(--shadow-sm);
+}
+
+.voice-select option {
+    padding: 0.5rem;
+}
+
+.generate-btn {
+    width: 100%;
+    padding: 1rem 2rem;
+    background: linear-gradient(135deg, var(--accent-primary), var(--accent-secondary));
+    border: none;
+    border-radius: var(--radius-md);
+    font-size: 1rem;
+    font-weight: 600;
+    color: white;
+    cursor: pointer;
+    transition: all var(--transition);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    gap: 0.5rem;
+    box-shadow: var(--shadow-md);
+}
+
+.generate-btn:hover:not(:disabled) {
+    transform: translateY(-2px);
+    box-shadow: var(--shadow-lg);
+}
+
+.generate-btn:active:not(:disabled) {
+    transform: translateY(0);
+}
+
+.generate-btn:disabled {
+    opacity: 0.7;
+    cursor: not-allowed;
+}
+
+.generate-btn .spinner {
+    width: 20px;
+    height: 20px;
+    border: 2px solid rgba(255, 255, 255, 0.3);
+    border-top-color: white;
+    border-radius: 50%;
+    animation: spin 0.8s linear infinite;
+}
+
+@keyframes spin {
+    to { transform: rotate(360deg); }
+}
+
+.output-section {
+    display: none;
+}
+
+.output-section.visible {
+    display: block;
+    animation: fadeIn 0.3s ease;
+}
+
+@keyframes fadeIn {
+    from {
+        opacity: 0;
+        transform: translateY(10px);
+    }
+    to {
+        opacity: 1;
+        transform: translateY(0);
+    }
+}
+
+.audio-player {
+    background: var(--bg-tertiary);
+    border-radius: var(--radius-md);
+    padding: 1rem;
+    margin-bottom: 1rem;
+}
+
+.audio-player audio {
+    width: 100%;
+    height: 48px;
+    border-radius: var(--radius-sm);
+}
+
+.audio-info {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-top: 0.75rem;
+    font-size: 0.8125rem;
+    color: var(--text-muted);
+}
+
+.download-btn {
+    display: inline-flex;
+    align-items: center;
+    gap: 0.375rem;
+    padding: 0.5rem 1rem;
+    background: var(--bg-secondary);
+    border: 1px solid var(--border-color);
+    border-radius: var(--radius-sm);
+    font-size: 0.8125rem;
+    font-weight: 500;
+    color: var(--text-secondary);
+    cursor: pointer;
+    text-decoration: none;
+    transition: all var(--transition);
+}
+
+.download-btn:hover {
+    background: var(--accent-light);
+    border-color: var(--accent-primary);
+    color: var(--accent-primary);
+}
+
+.error-message {
+    background: #fee2e2;
+    border: 1px solid #fecaca;
+    border-radius: var(--radius-md);
+    padding: 1rem;
+    color: #dc2626;
+    font-size: 0.875rem;
+    margin-bottom: 1rem;
+    display: none;
+}
+
+[data-theme="dark"] .error-message {
+    background: #3f1f1f;
+    border-color: #5c2626;
+    color: #fca5a5;
+}
+
+.error-message.visible {
+    display: block;
+}
+
+footer {
+    text-align: center;
+    margin-top: 2.5rem;
+    padding-top: 1.5rem;
+    border-top: 1px solid var(--border-color);
+    color: var(--text-muted);
+    font-size: 0.8125rem;
+}
+
+footer a {
+    color: var(--accent-primary);
+    text-decoration: none;
+    font-weight: 500;
+}
+
+footer a:hover {
+    text-decoration: underline;
+}
+
+.paw-decoration {
+    display: flex;
+    justify-content: center;
+    gap: 1rem;
+    margin: 1.5rem 0;
+    opacity: 0.15;
+}
+
+.paw-decoration span {
+    font-size: 1.5rem;
+}
+
+.voice-description {
+    font-size: 0.75rem;
+    color: var(--text-muted);
+    margin-top: 0.25rem;
+}
+
+.model-info {
+    font-size: 0.75rem;
+    color: var(--text-muted);
+    margin-top: 0.25rem;
+}
+
+@media (max-width: 640px) {
+    .container {
+        padding: 1.5rem 1rem;
+    }
+    
+    header {
+        flex-direction: column;
+        align-items: flex-start;
+        gap: 1rem;
+    }
+    
+    .logo-icon {
+        width: 40px;
+        height: 40px;
+        font-size: 1.25rem;
+    }
+    
+    .logo-text h1 {
+        font-size: 1.25rem;
+    }
+    
+    .theme-toggle {
+        position: absolute;
+        top: 1.5rem;
+        right: 1rem;
+    }
+    
+    header {
+        position: relative;
+        padding-right: 3.5rem;
+    }
+    
+    .settings-row {
+        grid-template-columns: 1fr;
+    }
+    
+    textarea {
+        min-height: 120px;
+    }
+}
+
+@media (prefers-reduced-motion: reduce) {
+    * {
+        animation: none !important;
+        transition-duration: 0.01ms !important;
+    }
+}
diff --git a/webui/templates/index.html b/webui/templates/index.html
new file mode 100644
index 0000000..18d477a
--- /dev/null
+++ b/webui/templates/index.html
@@ -0,0 +1,102 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <meta name="description" content="KittenTTS - A cute kitten-themed text-to-speech web interface">
+    <title>KittenTTS WebUI</title>
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap" rel="stylesheet">
+    <link rel="stylesheet" href="/static/style.css">
+    <link rel="icon" type="image/svg+xml" href="/static/favicon.svg">
+</head>
+<body>
+    <div class="container">
+        <header>
+            <div class="logo">
+                <div class="logo-icon">🐱</div>
+                <div class="logo-text">
+                    <h1>KittenTTS</h1>
+                    <span>Text to Speech</span>
+                </div>
+            </div>
+            <button id="themeToggle" class="theme-toggle" aria-label="Toggle theme">
+                🌙
+            </button>
+        </header>
+
+        <main>
+            <div class="card">
+                <div class="card-header">
+                    <h2>Settings</h2>
+                </div>
+                <div class="settings-row">
+                    <div class="form-group">
+                        <label for="modelSelect">Model</label>
+                        <select id="modelSelect" class="model-select"></select>
+                    </div>
+                    <div class="form-group">
+                        <label for="voiceSelect">Voice</label>
+                        <select id="voiceSelect" class="voice-select"></select>
+                    </div>
+                </div>
+                <div class="form-group">
+                    <div class="speed-container">
+                        <div class="speed-header">
+                            <label for="speedSlider">Speed</label>
+                            <span id="speedValue" class="speed-value">1.0x</span>
+                        </div>
+                        <input type="range" id="speedSlider" min="0.5" max="2.0" step="0.1" value="1.0">
+                    </div>
+                </div>
+            </div>
+
+            <div class="card">
+                <div class="card-header">
+                    <h2>Text Input</h2>
+                </div>
+                <div class="form-group">
+                    <textarea id="textInput" placeholder="Enter your text here... KittenTTS will transform it into natural-sounding speech. Try something like: 'Hello! I am KittenTTS, a lightweight text-to-speech model that runs entirely on your CPU.'"></textarea>
+                </div>
+                <button id="generateBtn" class="generate-btn">
+                    <span id="btnText">🔊 Generate Speech</span>
+                    <span id="btnSpinner" class="spinner" style="display: none;"></span>
+                </button>
+            </div>
+
+            <div id="errorMessage" class="error-message"></div>
+
+            <div id="outputSection" class="card output-section">
+                <div class="card-header">
+                    <h2>Output</h2>
+                </div>
+                <div class="audio-player">
+                    <audio id="audioPlayer" controls></audio>
+                    <div class="audio-info">
+                        <span id="audioDuration">Duration: 0s</span>
+                        <a id="downloadBtn" class="download-btn" href="#" download>
+                            ⬇ Download WAV
+                        </a>
+                    </div>
+                </div>
+            </div>
+
+            <div class="paw-decoration">
+                <span>🐾</span>
+                <span>🐾</span>
+                <span>🐾</span>
+            </div>
+        </main>
+
+        <footer>
+            <p>
+                <a href="https://github.com/KittenML/KittenTTS" target="_blank" rel="noopener">KittenTTS</a> 
+                by <a href="https://github.com/KittenML" target="_blank" rel="noopener">KittenML</a>
+            </p>
+        </footer>
+    </div>
+
+    <script src="/static/app.js"></script>
+</body>
+</html>

From dfa9bc2ef598db4d796c2985d0ef18b0696c3f5c Mon Sep 17 00:00:00 2001
From: Arjun Arihant <66896303+arjun-arihant@users.noreply.github.com>
Date: Fri, 20 Feb 2026 01:30:11 +0530
Subject: [PATCH 2/3] improved webui, added a debugging stat panel

---
 AGENTS.md                  | 225 +++++++++
 AUDIO_QUALITY.md           | 202 ++++++++
 README.md                  |  36 +-
 check_environment.py       | 173 +++++++
 kittentts/__index__.py     |   3 -
 kittentts/onnx_model.py    | 118 ++++-
 pyproject.toml             |  16 +-
 requirements.txt           |  26 +-
 run_webui.py               |   2 +-
 test_tts.py                | 158 +++++++
 webui/server.py            | 200 +++++++-
 webui/static/app.js        | 341 ++++++++++++--
 webui/static/favicon.svg   |  51 +-
 webui/static/icon.png      | Bin 0 -> 59185 bytes
 webui/static/style.css     | 932 +++++++++++++++++++++++++++++--------
 webui/templates/index.html | 142 +++++-
 16 files changed, 2315 insertions(+), 310 deletions(-)
 create mode 100644 AGENTS.md
 create mode 100644 AUDIO_QUALITY.md
 create mode 100644 check_environment.py
 delete mode 100644 kittentts/__index__.py
 create mode 100644 test_tts.py
 create mode 100644 webui/static/icon.png

diff --git a/AGENTS.md b/AGENTS.md
new file mode 100644
index 0000000..926c2b5
--- /dev/null
+++ b/AGENTS.md
@@ -0,0 +1,225 @@
+# KittenTTS Project Guide
+
+This document provides essential information for AI coding agents working on the KittenTTS project.
+
+## Project Overview
+
+KittenTTS is an open-source, ultra-lightweight text-to-speech (TTS) model designed for CPU-optimized, high-quality voice synthesis without requiring a GPU. The project provides both a Python library and a web interface.
+
+**Key Characteristics:**
+- Model sizes range from 15M to 80M parameters
+- ONNX-based inference for cross-platform compatibility
+- Models downloaded from Hugging Face at runtime (not bundled)
+- 8 distinct voices with speed control support
+- Target: Real-time speech synthesis on consumer hardware
+
+**Available Models:**
+| Model | Params | Size | HuggingFace Repo |
+|-------|--------|------|------------------|
+| kitten-tts-mini | 80M | 80MB | KittenML/kitten-tts-mini-0.8 |
+| kitten-tts-micro | 40M | 41MB | KittenML/kitten-tts-micro-0.8 |
+| kitten-tts-nano | 15M | 56MB | KittenML/kitten-tts-nano-0.8-fp32 |
+| kitten-tts-nano-int8 | 15M | 19MB | KittenML/kitten-tts-nano-0.8-int8 |
+
+**Available Voices:** Bella, Jasper, Luna, Bruno, Rosie, Hugo, Kiki, Leo (4 male, 4 female)
+
+## Technology Stack
+
+**Core Dependencies:**
+- Python 3.8+ (recommended 3.12)
+- `onnxruntime` - Model inference engine
+- `phonemizer` + `espeak-ng` - Text-to-phoneme conversion
+- `misaki[en]` - English text processing
+- `spacy` - NLP processing
+- `soundfile` - Audio I/O
+- `huggingface_hub` - Model downloading
+
+**WebUI Dependencies:**
+- `fastapi` - Web framework
+- `uvicorn` - ASGI server
+- `python-multipart` - Form parsing
+
+**Build System:**
+- `setuptools` with `pyproject.toml` (primary) and legacy `setup.py`
+- `ruff` for linting (cache directory `.ruff_cache/` present)
+
+## Project Structure
+
+```
+.
+├── kittentts/                 # Core library package
+│   ├── __init__.py           # Package exports (KittenTTS, get_model)
+│   ├── __index__.py          # Legacy exports
+│   ├── get_model.py          # Model download & main KittenTTS class
+│   ├── onnx_model.py         # ONNX inference engine (KittenTTS_1_Onnx)
+│   └── preprocess.py         # Text preprocessing pipeline
+│
+├── webui/                     # Web interface
+│   ├── __init__.py
+│   ├── server.py             # FastAPI application & endpoints
+│   ├── templates/
+│   │   └── index.html        # Main web interface
+│   └── static/
+│       ├── style.css         # UI styling
+│       ├── app.js            # Frontend JavaScript
+│       └── favicon.svg       # Branding icon
+│
+├── pyproject.toml            # Modern Python packaging config
+├── setup.py                  # Legacy packaging (keep in sync)
+├── requirements.txt          # Base dependencies
+├── MANIFEST.in               # Package distribution includes
+├── Dockerfile                # Container build
+├── run_webui.py              # WebUI entry point
+└── example.py                # Usage example
+```
+
+## Key Module Details
+
+### 1. `kittentts/get_model.py`
+- **KittenTTS** class: Main user-facing API
+  - `__init__(model_name, cache_dir)` - Downloads model from HF if needed
+  - `generate(text, voice, speed)` - Returns numpy array of audio
+  - `generate_to_file(text, output_path, ...)` - Saves to WAV file
+  - `available_voices` property - Lists supported voices
+- **download_from_huggingface()** - Downloads config, model ONNX, and voice embeddings
+
+### 2. `kittentts/onnx_model.py`
+- **KittenTTS_1_Onnx** class: Low-level ONNX inference
+  - Loads ONNX model and voice embeddings (NPZ format)
+  - Uses EspeakBackend for phonemization (language: "en-us")
+  - **TextCleaner** class: Maps phonemes to token IDs
+  - **chunk_text()**: Splits long text at sentence/word boundaries (400 char limit)
+  - Handles speed adjustments via voice-specific priors
+
+### 3. `kittentts/preprocess.py`
+- **TextPreprocessor** class: Comprehensive text normalization
+  - Number-to-words conversion (integers, floats, ordinals, fractions)
+  - Currency expansion ($, €, £, ¥, ₹, ₩, ₿)
+  - Time format expansion (3:30pm → "three thirty pm")
+  - Unit expansion (km, kg, GB, °C, etc.)
+  - Scientific notation, Roman numerals, phone numbers, IP addresses
+  - Model name normalization (GPT-3 → "GPT 3")
+  - HTML/URL/email removal, contraction expansion
+  - Configurable pipeline via constructor flags
+
+### 4. `webui/server.py`
+- FastAPI application with CORS enabled
+- Endpoints:
+  - `GET /` - Serves HTML template
+  - `GET /api/models` - Returns model metadata
+  - `GET /api/voices` - Returns voice metadata
+  - `POST /api/generate` - Generates speech (returns base64 WAV)
+  - `GET /api/health` - Health check with loaded models
+- **Model lazy-loading**: Models loaded on first request and cached
+
+## Build and Installation
+
+**Development Installation:**
+```bash
+pip install -e .
+# Or with WebUI support:
+pip install -e . fastapi uvicorn python-multipart
+```
+
+**Building Wheel:**
+```bash
+python -m build
+```
+
+**Docker Build:**
+```bash
+docker build -t kittentts-webui .
+docker run -d -p 7860:7860 -v ~/.cache/huggingface:/root/.cache/huggingface kittentts-webui
+```
+
+## Running the Application
+
+**Python API:**
+```python
+from kittentts import KittenTTS
+import soundfile as sf
+
+model = KittenTTS("KittenML/kitten-tts-mini-0.8")
+audio = model.generate("Hello world", voice="Jasper", speed=1.0)
+sf.write("output.wav", audio, 24000)
+```
+
+**WebUI:**
+```bash
+python run_webui.py --host 0.0.0.0 --port 7860
+```
+
+## Development Conventions
+
+**Code Style:**
+- Project uses `ruff` for linting (evidenced by `.ruff_cache/`)
+- Follow PEP 8 conventions
+- Use type hints where appropriate (FastAPI models use Pydantic)
+
+**Text Processing Order:**
+When modifying `preprocess.py`, maintain the processing order in `TextPreprocessor.process()`:
+1. Unicode normalization
+2. Content removal (HTML, URLs, emails)
+3. Contraction expansion
+4. IP addresses (before decimal normalization)
+5. Currency/percentages/scientific notation
+6. Time, ordinals, units, fractions, decades
+7. Phone numbers (before ranges)
+8. Ranges, model names, Roman numerals
+9. Generic number replacement
+10. Final cleanup (accents, punctuation, lowercase)
+
+**Voice Aliases:**
+The WebUI uses friendly names (Bella, Jasper, etc.) that map to internal voice IDs (expr-voice-2-f, expr-voice-2-m, etc.). Maintain this mapping in both `webui/server.py` and model configs.
+
+## Testing
+
+**Current State:** No test suite is currently present in the repository.
+
+**Recommended Testing Approach:**
+- Add unit tests for `TextPreprocessor` with various input cases
+- Test ONNX model inference with dummy inputs
+- Integration tests for HuggingFace model downloading
+- WebUI API endpoint testing with `TestClient` from FastAPI
+
+## Deployment Considerations
+
+**System Requirements:**
+- Python 3.12 recommended (3.8 minimum)
+- `espeak-ng` system package required (installed in Dockerfile)
+- HuggingFace cache directory should be persisted for faster restarts
+- Models are downloaded on-demand (~80MB per model variant)
+
+**Security:**
+- WebUI runs with CORS allow-all (`["*"]`) - configure appropriately for production
+- No authentication implemented in default WebUI
+- Input validation present for speed range (0.25-3.0) and empty text
+
+**Environment Variables:**
+- `PYTHONUNBUFFERED=1` set in Docker
+- HF cache location follows HuggingFace hub defaults (`~/.cache/huggingface`)
+
+## Common Tasks
+
+**Adding a New Voice:**
+1. Add voice embeddings to model's voices.npz on HuggingFace
+2. Update `available_voices` in `onnx_model.py`
+3. Add voice alias mapping in `webui/server.py`
+4. Update voice metadata in `VOICES` list in `server.py`
+
+**Adding a New Model:**
+1. Upload ONNX model and config to HuggingFace
+2. Add entry to `MODELS` dict in `webui/server.py`
+3. Add metadata to `MODEL_INFO` list
+4. Ensure config.json has correct `type`, `model_file`, `voices` keys
+
+**Modifying Text Preprocessing:**
+1. Add new regex pattern near other `_RE_*` definitions
+2. Create expansion function with docstring and examples
+3. Add config flag to `TextPreprocessor.__init__`
+4. Insert call in `process()` method at appropriate position
+5. Add test case in `if __name__ == "__main__"` block
+
+## License
+
+Apache License 2.0 - See LICENSE file for details.
diff --git a/AUDIO_QUALITY.md b/AUDIO_QUALITY.md
new file mode 100644
index 0000000..d8e1bd1
--- /dev/null
+++ b/AUDIO_QUALITY.md
@@ -0,0 +1,202 @@
+# KittenTTS Audio Quality Optimization Guide
+
+This guide explains how to get the best audio quality from KittenTTS.
+
+## 🎯 Model Selection (Most Important!)
+
+**The #1 factor for audio quality is model precision, not model size.**
+
+### Model Precision Comparison
+
+| Model | Params | Size | Precision | Quality | Use Case |
+|-------|--------|------|-----------|---------|----------|
+| **Nano (FP32)** | 15M | 56MB | 32-bit float | ⭐⭐⭐⭐⭐ **Best** | Recommended for best quality |
+| Mini (INT8) | 80M | 80MB | 8-bit int | ⭐⭐⭐⭐ Good | Long-form content |
+| Micro (INT8) | 40M | 41MB | 8-bit int | ⭐⭐⭐ Good | Balanced |
+| Nano (INT8) | 15M | 19MB | 8-bit int | ⭐⭐ Basic | Resource-constrained |
+
+### Why FP32 Sounds Better Than Larger INT8 Models
+
+The neural network generates continuous audio waveforms. Precision matters:
+
+- **FP32 (32-bit float)**: Smooth, continuous curves → natural speech
+- **INT8 (8-bit integer)**: Stepped approximations → subtle artifacts
+
+A smaller FP32 model (15M params, 56MB) produces smoother audio than a larger INT8 model (80M params, 80MB) because:
+1. **No quantization artifacts** - Full precision preserves subtle prosody
+2. **Smoother waveforms** - No stepped approximations in output
+3. **Better pitch/rhythm** - Floating point preserves continuous variations
+
+**Recommendation: Always use `kitten-tts-nano` (FP32) for best quality.**
+
+## 🔧 Environment Setup
+
+### Required Dependencies
+
+For optimal audio quality, ensure all dependencies are properly installed:
+
+```bash
+# Install all dependencies
+pip install -r requirements.txt
+python -m spacy download en_core_web_sm
+```
+
+### Critical Components
+
+| Component | Purpose | Quality Impact |
+|-----------|---------|----------------|
+| **ONNX Runtime** | Model inference engine | High - affects synthesis speed & stability |
+| **Phonemizer** | Text → phoneme conversion | Critical - wrong phonemes = gibberish speech |
+| **Espeak-ng** | Backend for phonemizer | Critical - version must match training environment |
+| **NumPy < 2.0** | Array operations | Medium - version 2.x may have precision issues |
+
+## 🎙️ Best Practices
+
+### 1. Voice Selection
+
+Different voices work better for different content:
+
+| Voice | Gender | Best For | Notes |
+|-------|--------|----------|-------|
+| **Jasper** | Male | General use, clarity | Most consistent across environments |
+| **Bella** | Female | Warm, friendly content | Good for conversational text |
+| **Luna** | Female | Soft, melodic speech | Best for poetry/artistic content |
+| **Bruno** | Male | Deep, authoritative | Good for announcements |
+
+### 2. Speed Settings
+
+- **1.0x (default)**: Most natural speech
+- **0.8-0.9x**: More deliberate, clearer pronunciation
+- **1.1-1.2x**: Faster but still natural
+- **>1.5x**: May become distorted
+
+### 3. Text Preparation
+
+```python
+# Good: Punctuation helps with prosody
+text = "Hello! How are you today? I hope you're doing well."
+
+# Avoid: Missing punctuation
+text = "hello how are you today i hope youre doing well"
+
+# Good: Numbers written out or let preprocessor handle them
+text = "I have 3 cats and 2 dogs."  # Auto-converted to "three" and "two"
+
+# Good: End sentences with punctuation
+# This helps the model know when to pause
+```
+
+### 4. Audio Output Settings
+
+When saving files, use appropriate bit depth:
+
+```python
+# Standard quality (recommended)
+model.generate_to_file(text, "output.wav", subtype='PCM_16')
+
+# Higher quality (larger file)
+model.generate_to_file(text, "output.wav", subtype='PCM_24')
+```
+
+## 🔍 Troubleshooting
+
+### Audio Sounds Robotic/Muffled
+
+**Cause**: Wrong phonemization (espeak version mismatch)
+
+**Fix**:
+```bash
+# Check espeak version
+espeak-ng --version  # Should be 1.51 or later
+
+# Reinstall phonemizer dependencies
+pip install --force-reinstall phonemizer espeakng-loader
+```
+
+### Audio Has Static/Noise
+
+**Cause**: Clipping or float precision issues
+
+**Fix**:
+- Lower the speed slightly (try 0.95x)
+- Check NumPy version: `pip install "numpy<2.0"`
+
+### Generation Is Slow
+
+**Cause**: ONNX Runtime not using optimal settings
+
+**Fix**: The model now auto-configures ONNX Runtime. If still slow:
+```python
+# Check available providers
+import onnxruntime as ort
+print(ort.get_available_providers())
+
+# Should show ['CPUExecutionProvider'] at minimum
+```
+
+### Voice Sounds Wrong (Wrong Pitch/Gender)
+
+**Cause**: Voice embeddings not loading correctly
+
+**Fix**: 
+1. Delete cached model: `~/.cache/huggingface/hub/KittenML_*`
+2. Re-download: The model will re-download on next use
+
+## 📊 Testing Your Setup
+
+Run the diagnostic script:
+
+```bash
+# Check environment
+python check_environment.py
+
+# Test audio generation
+python test_tts.py
+
+# With speed benchmark
+python test_tts.py --benchmark
+```
+
+## 🏗️ How It Works
+
+```
+Text Input
+    ↓
+Text Preprocessor (numbers → words, contractions, etc.)
+    ↓
+Phonemizer (espeak-ng) → IPA phonemes
+    ↓
+Tokenization → Integer IDs
+    ↓
+ONNX Model Inference
+    ↓
+Audio Trimming & Normalization
+    ↓
+24kHz Mono WAV Output
+```
+
+Each step can affect quality. The most critical is **phonemization** - if espeak produces different phonemes than expected, the neural network receives unfamiliar input.
+
+## 🐛 Known Issues
+
+1. **NumPy 2.0+**: May cause subtle audio differences. Stick to 1.24-1.26 for best results.
+
+2. **Windows Espeak**: Sometimes requires manual PATH configuration. The `espeakng-loader` package helps but may need:
+   ```python
+   import espeakng_loader
+   espeakng_loader.load_espeakng_library()
+   ```
+
+3. **Long Text**: Automatically chunked at 400 characters. Very long sentences may have slight discontinuities at chunk boundaries.
+
+## 📈 Performance Metrics
+
+On a modern CPU, you should expect:
+
+| Model | Size | RTF (Real-Time Factor) | Quality |
+|-------|------|----------------------|---------|
+| Nano | 15M | 5-10x | Good |
+| Micro | 40M | 3-5x | Better |
+| Mini | 80M | 1-2x | Best |
+
+RTF > 1 means faster than real-time (good for streaming).
diff --git a/README.md b/README.md
index 2f4739b..2c4b5b8 100644
--- a/README.md
+++ b/README.md
@@ -28,14 +28,16 @@ Email the creators with any questions : info@stellonlabs.com
 
 ## Models
 
-| Model | Params | Size | Link |
-|-------|--------|------|------|
-| kitten-tts-mini | 80M | 80MB | 🤗 [KittenML/kitten-tts-mini-0.8](https://huggingface.co/KittenML/kitten-tts-mini-0.8) |
-| kitten-tts-micro | 40M | 41MB | 🤗 [KittenML/kitten-tts-micro-0.8](https://huggingface.co/KittenML/kitten-tts-micro-0.8) |
-| kitten-tts-nano | 15M | 56MB | 🤗 [KittenML/kitten-tts-nano-0.8](https://huggingface.co/KittenML/kitten-tts-nano-0.8-fp32) |
-| kitten-tts-nano-int8 quantized | 15M | 19MB | 🤗 [KittenML/kitten-tts-nano-0.8-int8](https://huggingface.co/KittenML/kitten-tts-nano-0.8-int8) |
+| Model | Params | Size | Precision | Quality | Link |
+|-------|--------|------|-----------|---------|------|
+| **kitten-tts-nano** ⭐ | 15M | 56MB | FP32 | **Best** | 🤗 [KittenML/kitten-tts-nano-0.8-fp32](https://huggingface.co/KittenML/kitten-tts-nano-0.8-fp32) |
+| kitten-tts-mini | 80M | 80MB | INT8 | Good | 🤗 [KittenML/kitten-tts-mini-0.8](https://huggingface.co/KittenML/kitten-tts-mini-0.8) |
+| kitten-tts-micro | 40M | 41MB | INT8 | Good | 🤗 [KittenML/kitten-tts-micro-0.8](https://huggingface.co/KittenML/kitten-tts-micro-0.8) |
+| kitten-tts-nano-int8 | 15M | 19MB | INT8 | Basic | 🤗 [KittenML/kitten-tts-nano-0.8-int8](https://huggingface.co/KittenML/kitten-tts-nano-0.8-int8) |
 
-> Some users are facing minor issues with the kitten-tts-nano-int8  model. We are looking into it. Please report to us if you face any issues. 
+> **💡 Quality Tip:** The FP32 nano model (56MB) produces the best audio quality because it uses full 32-bit floating point precision. Larger models (mini, micro) use INT8 quantization which can introduce subtle artifacts. **For best results, use `kitten-tts-nano` (FP32).**
+
+> Some users are facing minor issues with the kitten-tts-nano-int8 model. We are looking into it. Please report to us if you face any issues. 
 
 ## Demo Video
 
@@ -58,7 +60,9 @@ pip install https://github.com/KittenML/KittenTTS/releases/download/0.8/kittentt
 
 ```
 from kittentts import KittenTTS
-m = KittenTTS("KittenML/kitten-tts-mini-0.8")
+
+# Use FP32 model for best quality (recommended)
+m = KittenTTS("KittenML/kitten-tts-nano-0.8-fp32")
 
 audio = m.generate("This high quality TTS model works without a GPU", voice='Jasper' )
 
@@ -76,7 +80,21 @@ sf.write('output.wav', audio, 24000)
 
 ## System Requirements
 
-Works literally everywhere. Needs python3.12. We recommend using conda. 
+Works literally everywhere. Needs python3.8+. We recommend using python3.12 with conda.
+
+### Audio Quality Note
+
+The model performance may vary based on your environment (OS, espeak-ng version, ONNX Runtime provider). For best results:
+
+```bash
+# Check your environment
+python check_environment.py
+
+# Test audio generation
+python test_tts.py
+```
+
+See [AUDIO_QUALITY.md](AUDIO_QUALITY.md) for detailed optimization guide. 
 
 
 
diff --git a/check_environment.py b/check_environment.py
new file mode 100644
index 0000000..49a41b1
--- /dev/null
+++ b/check_environment.py
@@ -0,0 +1,173 @@
+#!/usr/bin/env python3
+"""
+KittenTTS Environment Check Script
+Run this to verify your environment is properly configured for best audio quality.
+"""
+
+import sys
+import subprocess
+
+def check_import(module_name, package_name=None):
+    """Check if a module can be imported."""
+    package_name = package_name or module_name
+    try:
+        __import__(module_name)
+        print(f"  [OK] {package_name}")
+        return True
+    except ImportError:
+        print(f"  [MISSING] {package_name} (pip install {package_name})")
+        return False
+
+def check_version(module_name, attr='__version__'):
+    """Get version of a module."""
+    try:
+        mod = __import__(module_name)
+        version = getattr(mod, attr, 'unknown')
+        if callable(version):
+            version = version()
+        return version
+    except:
+        return 'unknown'
+
+def main():
+    print("=" * 60)
+    print("KittenTTS Environment Check")
+    print("=" * 60)
+    
+    # Check if in conda environment
+    if sys.prefix == sys.base_prefix:
+        print("\n[NOTE] Not running in a virtual environment.")
+        print("       For best results, use a conda environment:")
+        print("       conda activate kittentts")
+    else:
+        print(f"\n[OK] Running in virtual environment: {sys.prefix}")
+    
+    all_ok = True
+    
+    # Check Python version
+    print(f"\nPython Version: {sys.version}")
+    if sys.version_info < (3, 8):
+        print("  [WARN] Python 3.8+ recommended")
+        all_ok = False
+    else:
+        print("  [OK] Python version")
+    
+    # Check core dependencies
+    print("\nCore Dependencies:")
+    deps = [
+        ('numpy', 'numpy'),
+        ('onnxruntime', 'onnxruntime'),
+        ('soundfile', 'soundfile'),
+        ('phonemizer', 'phonemizer'),
+        ('spacy', 'spacy'),
+        ('num2words', 'num2words'),
+        ('huggingface_hub', 'huggingface-hub'),
+    ]
+    
+    for module, package in deps:
+        if not check_import(module, package):
+            all_ok = False
+    
+    # Check specific versions
+    print("\nVersions:")
+    try:
+        import numpy as np
+        print(f"  NumPy: {np.__version__}")
+        if int(np.__version__.split('.')[0]) >= 2:
+            print("    [WARN] NumPy 2.x detected - use numpy<2.0 for best compatibility")
+    except:
+        pass
+        
+    try:
+        import onnxruntime as ort
+        print(f"  ONNX Runtime: {ort.__version__}")
+        providers = ort.get_available_providers()
+        print(f"    Providers: {providers}")
+        if 'CPUExecutionProvider' not in providers:
+            print("    [WARN] CPUExecutionProvider not available")
+    except:
+        pass
+    
+    # Check espeak
+    print("\n[Espeak Phonemizer Backend]")
+    try:
+        # Try to load espeak-ng library if available (needed on Windows)
+        try:
+            import espeakng_loader
+            espeakng_loader.load_library()
+            import os
+            if 'ESPEAK_DATA_PATH' not in os.environ:
+                os.environ['ESPEAK_DATA_PATH'] = str(espeakng_loader.get_data_path())
+            # Tell phonemizer where to find the espeak library
+            from phonemizer.backend.espeak.base import BaseEspeakBackend
+            BaseEspeakBackend.set_library(str(espeakng_loader.get_library_path()))
+        except:
+            pass
+        
+        from phonemizer.backend import BACKENDS
+        EspeakBackend = BACKENDS.get('espeak') or BACKENDS.get('espeak-ng')
+        if EspeakBackend is None:
+            raise RuntimeError("No espeak backend available")
+        
+        # Try to create a backend
+        backend = EspeakBackend('en-us')
+        print(f"  [OK] Espeak backend working (language: {backend.language})")
+        
+        # Test phonemization
+        test = backend.phonemize(["hello world"])
+        # Encoding-safe print (Windows console may not support IPA chars)
+        try:
+            print(f"  [OK] Phonemization test: {test}")
+        except UnicodeEncodeError:
+            print(f"  [OK] Phonemization working (output contains IPA characters)")
+    except Exception as e:
+        print(f"  [ERROR] Espeak backend: {e}")
+        print("    Fix: pip install espeakng-loader phonemizer")
+        all_ok = False
+    
+    # Check spacy model
+    print("\nSpacy English Model:")
+    try:
+        import spacy
+        try:
+            nlp = spacy.load('en_core_web_sm')
+            print("  [OK] en_core_web_sm loaded")
+        except:
+            print("  [MISSING] en_core_web_sm not found")
+            print("    Run: python -m spacy download en_core_web_sm")
+            all_ok = False
+    except:
+        pass
+    
+    # ONNX Runtime optimization check
+    print("\nONNX Runtime Configuration:")
+    try:
+        import onnxruntime as ort
+        sess_options = ort.SessionOptions()
+        print(f"  Default threads: {sess_options.intra_op_num_threads}")
+        print(f"  Graph optimization: {sess_options.graph_optimization_level}")
+        
+        # Check if we can load a test session
+        print("  [OK] ONNX Runtime session options accessible")
+    except Exception as e:
+        print(f"  [ERROR] ONNX: {e}")
+    
+    # Summary
+    print("\n" + "=" * 60)
+    if all_ok:
+        print("[SUCCESS] Environment looks good! KittenTTS should work well.")
+        print("\nTips for best audio quality:")
+        print("   1. Use speed=1.0 for most natural speech")
+        print("   2. Keep sentences under 400 characters")
+        print("   3. End sentences with punctuation for better prosody")
+        print("   4. Use 'Jasper' or 'Bella' for clearest speech")
+    else:
+        print("[ERROR] Some issues found. Please install missing dependencies:")
+        print("   pip install -r requirements.txt")
+        print("   python -m spacy download en_core_web_sm")
+    print("=" * 60)
+    
+    return 0 if all_ok else 1
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/kittentts/__index__.py b/kittentts/__index__.py
deleted file mode 100644
index e178a13..0000000
--- a/kittentts/__index__.py
+++ /dev/null
@@ -1,3 +0,0 @@
-from kittentts.get_model import get_model
-
-    
\ No newline at end of file
diff --git a/kittentts/onnx_model.py b/kittentts/onnx_model.py
index 7ea20b3..c5f8d25 100644
--- a/kittentts/onnx_model.py
+++ b/kittentts/onnx_model.py
@@ -1,6 +1,23 @@
-from misaki import en, espeak
+# Try to load espeak-ng library if available (needed on Windows)
+# This sets up the espeak-ng library and data paths properly
+try:
+    import espeakng_loader
+    espeakng_loader.load_library()
+    # Set the data path environment variable required by espeak
+    import os
+    if 'ESPEAK_DATA_PATH' not in os.environ:
+        os.environ['ESPEAK_DATA_PATH'] = str(espeakng_loader.get_data_path())
+    # Tell phonemizer where to find the espeak library
+    from phonemizer.backend.espeak.base import BaseEspeakBackend
+    BaseEspeakBackend.set_library(str(espeakng_loader.get_library_path()))
+except Exception:
+    # If loader fails, phonemizer might still find system espeak
+    pass
+
 import numpy as np
+
 import phonemizer
+from phonemizer.backend import BACKENDS
 import soundfile as sf
 import onnxruntime as ort
 from .preprocess import TextPreprocessor
@@ -86,10 +103,44 @@ def __init__(self, model_path="kitten_tts_nano_preview.onnx", voices_path="voice
             voices_path: Path to the voices NPZ file
         """
         self.model_path = model_path
-        self.voices = np.load(voices_path) 
-        self.session = ort.InferenceSession(model_path)
+        self.voices = np.load(voices_path)
+        
+        # Configure ONNX Runtime for best audio quality and performance
+        sess_options = ort.SessionOptions()
+        
+        # Use all available cores for parallel processing
+        sess_options.intra_op_num_threads = 0  # 0 = use all cores
+        sess_options.inter_op_num_threads = 0
+        
+        # Graph optimizations for better inference
+        sess_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
+        
+        # Enable memory pattern optimization
+        sess_options.enable_mem_pattern = True
+        
+        # Get available providers (prefer CPUExecutionProvider for consistency)
+        available_providers = ort.get_available_providers()
+        providers = []
         
-        self.phonemizer = phonemizer.backend.EspeakBackend(
+        # For TTS quality/consistency, CPU is often more deterministic than GPU
+        if 'CPUExecutionProvider' in available_providers:
+            providers.append('CPUExecutionProvider')
+        elif 'AzureExecutionProvider' in available_providers:
+            providers.append('AzureExecutionProvider')
+        
+        # Create session with optimized settings
+        self.session = ort.InferenceSession(
+            model_path, 
+            sess_options=sess_options,
+            providers=providers
+        )
+        
+        # Use the BACKENDS dict to get EspeakBackend (handles API differences across versions)
+        EspeakBackend = BACKENDS.get('espeak') or BACKENDS.get('espeak-ng')
+        if EspeakBackend is None:
+            raise RuntimeError("No espeak backend available. Install espeak-ng and phonemizer.")
+        
+        self.phonemizer = EspeakBackend(
             language="en-us", preserve_punctuation=True, with_stress=True
         )
         self.text_cleaner = TextCleaner()
@@ -159,14 +210,56 @@ def generate_single_chunk(self, text: str, voice: str = "expr-voice-5-m", speed:
         onnx_inputs = self._prepare_inputs(text, voice, speed)
         
         outputs = self.session.run(None, onnx_inputs)
+        audio = outputs[0]
+        
+        # Smart trimming: remove trailing silence while preserving actual audio content
+        audio = self._smart_trim_trailing_silence(audio)
         
-        # Trim audio
-        audio = outputs[0][..., :-5000]
+        # Normalize audio to prevent clipping and ensure consistent volume
+        max_val = np.max(np.abs(audio))
+        if max_val > 0:
+            # Soft normalization: don't over-compress, just prevent clipping
+            if max_val > 0.95:
+                audio = audio * (0.95 / max_val)
 
         return audio
     
+    def _smart_trim_trailing_silence(self, audio: np.ndarray, threshold: float = 0.01, 
+                                      padding_ms: float = 50.0, sample_rate: int = 24000) -> np.ndarray:
+        """Trim trailing silence while preserving audio content.
+        
+        Args:
+            audio: Audio data as numpy array
+            threshold: Amplitude threshold for silence detection
+            padding_ms: Milliseconds of padding to keep after audio ends
+            sample_rate: Audio sample rate
+            
+        Returns:
+            Trimmed audio data
+        """
+        if audio.shape[-1] < 8000:  # Don't trim very short audio
+            return audio
+        
+        # Find the last sample above the threshold
+        energy = np.abs(audio)
+        above_threshold = np.where(energy > threshold)[0]
+        
+        if len(above_threshold) == 0:
+            # All silence, return original
+            return audio
+        
+        # Find the end of the last audio segment
+        last_audio_sample = above_threshold[-1]
+        
+        # Add padding (default 50ms) to avoid cutting off decay
+        padding_samples = int(padding_ms / 1000.0 * sample_rate)
+        end_sample = min(last_audio_sample + padding_samples, audio.shape[-1])
+        
+        return audio[..., :end_sample]
+    
     def generate_to_file(self, text: str, output_path: str, voice: str = "expr-voice-5-m", 
-                          speed: float = 1.0, sample_rate: int = 24000, clean_text: bool=True) -> None:
+                          speed: float = 1.0, sample_rate: int = 24000, clean_text: bool=True,
+                          subtype: str = 'PCM_16') -> None:
         """Synthesize speech and save to file.
         
         Args:
@@ -176,8 +269,15 @@ def generate_to_file(self, text: str, output_path: str, voice: str = "expr-voice
             speed: Speech speed (1.0 = normal)
             sample_rate: Audio sample rate
             clean_text: If true, it will cleanup the text. Eg. replace numbers with words.
+            subtype: SoundFile subtype for quality (PCM_16, PCM_24, FLOAT)
         """
         audio = self.generate(text, voice, speed, clean_text=clean_text)
-        sf.write(output_path, audio, sample_rate)
-        print(f"Audio saved to {output_path}")
+        
+        # Ensure audio is float32 for best compatibility
+        if audio.dtype != np.float32:
+            audio = audio.astype(np.float32)
+        
+        # Write with specified subtype for quality
+        sf.write(output_path, audio, sample_rate, subtype=subtype)
+        print(f"Audio saved to {output_path} ({len(audio)/sample_rate:.2f}s at {sample_rate}Hz)")
 
diff --git a/pyproject.toml b/pyproject.toml
index c2d1e5c..b6f7eb8 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -18,14 +18,16 @@ classifiers = [
     "Topic :: Scientific/Engineering :: Artificial Intelligence",
 ]
 dependencies = [
-    "num2words",
-    "spacy",
-    "espeakng_loader",
+    "num2words>=0.5.13",
+    "spacy>=3.7.0",
+    "phonemizer>=3.3.0",
+    "espeakng-loader>=0.1.0",
     "misaki[en]>=0.9.4",
-    "onnxruntime",
-    "soundfile",
-    "numpy",
-    "huggingface_hub",
+    "onnxruntime>=1.16.0",
+    "soundfile>=0.12.0",
+    "numpy>=1.24.0,<2.0.0",
+    "huggingface-hub>=0.20.0",
+    "psutil>=5.9.0",
 ]
 
 [project.urls]
diff --git a/requirements.txt b/requirements.txt
index 37bfbb3..c8aa768 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,8 +1,20 @@
-num2words
-spacy
-espeakng_loader
+# Core TTS dependencies
+num2words>=0.5.13
+spacy>=3.7.0
+phonemizer>=3.3.0
+espeakng-loader>=0.1.0
 misaki[en]>=0.9.4
-onnxruntime
-soundfile
-numpy
-huggingface_hub
+
+# ML/Audio
+onnxruntime>=1.16.0
+soundfile>=0.12.0
+numpy>=1.24.0,<2.0.0
+
+# Model download
+huggingface-hub>=0.20.0
+
+# System monitoring
+psutil>=5.9.0
+
+# Optional: Better phonemization support
+# espeak-ng (system package - see README for installation)
diff --git a/run_webui.py b/run_webui.py
index 39c2936..4be69d5 100644
--- a/run_webui.py
+++ b/run_webui.py
@@ -13,7 +13,7 @@ def main():
         "--host", type=str, default="0.0.0.0", help="Host to bind to (default: 0.0.0.0)"
     )
     parser.add_argument(
-        "--port", type=int, default=7860, help="Port to bind to (default: 7860)"
+        "--port", type=int, default=7880, help="Port to bind to (default: 7880)"
     )
     args = parser.parse_args()
 
diff --git a/test_tts.py b/test_tts.py
new file mode 100644
index 0000000..a71237c
--- /dev/null
+++ b/test_tts.py
@@ -0,0 +1,158 @@
+#!/usr/bin/env python3
+"""
+KittenTTS Audio Quality Test Script
+Tests TTS generation and reports on audio quality metrics.
+"""
+
+import sys
+import time
+
+# Try to load espeak-ng library if available (needed on Windows)
+try:
+    import espeakng_loader
+    espeakng_loader.load_library()
+    import os
+    if 'ESPEAK_DATA_PATH' not in os.environ:
+        os.environ['ESPEAK_DATA_PATH'] = str(espeakng_loader.get_data_path())
+    from phonemizer.backend.espeak.base import BaseEspeakBackend
+    BaseEspeakBackend.set_library(str(espeakng_loader.get_library_path()))
+except:
+    pass
+
+import numpy as np
+
+def test_basic_generation():
+    """Test basic TTS generation."""
+    print("=" * 60)
+    print("🐱 KittenTTS Audio Quality Test")
+    print("=" * 60)
+    
+    # Test imports
+    print("\n1. Testing imports...")
+    try:
+        from kittentts import KittenTTS
+        print("   ✓ KittenTTS imported successfully")
+    except Exception as e:
+        print(f"   ✗ Import failed: {e}")
+        return False
+    
+    # Test model loading
+    print("\n2. Loading model (this may take a moment)...")
+    try:
+        # Use nano model for quick testing
+        model = KittenTTS("KittenML/kitten-tts-nano-0.8-fp32")
+        print(f"   ✓ Model loaded")
+        print(f"   Available voices: {model.available_voices}")
+    except Exception as e:
+        print(f"   ✗ Model loading failed: {e}")
+        print(f"   Error details: {type(e).__name__}")
+        import traceback
+        traceback.print_exc()
+        return False
+    
+    # Test audio generation
+    print("\n3. Generating test audio...")
+    test_texts = [
+        ("Hello, this is a test of KittenTTS.", "Jasper"),
+        ("The quick brown fox jumps over the lazy dog.", "Bella"),
+    ]
+    
+    for text, voice in test_texts:
+        print(f"\n   Testing with voice '{voice}':")
+        print(f"   Text: \"{text}\"")
+        
+        try:
+            start = time.time()
+            audio = model.generate(text, voice=voice, speed=1.0)
+            duration = time.time() - start
+            
+            # Analyze audio
+            audio_duration = len(audio) / 24000  # 24kHz sample rate
+            max_amplitude = np.max(np.abs(audio))
+            rms = np.sqrt(np.mean(audio**2))
+            
+            print(f"   ✓ Generated {audio_duration:.2f}s audio in {duration:.2f}s")
+            print(f"     Max amplitude: {max_amplitude:.4f}")
+            print(f"     RMS level: {rms:.4f}")
+            print(f"     Real-time factor: {audio_duration/duration:.2f}x")
+            
+            # Quality checks
+            if max_amplitude > 1.0:
+                print(f"     ⚠️  Warning: Audio clipping detected!")
+            elif max_amplitude < 0.1:
+                print(f"     ⚠️  Warning: Audio level very low!")
+            else:
+                print(f"     ✓ Audio levels OK")
+                
+        except Exception as e:
+            print(f"   ✗ Generation failed: {e}")
+            import traceback
+            traceback.print_exc()
+            return False
+    
+    # Test file saving
+    print("\n4. Testing file output...")
+    try:
+        model.generate_to_file(
+            "This is a test file.", 
+            "test_output.wav", 
+            voice="Jasper",
+            subtype='PCM_16'
+        )
+        print("   ✓ File saved to test_output.wav")
+    except Exception as e:
+        print(f"   ✗ File saving failed: {e}")
+        return False
+    
+    print("\n" + "=" * 60)
+    print("✅ All tests passed! Audio quality looks good.")
+    print("=" * 60)
+    return True
+
+def benchmark_speed():
+    """Benchmark generation speed."""
+    print("\n" + "=" * 60)
+    print("⚡ Speed Benchmark")
+    print("=" * 60)
+    
+    try:
+        from kittentts import KittenTTS
+        model = KittenTTS("KittenML/kitten-tts-nano-0.8-fp32")
+        
+        text = "This is a benchmark test to measure generation speed."
+        
+        # Warmup
+        print("Warming up...")
+        model.generate(text, voice="Jasper")
+        
+        # Benchmark
+        print("Running benchmark...")
+        times = []
+        for _ in range(3):
+            start = time.time()
+            audio = model.generate(text, voice="Jasper")
+            times.append(time.time() - start)
+        
+        avg_time = np.mean(times)
+        audio_duration = len(audio) / 24000
+        rtf = audio_duration / avg_time
+        
+        print(f"Average generation time: {avg_time:.3f}s")
+        print(f"Audio duration: {audio_duration:.2f}s")
+        print(f"Real-time factor: {rtf:.2f}x")
+        
+        if rtf > 1.0:
+            print("✅ Faster than real-time!")
+        else:
+            print("⚠️  Slower than real-time - expect delays")
+            
+    except Exception as e:
+        print(f"Benchmark failed: {e}")
+
+if __name__ == "__main__":
+    success = test_basic_generation()
+    
+    if success and '--benchmark' in sys.argv:
+        benchmark_speed()
+    
+    sys.exit(0 if success else 1)
diff --git a/webui/server.py b/webui/server.py
index 0533f79..3496bd4 100644
--- a/webui/server.py
+++ b/webui/server.py
@@ -1,8 +1,11 @@
 import io
 import base64
 import tempfile
-from typing import Optional
+import time
+import os
+from typing import Optional, Dict, Any
 from pathlib import Path
+from datetime import datetime
 
 import numpy as np
 import soundfile as sf
@@ -12,6 +15,10 @@
 from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel
 
+# Configuration
+CACHE_DIR = Path.home() / ".cache" / "kittentts"
+CACHE_DIR.mkdir(parents=True, exist_ok=True)
+
 MODELS = {
     "kitten-tts-mini": "KittenML/kitten-tts-mini-0.8",
     "kitten-tts-micro": "KittenML/kitten-tts-micro-0.8",
@@ -72,42 +79,98 @@
 ]
 
 MODEL_INFO = [
+    {
+        "id": "kitten-tts-nano",
+        "name": "Nano (FP32)",
+        "params": "15M",
+        "size": "56MB",
+        "description": "⭐ Best quality - Full 32-bit precision",
+        "quality": "best",
+        "precision": "FP32",
+    },
     {
         "id": "kitten-tts-mini",
-        "name": "Mini",
+        "name": "Mini (INT8)",
         "params": "80M",
         "size": "80MB",
-        "description": "Highest quality, larger model",
+        "description": "Largest model, INT8 quantized",
+        "quality": "good",
+        "precision": "INT8",
     },
     {
         "id": "kitten-tts-micro",
-        "name": "Micro",
+        "name": "Micro (INT8)",
         "params": "40M",
         "size": "41MB",
-        "description": "Balanced quality & speed",
-    },
-    {
-        "id": "kitten-tts-nano",
-        "name": "Nano",
-        "params": "15M",
-        "size": "56MB",
-        "description": "Lightweight & fast",
+        "description": "Balanced size, INT8 quantized",
+        "quality": "good",
+        "precision": "INT8",
     },
     {
         "id": "kitten-tts-nano-int8",
         "name": "Nano (INT8)",
         "params": "15M",
         "size": "19MB",
-        "description": "Smallest, quantized",
+        "description": "Smallest, INT8 quantized",
+        "quality": "basic",
+        "precision": "INT8",
     },
 ]
 
-loaded_models = {}
+# In-memory model cache
+loaded_models: Dict[str, Any] = {}
+model_load_times: Dict[str, float] = {}
+
+# Stats tracking
+class StatsTracker:
+    def __init__(self):
+        self.total_requests = 0
+        self.total_generation_time = 0.0
+        self.total_audio_duration = 0.0
+        self.request_history: list = []
+        self.max_history = 50
+        
+    def record_request(self, model_id: str, voice: str, text_length: int, 
+                       generation_time: float, audio_duration: float,
+                       load_time: float = 0.0, preprocessing_time: float = 0.0):
+        self.total_requests += 1
+        self.total_generation_time += generation_time
+        self.total_audio_duration += audio_duration
+        
+        entry = {
+            "timestamp": datetime.now().isoformat(),
+            "model": model_id,
+            "voice": voice,
+            "text_length": text_length,
+            "generation_time": round(generation_time, 3),
+            "audio_duration": round(audio_duration, 3),
+            "load_time": round(load_time, 3),
+            "preprocessing_time": round(preprocessing_time, 3),
+            "rtf": round(audio_duration / generation_time, 3) if generation_time > 0 else 0,
+        }
+        
+        self.request_history.insert(0, entry)
+        if len(self.request_history) > self.max_history:
+            self.request_history = self.request_history[:self.max_history]
+    
+    def get_stats(self):
+        avg_gen_time = (self.total_generation_time / self.total_requests) if self.total_requests > 0 else 0
+        avg_rtf = (self.total_audio_duration / self.total_generation_time) if self.total_generation_time > 0 else 0
+        
+        return {
+            "total_requests": self.total_requests,
+            "avg_generation_time": round(avg_gen_time, 3),
+            "avg_rtf": round(avg_rtf, 3),
+            "total_audio_generated": round(self.total_audio_duration, 2),
+            "recent_requests": self.request_history[:10],
+        }
+
+stats_tracker = StatsTracker()
 
 
 class GenerateRequest(BaseModel):
     text: str
-    model: str = "kitten-tts-mini"
+    model: str = "kitten-tts-nano"  # Default to FP32 for best quality
     voice: str = "Bella"
     speed: float = 1.0
 
@@ -116,19 +179,36 @@ class GenerateResponse(BaseModel):
     audio_base64: str
     sample_rate: int
     duration: float
+    debug_info: Optional[Dict[str, Any]] = None
+
+
+def get_cache_size():
+    """Calculate total cache size in MB."""
+    total_size = 0
+    if CACHE_DIR.exists():
+        for dirpath, dirnames, filenames in os.walk(CACHE_DIR):
+            for f in filenames:
+                fp = os.path.join(dirpath, f)
+                total_size += os.path.getsize(fp)
+    return round(total_size / (1024 * 1024), 2)
 
 
 def get_model(model_id: str):
+    """Get or load a model with caching and timing."""
     if model_id not in MODELS:
         raise ValueError(f"Unknown model: {model_id}")
 
     if model_id not in loaded_models:
         from kittentts import KittenTTS
-
+        
+        start_time = time.time()
         repo_id = MODELS[model_id]
-        loaded_models[model_id] = KittenTTS(repo_id)
-
-    return loaded_models[model_id]
+        loaded_models[model_id] = KittenTTS(repo_id, cache_dir=str(CACHE_DIR))
+        load_time = time.time() - start_time
+        model_load_times[model_id] = load_time
+        print(f"[Model Load] {model_id} loaded in {load_time:.2f}s")
+    
+    return loaded_models[model_id], model_load_times.get(model_id, 0.0)
 
 
 def create_app() -> FastAPI:
@@ -167,7 +247,40 @@ async def get_voices():
 
     @app.get("/api/health")
     async def health_check():
-        return {"status": "healthy", "loaded_models": list(loaded_models.keys())}
+        return {
+            "status": "healthy", 
+            "loaded_models": list(loaded_models.keys()),
+            "cache_dir": str(CACHE_DIR),
+            "cache_size_mb": get_cache_size(),
+        }
+
+    @app.get("/api/stats")
+    async def get_stats():
+        """Get detailed stats for debugging."""
+        import sys
+        
+        # Try to get memory usage, fallback if psutil not available
+        try:
+            import psutil
+            process = psutil.Process()
+            memory_info = process.memory_info()
+            memory_mb = round(memory_info.rss / (1024 * 1024), 2)
+        except:
+            memory_mb = "N/A"
+        
+        return {
+            "generation_stats": stats_tracker.get_stats(),
+            "system": {
+                "cache_directory": str(CACHE_DIR),
+                "cache_size_mb": get_cache_size(),
+                "loaded_models": list(loaded_models.keys()),
+                "model_load_times": {k: round(v, 3) for k, v in model_load_times.items()},
+                "python_version": sys.version.split()[0],
+                "memory_usage_mb": memory_mb,
+            },
+            "available_models": list(MODELS.keys()),
+            "available_voices": [v["id"] for v in VOICES],
+        }
 
     @app.post("/api/generate", response_model=GenerateResponse)
     async def generate_audio(request: GenerateRequest):
@@ -180,14 +293,20 @@ async def generate_audio(request: GenerateRequest):
             )
 
         try:
-            model = get_model(request.model)
-
+            # Load model with timing
+            model_start = time.time()
+            model, load_time = get_model(request.model)
+            model_load_elapsed = time.time() - model_start
+            
             voice_id = VOICE_ALIASES.get(request.voice, request.voice)
-
+            
+            # Generate audio with timing
+            gen_start = time.time()
             audio = model.generate(
                 text=request.text, voice=voice_id, speed=request.speed
             )
-
+            generation_time = time.time() - gen_start
+            
             if isinstance(audio, np.ndarray):
                 audio_array = audio
             else:
@@ -199,15 +318,45 @@ async def generate_audio(request: GenerateRequest):
             sample_rate = 24000
             duration = len(audio_array) / sample_rate
 
+            # Ensure proper audio format for web playback
+            if audio_array.dtype != np.float32:
+                audio_array = audio_array.astype(np.float32)
+            
+            # Normalize if needed to prevent clipping
+            max_val = np.max(np.abs(audio_array))
+            if max_val > 0.99:
+                audio_array = audio_array * (0.99 / max_val)
+
             buffer = io.BytesIO()
-            sf.write(buffer, audio_array, sample_rate, format="WAV")
+            sf.write(buffer, audio_array, sample_rate, format="WAV", subtype='PCM_16')
             buffer.seek(0)
             audio_base64 = base64.b64encode(buffer.read()).decode("utf-8")
 
+            # Record stats
+            stats_tracker.record_request(
+                model_id=request.model,
+                voice=request.voice,
+                text_length=len(request.text),
+                generation_time=generation_time,
+                audio_duration=duration,
+                load_time=load_time if load_time > 0 else model_load_elapsed,
+            )
+
+            # Debug info for API response
+            debug_info = {
+                "model_load_time": round(load_time if load_time > 0 else model_load_elapsed, 3),
+                "generation_time": round(generation_time, 3),
+                "total_time": round(load_time + generation_time, 3),
+                "real_time_factor": round(duration / generation_time, 3) if generation_time > 0 else 0,
+                "audio_samples": len(audio_array),
+                "sample_rate": sample_rate,
+            }
+
             return GenerateResponse(
                 audio_base64=audio_base64,
                 sample_rate=sample_rate,
                 duration=round(duration, 2),
+                debug_info=debug_info,
             )
 
         except Exception as e:
@@ -227,6 +376,7 @@ def run_server(host: str = "0.0.0.0", port: int = 7860):
 
     app = create_app()
     print(f"\n🐱 KittenTTS WebUI starting at http://{host}:{port}")
+    print(f"📁 Cache directory: {CACHE_DIR}")
     print("Press Ctrl+C to stop\n")
     uvicorn.run(app, host=host, port=port)
 
diff --git a/webui/static/app.js b/webui/static/app.js
index a510948..03e152e 100644
--- a/webui/static/app.js
+++ b/webui/static/app.js
@@ -1,28 +1,64 @@
+// KittenTTS WebUI - Cute kitten-themed interactions 🐱
+
 const models = [
-    { id: 'kitten-tts-mini', name: 'Mini', params: '80M', size: '80MB', description: 'Highest quality, larger model' },
-    { id: 'kitten-tts-micro', name: 'Micro', params: '40M', size: '41MB', description: 'Balanced quality & speed' },
-    { id: 'kitten-tts-nano', name: 'Nano', params: '15M', size: '56MB', description: 'Lightweight & fast' },
-    { id: 'kitten-tts-nano-int8', name: 'Nano (INT8)', params: '15M', size: '19MB', description: 'Smallest, quantized' }
+    { id: 'kitten-tts-nano', name: 'Nano (FP32)', params: '15M', size: '56MB', precision: 'FP32', quality: 'best', description: '⭐ Best quality - Full 32-bit precision', emoji: '⭐' },
+    { id: 'kitten-tts-mini', name: 'Mini (INT8)', params: '80M', size: '80MB', precision: 'INT8', quality: 'good', description: 'Largest model, INT8 quantized', emoji: '🐱' },
+    { id: 'kitten-tts-micro', name: 'Micro (INT8)', params: '40M', size: '41MB', precision: 'INT8', quality: 'good', description: 'Balanced size, INT8 quantized', emoji: '🐈' },
+    { id: 'kitten-tts-nano-int8', name: 'Nano (INT8)', params: '15M', size: '19MB', precision: 'INT8', quality: 'basic', description: 'Smallest, INT8 quantized', emoji: '💫' }
 ];
 
 const voices = [
-    { id: 'Bella', name: 'Bella', gender: 'female', description: 'Warm & gentle' },
-    { id: 'Jasper', name: 'Jasper', gender: 'male', description: 'Clear & professional' },
-    { id: 'Luna', name: 'Luna', gender: 'female', description: 'Soft & melodic' },
-    { id: 'Bruno', name: 'Bruno', gender: 'male', description: 'Deep & resonant' },
-    { id: 'Rosie', name: 'Rosie', gender: 'female', description: 'Bright & cheerful' },
-    { id: 'Hugo', name: 'Hugo', gender: 'male', description: 'Confident & steady' },
-    { id: 'Kiki', name: 'Kiki', gender: 'female', description: 'Playful & energetic' },
-    { id: 'Leo', name: 'Leo', gender: 'male', description: 'Friendly & warm' }
+    { id: 'Bella', name: 'Bella', gender: 'female', description: 'Warm & gentle', emoji: '👩' },
+    { id: 'Jasper', name: 'Jasper', gender: 'male', description: 'Clear & professional', emoji: '👨' },
+    { id: 'Luna', name: 'Luna', gender: 'female', description: 'Soft & melodic', emoji: '🌙' },
+    { id: 'Bruno', name: 'Bruno', gender: 'male', description: 'Deep & resonant', emoji: '🐻' },
+    { id: 'Rosie', name: 'Rosie', gender: 'female', description: 'Bright & cheerful', emoji: '🌸' },
+    { id: 'Hugo', name: 'Hugo', gender: 'male', description: 'Confident & steady', emoji: '💼' },
+    { id: 'Kiki', name: 'Kiki', gender: 'female', description: 'Playful & energetic', emoji: '🎀' },
+    { id: 'Leo', name: 'Leo', gender: 'male', description: 'Friendly & warm', emoji: '🦁' }
+];
+
+const sampleTexts = [
+    "Hello! I'm KittenTTS, your cute and lightweight text-to-speech companion! 🐱",
+    "The quick brown fox jumps over the lazy dog. Meow! 🐾",
+    "Welcome to KittenTTS! For kittens, by kittens. 💕",
+    "Did you know? KittenTTS can run entirely on your CPU without a GPU! ✨",
+    "Purrr-fect speech synthesis at your fingertips! 🎙️"
 ];
 
-const pawIcon = `<svg width="20" height="20" viewBox="0 0 24 24" fill="currentColor"><path d="M12 10c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm-6 0c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm12 0c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm-6 6c-2.2 0-4 1.8-4 4h8c0-2.2-1.8-4-4-4zm-6-10c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm12 0c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2z"/></svg>`;
+let audioContext = null;
+let meowSounds = [];
 
 function init() {
     initializeTheme();
     populateModels();
     populateVoices();
     setupEventListeners();
+    addFloatingPaws();
+
+    // Randomly select a sample text
+    const textarea = document.getElementById('textInput');
+    if (textarea && !textarea.value) {
+        textarea.placeholder = sampleTexts[Math.floor(Math.random() * sampleTexts.length)];
+    }
+
+    // Load initial stats
+    loadDebugStats();
+}
+
+// Add floating paw decorations
+function addFloatingPaws() {
+    const container = document.querySelector('.container');
+    for (let i = 0; i < 5; i++) {
+        const paw = document.createElement('div');
+        paw.className = 'paw-bg';
+        paw.innerHTML = '🐾';
+        paw.style.left = `${Math.random() * 90}%`;
+        paw.style.top = `${Math.random() * 90}%`;
+        paw.style.animationDelay = `${Math.random() * -20}s`;
+        paw.style.fontSize = `${6 + Math.random() * 6}rem`;
+        document.body.insertBefore(paw, container);
+    }
 }
 
 function initializeTheme() {
@@ -51,42 +87,99 @@ function toggleTheme() {
 
 function populateModels() {
     const select = document.getElementById('modelSelect');
-    select.innerHTML = models.map(m => 
-        `<option value="${m.id}">${m.name} (${m.size}) - ${m.description}</option>`
-    ).join('');
+    select.innerHTML = models.map(m => {
+        const qualityIcon = m.quality === 'best' ? '⭐' : m.quality === 'good' ? '✓' : '○';
+        return `<option value="${m.id}">${qualityIcon} ${m.name} (${m.size}) — ${m.description}</option>`;
+    }).join('');
+
+    // Add change handler to update info display
+    select.addEventListener('change', updateModelInfo);
+    updateModelInfo();
+}
+
+function updateModelInfo() {
+    const select = document.getElementById('modelSelect');
+    const model = models.find(m => m.id === select.value);
+    const infoEl = document.getElementById('modelInfo');
+    if (infoEl && model) {
+        const qualityBadge = model.quality === 'best' ? '⭐ Best Quality' :
+            model.quality === 'good' ? '✓ Good' : '○ Basic';
+        infoEl.textContent = `${model.params} params • ${model.size} • ${model.precision} precision • ${qualityBadge}`;
+    }
 }
 
 function populateVoices() {
     const select = document.getElementById('voiceSelect');
-    select.innerHTML = voices.map(v => 
-        `<option value="${v.id}">${v.name} (${v.gender === 'female' ? '♀' : '♂'}) - ${v.description}</option>`
+    select.innerHTML = voices.map(v =>
+        `<option value="${v.id}">${v.emoji} ${v.name} — ${v.description}</option>`
     ).join('');
+
+    select.addEventListener('change', updateVoiceInfo);
+    updateVoiceInfo();
+}
+
+function updateVoiceInfo() {
+    const select = document.getElementById('voiceSelect');
+    const voice = voices.find(v => v.id === select.value);
+    const infoEl = document.getElementById('voiceInfo');
+    if (infoEl && voice) {
+        const genderEmoji = voice.gender === 'female' ? '♀️' : '♂️';
+        infoEl.textContent = `${genderEmoji} ${voice.gender} voice • ${voice.description}`;
+    }
 }
 
 function setupEventListeners() {
     document.getElementById('themeToggle').addEventListener('click', toggleTheme);
     document.getElementById('speedSlider').addEventListener('input', updateSpeedDisplay);
     document.getElementById('generateBtn').addEventListener('click', handleGenerate);
+
+    // Debug panel toggle
+    const debugToggle = document.getElementById('debugToggle');
+    if (debugToggle) {
+        debugToggle.addEventListener('click', toggleDebugPanel);
+    }
+
+    // Debug refresh button
+    const refreshBtn = document.getElementById('refreshStatsBtn');
+    if (refreshBtn) {
+        refreshBtn.addEventListener('click', loadDebugStats);
+    }
 }
 
 function updateSpeedDisplay() {
     const slider = document.getElementById('speedSlider');
-    document.getElementById('speedValue').textContent = `${slider.value}x`;
+    const value = slider.value;
+    document.getElementById('speedValue').childNodes[0].textContent = `${value}x `;
+
+    // Change emoji based on speed
+    let emoji = '🐱';
+    if (value < 0.8) emoji = '🐢'; // Slow
+    else if (value > 1.5) emoji = '⚡'; // Fast
+    else if (value > 1.2) emoji = '🐇'; // Quick
+
+    const emojiEl = document.getElementById('speedEmoji');
+    if (emojiEl) emojiEl.textContent = emoji;
 }
 
 function showLoading(show) {
     const btn = document.getElementById('generateBtn');
     const btnText = document.getElementById('btnText');
     const spinner = document.getElementById('btnSpinner');
-    
+
     btn.disabled = show;
     btnText.style.display = show ? 'none' : 'inline';
     spinner.style.display = show ? 'inline-block' : 'none';
+
+    if (show) {
+        btn.classList.add('generating');
+    } else {
+        btn.classList.remove('generating');
+    }
 }
 
 function showError(message) {
     const el = document.getElementById('errorMessage');
-    el.textContent = message;
+    el.textContent = '😿 ' + message;
     el.classList.add('visible');
     setTimeout(() => el.classList.remove('visible'), 5000);
 }
@@ -96,17 +189,22 @@ function showOutput(audioBase64, duration) {
     const audio = document.getElementById('audioPlayer');
     const durationEl = document.getElementById('audioDuration');
     const downloadBtn = document.getElementById('downloadBtn');
-    
+
     audio.src = `data:audio/wav;base64,${audioBase64}`;
-    durationEl.textContent = `Duration: ${duration}s`;
-    
+    durationEl.textContent = `⏱️ Duration: ${duration}s`;
+
     const blob = base64ToBlob(audioBase64, 'audio/wav');
     const url = URL.createObjectURL(blob);
     downloadBtn.href = url;
     downloadBtn.download = `kitten-tts-${Date.now()}.wav`;
-    
+
     section.classList.add('visible');
     section.scrollIntoView({ behavior: 'smooth', block: 'nearest' });
+
+    // Auto-play the audio
+    audio.play().catch(() => {
+        // Auto-play blocked, user will need to click
+    });
 }
 
 function base64ToBlob(base64, mimeType) {
@@ -124,35 +222,208 @@ async function handleGenerate() {
     const model = document.getElementById('modelSelect').value;
     const voice = document.getElementById('voiceSelect').value;
     const speed = parseFloat(document.getElementById('speedSlider').value);
-    
+
     if (!text) {
-        showError('Please enter some text to generate speech.');
+        showError('Please enter some text to generate speech! 🐾');
         return;
     }
-    
+
     showLoading(true);
     document.getElementById('errorMessage').classList.remove('visible');
-    
+
     try {
         const response = await fetch('/api/generate', {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
             body: JSON.stringify({ text, model, voice, speed })
         });
-        
+
         const data = await response.json();
-        
+        console.log('Generation response:', data);
+
         if (!response.ok) {
-            throw new Error(data.detail || 'Generation failed');
+            throw new Error(data.detail || 'Generation failed 😿');
         }
-        
+
         showOutput(data.audio_base64, data.duration);
+
+        // Update debug stats if available
+        if (data.debug_info) {
+            console.log('Debug info received:', data.debug_info);
+            updateCurrentStats(data.debug_info);
+        } else {
+            console.log('No debug_info in response');
+        }
+
+        // Refresh session stats
+        await loadDebugStats();
+
+        // Success animation on button
+        const btn = document.getElementById('generateBtn');
+        btn.style.transform = 'scale(0.98)';
+        setTimeout(() => btn.style.transform = '', 200);
+
     } catch (error) {
-        showError(error.message || 'An error occurred during generation.');
+        showError(error.message || 'An error occurred during generation 😿');
         console.error('Generation error:', error);
     } finally {
         showLoading(false);
     }
 }
 
-document.addEventListener('DOMContentLoaded', init);
+// Debug Panel Functions
+function updateCurrentStats(debugInfo) {
+    console.log('Updating current stats:', debugInfo);
+    const modelLoadEl = document.getElementById('statModelLoad');
+    const genTimeEl = document.getElementById('statGenTime');
+    const totalTimeEl = document.getElementById('statTotalTime');
+    const rtfEl = document.getElementById('statRTF');
+
+    if (modelLoadEl) modelLoadEl.textContent = debugInfo.model_load_time ? `${debugInfo.model_load_time}s` : '-';
+    if (genTimeEl) genTimeEl.textContent = debugInfo.generation_time ? `${debugInfo.generation_time}s` : '-';
+    if (totalTimeEl) totalTimeEl.textContent = debugInfo.total_time ? `${debugInfo.total_time}s` : '-';
+    if (rtfEl) rtfEl.textContent = debugInfo.real_time_factor || '-';
+}
+
+async function loadDebugStats() {
+    try {
+        console.log('Loading debug stats...');
+        const response = await fetch('/api/stats');
+        if (!response.ok) {
+            console.error('Stats fetch failed:', response.status);
+            return;
+        }
+
+        const data = await response.json();
+        console.log('Stats received:', data);
+
+        // Update session stats
+        if (data.generation_stats) {
+            const sessionRequests = document.getElementById('sessionRequests');
+            const sessionAvgGen = document.getElementById('sessionAvgGen');
+            const sessionAvgRTF = document.getElementById('sessionAvgRTF');
+            const sessionAudio = document.getElementById('sessionAudio');
+
+            if (sessionRequests) sessionRequests.textContent = data.generation_stats.total_requests || 0;
+            if (sessionAvgGen) sessionAvgGen.textContent = `${data.generation_stats.avg_generation_time || 0}s`;
+            if (sessionAvgRTF) sessionAvgRTF.textContent = data.generation_stats.avg_rtf || 0;
+            if (sessionAudio) sessionAudio.textContent = `${data.generation_stats.total_audio_generated || 0}s`;
+        }
+
+        // Update system info
+        if (data.system) {
+            const systemInfoEl = document.getElementById('systemInfo');
+            if (systemInfoEl) {
+                systemInfoEl.innerHTML = `
+                    <div class="debug-info-item">
+                        <span class="debug-info-key">Cache Directory</span>
+                        <span class="debug-info-value">${data.system.cache_directory || 'N/A'}</span>
+                    </div>
+                    <div class="debug-info-item">
+                        <span class="debug-info-key">Cache Size</span>
+                        <span class="debug-info-value">${data.system.cache_size_mb || 0} MB</span>
+                    </div>
+                    <div class="debug-info-item">
+                        <span class="debug-info-key">Memory Usage</span>
+                        <span class="debug-info-value">${data.system.memory_usage_mb || 'N/A'} MB</span>
+                    </div>
+                    <div class="debug-info-item">
+                        <span class="debug-info-key">Python Version</span>
+                        <span class="debug-info-value">${data.system.python_version || 'N/A'}</span>
+                    </div>
+                    <div class="debug-info-item">
+                        <span class="debug-info-key">Loaded Models</span>
+                        <span class="debug-info-value">${(data.system.loaded_models || []).join(', ') || 'None'}</span>
+                    </div>
+                `;
+            }
+        }
+
+        // Update recent requests
+        const requestsEl = document.getElementById('recentRequests');
+        if (requestsEl && data.generation_stats && data.generation_stats.recent_requests) {
+            if (data.generation_stats.recent_requests.length === 0) {
+                requestsEl.innerHTML = '<div class="debug-request-item">No recent generations</div>';
+            } else {
+                requestsEl.innerHTML = data.generation_stats.recent_requests.map(req => `
+                    <div class="debug-request-item">
+                        <span class="debug-request-model">${req.model || '?'}</span>
+                        <span class="debug-request-voice">${req.voice || '?'}</span>
+                        <span class="debug-request-time">${req.generation_time || 0}s</span>
+                        <span class="debug-request-rtf">RTF: ${req.rtf || 0}</span>
+                    </div>
+                `).join('');
+            }
+        }
+        console.log('Debug stats updated successfully');
+    } catch (error) {
+        console.error('Failed to load debug stats:', error);
+    }
+}
+
+function toggleDebugPanel() {
+    const panel = document.getElementById('debugPanel');
+    const content = document.getElementById('debugContent');
+
+    console.log('Toggling debug panel');
+    if (content.style.display === 'none') {
+        content.style.display = 'block';
+        panel.classList.add('expanded');
+        loadDebugStats();
+    } else {
+        content.style.display = 'none';
+        panel.classList.remove('expanded');
+    }
+}
+
+// Easter egg: Meow on logo click
+document.addEventListener('DOMContentLoaded', () => {
+    init();
+
+    const logoIcon = document.querySelector('.logo-icon');
+    if (logoIcon) {
+        logoIcon.addEventListener('click', () => {
+            // Visual feedback
+            logoIcon.style.transform = 'scale(1.1) rotate(-10deg)';
+            setTimeout(() => {
+                logoIcon.style.transform = '';
+            }, 300);
+
+            // Create a cute popup
+            const popup = document.createElement('div');
+            popup.textContent = 'Meow! 🐱';
+            popup.style.cssText = `
+                position: fixed;
+                top: 100px;
+                left: 50%;
+                transform: translateX(-50%);
+                background: linear-gradient(135deg, var(--accent-primary), var(--accent-secondary));
+                color: white;
+                padding: 0.75rem 1.5rem;
+                border-radius: 9999px;
+                font-weight: 600;
+                font-size: 1rem;
+                box-shadow: 0 4px 12px rgba(232, 146, 160, 0.4);
+                z-index: 1000;
+                animation: popIn 0.3s ease, fadeOut 0.3s ease 1s forwards;
+                pointer-events: none;
+            `;
+            document.body.appendChild(popup);
+            setTimeout(() => popup.remove(), 1500);
+        });
+    }
+});
+
+// Add popIn animation
+const style = document.createElement('style');
+style.textContent = `
+    @keyframes popIn {
+        from { opacity: 0; transform: translateX(-50%) scale(0.8) translateY(10px); }
+        to { opacity: 1; transform: translateX(-50%) scale(1) translateY(0); }
+    }
+    @keyframes fadeOut {
+        from { opacity: 1; transform: translateX(-50%) scale(1); }
+        to { opacity: 0; transform: translateX(-50%) scale(0.8) translateY(-10px); }
+    }
+`;
+document.head.appendChild(style);
diff --git a/webui/static/favicon.svg b/webui/static/favicon.svg
index 8b0284b..63b36b1 100644
--- a/webui/static/favicon.svg
+++ b/webui/static/favicon.svg
@@ -1,16 +1,51 @@
 <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64">
   <defs>
     <linearGradient id="grad" x1="0%" y1="0%" x2="100%" y2="100%">
-      <stop offset="0%" style="stop-color:#e8a87c;stop-opacity:1" />
-      <stop offset="100%" style="stop-color:#d4956a;stop-opacity:1" />
+      <stop offset="0%" style="stop-color:#e892a0;stop-opacity:1" />
+      <stop offset="100%" style="stop-color:#d67b8a;stop-opacity:1" />
+    </linearGradient>
+    <linearGradient id="earGrad" x1="0%" y1="0%" x2="0%" y2="100%">
+      <stop offset="0%" style="stop-color:#f0a0b0;stop-opacity:1" />
+      <stop offset="100%" style="stop-color:#e892a0;stop-opacity:1" />
     </linearGradient>
   </defs>
-  <circle cx="32" cy="32" r="30" fill="url(#grad)"/>
+  
+  <!-- Main circle -->
+  <circle cx="32" cy="34" r="26" fill="url(#grad)"/>
+  
+  <!-- Ears -->
+  <path d="M12 22 L18 6 L28 16 Z" fill="url(#earGrad)"/>
+  <path d="M52 22 L46 6 L36 16 Z" fill="url(#earGrad)"/>
+  
+  <!-- Inner ears -->
+  <path d="M16 18 L19 10 L24 16 Z" fill="#fce8eb"/>
+  <path d="M48 18 L45 10 L40 16 Z" fill="#fce8eb"/>
+  
+  <!-- Heart eyes -->
   <g fill="#fff">
-    <ellipse cx="22" cy="22" rx="6" ry="8"/>
-    <ellipse cx="42" cy="22" rx="6" ry="8"/>
-    <ellipse cx="16" cy="36" rx="5" ry="7"/>
-    <ellipse cx="48" cy="36" rx="5" ry="7"/>
-    <ellipse cx="32" cy="42" rx="10" ry="8"/>
+    <!-- Left heart eye -->
+    <path d="M20 28 C18 26, 14 26, 14 30 C14 33, 20 38, 20 38 C20 38, 26 33, 26 30 C26 26, 22 26, 20 28 Z"/>
+    <!-- Right heart eye -->
+    <path d="M44 28 C42 26, 38 26, 38 30 C38 33, 44 38, 44 38 C44 38, 50 33, 50 30 C50 26, 46 26, 44 28 Z"/>
+  </g>
+  
+  <!-- Nose -->
+  <ellipse cx="32" cy="42" rx="4" ry="3" fill="#fce8eb"/>
+  
+  <!-- Mouth -->
+  <path d="M28 46 Q32 50 36 46" fill="none" stroke="#fce8eb" stroke-width="2" stroke-linecap="round"/>
+  
+  <!-- Whiskers -->
+  <g stroke="#fce8eb" stroke-width="1.5" stroke-linecap="round" opacity="0.6">
+    <line x1="12" y1="40" x2="22" y2="42"/>
+    <line x1="10" y1="44" x2="22" y2="44"/>
+    <line x1="52" y1="40" x2="42" y2="42"/>
+    <line x1="54" y1="44" x2="42" y2="44"/>
   </g>
+  
+  <!-- Paws peeking from bottom -->
+  <ellipse cx="18" cy="56" rx="6" ry="5" fill="url(#grad)"/>
+  <ellipse cx="46" cy="56" rx="6" ry="5" fill="url(#grad)"/>
+  <ellipse cx="18" cy="56" rx="3" ry="2" fill="#fce8eb"/>
+  <ellipse cx="46" cy="56" rx="3" ry="2" fill="#fce8eb"/>
 </svg>
diff --git a/webui/static/icon.png b/webui/static/icon.png
new file mode 100644
index 0000000000000000000000000000000000000000..fc7499a19c9897bd921880be844686b1076e1be7
GIT binary patch
literal 59185
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
R>t6h0X*SRFn8YLO{{h(s^<n@3

literal 0
HcmV?d00001

diff --git a/webui/static/style.css b/webui/static/style.css
index 0ae504d..7e8a091 100644
--- a/webui/static/style.css
+++ b/webui/static/style.css
@@ -1,37 +1,67 @@
+/* KittenTTS - Cute Kitten Theme 🐱 */
+/* Inspired by the GitHub repo design */
+
 :root {
-    --bg-primary: #faf8f5;
+    /* Soft kitten color palette */
+    --bg-primary: #faf7f5;
     --bg-secondary: #ffffff;
-    --bg-tertiary: #f5f0e8;
-    --text-primary: #2d2a26;
-    --text-secondary: #6b6560;
-    --text-muted: #9a9590;
-    --accent-primary: #e8a87c;
-    --accent-secondary: #d4956a;
-    --accent-light: #f5d5c0;
-    --border-color: #e8e0d5;
-    --shadow-sm: 0 2px 4px rgba(45, 42, 38, 0.05);
-    --shadow-md: 0 4px 12px rgba(45, 42, 38, 0.08);
-    --shadow-lg: 0 8px 24px rgba(45, 42, 38, 0.12);
-    --radius-sm: 8px;
-    --radius-md: 12px;
-    --radius-lg: 20px;
-    --transition: 0.2s ease;
+    --bg-tertiary: #f5f0ed;
+    --bg-card: #fff9f7;
+
+    --text-primary: #2d2a35;
+    --text-secondary: #6b6570;
+    --text-muted: #9a959f;
+    --text-accent: #8b5a6b;
+
+    /* Soft pink/lavender accents */
+    --accent-primary: #e892a0;
+    --accent-secondary: #d67b8a;
+    --accent-light: #fce8eb;
+    --accent-lavender: #c9b8d4;
+    --accent-lavender-light: #f0e8f5;
+
+    --border-color: #ebe5e0;
+    --border-accent: #f0d5da;
+
+    --shadow-sm: 0 2px 8px rgba(139, 90, 107, 0.06);
+    --shadow-md: 0 4px 16px rgba(139, 90, 107, 0.1);
+    --shadow-lg: 0 8px 32px rgba(139, 90, 107, 0.14);
+    --shadow-glow: 0 0 20px rgba(232, 146, 160, 0.3);
+
+    --radius-sm: 12px;
+    --radius-md: 16px;
+    --radius-lg: 24px;
+    --radius-xl: 32px;
+    --radius-full: 9999px;
+
+    --transition: 0.25s cubic-bezier(0.4, 0, 0.2, 1);
+    --transition-bounce: 0.4s cubic-bezier(0.68, -0.55, 0.265, 1.55);
 }
 
 [data-theme="dark"] {
-    --bg-primary: #1a1815;
-    --bg-secondary: #252220;
-    --bg-tertiary: #2d2a26;
-    --text-primary: #f5f0e8;
-    --text-secondary: #b5ada0;
-    --text-muted: #7a7570;
-    --accent-primary: #e8a87c;
-    --accent-secondary: #f0b88c;
-    --accent-light: #3d3530;
-    --border-color: #3d3835;
-    --shadow-sm: 0 2px 4px rgba(0, 0, 0, 0.2);
-    --shadow-md: 0 4px 12px rgba(0, 0, 0, 0.25);
-    --shadow-lg: 0 8px 24px rgba(0, 0, 0, 0.35);
+    --bg-primary: #1a1820;
+    --bg-secondary: #252230;
+    --bg-tertiary: #2d2a38;
+    --bg-card: #2a2733;
+
+    --text-primary: #f5f0f7;
+    --text-secondary: #b5adb8;
+    --text-muted: #7a7580;
+    --text-accent: #e8b8c8;
+
+    --accent-primary: #e892a0;
+    --accent-secondary: #f0a0b0;
+    --accent-light: #3d3035;
+    --accent-lavender: #8b7a9a;
+    --accent-lavender-light: #3d3545;
+
+    --border-color: #3d3845;
+    --border-accent: #4d3842;
+
+    --shadow-sm: 0 2px 8px rgba(0, 0, 0, 0.25);
+    --shadow-md: 0 4px 16px rgba(0, 0, 0, 0.35);
+    --shadow-lg: 0 8px 32px rgba(0, 0, 0, 0.45);
+    --shadow-glow: 0 0 30px rgba(232, 146, 160, 0.2);
 }
 
 * {
@@ -41,7 +71,9 @@
 }
 
 html {
-    font-size: 16px;
+    font-size: 22.4px;
+    /* 16px * 1.4 = 22.4px for 140% scale */
+    scroll-behavior: smooth;
 }
 
 body {
@@ -49,126 +81,266 @@ body {
     background: var(--bg-primary);
     color: var(--text-primary);
     min-height: 100vh;
-    line-height: 1.5;
+    line-height: 1.6;
     transition: background var(--transition), color var(--transition);
+    overflow-x: hidden;
+}
+
+/* Floating paw background decorations */
+.paw-bg {
+    position: fixed;
+    pointer-events: none;
+    opacity: 0.04;
+    font-size: 8rem;
+    z-index: 0;
+    animation: float 20s ease-in-out infinite;
+    color: #8b5a6b;
+    /* Pink-ish color for light mode */
+}
+
+/* Dark mode paw colors - more visible */
+[data-theme="dark"] .paw-bg {
+    opacity: 0.15;
+    color: #e892a0;
+    /* Accent pink color for better visibility */
+}
+
+.paw-bg:nth-child(1) {
+    top: 5%;
+    left: 5%;
+    animation-delay: 0s;
+}
+
+.paw-bg:nth-child(2) {
+    top: 20%;
+    right: 8%;
+    animation-delay: -5s;
+}
+
+.paw-bg:nth-child(3) {
+    top: 50%;
+    left: 3%;
+    animation-delay: -10s;
+}
+
+.paw-bg:nth-child(4) {
+    bottom: 20%;
+    right: 5%;
+    animation-delay: -15s;
+}
+
+.paw-bg:nth-child(5) {
+    bottom: 10%;
+    left: 15%;
+    animation-delay: -7s;
+}
+
+@keyframes float {
+
+    0%,
+    100% {
+        transform: translateY(0) rotate(0deg);
+    }
+
+    50% {
+        transform: translateY(-20px) rotate(5deg);
+    }
 }
 
 .container {
-    max-width: 800px;
+    position: relative;
+    z-index: 1;
+    max-width: 1600px;
     margin: 0 auto;
-    padding: 2rem 1.5rem;
+    padding: 2rem 3rem;
+    width: 95%;
 }
 
+/* Header with cute logo */
 header {
     display: flex;
     align-items: center;
     justify-content: space-between;
-    margin-bottom: 2.5rem;
+    margin-bottom: 2rem;
     padding-bottom: 1.5rem;
-    border-bottom: 1px solid var(--border-color);
+    border-bottom: 2px dashed var(--border-color);
 }
 
 .logo {
     display: flex;
     align-items: center;
-    gap: 0.75rem;
+    gap: 1rem;
 }
 
 .logo-icon {
-    width: 48px;
-    height: 48px;
+    width: 64px;
+    height: 64px;
     background: linear-gradient(135deg, var(--accent-primary), var(--accent-secondary));
-    border-radius: var(--radius-md);
+    border-radius: var(--radius-lg);
     display: flex;
     align-items: center;
     justify-content: center;
-    font-size: 1.5rem;
-    box-shadow: var(--shadow-md);
+    box-shadow: var(--shadow-md), var(--shadow-glow);
+    transition: transform var(--transition-bounce);
+    position: relative;
+    overflow: hidden;
+}
+
+.logo-icon::before {
+    content: '';
+    position: absolute;
+    inset: 0;
+    background: linear-gradient(135deg, transparent 40%, rgba(255, 255, 255, 0.3) 50%, transparent 60%);
+    animation: shimmer 3s infinite;
+}
+
+@keyframes shimmer {
+    0% {
+        transform: translateX(-100%);
+    }
+
+    100% {
+        transform: translateX(100%);
+    }
+}
+
+.logo-icon:hover {
+    transform: scale(1.05) rotate(-3deg);
+}
+
+.logo-icon svg {
+    width: 44px;
+    height: 44px;
+    filter: drop-shadow(0 2px 4px rgba(0, 0, 0, 0.1));
 }
 
 .logo-text h1 {
-    font-size: 1.5rem;
-    font-weight: 700;
-    letter-spacing: -0.02em;
-    background: linear-gradient(135deg, var(--accent-primary), var(--accent-secondary));
+    font-size: 1.75rem;
+    font-weight: 800;
+    letter-spacing: -0.03em;
+    background: linear-gradient(135deg, var(--accent-primary), var(--accent-lavender), var(--accent-secondary));
+    background-size: 200% 200%;
     -webkit-background-clip: text;
     -webkit-text-fill-color: transparent;
     background-clip: text;
+    animation: gradient 5s ease infinite;
 }
 
-.logo-text span {
-    font-size: 0.75rem;
+@keyframes gradient {
+
+    0%,
+    100% {
+        background-position: 0% 50%;
+    }
+
+    50% {
+        background-position: 100% 50%;
+    }
+}
+
+.logo-text .tagline {
+    font-size: 0.8rem;
     color: var(--text-muted);
     font-weight: 500;
-    letter-spacing: 0.05em;
-    text-transform: uppercase;
+    letter-spacing: 0.08em;
+    margin-top: 0.25rem;
 }
 
 .theme-toggle {
-    width: 44px;
-    height: 44px;
-    border: 1px solid var(--border-color);
-    border-radius: var(--radius-md);
+    width: 48px;
+    height: 48px;
+    border: 2px solid var(--border-color);
+    border-radius: var(--radius-full);
     background: var(--bg-secondary);
     cursor: pointer;
     display: flex;
     align-items: center;
     justify-content: center;
     font-size: 1.25rem;
-    transition: all var(--transition);
+    transition: all var(--transition-bounce);
     color: var(--text-secondary);
+    position: relative;
 }
 
 .theme-toggle:hover {
-    background: var(--bg-tertiary);
+    background: var(--accent-light);
     border-color: var(--accent-primary);
-    color: var(--accent-primary);
+    color: var(--accent-secondary);
+    transform: scale(1.1) rotate(15deg);
+}
+
+.theme-toggle:active {
+    transform: scale(0.95);
 }
 
+/* Main content */
 main {
     display: flex;
     flex-direction: column;
-    gap: 1.5rem;
+    gap: 1.25rem;
 }
 
+/* Cards with cute styling */
 .card {
     background: var(--bg-secondary);
-    border: 1px solid var(--border-color);
+    border: 2px solid var(--border-color);
     border-radius: var(--radius-lg);
     padding: 1.5rem;
     box-shadow: var(--shadow-sm);
     transition: all var(--transition);
+    position: relative;
+}
+
+.card::before {
+    content: '';
+    position: absolute;
+    top: 0;
+    left: 1.5rem;
+    right: 1.5rem;
+    height: 3px;
+    background: linear-gradient(90deg, var(--accent-primary), var(--accent-lavender), var(--accent-primary));
+    border-radius: 0 0 4px 4px;
+    opacity: 0;
+    transition: opacity var(--transition);
 }
 
 .card:hover {
     box-shadow: var(--shadow-md);
+    border-color: var(--border-accent);
+}
+
+.card:hover::before {
+    opacity: 1;
 }
 
 .card-header {
     display: flex;
     align-items: center;
-    gap: 0.5rem;
-    margin-bottom: 1rem;
+    gap: 0.75rem;
+    margin-bottom: 1.25rem;
     padding-bottom: 0.75rem;
-    border-bottom: 1px solid var(--border-color);
+    border-bottom: 1px dashed var(--border-color);
 }
 
-.card-header h2 {
-    font-size: 0.875rem;
-    font-weight: 600;
-    text-transform: uppercase;
-    letter-spacing: 0.05em;
-    color: var(--text-secondary);
+.card-header-icon {
+    width: 32px;
+    height: 32px;
+    background: var(--accent-light);
+    border-radius: var(--radius-md);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-size: 1rem;
 }
 
-.card-header::before {
-    content: "";
-    width: 4px;
-    height: 16px;
-    background: linear-gradient(180deg, var(--accent-primary), var(--accent-secondary));
-    border-radius: 2px;
+.card-header h2 {
+    font-size: 0.9375rem;
+    font-weight: 700;
+    letter-spacing: 0.02em;
+    color: var(--text-accent);
 }
 
+/* Form elements */
 .form-group {
     margin-bottom: 1.25rem;
 }
@@ -178,82 +350,88 @@ main {
 }
 
 label {
-    display: block;
+    display: flex;
+    align-items: center;
+    gap: 0.375rem;
     font-size: 0.8125rem;
-    font-weight: 500;
+    font-weight: 600;
     color: var(--text-secondary);
-    margin-bottom: 0.5rem;
+    margin-bottom: 0.625rem;
 }
 
-select, input[type="range"] {
+label .label-icon {
+    font-size: 0.875rem;
+}
+
+select,
+input[type="range"] {
     width: 100%;
 }
 
 select {
     appearance: none;
     background: var(--bg-tertiary);
-    border: 1px solid var(--border-color);
-    border-radius: var(--radius-sm);
-    padding: 0.75rem 2.5rem 0.75rem 1rem;
+    border: 2px solid var(--border-color);
+    border-radius: var(--radius-md);
+    padding: 0.875rem 2.75rem 0.875rem 1rem;
     font-size: 0.9375rem;
     font-weight: 500;
     color: var(--text-primary);
     cursor: pointer;
-    background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='16' height='16' viewBox='0 0 24 24' fill='none' stroke='%236b6560' stroke-width='2' stroke-linecap='round' stroke-linejoin='round'%3E%3Cpath d='m6 9 6 6 6-6'/%3E%3C/svg%3E");
+    background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='18' height='18' viewBox='0 0 24 24' fill='none' stroke='%23e892a0' stroke-width='2.5' stroke-linecap='round' stroke-linejoin='round'%3E%3Cpath d='m6 9 6 6 6-6'/%3E%3C/svg%3E");
     background-repeat: no-repeat;
-    background-position: right 0.75rem center;
+    background-position: right 1rem center;
     transition: all var(--transition);
 }
 
 select:hover {
     border-color: var(--accent-primary);
+    background-color: var(--bg-card);
 }
 
 select:focus {
     outline: none;
     border-color: var(--accent-primary);
-    box-shadow: 0 0 0 3px var(--accent-light);
+    box-shadow: 0 0 0 4px var(--accent-light);
 }
 
-textarea {
-    width: 100%;
-    min-height: 150px;
-    background: var(--bg-tertiary);
-    border: 1px solid var(--border-color);
-    border-radius: var(--radius-sm);
-    padding: 1rem;
-    font-size: 0.9375rem;
-    font-family: inherit;
-    color: var(--text-primary);
-    resize: vertical;
-    transition: all var(--transition);
-    line-height: 1.6;
+.settings-row {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(280px, 1fr));
+    gap: 1.5rem;
 }
 
-textarea::placeholder {
-    color: var(--text-muted);
+/* Voice selector with avatars */
+.voice-select-wrapper {
+    position: relative;
 }
 
-textarea:hover {
-    border-color: var(--accent-primary);
+.voice-avatar {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    width: 20px;
+    height: 20px;
+    border-radius: 50%;
+    font-size: 0.75rem;
+    margin-right: 0.5rem;
 }
 
-textarea:focus {
-    outline: none;
-    border-color: var(--accent-primary);
-    box-shadow: 0 0 0 3px var(--accent-light);
+.voice-avatar.female {
+    background: var(--accent-light);
+    color: var(--accent-secondary);
 }
 
-.settings-row {
-    display: grid;
-    grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
-    gap: 1.25rem;
+.voice-avatar.male {
+    background: var(--accent-lavender-light);
+    color: var(--accent-lavender);
 }
 
+/* Speed slider with cute styling */
 .speed-container {
     display: flex;
     flex-direction: column;
-    gap: 0.5rem;
+    gap: 0.625rem;
 }
 
 .speed-header {
@@ -264,122 +442,207 @@ textarea:focus {
 
 .speed-value {
     font-size: 0.875rem;
-    font-weight: 600;
-    color: var(--accent-primary);
-    background: var(--accent-light);
-    padding: 0.25rem 0.75rem;
-    border-radius: var(--radius-sm);
+    font-weight: 700;
+    color: var(--accent-secondary);
+    background: linear-gradient(135deg, var(--accent-light), var(--bg-card));
+    padding: 0.375rem 1rem;
+    border-radius: var(--radius-full);
+    border: 1px solid var(--border-accent);
+    transition: all var(--transition);
+}
+
+.speed-value:hover {
+    transform: scale(1.05);
 }
 
 input[type="range"] {
     -webkit-appearance: none;
     appearance: none;
-    height: 6px;
-    background: var(--bg-tertiary);
-    border-radius: 3px;
+    height: 8px;
+    background: linear-gradient(90deg, var(--bg-tertiary), var(--accent-light));
+    border-radius: var(--radius-full);
     cursor: pointer;
+    border: 1px solid var(--border-color);
 }
 
 input[type="range"]::-webkit-slider-thumb {
     -webkit-appearance: none;
     appearance: none;
-    width: 20px;
-    height: 20px;
+    width: 24px;
+    height: 24px;
     background: linear-gradient(135deg, var(--accent-primary), var(--accent-secondary));
     border-radius: 50%;
     cursor: pointer;
-    box-shadow: var(--shadow-sm);
-    transition: transform var(--transition);
+    box-shadow: var(--shadow-sm), 0 0 10px rgba(232, 146, 160, 0.4);
+    transition: all var(--transition-bounce);
+    border: 3px solid white;
 }
 
 input[type="range"]::-webkit-slider-thumb:hover {
-    transform: scale(1.1);
+    transform: scale(1.2);
+    box-shadow: var(--shadow-md), 0 0 15px rgba(232, 146, 160, 0.6);
 }
 
 input[type="range"]::-moz-range-thumb {
-    width: 20px;
-    height: 20px;
+    width: 24px;
+    height: 24px;
     background: linear-gradient(135deg, var(--accent-primary), var(--accent-secondary));
     border-radius: 50%;
     cursor: pointer;
-    border: none;
+    border: 3px solid white;
     box-shadow: var(--shadow-sm);
 }
 
-.voice-select option {
-    padding: 0.5rem;
+/* Textarea with cute styling */
+textarea {
+    width: 100%;
+    min-height: 140px;
+    background: var(--bg-tertiary);
+    border: 2px solid var(--border-color);
+    border-radius: var(--radius-md);
+    padding: 1.125rem;
+    font-size: 0.9375rem;
+    font-family: inherit;
+    color: var(--text-primary);
+    resize: vertical;
+    transition: all var(--transition);
+    line-height: 1.7;
+}
+
+textarea::placeholder {
+    color: var(--text-muted);
+    font-style: italic;
+}
+
+textarea:hover {
+    border-color: var(--accent-primary);
+    background: var(--bg-card);
+}
+
+textarea:focus {
+    outline: none;
+    border-color: var(--accent-primary);
+    box-shadow: 0 0 0 4px var(--accent-light);
 }
 
+/* Generate button - the star of the show! */
 .generate-btn {
     width: 100%;
-    padding: 1rem 2rem;
+    padding: 1.125rem 2rem;
     background: linear-gradient(135deg, var(--accent-primary), var(--accent-secondary));
     border: none;
     border-radius: var(--radius-md);
-    font-size: 1rem;
-    font-weight: 600;
+    font-size: 1.0625rem;
+    font-weight: 700;
     color: white;
     cursor: pointer;
-    transition: all var(--transition);
+    transition: all var(--transition-bounce);
     display: flex;
     align-items: center;
     justify-content: center;
-    gap: 0.5rem;
-    box-shadow: var(--shadow-md);
+    gap: 0.625rem;
+    box-shadow: var(--shadow-md), 0 4px 0 #c96b7a;
+    position: relative;
+    overflow: hidden;
+    text-shadow: 0 1px 2px rgba(0, 0, 0, 0.1);
+}
+
+.generate-btn::before {
+    content: '';
+    position: absolute;
+    inset: 0;
+    background: linear-gradient(135deg, rgba(255, 255, 255, 0.2), transparent);
+    opacity: 0;
+    transition: opacity var(--transition);
 }
 
 .generate-btn:hover:not(:disabled) {
-    transform: translateY(-2px);
-    box-shadow: var(--shadow-lg);
+    transform: translateY(-3px);
+    box-shadow: var(--shadow-lg), 0 7px 0 #c96b7a, var(--shadow-glow);
+}
+
+.generate-btn:hover::before {
+    opacity: 1;
 }
 
 .generate-btn:active:not(:disabled) {
-    transform: translateY(0);
+    transform: translateY(2px);
+    box-shadow: var(--shadow-sm), 0 2px 0 #c96b7a;
 }
 
 .generate-btn:disabled {
     opacity: 0.7;
     cursor: not-allowed;
+    box-shadow: var(--shadow-sm);
+    transform: none;
+}
+
+.generate-btn .btn-icon {
+    font-size: 1.25rem;
+    animation: wiggle 2s ease-in-out infinite;
+}
+
+@keyframes wiggle {
+
+    0%,
+    100% {
+        transform: rotate(-3deg);
+    }
+
+    50% {
+        transform: rotate(3deg);
+    }
+}
+
+.generate-btn:disabled .btn-icon {
+    animation: none;
 }
 
 .generate-btn .spinner {
-    width: 20px;
-    height: 20px;
-    border: 2px solid rgba(255, 255, 255, 0.3);
+    width: 22px;
+    height: 22px;
+    border: 3px solid rgba(255, 255, 255, 0.3);
     border-top-color: white;
     border-radius: 50%;
     animation: spin 0.8s linear infinite;
 }
 
 @keyframes spin {
-    to { transform: rotate(360deg); }
+    to {
+        transform: rotate(360deg);
+    }
 }
 
+/* Output section */
 .output-section {
     display: none;
+    border-color: var(--accent-lavender);
+    background: linear-gradient(135deg, var(--bg-secondary), var(--accent-lavender-light));
 }
 
 .output-section.visible {
     display: block;
-    animation: fadeIn 0.3s ease;
+    animation: slideUp 0.4s var(--transition-bounce);
 }
 
-@keyframes fadeIn {
+@keyframes slideUp {
     from {
         opacity: 0;
-        transform: translateY(10px);
+        transform: translateY(20px) scale(0.98);
     }
+
     to {
         opacity: 1;
-        transform: translateY(0);
+        transform: translateY(0) scale(1);
     }
 }
 
 .audio-player {
-    background: var(--bg-tertiary);
+    background: var(--bg-secondary);
     border-radius: var(--radius-md);
-    padding: 1rem;
+    padding: 1.25rem;
     margin-bottom: 1rem;
+    border: 1px solid var(--border-color);
 }
 
 .audio-player audio {
@@ -392,7 +655,9 @@ input[type="range"]::-moz-range-thumb {
     display: flex;
     justify-content: space-between;
     align-items: center;
-    margin-top: 0.75rem;
+    margin-top: 1rem;
+    padding-top: 1rem;
+    border-top: 1px dashed var(--border-color);
     font-size: 0.8125rem;
     color: var(--text-muted);
 }
@@ -400,38 +665,41 @@ input[type="range"]::-moz-range-thumb {
 .download-btn {
     display: inline-flex;
     align-items: center;
-    gap: 0.375rem;
-    padding: 0.5rem 1rem;
-    background: var(--bg-secondary);
-    border: 1px solid var(--border-color);
-    border-radius: var(--radius-sm);
+    gap: 0.5rem;
+    padding: 0.625rem 1.25rem;
+    background: var(--bg-tertiary);
+    border: 2px solid var(--border-color);
+    border-radius: var(--radius-full);
     font-size: 0.8125rem;
-    font-weight: 500;
+    font-weight: 600;
     color: var(--text-secondary);
     cursor: pointer;
     text-decoration: none;
-    transition: all var(--transition);
+    transition: all var(--transition-bounce);
 }
 
 .download-btn:hover {
     background: var(--accent-light);
     border-color: var(--accent-primary);
-    color: var(--accent-primary);
+    color: var(--accent-secondary);
+    transform: translateY(-2px);
 }
 
+/* Error message */
 .error-message {
-    background: #fee2e2;
-    border: 1px solid #fecaca;
+    background: linear-gradient(135deg, #fee2e2, #fef2f2);
+    border: 2px solid #fecaca;
     border-radius: var(--radius-md);
-    padding: 1rem;
+    padding: 1.125rem;
     color: #dc2626;
     font-size: 0.875rem;
-    margin-bottom: 1rem;
+    font-weight: 500;
     display: none;
+    animation: shake 0.5s ease;
 }
 
 [data-theme="dark"] .error-message {
-    background: #3f1f1f;
+    background: linear-gradient(135deg, #3f1f25, #2d1a1f);
     border-color: #5c2626;
     color: #fca5a5;
 }
@@ -440,11 +708,28 @@ input[type="range"]::-moz-range-thumb {
     display: block;
 }
 
+@keyframes shake {
+
+    0%,
+    100% {
+        transform: translateX(0);
+    }
+
+    25% {
+        transform: translateX(-5px);
+    }
+
+    75% {
+        transform: translateX(5px);
+    }
+}
+
+/* Footer */
 footer {
     text-align: center;
     margin-top: 2.5rem;
     padding-top: 1.5rem;
-    border-top: 1px solid var(--border-color);
+    border-top: 2px dashed var(--border-color);
     color: var(--text-muted);
     font-size: 0.8125rem;
 }
@@ -452,75 +737,348 @@ footer {
 footer a {
     color: var(--accent-primary);
     text-decoration: none;
-    font-weight: 500;
+    font-weight: 600;
+    transition: all var(--transition);
 }
 
 footer a:hover {
+    color: var(--accent-secondary);
     text-decoration: underline;
+    text-underline-offset: 3px;
+}
+
+footer .heart {
+    color: var(--accent-primary);
+    display: inline-block;
+    animation: heartbeat 1.5s ease-in-out infinite;
 }
 
+@keyframes heartbeat {
+
+    0%,
+    100% {
+        transform: scale(1);
+    }
+
+    50% {
+        transform: scale(1.15);
+    }
+}
+
+/* Bottom paw decoration */
 .paw-decoration {
     display: flex;
     justify-content: center;
-    gap: 1rem;
+    gap: 1.5rem;
     margin: 1.5rem 0;
-    opacity: 0.15;
+    opacity: 0.12;
 }
 
 .paw-decoration span {
-    font-size: 1.5rem;
+    font-size: 1.75rem;
+    animation: pawWalk 2s ease-in-out infinite;
+}
+
+.paw-decoration span:nth-child(2) {
+    animation-delay: 0.2s;
+}
+
+.paw-decoration span:nth-child(3) {
+    animation-delay: 0.4s;
+}
+
+@keyframes pawWalk {
+
+    0%,
+    100% {
+        transform: translateY(0);
+    }
+
+    50% {
+        transform: translateY(-8px);
+    }
 }
 
+/* Model & Voice info */
+.model-info,
 .voice-description {
     font-size: 0.75rem;
     color: var(--text-muted);
-    margin-top: 0.25rem;
+    margin-top: 0.375rem;
+    display: flex;
+    align-items: center;
+    gap: 0.375rem;
+}
+
+.model-info::before {
+    content: '📦';
+}
+
+.voice-description::before {
+    content: '🔊';
+}
+
+/* Quick actions */
+.quick-actions {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 0.5rem;
+    margin-top: 0.75rem;
+}
+
+.quick-action-btn {
+    padding: 0.375rem 0.875rem;
+    background: var(--bg-tertiary);
+    border: 1px solid var(--border-color);
+    border-radius: var(--radius-full);
+    font-size: 0.75rem;
+    font-weight: 500;
+    color: var(--text-secondary);
+    cursor: pointer;
+    transition: all var(--transition);
+}
+
+.quick-action-btn:hover {
+    background: var(--accent-light);
+    border-color: var(--accent-primary);
+    color: var(--accent-secondary);
+    transform: translateY(-1px);
+}
+
+/* Debug Panel */
+.debug-panel {
+    border-color: var(--accent-lavender);
+    background: linear-gradient(135deg, var(--bg-secondary), var(--accent-lavender-light));
+}
+
+.debug-header {
+    cursor: pointer;
+    user-select: none;
+    transition: all var(--transition);
+}
+
+.debug-header:hover {
+    color: var(--accent-lavender);
+}
+
+.debug-arrow {
+    margin-left: auto;
+    transition: transform var(--transition);
+    font-size: 0.875rem;
+}
+
+.debug-panel.expanded .debug-arrow {
+    transform: rotate(180deg);
+}
+
+.debug-content {
+    animation: slideDown 0.3s ease;
+}
+
+@keyframes slideDown {
+    from {
+        opacity: 0;
+        transform: translateY(-10px);
+    }
+
+    to {
+        opacity: 1;
+        transform: translateY(0);
+    }
+}
+
+.debug-section {
+    margin-bottom: 1.25rem;
+    padding-bottom: 1.25rem;
+    border-bottom: 1px dashed var(--border-color);
+}
+
+.debug-section:last-of-type {
+    border-bottom: none;
+    margin-bottom: 0;
 }
 
-.model-info {
+.debug-section h3 {
     font-size: 0.75rem;
+    font-weight: 700;
+    color: var(--text-secondary);
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+    margin-bottom: 0.75rem;
+}
+
+.debug-stats-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(120px, 1fr));
+    gap: 0.75rem;
+}
+
+.debug-stat {
+    background: var(--bg-tertiary);
+    border-radius: var(--radius-sm);
+    padding: 0.75rem;
+    text-align: center;
+    border: 1px solid var(--border-color);
+}
+
+.debug-label {
+    display: block;
+    font-size: 0.6875rem;
     color: var(--text-muted);
-    margin-top: 0.25rem;
+    text-transform: uppercase;
+    letter-spacing: 0.03em;
+    margin-bottom: 0.25rem;
+}
+
+.debug-value {
+    display: block;
+    font-size: 1rem;
+    font-weight: 700;
+    color: var(--accent-primary);
+    font-family: 'SF Mono', Monaco, monospace;
+}
+
+.debug-info-list {
+    display: flex;
+    flex-direction: column;
+    gap: 0.5rem;
+}
+
+.debug-info-item {
+    display: flex;
+    justify-content: space-between;
+    font-size: 0.8125rem;
+    padding: 0.375rem 0;
+    border-bottom: 1px solid var(--border-color);
+}
+
+.debug-info-item:last-child {
+    border-bottom: none;
+}
+
+.debug-info-key {
+    color: var(--text-secondary);
+}
+
+.debug-info-value {
+    color: var(--text-primary);
+    font-family: 'SF Mono', Monaco, monospace;
+    font-size: 0.75rem;
+}
+
+.debug-requests {
+    max-height: 200px;
+    overflow-y: auto;
+    background: var(--bg-tertiary);
+    border-radius: var(--radius-sm);
+    border: 1px solid var(--border-color);
 }
 
+.debug-request-item {
+    display: grid;
+    grid-template-columns: 1fr auto auto auto;
+    gap: 0.75rem;
+    padding: 0.625rem 0.75rem;
+    font-size: 0.75rem;
+    border-bottom: 1px solid var(--border-color);
+    align-items: center;
+}
+
+.debug-request-item:last-child {
+    border-bottom: none;
+}
+
+.debug-request-model {
+    font-weight: 600;
+    color: var(--text-primary);
+}
+
+.debug-request-voice {
+    color: var(--text-secondary);
+}
+
+.debug-request-time {
+    font-family: 'SF Mono', Monaco, monospace;
+    color: var(--accent-primary);
+}
+
+.debug-request-rtf {
+    font-family: 'SF Mono', Monaco, monospace;
+    color: var(--text-muted);
+    font-size: 0.6875rem;
+}
+
+.debug-refresh-btn {
+    width: 100%;
+    padding: 0.75rem;
+    background: var(--bg-tertiary);
+    border: 1px solid var(--border-color);
+    border-radius: var(--radius-sm);
+    font-size: 0.8125rem;
+    font-weight: 600;
+    color: var(--text-secondary);
+    cursor: pointer;
+    transition: all var(--transition);
+    margin-top: 1rem;
+}
+
+.debug-refresh-btn:hover {
+    background: var(--accent-light);
+    border-color: var(--accent-primary);
+    color: var(--accent-secondary);
+}
+
+/* Responsive */
 @media (max-width: 640px) {
     .container {
-        padding: 1.5rem 1rem;
+        padding: 1.25rem;
     }
-    
+
     header {
         flex-direction: column;
         align-items: flex-start;
         gap: 1rem;
+        position: relative;
     }
-    
+
     .logo-icon {
-        width: 40px;
-        height: 40px;
-        font-size: 1.25rem;
+        width: 52px;
+        height: 52px;
     }
-    
+
+    .logo-icon svg {
+        width: 36px;
+        height: 36px;
+    }
+
     .logo-text h1 {
-        font-size: 1.25rem;
+        font-size: 1.5rem;
     }
-    
+
     .theme-toggle {
         position: absolute;
-        top: 1.5rem;
-        right: 1rem;
+        top: 0;
+        right: 0;
+        width: 44px;
+        height: 44px;
     }
-    
-    header {
-        position: relative;
-        padding-right: 3.5rem;
-    }
-    
+
     .settings-row {
         grid-template-columns: 1fr;
     }
-    
+
+    .card {
+        padding: 1.25rem;
+    }
+
     textarea {
         min-height: 120px;
+        padding: 1rem;
+    }
+
+    .generate-btn {
+        padding: 1rem 1.5rem;
+        font-size: 1rem;
     }
 }
 
@@ -529,4 +1087,4 @@ footer a:hover {
         animation: none !important;
         transition-duration: 0.01ms !important;
     }
-}
+}
\ No newline at end of file
diff --git a/webui/templates/index.html b/webui/templates/index.html
index 18d477a..61035f3 100644
--- a/webui/templates/index.html
+++ b/webui/templates/index.html
@@ -3,22 +3,24 @@
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <meta name="description" content="KittenTTS - A cute kitten-themed text-to-speech web interface">
-    <title>KittenTTS WebUI</title>
+    <meta name="description" content="KittenTTS - A cute kitten-themed text-to-speech web interface. For Kittens, By Kittens.">
+    <title>KittenTTS 🐱 Text to Speech</title>
     <link rel="preconnect" href="https://fonts.googleapis.com">
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
-    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap" rel="stylesheet">
-    <link rel="stylesheet" href="/static/style.css">
+    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700;800&display=swap" rel="stylesheet">
+    <link rel="stylesheet" href="/static/style.css?v=4">
     <link rel="icon" type="image/svg+xml" href="/static/favicon.svg">
 </head>
 <body>
     <div class="container">
         <header>
             <div class="logo">
-                <div class="logo-icon">🐱</div>
+                <div class="logo-icon" title="Click me! 🐱">
+                    <img src="/static/icon.png" alt="KittenTTS" width="44" height="44">
+                </div>
                 <div class="logo-text">
                     <h1>KittenTTS</h1>
-                    <span>Text to Speech</span>
+                    <span class="tagline">For Kittens. By Kittens. 🐾</span>
                 </div>
             </div>
             <button id="themeToggle" class="theme-toggle" aria-label="Toggle theme">
@@ -27,76 +29,178 @@ <h1>KittenTTS</h1>
         </header>
 
         <main>
+            <!-- Settings Card -->
             <div class="card">
                 <div class="card-header">
+                    <div class="card-header-icon">⚙️</div>
                     <h2>Settings</h2>
                 </div>
+                
                 <div class="settings-row">
                     <div class="form-group">
-                        <label for="modelSelect">Model</label>
+                        <label for="modelSelect">
+                            <span class="label-icon">📦</span> Model
+                        </label>
                         <select id="modelSelect" class="model-select"></select>
+                        <div class="model-info" id="modelInfo"></div>
                     </div>
+                    
                     <div class="form-group">
-                        <label for="voiceSelect">Voice</label>
+                        <label for="voiceSelect">
+                            <span class="label-icon">🎙️</span> Voice
+                        </label>
                         <select id="voiceSelect" class="voice-select"></select>
+                        <div class="voice-description" id="voiceInfo"></div>
                     </div>
                 </div>
-                <div class="form-group">
+                
+                <div class="form-group" style="margin-bottom: 0;">
                     <div class="speed-container">
                         <div class="speed-header">
-                            <label for="speedSlider">Speed</label>
-                            <span id="speedValue" class="speed-value">1.0x</span>
+                            <label for="speedSlider">
+                                <span class="label-icon">⚡</span> Speed
+                            </label>
+                            <span id="speedValue" class="speed-value">1.0x <span id="speedEmoji">🐱</span></span>
                         </div>
                         <input type="range" id="speedSlider" min="0.5" max="2.0" step="0.1" value="1.0">
                     </div>
                 </div>
             </div>
 
+            <!-- Text Input Card -->
             <div class="card">
                 <div class="card-header">
+                    <div class="card-header-icon">✏️</div>
                     <h2>Text Input</h2>
                 </div>
+                
                 <div class="form-group">
-                    <textarea id="textInput" placeholder="Enter your text here... KittenTTS will transform it into natural-sounding speech. Try something like: 'Hello! I am KittenTTS, a lightweight text-to-speech model that runs entirely on your CPU.'"></textarea>
+                    <textarea id="textInput" placeholder="Enter your text here..."></textarea>
                 </div>
+                
                 <button id="generateBtn" class="generate-btn">
-                    <span id="btnText">🔊 Generate Speech</span>
+                    <span class="btn-icon">🔊</span>
+                    <span id="btnText">Generate Speech</span>
                     <span id="btnSpinner" class="spinner" style="display: none;"></span>
                 </button>
             </div>
 
+            <!-- Error Message -->
             <div id="errorMessage" class="error-message"></div>
 
+            <!-- Output Card -->
             <div id="outputSection" class="card output-section">
                 <div class="card-header">
-                    <h2>Output</h2>
+                    <div class="card-header-icon">🎵</div>
+                    <h2>Your Audio</h2>
                 </div>
                 <div class="audio-player">
                     <audio id="audioPlayer" controls></audio>
                     <div class="audio-info">
-                        <span id="audioDuration">Duration: 0s</span>
+                        <span id="audioDuration">⏱️ Duration: 0s</span>
                         <a id="downloadBtn" class="download-btn" href="#" download>
-                            ⬇ Download WAV
+                            💾 Download WAV
                         </a>
                     </div>
                 </div>
             </div>
 
+            <!-- Debug Panel -->
+            <div id="debugPanel" class="card debug-panel">
+                <div class="card-header debug-header" id="debugToggle">
+                    <div class="card-header-icon">🔧</div>
+                    <h2>Debug Stats</h2>
+                    <span class="debug-arrow">▼</span>
+                </div>
+                <div class="debug-content" id="debugContent" style="display: none;">
+                    <!-- Current Request Stats -->
+                    <div class="debug-section">
+                        <h3>Current Generation</h3>
+                        <div id="currentStats" class="debug-stats-grid">
+                            <div class="debug-stat">
+                                <span class="debug-label">Model Load</span>
+                                <span class="debug-value" id="statModelLoad">-</span>
+                            </div>
+                            <div class="debug-stat">
+                                <span class="debug-label">Generation</span>
+                                <span class="debug-value" id="statGenTime">-</span>
+                            </div>
+                            <div class="debug-stat">
+                                <span class="debug-label">Total Time</span>
+                                <span class="debug-value" id="statTotalTime">-</span>
+                            </div>
+                            <div class="debug-stat">
+                                <span class="debug-label">RTF</span>
+                                <span class="debug-value" id="statRTF">-</span>
+                            </div>
+                        </div>
+                    </div>
+
+                    <!-- Session Stats -->
+                    <div class="debug-section">
+                        <h3>Session Stats</h3>
+                        <div class="debug-stats-grid">
+                            <div class="debug-stat">
+                                <span class="debug-label">Total Requests</span>
+                                <span class="debug-value" id="sessionRequests">-</span>
+                            </div>
+                            <div class="debug-stat">
+                                <span class="debug-label">Avg Gen Time</span>
+                                <span class="debug-value" id="sessionAvgGen">-</span>
+                            </div>
+                            <div class="debug-stat">
+                                <span class="debug-label">Avg RTF</span>
+                                <span class="debug-value" id="sessionAvgRTF">-</span>
+                            </div>
+                            <div class="debug-stat">
+                                <span class="debug-label">Audio Generated</span>
+                                <span class="debug-value" id="sessionAudio">-</span>
+                            </div>
+                        </div>
+                    </div>
+
+                    <!-- System Info -->
+                    <div class="debug-section">
+                        <h3>System Info</h3>
+                        <div class="debug-info-list" id="systemInfo">
+                            <!-- Populated by JS -->
+                        </div>
+                    </div>
+
+                    <!-- Recent Requests -->
+                    <div class="debug-section">
+                        <h3>Recent Generations</h3>
+                        <div class="debug-requests" id="recentRequests">
+                            <!-- Populated by JS -->
+                        </div>
+                    </div>
+
+                    <button id="refreshStatsBtn" class="debug-refresh-btn">
+                        🔄 Refresh Stats
+                    </button>
+                </div>
+            </div>
+
+            <!-- Paw Decoration -->
             <div class="paw-decoration">
                 <span>🐾</span>
                 <span>🐾</span>
                 <span>🐾</span>
+                <span>🐾</span>
             </div>
         </main>
 
         <footer>
             <p>
-                <a href="https://github.com/KittenML/KittenTTS" target="_blank" rel="noopener">KittenTTS</a> 
-                by <a href="https://github.com/KittenML" target="_blank" rel="noopener">KittenML</a>
+                Made with <span class="heart">💖</span> by 
+                <a href="https://github.com/KittenML" target="_blank" rel="noopener">KittenML</a>
+            </p>
+            <p style="margin-top: 0.5rem; font-size: 0.75rem;">
+                <a href="https://github.com/KittenML/KittenTTS" target="_blank" rel="noopener">⭐ Star on GitHub</a>
             </p>
         </footer>
     </div>
 
-    <script src="/static/app.js"></script>
+    <script src="/static/app.js?v=4"></script>
 </body>
 </html>

From 4e0a78410c731bda9c0df358d21714b807c4808a Mon Sep 17 00:00:00 2001
From: Arjun Arihant <66896303+arjun-arihant@users.noreply.github.com>
Date: Fri, 20 Feb 2026 23:37:31 +0530
Subject: [PATCH 3/3] added streaming capabilities via chunking

---
 AGENTS.md                  |  65 ++++
 KITTENTTS_API_REFERENCE.md | 649 +++++++++++++++++++++++++++++++++++++
 README.md                  |  82 +++++
 kittentts/__init__.py      |   3 +-
 kittentts/get_model.py     |  14 +-
 kittentts/onnx_model.py    |  96 ++++++
 webui/server.py            | 119 ++++++-
 7 files changed, 1024 insertions(+), 4 deletions(-)
 create mode 100644 KITTENTTS_API_REFERENCE.md

diff --git a/AGENTS.md b/AGENTS.md
index 926c2b5..4872864 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -90,6 +90,12 @@ KittenTTS is an open-source, ultra-lightweight text-to-speech (TTS) model design
   - **TextCleaner** class: Maps phonemes to token IDs
   - **chunk_text()**: Splits long text at sentence/word boundaries (400 char limit)
   - Handles speed adjustments via voice-specific priors
+- **StreamingTTS** class: Sentence-level streaming for real-time TTS
+  - Buffers incoming text and yields audio when complete sentences are detected
+  - `add_text(text)`: Add text chunk, yields audio for complete sentences
+  - `flush()`: Synthesize any remaining buffered text
+  - `reset()`: Clear buffer without generating audio
+  - `buffered_text` property: View current buffered text
 
 ### 3. `kittentts/preprocess.py`
 - **TextPreprocessor** class: Comprehensive text normalization
@@ -110,7 +116,11 @@ KittenTTS is an open-source, ultra-lightweight text-to-speech (TTS) model design
   - `GET /api/voices` - Returns voice metadata
   - `POST /api/generate` - Generates speech (returns base64 WAV)
   - `GET /api/health` - Health check with loaded models
+  - `POST /api/stream/start` - Start a streaming TTS session
+  - `POST /api/stream/chunk` - Add text to streaming session, get audio for complete sentences
+  - `DELETE /api/stream/end/{session_id}` - End streaming session
 - **Model lazy-loading**: Models loaded on first request and cached
+- **Streaming sessions**: In-memory session cache for streaming TTS
 
 ## Build and Installation
 
@@ -149,6 +159,61 @@ sf.write("output.wav", audio, 24000)
 python run_webui.py --host 0.0.0.0 --port 7860
 ```
 
+**Streaming TTS (for LLM integration):**
+```python
+from kittentts import KittenTTS, StreamingTTS
+import soundfile as sf
+
+# Initialize model
+model = KittenTTS("KittenML/kitten-tts-mini-0.8")
+
+# Create a streaming instance
+streamer = model.create_streamer(voice="Jasper", speed=1.0)
+
+# Simulate streaming from an LLM
+llm_tokens = ["Hello", " there", "! How", " are", " you", " today", "?"]
+
+for token in llm_tokens:
+    # add_text() yields audio chunks when complete sentences are detected
+    for audio_chunk in streamer.add_text(token):
+        sf.write("chunk.wav", audio_chunk, 24000)
+        # Or play immediately for real-time output
+
+# Don't forget to flush remaining buffered text
+for audio_chunk in streamer.flush():
+    sf.write("final_chunk.wav", audio_chunk, 24000)
+```
+
+**Streaming via Web API:**
+```python
+import requests
+import json
+
+BASE_URL = "http://localhost:7860"
+
+# Start a streaming session
+response = requests.post(f"{BASE_URL}/api/stream/start?model=kitten-tts-nano&voice=Jasper&speed=1.0")
+session_id = response.json()["session_id"]
+
+# Stream text chunks
+for token in ["Hello", " there", "! How", " are", " you", "?"]:
+    response = requests.post(
+        f"{BASE_URL}/api/stream/chunk?session_id={session_id}",
+        json={"text": token, "flush": False}
+    )
+    result = response.json()
+    for audio_base64 in result["audio_chunks"]:
+        # Decode and play audio
+        pass
+
+# Flush remaining text and end session
+response = requests.post(
+    f"{BASE_URL}/api/stream/chunk?session_id={session_id}",
+    json={"text": "", "flush": True}
+)
+requests.delete(f"{BASE_URL}/api/stream/end/{session_id}")
+```
+
 ## Development Conventions
 
 **Code Style:**
diff --git a/KITTENTTS_API_REFERENCE.md b/KITTENTTS_API_REFERENCE.md
new file mode 100644
index 0000000..eada78a
--- /dev/null
+++ b/KITTENTTS_API_REFERENCE.md
@@ -0,0 +1,649 @@
+# KittenTTS — API Reference
+
+> **Service**: KittenTTS Ultra-Lightweight Text-to-Speech  
+> **Base URL**: `http://localhost:7860`  
+> **Protocol**: REST (JSON)  
+> **CORS**: Enabled for all origins  
+> **Model**: KittenTTS — 15M to 80M param neural TTS, 24kHz sample rate
+
+---
+
+## Quick Start
+
+```javascript
+// Simplest usage — generate audio from text
+const response = await fetch('http://localhost:7860/api/generate', {
+  method: 'POST',
+  headers: { 'Content-Type': 'application/json' },
+  body: JSON.stringify({
+    text: 'Hello world!',
+    voice: 'Jasper',
+    speed: 1.0,
+    model: 'kitten-tts-nano'
+  })
+});
+const result = await response.json();
+const audioBlob = await fetch(`data:audio/wav;base64,${result.audio_base64}`).then(r => r.blob());
+const audioUrl = URL.createObjectURL(audioBlob);
+```
+
+```python
+# Python equivalent
+import requests
+import base64
+import io
+import soundfile as sf
+
+response = requests.post('http://localhost:7860/api/generate', json={
+    'text': 'Hello world!',
+    'voice': 'Jasper',
+    'speed': 1.0,
+    'model': 'kitten-tts-nano'
+})
+result = response.json()
+
+# Decode and save audio
+audio_bytes = base64.b64decode(result['audio_base64'])
+audio, sr = sf.read(io.BytesIO(audio_bytes))
+sf.write('output.wav', audio, sr)
+```
+
+---
+
+## Available Models
+
+| Model ID | Name | Params | Size | Precision | Quality | Description |
+|----------|------|--------|------|-----------|---------|-------------|
+| `kitten-tts-nano` ⭐ | Nano (FP32) | 15M | 56MB | FP32 | **Best** | Full 32-bit precision, highest quality |
+| `kitten-tts-mini` | Mini (INT8) | 80M | 80MB | INT8 | Good | Largest model, quantized |
+| `kitten-tts-micro` | Micro (INT8) | 40M | 41MB | INT8 | Good | Balanced size/performance |
+| `kitten-tts-nano-int8` | Nano (INT8) | 15M | 19MB | INT8 | Basic | Smallest footprint |
+
+> **💡 Quality Tip:** The FP32 nano model (56MB) produces the best audio quality. Use `kitten-tts-nano` for optimal results.
+
+---
+
+## Available Voices
+
+KittenTTS includes 8 expressive voices — 4 male and 4 female:
+
+| Voice ID | Name | Gender | Description |
+|----------|------|--------|-------------|
+| `Bella` | Bella | Female | Warm & gentle |
+| `Jasper` | Jasper | Male | Clear & professional |
+| `Luna` | Luna | Female | Soft & melodic |
+| `Bruno` | Bruno | Male | Deep & resonant |
+| `Rosie` | Rosie | Female | Bright & cheerful |
+| `Hugo` | Hugo | Male | Confident & steady |
+| `Kiki` | Kiki | Female | Playful & energetic |
+| `Leo` | Leo | Male | Friendly & warm |
+
+### Recommended Voices
+
+| Use Case | Recommended Voice | Notes |
+|----------|-------------------|-------|
+| **Professional/Narration** | `Jasper` | Clear, professional tone |
+| **Warm/Conversational** | `Bella` | Gentle, welcoming |
+| **Energetic/Cheerful** | `Kiki` | Playful, upbeat |
+| **Deep/Authoritative** | `Bruno` | Resonant, commanding |
+
+---
+
+## Endpoints
+
+### `GET /api/health`
+
+Health check and system info.
+
+**Response:**
+```json
+{
+  "status": "healthy",
+  "loaded_models": ["kitten-tts-nano"],
+  "cache_dir": "/home/user/.cache/kittentts",
+  "cache_size_mb": 56.2
+}
+```
+
+---
+
+### `GET /api/models`
+
+List available models.
+
+**Response:**
+```json
+{
+  "models": [
+    {
+      "id": "kitten-tts-nano",
+      "name": "Nano (FP32)",
+      "params": "15M",
+      "size": "56MB",
+      "description": "⭐ Best quality - Full 32-bit precision",
+      "quality": "best",
+      "precision": "FP32"
+    }
+  ]
+}
+```
+
+---
+
+### `GET /api/voices`
+
+List available voices.
+
+**Response:**
+```json
+{
+  "voices": [
+    {
+      "id": "Bella",
+      "name": "Bella",
+      "gender": "female",
+      "description": "Warm & gentle"
+    },
+    {
+      "id": "Jasper",
+      "name": "Jasper",
+      "gender": "male",
+      "description": "Clear & professional"
+    }
+  ]
+}
+```
+
+---
+
+### `GET /api/stats`
+
+Get detailed generation statistics.
+
+**Response:**
+```json
+{
+  "generation_stats": {
+    "total_requests": 42,
+    "avg_generation_time": 0.156,
+    "avg_rtf": 12.5,
+    "total_audio_generated": 125.4,
+    "recent_requests": []
+  },
+  "system": {
+    "cache_directory": "/home/user/.cache/kittentts",
+    "cache_size_mb": 56.2,
+    "loaded_models": ["kitten-tts-nano"],
+    "model_load_times": {"kitten-tts-nano": 2.34},
+    "python_version": "3.12.0",
+    "memory_usage_mb": 245.6
+  },
+  "available_models": ["kitten-tts-nano", "kitten-tts-mini", "kitten-tts-micro", "kitten-tts-nano-int8"],
+  "available_voices": ["Bella", "Jasper", "Luna", "Bruno", "Rosie", "Hugo", "Kiki", "Leo"]
+}
+```
+
+---
+
+### `POST /api/generate`
+
+Synthesize speech from text. Returns JSON with base64-encoded WAV audio.
+
+**Request Body:**
+
+| Field | Type | Default | Description |
+|-------|------|---------|-------------|
+| `text` | string | *required* | Text to speak |
+| `voice` | string | `Bella` | Voice ID |
+| `speed` | float | `1.0` | Speech rate (0.25–3.0) |
+| `model` | string | `kitten-tts-nano` | Model ID |
+
+**Response:**
+```json
+{
+  "audio_base64": "UklGRi4AAABXQVZFZm10...",
+  "sample_rate": 24000,
+  "duration": 2.45,
+  "debug_info": {
+    "model_load_time": 2.34,
+    "generation_time": 0.156,
+    "total_time": 2.496,
+    "real_time_factor": 15.7,
+    "audio_samples": 58800,
+    "sample_rate": 24000
+  }
+}
+```
+
+**Example:**
+```javascript
+const res = await fetch('http://localhost:7860/api/generate', {
+  method: 'POST',
+  headers: { 'Content-Type': 'application/json' },
+  body: JSON.stringify({
+    text: 'Hello world! This is a test.',
+    voice: 'Jasper',
+    speed: 1.0,
+    model: 'kitten-tts-nano'
+  })
+});
+const result = await res.json();
+console.log(`Generated ${result.duration}s of audio`);
+```
+
+---
+
+## Streaming API (for LLM Integration)
+
+The streaming API enables real-time text-to-speech for conversational AI applications. Audio generation starts as soon as complete sentences are detected.
+
+### `POST /api/stream/start`
+
+Start a new streaming TTS session.
+
+**Query Parameters:**
+
+| Param | Type | Default | Description |
+|-------|------|---------|-------------|
+| `model` | string | `kitten-tts-nano` | Model ID |
+| `voice` | string | `Bella` | Voice ID |
+| `speed` | float | `1.0` | Speech rate (0.25–3.0) |
+
+**Response:**
+```json
+{
+  "session_id": "550e8400-e29b-41d4-a716-446655440000",
+  "status": "created"
+}
+```
+
+**Example:**
+```javascript
+const res = await fetch('http://localhost:7860/api/stream/start?voice=Jasper&speed=1.0', {
+  method: 'POST'
+});
+const { session_id } = await res.json();
+```
+
+---
+
+### `POST /api/stream/chunk`
+
+Add text to a streaming session and receive audio for complete sentences.
+
+**Query Parameters:**
+
+| Param | Type | Required | Description |
+|-------|------|----------|-------------|
+| `session_id` | string | *required* | Session ID from `/api/stream/start` |
+
+**Request Body:**
+
+| Field | Type | Default | Description |
+|-------|------|---------|-------------|
+| `text` | string | `""` | Text chunk to add |
+| `flush` | boolean | `false` | Set `true` on final chunk to flush remaining text |
+
+**Response:**
+```json
+{
+  "audio_chunks": [
+    "UklGRi4AAABXQVZFZm10...",
+    "UklGRi4AAABXQVZFZm10..."
+  ],
+  "sample_rate": 24000,
+  "buffered_text": " remaining text",
+  "status": "streaming"
+}
+```
+
+**Status Values:**
+- `streaming` — Session is active, more chunks expected
+- `flushed` — Session was flushed, no more buffered text
+
+**Example:**
+```javascript
+// Stream text from an LLM
+const tokens = ["Hello", " there", "! How", " are", " you", " today", "?"];
+
+for (const token of tokens) {
+  const res = await fetch(`http://localhost:7860/api/stream/chunk?session_id=${sessionId}`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ text: token, flush: false })
+  });
+  const result = await res.json();
+  
+  // Play each audio chunk immediately
+  for (const audioBase64 of result.audio_chunks) {
+    const audioBlob = await fetch(`data:audio/wav;base64,${audioBase64}`).then(r => r.blob());
+    playAudio(audioBlob);
+  }
+}
+
+// Flush remaining text
+const finalRes = await fetch(`http://localhost:7860/api/stream/chunk?session_id=${sessionId}`, {
+  method: 'POST',
+  headers: { 'Content-Type': 'application/json' },
+  body: JSON.stringify({ text: "", flush: true })
+});
+```
+
+---
+
+### `DELETE /api/stream/end/{session_id}`
+
+End a streaming session and release resources.
+
+**Path Parameters:**
+
+| Param | Type | Description |
+|-------|------|-------------|
+| `session_id` | string | Session ID to terminate |
+
+**Response:**
+```json
+{
+  "status": "ended",
+  "session_id": "550e8400-e29b-41d4-a716-446655440000"
+}
+```
+
+**Example:**
+```javascript
+await fetch(`http://localhost:7860/api/stream/end/${sessionId}`, {
+  method: 'DELETE'
+});
+```
+
+---
+
+## Complete Streaming Example
+
+### JavaScript (Browser)
+
+```javascript
+class KittenTTSStreamer {
+  constructor(baseUrl = 'http://localhost:7860') {
+    this.baseUrl = baseUrl;
+    this.sessionId = null;
+  }
+
+  async start(voice = 'Jasper', speed = 1.0, model = 'kitten-tts-nano') {
+    const res = await fetch(
+      `${this.baseUrl}/api/stream/start?voice=${voice}&speed=${speed}&model=${model}`,
+      { method: 'POST' }
+    );
+    const data = await res.json();
+    this.sessionId = data.session_id;
+    return this.sessionId;
+  }
+
+  async addText(text, flush = false) {
+    if (!this.sessionId) throw new Error('Session not started');
+    
+    const res = await fetch(
+      `${this.baseUrl}/api/stream/chunk?session_id=${this.sessionId}`,
+      {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ text, flush })
+      }
+    );
+    return await res.json();
+  }
+
+  async end() {
+    if (!this.sessionId) return;
+    await fetch(`${this.baseUrl}/api/stream/end/${this.sessionId}`, {
+      method: 'DELETE'
+    });
+    this.sessionId = null;
+  }
+}
+
+// Usage with Web Audio API for immediate playback
+const audioCtx = new AudioContext();
+let nextStartTime = 0;
+
+async function playChunk(audioBase64) {
+  const response = await fetch(`data:audio/wav;base64,${audioBase64}`);
+  const arrayBuffer = await response.arrayBuffer();
+  const audioBuffer = await audioCtx.decodeAudioData(arrayBuffer);
+  
+  const source = audioCtx.createBufferSource();
+  source.buffer = audioBuffer;
+  source.connect(audioCtx.destination);
+  
+  const startTime = Math.max(audioCtx.currentTime, nextStartTime);
+  source.start(startTime);
+  nextStartTime = startTime + audioBuffer.duration;
+}
+
+// Main streaming loop
+async function streamFromLLM(llmStream) {
+  const streamer = new KittenTTSStreamer();
+  await streamer.start('Jasper');
+  
+  for await (const token of llmStream) {
+    const result = await streamer.addText(token);
+    for (const chunk of result.audio_chunks) {
+      await playChunk(chunk);
+    }
+  }
+  
+  // Flush remaining text
+  const final = await streamer.addText('', true);
+  for (const chunk of final.audio_chunks) {
+    await playChunk(chunk);
+  }
+  
+  await streamer.end();
+}
+```
+
+### Python
+
+```python
+import requests
+import base64
+import io
+import soundfile as sf
+import sounddevice as sd
+
+class KittenTTSStreamer:
+    def __init__(self, base_url='http://localhost:7860'):
+        self.base_url = base_url
+        self.session_id = None
+    
+    def start(self, voice='Jasper', speed=1.0, model='kitten-tts-nano'):
+        res = requests.post(
+            f'{self.base_url}/api/stream/start',
+            params={'voice': voice, 'speed': speed, 'model': model}
+        )
+        self.session_id = res.json()['session_id']
+        return self.session_id
+    
+    def add_text(self, text, flush=False):
+        if not self.session_id:
+            raise RuntimeError('Session not started')
+        
+        res = requests.post(
+            f'{self.base_url}/api/stream/chunk',
+            params={'session_id': self.session_id},
+            json={'text': text, 'flush': flush}
+        )
+        return res.json()
+    
+    def end(self):
+        if self.session_id:
+            requests.delete(f'{self.base_url}/api/stream/end/{self.session_id}')
+            self.session_id = None
+
+def play_audio_chunk(audio_base64, sample_rate=24000):
+    """Play audio chunk immediately using sounddevice."""
+    audio_bytes = base64.b64decode(audio_base64)
+    audio, sr = sf.read(io.BytesIO(audio_bytes))
+    sd.play(audio, sr)
+    sd.wait()
+
+# Usage example
+def stream_from_llm(llm_generator):
+    streamer = KittenTTSStreamer()
+    streamer.start(voice='Jasper', speed=1.0)
+    
+    try:
+        for token in llm_generator:
+            result = streamer.add_text(token)
+            for chunk in result['audio_chunks']:
+                play_audio_chunk(chunk)
+        
+        # Flush remaining text
+        final = streamer.add_text('', flush=True)
+        for chunk in final['audio_chunks']:
+            play_audio_chunk(chunk)
+    finally:
+        streamer.end()
+
+# Simulate LLM stream
+def mock_llm_stream():
+    tokens = ["Hello", " there", "! How", " are", " you", " today", "?"]
+    for token in tokens:
+        yield token
+
+if __name__ == '__main__':
+    stream_from_llm(mock_llm_stream())
+```
+
+---
+
+## Python Library API
+
+For direct Python usage without the web server:
+
+### Basic Usage
+
+```python
+from kittentts import KittenTTS
+import soundfile as sf
+
+# Initialize model (downloads from HuggingFace if needed)
+model = KittenTTS("KittenML/kitten-tts-nano-0.8-fp32")
+
+# Generate audio
+audio = model.generate(
+    text="Hello world! This is a test.",
+    voice="Jasper",
+    speed=1.0
+)
+
+# Save to file
+sf.write('output.wav', audio, 24000)
+
+# Or use the convenience method
+model.generate_to_file(
+    text="Hello world!",
+    output_path='output.wav',
+    voice="Jasper",
+    speed=1.0
+)
+
+# List available voices
+print(model.available_voices)
+# ['expr-voice-2-m', 'expr-voice-2-f', 'expr-voice-3-m', ...]
+```
+
+### Streaming API
+
+```python
+from kittentts import KittenTTS
+import soundfile as sf
+
+model = KittenTTS("KittenML/kitten-tts-nano-0.8-fp32")
+
+# Create a streaming instance
+streamer = model.create_streamer(voice="Jasper", speed=1.0)
+
+# Simulate LLM stream
+llm_tokens = ["Hello", " there", "! How", " are", " you", " today", "?"]
+
+for token in llm_tokens:
+    # add_text() yields audio chunks when complete sentences are detected
+    for audio_chunk in streamer.add_text(token):
+        sf.write("chunk.wav", audio_chunk, 24000)
+        # Or play immediately for real-time output
+
+# Flush remaining buffered text
+for audio_chunk in streamer.flush():
+    sf.write("final_chunk.wav", audio_chunk, 24000)
+
+# Check buffered text at any time
+print(streamer.buffered_text)  # Shows text waiting for sentence completion
+
+# Reset buffer without generating (optional)
+streamer.reset()
+```
+
+---
+
+## Error Handling
+
+All endpoints return appropriate HTTP status codes:
+
+| Status | Description |
+|--------|-------------|
+| `200` | Success |
+| `400` | Bad request (invalid parameters, empty text, speed out of range) |
+| `404` | Not found (invalid session ID) |
+| `500` | Server error (model loading failed, inference error) |
+
+**Error Response Format:**
+```json
+{
+  "detail": "Error description here"
+}
+```
+
+**Example Error Handling:**
+```javascript
+const res = await fetch('http://localhost:7860/api/generate', {
+  method: 'POST',
+  headers: { 'Content-Type': 'application/json' },
+  body: JSON.stringify({ text: '', voice: 'Jasper' })
+});
+
+if (!res.ok) {
+  const error = await res.json();
+  console.error(`Error ${res.status}: ${error.detail}`);
+}
+```
+
+---
+
+## Performance Notes
+
+- **Real-Time Factor (RTF)**: Typically 10-20x real-time on modern CPUs
+- **First Request Latency**: ~2-3 seconds (model loading)
+- **Subsequent Requests**: ~100-300ms for typical sentences
+- **Streaming Latency**: Audio available within ~100-300ms of sentence completion
+- **Memory Usage**: ~200-300MB depending on model
+
+---
+
+## Docker Deployment
+
+```bash
+# Build image
+docker build -t kittentts-webui .
+
+# Run container
+docker run -d -p 7860:7860 -v ~/.cache/huggingface:/root/.cache/huggingface kittentts-webui
+
+# Access at http://localhost:7860
+```
+
+---
+
+## License
+
+Apache License 2.0
diff --git a/README.md b/README.md
index 2c4b5b8..2449c30 100644
--- a/README.md
+++ b/README.md
@@ -74,6 +74,88 @@ sf.write('output.wav', audio, 24000)
 
 ```
 
+## Streaming TTS (for LLM Integration)
+
+KittenTTS supports sentence-level streaming, ideal for real-time conversational AI applications. Audio generation starts as soon as complete sentences are detected from streaming text.
+
+### Python API
+
+```python
+from kittentts import KittenTTS
+import soundfile as sf
+
+# Initialize model
+model = KittenTTS("KittenML/kitten-tts-nano-0.8-fp32")
+
+# Create a streaming instance
+streamer = model.create_streamer(voice="Jasper", speed=1.0)
+
+# Simulate streaming from an LLM
+llm_tokens = ["Hello", " there", "! How", " are", " you", " today", "?"]
+
+for token in llm_tokens:
+    # add_text() yields audio chunks when complete sentences are detected
+    for audio_chunk in streamer.add_text(token):
+        sf.write("chunk.wav", audio_chunk, 24000)
+        # Or play immediately for real-time output
+
+# Don't forget to flush remaining buffered text
+for audio_chunk in streamer.flush():
+    sf.write("final_chunk.wav", audio_chunk, 24000)
+```
+
+### Web API
+
+For remote applications, use the streaming endpoints:
+
+```python
+import requests
+import base64
+import soundfile as sf
+import io
+
+BASE_URL = "http://localhost:7860"
+
+# Start a streaming session
+response = requests.post(
+    f"{BASE_URL}/api/stream/start",
+    params={"model": "kitten-tts-nano", "voice": "Jasper", "speed": 1.0}
+)
+session_id = response.json()["session_id"]
+
+# Stream text chunks (e.g., from an LLM)
+for token in ["Hello", " there", "! How", " are", " you", "?"]:
+    response = requests.post(
+        f"{BASE_URL}/api/stream/chunk?session_id={session_id}",
+        json={"text": token, "flush": False}
+    )
+    result = response.json()
+    
+    # Process audio chunks for complete sentences
+    for audio_base64 in result["audio_chunks"]:
+        audio_bytes = base64.b64decode(audio_base64)
+        audio, sr = sf.read(io.BytesIO(audio_bytes))
+        # Play or save audio
+
+# Flush remaining text and end session
+response = requests.post(
+    f"{BASE_URL}/api/stream/chunk?session_id={session_id}",
+    json={"text": "", "flush": True}
+)
+# Process final audio chunks...
+
+# Clean up
+requests.delete(f"{BASE_URL}/api/stream/end/{session_id}")
+```
+
+### Streaming API Endpoints
+
+| Endpoint | Method | Description |
+|----------|--------|-------------|
+| `/api/stream/start` | POST | Start a new streaming session |
+| `/api/stream/chunk?session_id={id}` | POST | Add text chunk, get audio for complete sentences |
+| `/api/stream/end/{session_id}` | DELETE | End session and release resources |
+
 
 
 
diff --git a/kittentts/__init__.py b/kittentts/__init__.py
index 9cf1a2d..e63ca99 100644
--- a/kittentts/__init__.py
+++ b/kittentts/__init__.py
@@ -1,7 +1,8 @@
 from kittentts.get_model import get_model, KittenTTS
+from kittentts.onnx_model import StreamingTTS
 
 __version__ = "0.1.0"
 __author__ = "KittenML"
 __description__ = "Ultra-lightweight text-to-speech model with just 15 million parameters"
 
-__all__ = ["get_model", "KittenTTS"]
+__all__ = ["get_model", "KittenTTS", "StreamingTTS"]
diff --git a/kittentts/get_model.py b/kittentts/get_model.py
index b0d47b2..8b53f5f 100644
--- a/kittentts/get_model.py
+++ b/kittentts/get_model.py
@@ -1,7 +1,7 @@
 import json
 import os
 from huggingface_hub import hf_hub_download
-from .onnx_model import KittenTTS_1_Onnx
+from .onnx_model import KittenTTS_1_Onnx, StreamingTTS
 
 
 class KittenTTS:
@@ -52,6 +52,18 @@ def generate_to_file(self, text, output_path, voice="expr-voice-5-m", speed=1.0,
     def available_voices(self):
         """Get list of available voices."""
         return self.model.available_voices
+    
+    def create_streamer(self, voice="expr-voice-5-m", speed=1.0):
+        """Create a streaming TTS instance for real-time generation.
+        
+        Args:
+            voice: Voice to use for synthesis
+            speed: Speech speed (1.0 = normal)
+            
+        Returns:
+            StreamingTTS: A streaming TTS instance
+        """
+        return StreamingTTS(self.model, voice=voice, speed=speed)
 
 
 def download_from_huggingface(repo_id="KittenML/kitten-tts-nano-0.1", cache_dir=None):
diff --git a/kittentts/onnx_model.py b/kittentts/onnx_model.py
index c5f8d25..012c57d 100644
--- a/kittentts/onnx_model.py
+++ b/kittentts/onnx_model.py
@@ -281,3 +281,99 @@ def generate_to_file(self, text: str, output_path: str, voice: str = "expr-voice
         sf.write(output_path, audio, sample_rate, subtype=subtype)
         print(f"Audio saved to {output_path} ({len(audio)/sample_rate:.2f}s at {sample_rate}Hz)")
 
+
+class StreamingTTS:
+    """Sentence-level streaming TTS for real-time text-to-speech generation.
+    
+    Buffers incoming text and yields audio chunks as complete sentences are detected.
+    Ideal for use with streaming LLMs for conversational AI applications.
+    
+    Example:
+        >>> streamer = StreamingTTS(model)
+        >>> for token in llm_stream:
+        ...     for audio_chunk in streamer.add_text(token):
+        ...         play_audio(audio_chunk)
+        >>> # Don't forget to flush remaining text
+        >>> for audio_chunk in streamer.flush():
+        ...     play_audio(audio_chunk)
+    """
+    
+    # Sentence-ending punctuation that triggers audio generation
+    SENTENCE_ENDINGS = '.!?'
+    
+    def __init__(self, tts_model: KittenTTS_1_Onnx, voice: str = "expr-voice-5-m", 
+                 speed: float = 1.0, clean_text: bool = True):
+        """Initialize the streaming TTS.
+        
+        Args:
+            tts_model: An initialized KittenTTS_1_Onnx model instance
+            voice: Voice to use for synthesis
+            speed: Speech speed (1.0 = normal)
+            clean_text: Whether to preprocess text before synthesis
+        """
+        self.tts = tts_model
+        self.voice = voice
+        self.speed = speed
+        self.clean_text = clean_text
+        self._buffer = ""
+    
+    def add_text(self, text: str):
+        """Add text to the buffer and yield audio for any complete sentences.
+        
+        Args:
+            text: Text chunk to add (e.g., a token from an LLM stream)
+            
+        Yields:
+            numpy.ndarray: Audio chunks for complete sentences
+        """
+        self._buffer += text
+        
+        # Find complete sentences
+        while True:
+            # Find the earliest sentence ending
+            earliest_end = -1
+            for ending in self.SENTENCE_ENDINGS:
+                pos = self._buffer.find(ending)
+                if pos != -1 and (earliest_end == -1 or pos < earliest_end):
+                    earliest_end = pos
+            
+            if earliest_end == -1:
+                break
+            
+            # Extract the complete sentence (include the punctuation)
+            sentence = self._buffer[:earliest_end + 1].strip()
+            self._buffer = self._buffer[earliest_end + 1:].lstrip()
+            
+            if sentence:
+                audio = self.tts.generate_single_chunk(sentence, self.voice, self.speed)
+                yield audio
+    
+    def flush(self):
+        """Flush any remaining text in the buffer.
+        
+        Call this when the text stream is complete to synthesize
+        any remaining text that hasn't formed a complete sentence.
+        
+        Yields:
+            numpy.ndarray: Audio chunk for remaining text (if any)
+        """
+        if self._buffer.strip():
+            # Ensure the text ends with punctuation for natural prosody
+            text = self._buffer.strip()
+            if text[-1] not in self.SENTENCE_ENDINGS:
+                text += '.'
+            
+            audio = self.tts.generate_single_chunk(text, self.voice, self.speed)
+            yield audio
+        
+        self._buffer = ""
+    
+    def reset(self):
+        """Clear the buffer without generating audio."""
+        self._buffer = ""
+    
+    @property
+    def buffered_text(self) -> str:
+        """Return the current buffered text that hasn't been synthesized yet."""
+        return self._buffer
+
diff --git a/webui/server.py b/webui/server.py
index 3496bd4..cd3128a 100644
--- a/webui/server.py
+++ b/webui/server.py
@@ -3,14 +3,16 @@
 import tempfile
 import time
 import os
-from typing import Optional, Dict, Any
+import uuid
+import json
+from typing import Optional, Dict, Any, Generator
 from pathlib import Path
 from datetime import datetime
 
 import numpy as np
 import soundfile as sf
 from fastapi import FastAPI, HTTPException, BackgroundTasks
-from fastapi.responses import HTMLResponse, JSONResponse, FileResponse
+from fastapi.responses import HTMLResponse, JSONResponse, FileResponse, StreamingResponse
 from fastapi.staticfiles import StaticFiles
 from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel
@@ -121,6 +123,9 @@
 loaded_models: Dict[str, Any] = {}
 model_load_times: Dict[str, float] = {}
 
+# Streaming session cache (session_id -> StreamingTTS instance)
+streaming_sessions: Dict[str, Any] = {}
+
 # Stats tracking
 class StatsTracker:
     def __init__(self):
@@ -175,6 +180,15 @@ class GenerateRequest(BaseModel):
     speed: float = 1.0
 
 
+class StreamChunkRequest(BaseModel):
+    """Request model for streaming TTS endpoint."""
+    text: str
+    model: str = "kitten-tts-nano"
+    voice: str = "Bella"
+    speed: float = 1.0
+    flush: bool = False  # Set True on final chunk to flush remaining text
+
+
 class GenerateResponse(BaseModel):
     audio_base64: str
     sample_rate: int
@@ -362,6 +376,107 @@ async def generate_audio(request: GenerateRequest):
         except Exception as e:
             raise HTTPException(status_code=500, detail=str(e))
 
+    @app.post("/api/stream/start")
+    async def start_streaming_session(model: str = "kitten-tts-nano", voice: str = "Bella", speed: float = 1.0):
+        """Start a new streaming TTS session.
+        
+        Returns a session_id to use for subsequent streaming requests.
+        """
+        if speed < 0.25 or speed > 3.0:
+            raise HTTPException(status_code=400, detail="Speed must be between 0.25 and 3.0")
+        
+        try:
+            tts_model, _ = get_model(model)
+            from kittentts import StreamingTTS
+            
+            voice_id = VOICE_ALIASES.get(voice, voice)
+            streamer = tts_model.create_streamer(voice=voice_id, speed=speed)
+            
+            session_id = str(uuid.uuid4())
+            streaming_sessions[session_id] = {
+                "streamer": streamer,
+                "model": model,
+                "voice": voice,
+                "created_at": datetime.now().isoformat(),
+            }
+            
+            return {"session_id": session_id, "status": "created"}
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=str(e))
+
+    @app.post("/api/stream/chunk")
+    async def stream_chunk(request: StreamChunkRequest, session_id: str):
+        """Add text to a streaming session and get audio for complete sentences.
+        
+        Args:
+            session_id: The streaming session ID from /api/stream/start
+            request: Contains text chunk and flush flag
+            
+        Returns:
+            JSON with audio_base64 chunks for any complete sentences
+        """
+        if session_id not in streaming_sessions:
+            raise HTTPException(status_code=404, detail="Session not found. Start a new session with /api/stream/start")
+        
+        session = streaming_sessions[session_id]
+        streamer = session["streamer"]
+        
+        try:
+            audio_chunks = []
+            
+            # Process incoming text and get audio for complete sentences
+            for audio in streamer.add_text(request.text):
+                audio_chunks.append(audio)
+            
+            # If flush is True, also get any remaining buffered text
+            if request.flush:
+                for audio in streamer.flush():
+                    audio_chunks.append(audio)
+            
+            # Convert audio chunks to base64
+            sample_rate = 24000
+            audio_base64_chunks = []
+            
+            for audio in audio_chunks:
+                if isinstance(audio, np.ndarray):
+                    audio_array = audio
+                else:
+                    audio_array = np.array(audio)
+                
+                if audio_array.ndim > 1:
+                    audio_array = audio_array.squeeze()
+                
+                if audio_array.dtype != np.float32:
+                    audio_array = audio_array.astype(np.float32)
+                
+                # Normalize if needed
+                max_val = np.max(np.abs(audio_array))
+                if max_val > 0.99:
+                    audio_array = audio_array * (0.99 / max_val)
+                
+                buffer = io.BytesIO()
+                sf.write(buffer, audio_array, sample_rate, format="WAV", subtype='PCM_16')
+                buffer.seek(0)
+                audio_base64_chunks.append(base64.b64encode(buffer.read()).decode("utf-8"))
+            
+            return {
+                "audio_chunks": audio_base64_chunks,
+                "sample_rate": sample_rate,
+                "buffered_text": streamer.buffered_text,
+                "status": "flushed" if request.flush else "streaming",
+            }
+            
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=str(e))
+
+    @app.delete("/api/stream/end/{session_id}")
+    async def end_streaming_session(session_id: str):
+        """End a streaming session and release resources."""
+        if session_id in streaming_sessions:
+            del streaming_sessions[session_id]
+            return {"status": "ended", "session_id": session_id}
+        raise HTTPException(status_code=404, detail="Session not found")
+
     @app.get("/favicon.ico")
     async def favicon():
         return FileResponse(