diff --git a/components/FloatingBall.vue b/components/FloatingBall.vue
index 706c45d..e66e15a 100644
--- a/components/FloatingBall.vue
+++ b/components/FloatingBall.vue
@@ -33,12 +33,12 @@
         <div class="check-mark" v-if="isTranslating"></div>
         
         <!-- 添加快捷键提示 -->
-        <div class="shortcut-tooltip" v-if="showShortcutTooltip">
+        <div class="shortcut-tooltip" data-fr-translated="true" v-if="showShortcutTooltip">
           {{ shortcutTip }}
         </div>
         
         <!-- 波纹效果容器 -->
-        <div class="ripple-container" ref="rippleContainer"></div>
+        <div class="ripple-container" data-fr-translated="true" ref="rippleContainer"></div>
       </div>
     </div>
   </div>
diff --git a/components/Main.vue b/components/Main.vue
index a4f1bce..ec6e5a3 100644
--- a/components/Main.vue
+++ b/components/Main.vue
@@ -501,6 +501,43 @@
           </el-col>
         </el-row>
 
+        <!-- 批量翻译设置 -->
+        <el-row class="margin-bottom margin-left-2em">
+          <el-col :span="20" class="lightblue rounded-corner">
+            <el-tooltip class="box-item" effect="dark" content="批量翻译功能可以将多个文本项合并成一个批次进行翻译，提高翻译效率，减少API调用次数" placement="top-start" :show-after="500">
+              <span class="popup-text popup-vertical-left">批量翻译<el-icon class="icon-margin">
+                  <ChatDotRound />
+                </el-icon></span>
+            </el-tooltip>
+          </el-col>
+          <el-col :span="4" class="flex-end">
+            <el-switch v-model="config.batchTranslationEnabled" inline-prompt active-text="启用" inactive-text="禁用" />
+          </el-col>
+        </el-row>
+
+        <!-- 批量翻译大小 -->
+        <el-row v-if="config.batchTranslationEnabled" class="margin-bottom margin-left-2em">
+          <el-col :span="12" class="lightblue rounded-corner">
+            <el-tooltip class="box-item" effect="dark" content="设置每批翻译的最大文本长度，数值越大翻译效率越高，但可能超出API限制或影响翻译质量" placement="top-start" :show-after="500">
+              <span class="popup-text popup-vertical-left">批量翻译大小<el-icon class="icon-margin">
+                  <ChatDotRound />
+                </el-icon></span>
+            </el-tooltip>
+          </el-col>
+          <el-col :span="12">
+            <el-input-number
+                v-model="config.batchTranslationSize"
+                :min="1024"
+                :max="32768"
+                :step="500"
+                style="width: 100%"
+                @change="handleBatchSizeChange"
+                controls-position="right"
+            />
+            <div class="input-hint">建议范围：1024-32768字符</div>
+          </el-col>
+        </el-row>
+
         <!-- 输入框翻译目标语言 -->
         <el-row v-if="config.inputBoxTranslationTrigger !== 'disabled'" class="margin-bottom margin-left-2em">
           <el-col :span="12" class="lightblue rounded-corner">
@@ -1048,6 +1085,30 @@ const handleConcurrentChange = (currentValue: number | undefined, oldValue: numb
   });
 };
 
+// 处理批量翻译大小变化
+const handleBatchSizeChange = (currentValue: number | undefined, oldValue: number | undefined) => {
+  // 验证批量翻译大小的有效性
+  if (currentValue === undefined || currentValue < 1024 || currentValue > 32768) {
+    ElMessage({
+      message: '批量翻译大小必须在 1024-32768 字符之间',
+      type: 'warning',
+      duration: 2000
+    });
+    // 恢复默认值
+    config.value.batchTranslationSize = 4096;
+    return;
+  }
+  
+  // 显示设置已更新的提示
+  showRefreshTip.value = true;
+  
+  ElMessage({
+    message: `批量翻译大小已更新为 ${currentValue} 字符`,
+    type: 'success',
+    duration: 2000
+  });
+};
+
 // 显示刷新提示
 const showRefreshTip = ref(false);
 
@@ -1599,4 +1660,11 @@ const validateConfig = (configData: any): boolean => {
   margin-top: 4px;
   line-height: 1.4;
 }
+
+.input-hint {
+  color: var(--el-text-color-secondary);
+  font-size: 12px;
+  margin-top: 4px;
+  line-height: 1.4;
+}
 </style>
diff --git a/components/TranslationStatus.vue b/components/TranslationStatus.vue
index 3e6edb1..c4bcc27 100644
--- a/components/TranslationStatus.vue
+++ b/components/TranslationStatus.vue
@@ -2,20 +2,41 @@
   <div class="translation-status-container" v-if="isVisible && isFloatingBallTranslating && !userClosed">
     <div class="translation-status-card">
       <div class="translation-status-header">
-        <div class="translation-status-title">翻译进度</div>
-        <div class="translation-status-close" @click="close">×</div>
+        <div class="translation-status-title" data-fr-translated="true" >翻译进度</div>
+        <div class="translation-status-close" data-fr-translated="true" @click="close">×</div>
       </div>
       <div class="translation-status-content">
-        <div class="translation-status-row">
-          <div class="translation-status-label">当前活跃任务:</div>
-          <div class="translation-status-value">{{ status.activeTranslations }} / {{ status.maxConcurrent }}</div>
+        <!-- 进度条部分 -->
+        <div class="translation-progress-section">
+          <div class="translation-progress-info">
+            <div class="translation-progress-percentage">{{ Math.round(status.progressPercentage) }}%</div>
+            <div class="translation-remaining-time" v-if="realTimeRemaining > 0">
+              剩余: {{ formatRemainingTime(realTimeRemaining) }}
+            </div>
+          </div>
+          <div class="translation-overall-progress">
+            <div class="translation-overall-progress-bar" :style="overallProgressStyle"></div>
+          </div>
         </div>
