diff --git a/frontend/cypress/e2e/auto-update.cy.ts b/frontend/cypress/e2e/auto-update.cy.ts
index 26b9930fa..ab923d033 100644
--- a/frontend/cypress/e2e/auto-update.cy.ts
+++ b/frontend/cypress/e2e/auto-update.cy.ts
@@ -374,6 +374,17 @@ describe('Auto Update Feature', () => {
         delay: 2000,
       }).as('downloadUpdate');
 
+      cy.intercept('GET', '/api/download-update/progress*', {
+        statusCode: 200,
+        body: {
+          state: 'downloading',
+          bytes_written: 5242880,
+          total_bytes: 10485760,
+          percentage: 50,
+          indeterminate: false,
+        },
+      }).as('downloadProgress');
+
       cy.visit('/');
       cy.wait('@getFeeds');
 
@@ -389,6 +400,11 @@ describe('Auto Update Feature', () => {
 
       // Verify progress bar exists
       cy.get('[data-testid="update-download-progress"]').should('be.visible');
+      cy.wait('@downloadProgress');
+      cy.contains('50%').should('be.visible');
+      cy.wait('@downloadUpdate')
+        .its('request.body.request_id')
+        .should('match', /^[A-Za-z0-9_-]+$/);
     });
 
     it('should show installing message after download completes', () => {
@@ -464,7 +480,7 @@ describe('Auto Update Feature', () => {
       // Mock download failure
       cy.intercept('POST', '/api/download-update', {
         statusCode: 500,
-        body: { error: 'Download failed' },
+        body: { success: false, error_code: 'download_network_error' },
       }).as('downloadUpdate');
 
       cy.visit('/');
@@ -482,6 +498,8 @@ describe('Auto Update Feature', () => {
 
       // Verify error message is shown (via toast notification)
       cy.get('.toast-container').should('exist');
+      cy.contains(/release page|发布页/i).should('be.visible');
+      cy.contains(/network|网络/i).should('be.visible');
     });
 
     it('should handle update check failure gracefully', () => {
diff --git a/frontend/src/App.vue b/frontend/src/App.vue
index 6a7b7b419..dee21dad6 100644
--- a/frontend/src/App.vue
+++ b/frontend/src/App.vue
@@ -91,6 +91,10 @@ const {
   downloadingUpdate,
   installingUpdate,
   downloadProgress,
+  downloadProgressKnown,
+  downloadBytesWritten,
+  downloadTotalBytes,
+  downloadErrorCode,
 } = useAppUpdates();
 
 // Update dialog state
@@ -365,6 +369,10 @@ function onFeedUpdated(): void {
       :downloading-update="downloadingUpdate"
       :installing-update="installingUpdate"
       :download-progress="downloadProgress"
+      :download-progress-known="downloadProgressKnown"
+      :download-bytes-written="downloadBytesWritten"
+      :download-total-bytes="downloadTotalBytes"
+      :download-error-code="downloadErrorCode"
       @close="showUpdateDialog = false"
       @update="downloadAndInstallUpdate"
     />
diff --git a/frontend/src/components/modals/SettingsModal.vue b/frontend/src/components/modals/SettingsModal.vue
index 354109ebc..ee019daeb 100644
--- a/frontend/src/components/modals/SettingsModal.vue
+++ b/frontend/src/components/modals/SettingsModal.vue
@@ -49,6 +49,10 @@ const {
   downloadingUpdate,
   installingUpdate,
   downloadProgress,
+  downloadProgressKnown,
+  downloadBytesWritten,
+  downloadTotalBytes,
+  downloadErrorCode,
   checkForUpdates: handleCheckUpdates,
   downloadAndInstallUpdate: handleDownloadInstallUpdate,
 } = useAppUpdates();
@@ -270,6 +274,10 @@ function handleDiscoverAll() {
             :downloading-update="downloadingUpdate"
             :installing-update="installingUpdate"
             :download-progress="downloadProgress"
+            :download-progress-known="downloadProgressKnown"
+            :download-bytes-written="downloadBytesWritten"
+            :download-total-bytes="downloadTotalBytes"
+            :download-error-code="downloadErrorCode"
             @check-updates="handleCheckUpdates"
             @download-install-update="handleDownloadInstallUpdate"
           />
diff --git a/frontend/src/components/modals/settings/about/AboutTab.vue b/frontend/src/components/modals/settings/about/AboutTab.vue
index 6d6a46646..8522cd32c 100644
--- a/frontend/src/components/modals/settings/about/AboutTab.vue
+++ b/frontend/src/components/modals/settings/about/AboutTab.vue
@@ -28,6 +28,10 @@ interface Props {
   downloadingUpdate?: boolean;
   installingUpdate?: boolean;
   downloadProgress?: number;
+  downloadProgressKnown?: boolean;
+  downloadBytesWritten?: number;
+  downloadTotalBytes?: number;
+  downloadErrorCode?: string;
 }
 
 withDefaults(defineProps<Props>(), {
@@ -36,6 +40,10 @@ withDefaults(defineProps<Props>(), {
   downloadingUpdate: false,
   installingUpdate: false,
   downloadProgress: 0,
+  downloadProgressKnown: false,
+  downloadBytesWritten: 0,
+  downloadTotalBytes: 0,
+  downloadErrorCode: '',
 });
 
 const emit = defineEmits<{
@@ -80,6 +88,11 @@ function openGitHubRepo() {
 function openGitHubRelease() {
   openInBrowser('https://github.com/DevXDojo/MrRSS/releases/latest');
 }
+
+function formatBytes(bytes: number): string {
+  if (bytes <= 0) return '0 MB';
+  return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+}
 </script>
 
 <template>
@@ -153,6 +166,26 @@ function openGitHubRelease() {
               <span v-else-if="installingUpdate">{{ t('setting.update.installingUpdate') }}</span>
               <span v-else>{{ t('modal.update.downloadUpdate') }}</span>
             </button>
+            <div v-if="downloadingUpdate" class="mt-2 text-xs text-text-secondary">
+              <span v-if="downloadProgressKnown">
+                {{ Math.round(downloadProgress) }}% · {{ formatBytes(downloadBytesWritten) }} /
+                {{ formatBytes(downloadTotalBytes) }}
+              </span>
+              <span v-else>{{ formatBytes(downloadBytesWritten) }}</span>
+            </div>
+            <div
+              v-if="downloadErrorCode"
+              class="mt-2 rounded-md border border-red-500/30 bg-red-500/10 p-2 text-xs text-text-secondary"
+            >
+              <p>{{ t('setting.update.downloadFailedHelp') }}</p>
+              <button
+                type="button"
+                class="mt-1 text-accent hover:underline"
+                @click="openGitHubRelease"
+              >
+                {{ t('setting.update.downloadManually') }}
+              </button>
+            </div>
           </div>
 
           <!-- Fallback to GitHub if no download URL -->
diff --git a/frontend/src/components/modals/update/UpdateAvailableDialog.vue b/frontend/src/components/modals/update/UpdateAvailableDialog.vue
index c4d1b3d56..6dcd00270 100644
--- a/frontend/src/components/modals/update/UpdateAvailableDialog.vue
+++ b/frontend/src/components/modals/update/UpdateAvailableDialog.vue
@@ -4,6 +4,7 @@ import { useI18n } from 'vue-i18n';
 import { PhArrowCircleUp, PhDownloadSimple, PhCircleNotch, PhGear } from '@phosphor-icons/vue';
 import BaseModal from '@/components/common/BaseModal.vue';
 import ModalFooter from '@/components/common/ModalFooter.vue';
+import { openInBrowser } from '@/utils/browser';
 
 interface UpdateInfo {
   has_update: boolean;
@@ -18,12 +19,20 @@ interface Props {
   downloadingUpdate?: boolean;
   installingUpdate?: boolean;
   downloadProgress?: number;
+  downloadProgressKnown?: boolean;
+  downloadBytesWritten?: number;
+  downloadTotalBytes?: number;
+  downloadErrorCode?: string;
 }
 
 const props = withDefaults(defineProps<Props>(), {
   downloadingUpdate: false,
   installingUpdate: false,
   downloadProgress: 0,
+  downloadProgressKnown: false,
+  downloadBytesWritten: 0,
+  downloadTotalBytes: 0,
+  downloadErrorCode: '',
 });
 
 const emit = defineEmits<{
@@ -56,6 +65,37 @@ const normalizedDownloadProgress = computed(() =>
   Math.min(100, Math.max(0, props.downloadProgress))
 );
 
+function formatBytes(bytes: number): string {
+  if (bytes <= 0) return '0 MB';
+  return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+}
+
+const downloadSizeLabel = computed(() => {
+  if (props.downloadProgressKnown && props.downloadTotalBytes > 0) {
+    return `${formatBytes(props.downloadBytesWritten)} / ${formatBytes(props.downloadTotalBytes)}`;
+  }
+  return formatBytes(props.downloadBytesWritten);
+});
+
+const downloadErrorMessage = computed(() => {
+  switch (props.downloadErrorCode) {
+    case 'download_proxy_error':
+      return t('setting.update.downloadProxyError');
+    case 'download_timeout':
+      return t('setting.update.downloadTimeout');
+    case 'download_network_error':
+      return t('setting.update.downloadNetworkError');
+    case 'download_server_error':
+      return t('setting.update.downloadServerError');
+    default:
+      return t('setting.update.downloadFailedHelp');
+  }
+});
+
+function openReleasePage() {
+  openInBrowser('https://github.com/DevXDojo/MrRSS/releases/latest');
+}
+
 function handleKeyDown(e: KeyboardEvent) {
   if (e.key === 'Enter') {
     e.preventDefault();
@@ -113,15 +153,33 @@ onUnmounted(() => {
       <div v-if="props.downloadingUpdate" class="mt-4" data-testid="update-download-progress">
         <div class="mb-1 flex items-center justify-between text-xs text-text-secondary">
           <span>{{ t('common.action.downloading') }}</span>
-          <span>{{ Math.round(normalizedDownloadProgress) }}%</span>
+          <span>
+            {{
+              props.downloadProgressKnown
+                ? `${Math.round(normalizedDownloadProgress)}%`
+                : downloadSizeLabel
+            }}
+          </span>
         </div>
         <progress
           class="download-progress block h-2 w-full overflow-hidden rounded-full"
-          :value="normalizedDownloadProgress"
+          :value="props.downloadProgressKnown ? normalizedDownloadProgress : undefined"
           max="100"
         ></progress>
+        <div v-if="props.downloadProgressKnown" class="mt-1 text-right text-xs text-text-secondary">
+          {{ downloadSizeLabel }}
+        </div>
       </div>
 
+      <div
+        v-if="props.downloadErrorCode"
+        class="mt-4 rounded-lg border border-red-500/30 bg-red-500/10 p-3 text-xs text-text-secondary"
+      >
+        <p>{{ downloadErrorMessage }}</p>
+        <button type="button" class="mt-2 text-accent hover:underline" @click="openReleasePage">
+          {{ t('setting.update.downloadManually') }}
+        </button>
+      </div>
       <p v-if="!updateInfo.download_url" class="text-text-secondary text-xs mt-4">
         {{ t('setting.update.noInstallerAvailable') }}
         <a
@@ -185,6 +243,10 @@ onUnmounted(() => {
   background: var(--accent-color);
 }
 
+.download-progress:indeterminate {
+  animation: progress-pulse 1.2s ease-in-out infinite;
+}
+
 .animate-spin {
   animation: spin 1s linear infinite;
 }
@@ -196,4 +258,13 @@ onUnmounted(() => {
     transform: rotate(360deg);
   }
 }
+@keyframes progress-pulse {
+  0%,
+  100% {
+    opacity: 0.45;
+  }
+  50% {
+    opacity: 1;
+  }
+}
 </style>
diff --git a/frontend/src/composables/core/useAppUpdates.ts b/frontend/src/composables/core/useAppUpdates.ts
index 1c1e1b310..b142e0f4f 100644
--- a/frontend/src/composables/core/useAppUpdates.ts
+++ b/frontend/src/composables/core/useAppUpdates.ts
@@ -13,6 +13,50 @@ export function useAppUpdates() {
   const downloadingUpdate = ref(false);
   const installingUpdate = ref(false);
   const downloadProgress = ref(0);
+  const downloadProgressKnown = ref(false);
+  const downloadBytesWritten = ref(0);
+  const downloadTotalBytes = ref(0);
+  const downloadErrorCode = ref('');
+
+  function createDownloadRequestId(): string {
+    if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
+      return crypto.randomUUID();
+    }
+    return `update-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+  }
+
+  async function fetchDownloadProgress(requestId: string): Promise<void> {
+    try {
+      const res = await fetch(
+        `/api/download-update/progress?request_id=${encodeURIComponent(requestId)}`
+      );
+      if (!res.ok) return;
+      const progress = await res.json();
+      downloadBytesWritten.value = Number(progress.bytes_written) || 0;
+      downloadTotalBytes.value = Number(progress.total_bytes) || 0;
+      downloadProgressKnown.value = !progress.indeterminate && downloadTotalBytes.value > 0;
+      if (downloadProgressKnown.value) {
+        downloadProgress.value = Math.min(100, Math.max(0, Number(progress.percentage) || 0));
+      }
+    } catch (error) {
+      console.debug('Unable to poll update download progress:', error);
+    }
+  }
+
+  function downloadErrorMessage(errorCode: string): string {
+    switch (errorCode) {
+      case 'download_proxy_error':
+        return t('setting.update.downloadProxyError');
+      case 'download_timeout':
+        return t('setting.update.downloadTimeout');
+      case 'download_network_error':
+        return t('setting.update.downloadNetworkError');
+      case 'download_server_error':
+        return t('setting.update.downloadServerError');
+      default:
+        return t('common.toast.downloadFailed');
+    }
+  }
 
   /**
    * Check for available updates
@@ -21,6 +65,7 @@ export function useAppUpdates() {
   async function checkForUpdates(silent = false) {
     checkingUpdates.value = true;
     updateInfo.value = null;
+    downloadErrorCode.value = '';
 
     try {
       const res = await fetch('/api/check-updates');
@@ -63,13 +108,14 @@ export function useAppUpdates() {
 
     downloadingUpdate.value = true;
     downloadProgress.value = 0;
-
-    // Simulate progress while downloading
-    const progressInterval = setInterval(() => {
-      if (downloadProgress.value < 90) {
-        downloadProgress.value += 10;
-      }
-    }, 500);
+    downloadProgressKnown.value = false;
+    downloadBytesWritten.value = 0;
+    downloadTotalBytes.value = 0;
+    downloadErrorCode.value = '';
+    const requestId = createDownloadRequestId();
+    const progressInterval = window.setInterval(() => {
+      void fetchDownloadProgress(requestId);
+    }, 300);
 
     try {
       // Download the update
@@ -79,15 +125,19 @@ export function useAppUpdates() {
         body: JSON.stringify({
           download_url: updateInfo.value.download_url,
           asset_name: updateInfo.value.asset_name,
+          request_id: requestId,
         }),
       });
 
-      clearInterval(progressInterval);
+      window.clearInterval(progressInterval);
+      await fetchDownloadProgress(requestId);
 
       if (!downloadRes.ok) {
-        const errorText = await downloadRes.text();
-        console.error('Download error:', errorText);
-        throw new Error('DOWNLOAD_ERROR: ' + errorText);
+        const errorData = await downloadRes.json().catch(() => ({}));
+        const errorCode = errorData.error_code || 'download_failed';
+        downloadErrorCode.value = errorCode;
+        console.error('Update download failed:', errorCode);
+        throw new Error(`DOWNLOAD_ERROR:${errorCode}`);
       }
 
       const downloadData = (await downloadRes.json()) as DownloadResponse;
@@ -97,6 +147,9 @@ export function useAppUpdates() {
 
       downloadingUpdate.value = false;
       downloadProgress.value = 100;
+      downloadProgressKnown.value = true;
+      downloadBytesWritten.value = Number(downloadData.bytes_written) || downloadBytesWritten.value;
+      downloadTotalBytes.value = Number(downloadData.total_bytes) || downloadTotalBytes.value;
 
       // Show notification
       window.showToast(t('common.toast.downloadComplete'), 'success');
@@ -131,14 +184,16 @@ export function useAppUpdates() {
       window.showToast(t('setting.update.updateWillRestart'), 'info');
     } catch (e) {
       console.error('Update error:', e);
-      clearInterval(progressInterval);
+      window.clearInterval(progressInterval);
       downloadingUpdate.value = false;
       installingUpdate.value = false;
 
       // Use error codes for more reliable error classification
       const errorMessage = (e as Error).message || '';
       if (errorMessage.includes('DOWNLOAD_ERROR')) {
-        window.showToast(t('common.toast.downloadFailed'), 'error');
+        const errorCode = errorMessage.split(':')[1] || 'download_failed';
+        downloadErrorCode.value = errorCode;
+        window.showToast(downloadErrorMessage(errorCode), 'error');
       } else if (errorMessage.includes('INSTALL_ERROR')) {
         window.showToast(t('setting.update.installFailed'), 'error');
       } else {
@@ -153,6 +208,10 @@ export function useAppUpdates() {
     downloadingUpdate,
     installingUpdate,
     downloadProgress,
+    downloadProgressKnown,
+    downloadBytesWritten,
+    downloadTotalBytes,
+    downloadErrorCode,
     checkForUpdates,
     downloadAndInstallUpdate,
   };
diff --git a/frontend/src/i18n/locales/en.ts b/frontend/src/i18n/locales/en.ts
index 8cece24ed..0f8476729 100644
--- a/frontend/src/i18n/locales/en.ts
+++ b/frontend/src/i18n/locales/en.ts
@@ -1150,6 +1150,15 @@ const en: TranslationMessages = {
       autoUpdateIntervalDesc: 'Interval for automatic update checks',
       checkForUpdates: 'Check for Updates',
       currentVersion: 'Current version',
+      downloadFailedHelp:
+        'The automatic download did not finish. Check your network or proxy and retry, or download the update manually.',
+      downloadManually: 'Open the release page',
+      downloadNetworkError:
+        'Could not connect to GitHub. Check your network or proxy settings and try again.',
+      downloadProxyError: 'The proxy settings are invalid. Check Network settings and try again.',
+      downloadServerError:
+        'The GitHub download service is temporarily unavailable. Try again later.',
+      downloadTimeout: 'The update download timed out. Check your network or proxy and try again.',
       installFailed: 'Installation failed',
       installingUpdate: 'Installing update...',
       latestVersion: 'Latest version',
diff --git a/frontend/src/i18n/locales/zh.ts b/frontend/src/i18n/locales/zh.ts
index 3c4942e73..66b0774fc 100644
--- a/frontend/src/i18n/locales/zh.ts
+++ b/frontend/src/i18n/locales/zh.ts
@@ -1124,6 +1124,12 @@ const zh: TranslationMessages = {
       autoUpdateIntervalDesc: '自动检查更新的时间间隔',
       checkForUpdates: '检查更新',
       currentVersion: '当前版本',
+      downloadFailedHelp: '自动下载未完成。您可以检查网络或代理设置后重试，也可以手动下载更新。',
+      downloadManually: '前往发布页手动下载',
+      downloadNetworkError: '无法连接到 GitHub 下载更新，请检查网络或代理设置。',
+      downloadProxyError: '代理设置无效，请检查网络设置后重试。',
+      downloadServerError: 'GitHub 下载服务暂时不可用，请稍后重试。',
+      downloadTimeout: '下载更新超时，请检查网络或代理设置后重试。',
       installFailed: '安装失败',
       installingUpdate: '正在安装更新...',
       latestVersion: '最新版本',
diff --git a/frontend/src/types/settings.ts b/frontend/src/types/settings.ts
index f32b14e9c..dce3edc77 100644
--- a/frontend/src/types/settings.ts
+++ b/frontend/src/types/settings.ts
@@ -40,6 +40,9 @@ export interface UpdateInfo {
 export interface DownloadResponse {
   success: boolean;
   file_path: string;
+  request_id?: string;
+  total_bytes?: number;
+  bytes_written?: number;
 }
 
 export interface InstallResponse {
diff --git a/internal/handlers/update/download_handlers_test.go b/internal/handlers/update/download_handlers_test.go
index 7fc1fe813..afae26e05 100644
--- a/internal/handlers/update/download_handlers_test.go
+++ b/internal/handlers/update/download_handlers_test.go
@@ -2,10 +2,20 @@ package update
 
 import (
 	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
 	"net/http"
 	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync/atomic"
 	"testing"
+	"time"
 
+	"MrRSS/internal/database"
 	"MrRSS/internal/handlers/core"
 )
 
@@ -43,3 +53,201 @@ func TestHandleDownloadUpdate_InvalidAssetName(t *testing.T) {
 		t.Fatalf("expected 400 for invalid asset name, got %d", rr.Code)
 	}
 }
+func TestHandleDownloadUpdateProgress(t *testing.T) {
+	requestID := "progress-test"
+	setDownloadProgress(downloadProgress{
+		RequestID: requestID, State: "downloading", BytesWritten: 50,
+		TotalBytes: 100, Percentage: 50,
+	})
+
+	req := httptest.NewRequest(http.MethodGet, "/api/download-update/progress?request_id="+requestID, nil)
+	rr := httptest.NewRecorder()
+	HandleDownloadUpdateProgress(nil, rr, req)
+
+	if rr.Code != http.StatusOK {
+		t.Fatalf("expected 200, got %d", rr.Code)
+	}
+	var progress downloadProgress
+	if err := json.NewDecoder(rr.Body).Decode(&progress); err != nil {
+		t.Fatalf("decode progress: %v", err)
+	}
+	if progress.BytesWritten != 50 || progress.Percentage != 50 || progress.State != "downloading" {
+		t.Fatalf("unexpected progress: %+v", progress)
+	}
+}
+
+func TestDownloadUpdateFileRetriesWithRange(t *testing.T) {
+	content := []byte(strings.Repeat("update-data-", 8192))
+	half := len(content) / 2
+	var attempts atomic.Int32
+	var resumed atomic.Bool
+
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		attempt := attempts.Add(1)
+		if attempt == 1 {
+			w.Header().Set("Content-Length", fmt.Sprint(len(content)))
+			_, _ = w.Write(content[:half])
+			return
+		}
+		expectedRange := fmt.Sprintf("bytes=%d-", half)
+		if r.Header.Get("Range") != expectedRange {
+			t.Errorf("expected Range %q, got %q", expectedRange, r.Header.Get("Range"))
+		}
+		resumed.Store(true)
+		w.Header().Set("Content-Length", fmt.Sprint(len(content)-half))
+		w.Header().Set("Content-Range", fmt.Sprintf("bytes %d-%d/%d", half, len(content)-1, len(content)))
+		w.WriteHeader(http.StatusPartialContent)
+		_, _ = w.Write(content[half:])
+	}))
+	defer server.Close()
+
+	filePath := filepath.Join(t.TempDir(), "update.bin")
+	written, total, err := downloadUpdateFile(context.Background(), server.Client(), server.URL, filePath, "range-test", 3, 0)
+	if err != nil {
+		t.Fatalf("downloadUpdateFile: %v", err)
+	}
+	if !resumed.Load() || attempts.Load() != 2 {
+		t.Fatalf("expected one resumed request, attempts=%d resumed=%v", attempts.Load(), resumed.Load())
+	}
+	if written != int64(len(content)) || total != int64(len(content)) {
+		t.Fatalf("unexpected sizes: written=%d total=%d", written, total)
+	}
+	got, err := os.ReadFile(filePath)
+	if err != nil {
+		t.Fatalf("read downloaded file: %v", err)
+	}
+	if !bytes.Equal(got, content) {
+		t.Fatal("downloaded content does not match")
+	}
+}
+
+func TestDownloadUpdateFileRestartsWhenRangeUnsupported(t *testing.T) {
+	content := []byte(strings.Repeat("no-range-", 4096))
+	half := len(content) / 2
+	var attempts atomic.Int32
+
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		attempt := attempts.Add(1)
+		w.Header().Set("Content-Length", fmt.Sprint(len(content)))
+		if attempt == 1 {
+			_, _ = w.Write(content[:half])
+			return
+		}
+		if r.Header.Get("Range") == "" {
+			t.Error("expected a resume request")
+		}
+		_, _ = w.Write(content)
+	}))
+	defer server.Close()
+
+	filePath := filepath.Join(t.TempDir(), "update.bin")
+	_, _, err := downloadUpdateFile(context.Background(), server.Client(), server.URL, filePath, "no-range-test", 3, 0)
+	if err != nil {
+		t.Fatalf("downloadUpdateFile: %v", err)
+	}
+	got, _ := os.ReadFile(filePath)
+	if !bytes.Equal(got, content) {
+		t.Fatal("fallback full download did not replace partial content")
+	}
+}
+
+func TestDownloadUpdateFileRetriesServerErrors(t *testing.T) {
+	var attempts atomic.Int32
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		if attempts.Add(1) < 3 {
+			http.Error(w, "temporary", http.StatusServiceUnavailable)
+			return
+		}
+		_, _ = w.Write([]byte("complete"))
+	}))
+	defer server.Close()
+
+	filePath := filepath.Join(t.TempDir(), "update.bin")
+	if _, _, err := downloadUpdateFile(context.Background(), server.Client(), server.URL, filePath, "server-retry", 3, 0); err != nil {
+		t.Fatalf("downloadUpdateFile: %v", err)
+	}
+	if attempts.Load() != 3 {
+		t.Fatalf("expected 3 attempts, got %d", attempts.Load())
+	}
+}
+
+func TestDownloadUpdateFileCleansPartialAfterFailure(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		w.Header().Set("Content-Length", "100")
+		_, _ = w.Write([]byte("partial"))
+	}))
+	defer server.Close()
+
+	filePath := filepath.Join(t.TempDir(), "update.bin")
+	if _, _, err := downloadUpdateFile(context.Background(), server.Client(), server.URL, filePath, "cleanup-test", 2, 0); err == nil {
+		t.Fatal("expected incomplete download error")
+	}
+	if _, err := os.Stat(filePath + ".part"); !errors.Is(err, os.ErrNotExist) {
+		t.Fatalf("partial file was not removed: %v", err)
+	}
+	if _, err := os.Stat(filePath); !errors.Is(err, os.ErrNotExist) {
+		t.Fatalf("incomplete final file exists: %v", err)
+	}
+}
+
+func TestDownloadUpdateFileTracksUnknownLength(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		flusher, ok := w.(http.Flusher)
+		if !ok {
+			t.Fatal("response writer does not support flushing")
+		}
+		_, _ = w.Write([]byte("chunk-one"))
+		flusher.Flush()
+		_, _ = w.Write([]byte("chunk-two"))
+	}))
+	defer server.Close()
+
+	filePath := filepath.Join(t.TempDir(), "update.bin")
+	written, total, err := downloadUpdateFile(context.Background(), server.Client(), server.URL, filePath, "unknown-size", 1, 0)
+	if err != nil {
+		t.Fatalf("downloadUpdateFile: %v", err)
+	}
+	if total != 0 || written == 0 {
+		t.Fatalf("expected unknown total and downloaded bytes, total=%d written=%d", total, written)
+	}
+	updateDownloads.RLock()
+	progress := updateDownloads.items["unknown-size"]
+	updateDownloads.RUnlock()
+	if !progress.Indeterminate || progress.BytesWritten != written {
+		t.Fatalf("unexpected unknown-length progress: %+v", progress)
+	}
+}
+
+func TestCreateUpdateHTTPClientUsesGlobalProxy(t *testing.T) {
+	db, err := database.NewDB(filepath.Join(t.TempDir(), "settings.db"))
+	if err != nil {
+		t.Fatalf("NewDB: %v", err)
+	}
+	defer db.Close()
+	if err := db.Init(); err != nil {
+		t.Fatalf("Init: %v", err)
+	}
+	for key, value := range map[string]string{
+		"proxy_enabled": "true", "proxy_type": "http", "proxy_host": "127.0.0.1", "proxy_port": "7890",
+	} {
+		if err := db.SetSetting(key, value); err != nil {
+			t.Fatalf("SetSetting(%s): %v", key, err)
+		}
+	}
+
+	client, err := createUpdateHTTPClient(&core.Handler{DB: db}, time.Second)
+	if err != nil {
+		t.Fatalf("createUpdateHTTPClient: %v", err)
+	}
+	transport, ok := client.Transport.(*http.Transport)
+	if !ok {
+		t.Fatalf("unexpected transport %T", client.Transport)
+	}
+	proxyURL, err := transport.Proxy(httptest.NewRequest(http.MethodGet, "https://github.com", nil))
+	if err != nil {
+		t.Fatalf("proxy lookup: %v", err)
+	}
+	if proxyURL == nil || proxyURL.String() != "http://127.0.0.1:7890" {
+		t.Fatalf("unexpected proxy URL: %v", proxyURL)
+	}
+}
diff --git a/internal/handlers/update/update_check_handlers.go b/internal/handlers/update/update_check_handlers.go
index 5a1355997..e647d9484 100644
--- a/internal/handlers/update/update_check_handlers.go
+++ b/internal/handlers/update/update_check_handlers.go
@@ -69,6 +69,32 @@ func isNetworkError(err error) bool {
 	return false
 }
 
+func createUpdateHTTPClient(h *core.Handler, timeout time.Duration) (*http.Client, error) {
+	var proxyURL string
+	if h != nil && h.DB != nil {
+		proxyEnabled, _ := h.DB.GetSetting("proxy_enabled")
+		if proxyEnabled == "true" {
+			proxyType, _ := h.DB.GetSetting("proxy_type")
+			proxyHost, _ := h.DB.GetSetting("proxy_host")
+			proxyPort, _ := h.DB.GetSetting("proxy_port")
+			proxyUsername, _ := h.DB.GetEncryptedSetting("proxy_username")
+			proxyPassword, _ := h.DB.GetEncryptedSetting("proxy_password")
+			proxyURL = httputil.BuildProxyURL(proxyType, proxyHost, proxyPort, proxyUsername, proxyPassword)
+		}
+	}
+	client, err := httputil.CreateHTTPClient(proxyURL, timeout)
+	if err != nil {
+		return nil, err
+	}
+	if transport, ok := client.Transport.(*http.Transport); ok {
+		transport.DialContext = (&net.Dialer{Timeout: 20 * time.Second, KeepAlive: 30 * time.Second}).DialContext
+		transport.TLSHandshakeTimeout = 15 * time.Second
+		transport.ResponseHeaderTimeout = 30 * time.Second
+		transport.ExpectContinueTimeout = time.Second
+	}
+	return client, nil
+}
+
 // HandleCheckUpdates checks for the latest stable version on GitHub.
 // Pre-release versions (alpha, beta) are filtered out.
 // @Summary      Check for updates
@@ -89,20 +115,8 @@ func HandleCheckUpdates(h *core.Handler, w http.ResponseWriter, r *http.Request)
 	// Use /releases endpoint to get all releases, then filter for stable versions
 	const githubAPI = "https://api.github.com/repos/DevXDojo/MrRSS/releases"
 
-	// Create HTTP client with global proxy support
-	var proxyURL string
-	proxyEnabled, _ := h.DB.GetSetting("proxy_enabled")
-	if proxyEnabled == "true" {
-		// Build proxy URL from global settings (use encrypted methods for credentials)
-		proxyType, _ := h.DB.GetSetting("proxy_type")
-		proxyHost, _ := h.DB.GetSetting("proxy_host")
-		proxyPort, _ := h.DB.GetSetting("proxy_port")
-		proxyUsername, _ := h.DB.GetEncryptedSetting("proxy_username")
-		proxyPassword, _ := h.DB.GetEncryptedSetting("proxy_password")
-		proxyURL = httputil.BuildProxyURL(proxyType, proxyHost, proxyPort, proxyUsername, proxyPassword)
-	}
-
-	client, err := httputil.CreateHTTPClient(proxyURL, 30*time.Second)
+	// Use the same proxy-aware client as the update downloader.
+	client, err := createUpdateHTTPClient(h, 30*time.Second)
 	if err != nil {
 		log.Printf("Error creating HTTP client: %v", err)
 		response.JSON(w, map[string]interface{}{
diff --git a/internal/handlers/update/update_download_handlers.go b/internal/handlers/update/update_download_handlers.go
index 4d7c11078..6a53cb7b3 100644
--- a/internal/handlers/update/update_download_handlers.go
+++ b/internal/handlers/update/update_download_handlers.go
@@ -1,29 +1,59 @@
 package update
 
 import (
+	"context"
+	"crypto/rand"
+	"encoding/hex"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"io"
 	"log"
+	"net"
 	"net/http"
 	"os"
 	"path/filepath"
+	"strconv"
 	"strings"
+	"sync"
+	"time"
 
 	"MrRSS/internal/handlers/core"
 	"MrRSS/internal/handlers/response"
 )
 
+const (
+	downloadMaxAttempts    = 3
+	downloadRequestTimeout = 30 * time.Minute
+	downloadProgressTTL    = 30 * time.Minute
+)
+
+type downloadProgress struct {
+	RequestID     string  `json:"request_id"`
+	State         string  `json:"state"`
+	BytesWritten  int64   `json:"bytes_written"`
+	TotalBytes    int64   `json:"total_bytes"`
+	Percentage    float64 `json:"percentage"`
+	Indeterminate bool    `json:"indeterminate"`
+	ErrorCode     string  `json:"error_code,omitempty"`
+	updatedAt     time.Time
+}
+
+var updateDownloads = struct {
+	sync.RWMutex
+	items map[string]downloadProgress
+}{items: make(map[string]downloadProgress)}
+
 // HandleDownloadUpdate downloads the update file.
 // @Summary      Download update
 // @Description  Download the update file from GitHub releases to the temp directory
 // @Tags         update
 // @Accept       json
 // @Produce      json
-// @Param        request  body      object  true  "Download request (download_url, asset_name)"
-// @Success      200  {object}  map[string]interface{}  "Download success (success, file_path, total_bytes, bytes_written)"
-// @Failure      400  {object}  map[string]string  "Bad request (invalid URL or asset name)"
-// @Failure      500  {object}  map[string]string  "Internal server error"
+// @Param        request  body      object  true  "Download request (download_url, asset_name, optional request_id)"
+// @Success      200  {object}  map[string]interface{}  "Download success (success, request_id, file_path, total_bytes, bytes_written)"
+// @Failure      400  {object}  map[string]string  "Bad request (invalid URL, asset name, or request ID)"
+// @Failure      500  {object}  map[string]string  "Download failed"
 // @Router       /update/download [post]
 func HandleDownloadUpdate(h *core.Handler, w http.ResponseWriter, r *http.Request) {
 	if r.Method != http.MethodPost {
@@ -34,6 +64,7 @@ func HandleDownloadUpdate(h *core.Handler, w http.ResponseWriter, r *http.Reques
 	var req struct {
 		DownloadURL string `json:"download_url"`
 		AssetName   string `json:"asset_name"`
+		RequestID   string `json:"request_id"`
 	}
 
 	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
@@ -41,110 +72,348 @@ func HandleDownloadUpdate(h *core.Handler, w http.ResponseWriter, r *http.Reques
 		return
 	}
 
-	// Validate download URL is from the official GitHub repository releases
 	const allowedURLPrefix = "https://github.com/DevXDojo/MrRSS/releases/download/"
 	if !strings.HasPrefix(req.DownloadURL, allowedURLPrefix) {
-		log.Printf("Invalid download URL attempted: %s", req.DownloadURL)
+		log.Printf("Invalid update download URL")
 		response.Error(w, fmt.Errorf("invalid download URL"), http.StatusBadRequest)
 		return
 	}
 
-	// Validate asset name to prevent path traversal
-	if strings.Contains(req.AssetName, "..") || strings.Contains(req.AssetName, "/") || strings.Contains(req.AssetName, "\\") {
-		log.Printf("Invalid asset name attempted: %s", req.AssetName)
+	if req.AssetName == "" || strings.Contains(req.AssetName, "..") || strings.Contains(req.AssetName, "/") || strings.Contains(req.AssetName, "\\") {
+		log.Printf("Invalid update asset name")
 		response.Error(w, fmt.Errorf("invalid asset name"), http.StatusBadRequest)
 		return
 	}
 
-	// Create temp directory for download
-	tempDir := os.TempDir()
-	filePath := filepath.Join(tempDir, req.AssetName)
+	if req.RequestID == "" {
+		req.RequestID = newDownloadRequestID()
+	}
+	if !validDownloadRequestID(req.RequestID) {
+		response.Error(w, fmt.Errorf("invalid request ID"), http.StatusBadRequest)
+		return
+	}
 
-	// Download the file
-	log.Printf("Downloading update from: %s", req.DownloadURL)
-	resp, err := http.Get(req.DownloadURL)
+	setDownloadProgress(downloadProgress{RequestID: req.RequestID, State: "starting", Indeterminate: true})
+	client, err := createUpdateHTTPClient(h, downloadRequestTimeout)
 	if err != nil {
-		log.Printf("Error downloading update: %v", err)
-		response.Error(w, fmt.Errorf("failed to download update: %w", err), http.StatusInternalServerError)
+		failDownload(req.RequestID, "download_proxy_error")
+		writeDownloadError(w, req.RequestID, "download_proxy_error")
 		return
 	}
-	defer resp.Body.Close()
 
-	if resp.StatusCode != http.StatusOK {
-		log.Printf("Download failed with status: %d", resp.StatusCode)
-		response.Error(w, fmt.Errorf("failed to download update"), http.StatusInternalServerError)
+	filePath := filepath.Join(os.TempDir(), req.AssetName)
+	log.Printf("Downloading update asset %s (request %s)", req.AssetName, req.RequestID)
+	written, total, err := downloadUpdateFile(r.Context(), client, req.DownloadURL, filePath, req.RequestID, downloadMaxAttempts, time.Second)
+	if err != nil {
+		code := classifyDownloadError(err)
+		failDownload(req.RequestID, code)
+		log.Printf("Update download failed (request %s, code %s): %v", req.RequestID, code, err)
+		writeDownloadError(w, req.RequestID, code)
 		return
 	}
 
-	// Create the file
-	out, err := os.Create(filePath)
-	if err != nil {
-		log.Printf("Error creating file: %v", err)
-		response.Error(w, fmt.Errorf("failed to create download file: %w", err), http.StatusInternalServerError)
+	setDownloadProgress(downloadProgress{
+		RequestID: req.RequestID, State: "completed", BytesWritten: written,
+		TotalBytes: total, Percentage: 100,
+	})
+	log.Printf("Update downloaded successfully (request %s, %.2f MB)", req.RequestID, float64(written)/(1024*1024))
+
+	response.JSON(w, map[string]interface{}{
+		"success": true, "request_id": req.RequestID, "file_path": filePath,
+		"total_bytes": total, "bytes_written": written,
+	})
+}
+
+// HandleDownloadUpdateProgress reports download progress for a caller-supplied request ID.
+// @Summary      Get update download progress
+// @Description  Get real-time progress for an update download request
+// @Tags         update
+// @Produce      json
+// @Param        request_id  query     string  true  "Download request ID"
+// @Success      200  {object}  map[string]interface{}  "Download progress"
+// @Failure      400  {object}  map[string]string  "Invalid request ID"
+// @Failure      404  {object}  map[string]string  "Download request not found"
+// @Router       /update/download/progress [get]
+func HandleDownloadUpdateProgress(_ *core.Handler, w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodGet {
+		response.Error(w, nil, http.StatusMethodNotAllowed)
 		return
 	}
-	defer out.Close()
+	requestID := r.URL.Query().Get("request_id")
+	if !validDownloadRequestID(requestID) {
+		response.Error(w, fmt.Errorf("invalid request ID"), http.StatusBadRequest)
+		return
+	}
+	updateDownloads.RLock()
+	progress, ok := updateDownloads.items[requestID]
+	updateDownloads.RUnlock()
+	if !ok {
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(http.StatusNotFound)
+		response.JSON(w, map[string]interface{}{"success": false, "error_code": "download_not_found"})
+		return
+	}
+	response.JSON(w, progress)
+}
+
+func downloadUpdateFile(ctx context.Context, client *http.Client, downloadURL, filePath, requestID string, maxAttempts int, baseDelay time.Duration) (int64, int64, error) {
+	partPath := filePath + ".part"
+	_ = os.Remove(partPath)
+	var lastErr error
+
+	for attempt := 1; attempt <= maxAttempts; attempt++ {
+		written, total, retry, err := downloadUpdateAttempt(ctx, client, downloadURL, partPath, requestID)
+		if err == nil {
+			if err := os.Remove(filePath); err != nil && !errors.Is(err, os.ErrNotExist) {
+				_ = os.Remove(partPath)
+				return 0, 0, fmt.Errorf("replace existing update: %w", err)
+			}
+			if err := os.Rename(partPath, filePath); err != nil {
+				_ = os.Remove(partPath)
+				return 0, 0, fmt.Errorf("finalize update: %w", err)
+			}
+			return written, total, nil
+		}
+		lastErr = err
+		if !retry || attempt == maxAttempts || ctx.Err() != nil {
+			break
+		}
+		delay := baseDelay * time.Duration(1<<(attempt-1))
+		if delay > 0 {
+			timer := time.NewTimer(delay)
+			select {
+			case <-ctx.Done():
+				timer.Stop()
+				lastErr = ctx.Err()
+				attempt = maxAttempts
+			case <-timer.C:
+			}
+		}
+	}
+
+	_ = os.Remove(partPath)
+	return 0, 0, lastErr
+}
+
+func downloadUpdateAttempt(ctx context.Context, client *http.Client, downloadURL, partPath, requestID string) (int64, int64, bool, error) {
+	offset := int64(0)
+	if info, err := os.Stat(partPath); err == nil {
+		offset = info.Size()
+	}
 
-	// Write the body to file with progress tracking
-	totalSize := resp.ContentLength
-	var bytesWritten int64
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, downloadURL, nil)
+	if err != nil {
+		return 0, 0, false, err
+	}
+	req.Header.Set("User-Agent", "MrRSS-Updater")
+	req.Header.Set("Accept", "application/octet-stream")
+	if offset > 0 {
+		req.Header.Set("Range", fmt.Sprintf("bytes=%d-", offset))
+	}
+
+	resp, err := client.Do(req)
+	if err != nil {
+		return 0, 0, isRetryableDownloadError(err), err
+	}
+	defer resp.Body.Close()
 
-	// Create a buffer for efficient copying
-	buffer := make([]byte, 32*1024) // 32KB buffer
+	if resp.StatusCode == http.StatusRequestedRangeNotSatisfiable && offset > 0 {
+		_ = os.Remove(partPath)
+		return 0, 0, true, fmt.Errorf("range no longer valid")
+	}
+	if resp.StatusCode >= 500 {
+		return 0, 0, true, fmt.Errorf("download server returned %d", resp.StatusCode)
+	}
+	if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusPartialContent {
+		return 0, 0, false, fmt.Errorf("download server returned %d", resp.StatusCode)
+	}
+
+	resume := offset > 0 && resp.StatusCode == http.StatusPartialContent
+	if resume {
+		start, _, ok := parseContentRange(resp.Header.Get("Content-Range"))
+		if !ok || start != offset {
+			_ = os.Remove(partPath)
+			return 0, 0, true, fmt.Errorf("invalid range response")
+		}
+	} else {
+		offset = 0
+	}
 
+	flags := os.O_CREATE | os.O_WRONLY
+	if resume {
+		flags |= os.O_APPEND
+	} else {
+		flags |= os.O_TRUNC
+	}
+	out, err := os.OpenFile(partPath, flags, 0o600)
+	if err != nil {
+		return 0, 0, false, err
+	}
+
+	total := responseTotalSize(resp, offset)
+	setDownloadProgress(downloadProgress{
+		RequestID: requestID, State: "downloading", BytesWritten: offset,
+		TotalBytes: total, Percentage: downloadPercentage(offset, total), Indeterminate: total <= 0,
+	})
+
+	buffer := make([]byte, 64*1024)
+	written := offset
 	for {
-		nr, er := resp.Body.Read(buffer)
-		if nr > 0 {
-			nw, ew := out.Write(buffer[0:nr])
-			if nw > 0 {
-				bytesWritten += int64(nw)
+		n, readErr := resp.Body.Read(buffer)
+		if n > 0 {
+			wn, writeErr := out.Write(buffer[:n])
+			written += int64(wn)
+			setDownloadProgress(downloadProgress{
+				RequestID: requestID, State: "downloading", BytesWritten: written,
+				TotalBytes: total, Percentage: downloadPercentage(written, total), Indeterminate: total <= 0,
+			})
+			if writeErr != nil {
+				_ = out.Close()
+				return written, total, false, writeErr
 			}
-			if ew != nil {
-				err = ew
-				break
+			if wn != n {
+				_ = out.Close()
+				return written, total, false, io.ErrShortWrite
 			}
-			if nr != nw {
-				err = io.ErrShortWrite
+		}
+		if readErr != nil {
+			if errors.Is(readErr, io.EOF) {
 				break
 			}
+			_ = out.Close()
+			return written, total, isRetryableDownloadError(readErr), readErr
 		}
-		if er != nil {
-			if er != io.EOF {
-				err = er
-			}
-			break
+	}
+	if err := out.Sync(); err != nil {
+		_ = out.Close()
+		return written, total, false, err
+	}
+	if err := out.Close(); err != nil {
+		return written, total, false, err
+	}
+	if total > 0 && written != total {
+		return written, total, true, fmt.Errorf("download incomplete: expected %d bytes, got %d", total, written)
+	}
+	return written, total, false, nil
+}
+
+func responseTotalSize(resp *http.Response, offset int64) int64 {
+	if resp.StatusCode == http.StatusPartialContent {
+		_, total, ok := parseContentRange(resp.Header.Get("Content-Range"))
+		if ok {
+			return total
 		}
 	}
+	if resp.ContentLength > 0 {
+		return offset + resp.ContentLength
+	}
+	return 0
+}
 
-	if err != nil {
-		log.Printf("Error writing file: %v", err)
-		os.Remove(filePath) // Clean up partial file
-		response.Error(w, fmt.Errorf("failed to write download file: %w", err), http.StatusInternalServerError)
-		return
+func parseContentRange(value string) (int64, int64, bool) {
+	if !strings.HasPrefix(value, "bytes ") {
+		return 0, 0, false
+	}
+	parts := strings.Split(strings.TrimPrefix(value, "bytes "), "/")
+	if len(parts) != 2 {
+		return 0, 0, false
+	}
+	rangeParts := strings.Split(parts[0], "-")
+	if len(rangeParts) != 2 {
+		return 0, 0, false
 	}
+	start, err1 := strconv.ParseInt(rangeParts[0], 10, 64)
+	total, err2 := strconv.ParseInt(parts[1], 10, 64)
+	return start, total, err1 == nil && err2 == nil && start >= 0 && total > 0
+}
 
-	// Ensure all data is flushed to disk
-	if err := out.Sync(); err != nil {
-		log.Printf("Error syncing file: %v", err)
-		os.Remove(filePath) // Clean up
-		response.Error(w, fmt.Errorf("failed to save download file: %w", err), http.StatusInternalServerError)
-		return
+func isRetryableDownloadError(err error) bool {
+	if err == nil {
+		return false
 	}
+	var netErr net.Error
+	return errors.As(err, &netErr) || errors.Is(err, io.ErrUnexpectedEOF)
+}
 
-	// Verify the file size matches expected size
-	if totalSize > 0 && bytesWritten != totalSize {
-		log.Printf("Download incomplete: expected %d bytes, got %d bytes", totalSize, bytesWritten)
-		os.Remove(filePath) // Clean up incomplete file
-		response.Error(w, fmt.Errorf("download incomplete"), http.StatusInternalServerError)
-		return
+func classifyDownloadError(err error) string {
+	if errors.Is(err, context.DeadlineExceeded) || errors.Is(err, os.ErrDeadlineExceeded) {
+		return "download_timeout"
+	}
+	var netErr net.Error
+	if errors.As(err, &netErr) {
+		if netErr.Timeout() {
+			return "download_timeout"
+		}
+		return "download_network_error"
 	}
+	message := strings.ToLower(err.Error())
+	if strings.Contains(message, "server returned 5") {
+		return "download_server_error"
+	}
+	if strings.Contains(message, "incomplete") {
+		return "download_incomplete"
+	}
+	return "download_failed"
+}
 
-	log.Printf("Update downloaded successfully to: %s (%.2f MB)", filePath, float64(bytesWritten)/(1024*1024))
+func downloadPercentage(written, total int64) float64 {
+	if total <= 0 {
+		return 0
+	}
+	percentage := float64(written) * 100 / float64(total)
+	if percentage > 100 {
+		return 100
+	}
+	return percentage
+}
 
-	response.JSON(w, map[string]interface{}{
-		"success":       true,
-		"file_path":     filePath,
-		"total_bytes":   totalSize,
-		"bytes_written": bytesWritten,
+func setDownloadProgress(progress downloadProgress) {
+	progress.updatedAt = time.Now()
+	updateDownloads.Lock()
+	updateDownloads.items[progress.RequestID] = progress
+	for id, item := range updateDownloads.items {
+		if progress.updatedAt.Sub(item.updatedAt) > downloadProgressTTL {
+			delete(updateDownloads.items, id)
+		}
+	}
+	updateDownloads.Unlock()
+}
+
+func failDownload(requestID, errorCode string) {
+	updateDownloads.RLock()
+	progress := updateDownloads.items[requestID]
+	updateDownloads.RUnlock()
+	progress.RequestID = requestID
+	progress.State = "failed"
+	progress.ErrorCode = errorCode
+	setDownloadProgress(progress)
+}
+
+func writeDownloadError(w http.ResponseWriter, requestID, code string) {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(http.StatusInternalServerError)
+	_ = json.NewEncoder(w).Encode(map[string]interface{}{
+		"success": false, "request_id": requestID, "error_code": code,
 	})
 }
+
+func validDownloadRequestID(requestID string) bool {
+	if requestID == "" || len(requestID) > 128 {
+		return false
+	}
+	for _, r := range requestID {
+		if (r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') || (r >= '0' && r <= '9') || r == '-' || r == '_' {
+			continue
+		}
+		return false
+	}
+	return true
+}
+
+func newDownloadRequestID() string {
+	buffer := make([]byte, 16)
+	if _, err := rand.Read(buffer); err == nil {
+		return hex.EncodeToString(buffer)
+	}
+	return strconv.FormatInt(time.Now().UnixNano(), 36)
+}
diff --git a/internal/routes/other_routes.go b/internal/routes/other_routes.go
index 37dd52905..fbb1c67b8 100644
--- a/internal/routes/other_routes.go
+++ b/internal/routes/other_routes.go
@@ -32,6 +32,7 @@ func registerOtherRoutes(mux *http.ServeMux, h *core.Handler) {
 	// Update
 	mux.HandleFunc("/api/check-updates", func(w http.ResponseWriter, r *http.Request) { update.HandleCheckUpdates(h, w, r) })
 	mux.HandleFunc("/api/download-update", func(w http.ResponseWriter, r *http.Request) { update.HandleDownloadUpdate(h, w, r) })
+	mux.HandleFunc("/api/download-update/progress", func(w http.ResponseWriter, r *http.Request) { update.HandleDownloadUpdateProgress(h, w, r) })
 	mux.HandleFunc("/api/install-update", func(w http.ResponseWriter, r *http.Request) { update.HandleInstallUpdate(h, w, r) })
 	mux.HandleFunc("/api/version", func(w http.ResponseWriter, r *http.Request) { update.HandleVersion(h, w, r) })