Back to Details

rust-desktop-applications

Compare original and translation side by side

🇺🇸

Original

English
🇨🇳

Translation

Chinese

Rust Desktop Applications

Rust 桌面应用

Overview

概述

Rust has emerged as a premier language for building desktop applications that combine native performance with memory safety. The ecosystem offers two main approaches: Tauri for hybrid web UI + Rust backend apps (think Electron but 10x smaller and faster), and native GUI frameworks like egui, iced, and slint for pure Rust interfaces.
Tauri has revolutionized desktop development by enabling developers to use web technologies (React, Vue, Svelte) for the frontend while leveraging Rust's performance and safety for system-level operations. With bundle sizes under 5MB and memory usage 1/10th of Electron, Tauri apps deliver desktop-class performance. Native frameworks shine for specialized use cases: egui for immediate-mode tools and game editors, iced for Elm-style reactive apps, slint for embedded and declarative UIs.
This skill covers the complete Rust desktop development lifecycle from framework selection through architecture, state management, platform integration, and deployment. You'll build production-ready applications with proper IPC patterns, async runtime integration, native system access, and cross-platform distribution.
Rust已成为构建兼具原生性能与内存安全性的桌面应用的首选语言。其生态系统主要提供两种开发方案：Tauri用于构建混合Web UI + Rust后端应用（类似Electron，但体积小10倍且速度更快），以及原生GUI框架如egui、iced和slint用于纯Rust界面开发。
Tauri彻底革新了桌面开发，开发者可使用Web技术（React、Vue、Svelte）构建前端，同时借助Rust的性能与安全性处理系统级操作。Tauri应用的包体积不足5MB，内存占用仅为Electron的1/10，能提供桌面级的高性能体验。原生框架则在特定场景下表现出色：egui适用于即时模式工具和游戏编辑器，iced适用于Elm风格的响应式应用，slint适用于嵌入式和声明式UI开发。
本技能涵盖了从框架选择、架构设计、状态管理、平台集成到部署的完整Rust桌面开发生命周期。你将学习如何构建具备规范IPC模式、异步运行时集成、原生系统访问能力和跨平台分发能力的生产级应用。

When to Use This Skill

适用场景

Activate when building desktop applications that need native performance, small bundle sizes, system integration, or memory safety guarantees. Specifically use when:
  • Building Electron alternatives with web UI + Rust backend (Tauri)
  • Creating high-performance developer tools or productivity apps
  • Developing system utilities requiring native OS integration
  • Building cross-platform apps for Windows, macOS, and Linux
  • Need <10MB bundle sizes vs 100MB+ Electron apps
  • Implementing real-time applications (audio/video processing, games)
  • Creating embedded GUI applications (kiosks, IoT devices)
当你需要构建具备原生性能、小包体积、系统集成能力或内存安全保障的桌面应用时，启用本技能。具体适用于：
  • 构建Electron替代方案，采用Web UI + Rust后端架构（Tauri）
  • 创建高性能开发者工具或生产力应用
  • 开发需要原生操作系统集成的系统工具
  • 构建支持Windows、macOS和Linux的跨平台应用
  • 需要包体积小于10MB（对比Electron的100MB+）
  • 实现实时应用（音频/视频处理、游戏）
  • 构建嵌入式GUI应用（自助终端、IoT设备）

Don't Use When

不适用场景

  • Simple web apps - Use Next.js, Vite, or web frameworks
  • Mobile-first applications - Use Flutter, React Native, or Kotlin Multiplatform
  • Purely CLI tools - Use clap/structopt for command-line apps
  • Browser extensions - Use WebExtensions API
  • Quick prototypes - Native development has setup overhead
  • Team lacks Rust experience - Steep learning curve for system programming
  • 简单Web应用 - 使用Next.js、Vite或其他Web框架
  • 移动优先应用 - 使用Flutter、React Native或Kotlin Multiplatform
  • 纯CLI工具 - 使用clap/structopt构建命令行应用
  • 浏览器扩展 - 使用WebExtensions API
  • 快速原型 - 原生开发存在一定的配置开销
  • 团队缺乏Rust经验 - 系统编程存在陡峭的学习曲线

The Iron Law

铁律

TAURI FOR WEB UI + RUST BACKEND | NATIVE GUI FOR PURE RUST | NEVER MIX BUSINESS LOGIC IN FRONTEND
Duplicating logic between frontend and backend, or bypassing IPC for direct access, violates architecture.
TAURI FOR WEB UI + RUST BACKEND | NATIVE GUI FOR PURE RUST | NEVER MIX BUSINESS LOGIC IN FRONTEND
在前端和后端之间重复实现逻辑，或绕过IPC直接访问系统资源，均违反架构原则。

