diff --git a/.gitignore b/.gitignore
index 05f7ef0d..cb01402d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -38,9 +38,14 @@ Thumbs.db
 data/profiles/*
 data/generations/*
 data/projects/*
+data/cache/*
+data/finetune/*
 data/voicebox.db
 !data/.gitkeep
 
+# Model binaries (downloaded at runtime)
+backend/models/
+
 # Logs
 *.log
 logs/
diff --git a/CHANGELOG.md b/CHANGELOG.md
index b7116d39..e87d4790 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -57,6 +57,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Audio export failing when Tauri save dialog returns object instead of string path
 
 ### Added
+- **Hebrew Language Support** - Full Hebrew voice cloning and transcription
+  - Chatterbox Multilingual TTS backend (`ResembleAI/chatterbox`) for Hebrew voice generation
+  - ivrit-ai Whisper models (`ivrit-ai/whisper-large-v3-turbo` and `ivrit-ai/whisper-large-v3`) for Hebrew transcription
+  - Automatic backend routing: Hebrew requests use Chatterbox, all other languages use Qwen3-TTS
+  - Auto-download of Hebrew models on first use with progress tracking
+  - Trailing silence trimming for Chatterbox output
+- **Model Unloading** - New `/models/{model_name}/unload` endpoint to free memory for individual models
 - **Makefile** - Comprehensive development workflow automation with commands for setup, development, building, testing, and code quality checks
   - Includes Python version detection and compatibility warnings
   - Self-documenting help system with `make help`
@@ -68,9 +75,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
-## [Unreleased - Planned]
+## Roadmap
 
-### Planned
 - Real-time streaming synthesis
 - Conversation mode with multiple speakers
 - Voice effects (pitch shift, reverb, M3GAN-style)
@@ -82,4 +88,5 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+[Unreleased]: https://github.com/nadavox/voicebox/compare/v0.1.0...HEAD
 [0.1.0]: https://github.com/jamiepine/voicebox/releases/tag/v0.1.0
diff --git a/app/src/components/Generation/FloatingGenerateBox.tsx b/app/src/components/Generation/FloatingGenerateBox.tsx
index a8d556a6..55791f9e 100644
--- a/app/src/components/Generation/FloatingGenerateBox.tsx
+++ b/app/src/components/Generation/FloatingGenerateBox.tsx
@@ -13,7 +13,7 @@ import {
 } from '@/components/ui/select';
 import { Textarea } from '@/components/ui/textarea';
 import { useToast } from '@/components/ui/use-toast';
-import { LANGUAGE_OPTIONS } from '@/lib/constants/languages';
+import { LANGUAGE_OPTIONS, type LanguageCode } from '@/lib/constants/languages';
 import { useGenerationForm } from '@/lib/hooks/useGenerationForm';
 import { useProfile, useProfiles } from '@/lib/hooks/useProfiles';
 import { useAddStoryItem, useStory } from '@/lib/hooks/useStories';
@@ -75,6 +75,16 @@ export function FloatingGenerateBox({
     },
   });
 
+  // Auto-sync language when selected profile changes
+  useEffect(() => {
+    if (selectedProfile?.language) {
+      const profileLang = selectedProfile.language as LanguageCode;
+      if (LANGUAGE_OPTIONS.some((l) => l.value === profileLang)) {
+        form.setValue('language', profileLang);
+      }
+    }
+  }, [selectedProfile?.language, form]);
+
   // Click away handler to collapse the box
   useEffect(() => {
     function handleClickOutside(event: MouseEvent) {
@@ -383,7 +393,7 @@ export function FloatingGenerateBox({
                     name="language"
                     render={({ field }) => (
                       <FormItem className="flex-1 space-y-0">
-                        <Select onValueChange={field.onChange} defaultValue={field.value}>
+                        <Select onValueChange={field.onChange} value={field.value}>
                           <FormControl>
                             <SelectTrigger className="h-8 text-xs bg-card border-border rounded-full hover:bg-background/50 transition-all">
                               <SelectValue />
diff --git a/app/src/components/Generation/GenerationForm.tsx b/app/src/components/Generation/GenerationForm.tsx
index 31b100f8..46e54b83 100644
--- a/app/src/components/Generation/GenerationForm.tsx
+++ b/app/src/components/Generation/GenerationForm.tsx
@@ -1,3 +1,4 @@
+import { useEffect } from 'react';
 import { Loader2, Mic } from 'lucide-react';
 import { Button } from '@/components/ui/button';
 import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card';
@@ -19,7 +20,7 @@ import {
   SelectValue,
 } from '@/components/ui/select';
 import { Textarea } from '@/components/ui/textarea';
-import { LANGUAGE_OPTIONS } from '@/lib/constants/languages';
+import { LANGUAGE_OPTIONS, type LanguageCode } from '@/lib/constants/languages';
 import { useGenerationForm } from '@/lib/hooks/useGenerationForm';
 import { useProfile } from '@/lib/hooks/useProfiles';
 import { useUIStore } from '@/stores/uiStore';
@@ -30,6 +31,16 @@ export function GenerationForm() {
 
   const { form, handleSubmit, isPending } = useGenerationForm();
 
+  // Auto-sync language when selected profile changes
+  useEffect(() => {
+    if (selectedProfile?.language) {
+      const profileLang = selectedProfile.language as LanguageCode;
+      if (LANGUAGE_OPTIONS.some((l) => l.value === profileLang)) {
+        form.setValue('language', profileLang);
+      }
+    }
+  }, [selectedProfile?.language, form]);
+
   async function onSubmit(data: Parameters<typeof handleSubmit>[0]) {
     await handleSubmit(data, selectedProfileId);
   }
@@ -105,7 +116,7 @@ export function GenerationForm() {
                 render={({ field }) => (
                   <FormItem>
                     <FormLabel>Language</FormLabel>
-                    <Select onValueChange={field.onChange} defaultValue={field.value}>
+                    <Select onValueChange={field.onChange} value={field.value}>
                       <FormControl>
                         <SelectTrigger>
                           <SelectValue />
diff --git a/app/src/components/ServerSettings/ModelManagement.tsx b/app/src/components/ServerSettings/ModelManagement.tsx
index 4a5fd439..ad7a66ab 100644
--- a/app/src/components/ServerSettings/ModelManagement.tsx
+++ b/app/src/components/ServerSettings/ModelManagement.tsx
@@ -1,5 +1,5 @@
 import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
-import { Download, Loader2, Trash2 } from 'lucide-react';
+import { Download, Loader2, Power, Trash2 } from 'lucide-react';
 import { useCallback, useState } from 'react';
 import {
   AlertDialog,
@@ -136,6 +136,27 @@ export function ModelManagement() {
     },
   });
 
+  const unloadMutation = useMutation({
+    mutationFn: async (modelName: string) => {
+      return apiClient.unloadModel(modelName);
+    },
+    onSuccess: async (_data, modelName) => {
+      const model = modelStatus?.models.find((m) => m.model_name === modelName);
+      toast({
+        title: 'Model unloaded',
+        description: `${model?.display_name || modelName} has been unloaded from memory.`,
+      });
+      await queryClient.invalidateQueries({ queryKey: ['modelStatus'], refetchType: 'all' });
+    },
+    onError: (error: Error) => {
+      toast({
+        title: 'Unload failed',
+        description: error.message,
+        variant: 'destructive',
+      });
+    },
+  });
+
   const formatSize = (sizeMb?: number): string => {
     if (!sizeMb) return 'Unknown';
     if (sizeMb < 1024) return `${sizeMb.toFixed(1)} MB`;
@@ -164,7 +185,7 @@ export function ModelManagement() {
               </h3>
               <div className="space-y-2">
                 {modelStatus.models
-                  .filter((m) => m.model_name.startsWith('qwen-tts'))
+                  .filter((m) => m.model_name.startsWith('qwen-tts') || m.model_name === 'chatterbox-tts')
                   .map((model) => (
                     <ModelItem
                       key={model.model_name}
@@ -178,7 +199,9 @@ export function ModelManagement() {
                         });
                         setDeleteDialogOpen(true);
                       }}
+                      onUnload={() => unloadMutation.mutate(model.model_name)}
                       isDownloading={downloadingModel === model.model_name}
+                      isUnloading={unloadMutation.isPending && unloadMutation.variables === model.model_name}
                       formatSize={formatSize}
                     />
                   ))}
@@ -206,7 +229,9 @@ export function ModelManagement() {
                         });
                         setDeleteDialogOpen(true);
                       }}
+                      onUnload={() => unloadMutation.mutate(model.model_name)}
                       isDownloading={downloadingModel === model.model_name}
+                      isUnloading={unloadMutation.isPending && unloadMutation.variables === model.model_name}
                       formatSize={formatSize}
                     />
                   ))}
@@ -271,14 +296,16 @@ interface ModelItemProps {
   };
   onDownload: () => void;
   onDelete: () => void;
+  onUnload: () => void;
   isDownloading: boolean;  // Local state - true if user just clicked download
+  isUnloading: boolean;
   formatSize: (sizeMb?: number) => string;
 }
 
-function ModelItem({ model, onDownload, onDelete, isDownloading, formatSize }: ModelItemProps) {
+function ModelItem({ model, onDownload, onDelete, onUnload, isDownloading, isUnloading, formatSize }: ModelItemProps) {
   // Use server's downloading state OR local state (for immediate feedback before server updates)
   const showDownloading = model.downloading || isDownloading;
-  
+
   return (
     <div className="flex items-center justify-between p-3 border rounded-lg">
       <div className="flex-1">
@@ -305,9 +332,25 @@ function ModelItem({ model, onDownload, onDelete, isDownloading, formatSize }: M
       <div className="flex items-center gap-2">
         {model.downloaded && !showDownloading ? (
           <div className="flex items-center gap-2">
-            <div className="flex items-center gap-1 text-sm text-muted-foreground">
-              <span>Ready</span>
-            </div>
+            {model.loaded ? (
+              <Button
+                size="sm"
+                onClick={onUnload}
+                variant="outline"
+                disabled={isUnloading}
+                title="Unload model from memory"
+              >
+                {isUnloading ? (
+                  <Loader2 className="h-4 w-4 animate-spin" />
+                ) : (
+                  <Power className="h-4 w-4" />
+                )}
+              </Button>
+            ) : (
+              <div className="flex items-center gap-1 text-sm text-muted-foreground">
+                <span>Ready</span>
+              </div>
+            )}
             <Button
               size="sm"
               onClick={onDelete}
diff --git a/app/src/lib/api/client.ts b/app/src/lib/api/client.ts
index c5b079b2..ce5dfd8e 100644
--- a/app/src/lib/api/client.ts
+++ b/app/src/lib/api/client.ts
@@ -310,13 +310,10 @@ class ApiClient {
   }
 
   async triggerModelDownload(modelName: string): Promise<{ message: string }> {
-    console.log('[API] triggerModelDownload called for:', modelName, 'at', new Date().toISOString());
-    const result = await this.request<{ message: string }>('/models/download', {
+    return this.request<{ message: string }>('/models/download', {
       method: 'POST',
       body: JSON.stringify({ model_name: modelName } as ModelDownloadRequest),
     });
-    console.log('[API] triggerModelDownload response:', result);
-    return result;
   }
 
   async deleteModel(modelName: string): Promise<{ message: string }> {
@@ -325,6 +322,12 @@ class ApiClient {
     });
   }
 
+  async unloadModel(modelName: string): Promise<{ message: string }> {
+    return this.request<{ message: string }>(`/models/${modelName}/unload`, {
+      method: 'POST',
+    });
+  }
+
   // Task Management
   async getActiveTasks(): Promise<ActiveTasksResponse> {
     return this.request<ActiveTasksResponse>('/tasks/active');
diff --git a/app/src/lib/api/types.ts b/app/src/lib/api/types.ts
index 131c1be5..dd76ca1e 100644
--- a/app/src/lib/api/types.ts
+++ b/app/src/lib/api/types.ts
@@ -34,6 +34,7 @@ export interface GenerationRequest {
   language: LanguageCode;
   seed?: number;
   model_size?: '1.7B' | '0.6B';
+  instruct?: string;
 }
 
 export interface GenerationResponse {
diff --git a/app/src/lib/constants/languages.ts b/app/src/lib/constants/languages.ts
index 9ffc396f..9c85aafd 100644
--- a/app/src/lib/constants/languages.ts
+++ b/app/src/lib/constants/languages.ts
@@ -1,6 +1,6 @@
 /**
- * Supported languages for Qwen3-TTS
- * Based on: https://github.com/QwenLM/Qwen3-TTS
+ * Supported languages for voice generation.
+ * Most languages use Qwen3-TTS; Hebrew uses Chatterbox TTS.
  */
 
 export const SUPPORTED_LANGUAGES = {
@@ -14,6 +14,7 @@ export const SUPPORTED_LANGUAGES = {
   pt: 'Portuguese',
   es: 'Spanish',
   it: 'Italian',
+  he: 'Hebrew',
 } as const;
 
 export type LanguageCode = keyof typeof SUPPORTED_LANGUAGES;
diff --git a/app/src/lib/hooks/useGenerationForm.ts b/app/src/lib/hooks/useGenerationForm.ts
index c6fdba50..24873682 100644
--- a/app/src/lib/hooks/useGenerationForm.ts
+++ b/app/src/lib/hooks/useGenerationForm.ts
@@ -67,8 +67,15 @@ export function useGenerationForm(options: UseGenerationFormOptions = {}) {
     try {
       setIsGenerating(true);
 
-      const modelName = `qwen-tts-${data.modelSize}`;
-      const displayName = data.modelSize === '1.7B' ? 'Qwen TTS 1.7B' : 'Qwen TTS 0.6B';
+      // Determine model name for download tracking
+      // Hebrew uses Chatterbox TTS, other languages use Qwen
+      const isHebrew = data.language === 'he';
+      const modelName = isHebrew ? 'chatterbox-tts' : `qwen-tts-${data.modelSize}`;
+      const displayName = isHebrew
+        ? 'Chatterbox TTS (Hebrew)'
+        : data.modelSize === '1.7B'
+          ? 'Qwen TTS 1.7B'
+          : 'Qwen TTS 0.6B';
 
       try {
         const modelStatus = await apiClient.getModelStatus();
diff --git a/backend/README.md b/backend/README.md
index 57163467..76104c8a 100644
--- a/backend/README.md
+++ b/backend/README.md
@@ -1,13 +1,14 @@
 # voicebox Backend
 
-Production-quality FastAPI backend for Qwen3-TTS voice cloning.
+Production-quality FastAPI backend for voice cloning with Qwen3-TTS and Chatterbox TTS.
 
 ## Features
 
 - ✅ **Voice Profile Management** - Create, update, delete voice profiles with multi-sample support
 - ✅ **Voice Cloning** - Generate speech using voice profiles with caching
 - ✅ **Generation History** - Full history tracking with search and filtering
-- ✅ **Transcription** - Whisper-based audio transcription
+- ✅ **Hebrew Language Support** - Chatterbox TTS for Hebrew voice cloning with ivrit-ai Whisper for transcription
+- ✅ **Transcription** - Whisper-based audio transcription (including Hebrew via ivrit-ai models)
 - ✅ **Multi-Sample Profiles** - Combine multiple reference samples for better quality
 - ✅ **Voice Prompt Caching** - Dual memory + disk caching for fast generation
 - ✅ **Audio Validation** - Automatic validation of reference audio quality
@@ -25,7 +26,8 @@ backend/
 ├── backends/           # Backend implementations
 │   ├── __init__.py     # Backend factory and protocols
 │   ├── mlx_backend.py  # MLX backend (Apple Silicon)
-│   └── pytorch_backend.py  # PyTorch backend (Windows/Linux/Intel)
+│   ├── pytorch_backend.py  # PyTorch backend (Windows/Linux/Intel)
+│   └── chatterbox_backend.py  # Chatterbox TTS backend (Hebrew)
 ├── profiles.py         # Voice profile CRUD
 ├── history.py          # Generation history
 ├── studio.py           # Audio editing (TODO)
@@ -38,12 +40,13 @@ backend/
 
 ### Backend Selection
 
-Voicebox automatically selects the best backend based on platform:
+Voicebox automatically selects the best backend based on platform and language:
 
 - **Apple Silicon (M1/M2/M3)**: Uses MLX backend with native Metal acceleration (4-5x faster)
 - **Windows/Linux/Intel Mac**: Uses PyTorch backend (CUDA GPU if available, CPU fallback)
+- **Hebrew**: Uses Chatterbox Multilingual TTS (ResembleAI/chatterbox) on all platforms
 
-The backend is detected at runtime via `platform_detect.py`. Both backends implement the same interface, so the API remains consistent across platforms.
+The TTS/STT backend is detected at runtime via `platform_detect.py`. For Hebrew, the Chatterbox backend is used regardless of platform. Both Qwen3-TTS backends (MLX and PyTorch) implement the same interface, so the API remains consistent across platforms.
 
 ## API Endpoints
 
@@ -87,6 +90,17 @@ Create a new voice profile.
 }
 ```
 
+**Supported languages:** `zh`, `en`, `ja`, `ko`, `de`, `fr`, `ru`, `pt`, `es`, `it`, `he`
+
+**Request (Hebrew example):**
+```json
+{
+  "name": "My Voice",
+  "description": "Optional description",
+  "language": "he"
+}
+```
+
 **Response:**
 ```json
 {
@@ -149,6 +163,10 @@ Generate speech from text using a voice profile.
 }
 ```
 
+**Supported languages:** `zh`, `en`, `ja`, `ko`, `de`, `fr`, `ru`, `pt`, `es`, `it`, `he`
+
+When `language` is `"he"`, the request is routed to the Chatterbox TTS backend. The Chatterbox model is auto-downloaded on first use. All other languages use Qwen3-TTS.
+
 **Response:**
 ```json
 {
@@ -209,7 +227,9 @@ Transcribe audio file to text.
 
 **Form Data:**
 - `file`: Audio file
-- `language` (optional): Language hint (en or zh)
+- `language` (optional): Language hint (`zh`, `en`, `ja`, `ko`, `de`, `fr`, `ru`, `pt`, `es`, `it`, `he`)
+
+For Hebrew (`he`), the ivrit-ai Whisper model (`ivrit-ai/whisper-large-v3-turbo`) is automatically selected for optimal transcription quality. The model is downloaded on first use.
 
 **Response:**
 ```json
@@ -236,7 +256,7 @@ Unload TTS model to free memory.
 - `id`: UUID primary key
 - `name`: Profile name (unique)
 - `description`: Optional description
-- `language`: Language code (en/zh)
+- `language`: Language code (zh/en/ja/ko/de/fr/ru/pt/es/it/he)
 - `created_at`: Creation timestamp
 - `updated_at`: Last update timestamp
 
@@ -250,7 +270,7 @@ Unload TTS model to free memory.
 - `id`: UUID primary key
 - `profile_id`: Foreign key to profiles
 - `text`: Generated text
-- `language`: Language code
+- `language`: Language code (zh/en/ja/ko/de/fr/ru/pt/es/it/he)
 - `audio_path`: Path to audio file
 - `duration`: Duration in seconds
 - `seed`: Random seed (optional)
@@ -299,11 +319,17 @@ The Qwen3-TTS models are automatically downloaded from HuggingFace Hub on first
 
 **No manual download required!** The models will be cached locally after the first download.
 
-Available models:
-- **1.7B** (recommended): `Qwen/Qwen3-TTS-12Hz-1.7B-Base` (~4GB)
-- **0.6B** (faster): `Qwen/Qwen3-TTS-12Hz-0.6B-Base` (~2GB)
+Available TTS models:
+- **Qwen3-TTS 1.7B** (recommended): `Qwen/Qwen3-TTS-12Hz-1.7B-Base` (~4GB)
+- **Qwen3-TTS 0.6B** (faster): `Qwen/Qwen3-TTS-12Hz-0.6B-Base` (~2GB)
+- **Chatterbox Multilingual** (Hebrew): `ResembleAI/chatterbox` (~1GB) — auto-downloaded when Hebrew is first used
+
+Available STT models:
+- **Whisper** (general): `openai/whisper-base` (default, auto-downloaded)
+- **ivrit-ai Whisper v3-turbo** (Hebrew): `ivrit-ai/whisper-large-v3-turbo` — auto-selected for Hebrew transcription
+- **ivrit-ai Whisper v3** (Hebrew, higher quality): `ivrit-ai/whisper-large-v3`
 
-**Note:** The first generation will take longer as the model downloads. Subsequent generations will use the cached model.
+**Note:** The first generation/transcription will take longer as the model downloads. Subsequent runs use the cached model.
 
 #### Manual Download (Optional)
 
diff --git a/backend/backends/__init__.py b/backend/backends/__init__.py
index f7c47ba9..718147a8 100644
--- a/backend/backends/__init__.py
+++ b/backend/backends/__init__.py
@@ -10,6 +10,17 @@
 
 from ..platform_detect import get_backend_type
 
+# Shared model name mapping for STT backends (MLX + PyTorch).
+# Maps short model size keys to HuggingFace repo IDs.
+STT_MODEL_MAP = {
+    "base": "openai/whisper-base",
+    "small": "openai/whisper-small",
+    "medium": "openai/whisper-medium",
+    "large": "openai/whisper-large",
+    "ivrit-v3": "ivrit-ai/whisper-large-v3",
+    "ivrit-v3-turbo": "ivrit-ai/whisper-large-v3-turbo",
+}
+
 
 @runtime_checkable
 class TTSBackend(Protocol):
@@ -113,6 +124,9 @@ def is_loaded(self) -> bool:
 # Global backend instances
 _tts_backend: Optional[TTSBackend] = None
 _stt_backend: Optional[STTBackend] = None
+_chatterbox_backend = None  # Optional[ChatterboxTTSBackend]
+_pytorch_tts_backend: Optional[TTSBackend] = None  # For adapter-based generation
+_pytorch_stt_backend: Optional[STTBackend] = None  # For ivrit models on MLX
 
 
 def get_tts_backend() -> TTSBackend:
@@ -159,8 +173,71 @@ def get_stt_backend() -> STTBackend:
     return _stt_backend
 
 
+def get_pytorch_tts_backend() -> TTSBackend:
+    """
+    Get or create a PyTorch TTS backend instance.
+
+    Used specifically for adapter-based generation, since LoRA adapters
+    are trained with PyTorch+PEFT and must be loaded in PyTorch.
+    On Apple Silicon, the default backend is MLX which doesn't support
+    PEFT adapters, so we maintain a separate PyTorch backend.
+    """
+    global _pytorch_tts_backend
+
+    if _pytorch_tts_backend is None:
+        # Check if the default backend is already PyTorch — reuse it
+        backend_type = get_backend_type()
+        if backend_type != "mlx":
+            _pytorch_tts_backend = get_tts_backend()
+        else:
+            from .pytorch_backend import PyTorchTTSBackend
+            _pytorch_tts_backend = PyTorchTTSBackend()
+
+    return _pytorch_tts_backend
+
+
+def get_pytorch_stt_backend() -> STTBackend:
+    """
+    Get or create a PyTorch STT backend instance.
+
+    Used for models that mlx_audio cannot load (e.g. ivrit-ai fine-tuned
+    Whisper models). On Apple Silicon the default STT backend is MLX,
+    so we maintain a separate PyTorch backend for these models.
+    """
+    global _pytorch_stt_backend
+
+    if _pytorch_stt_backend is None:
+        backend_type = get_backend_type()
+        if backend_type != "mlx":
+            _pytorch_stt_backend = get_stt_backend()
+        else:
+            from .pytorch_backend import PyTorchSTTBackend
+            _pytorch_stt_backend = PyTorchSTTBackend()
+
+    return _pytorch_stt_backend
+
+
+def get_chatterbox_backend() -> "ChatterboxTTSBackend":
+    """
+    Get or create Chatterbox TTS backend instance (for Hebrew).
+
+    Returns:
+        ChatterboxTTSBackend instance
+    """
+    global _chatterbox_backend
+
+    if _chatterbox_backend is None:
+        from .chatterbox_backend import ChatterboxTTSBackend
+        _chatterbox_backend = ChatterboxTTSBackend()
+
+    return _chatterbox_backend
+
+
 def reset_backends():
     """Reset backend instances (useful for testing)."""
-    global _tts_backend, _stt_backend
+    global _tts_backend, _stt_backend, _chatterbox_backend, _pytorch_tts_backend, _pytorch_stt_backend
     _tts_backend = None
     _stt_backend = None
+    _chatterbox_backend = None
+    _pytorch_tts_backend = None
+    _pytorch_stt_backend = None
diff --git a/backend/backends/chatterbox_backend.py b/backend/backends/chatterbox_backend.py
new file mode 100644
index 00000000..68ecc352
--- /dev/null
+++ b/backend/backends/chatterbox_backend.py
@@ -0,0 +1,351 @@
+"""
+Chatterbox Multilingual TTS backend for Hebrew voice generation.
+
+Uses ChatterboxMultilingualTTS from the chatterbox-tts package
+(ResembleAI/chatterbox on HuggingFace) which supports 23 languages
+including Hebrew. Forces CPU on macOS due to known MPS tensor issues.
+"""
+
+from typing import Optional, List, Tuple, ClassVar
+import asyncio
+import platform
+import threading
+import numpy as np
+from pathlib import Path
+
+from . import TTSBackend
+from ..utils.audio import normalize_audio, load_audio
+from ..utils.progress import get_progress_manager
+from ..utils.hf_progress import HFProgressTracker, create_hf_progress_callback
+from ..utils.tasks import get_task_manager
+
+
+class ChatterboxTTSBackend:
+    """Chatterbox Multilingual TTS backend for Hebrew voice cloning."""
+
+    HF_REPO_ID = "ResembleAI/chatterbox"
+
+    # Files specific to the multilingual model
+    _MTL_WEIGHT_FILES: ClassVar[List[str]] = [
+        "t3_mtl23ls_v2.safetensors",
+        "s3gen.pt",
+        "ve.pt",
+    ]
+
+    # Class-level lock for torch.load monkey-patching (shared across calls)
+    _load_lock: ClassVar[threading.Lock] = threading.Lock()
+
+    def __init__(self):
+        self.model = None
+        self._device = None
+        self._model_load_lock = asyncio.Lock()
+
+    def _get_device(self) -> str:
+        """Get the best available device. Forces CPU on macOS (MPS issue)."""
+        if platform.system() == "Darwin":
+            return "cpu"
+        try:
+            import torch
+            if torch.cuda.is_available():
+                return "cuda"
+        except ImportError:
+            pass
+        return "cpu"
+
+    def is_loaded(self) -> bool:
+        """Check if model is loaded."""
+        return self.model is not None
+
+    def _get_model_path(self, model_size: str) -> str:
+        """Get model path (Chatterbox has a single model)."""
+        return self.HF_REPO_ID
+
+    def _is_model_cached(self, model_size: str) -> bool:
+        """Check if the Chatterbox multilingual model is cached locally."""
+        try:
+            from huggingface_hub import constants as hf_constants
+            repo_cache = Path(hf_constants.HF_HUB_CACHE) / (
+                "models--" + self.HF_REPO_ID.replace("/", "--")
+            )
+
+            if not repo_cache.exists():
+                return False
+
+            blobs_dir = repo_cache / "blobs"
+            if blobs_dir.exists() and any(blobs_dir.glob("*.incomplete")):
+                return False
+
+            # Check specifically for multilingual weight files
+            snapshots_dir = repo_cache / "snapshots"
+            if snapshots_dir.exists():
+                for fname in self._MTL_WEIGHT_FILES:
+                    if not any(snapshots_dir.rglob(fname)):
+                        return False
+                return True
+
+            return False
+        except Exception as e:
+            print(f"[ChatterboxTTSBackend._is_model_cached] Error: {e}")
+            return False
+
+    async def load_model(self, model_size: str = "default") -> None:
+        """Load the Chatterbox multilingual model."""
+        if self.model is not None:
+            return
+        async with self._model_load_lock:
+            if self.model is not None:
+                return
+            await asyncio.to_thread(self._load_model_sync, model_size)
+
+    def _load_model_sync(self, model_size: str):
+        """Synchronous model loading."""
+        try:
+            progress_manager = get_progress_manager()
+            task_manager = get_task_manager()
+            progress_model_name = "chatterbox-tts"
+
+            is_cached = self._is_model_cached(model_size)
+
+            progress_callback = create_hf_progress_callback(
+                progress_model_name, progress_manager
+            )
+            tracker = HFProgressTracker(
+                progress_callback, filter_non_downloads=is_cached
+            )
+
+            if not is_cached:
+                task_manager.start_download(progress_model_name)
+                progress_manager.update_progress(
+                    model_name=progress_model_name,
+                    current=0,
+                    total=0,
+                    filename="Connecting to HuggingFace...",
+                    status="downloading",
+                )
+
+            with tracker.patch_download():
+                device = self._get_device()
+                self._device = device
+
+                print(f"Loading Chatterbox Multilingual TTS model on {device}...")
+
+                import torch
+                from chatterbox.mtl_tts import ChatterboxMultilingualTTS
+
+                # Patch Hebrew diacritization: dicta-onnx needs a model_path
+                # argument in newer versions. Patch the tokenizer module so
+                # Chatterbox can find and use the dicta ONNX model.
+                self._patch_hebrew_diacritics()
+
+                # Monkey-patch torch.load to add map_location for CPU loading.
+                # The multilingual model's .pt files were saved on CUDA and
+                # from_local() doesn't pass map_location, so loading on CPU fails.
+                if device == "cpu":
+                    _orig_torch_load = torch.load
+
+                    def _patched_load(*args, **kwargs):
+                        kwargs.setdefault("map_location", "cpu")
+                        return _orig_torch_load(*args, **kwargs)
+
+                    with ChatterboxTTSBackend._load_lock:
+                        torch.load = _patched_load
+                        try:
+                            self.model = ChatterboxMultilingualTTS.from_pretrained(device=device)
+                        finally:
+                            torch.load = _orig_torch_load
+                else:
+                    self.model = ChatterboxMultilingualTTS.from_pretrained(device=device)
+
+                # Fix: transformers >= 4.36 defaults LlamaModel to sdpa attention
+                # which doesn't support output_attentions=True (needed by
+                # Chatterbox's AlignmentStreamAnalyzer). Force eager attention.
+                # TODO: remove once chatterbox-tts updates its model config.
+                t3_tfmr = self.model.t3.tfmr
+                if hasattr(t3_tfmr, 'config') and hasattr(t3_tfmr.config, '_attn_implementation'):
+                    t3_tfmr.config._attn_implementation = "eager"
+                    # Also update each layer's self_attn
+                    for layer in getattr(t3_tfmr, 'layers', []):
+                        if hasattr(layer, 'self_attn'):
+                            layer.self_attn._attn_implementation = "eager"
+
+            if not is_cached:
+                progress_manager.mark_complete(progress_model_name)
+                task_manager.complete_download(progress_model_name)
+
+            print("Chatterbox Multilingual TTS model loaded successfully")
+
+        except ImportError as e:
+            print(
+                "Error: chatterbox-tts package not found. "
+                "Install with: pip install chatterbox-tts"
+            )
+            progress_manager = get_progress_manager()
+            task_manager = get_task_manager()
+            progress_manager.mark_error("chatterbox-tts", str(e))
+            task_manager.error_download("chatterbox-tts", str(e))
+            raise
+        except Exception as e:
+            print(f"Error loading Chatterbox Multilingual TTS model: {e}")
+            progress_manager = get_progress_manager()
+            task_manager = get_task_manager()
+            progress_manager.mark_error("chatterbox-tts", str(e))
+            task_manager.error_download("chatterbox-tts", str(e))
+            raise
+
+    @staticmethod
+    def _patch_hebrew_diacritics():
+        """Patch chatterbox tokenizer to use local dicta-onnx model for Hebrew nikud."""
+        try:
+            dicta_model_path = str(
+                Path(__file__).resolve().parent.parent / "models" / "dicta-onnx" / "dicta-1.0.onnx"
+            )
+            if not Path(dicta_model_path).exists():
+                print(f"[Chatterbox] dicta model not found at {dicta_model_path}, Hebrew diacritics disabled")
+                return
+
+            from chatterbox.models.tokenizers import tokenizer as tok_mod
+            from dicta_onnx import Dicta
+
+            _dicta_instance = Dicta(dicta_model_path)
+
+            def _patched_add_hebrew_diacritics(text: str) -> str:
+                try:
+                    return _dicta_instance.add_diacritics(text)
+                except Exception as e:
+                    print(f"[Chatterbox] Hebrew diacritization failed: {e}")
+                    return text
+
+            tok_mod.add_hebrew_diacritics = _patched_add_hebrew_diacritics
+            print("[Chatterbox] Hebrew diacritization (nikud) enabled via dicta-onnx")
+        except Exception as e:
+            print(f"[Chatterbox] Could not patch Hebrew diacritics: {e}")
+
+    def unload_model(self) -> None:
+        """Unload model to free memory."""
+        if self.model is not None:
+            device = self._device
+            del self.model
+            self.model = None
+            self._device = None
+            if device == "cuda":
+                import torch
+                torch.cuda.empty_cache()
+            print("Chatterbox Multilingual TTS model unloaded")
+
+    async def create_voice_prompt(
+        self,
+        audio_path: str,
+        reference_text: str,
+        use_cache: bool = True,  # noqa: ARG002 — Chatterbox defers processing to generate()
+    ) -> Tuple[dict, bool]:
+        """
+        Create voice prompt from reference audio.
+
+        Chatterbox processes reference audio at generation time,
+        so the prompt simply stores the file path and text.
+        The use_cache parameter is accepted for API compatibility but not used.
+        """
+        voice_prompt = {
+            "ref_audio": str(audio_path),
+            "ref_text": reference_text,
+        }
+        return voice_prompt, False
+
+    async def combine_voice_prompts(
+        self,
+        audio_paths: List[str],
+        reference_texts: List[str],
+    ) -> Tuple[np.ndarray, str]:
+        """Combine multiple reference samples."""
+        combined_audio = []
+
+        for audio_path in audio_paths:
+            audio, _sr = load_audio(audio_path)
+            audio = normalize_audio(audio)
+            combined_audio.append(audio)
+
+        mixed = np.concatenate(combined_audio)
+        mixed = normalize_audio(mixed)
+        combined_text = " ".join(reference_texts)
+
+        return mixed, combined_text
+
+    # Tuned generation defaults per language.
+    # Lower temperature + higher cfg_weight = clearer pronunciation.
+    _LANG_DEFAULTS: ClassVar[dict] = {
+        "he": {"exaggeration": 0.4, "cfg_weight": 0.7, "temperature": 0.65, "repetition_penalty": 2.5},
+    }
+    _GLOBAL_DEFAULTS: ClassVar[dict] = {"exaggeration": 0.5, "cfg_weight": 0.5, "temperature": 0.8, "repetition_penalty": 2.0}
+
+    async def generate(
+        self,
+        text: str,
+        voice_prompt: dict,
+        language: str = "he",
+        seed: Optional[int] = None,
+        instruct: Optional[str] = None,
+        *,
+        exaggeration: Optional[float] = None,
+        cfg_weight: Optional[float] = None,
+        temperature: Optional[float] = None,
+        repetition_penalty: Optional[float] = None,
+    ) -> Tuple[np.ndarray, int]:
+        """
+        Generate multilingual audio using Chatterbox.
+
+        Args:
+            text: Text to synthesize
+            voice_prompt: Dict with ref_audio path
+            language: Language code (e.g. "he" for Hebrew)
+            seed: Random seed for reproducibility
+            instruct: Unused (kept for protocol compatibility)
+            exaggeration: Emotion intensity (0-1, default varies by lang)
+            cfg_weight: Classifier-free guidance (higher = more faithful)
+            temperature: Sampling temperature (lower = more deterministic)
+            repetition_penalty: Token repetition penalty
+
+        Returns:
+            Tuple of (audio_array, sample_rate)
+        """
+        await self.load_model()
+
+        ref_audio = voice_prompt.get("ref_audio")
+        if ref_audio and not Path(ref_audio).exists():
+            print(f"Warning: Reference audio not found: {ref_audio}")
+            ref_audio = None
+
+        # Merge language-specific defaults with any explicit overrides
+        lang_defaults = self._LANG_DEFAULTS.get(language, self._GLOBAL_DEFAULTS)
+        gen_params = {
+            "exaggeration": exaggeration if exaggeration is not None else lang_defaults.get("exaggeration", 0.5),
+            "cfg_weight": cfg_weight if cfg_weight is not None else lang_defaults.get("cfg_weight", 0.5),
+            "temperature": temperature if temperature is not None else lang_defaults.get("temperature", 0.8),
+            "repetition_penalty": repetition_penalty if repetition_penalty is not None else lang_defaults.get("repetition_penalty", 2.0),
+        }
+
+        def _generate_sync():
+            import torch
+
+            if seed is not None:
+                torch.manual_seed(seed)
+
+            print(f"[Chatterbox] Generating: lang={language}, params={gen_params}")
+
+            wav = self.model.generate(
+                text,
+                language_id=language,
+                audio_prompt_path=ref_audio,
+                **gen_params,
+            )
+
+            # Chatterbox returns a torch tensor; convert to numpy
+            if isinstance(wav, torch.Tensor):
+                audio = wav.squeeze().cpu().numpy().astype(np.float32)
+            else:
+                audio = np.asarray(wav, dtype=np.float32)
+
+            sample_rate = getattr(self.model, 'sr', None) or getattr(self.model, 'sample_rate', 24000)
+
+            return audio, sample_rate
+
+        return await asyncio.to_thread(_generate_sync)
diff --git a/backend/backends/mlx_backend.py b/backend/backends/mlx_backend.py
index c4ecc090..6ec920fa 100644
--- a/backend/backends/mlx_backend.py
+++ b/backend/backends/mlx_backend.py
@@ -378,10 +378,34 @@ def _generate_sync():
 
         return audio, sample_rate
 
+    async def generate_with_adapter(
+        self,
+        text: str,
+        voice_prompt: dict,
+        adapter_path: str,
+        language: str = "en",
+        seed: Optional[int] = None,
+        instruct: Optional[str] = None,
+    ) -> Tuple[np.ndarray, int]:
+        """
+        Generate audio using a LoRA adapter.
+
+        MLX adapter support is experimental. Falls back to standard generation
+        if adapter loading fails.
+        """
+        print(f"[MLX] generate_with_adapter called. Adapter: {adapter_path}")
+        print("[MLX] MLX LoRA adapter loading is experimental, falling back to standard generation")
+        # MLX doesn't have mature PEFT/LoRA support for Qwen3-TTS yet.
+        # Fall back to standard generation for now.
+        return await self.generate(text, voice_prompt, language, seed, instruct)
+
+
+from . import STT_MODEL_MAP
+
 
 class MLXSTTBackend:
     """MLX-based STT backend using mlx-audio Whisper."""
-    
+
     def __init__(self, model_size: str = "base"):
         self.model = None
         self.model_size = model_size
@@ -389,20 +413,24 @@ def __init__(self, model_size: str = "base"):
     def is_loaded(self) -> bool:
         """Check if model is loaded."""
         return self.model is not None
-    
+
+    def _resolve_model_name(self, model_size: str) -> str:
+        """Resolve a model size key to a HuggingFace model name."""
+        return STT_MODEL_MAP.get(model_size, f"openai/whisper-{model_size}")
+
     def _is_model_cached(self, model_size: str) -> bool:
         """
         Check if the Whisper model is already cached locally AND fully downloaded.
-        
+
         Args:
             model_size: Model size to check
-            
+
         Returns:
             True if model is fully cached, False if missing or incomplete
         """
         try:
             from huggingface_hub import constants as hf_constants
-            model_name = f"openai/whisper-{model_size}"
+            model_name = self._resolve_model_name(model_size)
             repo_cache = Path(hf_constants.HF_HUB_CACHE) / ("models--" + model_name.replace("/", "--"))
             
             if not repo_cache.exists():
@@ -473,8 +501,7 @@ def _load_model_sync(self, model_size: str):
             # Import mlx_audio
             from mlx_audio.stt import load
 
-            # MLX Whisper uses the standard OpenAI models
-            model_name = f"openai/whisper-{model_size}"
+            model_name = self._resolve_model_name(model_size)
 
             print(f"Loading MLX Whisper model {model_size}...")
 
@@ -542,7 +569,7 @@ async def transcribe(
 
         Args:
             audio_path: Path to audio file
-            language: Optional language hint (en or zh)
+            language: Optional language code (e.g. "he", "en", "zh")
 
         Returns:
             Transcribed text
@@ -551,13 +578,31 @@ async def transcribe(
 
         def _transcribe_sync():
             """Run synchronous transcription in thread pool."""
-            # MLX Whisper transcription using generate method
-            # The generate method accepts audio path directly
-            decode_options = {}
+            decode_options = {
+                "task": "transcribe",
+            }
+
             if language:
                 decode_options["language"] = language
 
-            result = self.model.generate(str(audio_path), **decode_options)
+            # For Hebrew (and other non-English): prevent language drift
+            # by disabling conditioning on previous text. Without this,
+            # if one 30s chunk drifts to Arabic, all subsequent chunks
+            # also output Arabic because they condition on wrong output.
+            if language and language not in ("en",):
+                result = self.model.generate(
+                    str(audio_path),
+                    condition_on_previous_text=False,
+                    # Temperature fallback: start greedy, retry with more
+                    # randomness if compression ratio is too high (repetition)
+                    temperature=(0.0, 0.2, 0.4, 0.6, 0.8, 1.0),
+                    compression_ratio_threshold=2.0,
+                    no_speech_threshold=0.6,
+                    hallucination_silence_threshold=0.5,
+                    **decode_options,
+                )
+            else:
+                result = self.model.generate(str(audio_path), **decode_options)
 
             # Extract text from result
             if isinstance(result, str):
diff --git a/backend/backends/pytorch_backend.py b/backend/backends/pytorch_backend.py
index d0cba11a..bfdc9e7f 100644
--- a/backend/backends/pytorch_backend.py
+++ b/backend/backends/pytorch_backend.py
@@ -152,34 +152,27 @@ def _load_model_sync(self, model_size: str):
             progress_callback = create_hf_progress_callback(model_name, progress_manager)
             tracker = HFProgressTracker(progress_callback, filter_non_downloads=is_cached)
 
-            # Patch tqdm BEFORE importing qwen_tts
-            tracker_context = tracker.patch_download()
-            tracker_context.__enter__()
+            # Patch tqdm BEFORE importing qwen_tts so download
+            # progress is captured via the HFProgressTracker.
+            with tracker.patch_download():
+                from qwen_tts import Qwen3TTSModel
 
-            # Import qwen_tts
-            from qwen_tts import Qwen3TTSModel
+                model_path = self._get_model_path(model_size)
 
-            # Get model path (local or HuggingFace Hub ID)
-            model_path = self._get_model_path(model_size)
+                print(f"Loading TTS model {model_size} on {self.device}...")
 
-            print(f"Loading TTS model {model_size} on {self.device}...")
+                # Only track download progress if model is NOT cached
+                if not is_cached:
+                    task_manager.start_download(model_name)
 
-            # Only track download progress if model is NOT cached
-            if not is_cached:
-                # Start tracking download task
-                task_manager.start_download(model_name)
-
-                # Initialize progress state so SSE endpoint has initial data to send
-                progress_manager.update_progress(
-                    model_name=model_name,
-                    current=0,
-                    total=0,  # Will be updated once actual total is known
-                    filename="Connecting to HuggingFace...",
-                    status="downloading",
-                )
+                    progress_manager.update_progress(
+                        model_name=model_name,
+                        current=0,
+                        total=0,
+                        filename="Connecting to HuggingFace...",
+                        status="downloading",
+                    )
 
-            # Load the model (tqdm is patched, but filters out non-download progress)
-            try:
                 # Don't pass device_map on CPU: accelerate's meta-tensor mechanism
                 # causes "Cannot copy out of meta tensor" when moving to CPU.
                 # Instead load directly then call .to(device) if needed.
@@ -195,9 +188,6 @@ def _load_model_sync(self, model_size: str):
                         device_map=self.device,
                         torch_dtype=torch.bfloat16,
                     )
-            finally:
-                # Exit the patch context
-                tracker_context.__exit__(None, None, None)
             
             # Only mark download as complete if we were tracking it
             if not is_cached:
@@ -369,9 +359,12 @@ def _generate_sync():
         return audio, sample_rate
 
 
+from . import STT_MODEL_MAP
+
+
 class PyTorchSTTBackend:
     """PyTorch-based STT backend using Whisper."""
-    
+
     def __init__(self, model_size: str = "base"):
         self.model = None
         self.processor = None
@@ -403,20 +396,24 @@ def _get_device(self) -> str:
     def is_loaded(self) -> bool:
         """Check if model is loaded."""
         return self.model is not None
-    
+
+    def _resolve_model_name(self, model_size: str) -> str:
+        """Resolve a model size key to a HuggingFace model name."""
+        return STT_MODEL_MAP.get(model_size, f"openai/whisper-{model_size}")
+
     def _is_model_cached(self, model_size: str) -> bool:
         """
         Check if the Whisper model is already cached locally AND fully downloaded.
-        
+
         Args:
             model_size: Model size to check
-            
+
         Returns:
             True if model is fully cached, False if missing or incomplete
         """
         try:
             from huggingface_hub import constants as hf_constants
-            model_name = f"openai/whisper-{model_size}"
+            model_name = self._resolve_model_name(model_size)
             repo_cache = Path(hf_constants.HF_HUB_CACHE) / ("models--" + model_name.replace("/", "--"))
             
             if not repo_cache.exists():
@@ -451,26 +448,24 @@ async def load_model_async(self, model_size: Optional[str] = None):
         Args:
             model_size: Model size (tiny, base, small, medium, large)
         """
-        print(f"[DEBUG] load_model_async called with size: {model_size}")
         if model_size is None:
             model_size = self.model_size
 
-        print(f"[DEBUG] Model already loaded? {self.model is not None}, current size: {self.model_size}, requested: {model_size}")
         if self.model is not None and self.model_size == model_size:
-            print(f"[DEBUG] Early return - model already loaded")
             return
 
-        print(f"[DEBUG] Calling asyncio.to_thread for _load_model_sync")
+        # Free previous model before loading a different size
+        if self.model is not None:
+            self.unload_model()
+
         # Run blocking load in thread pool
         await asyncio.to_thread(self._load_model_sync, model_size)
-        print(f"[DEBUG] asyncio.to_thread completed")
     
     # Alias for compatibility
     load_model = load_model_async
     
     def _load_model_sync(self, model_size: str):
         """Synchronous model loading."""
-        print(f"[DEBUG] _load_model_sync called for Whisper {model_size}")
         try:
             progress_manager = get_progress_manager()
             task_manager = get_task_manager()
@@ -485,48 +480,48 @@ def _load_model_sync(self, model_size: str):
             progress_callback = create_hf_progress_callback(progress_model_name, progress_manager)
             tracker = HFProgressTracker(progress_callback, filter_non_downloads=is_cached)
 
-            # Patch tqdm BEFORE importing transformers
-            print("[DEBUG] Starting tqdm patch BEFORE transformers import")
-            tracker_context = tracker.patch_download()
-            tracker_context.__enter__()
-            print("[DEBUG] tqdm patched, now importing transformers")
+            # Patch tqdm BEFORE importing transformers so download
+            # progress is captured via the HFProgressTracker.
+            with tracker.patch_download():
+                from transformers import WhisperProcessor, WhisperForConditionalGeneration
 
-            # Import transformers
-            from transformers import WhisperProcessor, WhisperForConditionalGeneration
+                model_name = self._resolve_model_name(model_size)
 
-            model_name = f"openai/whisper-{model_size}"
-            print(f"[DEBUG] Model name: {model_name}")
+                print(f"Loading Whisper model {model_size} on {self.device}...")
 
-            print(f"Loading Whisper model {model_size} on {self.device}...")
+                # Only track download progress if model is NOT cached
+                if not is_cached:
+                    task_manager.start_download(progress_model_name)
 
-            # Only track download progress if model is NOT cached
-            if not is_cached:
-                # Start tracking download task
-                task_manager.start_download(progress_model_name)
-
-                # Initialize progress state so SSE endpoint has initial data to send
-                progress_manager.update_progress(
-                    model_name=progress_model_name,
-                    current=0,
-                    total=0,  # Will be updated once actual total is known
-                    filename="Connecting to HuggingFace...",
-                    status="downloading",
-                )
+                    progress_manager.update_progress(
+                        model_name=progress_model_name,
+                        current=0,
+                        total=0,
+                        filename="Connecting to HuggingFace...",
+                        status="downloading",
+                    )
 
-            # Load models (tqdm is patched, but filters out non-download progress)
-            try:
                 self.processor = WhisperProcessor.from_pretrained(model_name)
-                self.model = WhisperForConditionalGeneration.from_pretrained(model_name)
-            finally:
-                # Exit the patch context
-                tracker_context.__exit__(None, None, None)
-            
+                if self.device == "cpu":
+                    self.model = WhisperForConditionalGeneration.from_pretrained(
+                        model_name,
+                        torch_dtype=torch.float32,
+                        low_cpu_mem_usage=True,
+                    )
+                else:
+                    self.model = WhisperForConditionalGeneration.from_pretrained(
+                        model_name,
+                        device_map=self.device,
+                        torch_dtype=torch.bfloat16,
+                    )
+
             # Only mark download as complete if we were tracking it
             if not is_cached:
                 progress_manager.mark_complete(progress_model_name)
                 task_manager.complete_download(progress_model_name)
-            
-            self.model.to(self.device)
+
+            if self.device == "cpu":
+                self.model.to(self.device)
             self.model_size = model_size
             
             print(f"Whisper model {model_size} loaded successfully")
@@ -560,21 +555,21 @@ async def transcribe(
     ) -> str:
         """
         Transcribe audio to text.
-        
+
         Args:
             audio_path: Path to audio file
-            language: Optional language hint (en or zh)
-            
+            language: Optional language code (e.g. "he", "en", "zh")
+
         Returns:
             Transcribed text
         """
         await self.load_model_async(None)
-        
+
         def _transcribe_sync():
             """Run synchronous transcription in thread pool."""
             # Load audio
-            audio, sr = load_audio(audio_path, sample_rate=16000)
-            
+            audio, _sr = load_audio(audio_path, sample_rate=16000)
+
             # Process audio
             inputs = self.processor(
                 audio,
@@ -582,31 +577,50 @@ def _transcribe_sync():
                 return_tensors="pt",
             )
             inputs = inputs.to(self.device)
-            
-            # Set language if provided
+
+            # Force language and task via decoder prompt IDs
             forced_decoder_ids = None
             if language:
-                # Support all languages from frontend: en, zh, ja, ko, de, fr, ru, pt, es, it
-                # Whisper supports these and many more
                 forced_decoder_ids = self.processor.get_decoder_prompt_ids(
                     language=language,
                     task="transcribe",
                 )
-            
-            # Generate transcription
+
+            # Generate transcription with language-aware settings
+            generate_kwargs = {
+                "input_features": inputs["input_features"],
+                "forced_decoder_ids": forced_decoder_ids,
+            }
+
+            # For non-English: use greedy decoding + suppress language
+            # drift by forcing language tokens throughout generation
+            if language and language not in ("en",):
+                tokenizer = self.processor.tokenizer
+                lang_token = f"<|{language}|>"
+                if lang_token in tokenizer.get_vocab():
+                    # Suppress all other language tokens to prevent drift
+                    all_lang_tokens = []
+                    for tok in tokenizer.additional_special_tokens:
+                        if not (tok.startswith("<|") and tok.endswith("|>")):
+                            continue
+                        if tok in (lang_token, "<|transcribe|>", "<|notimestamps|>"):
+                            continue
+                        tid = tokenizer.convert_tokens_to_ids(tok)
+                        if tid is not None and tid != tokenizer.unk_token_id:
+                            all_lang_tokens.append(tid)
+                    if all_lang_tokens:
+                        generate_kwargs["suppress_tokens"] = all_lang_tokens
+
             with torch.no_grad():
-                predicted_ids = self.model.generate(
-                    inputs["input_features"],
-                    forced_decoder_ids=forced_decoder_ids,
-                )
-            
+                predicted_ids = self.model.generate(**generate_kwargs)
+
             # Decode
             transcription = self.processor.batch_decode(
                 predicted_ids,
                 skip_special_tokens=True,
             )[0]
-            
+
             return transcription.strip()
-        
+
         # Run blocking transcription in thread pool
         return await asyncio.to_thread(_transcribe_sync)
diff --git a/backend/channels.py b/backend/channels.py
index 146c003d..fd905862 100644
--- a/backend/channels.py
+++ b/backend/channels.py
@@ -3,7 +3,7 @@
 """
 
 from typing import List, Optional
-from datetime import datetime
+from datetime import datetime, timezone
 import uuid
 from sqlalchemy.orm import Session
 
@@ -81,7 +81,7 @@ async def create_channel(
         id=str(uuid.uuid4()),
         name=data.name,
         is_default=False,
-        created_at=datetime.utcnow(),
+        created_at=datetime.now(timezone.utc),
     )
     db.add(channel)
     db.flush()
diff --git a/backend/config.py b/backend/config.py
index b5c64825..85dfd60b 100644
--- a/backend/config.py
+++ b/backend/config.py
@@ -66,3 +66,9 @@ def get_models_dir() -> Path:
     path = _data_dir / "models"
     path.mkdir(parents=True, exist_ok=True)
     return path
+
+def get_finetune_dir() -> Path:
+    """Get finetune directory path."""
+    path = _data_dir / "finetune"
+    path.mkdir(parents=True, exist_ok=True)
+    return path
diff --git a/backend/database.py b/backend/database.py
index 3b9c51ee..6d4e778a 100644
--- a/backend/database.py
+++ b/backend/database.py
@@ -5,7 +5,7 @@
 from sqlalchemy import create_engine, Column, String, Integer, Float, DateTime, Text, ForeignKey, Boolean
 from sqlalchemy.ext.declarative import declarative_base
 from sqlalchemy.orm import sessionmaker, Session
-from datetime import datetime
+from datetime import datetime, timezone
 import uuid
 from pathlib import Path
 
@@ -23,8 +23,8 @@ class VoiceProfile(Base):
     description = Column(Text)
     language = Column(String, default="en")
     avatar_path = Column(String, nullable=True)
-    created_at = Column(DateTime, default=datetime.utcnow)
-    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+    created_at = Column(DateTime, default=lambda: datetime.now(timezone.utc))
+    updated_at = Column(DateTime, default=lambda: datetime.now(timezone.utc), onupdate=lambda: datetime.now(timezone.utc))
 
 
 class ProfileSample(Base):
@@ -49,7 +49,7 @@ class Generation(Base):
     duration = Column(Float, nullable=False)
     seed = Column(Integer)
     instruct = Column(Text)
-    created_at = Column(DateTime, default=datetime.utcnow)
+    created_at = Column(DateTime, default=lambda: datetime.now(timezone.utc))
 
 
 class Story(Base):
@@ -59,8 +59,8 @@ class Story(Base):
     id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4()))
     name = Column(String, nullable=False)
     description = Column(Text)
-    created_at = Column(DateTime, default=datetime.utcnow)
-    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+    created_at = Column(DateTime, default=lambda: datetime.now(timezone.utc))
+    updated_at = Column(DateTime, default=lambda: datetime.now(timezone.utc), onupdate=lambda: datetime.now(timezone.utc))
 
 
 class StoryItem(Base):
@@ -74,7 +74,7 @@ class StoryItem(Base):
     track = Column(Integer, nullable=False, default=0)  # Track number (0 = main track)
     trim_start_ms = Column(Integer, nullable=False, default=0)  # Milliseconds trimmed from start
     trim_end_ms = Column(Integer, nullable=False, default=0)  # Milliseconds trimmed from end
-    created_at = Column(DateTime, default=datetime.utcnow)
+    created_at = Column(DateTime, default=lambda: datetime.now(timezone.utc))
 
 
 class Project(Base):
@@ -84,8 +84,8 @@ class Project(Base):
     id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4()))
     name = Column(String, nullable=False)
     data = Column(Text)  # JSON string
-    created_at = Column(DateTime, default=datetime.utcnow)
-    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+    created_at = Column(DateTime, default=lambda: datetime.now(timezone.utc))
+    updated_at = Column(DateTime, default=lambda: datetime.now(timezone.utc), onupdate=lambda: datetime.now(timezone.utc))
 
 
 class AudioChannel(Base):
@@ -95,7 +95,7 @@ class AudioChannel(Base):
     id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4()))
     name = Column(String, nullable=False)
     is_default = Column(Boolean, default=False)
-    created_at = Column(DateTime, default=datetime.utcnow)
+    created_at = Column(DateTime, default=lambda: datetime.now(timezone.utc))
 
 
 class ChannelDeviceMapping(Base):
diff --git a/backend/export_import.py b/backend/export_import.py
index 6d705aa4..5e85c9f1 100644
--- a/backend/export_import.py
+++ b/backend/export_import.py
@@ -6,6 +6,7 @@
 """
 
 import json
+import uuid
 import zipfile
 import io
 from pathlib import Path
@@ -321,11 +322,9 @@ async def import_generation_from_zip(file_bytes: bytes, db: Session) -> dict:
     Raises:
         ValueError: If ZIP is invalid or missing required files
     """
-    from pathlib import Path
     import tempfile
     import shutil
-    from datetime import datetime
-    from . import config
+    from datetime import datetime, timezone
     
     zip_buffer = io.BytesIO(file_bytes)
     
@@ -393,7 +392,7 @@ async def import_generation_from_zip(file_bytes: bytes, db: Session) -> dict:
                 generations_dir.mkdir(parents=True, exist_ok=True)
                 
                 # Generate new ID for this generation
-                new_generation_id = str(__import__('uuid').uuid4())
+                new_generation_id = str(uuid.uuid4())
                 
                 # Copy audio to generations directory
                 audio_dest = generations_dir / f"{new_generation_id}.wav"
@@ -409,7 +408,7 @@ async def import_generation_from_zip(file_bytes: bytes, db: Session) -> dict:
                     duration=generation_data["duration"],
                     seed=generation_data.get("seed"),
                     instruct=generation_data.get("instruct"),
-                    created_at=datetime.utcnow(),
+                    created_at=datetime.now(timezone.utc),
                 )
                 
                 db.add(db_generation)
diff --git a/backend/history.py b/backend/history.py
index 64834d30..e910af44 100644
--- a/backend/history.py
+++ b/backend/history.py
@@ -3,7 +3,7 @@
 """
 
 from typing import List, Optional, Tuple
-from datetime import datetime
+from datetime import datetime, timezone
 import uuid
 import shutil
 from pathlib import Path
@@ -55,7 +55,7 @@ async def create_generation(
         duration=duration,
         seed=seed,
         instruct=instruct,
-        created_at=datetime.utcnow(),
+        created_at=datetime.now(timezone.utc),
     )
 
     db.add(db_generation)
diff --git a/backend/main.py b/backend/main.py
index e218d237..eaae2174 100644
--- a/backend/main.py
+++ b/backend/main.py
@@ -4,13 +4,13 @@
 Handles voice cloning, generation history, and server mode.
 """
 
-from fastapi import FastAPI, Depends, UploadFile, File, Form, HTTPException
+from fastapi import FastAPI, Depends, Request, UploadFile, File, Form, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import FileResponse, StreamingResponse
 from fastapi.staticfiles import StaticFiles
 from sqlalchemy.orm import Session
 from typing import List, Optional
-from datetime import datetime
+from datetime import datetime, timezone
 import asyncio
 import uvicorn
 import argparse
@@ -19,7 +19,6 @@
 import io
 from pathlib import Path
 import uuid
-import asyncio
 import signal
 import os
 from urllib.parse import quote
@@ -600,57 +599,102 @@ async def generate_speech(
         if not profile:
             raise HTTPException(status_code=404, detail="Profile not found")
         
-        # Generate audio
+        # Generate audio — route to the appropriate TTS backend
+        if data.language == "he":
+            # Hebrew → use Chatterbox TTS
+            chatterbox = tts.get_chatterbox_model()
+
+            if not chatterbox._is_model_cached("default"):
+                model_name = "chatterbox-tts"
+
+                async def download_chatterbox_background():
+                    try:
+                        await chatterbox.load_model("default")
+                    except Exception as e:
+                        task_manager.error_download(model_name, str(e))
+
+                task_manager.start_download(model_name)
+                _task = asyncio.create_task(download_chatterbox_background())  # noqa: F841
+
+                raise HTTPException(
+                    status_code=202,
+                    detail={
+                        "message": "Chatterbox TTS model is being downloaded. Please wait and try again.",
+                        "model_name": model_name,
+                        "downloading": True,
+                    },
+                )
 
-        # Resolve model size and load the correct model FIRST.
-        # This must happen before create_voice_prompt_for_profile because that
-        # function calls load_model_async(None), which falls back to self.model_size.
-        # If the model is already loaded with the right size at that point, it
-        # returns immediately and the voice prompt is created by the correct model.
-        tts_model = tts.get_tts_model()
-        model_size = data.model_size or "1.7B"
+            await chatterbox.load_model("default")
 
-        # Check if model needs to be downloaded first
-        model_path = tts_model._get_model_path(model_size)
-        if not tts_model._is_model_cached(model_size):
-            # Model is not fully cached — kick off a background download and tell
-            # the client to retry once it's ready.
-            model_name = f"qwen-tts-{model_size}"
+            voice_prompt = await profiles.create_voice_prompt_for_profile(
+                data.profile_id,
+                db,
+                tts_backend=chatterbox,
+            )
 
-            async def download_model_background():
-                try:
-                    await tts_model.load_model_async(model_size)
-                except Exception as e:
-                    task_manager.error_download(model_name, str(e))
+            audio, sample_rate = await chatterbox.generate(
+                data.text,
+                voice_prompt,
+                data.language,
+                data.seed,
+                data.instruct,
+            )
+        else:
+            # All other languages → use Qwen TTS
+            # Resolve model size and load the correct model FIRST.
+            # This must happen before create_voice_prompt_for_profile because that
+            # function calls load_model_async(None), which falls back to self.model_size.
+            # If the model is already loaded with the right size at that point, it
+            # returns immediately and the voice prompt is created by the correct model.
+            tts_model = tts.get_tts_model()
+            model_size = data.model_size or "1.7B"
+
+            # Check if model needs to be downloaded first
+            if not tts_model._is_model_cached(model_size):
+                # Model is not fully cached — kick off a background download and tell
+                # the client to retry once it's ready.
+                model_name = f"qwen-tts-{model_size}"
+
+                async def download_model_background():
+                    try:
+                        await tts_model.load_model_async(model_size)
+                    except Exception as e:
+                        task_manager.error_download(model_name, str(e))
+
+                task_manager.start_download(model_name)
+                _task = asyncio.create_task(download_model_background())  # noqa: F841
+
+                raise HTTPException(
+                    status_code=202,
+                    detail={
+                        "message": f"Model {model_size} is being downloaded. Please wait and try again.",
+                        "model_name": model_name,
+                        "downloading": True,
+                    },
+                )
 
-            task_manager.start_download(model_name)
-            asyncio.create_task(download_model_background())
+            # Load (or switch to) the requested model before building the voice prompt
+            await tts_model.load_model_async(model_size)
 
-            raise HTTPException(
-                status_code=202,
-                detail={
-                    "message": f"Model {model_size} is being downloaded. Please wait and try again.",
-                    "model_name": model_name,
-                    "downloading": True,
-                },
+            # Create voice prompt from profile (model is already loaded with correct size)
+            voice_prompt = await profiles.create_voice_prompt_for_profile(
+                data.profile_id,
+                db,
             )
 
-        # Load (or switch to) the requested model before building the voice prompt
-        await tts_model.load_model_async(model_size)
-
-        # Create voice prompt from profile (model is already loaded with correct size)
-        voice_prompt = await profiles.create_voice_prompt_for_profile(
-            data.profile_id,
-            db,
-        )
+            audio, sample_rate = await tts_model.generate(
+                data.text,
+                voice_prompt,
+                data.language,
+                data.seed,
+                data.instruct,
+            )
 
-        audio, sample_rate = await tts_model.generate(
-            data.text,
-            voice_prompt,
-            data.language,
-            data.seed,
-            data.instruct,
-        )
+        # Trim trailing silence/noise (Chatterbox-specific hallucination issue)
+        if data.language == "he":
+            from .utils.audio import trim_tts_output
+            audio = trim_tts_output(audio, sample_rate)
 
         # Calculate duration
         duration = len(audio) / sample_rate
@@ -678,6 +722,9 @@ async def download_model_background():
         
         return generation
         
+    except HTTPException:
+        task_manager.complete_generation(generation_id)
+        raise
     except ValueError as e:
         task_manager.complete_generation(generation_id)
         raise HTTPException(status_code=400, detail=str(e))
@@ -702,27 +749,55 @@ async def stream_speech(
     if not profile:
         raise HTTPException(status_code=404, detail="Profile not found")
 
-    tts_model = tts.get_tts_model()
-    model_size = data.model_size or "1.7B"
+    if data.language == "he":
+        # Hebrew → use Chatterbox TTS
+        chatterbox = tts.get_chatterbox_model()
 
-    if not tts_model._is_model_cached(model_size):
-        raise HTTPException(
-            status_code=400,
-            detail=f"Model {model_size} is not downloaded yet. Use /generate to trigger a download.",
+        if not chatterbox._is_model_cached("default"):
+            raise HTTPException(
+                status_code=400,
+                detail="Chatterbox TTS model is not downloaded yet. Use /generate to trigger a download.",
+            )
+
+        await chatterbox.load_model("default")
+
+        voice_prompt = await profiles.create_voice_prompt_for_profile(
+            data.profile_id, db, tts_backend=chatterbox
+        )
+
+        audio, sample_rate = await chatterbox.generate(
+            data.text,
+            voice_prompt,
+            data.language,
+            data.seed,
+            data.instruct,
         )
 
-    # Load the correct model before building the voice prompt (fixes issue #96)
-    await tts_model.load_model_async(model_size)
+        # Trim trailing silence/noise from Chatterbox output (same as /generate)
+        from .utils.audio import trim_tts_output
+        audio = trim_tts_output(audio, sample_rate)
+    else:
+        tts_model = tts.get_tts_model()
+        model_size = data.model_size or "1.7B"
+
+        if not tts_model._is_model_cached(model_size):
+            raise HTTPException(
+                status_code=400,
+                detail=f"Model {model_size} is not downloaded yet. Use /generate to trigger a download.",
+            )
+
+        # Load the correct model before building the voice prompt (fixes issue #96)
+        await tts_model.load_model_async(model_size)
 
-    voice_prompt = await profiles.create_voice_prompt_for_profile(data.profile_id, db)
+        voice_prompt = await profiles.create_voice_prompt_for_profile(data.profile_id, db)
 
-    audio, sample_rate = await tts_model.generate(
-        data.text,
-        voice_prompt,
-        data.language,
-        data.seed,
-        data.instruct,
-    )
+        audio, sample_rate = await tts_model.generate(
+            data.text,
+            voice_prompt,
+            data.language,
+            data.seed,
+            data.instruct,
+        )
 
     wav_bytes = tts.audio_to_wav_bytes(audio, sample_rate)
 
@@ -920,19 +995,38 @@ async def transcribe_audio(
         content = await file.read()
         tmp.write(content)
         tmp_path = tmp.name
-    
+
+    preprocessed_path = None
+
     try:
-        # Get audio duration
-        from .utils.audio import load_audio
-        audio, sr = load_audio(tmp_path)
+        # Load and preprocess audio for better transcription
+        from .utils.audio import load_audio, prepare_for_transcription, save_audio
+        audio, sr = load_audio(tmp_path, sample_rate=16000)
         duration = len(audio) / sr
-        
+
+        # Preprocess: trim silence + normalize
+        audio = prepare_for_transcription(audio, sr)
+
+        # Save preprocessed audio to a temp file for the backend
+        preprocessed_path = tmp_path + ".preprocessed.wav"
+        save_audio(audio, preprocessed_path, sample_rate=16000)
+
         # Transcribe
-        whisper_model = transcribe.get_whisper_model()
+        # Hebrew → use ivrit-ai turbo model via PyTorch backend
+        # (mlx_audio cannot load the ivrit-ai fine-tuned model);
+        # otherwise use default MLX/PyTorch backend
+        if language == "he":
+            model_size = "ivrit-v3-turbo"
+            whisper_model = transcribe.get_pytorch_whisper_model()
+        else:
+            whisper_model = transcribe.get_whisper_model()
+            model_size = whisper_model.model_size
 
-        # Check if Whisper model is downloaded (uses default size "base")
-        model_size = whisper_model.model_size
-        model_name = f"openai/whisper-{model_size}"
+        # Resolve model name using the backend's model map
+        if hasattr(whisper_model, '_resolve_model_name'):
+            model_name = whisper_model._resolve_model_name(model_size)
+        else:
+            model_name = f"openai/whisper-{model_size}"
 
         # Check if model is cached
         from huggingface_hub import constants as hf_constants
@@ -948,7 +1042,7 @@ async def download_whisper_background():
                     get_task_manager().error_download(progress_model_name, str(e))
 
             get_task_manager().start_download(progress_model_name)
-            asyncio.create_task(download_whisper_background())
+            _task = asyncio.create_task(download_whisper_background())  # noqa: F841
 
             # Return 202 Accepted
             raise HTTPException(
@@ -960,18 +1054,29 @@ async def download_whisper_background():
                 }
             )
 
-        text = await whisper_model.transcribe(tmp_path, language)
-        
+        # Load the correct model (may switch from base→ivrit-v3 or vice versa)
+        current_size = getattr(whisper_model, 'model_size', None)
+        if current_size and current_size != model_size:
+            print(f"[transcribe] Switching STT model from {current_size} to {model_size}")
+        await whisper_model.load_model_async(model_size)
+
+        # Always pass language explicitly (critical for ivrit-ai models)
+        text = await whisper_model.transcribe(preprocessed_path, language)
+
         return models.TranscriptionResponse(
             text=text,
             duration=duration,
         )
-        
+
+    except HTTPException:
+        raise
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
     finally:
-        # Clean up temp file
+        # Clean up temp files
         Path(tmp_path).unlink(missing_ok=True)
+        if preprocessed_path:
+            Path(preprocessed_path).unlink(missing_ok=True)
 
 
 # ============================================
@@ -1244,6 +1349,54 @@ async def unload_model():
         raise HTTPException(status_code=500, detail=str(e))
 
 
+@app.post("/models/{model_name}/unload")
+async def unload_specific_model(model_name: str):
+    """Unload a specific model from memory to free resources."""
+    model_types = {
+        "qwen-tts-1.7B": ("tts", "1.7B"),
+        "qwen-tts-0.6B": ("tts", "0.6B"),
+        "whisper-base": ("whisper", "base"),
+        "whisper-small": ("whisper", "small"),
+        "whisper-medium": ("whisper", "medium"),
+        "whisper-large": ("whisper", "large"),
+        "whisper-ivrit-v3": ("whisper", "ivrit-v3"),
+        "whisper-ivrit-v3-turbo": ("whisper", "ivrit-v3-turbo"),
+        "chatterbox-tts": ("chatterbox", "default"),
+    }
+
+    if model_name not in model_types:
+        raise HTTPException(status_code=400, detail=f"Unknown model: {model_name}")
+
+    model_type, model_size = model_types[model_name]
+
+    try:
+        if model_type == "tts":
+            tts_model = tts.get_tts_model()
+            if not tts_model.is_loaded() or getattr(tts_model, 'model_size', None) != model_size:
+                raise HTTPException(status_code=400, detail=f"Model {model_name} is not loaded")
+            tts.unload_tts_model()
+        elif model_type == "whisper":
+            # ivrit models are loaded via the PyTorch STT backend (MLX can't load them)
+            if model_size.startswith("ivrit"):
+                whisper_model = transcribe.get_pytorch_whisper_model()
+            else:
+                whisper_model = transcribe.get_whisper_model()
+            if not whisper_model.is_loaded() or getattr(whisper_model, 'model_size', None) != model_size:
+                raise HTTPException(status_code=400, detail=f"Model {model_name} is not loaded")
+            whisper_model.unload_model()
+        elif model_type == "chatterbox":
+            chatterbox_model = tts.get_chatterbox_model()
+            if not chatterbox_model.is_loaded():
+                raise HTTPException(status_code=400, detail=f"Model {model_name} is not loaded")
+            tts.unload_chatterbox_model()
+
+        return {"message": f"Model {model_name} unloaded successfully"}
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
 @app.get("/models/progress/{model_name}")
 async def get_model_progress(model_name: str):
     """Get model download progress via Server-Sent Events."""
@@ -1294,14 +1447,27 @@ def check_tts_loaded(model_size: str):
         except Exception:
             return False
     
-    def check_whisper_loaded(model_size: str):
+    def check_whisper_loaded(model_size: str, *, use_pytorch: bool = False):
         """Check if Whisper model is loaded with specific size."""
         try:
-            whisper_model = transcribe.get_whisper_model()
+            whisper_model = (
+                transcribe.get_pytorch_whisper_model()
+                if use_pytorch
+                else transcribe.get_whisper_model()
+            )
             return whisper_model.is_loaded() and getattr(whisper_model, 'model_size', None) == model_size
         except Exception:
             return False
-    
+
+    def check_chatterbox_loaded():
+        """Check if Chatterbox TTS model is loaded."""
+        try:
+            from .backends import get_chatterbox_backend
+            cb = get_chatterbox_backend()
+            return cb.is_loaded()
+        except Exception:
+            return False
+
     # Use backend-specific model IDs
     if backend_type == "mlx":
         tts_1_7b_id = "mlx-community/Qwen3-TTS-12Hz-1.7B-Base-bf16"
@@ -1362,8 +1528,29 @@ def check_whisper_loaded(model_size: str):
             "model_size": "large",
             "check_loaded": lambda: check_whisper_loaded("large"),
         },
+        {
+            "model_name": "whisper-ivrit-v3",
+            "display_name": "Whisper Hebrew (ivrit-ai)",
+            "hf_repo_id": "ivrit-ai/whisper-large-v3",
+            "model_size": "ivrit-v3",
+            "check_loaded": lambda: check_whisper_loaded("ivrit-v3", use_pytorch=True),
+        },
+        {
+            "model_name": "whisper-ivrit-v3-turbo",
+            "display_name": "Whisper Hebrew Turbo (ivrit-ai)",
+            "hf_repo_id": "ivrit-ai/whisper-large-v3-turbo",
+            "model_size": "ivrit-v3-turbo",
+            "check_loaded": lambda: check_whisper_loaded("ivrit-v3-turbo", use_pytorch=True),
+        },
+        {
+            "model_name": "chatterbox-tts",
+            "display_name": "Chatterbox TTS (Hebrew)",
+            "hf_repo_id": "ResembleAI/chatterbox",
+            "model_size": "default",
+            "check_loaded": lambda: check_chatterbox_loaded(),
+        },
     ]
-    
+
     # Build a mapping of model_name -> hf_repo_id so we can check if shared repos are downloading
     model_to_repo = {cfg["model_name"]: cfg["hf_repo_id"] for cfg in model_configs}
     
@@ -1515,8 +1702,6 @@ def check_whisper_loaded(model_size: str):
 @app.post("/models/download")
 async def trigger_model_download(request: models.ModelDownloadRequest):
     """Trigger download of a specific model."""
-    import asyncio
-    
     task_manager = get_task_manager()
     progress_manager = get_progress_manager()
     
@@ -1545,8 +1730,20 @@ async def trigger_model_download(request: models.ModelDownloadRequest):
             "model_size": "large",
             "load_func": lambda: transcribe.get_whisper_model().load_model("large"),
         },
+        "whisper-ivrit-v3": {
+            "model_size": "ivrit-v3",
+            "load_func": lambda: transcribe.get_pytorch_whisper_model().load_model("ivrit-v3"),
+        },
+        "whisper-ivrit-v3-turbo": {
+            "model_size": "ivrit-v3-turbo",
+            "load_func": lambda: transcribe.get_pytorch_whisper_model().load_model("ivrit-v3-turbo"),
+        },
+        "chatterbox-tts": {
+            "model_size": "default",
+            "load_func": lambda: tts.get_chatterbox_model().load_model("default"),
+        },
     }
-    
+
     if request.model_name not in model_configs:
         raise HTTPException(status_code=400, detail=f"Unknown model: {request.model_name}")
     
@@ -1580,7 +1777,7 @@ async def download_in_background():
     )
 
     # Start download in background task (don't await)
-    asyncio.create_task(download_in_background())
+    _task = asyncio.create_task(download_in_background())  # noqa: F841
 
     # Return immediately - frontend should poll progress endpoint
     return {"message": f"Model {request.model_name} download started"}
@@ -1625,8 +1822,23 @@ async def delete_model(model_name: str):
             "model_size": "large",
             "model_type": "whisper",
         },
+        "whisper-ivrit-v3": {
+            "hf_repo_id": "ivrit-ai/whisper-large-v3",
+            "model_size": "ivrit-v3",
+            "model_type": "whisper",
+        },
+        "whisper-ivrit-v3-turbo": {
+            "hf_repo_id": "ivrit-ai/whisper-large-v3-turbo",
+            "model_size": "ivrit-v3-turbo",
+            "model_type": "whisper",
+        },
+        "chatterbox-tts": {
+            "hf_repo_id": "ResembleAI/chatterbox",
+            "model_size": "default",
+            "model_type": "chatterbox",
+        },
     }
-    
+
     if model_name not in model_configs:
         raise HTTPException(status_code=400, detail=f"Unknown model: {model_name}")
     
@@ -1640,10 +1852,18 @@ async def delete_model(model_name: str):
             if tts_model.is_loaded() and tts_model.model_size == config["model_size"]:
                 tts.unload_tts_model()
         elif config["model_type"] == "whisper":
-            whisper_model = transcribe.get_whisper_model()
+            # ivrit models are loaded via PyTorch STT backend (MLX can't load them)
+            if config["model_size"].startswith("ivrit"):
+                whisper_model = transcribe.get_pytorch_whisper_model()
+            else:
+                whisper_model = transcribe.get_whisper_model()
             if whisper_model.is_loaded() and whisper_model.model_size == config["model_size"]:
-                transcribe.unload_whisper_model()
-        
+                whisper_model.unload_model()
+        elif config["model_type"] == "chatterbox":
+            chatterbox_model = tts.get_chatterbox_model()
+            if chatterbox_model.is_loaded():
+                tts.unload_chatterbox_model()
+
         # Find and delete the cache directory (using HuggingFace's OS-specific cache location)
         cache_dir = hf_constants.HF_HUB_CACHE
         repo_cache_dir = Path(cache_dir) / ("models--" + hf_repo_id.replace("/", "--"))
@@ -1722,9 +1942,9 @@ async def get_active_tasks():
                 try:
                     started_at = datetime.fromisoformat(timestamp_str.replace('Z', '+00:00'))
                 except (ValueError, AttributeError):
-                    started_at = datetime.utcnow()
+                    started_at = datetime.now(timezone.utc)
             else:
-                started_at = datetime.utcnow()
+                started_at = datetime.now(timezone.utc)
             
             active_downloads.append(models.ActiveDownloadTask(
                 model_name=model_name,
@@ -1799,7 +2019,9 @@ async def shutdown_event():
     print("voicebox API shutting down...")
     # Unload models to free memory
     tts.unload_tts_model()
+    tts.unload_chatterbox_model()
     transcribe.unload_whisper_model()
+    transcribe.unload_pytorch_whisper_model()
 
 
 # ============================================
diff --git a/backend/models.py b/backend/models.py
index 59e45405..98351a1a 100644
--- a/backend/models.py
+++ b/backend/models.py
@@ -11,7 +11,7 @@ class VoiceProfileCreate(BaseModel):
     """Request model for creating a voice profile."""
     name: str = Field(..., min_length=1, max_length=100)
     description: Optional[str] = Field(None, max_length=500)
-    language: str = Field(default="en", pattern="^(zh|en|ja|ko|de|fr|ru|pt|es|it)$")
+    language: str = Field(default="en", pattern="^(zh|en|ja|ko|de|fr|ru|pt|es|it|he)$")
 
 
 class VoiceProfileResponse(BaseModel):
@@ -53,7 +53,7 @@ class GenerationRequest(BaseModel):
     """Request model for voice generation."""
     profile_id: str
     text: str = Field(..., min_length=1, max_length=5000)
-    language: str = Field(default="en", pattern="^(zh|en|ja|ko|de|fr|ru|pt|es|it)$")
+    language: str = Field(default="en", pattern="^(zh|en|ja|ko|de|fr|ru|pt|es|it|he)$")
     seed: Optional[int] = Field(None, ge=0)
     model_size: Optional[str] = Field(default="1.7B", pattern="^(1\\.7B|0\\.6B)$")
     instruct: Optional[str] = Field(None, max_length=500)
@@ -108,7 +108,7 @@ class HistoryListResponse(BaseModel):
 
 class TranscriptionRequest(BaseModel):
     """Request model for audio transcription."""
-    language: Optional[str] = Field(None, pattern="^(en|zh)$")
+    language: Optional[str] = Field(None, pattern="^(zh|en|ja|ko|de|fr|ru|pt|es|it|he)$")
 
 
 class TranscriptionResponse(BaseModel):
diff --git a/backend/profiles.py b/backend/profiles.py
index cda6bee0..d714de3f 100644
--- a/backend/profiles.py
+++ b/backend/profiles.py
@@ -3,7 +3,7 @@
 """
 
 from typing import List, Optional
-from datetime import datetime
+from datetime import datetime, timezone
 import uuid
 import shutil
 from pathlib import Path
@@ -52,8 +52,8 @@ async def create_profile(
         name=data.name,
         description=data.description,
         language=data.language,
-        created_at=datetime.utcnow(),
-        updated_at=datetime.utcnow(),
+        created_at=datetime.now(timezone.utc),
+        updated_at=datetime.now(timezone.utc),
     )
     
     db.add(db_profile)
@@ -116,7 +116,7 @@ async def add_profile_sample(
     db.add(db_sample)
     
     # Update profile timestamp
-    profile.updated_at = datetime.utcnow()
+    profile.updated_at = datetime.now(timezone.utc)
     
     db.commit()
     db.refresh(db_sample)
@@ -208,7 +208,7 @@ async def update_profile(
     profile.name = data.name
     profile.description = data.description
     profile.language = data.language
-    profile.updated_at = datetime.utcnow()
+    profile.updated_at = datetime.now(timezone.utc)
     
     db.commit()
     db.refresh(profile)
@@ -327,6 +327,7 @@ async def create_voice_prompt_for_profile(
     profile_id: str,
     db: Session,
     use_cache: bool = True,
+    tts_backend=None,
 ) -> dict:
     """
     Create a combined voice prompt from all samples in a profile.
@@ -335,6 +336,7 @@ async def create_voice_prompt_for_profile(
         profile_id: Profile ID
         db: Database session
         use_cache: Whether to use cached prompts
+        tts_backend: Optional TTS backend override (e.g. Chatterbox for Hebrew)
 
     Returns:
         Voice prompt dictionary
@@ -345,12 +347,12 @@ async def create_voice_prompt_for_profile(
     if not samples:
         raise ValueError(f"No samples found for profile {profile_id}")
 
-    tts_model = get_tts_model()
+    backend = tts_backend or get_tts_model()
 
     if len(samples) == 1:
         # Single sample - use directly
         sample = samples[0]
-        voice_prompt, _ = await tts_model.create_voice_prompt(
+        voice_prompt, _ = await backend.create_voice_prompt(
             sample.audio_path,
             sample.reference_text,
             use_cache=use_cache,
@@ -362,7 +364,7 @@ async def create_voice_prompt_for_profile(
         reference_texts = [s.reference_text for s in samples]
 
         # Combine audio
-        combined_audio, combined_text = await tts_model.combine_voice_prompts(
+        combined_audio, combined_text = await backend.combine_voice_prompts(
             audio_paths,
             reference_texts,
         )
@@ -382,7 +384,7 @@ async def create_voice_prompt_for_profile(
         save_audio(combined_audio, str(combined_path), 24000)
 
         # Create prompt from combined audio
-        voice_prompt, _ = await tts_model.create_voice_prompt(
+        voice_prompt, _ = await backend.create_voice_prompt(
             str(combined_path),
             combined_text,
             use_cache=use_cache,
@@ -446,7 +448,7 @@ async def upload_avatar(
 
     # Update database
     profile.avatar_path = str(output_path)
-    profile.updated_at = datetime.utcnow()
+    profile.updated_at = datetime.now(timezone.utc)
 
     db.commit()
     db.refresh(profile)
@@ -479,7 +481,7 @@ async def delete_avatar(
 
     # Update database
     profile.avatar_path = None
-    profile.updated_at = datetime.utcnow()
+    profile.updated_at = datetime.now(timezone.utc)
 
     db.commit()
 
diff --git a/backend/requirements.txt b/backend/requirements.txt
index 4af5cc85..a82fbbaa 100644
--- a/backend/requirements.txt
+++ b/backend/requirements.txt
@@ -13,6 +13,15 @@ transformers>=4.36.0
 accelerate>=0.26.0
 huggingface_hub>=0.20.0
 qwen-tts>=0.0.5
+# Hebrew TTS (Chatterbox) and its sub-dependencies
+chatterbox-tts>=0.1.0
+conformer
+dicta-onnx
+diffusers
+omegaconf
+pykakasi
+resemble-perth
+s3tokenizer
 
 # Audio processing
 librosa>=0.10.0
diff --git a/backend/stories.py b/backend/stories.py
index 2a2f5abb..4f026493 100644
--- a/backend/stories.py
+++ b/backend/stories.py
@@ -3,7 +3,7 @@
 """
 
 from typing import List, Optional
-from datetime import datetime
+from datetime import datetime, timezone
 import uuid
 import tempfile
 from pathlib import Path
@@ -44,8 +44,8 @@ async def create_story(
         id=str(uuid.uuid4()),
         name=data.name,
         description=data.description,
-        created_at=datetime.utcnow(),
-        updated_at=datetime.utcnow(),
+        created_at=datetime.now(timezone.utc),
+        updated_at=datetime.now(timezone.utc),
     )
 
     db.add(db_story)
@@ -173,7 +173,7 @@ async def update_story(
 
     story.name = data.name
     story.description = data.description
-    story.updated_at = datetime.utcnow()
+    story.updated_at = datetime.now(timezone.utc)
 
     db.commit()
     db.refresh(story)
@@ -307,13 +307,13 @@ async def add_item_to_story(
         generation_id=data.generation_id,
         start_time_ms=start_time_ms,
         track=track,
-        created_at=datetime.utcnow(),
+        created_at=datetime.now(timezone.utc),
     )
 
     db.add(item)
     
     # Update story updated_at
-    story.updated_at = datetime.utcnow()
+    story.updated_at = datetime.now(timezone.utc)
     
     db.commit()
     db.refresh(item)
@@ -380,7 +380,7 @@ async def move_story_item(
     # Update story updated_at
     story = db.query(DBStory).filter_by(id=story_id).first()
     if story:
-        story.updated_at = datetime.utcnow()
+        story.updated_at = datetime.now(timezone.utc)
 
     db.commit()
     db.refresh(item)
@@ -438,7 +438,7 @@ async def remove_item_from_story(
     # Update story updated_at
     story = db.query(DBStory).filter_by(id=story_id).first()
     if story:
-        story.updated_at = datetime.utcnow()
+        story.updated_at = datetime.now(timezone.utc)
 
     db.commit()
     return True
@@ -487,7 +487,7 @@ async def trim_story_item(
     # Update story updated_at
     story = db.query(DBStory).filter_by(id=story_id).first()
     if story:
-        story.updated_at = datetime.utcnow()
+        story.updated_at = datetime.now(timezone.utc)
 
     db.commit()
     db.refresh(item)
@@ -572,7 +572,7 @@ async def split_story_item(
         track=item.track,
         trim_start_ms=absolute_split_ms,
         trim_end_ms=current_trim_end,
-        created_at=datetime.utcnow(),
+        created_at=datetime.now(timezone.utc),
     )
 
     db.add(new_item)
@@ -580,7 +580,7 @@ async def split_story_item(
     # Update story updated_at
     story = db.query(DBStory).filter_by(id=story_id).first()
     if story:
-        story.updated_at = datetime.utcnow()
+        story.updated_at = datetime.now(timezone.utc)
 
     db.commit()
     db.refresh(item)
@@ -678,7 +678,7 @@ async def duplicate_story_item(
         track=original_item.track,
         trim_start_ms=current_trim_start,
         trim_end_ms=current_trim_end,
-        created_at=datetime.utcnow(),
+        created_at=datetime.now(timezone.utc),
     )
 
     db.add(new_item)
@@ -686,7 +686,7 @@ async def duplicate_story_item(
     # Update story updated_at
     story = db.query(DBStory).filter_by(id=story_id).first()
     if story:
-        story.updated_at = datetime.utcnow()
+        story.updated_at = datetime.now(timezone.utc)
 
     db.commit()
     db.refresh(new_item)
@@ -746,7 +746,7 @@ async def update_story_item_times(
         item_map[update.generation_id].start_time_ms = update.start_time_ms
 
     # Update story updated_at
-    story.updated_at = datetime.utcnow()
+    story.updated_at = datetime.now(timezone.utc)
 
     db.commit()
     return True
@@ -834,7 +834,7 @@ async def reorder_story_items(
         ))
 
     # Update story updated_at
-    story.updated_at = datetime.utcnow()
+    story.updated_at = datetime.now(timezone.utc)
 
     db.commit()
     return updated_items
diff --git a/backend/transcribe.py b/backend/transcribe.py
index 4d735fce..cc90ee49 100644
--- a/backend/transcribe.py
+++ b/backend/transcribe.py
@@ -3,20 +3,39 @@
 """
 
 from typing import Optional
-from .backends import get_stt_backend, STTBackend
+from .backends import get_stt_backend, get_pytorch_stt_backend, STTBackend
 
 
 def get_whisper_model() -> STTBackend:
     """
     Get STT backend instance (MLX or PyTorch based on platform).
-    
+
     Returns:
         STT backend instance
     """
     return get_stt_backend()
 
 
+def get_pytorch_whisper_model() -> STTBackend:
+    """
+    Get PyTorch STT backend instance.
+
+    Used for models that mlx_audio cannot load (e.g. ivrit-ai models).
+    On non-MLX platforms this returns the same instance as get_whisper_model().
+
+    Returns:
+        PyTorch STT backend instance
+    """
+    return get_pytorch_stt_backend()
+
+
 def unload_whisper_model():
     """Unload Whisper model to free memory."""
     backend = get_stt_backend()
     backend.unload_model()
+
+
+def unload_pytorch_whisper_model():
+    """Unload PyTorch Whisper model to free memory."""
+    backend = get_pytorch_stt_backend()
+    backend.unload_model()
diff --git a/backend/tts.py b/backend/tts.py
index 453f2f5c..672d9ead 100644
--- a/backend/tts.py
+++ b/backend/tts.py
@@ -7,7 +7,7 @@
 import io
 import soundfile as sf
 
-from .backends import get_tts_backend, TTSBackend
+from .backends import get_tts_backend, get_chatterbox_backend, TTSBackend
 
 
 def get_tts_model() -> TTSBackend:
@@ -26,6 +26,17 @@ def unload_tts_model():
     backend.unload_model()
 
 
+def get_chatterbox_model():
+    """Get Chatterbox TTS backend instance (for Hebrew)."""
+    return get_chatterbox_backend()
+
+
+def unload_chatterbox_model():
+    """Unload Chatterbox TTS model to free memory."""
+    backend = get_chatterbox_backend()
+    backend.unload_model()
+
+
 def audio_to_wav_bytes(audio: np.ndarray, sample_rate: int) -> bytes:
     """Convert audio array to WAV bytes."""
     buffer = io.BytesIO()
diff --git a/backend/utils/audio.py b/backend/utils/audio.py
index 302dff25..a7121d66 100644
--- a/backend/utils/audio.py
+++ b/backend/utils/audio.py
@@ -80,6 +80,136 @@ def save_audio(
     sf.write(path, audio, sample_rate)
 
 
+def prepare_for_transcription(
+    audio: np.ndarray,
+    sr: int = 16000,  # noqa: ARG001 — kept for API consistency
+) -> np.ndarray:
+    """
+    Prepare audio for Whisper transcription.
+
+    Trims leading/trailing silence and normalizes volume.
+    Does NOT apply denoising (Whisper handles noise natively).
+
+    Args:
+        audio: Input audio array (16kHz mono expected)
+        sr: Sample rate
+
+    Returns:
+        Preprocessed audio array
+    """
+    # Trim leading/trailing silence using librosa
+    trimmed, _ = librosa.effects.trim(audio, top_db=30)
+
+    # Peak normalization (scale to [-1, 1])
+    peak = np.max(np.abs(trimmed))
+    if peak > 0:
+        trimmed = trimmed / peak
+
+    return trimmed
+
+
+def trim_tts_output(
+    audio: np.ndarray,
+    sample_rate: int = 24000,
+    frame_ms: int = 20,
+    silence_threshold_db: float = -40.0,
+    min_silence_ms: int = 200,
+    max_internal_silence_ms: int = 1000,
+    fade_ms: int = 30,
+) -> np.ndarray:
+    """
+    Trim TTS-generated audio: removes trailing silence/noise AND cuts at
+    long internal silence gaps (Chatterbox hallucination boundary).
+
+    The Chatterbox T3 token generator can overshoot: after speech ends it
+    may emit silence tokens followed by garbage/hallucinated audio.  This
+    function detects the first long silence gap after speech starts and
+    cuts everything after it.
+
+    Args:
+        audio: Input audio array
+        sample_rate: Sample rate in Hz
+        frame_ms: Frame size in milliseconds for energy calculation
+        silence_threshold_db: Absolute silence threshold in dB
+        min_silence_ms: Minimum trailing silence before trimming
+        max_internal_silence_ms: Cut after a silence gap longer than this
+        fade_ms: Fade-out duration in milliseconds
+
+    Returns:
+        Trimmed audio with fade-out applied
+    """
+    if len(audio) == 0:
+        return audio
+
+    frame_size = int(sample_rate * frame_ms / 1000)
+    min_silence_frames = int(min_silence_ms / frame_ms)
+    max_internal_silence_frames = int(max_internal_silence_ms / frame_ms)
+    threshold = 10 ** (silence_threshold_db / 20)
+    n_frames = len(audio) // frame_size
+
+    if n_frames == 0:
+        return audio
+
+    # Calculate RMS per frame
+    rms_per_frame = np.array([
+        np.sqrt(np.mean(audio[i * frame_size : (i + 1) * frame_size] ** 2))
+        for i in range(n_frames)
+    ])
+
+    is_speech = rms_per_frame > threshold
+
+    # Find first speech frame (trim leading silence)
+    first_speech_frame = 0
+    for i in range(n_frames):
+        if is_speech[i]:
+            first_speech_frame = max(0, i - 1)  # Keep 1 frame before speech
+            break
+
+    # Scan forward from first speech: cut at any silence gap > max_internal_silence_ms
+    # This catches the pattern: [speech] [long silence] [garbage/hallucination]
+    speech_started = False
+    consecutive_silence = 0
+    cut_frame = n_frames  # Default: keep everything
+
+    for i in range(first_speech_frame, n_frames):
+        if is_speech[i]:
+            speech_started = True
+            consecutive_silence = 0
+        else:
+            if speech_started:
+                consecutive_silence += 1
+                if consecutive_silence >= max_internal_silence_frames:
+                    # Cut at the start of this silence gap
+                    cut_frame = i - consecutive_silence + 1
+                    break
+
+    # Also trim trailing silence from the cut point
+    last_speech_frame = cut_frame
+    for i in range(cut_frame - 1, first_speech_frame - 1, -1):
+        if is_speech[i]:
+            last_speech_frame = i + 1
+            break
+
+    # Only trim trailing if enough silence
+    trailing_silence = cut_frame - last_speech_frame
+    if trailing_silence >= min_silence_frames:
+        end_frame = last_speech_frame + 1
+    else:
+        end_frame = cut_frame
+
+    start_sample = first_speech_frame * frame_size
+    end_sample = min(end_frame * frame_size, len(audio))
+    trimmed = audio[start_sample:end_sample].copy()
+
+    # Apply cosine fade-out to prevent clicks
+    fade_samples = min(int(fade_ms * sample_rate / 1000), len(trimmed) // 4)
+    if fade_samples > 0:
+        fade = (np.cos(np.linspace(0, np.pi / 2, fade_samples)) ** 2).astype(np.float32)
+        trimmed[-fade_samples:] *= fade
+
+    return trimmed
+
+
 def validate_reference_audio(
     audio_path: str,
     min_duration: float = 2.0,
diff --git a/backend/utils/tasks.py b/backend/utils/tasks.py
index 05b8e019..3bb98af6 100644
--- a/backend/utils/tasks.py
+++ b/backend/utils/tasks.py
@@ -3,7 +3,7 @@
 """
 
 from typing import Optional, Dict, List
-from datetime import datetime
+from datetime import datetime, timezone
 from dataclasses import dataclass, field
 
 
@@ -12,7 +12,7 @@ class DownloadTask:
     """Represents an active download task."""
     model_name: str
     status: str = "downloading"  # downloading, extracting, complete, error
-    started_at: datetime = field(default_factory=datetime.utcnow)
+    started_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
     error: Optional[str] = None
 
 
@@ -22,7 +22,7 @@ class GenerationTask:
     task_id: str
     profile_id: str
     text_preview: str  # First 50 chars of text
-    started_at: datetime = field(default_factory=datetime.utcnow)
+    started_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
 
 
 class TaskManager:
diff --git a/bun.lock b/bun.lock
index 9e08a825..d271b5c6 100644
--- a/bun.lock
+++ b/bun.lock
@@ -13,7 +13,7 @@
     },
     "app": {
       "name": "@voicebox/app",
-      "version": "0.1.11",
+      "version": "0.1.13",
       "dependencies": {
         "@dnd-kit/core": "^6.3.1",
         "@dnd-kit/sortable": "^10.0.0",
@@ -68,7 +68,7 @@
     },
     "landing": {
       "name": "@voicebox/landing",
-      "version": "0.1.11",
+      "version": "0.1.13",
       "dependencies": {
         "@radix-ui/react-separator": "^1.1.8",
         "@radix-ui/react-slot": "^1.2.4",
@@ -93,7 +93,7 @@
     },
     "tauri": {
       "name": "@voicebox/tauri",
-      "version": "0.1.11",
+      "version": "0.1.13",
       "dependencies": {
         "@tauri-apps/api": "^2.0.0",
         "@tauri-apps/plugin-dialog": "^2.0.0",
@@ -116,7 +116,7 @@
     },
     "web": {
       "name": "@voicebox/web",
-      "version": "0.1.11",
+      "version": "0.1.13",
       "dependencies": {
         "@tanstack/react-query": "^5.0.0",
         "react": "^18.3.0",
@@ -125,6 +125,7 @@
         "zustand": "^4.5.0",
       },
       "devDependencies": {
+        "@tailwindcss/vite": "^4.0.0",
         "@types/react": "^18.3.0",
         "@types/react-dom": "^18.3.0",
         "@typescript-eslint/eslint-plugin": "^7.0.0",