diff --git a/src/content/docs/zh-cn/concept/Inter-Process Communication/brownfield.md b/src/content/docs/zh-cn/concept/Inter-Process Communication/brownfield.md
index 436c57c0c5..b60de5c6d8 100644
--- a/src/content/docs/zh-cn/concept/Inter-Process Communication/brownfield.md	
+++ b/src/content/docs/zh-cn/concept/Inter-Process Communication/brownfield.md	
@@ -4,7 +4,7 @@ title: Brownfield 模式
 
 _**这是默认模式。**_
 
-这是使用 Tauri 的最简单和最直接的模式，因为本模式会尽最大可能尝试与现有的前端项目兼容。简而言之，它尽量不要求额外的配置，跟现有的 web 前端应用在浏览器中使用的方式保持一致。但并不是 _**所有**_ 在现有浏览器应用中有效的功能都会开箱即用。
+Brownfield 模式是使用 Tauri 最简单、最直接的方式，因为它旨在最大限度地兼容现有的前端项目。简而言之，它几乎不需要额外配置，让你能够像在浏览器中运行 Web 应用一样无缝开发。不过需要注意，**并非所有**能在浏览器中运行的功能都支持“开箱即用”。
 
 如果你不熟悉 Brownfield 软件开发模式，可以阅读 [Brownfield 维基百科]。对 Tauri 而言，现有软件特指现代浏览器支持的特性与行为规范，而非传统遗留系统。
 
diff --git a/src/content/docs/zh-cn/concept/Inter-Process Communication/index.mdx b/src/content/docs/zh-cn/concept/Inter-Process Communication/index.mdx
index 3a90bfe69c..8e0ce9481e 100644
--- a/src/content/docs/zh-cn/concept/Inter-Process Communication/index.mdx	
+++ b/src/content/docs/zh-cn/concept/Inter-Process Communication/index.mdx	
@@ -23,15 +23,15 @@ import { CardGrid, LinkCard } from '@astrojs/starlight/components';
   />
 </CardGrid>
 
-Tauri 使用一种特定风格的进程间通信，称为[异步消息传递]，其中进程通过一些简单的数据表示交换*请求*和*响应*。对于任何有 Web 开发经验的人来说，消息传递应该听起来很熟悉，因为这种范式用于互联网的客户端-服务器通信。
+Tauri 使用一种特定风格的进程间通信，称为[异步消息传递]，进程间通过简单的数据载体交换“请求”和“响应”。对于有 Web 开发经验的人来说，消息传递机制一定不陌生，因为互联网的客户端-服务器（Client-Server）通信正是采用了这种范式。
 
-消息传递是一种比共享内存或直接函数访问更安全的技术，因为接收方可以自由地拒绝或丢弃请求。例如，如果Tauri核心进程确定某个请求是恶意的，它将简单地丢弃该请求，并且不会执行相应的函数。
+相比于共享内存或直接调用函数，消息传递是一种更安全的技术。因为接收方拥有主动权，可以自由地过滤或丢弃非法请求。例如，如果 Tauri 核心进程判断某个 IPC 请求具有恶意，它会直接丢弃该消息，而绝不会去执行相应的函数。
 
 接下来，我们将更详细地解释 Tauri 的两个 IPC 原语——`事件`和`命令`。
 
 ## 事件
 