-        <div class="translation-status-row">
-          <div class="translation-status-label">等待中的任务:</div>
-          <div class="translation-status-value">{{ status.pendingTranslations }}</div>
-        </div>
-        <div class="translation-status-progress">
-          <div class="translation-status-progress-bar" :style="progressStyle"></div>
+        
+        <!-- 统计信息部分 -->
+        <div class="translation-stats-section">
+          <div class="translation-status-row">
+            <div class="translation-status-label" data-fr-translated="true" >当前活跃任务:</div>
+            <div class="translation-status-value" data-fr-translated="true" >{{ status.activeTranslations }} / {{ status.maxConcurrent }}</div>
+          </div>
+          <div class="translation-status-row">
+            <div class="translation-status-label" data-fr-translated="true" >等待中的任务:</div>
+            <div class="translation-status-value" data-fr-translated="true" >{{ status.pendingTranslations }}</div>
+          </div>
+          <div class="translation-status-row">
+            <div class="translation-status-label" data-fr-translated="true" >字符进度:</div>
+            <div class="translation-status-value" data-fr-translated="true" >{{ formatNumber(status.completedCharacters) }} / {{ formatNumber(status.totalCharacters) }}</div>
+          </div>
+          <div class="translation-status-row">
+            <div class="translation-status-label" data-fr-translated="true" >平均速度:</div>
+            <div class="translation-status-value" data-fr-translated="true" >{{ status.averageSpeed }} 字符/秒</div>
+          </div>
         </div>
       </div>
     </div>
@@ -23,30 +44,60 @@
 </template>
 
 <script setup lang="ts">
-import { ref, onMounted, onUnmounted, computed } from 'vue';
-import { getTranslationStatus } from '../entrypoints/utils/translateApi';
+import { ref, onMounted, onUnmounted, computed, watch } from 'vue';
+import { getExtendedQueueStatus, ExtendedQueueStatus } from '../entrypoints/utils/translateQueue';
 
 // 组件状态
 const isVisible = ref(false);
 const isFloatingBallTranslating = ref(false);
 const userClosed = ref(false); // 用户是否关闭了状态框