Core Principles

核心原则

  1. Framework Alignment: Tauri for web-skilled teams, native GUI for Rust-first projects
  2. Clear Separation: Frontend handles UI, Rust backend handles business logic and system access
  3. Type-Safe IPC: Commands and events strongly typed with serde serialization
  4. Async Runtime: Tokio for backend concurrency, prevent blocking main thread
  5. Security First: Validate all IPC inputs, minimize exposed commands, CSP policies
  6. Platform Abstraction: Write once, handle platform differences gracefully
  1. 框架匹配：具备Web开发技能的团队选择Tauri，Rust优先的项目选择原生GUI框架
  2. 清晰分离：前端负责UI展示，Rust后端负责业务逻辑和系统访问
  3. 类型安全IPC：使用serde序列化实现强类型的命令与事件
  4. 异步运行时：使用Tokio处理后端并发，避免阻塞主线程
  5. 安全优先：验证所有IPC输入，最小化暴露的命令，配置CSP策略
  6. 平台抽象：一次编写代码，优雅处理平台差异

Quick Start

快速开始

  1. Choose Your Framework
    • Tauri: Have web skills (React/Vue/Svelte)? Want rapid UI development? → 
      cargo install tauri-cli
    • Native GUI: Pure Rust project? Immediate mode or reactive patterns? → Choose egui/iced/slint
  2. Initialize Project
    bash
    # Tauri
cargo create-tauri-app my-app
# Select: npm, React/Vue/Svelte, TypeScript

# Native (egui example)
cargo new my-app
cargo add eframe egui
  3. Setup Architecture
    • Tauri: Define commands in 
      src-tauri/src/main.rs
      , handle IPC
    • Native: Implement app state, event loop, and UI update logic
    • Structure: 
      src/
      (backend), 
      ui/
      or 
      src-ui/
      (frontend if Tauri)
  4. Implement Core Features
    • Define Tauri commands with 
      #[tauri::command]
    • Setup state management (Arc<Mutex<T>> or channels)
    • Integrate Tokio for async operations
    • Add error handling with 
      Result<T, E>
  5. Add Platform Integration
    • File system access (dialogs, read/write)
    • System tray, notifications, auto-updates
    • Deep linking, custom URL schemes
    • OS-specific features (Windows registry, macOS sandboxing)
  6. Build and Distribute
    bash
    # Development
cargo tauri dev  # or cargo run

# Production build
cargo tauri build  # Creates installers for current platform

# Cross-platform: Use GitHub Actions with matrix builds
  1. 选择框架
    • Tauri：具备Web技能（React/Vue/Svelte）？希望快速开发UI？ → 
      cargo install tauri-cli
    • 原生GUI：纯Rust项目？需要即时模式或响应式模式？ → 选择egui/iced/slint
  2. 初始化项目
    bash
    # Tauri
cargo create-tauri-app my-app
# 选择: npm, React/Vue/Svelte, TypeScript

# 原生GUI（egui示例）
cargo new my-app
cargo add eframe egui
  3. 架构搭建
    • Tauri：在
      src-tauri/src/main.rs
      中定义命令，处理IPC通信
    • 原生GUI：实现应用状态、事件循环和UI更新逻辑
    • 结构：
      src/
      （后端），
      ui/
      或
      src-ui/
      （Tauri项目的前端代码）
  4. 实现核心功能
    • 使用
      #[tauri::command]
      定义Tauri命令
    • 搭建状态管理（Arc<Mutex<T>>或通道）
    • 集成Tokio处理异步操作
    • 使用
      Result<T, E>
      实现错误处理
  5. 平台集成
    • 文件系统访问（对话框、读写操作）
    • 系统托盘、通知、自动更新
    • 深度链接、自定义URL协议
    • 操作系统特定功能（Windows注册表、macOS沙箱）
  6. 构建与分发
    bash
    # 开发模式
cargo tauri dev  # 或 cargo run

# 生产构建
cargo tauri build  # 为当前平台创建安装包

# 跨平台构建：使用GitHub Actions的矩阵构建

Framework Decision Tree

框架决策树