-事件是一次性、单向的 IPC 消息，最适合用于通信生命周期事件和状态变化。与[命令](#命令)不同，事件可以由前端*和* Tauri 核心发出。
+事件是一次性、单向的 IPC 消息，最适合用于通信生命周期事件和状态变化。与[命令](#命令)不同，事件可以由前端*和* Tauri 核心双向发起。
 
 <figure>
 
@@ -56,7 +56,7 @@ Core -> Frontend: "Event"{style.animated: true}
 
 ## 命令
 
-Tauri 还提供了一种类似于[外部函数接口]的抽象，建立在IPC消息之上[^1]。主要 API `invoke` 类似于浏览器的`fetch` API，允许前端调用 Rust 函数、传递参数并接收数据。
+Tauri 还提供了一种类似于[外部函数接口]的抽象，建立在IPC消息之上[^1]。核心 API `invoke` 的用法类似于浏览器的`fetch` API，允许前端调用 Rust 函数、传递参数并接收数据。
 
 由于该机制在底层使用类似 [JSON-RPC] 的协议来序列化请求和响应，因此所有参数和返回数据必须能够序列化为 JSON。
 
@@ -86,7 +86,7 @@ Core -> Frontend: "Response"{style.animated: true}
 <figcaption>命令调用中涉及的 IPC 消息。</figcaption>
 </figure>
 
-[^1]: 由于命令在底层仍然使用消息传递，因此它们没有真实 FFI 接口所面临的安全隐患。
+[^1]: 因为命令在底层依然遵循消息传递机制，所以它们规避了真实 FFI 接口常见的内存安全隐患。
 
 [异步消息传递]: https://en.wikipedia.org/wiki/Message_passing#Asynchronous_message_passing
 [json-rpc]: https://www.jsonrpc.org
diff --git a/src/content/docs/zh-cn/concept/Inter-Process Communication/isolation.md b/src/content/docs/zh-cn/concept/Inter-Process Communication/isolation.md
index e0f7e0cab5..a96f9c0e11 100644
--- a/src/content/docs/zh-cn/concept/Inter-Process Communication/isolation.md	
+++ b/src/content/docs/zh-cn/concept/Inter-Process Communication/isolation.md	
@@ -7,13 +7,13 @@ i18nReady: true
 
 ## 为什么这么做
 
-隔离模式向开发者提供一种避免程序中前端不必要或恶意地调用 Tauri Core 的机制。这一需求源自运行在前端的不受信任内容的威胁，有大量依赖的应用经常遇到这种情形。请查看 [Security: Threat Models] 来了解应用程序可能遇到的威胁的来源。
+隔离模式为开发者提供了一种防御机制，防止前端意外或恶意地调用 Tauri 核心。这一需求源自运行在前端的不受信任内容的威胁，有大量依赖的应用经常遇到这种情形。请查看 [security: threat models] 来了解应用程序可能遇到的威胁的来源。
 
-隔离模式在设计时考虑的最大的威胁模型是**开发威胁**（Development Threats）。除了许多前端构建时工具所包括的数十（甚至数百）个通常是深度嵌套的依赖，一个复杂的应用也还可能捆绑大量（通常也是深度嵌套的）依赖到最终输出。
+隔离模式设计的初衷是为了应对**开发环境威胁**（Development Threats）。现代前端应用除了构建工具自带的成百上千个深度嵌套依赖外，最终产物中通常也会捆绑大量复杂的第三方库。
 
-## 何时需要
+## 适用场景
 
-Tauri 强烈推荐只要有可能就使用隔离模式。因为隔离应用程序截获来自前端的***所有***信息，它*始终*可以被使用。
+Tauri 强烈建议只要条件允许就开启隔离模式。由于隔离应用会拦截来自前端的***所有***通信，因此它在任何场景下都有效。
 
 Tauri 同时也强烈推荐在使用外部 Tauri API 时加强应用的安全性。作为开发者，你可以使用安全隔离应用程序尝试验证 IPC 输入，以确保它们在某些预期参数范围内。例如，你可能需要检查读取或写入文件的调用是否尝试访问应用程序预期位置之外的路径。另一个例子是确保 Tauri API 的 HTTP 获取调用仅将 Origin 标头设置为应用程序预期的值。
 
@@ -21,13 +21,13 @@ Tauri 同时也强烈推荐在使用外部 Tauri API 时加强应用的安全性
 
 ## 如何使用
 
-隔离模式的核心在于在前端和 Tauri Core 之间注入一个安全的应用程序，用于拦截和修改传入的 IPC 消息。它利用 `<iframe>` 的沙盒功能，将 JavaScript 与主前端应用程序安全地一起运行。Tauri 在加载页面时强制执行隔离模式，强制所有对 Tauri Core 的 IPC 调用都首先通过沙盒隔离应用程序进行路由。一旦消息准备好传递给 Tauri Core，它将使用浏览器的 [SubtleCrypto] 实现进行加密，然后传递回主前端应用程序。到达主前端应用程序后，它将直接传递给 Tauri Core，然后像平常一样进行解密和读取。
+隔离模式的核心在于在前端和 Tauri 核心之间注入一个安全的应用程序，用于拦截和修改传入的 IPC 消息。它利用 `<iframe>` 的沙盒功能，将 JavaScript 与主前端应用程序安全地一起运行。Tauri 在加载页面时强制执行隔离模式，强制所有对 Tauri 核心的 IPC 调用都首先通过沙盒隔离应用程序进行路由。一旦消息准备好传递给 Tauri 核心，它将使用浏览器的 [SubtleCrypto] 实现进行加密，然后传递回主前端应用程序。到达主前端应用程序后，它将直接传递给 Tauri 核心，然后像平常一样进行解密和读取。
 
 为了确保他人无法手动读取应用程序特定版本的密钥并使用它来修改加密后的消息，每次运行应用程序时都会生成新密钥。
 
-### IPC 消息的大致步骤
+### IPC 消息流转步骤
 
-为了更容易理解，下面列出了 IPC 消息通过隔离模式发送到 Tauri Core 时将经历的大致步骤：
+为了方便理解，下面列出了 IPC 消息通过隔离模式发送到 Tauri 核心时将经历的大致步骤：
 
 1. Tauri 的 IPC 处理程序收到一条消息
 2. IPC 处理程序 -> 隔离应用程序
@@ -40,9 +40,9 @@ _注意：箭头（->）表示消息传递。_
 
 ### 性能影响
 
-由于消息确实会加密，因此与 [Brownfield 模式] 相比，即使安全隔离应用程序不执行任何操作，也会产生额外的开销。除了性能敏感的应用程序（这些应用程序可能拥有精心维护且数量较少的依赖项，以保持足够的性能）外，大多数应用程序应该不会在意加密/解密 IPC 消息的运行时成本，因为它们相对较小，并且 AES-GCM 相对较快。如果你不熟悉 AES-GCM，那么在此上下文中，重要的是它是 [SubtleCrypto] 中包含的唯一身份验证模式算法，并且你可能每天都在 [TLS][transport_layer_security] 中使用它。
+由于消息确实会加密，因此与 [Brownfield 模式] 相比，即使安全隔离应用程序不执行任何操作，也会产生额外的开销。除了性能敏感的应用程序（这些应用程序可能拥有精心维护且数量较少的依赖项，以保持足够的性能）外，大多数应用程序应该不会受到加密/解密 IPC 消息的运行时成本影响，因为它们相对较小，并且 AES-GCM 相对较快。如果你不熟悉 AES-GCM，那么在此上下文中，重要的是它是 [SubtleCrypto] 中包含的唯一身份验证模式算法，并且你可能每天都在 [TLS][transport_layer_security] 中使用它。
 
-Tauri 应用程序每次启动时都会生成一个加密安全密钥。如果系统已经拥有足够的熵来立即返回足够的随机数，通常不会注意到这一点，这在桌面环境中非常常见。如果您在无头环境中运行 [WebDriver 一体化测试]， 则可能需要安装某种熵生成服务（例如 `haveged` ，如果您的操作系统尚未安装该服务）。<sup>Linux 5.6（2020 年 3 月）现在包含使用推测执行的熵生成功能。</sup>
+Tauri 应用程序每次启动时都会生成一个加密安全密钥。如果系统已经拥有足够的熵来立即返回足够的随机数，通常不会注意到这一点，这在桌面环境中非常常见。如果你在无头环境中运行 [WebDriver 集成测试]， 则可能需要安装某种熵生成服务（例如 `haveged` ，如果你的操作系统尚未安装该服务）。<sup>Linux 5.6（2020 年 3 月）现在包含使用推测执行的熵生成功能。</sup>
 
 ### 限制
 
@@ -50,11 +50,11 @@ Tauri 应用程序每次启动时都会生成一个加密安全密钥。如果
 
 ## 建议
 
-由于隔离应用程序的目的是防御开发威胁，我们强烈建议您的隔离应用程序尽可能保持简单。您不仅应该努力保持隔离应用程序的依赖关系最小化，还应该考虑尽量减少其所需的构建步骤。这样，您就无需担心前端应用程序之上的隔离应用程序受到供应链攻击。
+由于隔离应用程序的目的是防御开发威胁，我们强烈建议你的隔离应用程序尽可能保持简单。你不仅应该努力保持隔离应用程序的依赖关系最小化，还应该考虑尽量减少其所需的构建步骤。这样，你就无需担心前端应用程序之上的隔离应用程序受到供应链攻击。
 
 ## 创建隔离应用程序
 
-在这个例子中，我们将创建一个小型的 hello-world 风格的 Isolation 应用，并将其连接到一个虚构的现有 Tauri 应用。它不会对传入的消息进行验证，只会将内容打印到 WebView 控制台。
+在这个例子中，我们将创建一个小型的 hello-world 风格的隔离模式应用，并将其连接到一个虚构的现有 Tauri 应用。它不会对传入的消息进行验证，只会将内容打印到 WebView 控制台。
 
 为了本例的目的，假设我们与 `tauri.conf.json` 位于同一目录中。现有的 Tauri 应用程序将其 `distDir` 设置为 `../dist` 。
 
@@ -77,7 +77,7 @@ Tauri 应用程序每次启动时都会生成一个加密安全密钥。如果
 
 ```javascript
 window.__TAURI_ISOLATION_HOOK__ = (payload) => {
-  // 不需要验证或修改任何内容，仅输出钩子中的内容
+  // 不需要验证或修改任何内容，仅输出 Hook 中的内容
   console.log('hook', payload);
   return payload;
 };
@@ -112,4 +112,4 @@ window.__TAURI_ISOLATION_HOOK__ = (payload) => {
 [事件]: /zh-cn/reference/javascript/api/namespaceevent/
 [subtlecrypto]: https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto
 [brownfield 模式]: /zh-cn/concept/inter-process-communication/brownfield/
-[WebDriver 一体化测试]: /zh-cn/develop/tests/webdriver/
+[WebDriver 集成测试]: /zh-cn/develop/tests/webdriver/
diff --git a/src/content/docs/zh-cn/concept/architecture.mdx b/src/content/docs/zh-cn/concept/architecture.mdx
index 2a5233a1c9..b130490d05 100644
--- a/src/content/docs/zh-cn/concept/architecture.mdx
+++ b/src/content/docs/zh-cn/concept/architecture.mdx
@@ -1,5 +1,5 @@
 ---
-title: Tauri 结构
+title: Tauri 架构
 sidebar:
   order: 0
   i18nReady: true
@@ -7,15 +7,15 @@ sidebar:
 
 ## 介绍
 
-Tauri 是一个多语言和通用工具包，非常可组合，允许工程师创建各种应用程序。它用于使用 Rust 工具和在Webview 中呈现的 HTML 构建桌面计算机应用程序。使用 Tauri 构建的应用程序可以与任意数量的可选 JS API 和Rust API一起发布，以便 Webview 可以通过消息传递控制系统。开发人员可以轻松扩展默认 API，以实现自己的功能，并在 Webview 和基于 Rust 的后端之间建立桥接。
+Tauri 是一个多语言通用工具包，具有极强的可组合性，能够帮助工程师构建各类应用。它通过结合 Rust 工具链和 Webview 渲染的 HTML 来打造桌面端应用程序。基于 Tauri 构建的应用可以根据需要选择性地引入 JS API 和 Rust API，使 Webview 能够通过消息传递来操控系统。开发者可以用自定义功能扩展默认 API，轻松搭建起 Webview 与 Rust 后端之间的桥梁。
 
-Tauri 应用程序可以具有[托盘类型接口](/zh-cn/learn/system-tray/)。它们可以被[更新](/zh-cn/plugin/updater/)，并按预期由用户的操作系统进行管理。由于使用了操作系统的 Webview，它们非常小。它们不附带运行时，因为最终的二进制文件是从 Rust 编译而来的。这使得[反向工程 Tauri 应用程序不是一项简单的任务](/zh-cn/security/)。
+Tauri 应用支持[系统托盘](/zh-cn/learn/system-tray/)，具备[自我更新](/zh-cn/plugin/updater/)能力，并由用户的操作系统管理。由于直接调用系统的 Webview，生成的应用体积非常小。同时，由于最终的可执行文件由 Rust 编译而成，不携带运行环境，这使得[对 Tauri 应用进行反编译](/zh-cn/security/)变得非常困难。
 
-### Tauri 不是
+### Tauri 不是什么
 
-Tauri 不是一个轻量级内核包装器。相反，它直接使用 [WRY](#wry) 和 [TAO](#tao) 来进行系统调用的重负载。
+Tauri 不是一个轻量级内核封装层。相反，它直接使用 [WRY](#wry) 和 [TAO](#tao) 来处理与操作系统进行系统调用的一系列重负载。
 
-Tauri 不是虚拟机或虚拟化环境。相反，它是一个应用程序工具包，允许制作 Webview OS 应用程序。
+Tauri 不是虚拟机或虚拟化环境。相反，它是一个应用程序工具包，用于制作 Webview OS 应用程序。
 
 ## 核心生态系统
 
@@ -50,20 +50,20 @@ Upstream.WRY -> Upstream.TAO{style.animated: true}
 Core."tauri-runtime-wry" -> Upstream.Wry {style.animated: true}
 ```
 
-<figcaption>简化的 Tauri 架构图</figcaption>
+<figcaption>Tauri 架构简化示意图</figcaption>
 </figure>
 
 ### tauri
 
 [在 GitHub 上查看](https://github.com/tauri-apps/tauri/tree/dev/crates/tauri)
 
-这是一个主要的 crate，将所有内容结合在一起。它将运行时、宏、工具和 API 整合成一个最终产品。它在编译时读取[`tauri.conf.json`](/zh-cn/reference/config/)文件，以引入功能并进行应用程序的实际配置（甚至是项目文件夹中的 `Cargo.toml` 文件）。它在运行时处理脚本注入（用于 polyfills / 原型修订），托管与系统交互的 API，甚至管理更新过程。
+这是将所有组件凝聚在一起的核心 Crate。它将运行时、宏、工具函数和 API 整合为一个最终成品。它在编译时读取 [`tauri.conf.json`](/zh-cn/reference/config/) 配置文件来引入功能并完成应用配置（甚至包括项目目录下的 `Cargo.toml`）。它负责在运行时进行脚本注入（用于 Polyfill 或原型修订）、托管系统交互 API，并管理更新流程。
 
 ### tauri-runtime
 
 [在 GitHub 上查看](https://github.com/tauri-apps/tauri/tree/dev/crates/tauri-runtime)
 
-Tauri 本身与底层 Webview 库之间的粘合层。
+连接 Tauri 自身与底层 Webview 库的胶水层。
 
 ### tauri-macros
 
@@ -75,7 +75,7 @@ Tauri 本身与底层 Webview 库之间的粘合层。
 
 [在 GitHub 上查看](https://github.com/tauri-apps/tauri/tree/dev/crates/tauri-utils)
 
-在许多地方重复使用的通用代码，提供有用的工具，如解析配置文件、检测平台三元组、注入 CSP 和管理资产。
+在多处复用的公共代码，提供诸如解析配置文件、检测平台三元组（Target Triple）、注入内容安全策略（CSP）以及资源管理等实用功能。
 
 ### tauri-build
 
@@ -87,13 +87,13 @@ Tauri 本身与底层 Webview 库之间的粘合层。
 
 [在 GitHub 上查看](https://github.com/tauri-apps/tauri/tree/dev/crates/tauri-codegen)
 
-嵌入、哈希和压缩资产，包括应用程序的图标以及系统托盘。在编译时解析[`tauri.conf.json`](/zh-cn/reference/config/)并生成 Config 结构。
+负责对资源（包括应用图标和系统托盘图标）进行嵌入、哈希和压缩。在编译时解析 [`tauri.conf.json`](/zh-cn/reference/config/) 并生成 Config 结构体。
 
 ### tauri-runtime-wry
 
 [在 GitHub 上查看](https://github.com/tauri-apps/tauri/tree/dev/crates/tauri-runtime-wry)
 
-这个 crate 为 WRY 打开了直接的系统级交互，例如打印、监视器检测和其他与窗口相关的任务。
+该 Crate 专门为 WRY 开启底层系统级交互，例如打印、显示器检测及其他窗口相关的任务。
 
 ## Tauri 工具
 
@@ -101,41 +101,41 @@ Tauri 本身与底层 Webview 库之间的粘合层。
 
 [在 GitHub 上查看](https://github.com/tauri-apps/tauri/tree/dev/packages/api)
 
-一个 TypeScript 库，为您创建 `cjs` 和 `esm` JavaScript 端点，以便您导入到前端框架中，以便 Webview 可以调用和监听后端活动。还以纯 TypeScript 的形式发布，因为对于某些框架来说，这更为优化。它利用 Webview 的消息传递与其主机进行通信。
+一个 TypeScript 库，提供 `cjs` 和 `esm` 格式的 JavaScript 端点，供前端框架导入。通过它，Webview 可以调用后端功能或监听后端活动。该库也提供纯 TypeScript 版本，以适配某些特定框架。它利用 Webview 到主机的消息传递机制实现通信。
 
 ### Bundler (Rust / Shell)
 
 [在 GitHub 上查看](https://github.com/tauri-apps/tauri/tree/dev/crates/tauri-bundler)
 
-一个库，为其检测或被告知的平台构建 Tauri 应用程序。目前支持 macOS、Windows 和 Linux—但在不久的将来也将支持移动平台。可以在 Tauri 项目之外使用。
+一个用于针对目标平台构建 Tauri 应用的库。目前支持 macOS、Windows 和 Linux，并计划在不久的将来支持移动平台。该工具也可在 Tauri 项目之外独立使用。
 
 ### cli.rs (Rust)
 
 [在 GitHub 上查看](https://github.com/tauri-apps/tauri/tree/dev/crates/tauri-cli)
 
-这个 Rust 可执行文件提供了 CLI 所需的所有活动的完整接口。它在 macOS、Windows 和 Linux 上运行。
+这个 Rust 编写的可执行文件提供了 CLI 所需的所有核心交互接口，可在 macOS、Windows 和 Linux 上运行。
 
 ### cli.js (JavaScript)
 
 [在 GitHub 上查看](https://github.com/tauri-apps/tauri/tree/dev/packages/cli)
 
-围绕 [`cli.rs`](https://github.com/tauri-apps/tauri/blob/dev/crates/tauri-cli)的包装，使用 [`napi-rs`](https://github.com/napi-rs/napi-rs) 为每个平台生成 npm 包。
+基于 [`napi-rs`](https://github.com/napi-rs/napi-rs) 对 [`cli.rs`](https://github.com/tauri-apps/tauri/blob/dev/crates/tauri-cli) 进行了封装，为各个平台生成对应的 npm 包。
 
 ### create-tauri-app (JavaScript)
 
 [在 GitHub 上查看](https://github.com/tauri-apps/create-tauri-app)
 
-一个工具包，使工程团队能够快速搭建新的 `tauri-apps` 项目，使用他们选择的前端框架（只要它已被配置）。
+一个脚手架工具，帮助工程团队使用自选的前端框架快速初始化 `tauri-apps` 项目。
 
 ## 上游 Crates
 
-Tauri-Apps 组织维护两个来自 Tauri 的“上游” crate，即 TAO 用于创建和管理应用程序窗口，WRY 用于与窗口内的 Webview 进行接口。
+Tauri-Apps 组织维护着两个 Tauri 的上游 Crate：用于创建和管理应用窗口的 **TAO**，以及用于与窗口内 Webview 进行交互的 **WRY**。
 
 ### TAO
 
 [在 GitHub 上查看](https://github.com/tauri-apps/tao)
 
-一个跨平台的应用程序窗口创建库，支持所有主要平台，如 Windows、macOS、Linux、iOS 和 Android。用 Rust 编写，它是 [winit](https://github.com/rust-windowing/winit) 的一个分支，我们根据自己的需要进行了扩展—例如菜单栏和系统托盘。
+一个跨平台的 Rust 窗口创建库，支持 Windows、macOS、Linux、iOS 和 Android。它分叉（Fork）自 [winit](https://github.com/rust-windowing/winit)，并针对我们的需求（如菜单栏和系统托盘）进行了扩展。
 
 ### WRY
 
@@ -143,25 +143,25 @@ Tauri-Apps 组织维护两个来自 Tauri 的“上游” crate，即 TAO 用于
 
 WRY 是一个跨平台的 WebView 渲染库，用 Rust 编写，支持所有主要桌面平台，如 Windows、macOS 和 Linux。Tauri 使用 WRY 作为抽象层，负责确定使用哪个 Webview（以及如何进行交互）。
 
-## 其他工具
+## 辅助工具
 
 ### tauri-action
 
 [在 GitHub 上查看](https://github.com/tauri-apps/tauri-action)
 
-一个 GitHub 工作流，为所有平台构建 Tauri 二进制文件。甚至允许创建一个（非常基本的）Tauri 应用程序，即使没有设置 Tauri。
+一个 GitHub 工作流（Workflow），用于为全平台构建 Tauri 二进制文件。即使在未配置 Tauri 的环境下，也能构建基础的 Tauri 应用。
 
 ### tauri-vscode
 
 [在 GitHub 上查看](https://github.com/tauri-apps/tauri-vscode)
 
-这个项目增强了 Visual Studio Code 界面，提供了一些非常实用的功能。
+该项目为 Visual Studio Code 增强了多项实用的开发界面和特性。
 
 ### vue-cli-plugin-tauri
 
 [在 GitHub 上查看](https://github.com/tauri-apps/vue-cli-plugin-tauri)
 
-允许您在 vue-cli 项目中非常快速地安装 Tauri。
+在 vue-cli 项目中非常快速地安装 Tauri。
 
 ## 插件
 
@@ -169,9 +169,9 @@ WRY 是一个跨平台的 WebView 渲染库，用 Rust 编写，支持所有主
 
 一般来说，插件由第三方编写（尽管可能有官方支持的插件）。一个插件通常完成三件事：
 
-1. 使 Rust 代码能够“做某事”。
-2. 提供接口粘合，使其易于集成到应用程序中。
-3. 提供 JavaScript API，以便与 Rust 代码进行接口。
+1. 编写 Rust 代码实现特定功能。
+2. 提供接口胶水层，方便集成到应用中。
+3. 提供用于与 Rust 代码通信的 JavaScript API。
 
 以下是一些 Tauri 插件的示例：
 
@@ -181,6 +181,6 @@ WRY 是一个跨平台的 WebView 渲染库，用 Rust 编写，支持所有主
 
 ## 许可证
 
-Tauri 本身根据 MIT 或 Apache-2.0 许可证授权。如果您重新打包并修改任何源代码，您有责任确保遵守所有上游许可证。Tauri 以“原样”提供，没有明确的适用性声明。
+Tauri 本身采用 MIT 或 Apache-2.0 协议授权。如果你重新封装并修改了任何源代码，你有责任确保遵守所有上游许可证。Tauri 按“原样”提供，不对其特定用途的适用性作任何明示保证。
 
-在这里，您可以浏览我们的[软件材料清单](https://app.fossa.com/projects/git%2Bgithub.com%2Ftauri-apps%2Ftauri)。
+你可以在此处查阅我们的[软件物料清单 (SBOM)](https://app.fossa.com/projects/git%2Bgithub.com%2Ftauri-apps%2Ftauri)。
diff --git a/src/content/docs/zh-cn/concept/index.mdx b/src/content/docs/zh-cn/concept/index.mdx
index 76ab1654bf..3a586a99c4 100644
--- a/src/content/docs/zh-cn/concept/index.mdx
+++ b/src/content/docs/zh-cn/concept/index.mdx
@@ -8,32 +8,32 @@ sidebar:
 
 import { CardGrid, LinkCard } from '@astrojs/starlight/components';
 
-Tauri 有多种主题被认为是核心概念，任何开发者在开发应用程序时都应该了解的事情。如果你想充分利用这个框架，这里有一些你应该更加熟悉的主题。
+Tauri 包含了一系列核心概念，是任何开发者在开发应用时都应了解的内容。如果你想充分发挥该框架的能力，建议深入熟悉以下这些主题。
 
 <CardGrid>
   <LinkCard
     title="Tauri 架构"
     href="/zh-cn/concept/architecture/"
-    description="架构和生态系统。"
+    description="架构设计与生态系统全貌。"
   />
   <LinkCard
     title="进程间通信 (IPC)"
     href="/zh-cn/concept/inter-process-communication/"
-    description="IPC 的内部工作原理。"
+    description="深入探索 IPC 的底层运作机制。"
   />
   <LinkCard
     title="安全性"
     href="/security/"
-    description="Tauri 如何实施安全实践。"
+    description="了解 Tauri 如何保障应用安全。"
   />
   <LinkCard
     title="进程模型"
     href="/zh-cn/concept/process-model/"
-    description="Tauri 管理哪些进程以及原因。"
+    description="详解 Tauri 的进程管理方式及其设计初衷。"
   />
   <LinkCard
-    title="应用程序大小"
+    title="程序大小"
     href="/zh-cn/concept/size/"
-    description="如何尽量缩小你的应用程序。"
+    description="如何打造极简尺寸的应用安装包。"
   />
 </CardGrid>
diff --git a/src/content/docs/zh-cn/concept/process-model.md b/src/content/docs/zh-cn/concept/process-model.md
index a6de83527f..f8e8c4f7df 100644
--- a/src/content/docs/zh-cn/concept/process-model.md
+++ b/src/content/docs/zh-cn/concept/process-model.md
@@ -9,21 +9,21 @@ Tauri 采用了类似于 Electron 或许多现代网页浏览器的多进程架
 
 ## 为什么使用多个进程？
 
-在图形用户界面（GUI）应用程序的早期阶段，通常使用单个进程来执行计算、绘制界面和响应用户输入。正如你可能猜到的，这意味着长时间运行的昂贵计算会使用户界面无响应，或者更糟糕的是，应用程序的一个组件发生故障会导致整个应用程序崩溃。
+在早期的 GUI（图形用户界面）应用时代，通常使用单个进程来执行计算、绘制界面和响应用户输入。正如你所料，这意味着一旦应用执行耗时较长的重度计算，界面就会卡死；更糟糕的是，一旦某个组件出故障，整个应用都会崩溃。
 
-显然，需要一种更具弹性的架构，应用程序开始在不同的进程中运行不同的组件。这更好地利用了现代多核 CPU，并创造了更安全的应用程序。一个组件的崩溃不会再影响整个系统，因为组件在不同的进程中隔离开来。如果一个进程进入无效状态，我们可以轻松重启它。
+显然，需要一种更具弹性的架构，于是，应用开始将不同的功能组件放在独立的进程中运行。这种设计不仅能更好地利用现代多核 CPU 的性能，还能让应用变得更安全。因为组件之间相互隔离，某个组件崩溃并不会波及全局。如果某个进程状态异常，我们直接重启它就可以恢复。
 
-我们还可以通过仅向每个进程分配最低限度的权限来限制潜在漏洞的影响范围，给予它们完成工作的足够权限。这种模式被称为[最小权限原则]，在现实世界中你经常会看到。如果你请来一个园丁修剪你的树篱，你会给他们你的花园的钥匙。你不会给他们你房子的钥匙；他们为什么需要访问那个呢？同样的概念适用于计算机程序。我们给他们的访问权限越少，如果被攻破，他们造成的伤害就越小。
+此外，我们还可以根据[最小权限原则]，只给每个进程分配完成任务所需的最低权限。这在现实生活中很常见：如果你请园丁来修剪树篱，你只会给他花园的钥匙，而不会把房门的钥匙也交给他——因为他根本不需要进屋。计算机程序也是同理：我们给出的访问权限越少，万一程序被攻破时，潜在的破坏就越小。
 
 ## 核心进程
 
-每个 Tauri 应用程序都有一个核心进程，作为应用程序的入口点，并且是唯一一个拥有完全操作系统访问权限的组件。
+每个 Tauri 应用都有一个核心进程，它是应用的入口点，也是唯一拥有完整操作系统访问权限的组件。
 
-核心的主要责任是利用该权限创建和协调应用程序窗口、系统托盘菜单或通知。Tauri 实现了必要的跨平台抽象，使这一过程变得简单。它还通过核心进程路由所有[进程间通信]，允许你在一个中心位置拦截、过滤和操作 IPC 消息。
+核心进程的主要职责是利用这些权限来创建和管理应用窗口、系统托盘菜单或通知。Tauri 帮你做好了复杂的跨平台抽象，让这些操作变得非常简单。同时，所有的[进程间通信]（IPC）都会经过核心进程进行路由，方便你在中心位置对消息进行拦截、过滤或处理。
 
-核心进程还应负责管理全局状态，例如设置或数据库连接。这使你能够轻松同步窗口之间的状态，并保护你的商业敏感数据免受前端窥探。
+核心进程还负责管理全局状态，比如应用设置或数据库连接。这样你就能轻松地在不同窗口间同步状态，并防止前端脚本窥探到商业敏感数据。
 
-我们选择 Rust 来实现 Tauri，因为它的[所有权]概念在保证内存安全的同时保持了优异的性能。
+我们选择用 Rust 来实现 Tauri，正是因为 Rust 的[所有权]概念既能保证出色的内存安全性，又能兼顾高性能。
 
 <figure>
 
@@ -55,16 +55,16 @@ Core -> "事件与命令 3"{style.animated: true}
 "事件与命令 3" -> WebView3{style.animated: true}
 ```
 
-<figcaption>Tauri 进程模型的简化表示。一个核心进程管理一个或多个 WebView 进程。</figcaption>
+<figcaption>Tauri 进程模型简化示意图。由一个核心进程管理一个或多个 WebView 进程。</figcaption>
 </figure>
 
 ## WebView 进程
 
-核心进程并不直接渲染实际的用户界面（UI）；它启动 WebView 进程，这些进程利用操作系统提供的 WebView 库。WebView 是一个类似浏览器的环境，可以执行你的 HTML、CSS 和 JavaScript。
+核心进程本身并不负责渲染界面，它会启动 WebView 进程。这些进程调用的是操作系统自带的 WebView 库（可以把 WebView 看作一个可以执行 HTML、CSS 和 JavaScript 的浏览器环境）。
 
 这意味着你在传统网页开发中使用的大多数技术和工具都可以用来创建 Tauri 应用程序。例如，许多 Tauri 示例是使用 [Svelte] 前端框架和 [Vite] 打包工具编写的。
 
-安全最佳实践同样适用；例如，你必须始终清理用户输入，绝不要在前端处理机密信息，并且理想情况下将尽可能多的业务逻辑推迟到核心进程，以保持你的攻击面较小。
+当然，Web 开发的安全最佳实践在这里同样适用。例如：永远要过滤用户输入，绝不要在前端处理敏感机密信息，并且尽可能把业务逻辑写在核心进程里，以缩小被攻击的风险。
 
 与其他类似解决方案不同，WebView 库**不**包含在你的最终可执行文件中，而是在运行时动态链接[^1]。这使你的应用程序*显著*更小，但也意味着你需要考虑平台差异，就像传统网页开发一样。
 
diff --git a/src/content/docs/zh-cn/concept/size.mdx b/src/content/docs/zh-cn/concept/size.mdx
index f2f8581cb0..1b570b8b2f 100644
--- a/src/content/docs/zh-cn/concept/size.mdx
+++ b/src/content/docs/zh-cn/concept/size.mdx
@@ -7,13 +7,13 @@ sidebar:
 
 import { Tabs, TabItem } from '@astrojs/starlight/components';
 
-虽然 Tauri 默认提供非常小的二进制文件，但稍微推一下极限也无妨，因此这里有一些技巧和建议，以达到最佳效果。
+虽然 Tauri 默认提供非常小的二进制文件，但稍微推一下极限也无妨。以下是一些实用的技巧和建议，帮助你进一步压缩应用体积。
 
 ## Cargo 配置
 
-您可以对项目进行的最简单的前端无关的大小优化之一是为其添加一个 Cargo 配置文件。
+在不改动任何前端代码的情况下，最简单的大小优化方法就是调整 Cargo 配置文件。
 
-根据您使用的是 stable 还是 nightly 的 Rust 工具链，您可以使用的选项会有所不同。除非您是高级用户，建议您坚持使用稳定版工具链。
+根据你使用的是 Stable（稳定版）还是 Nightly（开发版）的 Rust 工具链，可用的选项会有所不同。除非你是进阶用户，否则建议坚持使用稳定版。
 
 <Tabs>
 <TabItem label="Stable">
@@ -21,14 +21,14 @@ import { Tabs, TabItem } from '@astrojs/starlight/components';
 ```toml
 # src-tauri/Cargo.toml
 [profile.dev]
-incremental = true # 以较小的步骤编译您的二进制文件。
+incremental = true # 开启增量编译，提升开发时的编译速度。
 
 [profile.release]
-codegen-units = 1 # 允许 LLVM 执行更好的优化。
+codegen-units = 1 # 设为 1 允许 LLVM 进行更深度的全局优化，但会增加编译时间。
 lto = true # 启用链接时优化。
-opt-level = "s" # 优先考虑小的二进制文件大小。如果您更喜欢速度，请使用 `3`。
-panic = "abort" # 通过禁用 panic 处理程序来提高性能。
-strip = true # 确保移除调试符号。
+opt-level = "s" # 优先优化体积。如果你更在意运行速度，请改用 `3`。
+panic = "abort" # 禁用 panic 展开 (unwind)，减少运行时代码量并提升性能。
+strip = true # 移除符号表和调试信息。
 ```
 
 </TabItem>
@@ -38,17 +38,17 @@ strip = true # 确保移除调试符号。
 ```toml
 # src-tauri/Cargo.toml
 [profile.dev]
-incremental = true # 以较小的步骤编译您的二进制文件。
-rustflags = ["-Zthreads=8"] # 提高编译性能。
+incremental = true # 开启增量编译。
+rustflags = ["-Zthreads=8"] # 利用多线程加速编译。
 
 [profile.release]
-codegen-units = 1 # 允许 LLVM 执行更好的优化。
+codegen-units = 1 # 设为 1 允许 LLVM 进行更深度的全局优化，但会增加编译时间。
 lto = true # 启用链接时优化。
-opt-level = "s" # 优先考虑小的二进制文件大小。如果您更喜欢速度，请使用 `3`。
-panic = "abort" # 通过禁用 panic 处理程序来提高性能。
-strip = true # 确保移除调试符号。
-trim-paths = "all" # 从您的二进制文件中移除潜在的特权信息。
-rustflags = ["-Cdebuginfo=0", "-Zthreads=8"] # 提高编译性能。
+opt-level = "s" # 优先优化体积。如果你更在意运行速度，请改用 `3`。
+panic = "abort" # 禁用 panic 展开 (unwind)，减少运行时代码量并提升性能。
+strip = true # 移除符号表和调试信息。
+trim-paths = "all" # 从二进制文件中移除潜在的敏感路径信息。
+rustflags = ["-Cdebuginfo=0", "-Zthreads=8"] # 极致的编译调优。
 ```
 
 </TabItem>
@@ -60,21 +60,21 @@ rustflags = ["-Cdebuginfo=0", "-Zthreads=8"] # 提高编译性能。
 这并不是所有可用选项的完整参考，只是我们想特别强调的几个选项。
 :::
 
-- [incremental:](https://doc.rust-lang.org/cargo/reference/profiles.html#incremental) 以较小的步骤编译您的二进制文件。
+- [incremental:](https://doc.rust-lang.org/cargo/reference/profiles.html#incremental) 以较小的增量重新编译代码，缩短开发循环。
 - [codegen-units:](https://doc.rust-lang.org/cargo/reference/profiles.html#codegen-units) 以牺牲编译时间优化为代价，加快编译时间。
 - [lto:](https://doc.rust-lang.org/cargo/reference/profiles.html#lto) 启用链接时优化。
-- [opt-level:](https://doc.rust-lang.org/cargo/reference/profiles.html#opt-level) 确定编译器的关注点。使用 `3` 来优化性能，使用 `z` 来优化大小，使用 `s` 以达到两者之间的平衡。
-- [panic:](https://doc.rust-lang.org/cargo/reference/profiles.html#panic) 通过移除 panic unwind 来减少大小。
-- [strip:](https://doc.rust-lang.org/cargo/reference/profiles.html#strip) 从二进制文件中剥离符号或调试信息。
+- [opt-level:](https://doc.rust-lang.org/cargo/reference/profiles.html#opt-level) 决定编译器的优化重心。3 侧重运行速度，z 极致压缩体积，s 则是在速度与体积间取得平衡。
+- [panic:](https://doc.rust-lang.org/cargo/reference/profiles.html#panic) 通过移除 panic 展开 (unwind) 来减少大小。
+- [strip:](https://doc.rust-lang.org/cargo/reference/profiles.html#strip) 从二进制文件中移除符号表或调试信息。
 - [rpath:](https://doc.rust-lang.org/cargo/reference/profiles.html#rpath) 通过将信息硬编码到二进制文件中，帮助找到二进制文件所需的动态库。
 - [trim-paths:](https://rust-lang.github.io/rfcs/3127-trim-paths.html) 从二进制文件中移除潜在的特权信息。
-- [rustflags:](https://doc.rust-lang.org/nightly/cargo/reference/unstable.html#profile-rustflags-option) 在每个配置文件的基础上设置 Rust 编译器标志。
+- [rustflags:](https://doc.rust-lang.org/nightly/cargo/reference/unstable.html#profile-rustflags-option) 针对特定 Profile 设置底层的 Rust 编译器标志。
   - `-Cdebuginfo=0`: 是否应在构建中包含调试信息符号。
   - `-Zthreads=8`: 增加编译期间使用的线程数。
 
 ## 移除未使用的命令
 
-在拉取请求 [`feat: add a new option to remove unused commands`](https://github.com/tauri-apps/tauri/pull/12890) 中，我们在 tauri 配置文件中添加了一个新选项。
+在 PR [`feat: add a new option to remove unused commands`](https://github.com/tauri-apps/tauri/pull/12890) 中，我们在 Tauri 配置文件中添加了一个新选项。
 
 ```json title=tauri.conf.json
 {
@@ -84,10 +84,10 @@ rustflags = ["-Cdebuginfo=0", "-Zthreads=8"] # 提高编译性能。
 }
 ```
 
-移除您在权限文件（ACL）中永远不允许使用的命令，这样您就无需为未使用的功能付费。
+开启此选项后，你在权限文件（ACL）中未明确允许的命令将不会被编译进应用。这样你就无需为那些根本没用到的功能负担额外的代码体积。
 
 :::tip
-为了最大限度地发挥这一优势，请仅在访问控制列表（ACL）中包含您实际使用的命令，而不要使用“默认值”。
+为了最大限度地发挥这一优势，请仅在访问控制列表（ACL）中包含你实际使用的命令，而不要使用默认值。
 :::
 
 :::note
@@ -101,8 +101,8 @@ rustflags = ["-Cdebuginfo=0", "-Zthreads=8"] # 提高编译性能。
 <details>
 <summary>它内部是如何运作的？</summary>
 
-`tauri-cli` 将通过环境变量与 `tauri-build` 以及 `tauri` 和 `tauri-plugin` 的构建脚本进行通信，并让它们从访问控制列表（ACL）生成允许的命令列表，然后 `generate_handler` 宏会根据该列表移除未使用的命令。
+`tauri-cli` 会通过环境变量与 `tauri-build`、`tauri` 核心库以及各插件的构建脚本进行通信。构建脚本会根据 ACL 文件生成一个允许命令白名单，随后 `generate_handler` 宏会根据该名单剔除未被授权的命令代码。
 
-内部细节是，当前环境变量为 `REMOVE_UNUSED_COMMANDS`，它被设置为项目的目录，通常是 `src-tauri` 目录，这用于构建脚本查找能力文件。尽管不建议这样做，但如果您无法或不想使用 `tauri-cli` 来实现此功能，您仍然可以自行设置此环境变量（**请注意，由于这是实现细节，我们不保证其稳定性**）。
+具体实现上，目前使用的是 `REMOVE_UNUSED_COMMANDS` 环境变量，其值为项目的目录路径（通常是 `src-tauri`）。虽然不建议，但如果你无法或者不想使用官方 CLI 却仍想体验此功能，可以尝试手动设置该环境变量（注意：**由于这是内部实现细节，未来可能会有变动**）。
 
 </details>