diff --git a/app/src/components/ServerSettings/GpuAcceleration.tsx b/app/src/components/ServerSettings/GpuAcceleration.tsx
index 17da7690..69824d63 100644
--- a/app/src/components/ServerSettings/GpuAcceleration.tsx
+++ b/app/src/components/ServerSettings/GpuAcceleration.tsx
@@ -32,7 +32,7 @@ export function GpuAcceleration() {
   } = useQuery({
     queryKey: ['cuda-status', serverUrl],
     queryFn: () => apiClient.getCudaStatus(),
-    refetchInterval: cudaStatusLoading ? false : 10000,
+    refetchInterval: (query) => (query.state.status === 'pending' ? false : 10000),
     retry: 1,
     enabled: !!health, // Only fetch when backend is reachable
   });
diff --git a/app/src/components/ServerSettings/ModelManagement.tsx b/app/src/components/ServerSettings/ModelManagement.tsx
index 4783a880..ec94cb12 100644
--- a/app/src/components/ServerSettings/ModelManagement.tsx
+++ b/app/src/components/ServerSettings/ModelManagement.tsx
@@ -16,7 +16,7 @@ import {
   X,
   Zap,
 } from 'lucide-react';
-import { useCallback, useState } from 'react';
+import { useCallback, useMemo, useState } from 'react';
 import {
   AlertDialog,
   AlertDialogAction,
@@ -36,6 +36,7 @@ import {
   DialogHeader,
   DialogTitle,
 } from '@/components/ui/dialog';
+import { Progress } from '@/components/ui/progress';
 import { useToast } from '@/components/ui/use-toast';
 import { apiClient } from '@/lib/api/client';
 import type { ActiveDownloadTask, HuggingFaceModelInfo, ModelStatus } from '@/lib/api/types';
@@ -73,6 +74,14 @@ function formatPipelineTag(tag: string): string {
     .join(' ');
 }
 
+function formatBytes(bytes: number): string {
+  if (bytes === 0) return '0 B';
+  const k = 1024;
+  const sizes = ['B', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${(bytes / k ** i).toFixed(1)} ${sizes[i]}`;
+}
+
 export function ModelManagement() {
   const { toast } = useToast();
   const queryClient = useQueryClient();
@@ -98,7 +107,11 @@ export function ModelManagement() {
   const { data: activeTasks } = useQuery({
     queryKey: ['activeTasks'],
     queryFn: () => apiClient.getActiveTasks(),
-    refetchInterval: 5000,
+    refetchInterval: (query) => {
+      const data = query.state.data;
+      const hasActive = data?.downloads.some((d) => d.status === 'downloading');
+      return hasActive ? 1000 : 5000;
+    },
   });
 
   // HuggingFace model card query - only fetches when modal is open and model has a repo ID
@@ -133,6 +146,19 @@ export function ModelManagement() {
 
   const errorCount = erroredDownloads.size;
 
+  // Build progress map from active tasks for inline display
+  const downloadProgressMap = useMemo(() => {
+    const map = new Map<string, ActiveDownloadTask>();
+    if (activeTasks?.downloads) {
+      for (const dl of activeTasks.downloads) {
+        if (dl.status === 'downloading') {
+          map.set(dl.model_name, dl);
+        }
+      }
+    }
+    return map;
+  }, [activeTasks]);
+
   const handleDownloadComplete = useCallback(() => {
     setDownloadingModel(null);
     setDownloadingDisplayName(null);
@@ -371,16 +397,29 @@ export function ModelManagement() {
                         )}
                       </div>
 
-                      {/* Name + meta */}
+                      {/* Name + inline progress */}
                       <div className="flex-1 min-w-0">
                         <span className="text-sm font-medium">{model.display_name}</span>
+                        {isDownloading &&
+                          (() => {
+                            const dl = downloadProgressMap.get(model.model_name);
+                            const pct = dl?.progress ?? 0;
+                            const hasProgress = dl && dl.total && dl.total > 0;
+                            return (
+                              <div className="mt-1 space-y-0.5">
+                                <Progress value={hasProgress ? pct : undefined} className="h-1" />
+                                <div className="text-[10px] text-muted-foreground truncate">
+                                  {hasProgress
+                                    ? `${formatBytes(dl.current ?? 0)} / ${formatBytes(dl.total!)} (${pct.toFixed(0)}%)`
+                                    : dl?.filename || 'Connecting...'}
+                                </div>
+                              </div>
+                            );
+                          })()}
                       </div>
 
                       {/* Right side info */}
                       <div className="shrink-0 flex items-center gap-2">
-                        {isDownloading && (
-                          <span className="text-xs text-muted-foreground">Downloading...</span>
-                        )}
                         {hasError && (
                           <Badge variant="destructive" className="text-[10px] h-5">
                             Error
@@ -510,12 +549,6 @@ export function ModelManagement() {
                       Downloaded
                     </Badge>
                   )}
-                  {selectedState?.isDownloading && (
-                    <Badge variant="outline" className="text-xs">
-                      <Loader2 className="h-3 w-3 mr-1 animate-spin" />
-                      Downloading
-                    </Badge>
-                  )}
                   {selectedState?.hasError && (
                     <Badge variant="destructive" className="text-xs">
                       <CircleX className="h-3 w-3 mr-1" />
@@ -633,10 +666,25 @@ export function ModelManagement() {
                     </>
                   ) : selectedState?.isDownloading ? (
                     <>
-                      <Button size="sm" variant="outline" disabled className="flex-1">
-                        <Loader2 className="h-4 w-4 mr-2 animate-spin" />
-                        Downloading...
-                      </Button>
+                      <div className="flex-1 space-y-2">
+                        {(() => {
+                          const dl = freshSelectedModel
+                            ? downloadProgressMap.get(freshSelectedModel.model_name)
+                            : undefined;
+                          const pct = dl?.progress ?? 0;
+                          const hasProgress = dl && dl.total && dl.total > 0;
+                          return (
+                            <>
+                              <Progress value={hasProgress ? pct : undefined} className="h-2" />
+                              <div className="text-xs text-muted-foreground">
+                                {hasProgress
+                                  ? `${formatBytes(dl.current ?? 0)} / ${formatBytes(dl.total!)} (${pct.toFixed(1)}%)`
+                                  : dl?.filename || 'Connecting to HuggingFace...'}
+                              </div>
+                            </>
+                          );
+                        })()}
+                      </div>
                       <Button
                         size="sm"
                         onClick={() => handleCancel(freshSelectedModel.model_name)}
diff --git a/app/src/lib/api/types.ts b/app/src/lib/api/types.ts
index 0da89da5..9819e00a 100644
--- a/app/src/lib/api/types.ts
+++ b/app/src/lib/api/types.ts
@@ -155,6 +155,10 @@ export interface ActiveDownloadTask {
   status: string;
   started_at: string;
   error?: string;
+  progress?: number; // 0-100 percentage
+  current?: number; // bytes downloaded
+  total?: number; // total bytes
+  filename?: string; // current file being downloaded
 }
 
 export interface ActiveGenerationTask {
diff --git a/backend/backends/chatterbox_backend.py b/backend/backends/chatterbox_backend.py
index 9078f686..88f87d4e 100644
--- a/backend/backends/chatterbox_backend.py
+++ b/backend/backends/chatterbox_backend.py
@@ -103,19 +103,27 @@ class ChatterboxTTSBackend:
 
     def _load_model_sync(self):
         """Synchronous model loading."""
+        from ..utils.hf_progress import HFProgressTracker, create_hf_progress_callback
+
         progress_manager = get_progress_manager()
         task_manager = get_task_manager()
         model_name = "chatterbox-tts"
 
         is_cached = self._is_model_cached()
 
+        # Set up HF progress tracking (intercepts tqdm for file-level progress)
+        progress_callback = create_hf_progress_callback(model_name, progress_manager)
+        tracker = HFProgressTracker(progress_callback, filter_non_downloads=is_cached)
+        tracker_context = tracker.patch_download()
+        tracker_context.__enter__()
+
         if not is_cached:
             task_manager.start_download(model_name)
             progress_manager.update_progress(
                 model_name=model_name,
                 current=0,
                 total=0,
-                filename="Downloading Chatterbox model...",
+                filename="Connecting to HuggingFace...",
                 status="downloading",
             )
 
@@ -131,25 +139,28 @@ class ChatterboxTTSBackend:
             # Monkey-patch torch.load for CPU loading. The model's .pt files
             # were saved on CUDA; from_pretrained() doesn't pass map_location
             # so loading on CPU fails without this.
-            if device == "cpu":
-                _orig_torch_load = torch.load
+            try:
+                if device == "cpu":
+                    _orig_torch_load = torch.load
 
-                def _patched_load(*args, **kwargs):
-                    kwargs.setdefault("map_location", "cpu")
-                    return _orig_torch_load(*args, **kwargs)
+                    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,
-                )
+                    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,
+                    )
+            finally:
+                tracker_context.__exit__(None, None, None)
 
             # Fix: transformers >= 4.36 defaults LlamaModel to sdpa attention
             # which doesn't support output_attentions=True (needed by
diff --git a/backend/backends/luxtts_backend.py b/backend/backends/luxtts_backend.py
index 7e692139..549e44ff 100644
--- a/backend/backends/luxtts_backend.py
+++ b/backend/backends/luxtts_backend.py
@@ -94,19 +94,27 @@ class LuxTTSBackend:
 
     def _load_model_sync(self):
         """Synchronous model loading."""
+        from ..utils.hf_progress import HFProgressTracker, create_hf_progress_callback
+
         progress_manager = get_progress_manager()
         task_manager = get_task_manager()
         model_name = "luxtts"
 
         is_cached = self._is_model_cached()
 
+        # Set up HF progress tracking (intercepts tqdm for file-level progress)
+        progress_callback = create_hf_progress_callback(model_name, progress_manager)
+        tracker = HFProgressTracker(progress_callback, filter_non_downloads=is_cached)
+        tracker_context = tracker.patch_download()
+        tracker_context.__enter__()
+
         if not is_cached:
             task_manager.start_download(model_name)
             progress_manager.update_progress(
                 model_name=model_name,
                 current=0,
                 total=0,
-                filename="Downloading LuxTTS model...",
+                filename="Connecting to HuggingFace...",
                 status="downloading",
             )
 
@@ -117,19 +125,22 @@ class LuxTTSBackend:
             logger.info(f"Loading LuxTTS on {device}...")
 
             # LuxTTS constructor downloads model and loads everything
-            if device == "cpu":
-                import os
-                threads = os.cpu_count() or 4
-                self.model = LuxTTS(
-                    model_path=LUXTTS_HF_REPO,
-                    device="cpu",
-                    threads=min(threads, 8),
-                )
-            else:
-                self.model = LuxTTS(
-                    model_path=LUXTTS_HF_REPO,
-                    device=device,
-                )
+            try:
+                if device == "cpu":
+                    import os
+                    threads = os.cpu_count() or 4
+                    self.model = LuxTTS(
+                        model_path=LUXTTS_HF_REPO,
+                        device="cpu",
+                        threads=min(threads, 8),
+                    )
+                else:
+                    self.model = LuxTTS(
+                        model_path=LUXTTS_HF_REPO,
+                        device=device,
+                    )
+            finally:
+                tracker_context.__exit__(None, None, None)
 
             if not is_cached:
                 progress_manager.mark_complete(model_name)
diff --git a/backend/main.py b/backend/main.py
index 7eeabe40..3d2ec359 100644
--- a/backend/main.py
+++ b/backend/main.py
@@ -1912,11 +1912,22 @@ async def get_active_tasks():
                     pm_data = progress_manager._progress.get(model_name)
                     if pm_data:
                         error = pm_data.get("error")
+            # Include progress data if available
+            prog = progress or {}
+            if not prog:
+                with progress_manager._lock:
+                    pm_data = progress_manager._progress.get(model_name)
+                    if pm_data:
+                        prog = pm_data
             active_downloads.append(models.ActiveDownloadTask(
                 model_name=model_name,
                 status=task.status,
                 started_at=task.started_at,
                 error=error,
+                progress=prog.get("progress"),
+                current=prog.get("current"),
+                total=prog.get("total"),
+                filename=prog.get("filename"),
             ))
         elif progress:
             # Progress exists but no task - create from progress data
@@ -1934,6 +1945,10 @@ async def get_active_tasks():
                 status=progress.get("status", "downloading"),
                 started_at=started_at,
                 error=progress.get("error"),
+                progress=progress.get("progress"),
+                current=progress.get("current"),
+                total=progress.get("total"),
+                filename=progress.get("filename"),
             ))
     
     # Get active generations
diff --git a/backend/models.py b/backend/models.py
index 9b945adb..c46ded58 100644
--- a/backend/models.py
+++ b/backend/models.py
@@ -158,6 +158,10 @@ class ActiveDownloadTask(BaseModel):
     status: str
     started_at: datetime
     error: Optional[str] = None
+    progress: Optional[float] = None  # 0-100 percentage
+    current: Optional[int] = None     # bytes downloaded
+    total: Optional[int] = None       # total bytes
+    filename: Optional[str] = None    # current file being downloaded
 
 
 class ActiveGenerationTask(BaseModel):