Need desktop app?
├─ Have web frontend skills (React/Vue/Svelte)?
│  └─ YES → Use Tauri
│     ├─ Need <5MB bundles? ✓
│     ├─ System integration? ✓
│     ├─ Cross-platform? ✓
│     └─ Rapid UI development? ✓
│
└─ Pure Rust, no web frontend?
   ├─ Game editor or immediate mode tools? → egui
   ├─ Elm-style reactive architecture? → iced
   ├─ Declarative UI, embedded devices? → slint
   └─ Data-first reactive? → druid
Tauri when: Web UI expertise, need modern frontend frameworks, rapid iteration Native when: Maximum performance, no web dependencies, specialized UI patterns
需要开发桌面应用？
├─ 具备Web前端技能（React/Vue/Svelte）？
│  └─ 是 → 使用Tauri
│     ├─ 需要包体积<5MB？ ✓
│     ├─ 需要系统集成？ ✓
│     ├─ 需要跨平台？ ✓
│     └─ 需要快速UI开发？ ✓
│
└─ 纯Rust项目，无Web前端？
   ├─ 游戏编辑器或即时模式工具？ → egui
   ├─ Elm风格响应式架构？ → iced
   ├─ 声明式UI、嵌入式设备？ → slint
   └─ 数据优先的响应式应用？ → druid
选择Tauri的场景：具备Web UI开发经验、需要使用现代前端框架、快速迭代 选择原生GUI的场景：追求极致性能、无Web依赖、需要特定UI模式

Navigation

导航

Detailed guides available:
  • Tauri Framework: Complete Tauri architecture, project setup, IPC communication patterns, native API access, configuration, security model, and build process with real-world examples
  • Native GUI Frameworks: Deep dive into egui, iced, druid, and slint - architecture patterns, when to use each, comparison matrix, and production code examples
  • Architecture Patterns: Desktop-specific patterns including MVC/MVVM, command pattern, event-driven architecture, plugin systems, resource management, and error handling strategies
  • State Management: State management strategies, async runtime integration with Tokio, message passing, reactive patterns, persistence (configs/databases), and multi-window state sharing
  • Platform Integration: File system access, system tray, notifications, auto-updates, deep linking, OS-specific features (Windows/macOS/Linux), permissions, and security
  • Testing & Deployment: Integration testing, UI testing approaches, cross-compilation, platform-specific builds, distribution (installers/bundles/stores), signing, notarization, and CI/CD pipelines
可查看详细指南：
  • Tauri框架：完整的Tauri架构、项目搭建、IPC通信模式、原生API访问、配置、安全模型及构建流程，包含真实案例
  • 原生GUI框架：深入解析egui、iced、druid和slint的架构模式、适用场景、对比矩阵及生产代码示例
  • 架构模式：桌面应用特定模式，包括MVC/MVVM、命令模式、事件驱动架构、插件系统、资源管理及错误处理策略
  • 状态管理：状态管理策略、Tokio异步运行时集成、消息传递、响应式模式、持久化（配置/数据库）及多窗口状态共享
  • 平台集成：文件系统访问、系统托盘、通知、自动更新、深度链接、操作系统特定功能（Windows/macOS/Linux）、权限及安全
  • 测试与部署：集成测试、UI测试方法、交叉编译、平台特定构建、分发（安装包/捆绑包/应用商店）、签名、公证及CI/CD流水线

Key Patterns

核心模式

Correct Tauri Pattern:
rust
✅ Commands in Rust backend
✅ Type-safe IPC with serde
✅ Async operations with Tokio
✅ State management with Arc<Mutex<T>>
✅ Error propagation with Result<T, E>
✅ Frontend calls backend via invoke()
Correct Native GUI Pattern:
rust
✅ Immediate mode (egui) or retained mode (iced)
✅ State updates trigger redraws
✅ Event handling in Rust
✅ Platform-agnostic rendering
✅ Resource cleanup on drop
Incorrect Patterns:
rust
❌ Business logic in frontend JavaScript
❌ Exposing unsafe commands without validation
❌ Blocking operations on main thread
❌ Direct filesystem access from frontend
❌ Missing error handling on IPC
❌ Hardcoded platform-specific paths
正确的Tauri模式：
rust
✅ 在Rust后端定义命令
✅ 使用serde实现类型安全IPC
✅ 使用Tokio处理异步操作
✅ 使用Arc<Mutex<T>>进行状态管理
✅ 使用Result<T, E>传播错误
✅ 前端通过invoke()调用后端
正确的原生GUI模式：
rust
✅ 即时模式（egui）或保留模式（iced）
✅ 状态更新触发重绘
✅ 在Rust中处理事件
✅ 平台无关的渲染
✅ 资源在drop时自动清理
错误模式：
rust
❌ 业务逻辑写在前端JavaScript中
❌ 暴露未验证的不安全命令
❌ 在主线程执行阻塞操作
❌ 前端直接访问文件系统
❌ IPC通信缺少错误处理
❌ 硬编码平台特定路径