-const status = ref({
+const status = ref<ExtendedQueueStatus>({
   activeTranslations: 0,
   pendingTranslations: 0,
   maxConcurrent: 6,
   isQueueFull: false,
-  totalTasksInProcess: 0
+  totalTasksInProcess: 0,
+  totalCharacters: 0,
+  completedCharacters: 0,
+  remainingCharacters: 0,
+  progressPercentage: 0,
+  estimatedRemainingTime: 0,
+  averageSpeed: 0
 });
 
-// 计算进度条样式
-const progressStyle = computed(() => {
-  const percent = status.value.activeTranslations / status.value.maxConcurrent * 100;
+// 实时剩余时间
+const realTimeRemaining = ref(0);
+let countdownTimer: number | null = null;
+
+// 计算总体进度条样式
+const overallProgressStyle = computed(() => {
+  const percent = status.value.progressPercentage;
   return {
     width: `${percent}%`,
-    backgroundColor: percent > 80 ? '#ff7675' : percent > 50 ? '#fdcb6e' : '#00cec9'
+    backgroundColor: percent > 80 ? '#00b894' : percent > 50 ? '#fdcb6e' : '#0984e3'
   };
 });
 
+// 格式化剩余时间
+const formatRemainingTime = (seconds: number): string => {
+  if (seconds < 60) {
+    return `${seconds}秒`;
+  } else if (seconds < 3600) {
+    const minutes = Math.floor(seconds / 60);
+    const remainingSeconds = seconds % 60;
+    return `${minutes}分${remainingSeconds}秒`;
+  } else {
+    const hours = Math.floor(seconds / 3600);
+    const minutes = Math.floor((seconds % 3600) / 60);
+    return `${hours}小时${minutes}分`;
+  }
+};
+
+// 格式化数字显示（添加千位分隔符）
+const formatNumber = (num: number): string => {
+  return num.toLocaleString('zh-CN');
+};
+
 // 关闭状态卡片
 const close = () => {
   userClosed.value = true; // 标记用户已关闭
@@ -81,16 +132,68 @@ const resetClosedState = () => {
   };
 };
 
+// 启动倒计时
+const startCountdown = () => {
+  if (countdownTimer) {
+    clearInterval(countdownTimer);
+  }
+  
+  // 只有当有剩余时间时才启动倒计时
+  if (status.value.estimatedRemainingTime > 0) {
+    realTimeRemaining.value = status.value.estimatedRemainingTime;
+    
+    countdownTimer = window.setInterval(() => {
+      if (realTimeRemaining.value > 0) {
+        realTimeRemaining.value--;
+      } else {
+        // 倒计时结束，停止定时器
+        if (countdownTimer) {
+          clearInterval(countdownTimer);
+          countdownTimer = null;
+        }
+      }
+    }, 1000);
+  }
+};
+
+// 停止倒计时
+const stopCountdown = () => {
+  if (countdownTimer) {
+    clearInterval(countdownTimer);
+    countdownTimer = null;
+  }
+  realTimeRemaining.value = 0;
+};
+
+// 监听状态变化，重新启动倒计时
+watch(() => status.value.estimatedRemainingTime, (newTime, oldTime) => {
+  // 如果剩余时间变化较大（超过5秒），重新启动倒计时
+  if (Math.abs(newTime - oldTime) > 5) {
+    stopCountdown();
+    startCountdown();
+  }
+});
+
 // 更新状态的定时器
 let statusUpdateTimer: number;
 
-// 创建更新状态的函数
-const updateStatus = () => {
-  const currentStatus = getTranslationStatus();
-  status.value = currentStatus;
-  
-  // 只有当有活跃任务或等待任务时才显示状态卡片
-  isVisible.value = currentStatus.activeTranslations > 0 || currentStatus.pendingTranslations > 0;
+// 创建更新状态的函数（支持异步 getExtendedQueueStatus）
+const updateStatus = async () => {
+  try {
+    const currentStatus = await getExtendedQueueStatus();
+    status.value = currentStatus;
+
+    // 只有当有活跃任务或等待任务时才显示状态卡片
+    isVisible.value = currentStatus.activeTranslations > 0 || currentStatus.pendingTranslations > 0;
+
+    // 如果没有活跃任务，停止倒计时
+    if (currentStatus.activeTranslations === 0 && currentStatus.pendingTranslations === 0) {
+      stopCountdown();
+    }
+  } catch (e) {
+    // 如果获取状态失败，保持现有状态并停止倒计时以避免误导用户
+    stopCountdown();
+  }
 };
 
 // 监听悬浮球翻译状态变化
@@ -102,11 +205,15 @@ const listenToFloatingBallState = () => {
     if (!isVisible.value) {
       userClosed.value = false;
     }
+    // 开始倒计时
+    startCountdown();
   };
   
   // 监听自定义事件: 翻译结束
   const handleTranslationEnded = () => {
     isFloatingBallTranslating.value = false;
+    // 停止倒计时
+    stopCountdown();
   };
   
   // 添加事件监听器
@@ -128,8 +235,12 @@ let resetClosedStateCleanup: () => void;
 
 // 组件挂载时启动定时器和事件监听
 onMounted(() => {
-  updateStatus(); // 立即执行一次更新
-  statusUpdateTimer = window.setInterval(updateStatus, 500);
+  // 立即执行一次更新（异步），并启动定时器来周期性调用异步更新函数
+  updateStatus();
+  statusUpdateTimer = window.setInterval(() => {
+    // 调用异步函数但不要泄漏未处理的Promise
+    updateStatus().catch(() => {});
+  }, 500);
   eventListenerCleanup = listenToFloatingBallState();
   resetClosedStateCleanup = resetClosedState();
 });
@@ -137,6 +248,7 @@ onMounted(() => {
 // 组件卸载时清理定时器和事件监听
 onUnmounted(() => {
   clearInterval(statusUpdateTimer);
+  stopCountdown();
   eventListenerCleanup.cleanup();
   resetClosedStateCleanup();
 });
@@ -156,7 +268,7 @@ onUnmounted(() => {
   border-radius: 8px;
   box-shadow: 0 4px 12px rgba(0, 0, 0, 0.1);
   overflow: hidden;
-  width: 220px;
+  width: 280px;
   transition: all 0.3s ease;
   border: 1px solid #e0e0e0;
 }
@@ -191,35 +303,63 @@ onUnmounted(() => {
   padding: 12px;
 }
 
-.translation-status-row {
+/* 进度条部分样式 */
+.translation-progress-section {
+  margin-bottom: 12px;
+}
+
+.translation-progress-info {
   display: flex;
   justify-content: space-between;
-  margin-bottom: 8px;
-  font-size: 13px;
+  align-items: center;
+  margin-bottom: 6px;
 }
 
-.translation-status-label {
-  color: #666;
+.translation-progress-percentage {
+  font-size: 16px;
+  font-weight: bold;
+  color: #3498db;
 }
 
-.translation-status-value {
-  font-weight: 600;
-  color: #333;
+.translation-remaining-time {
+  font-size: 12px;
+  color: #666;
 }
 
-.translation-status-progress {
-  height: 6px;
+.translation-overall-progress {
+  height: 8px;
   background-color: #f1f1f1;
-  border-radius: 3px;
+  border-radius: 4px;
   overflow: hidden;
-  margin-top: 10px;
 }
 
-.translation-status-progress-bar {
+.translation-overall-progress-bar {
   height: 100%;
   transition: width 0.3s ease, background-color 0.3s ease;
 }
 
+/* 统计信息部分样式 */
+.translation-stats-section {
+  border-top: 1px solid #f0f0f0;
+  padding-top: 12px;
+}
+
+.translation-status-row {
+  display: flex;
+  justify-content: space-between;
+  margin-bottom: 6px;
+  font-size: 12px;
+}
+
+.translation-status-label {
+  color: #666;
+}
+
+.translation-status-value {
+  font-weight: 600;
+  color: #333;
+}
+
 /* 暗黑模式支持 - 使用 :root[class="dark"] 选择器匹配 FluentRead 的主题系统 */
 :root[class="dark"] .translation-status-card {
   background-color: #2d3436;
@@ -267,4 +407,4 @@ onUnmounted(() => {
     background-color: #3d3d3d;
   }
 }
-</style> 
\ No newline at end of file
+</style>
diff --git a/entrypoints/background.ts b/entrypoints/background.ts
index 8753668..a41b0d2 100644
--- a/entrypoints/background.ts
+++ b/entrypoints/background.ts
@@ -1,6 +1,7 @@
 import {_service} from "@/entrypoints/service/_service";
 import {config} from "@/entrypoints/utils/config";
 import {CONTEXT_MENU_IDS} from "@/entrypoints/utils/constant";
+import { translationStatsManager } from "@/entrypoints/utils/translationStats";
 
 // 翻译状态管理
 let translationStateMap = new Map<number, boolean>(); // tabId -> isTranslated
@@ -56,7 +57,7 @@ export default defineBackground({
     persistent: {
         safari: false,
     },
-    main() {
+    async main() {
         // 创建右键菜单项
         try {
             // 创建父菜单
diff --git a/entrypoints/main/trans.ts b/entrypoints/main/trans.ts
index a7dc91d..bfca9b1 100644
--- a/entrypoints/main/trans.ts
+++ b/entrypoints/main/trans.ts
@@ -8,6 +8,7 @@ import { detectlang, throttle } from "@/entrypoints/utils/common";
 import { getMainDomain, replaceCompatFn } from "@/entrypoints/main/compat";
 import { config } from "@/entrypoints/utils/config";
 import { translateText, cancelAllTranslations } from '@/entrypoints/utils/translateApi';
+import { batchTranslationManager } from '@/entrypoints/utils/batchTranslation';
 
 let hoverTimer: any; // 鼠标悬停计时器
 let htmlSet = new Set(); // 防抖
@@ -21,6 +22,7 @@ const TRANSLATED_ATTR = 'data-fr-translated';
 const TRANSLATED_ID_ATTR = 'data-fr-node-id'; // 添加节点ID属性
 
 let nodeIdCounter = 0; // 节点ID计数器
+let batchTranslationTimer: any = null; // 批量翻译计时器
 
 // 恢复原文内容
 export function restoreOriginalContent() {
@@ -72,6 +74,8 @@ export function restoreOriginalContent() {
     // 7. 消除可能存在的全局样式污染
     const tempStyleElements = document.querySelectorAll('style[data-fr-temp-style]');
     tempStyleElements.forEach(el => el.remove());
+
+    batchTranslationManager.clear();
 }
 
 // 自动翻译整个页面的功能
@@ -97,6 +101,74 @@ export function autoTranslateEnglishPage() {
 
     isAutoTranslating = true;
 
+    batchTranslationManager.clear();
+
+    if (config.batchTranslationEnabled) {
+        nodes.forEach(node => {
+            if (node.hasAttribute(TRANSLATED_ATTR)) return;
+            
+            const nodeId = `fr-node-${nodeIdCounter++}`;
+            node.setAttribute(TRANSLATED_ID_ATTR, nodeId);
+            
+            originalContents.set(nodeId, node.innerHTML);
+            
+            node.setAttribute(TRANSLATED_ATTR, 'true');
+
+            const text = node.textContent;
+            if (text && text.trim()) {
+                batchTranslationManager.addTextItem(text, node);
+            }
+        });
+        
+        if (isAutoTranslating) {
+            batchTranslationManager.startBatchTranslation();
+        }
+
+        mutationObserver = new MutationObserver((mutations) => {
+            if (!isAutoTranslating) return;
+            
+            const newNodesToTranslate: Element[] = [];
+            
+            mutations.forEach(mutation => {
+                mutation.addedNodes.forEach(node => {
+                    if (node.nodeType === 1) { 
+                        const newNodes = grabAllNode(node as Element).filter(
+                            n => !n.hasAttribute(TRANSLATED_ATTR)
+                        );
+                        newNodesToTranslate.push(...newNodes);
+                    }
+                });
+            });
+            
+            if (newNodesToTranslate.length > 0) {
+                newNodesToTranslate.forEach(node => {
+
+                    const nodeId = `fr-node-${nodeIdCounter++}`;
+                    node.setAttribute(TRANSLATED_ID_ATTR, nodeId);
+                    
+                    originalContents.set(nodeId, node.innerHTML);
+                    
+                    node.setAttribute(TRANSLATED_ATTR, 'true');
+
+                    const text = node.textContent;
+                    if (text && text.trim()) {
+                        batchTranslationManager.addTextItem(text, node);
+                    }
+                });
+                
+                if (batchTranslationTimer) {
+                    clearTimeout(batchTranslationTimer);
+                }
+                batchTranslationTimer = setTimeout(() => {
+                    if (isAutoTranslating) {
+                        batchTranslationManager.startBatchTranslation();
+                    }
+                    batchTranslationTimer = null;
+                }, 1000); 
+            }
+        });
+    } else {
+        // 传统翻译模式：使用视窗观察器
     // 创建观察器
     observer = new IntersectionObserver((entries, observer) => {
         entries.forEach(entry => {
@@ -153,6 +225,7 @@ export function autoTranslateEnglishPage() {
             });
         });
     });
+    }
 
     // 监听整个 body 的变化
     mutationObserver.observe(document.body, {
@@ -331,4 +404,4 @@ function bilingualAppendChild(node: any, text: string) {
     newNode.append(text);
     smashTruncationStyle(node);
     node.appendChild(newNode);
-}
\ No newline at end of file
+}
diff --git a/entrypoints/utils/batchTranslation.ts b/entrypoints/utils/batchTranslation.ts
new file mode 100644
index 0000000..bb0a2b8
--- /dev/null
+++ b/entrypoints/utils/batchTranslation.ts
@@ -0,0 +1,251 @@
+/**
+ * 批量翻译管理器
+ * 负责收集、分组、批量翻译和分配翻译结果
+ */
+
+import { config } from './config';
+import { cache } from './cache';
+import { detectlang } from './common';
+import { enqueueTranslation } from './translateQueue';
+
+// 批量翻译文本项接口
+export interface BatchTextItem {
+  id: string; // 唯一标识
+  text: string; // 原始文本
+  node: Element; // 对应的DOM节点
+  nodeId: string; // 节点ID
+  translated: boolean; // 是否已翻译
+}
+
+// 批量翻译组接口
+export interface BatchTranslationGroup {
+  id: string; // 组ID
+  items: BatchTextItem[]; // 该组包含的文本项
+  combinedText: string; // 合并后的文本
+  translatedText?: string; // 翻译后的文本
+  translated?: boolean; // 是否已翻译
+}
+
+// 批量翻译管理器类
+export class BatchTranslationManager {
+  private groups: Map<string, BatchTranslationGroup> = new Map();
+  private isProcessing: boolean = false;
+  private separator: string = '\n\n=====\n\n';
+
+  /**
+   * 添加文本项到批量翻译队列
+   * @param text 原始文本
+   * @param node 对应的DOM节点
+   */
+  public addTextItem(text: string, node: Element): void {
+    if (!text || !text.trim() || this.isTextTranslated(text)) {
+      return;
+    }
+
+    const nodeId = node.getAttribute('data-fr-node-id');
+    if (!nodeId) {
+      console.warn('Node does not have data-fr-node-id attribute');
+      return;
+    }
+
+    const item: BatchTextItem = {
+      id: `item-${Date.now()}-${crypto.randomUUID()}`,
+      text: text.trim(),
+      node: node,
+      nodeId: nodeId,
+      translated: false
+    };
+
+    const groupsArray = Array.from(this.groups.values());
+    let targetGroup: BatchTranslationGroup | undefined;
+    for (let i = groupsArray.length - 1; i >= 0; i--) {
+      const g = groupsArray[i];
+      if (!g.translated) {
+        const newLength = (g.combinedText ? g.combinedText.length + this.separator.length : 0) + item.text.length;
+        if (newLength <= config.batchTranslationSize) {
+          targetGroup = g;
+          break;
+        }
+      }
+    }
+
+    if (targetGroup) {
+      // 追加到已有组
+      targetGroup.items.push(item);
+      targetGroup.combinedText = (targetGroup.combinedText ? targetGroup.combinedText + this.separator : '') + item.text;
+    } else {
+      // 创建新组并加入
+      const groupId = `group-${Date.now()}-${crypto.randomUUID()}`;
+      const group: BatchTranslationGroup = {
+        id: groupId,
+        items: [item],
+        combinedText: item.text
+      };
+      this.groups.set(groupId, group);
+    }
+  }
+
+  /**
+   * 开始批量翻译
+   */
+  public async startBatchTranslation(): Promise<void> {
+    if (this.isProcessing || this.groups.size === 0) {
+      return;
+    }
+
+    this.isProcessing = true;
+
+    try {
+      for (const group of this.groups.values()) {
+        if (!group.translatedText && !group.translated) {
+          group.translated = true;
+          this.translateGroup(group);
+        }
+      }
+    } catch (error) {
+      console.error('Batch translation failed:', error);
+    } finally {
+      this.isProcessing = false;
+    }
+  }
+
+  /**
+   * 翻译一个组
+   */
+  private async translateGroup(group: BatchTranslationGroup): Promise<void> {
+    if (group.translatedText) {
+      return;
+    }
+
+    const combinedText = group.combinedText;
+
+    const cached = cache.localGet(combinedText);
+    if (cached) {
+      group.translatedText = cached;
+      this.applyTranslationToGroup(group, cached);
+      return;
+    }
+
+    // 计算字符数
+    const characterCount = combinedText.length;
+
+    return enqueueTranslation(async () => {
+      try {
+        const result = await Promise.race([
+          browser.runtime.sendMessage({ context: document.title, origin: combinedText }),
+
+          new Promise<never>((_, reject) =>
+            setTimeout(() => reject(new Error('翻译请求超时')), 60000)
+          )
+        ]) as string;
+
+        if (result && result !== combinedText) {
+          group.translatedText = result;
+          cache.localSet(combinedText, result);
+          this.applyTranslationToGroup(group, result);
+        } else {
+          group.translatedText = combinedText;
+          group.items.forEach(item => item.translated = true);
+          this.groups.delete(group.id);
+        }
+      } catch (error) {
+        console.error('Group translation failed:', error);
+        group.translatedText = combinedText;
+        group.items.forEach(item => item.translated = true);
+        this.groups.delete(group.id);
+      }
+    }, characterCount);
+  }
+
+  /**
+   * 将翻译结果应用到组中的所有节点
+   */
+  private applyTranslationToGroup(group: BatchTranslationGroup, translatedText: string): void {
+    if (!translatedText) {
+      return;
+    }
+
+    // 分割翻译文本
+    const translatedSegments = this.splitTranslatedText(group.combinedText, translatedText);
+
+    // 应用到对应的节点
+    group.items.forEach((item, index) => {
+      if (index < translatedSegments.length) {
+        this.applyTranslationToNode(item, translatedSegments[index]);
+        item.translated = true;
+      }
+    });
+    this.groups.delete(group.id);
+  }
+
+  /**
+   * 分割翻译文本
+   */
+  private splitTranslatedText(originalText: string, translatedText: string): string[] {
+    // 简单实现：按换行符分割
+    const originalSegments = originalText.split(this.separator);
+    const translatedSegments = translatedText.split(this.separator);
+
+    // 如果分割后的数量不匹配，返回整个翻译文本
+    if (originalSegments.length !== translatedSegments.length) {
+      return [translatedText];
+    }
+
+    return translatedSegments;
+  }
+
+  /**
+   * 将翻译结果应用到单个节点
+   */
+  private applyTranslationToNode(item: BatchTextItem, translatedText: string): void {
+    if (!translatedText || translatedText === item.text) {
+      return;
+    }
+
+    const node = item.node;
+
+    // 根据翻译模式应用结果
+    if (config.display === 1) {
+      // 双语模式
+      node.classList.add('fluent-read-bilingual');
+
+      // 移除旧的翻译内容
+      const existingTranslation = node.querySelector('.fluent-read-bilingual-content');
+      if (existingTranslation) {
+        existingTranslation.remove();
+      }
+
+      // 添加新的翻译内容
+      const translationNode = document.createElement('span');
+      translationNode.className = 'fluent-read-bilingual-content';
+      translationNode.textContent = translatedText;
+      node.appendChild(translationNode);
+    } else {
+      // 单语模式
+      node.innerHTML = translatedText;
+    }
+  }
+
+  /**
+ * 清空所有文本项和组
+ */
+  public clear(): void {
+    this.groups.clear();
+    this.isProcessing = false;
+  }
+
+  /**
+   * 检查文本是否已经翻译
+   */
+  private isTextTranslated(text: string): boolean {
+    // 检查语言
+    if (detectlang(text.replace(/[\s\u3000]/g, '')) === config.to) {
+      return true;
+    }
+
+    return false;
+  }
+}
+
+// 创建全局批量翻译管理器实例
+export const batchTranslationManager = new BatchTranslationManager();
diff --git a/entrypoints/utils/model.ts b/entrypoints/utils/model.ts
index 915e58c..6de3293 100644
--- a/entrypoints/utils/model.ts
+++ b/entrypoints/utils/model.ts
@@ -53,6 +53,8 @@ export class Config {
     translationStatus: boolean; // 是否启用全文翻译进度面板
     inputBoxTranslationTrigger: string; // 输入框翻译触发方式
     inputBoxTranslationTarget: string; // 输入框翻译目标语言
+    batchTranslationEnabled: boolean; // 是否启用批量翻译
+    batchTranslationSize: number; // 每批翻译的最大文本长度
 
     constructor() {
         this.on = true;
@@ -98,6 +100,8 @@ export class Config {
         this.translationStatus = true; // 默认启用翻译进度面板
         this.inputBoxTranslationTrigger = 'disabled'; // 默认关闭输入框翻译
         this.inputBoxTranslationTarget = 'en'; // 默认翻译成英文
+        this.batchTranslationEnabled = true; // 默认开启批量翻译
+        this.batchTranslationSize = 3000; // 默认每批3000字符
     }
 }
 
diff --git a/entrypoints/utils/option.ts b/entrypoints/utils/option.ts
index 8293314..2231834 100644
--- a/entrypoints/utils/option.ts
+++ b/entrypoints/utils/option.ts
@@ -385,7 +385,7 @@ export const options = {
         {value: "triple_space", label: "连按三下空格"},
         {value: "triple_equal", label: "连按三下等号(=)"},
         {value: "triple_dash", label: "连按三下短横线(-)"},
-    ],
+    ]
 };
 
 export const defaultOption = {
@@ -408,5 +408,7 @@ export const defaultOption = {
     floatingBallHotkey: "Alt+T", // 默认悬浮球快捷键
     inputBoxTranslationTrigger: "disabled", // 默认关闭输入框翻译
     inputBoxTranslationTarget: "en", // 默认翻译成英文
+    batchTranslationEnabled: true, // 默认开启批量翻译
+    batchTranslationSize: 3000, // 默认每批3000字符
 };
 
diff --git a/entrypoints/utils/translateApi.ts b/entrypoints/utils/translateApi.ts
index 6bd2526..16b0124 100644
--- a/entrypoints/utils/translateApi.ts
+++ b/entrypoints/utils/translateApi.ts
@@ -51,7 +51,10 @@ export async function translateText(origin: string, context: string = document.t
   // 保存配置以确保计数持久化
   storage.setItem('local:config', JSON.stringify(config));
 
-  // 使用队列处理翻译请求
+  // 计算字符数
+  const characterCount = origin.length;
+
+  // 使用队列处理翻译请求（支持字符计数）
   return enqueueTranslation(async () => {
     // 创建翻译任务
     const translationTask = async (retryCount: number = 0): Promise<string> => {
@@ -94,7 +97,7 @@ export async function translateText(origin: string, context: string = document.t
 
     // 开始执行翻译任务
     return translationTask();
-  });
+  }, characterCount);
 }
 
 /**
diff --git a/entrypoints/utils/translateQueue.ts b/entrypoints/utils/translateQueue.ts
index 7e792bd..de59db6 100644
--- a/entrypoints/utils/translateQueue.ts
+++ b/entrypoints/utils/translateQueue.ts
@@ -1,14 +1,38 @@
 /**
  * 翻译队列管理模块
  * 控制并发翻译任务的数量，避免同时进行过多翻译请求
+ * 扩展支持字符计数和进度监控
  */
 
 import { config } from './config';
+import { translationStatsManager } from './translationStats';
 
 // 队列状态
 let activeTranslations = 0; // 当前活跃的翻译任务数量
 let pendingTranslations: Array<() => Promise<any>> = []; // 等待执行的翻译任务队列
 
+// 字符计数和任务跟踪
+let totalCharacters = 0; // 总字符数
+let completedCharacters = 0; // 已完成字符数
+let currentTasks: Map<string, { taskId: string; characterCount: number; startTime: number }> = new Map();
+
+/**
+ * 扩展队列状态接口
+ */
+export interface ExtendedQueueStatus {
+  activeTranslations: number;
+  pendingTranslations: number;
+  maxConcurrent: number;
+  isQueueFull: boolean;
+  totalTasksInProcess: number;
+  totalCharacters: number;
+  completedCharacters: number;
+  remainingCharacters: number;
+  progressPercentage: number;
+  estimatedRemainingTime: number;
+  averageSpeed: number;
+}
+
 // 调试相关
 const isDev = process.env.NODE_ENV === 'development';
 
@@ -18,21 +42,40 @@ function getMaxConcurrentTranslations(): number {
 }
 
 /**
- * 添加翻译任务到队列
+ * 添加翻译任务到队列（支持字符计数）
  * @param translationTask 翻译任务函数, 需要返回Promise
+ * @param characterCount 翻译字符数
+ * @param taskId 任务ID（可选，自动生成）
  * @returns 返回一个Promise，当任务执行完成时resolve
  */
-export function enqueueTranslation<T>(translationTask: () => Promise<T>): Promise<T> {
+export function enqueueTranslation<T>(
+  translationTask: () => Promise<T>,
+  characterCount: number = 0,
+  taskId?: string
+): Promise<T> {
+  const actualTaskId = taskId || `task_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  
   return new Promise((resolve, reject) => {
     // 创建任务包装器，在任务完成后处理队列状态
     const taskWrapper = async () => {
+      // 开始翻译任务统计
+      translationStatsManager.startTranslation(actualTaskId, characterCount);
       
       try {
         // 执行实际的翻译任务
         const result = await translationTask();
+        
+        // 完成翻译任务统计
+        translationStatsManager.completeTranslation(actualTaskId);
+        
+        // 更新已完成字符数
+        completedCharacters += characterCount;
+        
         resolve(result);
         return result;
       } catch (error) {
+        // 即使失败也完成统计
+        translationStatsManager.completeTranslation(actualTaskId);
         reject(error);
         throw error;
       } finally {
@@ -40,9 +83,21 @@ export function enqueueTranslation<T>(translationTask: () => Promise<T>): Promis
         activeTranslations--;
         processQueue();
         
+        // 从当前任务中移除
+        currentTasks.delete(actualTaskId);
       }
     };
 
+    // 更新总字符数
+    totalCharacters += characterCount;
+    
+    // 记录当前任务
+    currentTasks.set(actualTaskId, {
+      taskId: actualTaskId,
+      characterCount,
+      startTime: Date.now()
+    });
+
     // 将任务添加到队列
     if (activeTranslations < getMaxConcurrentTranslations()) {
       // 直接执行任务
@@ -95,6 +150,52 @@ export function getQueueStatus() {
   };
 }
 
+/**
+ * 获取扩展队列状态（包含进度和统计信息）
+ * @returns 返回扩展队列状态对象
+ */
+export async function getExtendedQueueStatus(): Promise<ExtendedQueueStatus> {
+  const maxConcurrent = getMaxConcurrentTranslations();
+  const remainingCharacters = totalCharacters - completedCharacters;
+  const progressPercentage = totalCharacters > 0 ? (completedCharacters / totalCharacters) * 100 : 0;
+
+  // Ensure translationStatsManager has loaded persisted stats before using it.
+  try {
+    // Some environments may have already initialized it; awaiting ready is safe.
+    // @ts-ignore - access ready promise
+    if (translationStatsManager.ready) await (translationStatsManager as any).ready;
+  } catch (e) {
+    // ignore
+  }
+
+  const averageSpeed = translationStatsManager.getAverageSpeed();
+  const estimatedRemainingTime = translationStatsManager.getRemainingTime(remainingCharacters);
+
+  return {
+    activeTranslations,
+    pendingTranslations: pendingTranslations.length,
+    maxConcurrent,
+    isQueueFull: activeTranslations >= maxConcurrent,
+    totalTasksInProcess: activeTranslations + pendingTranslations.length,
+    totalCharacters,
+    completedCharacters,
+    remainingCharacters,
+    progressPercentage,
+    estimatedRemainingTime,
+    averageSpeed
+  };
+}
+
+/**
+ * 重置队列统计信息
+ */
+export function resetQueueStats(): void {
+  totalCharacters = 0;
+  completedCharacters = 0;
+  currentTasks.clear();
+  translationStatsManager.resetStats();
+}
+
 /**
  * 检查是否可以添加更多任务
  * 当快速扫描页面，判断是否需要暂停扫描时使用
diff --git a/entrypoints/utils/translationStats.ts b/entrypoints/utils/translationStats.ts
new file mode 100644
index 0000000..af2be7c
--- /dev/null
+++ b/entrypoints/utils/translationStats.ts
@@ -0,0 +1,267 @@
+import { storage } from '@wxt-dev/storage';
+
+/**
+ * 翻译速度统计信息
+ */
+export interface TranslationSpeedStats {
+  /** 总翻译字符数 */
+  totalCharacters: number;
+  /** 总翻译时间（毫秒） */
+  totalTimeMs: number;
+  /** 平均速度（字符/秒） */
+  averageSpeed: number;
+  /** 历史翻译任务数量 */
+  taskCount: number;
+  /** 最后更新时间 */
+  lastUpdated: number;
+}
+
+/**
+ * 翻译任务信息
+ */
+export interface TranslationTaskInfo {
+  /** 任务ID */
+  taskId: string;
+  /** 翻译字符数 */
+  characterCount: number;
+  /** 开始时间 */
+  startTime: number;
+  /** 结束时间 */
+  endTime?: number;
+  /** 翻译时间（毫秒） */
+  translationTime?: number;
+}
+
+/**
+ * 历史速度数据存储结构
+ */
+export interface SpeedHistory {
+  /** 历史速度统计 */
+  stats: TranslationSpeedStats;
+  /** 最近的任务记录（用于计算平均速度） */
+  recentTasks: TranslationTaskInfo[];
+  /** 最大记录任务数 */
+  maxTaskRecords: number;
+}
+
+/**
+ * 翻译统计管理器
+ * 负责速度计算、数据持久化和进度计算
+ */
+export class TranslationStatsManager {
+  private _initialized = false;
+  private _readyPromise!: Promise<void>;
+  private _readyResolve!: () => void;
+  private static readonly STORAGE_KEY = 'translation-speed-history';
+  private static readonly DEFAULT_SPEED = 20; // 默认速度 20 字符/秒
+  private static readonly MAX_TASK_RECORDS = 50; // 最大记录任务数
+
+  private currentStats: TranslationSpeedStats = {
+    totalCharacters: 0,
+    totalTimeMs: 0,
+    averageSpeed: TranslationStatsManager.DEFAULT_SPEED,
+    taskCount: 0,
+    lastUpdated: Date.now()
+  };
+
+  private currentTasks: Map<string, TranslationTaskInfo> = new Map();
+
+  constructor() {
+    // 创建 ready promise，使外部可通过 translationStatsManager.ready 等待初始化完成
+    this._readyPromise = new Promise<void>((resolve) => {
+      this._readyResolve = resolve;
+    });
+    // 注意：initialize() 仍需被外部或模块顶层调用以开始加载。
+  }
+
+  /**
+   * 初始化统计管理器
+   */
+  async initialize(): Promise<void> {
+    if (this._initialized) return;
+    this._initialized = true;
+    try {
+      await this.loadSpeedHistory();
+    } catch (error) {
+      // preserve previous behavior: log and continue, but ensure ready will resolve
+      console.warn('Failed to initialize TranslationStatsManager:', error);
+    } finally {
+      // resolve ready promise when load done or on error so callers won't block forever
+      if (this._readyResolve) this._readyResolve();
+    }
+  }
+
+  /**
+   * A promise that resolves when the manager has loaded persisted stats.
+   * Useful for callers that need the persisted averageSpeed to be available.
+   */
+  get ready(): Promise<void> {
+    return this._readyPromise;
+  }
+
+  /**
+   * 开始翻译任务
+   * @param taskId 任务ID
+   * @param characterCount 字符数
+   */
+  startTranslation(taskId: string, characterCount: number): void {
+    const taskInfo: TranslationTaskInfo = {
+      taskId,
+      characterCount,
+      startTime: Date.now()
+    };
+    this.currentTasks.set(taskId, taskInfo);
+  }
+
+  /**
+   * 完成翻译任务
+   * @param taskId 任务ID
+   */
+  completeTranslation(taskId: string): void {
+    const taskInfo = this.currentTasks.get(taskId);
+    if (!taskInfo) return;
+
+    const endTime = Date.now();
+    const translationTime = endTime - taskInfo.startTime;
+
+    taskInfo.endTime = endTime;
+    taskInfo.translationTime = translationTime;
+
+    // 更新统计信息
+    this.updateSpeedStats(taskInfo);
+
+    // 从当前任务中移除
+    this.currentTasks.delete(taskId);
+  }
+
+  /**
+   * 更新速度统计
+   * @param taskInfo 任务信息
+   */
+  private updateSpeedStats(taskInfo: TranslationTaskInfo): void {
+    if (!taskInfo.translationTime || taskInfo.translationTime <= 0) return;
+
+    // 更新总字符数和总时间
+    this.currentStats.totalCharacters += taskInfo.characterCount;
+    this.currentStats.totalTimeMs += taskInfo.translationTime;
+    this.currentStats.taskCount += 1;
+    this.currentStats.lastUpdated = Date.now();
+
+    // 计算平均速度（字符/秒）
+    if (this.currentStats.totalTimeMs > 0) {
+      this.currentStats.averageSpeed = Math.round(
+        (this.currentStats.totalCharacters / this.currentStats.totalTimeMs) * 1000
+      );
+    }
+
+    // 保存更新后的统计信息
+    this.saveSpeedHistory();
+  }
+
+  /**
+   * 获取当前平均速度
+   * @returns 平均速度（字符/秒）
+   */
+  getAverageSpeed(): number {
+    return this.currentStats.averageSpeed;
+  }
+
+  /**
+   * 获取剩余时间估算
+   * @param remainingCharacters 剩余字符数
+   * @returns 剩余时间（秒）
+   */
+  getRemainingTime(remainingCharacters: number): number {
+    const speed = this.getAverageSpeed();
+    if (speed <= 0) return 0;
+    
+    return Math.ceil(remainingCharacters / speed);
+  }
+
+  /**
+   * 获取总体进度
+   * @param completedCharacters 已完成字符数
+   * @param totalCharacters 总字符数
+   * @returns 进度百分比（0-100）
+   */
+  getOverallProgress(completedCharacters: number, totalCharacters: number): number {
+    if (totalCharacters <= 0) return 0;
+    
+    const progress = (completedCharacters / totalCharacters) * 100;
+    return Math.min(Math.max(progress, 0), 100);
+  }
+
+  /**
+   * 获取当前统计信息
+   * @returns 当前统计信息
+   */
+  getStats(): TranslationSpeedStats {
+    return { ...this.currentStats };
+  }
+
+  /**
+   * 重置统计信息
+   */
+  resetStats(): void {
+    this.currentStats = {
+      totalCharacters: 0,
+      totalTimeMs: 0,
+      averageSpeed: TranslationStatsManager.DEFAULT_SPEED,
+      taskCount: 0,
+      lastUpdated: Date.now()
+    };
+    this.currentTasks.clear();
+    this.saveSpeedHistory();
+  }
+
+  /**
+   * 保存速度历史数据
+   */
+  private async saveSpeedHistory(): Promise<void> {
+    const history: SpeedHistory = {
+      stats: this.currentStats,
+      recentTasks: Array.from(this.currentTasks.values()),
+      maxTaskRecords: TranslationStatsManager.MAX_TASK_RECORDS
+    };
+
+    await storage.setItem(`local:${TranslationStatsManager.STORAGE_KEY}`, history);
+  }
+
+  /**
+   * 加载速度历史数据
+   */
+  private async loadSpeedHistory(): Promise<void> {
+    try {
+      const history = await storage.getItem<SpeedHistory>(`local:${TranslationStatsManager.STORAGE_KEY}`);
+      
+      if (history && history.stats) {
+        this.currentStats = history.stats;
+        
+        // 恢复当前任务
+        if (history.recentTasks) {
+          history.recentTasks.forEach((task: TranslationTaskInfo) => {
+            if (!task.endTime) {
+              this.currentTasks.set(task.taskId, task);
+            }
+          });
+        }
+      }
+    } catch (error) {
+      console.warn('Failed to load translation speed history:', error);
+      // 使用默认统计信息
+      this.currentStats = {
+        totalCharacters: 0,
+        totalTimeMs: 0,
+        averageSpeed: TranslationStatsManager.DEFAULT_SPEED,
+        taskCount: 0,
+        lastUpdated: Date.now()
+      };
+    }
+  }
+}
+
+// 创建全局统计管理器实例
+export const translationStatsManager = new TranslationStatsManager();
+
+
+translationStatsManager.initialize();
\ No newline at end of file