Red Flags - STOP

危险信号 - 立即停止

  • Blocking the main thread - Use Tokio spawn for long operations
  • Exposing sensitive commands - Validate, rate limit, minimize surface area
  • Missing CSP in Tauri - Configure Content Security Policy
  • No input validation - Always validate IPC command arguments
  • Direct frontend file access - Use Tauri file system APIs
  • Ignoring platform differences - Test on all target platforms
  • Large bundle sizes - Profile and optimize dependencies
  • No auto-update strategy - Users won't manually update
  • 阻塞主线程 - 使用Tokio spawn处理长时间操作
  • 暴露敏感命令 - 验证、限流、最小化暴露面
  • Tauri中缺少CSP配置 - 配置内容安全策略
  • 无输入验证 - 始终验证IPC命令参数
  • 前端直接访问文件 - 使用Tauri文件系统API
  • 忽略平台差异 - 在所有目标平台上测试
  • 包体积过大 - 分析并优化依赖
  • 无自动更新策略 - 用户不会手动更新应用

Integration with Other Skills

与其他技能的集成

  • vite-local-dev: Integrate Vite with Tauri for hot module replacement and fast frontend builds
  • async-testing: Test async Tokio code in Tauri commands and background tasks
  • performance-profiling: Profile Rust backend with Criterion, flamegraphs for optimization
  • test-driven-development: Write tests for commands, state management, and business logic
  • verification-before-completion: Test cross-platform builds before shipping
  • systematic-debugging: Debug Tauri IPC issues, inspect console logs, use Rust debugger
  • vite-local-dev：将Vite与Tauri集成，实现热模块替换和快速前端构建
  • async-testing：测试Tauri命令和后台任务中的异步Tokio代码
  • performance-profiling：使用Criterion、火焰图分析Rust后端以优化性能
  • test-driven-development：为命令、状态管理和业务逻辑编写测试
  • verification-before-completion：在发布前测试跨平台构建
  • systematic-debugging：调试Tauri IPC问题、检查控制台日志、使用Rust调试器

Real-World Impact

实际影响

Performance Metrics:
  • Bundle size: 3-5MB (Tauri) vs 100-200MB (Electron)
  • Memory usage: 50-100MB (Tauri) vs 500MB-1GB (Electron)
  • Startup time: <1s (Tauri) vs 3-5s (Electron)
  • Build time: 1-2 min (Tauri) vs 5-10 min (Electron)
Production Examples:
  • Warp Terminal: High-performance terminal built with Rust (egui/custom)
  • Lapce: Fast code editor using Druid (later custom framework)
  • Zed: Collaborative code editor with native Rust UI
  • Notion-like apps: Using Tauri for desktop versions
  • System utilities: File managers, task managers, monitoring tools
性能指标：
  • 包体积：3-5MB（Tauri） vs 100-200MB（Electron）
  • 内存占用：50-100MB（Tauri） vs 500MB-1GB（Electron）
  • 启动时间：<1秒（Tauri） vs 3-5秒（Electron）
  • 构建时间：1-2分钟（Tauri） vs 5-10分钟（Electron）
生产案例：
  • Warp Terminal：使用Rust构建的高性能终端（egui/自定义框架）
  • Lapce：使用Druid开发的快速代码编辑器（后续改用自定义框架）
  • Zed：具备协作功能的原生Rust UI代码编辑器
  • 类Notion应用：使用Tauri构建桌面版本
  • 系统工具：文件管理器、任务管理器、监控工具

The Bottom Line

总结

Rust desktop development offers unmatched performance with memory safety.
Choose Tauri for web UI + Rust backend with tiny bundles. Choose native GUI for pure Rust with specialized patterns. Architect with clear frontend/backend separation. Use type-safe IPC. Integrate Tokio for async. Handle platform differences. Test cross-platform early.
This is the Rust desktop way.
Rust桌面开发兼具无与伦比的性能与内存安全性。
选择Tauri构建Web UI + Rust后端的小包体积应用，选择原生GUI构建纯Rust的特定模式应用。采用清晰的前后端分离架构，使用类型安全的IPC，集成Tokio处理异步，优雅处理平台差异，尽早进行跨平台测试。
这就是Rust桌面开发之道。