Zed 1.0 深度实战：Atom 原班人马用 Rust 重塑编辑器——从 GPUI 架构到 AI 原生协作的全链路解析

引言：一个关于"推倒重来"的故事

2026年4月29日，Zed 团队正式宣布编辑器达到 1.0 版本。对于常年折腾编辑器的开发者来说，这个版本号背后藏着一个有趣的故事——这是一个关于推倒重来、技术执念，以及对"编辑器到底应该是什么"这个问题的重新思考。

Zed 由 Atom 编辑器的原班人马倾力打造。如果你还记得 Atom，那个曾经被誉为"21世纪可入侵文本编辑器"的项目，它在2015年被 GitHub 收购，最终在2022年正式停止维护。Atom 团队的核心成员 Nathan Sobo、Antonio Scandurra 和 Max Brunsfeld 并没有停下脚步，他们带着从 Atom 项目中积累的 15 年经验，开启了一个全新的征程。

这一次，他们做了一个大胆的决定：放弃 Electron，用 Rust 重写一切。

为什么？因为 Electron 虽然让跨平台开发变得简单，但它带来的性能开销是实打实的。VS Code 基于 Electron，启动慢、内存占用高、大文件卡顿——这些问题每个开发者都经历过。Zed 团队想要的是一种全新的体验：毫秒级启动、零延迟输入、流畅如游戏般的滚动。

五年，1000 多个预发布版本，终于，Zed 1.0 来了。官方说："大多数开发者现在可以安心切换到 Zed。"

本文将从技术架构、核心实现、性能优化、AI 集成等多个维度，深度解析这个用 Rust 重塑的编辑器。

一、架构革命：从 Electron 到 Rust + GPUI

1.1 为什么放弃 Electron？

Electron 的本质是：Chromium 浏览器 + Node.js 运行时 + 你的 JavaScript 代码。这个架构带来了几个无法回避的问题：

内存占用：每个 Electron 应用都自带一个完整的 Chromium，基础内存开销就在 200MB 以上。打开几个 VS Code 窗口，内存占用轻松过 GB。

启动延迟：Chromium 的初始化、JavaScript 的解析执行、插件的加载——每一步都需要时间。即使是最简单的"打开一个文件"，也要等待整个 Electron 运行时启动完成。

渲染性能：Web 技术栈的渲染管线是为网页设计的，不是为编辑器设计的。DOM 操作、CSS 重绘、JavaScript 事件循环——这些抽象层在编辑器场景下是性能杀手。

Zed 团队算过一笔账：如果你每天打开编辑器 50 次，每次启动多等 2 秒，一年就是约 10 小时。这 10 小时本可以用来写代码、思考问题、或者喝杯咖啡。

1.2 GPUI：自研的 GPU 加速 UI 框架

Zed 的核心创新之一是 GPUI（GPU-accelerated UI）——一个完全自研的 UI 框架，直接使用 GPU 进行渲染。

// GPUI 的核心架构示意
pub struct Window {
    surface: Surface,           // GPU 渲染表面
    element_tree: ElementTree,  // UI 元素树
    style_cache: StyleCache,    // 样式缓存
    layout_engine: LayoutEngine, // 布局引擎
    paint_pipeline: PaintPipeline, // 绘制管线
}

GPUI 的设计理念借鉴了游戏引擎：

1. Retained Mode + Immediate Mode 混合：UI 元素树是保留的（避免每帧重建），但绘制命令是立即模式的（直接向 GPU 提交）。

2. 零拷贝渲染：文本缓冲区直接映射到 GPU 纹理，编辑时不涉及数据拷贝。

3. 增量更新：只有变化的区域才重新绘制，类似 React 的虚拟 DOM diff，但在 GPU 层面实现。

// 增量绘制示意
impl Element for TextElement {
    fn paint(&mut self, cx: &mut PaintContext) {
        // 只绘制脏区域
        if self.content_changed() {
            let dirty_regions = self.compute_dirty_regions();
            for region in dirty_regions {
                self.paint_text_region(region, cx);
            }
        }
    }
}

1.3 Rust 的零成本抽象

选择 Rust 不仅仅是为了"快"，更是为了零成本抽象。在 C++ 中，虚函数调用有运行时开销；在 Go 中，GC 会带来不可预测的停顿；在 JavaScript 中，JIT 编译器的优化是不确定的。

Rust 的 trait 对象虽然也有动态分发，但大部分情况下，泛型单态化让抽象在编译期就展开为零开销的内联代码。

// Rust 泛型单态化示例
pub trait EditorAction {
    fn perform(&self, editor: &mut Editor);
}

// 编译后会为每个具体类型生成专用代码
pub struct InsertChar { ch: char }
pub struct DeleteLine { line: usize }
pub struct MoveCursor { direction: Direction }

// 所有这些在编译后都是零开销的内联调用
fn execute<A: EditorAction>(action: A, editor: &mut Editor) {
    action.perform(editor); // 内联展开，无虚函数调用
}

二、核心数据结构：Rope 与增量编辑

2.1 为什么不用 String？

一个 100MB 的文件，如果用 String 存储，在任何位置插入一个字符都需要 O(n) 的数据移动。这在编辑器场景下是不可接受的。

Zed 使用 Rope 数据结构——一种专为文本编辑设计的持久化数据结构。

Rope = 树形结构的文本表示
├── 每个叶子节点存储一小段文本（通常 512-2048 字节）
├── 内部节点存储子树的字符计数
└── 编辑操作时间复杂度：O(log n)

pub struct Rope {
    root: Arc<RopeNode>,
    length: usize,
}

enum RopeNode {
    Leaf {
        buffer: Arc<str>,  // 不可变字符串
    },
    Internal {
        left: Arc<RopeNode>,
        right: Arc<RopeNode>,
        left_weight: usize, // 左子树的字符数
    },
}

2.2 增量编辑与撤销重做

Rope 的持久化特性让撤销重做变得极其简单：每次编辑产生新的 Rope 根节点，旧的节点仍然存在。撤销就是切换回上一个根节点。

pub struct Editor {
    current: Rope,
    history: Vec<Rope>,  // 历史版本栈
    cursor: usize,
}

impl Editor {
    pub fn insert(&mut self, ch: char) {
        let new_rope = self.current.insert(self.cursor, ch);
        self.history.push(std::mem::replace(&mut self.current, new_rope));
        self.cursor += ch.len_utf8();
    }
    
    pub fn undo(&mut self) {
        if let Some(prev) = self.history.pop() {
            self.current = prev;
        }
    }
}

2.3 并发安全：Arc 与无锁数据结构

Zed 大量使用 Arc（原子引用计数）来实现跨线程共享。由于 Rope 节点是不可变的，多个线程可以安全地读取同一份文本数据，无需加锁。

// 多线程安全的文本读取
pub fn search_parallel(rope: &Rope, pattern: &str) -> Vec<Match> {
    let chunks: Vec<_> = rope.chunks().collect();
    
    chunks.par_iter()  // Rayon 并行迭代
        .flat_map(|chunk| find_matches(chunk, pattern))
        .collect()
}

对于需要修改的数据，Zed 使用无锁数据结构：

use crossbeam::queue::SegQueue;

pub struct AsyncTaskQueue {
    queue: SegQueue<Box<dyn FnOnce() + Send>>,
}

impl AsyncTaskQueue {
    pub fn push(&self, task: Box<dyn FnOnce() + Send>) {
        self.queue.push(task); // 无锁入队
    }
    
    pub fn pop(&self) -> Option<Box<dyn FnOnce() + Send>> {
        self.queue.pop() // 无锁出队
    }
}

三、语法高亮：Tree-sitter 的深度集成

3.1 Tree-sitter 是什么？

Tree-sitter 是一个解析器生成工具，能够在 O(n) 时间内构建增量语法树。与传统的正则高亮不同，Tree-sitter 提供了结构化的语法信息，支持精确的作用域分析、括号匹配、代码折叠。

pub struct SyntaxTree {
    tree: Tree,           // Tree-sitter 语法树
    source: Rope,         // 源文本
    queries: Queries,     // 高亮查询
}

pub struct Queries {
    highlights: Query,    // 高亮规则
    injections: Query,    // 语言注入（如 HTML 中的 JS）
    locals: Query,        // 局部作用域
}

3.2 增量解析

当用户编辑文本时，Tree-sitter 不需要重新解析整个文件，只需要：

1. 找到受影响的语法树节点
2. 重新解析这些节点
3. 复用未受影响的部分

impl SyntaxTree {
    pub fn edit(&mut self, edit: &Edit) {
        // 1. 更新语法树的范围信息
        self.tree.edit(edit);
        
        // 2. 增量重新解析
        let new_tree = self.parser.parse(
            &self.source,
            Some(&self.tree)  // 传入旧树作为参考
        ).unwrap();
        
        self.tree = new_tree;
    }
}

3.3 高亮性能优化

Zed 对 Tree-sitter 高亮进行了深度优化：

// 高亮缓存：每行的高亮结果缓存
pub struct HighlightCache {
    lines: Vec<Option<HighlightLine>>,
    version: usize,  // 文本版本号
}

impl HighlightCache {
    pub fn get_or_compute(&mut self, line: usize, tree: &SyntaxTree) -> &[Highlight] {
        if self.lines.get(line).map_or(true, |l| l.is_none()) {
            // 惰性计算
            let highlights = self.compute_highlights(line, tree);
            self.lines[line] = Some(highlights);
        }
        &self.lines[line].as_ref().unwrap().highlights
    }
}

四、实时协作：CRDT 与 OT 的选择

4.1 为什么选择 CRDT？

Zed 内置了多人实时协作功能。在协作编辑场景下，最核心的问题是：如何合并多个用户的并发编辑？

有两种主流方案：

Zed 选择了 CRDT，具体是 RGA（Replicated Growable Array） 变体。

4.2 RGA 算法原理

RGA 为每个字符分配一个全局唯一的 ID（site_id, sequence_number），并定义了确定性的冲突解决规则。

#[derive(Clone, Copy, PartialEq, Eq, Hash)]
pub struct NodeId {
    site: u32,      // 站点 ID（用户标识）
    seq: u64,       // 序列号
}

pub struct RgaNode {
    id: NodeId,
    value: char,
    tombstone: bool,  // 逻辑删除标记
    left: Option<NodeId>,  // 左邻居
}

// 冲突解决：比较 (site, seq) 的字典序
impl Ord for NodeId {
    fn cmp(&self, other: &Self) -> Ordering {
        (self.seq, self.site).cmp(&(other.seq, other.site))
    }
}

4.3 协议设计

Zed 的协作协议基于 WebSocket，消息格式如下：

pub enum CollabMessage {
    // 客户端 -> 服务器
    Join { 
        document_id: Uuid, 
        site_id: u32 
    },
    Edit { 
        document_id: Uuid,
        operations: Vec<RgaOp>,
    },
    
    // 服务器 -> 客户端
    Welcome { 
        document: Rope,
        site_id: u32,
        peers: Vec<PeerInfo>,
    },
    Sync { 
        from_site: u32,
        operations: Vec<RgaOp>,
    },
}

pub enum RgaOp {
    Insert { 
        id: NodeId, 
        value: char, 
        left: Option<NodeId> 
    },
    Delete { 
        id: NodeId 
    },
}

4.4 性能优化：操作压缩

当用户快速输入时，会产生大量单字符插入操作。Zed 会将这些操作压缩：

pub fn compress_ops(ops: Vec<RgaOp>) -> Vec<RgaOp> {
    let mut compressed = Vec::new();
    let mut current_insert: Option<String> = None;
    
    for op in ops {
        match op {
            RgaOp::Insert { id, value, left } => {
                if let Some(ref mut s) = current_insert {
                    if is_consecutive(id, left) {
                        s.push(value);
                        continue;
                    }
                }
                // 刷新当前累积
                if let Some(s) = current_insert.take() {
                    compressed.push(RgaOp::InsertBatch { /* ... */ });
                }
                current_insert = Some(value.to_string());
            }
            RgaOp::Delete { id } => {
                // 先刷新插入累积
                // ...
                compressed.push(RgaOp::Delete { id });
            }
        }
    }
    
    compressed
}

五、LSP 集成：语言服务的艺术

5.1 Language Server Protocol 简介

LSP 是微软提出的协议，让编辑器与语言服务解耦。Zed 内置了对几乎所有主流语言的 LSP 支持：

• 语法高亮（Syntax Highlighting）
• 自动补全（Auto Completion）
• 代码诊断（Diagnostics）
• 跳转定义（Go to Definition）
• 查找引用（Find References）
• 重命名符号（Rename Symbol）
• 代码操作（Code Actions）

5.2 LSP 客户端架构

pub struct LspClient {
    transport: LspTransport,       // 通信层（stdio/socket）
    capabilities: ServerCapabilities,
    pending_requests: HashMap<RequestId, Sender<LspResponse>>,
    document_state: HashMap<Url, DocumentState>,
}

pub struct DocumentState {
    version: i32,
    diagnostics: Vec<Diagnostic>,
    semantic_tokens: Option<SemanticTokens>,
}

5.3 请求去抖与缓存

LSP 请求（特别是补全和诊断）可能很慢。Zed 使用多层缓存和去抖策略：

pub struct CompletionCache {
    // 三级缓存
    memory_cache: LruCache<CacheKey, Vec<CompletionItem>>,
    disk_cache: DiskCache,
    // 去抖器
    debouncer: Debouncer,
}

impl CompletionCache {
    pub async fn get_completions(&mut self, position: Position) -> Vec<CompletionItem> {
        let key = self.make_cache_key(position);
        
        // 1. 内存缓存
        if let Some(items) = self.memory_cache.get(&key) {
            return items.clone();
        }
        
        // 2. 去抖：避免频繁请求
        self.debouncer.wait(Duration::from_millis(50)).await;
        
        // 3. 请求 LSP 服务器
        let items = self.request_lsp(position).await?;
        
        // 4. 更新缓存
        self.memory_cache.put(key, items.clone());
        items
    }
}

5.4 多语言项目支持

现代项目通常是多语言的（如 TypeScript + Python + SQL）。Zed 通过 语言注入 支持：

pub struct LanguageRegistry {
    languages: HashMap<LanguageId, LanguageConfig>,
    injections: Vec<InjectionRule>,
}

pub struct InjectionRule {
    host_language: LanguageId,
    injection_query: Query,  // Tree-sitter 查询
    injected_language: LanguageId,
}

// 示例：HTML 中的 JavaScript
// injection_query: (script_element (raw_text) @js)

六、AI 集成：从 Inline Assistant 到 Agentic Editing

6.1 多模型支持

Zed 不锁定特定模型，支持接入：

• OpenAI：GPT-4o、GPT-4 Turbo
• Anthropic：Claude 3.5 Sonnet、Claude Opus
• DeepSeek：DeepSeek Coder
• 本地模型：Ollama、llama.cpp

配置示例：

// ~/.config/zed/settings.json
{
  "features": {
    "edit_prediction_provider": "copilot"
  },
  "language_models": {
    "openai": {
      "version": "gpt-4o"
    },
    "anthropic": {
      "version": "claude-3-5-sonnet"
    }
  }
}

6.2 Inline Assistant：行内 AI 助手

Inline Assistant 允许你选中代码，用自然语言描述修改意图：

pub struct InlineAssistant {
    model: Box<dyn LanguageModel>,
    context: AssistantContext,
}

pub struct AssistantContext {
    before_cursor: String,    // 光标前的代码
    after_cursor: String,     // 光标后的代码
    selected_text: String,    // 选中的代码
    file_path: PathBuf,       // 文件路径
    language: LanguageId,     // 语言
}

impl InlineAssistant {
    pub async fn transform(&self, instruction: &str) -> Result<String> {
        let prompt = format!(
            "You are an expert programmer. Transform the following code according to the instruction.\n\
             \n\
             File: {}\n\
             Language: {}\n\
             \n\
             Selected code:\n\
             ```\n\
             {}\n\
             ```\n\
             \n\
             Instruction: {}\n\
             \n\
             Output only the transformed code, no explanation.",
            self.context.file_path.display(),
            self.context.language,
            self.context.selected_text,
            instruction
        );
        
        self.model.complete(&prompt).await
    }
}

6.3 Edit Prediction：编辑预测

Zed 自研了 Zeta 模型，用于预测用户的下一个编辑操作。这是一个开源、开放数据的模型。

pub struct EditPredictor {
    model: ZetaModel,
    history: VecDeque<EditAction>,
}

impl EditPredictor {
    pub fn predict(&mut self, context: &EditorContext) -> Option<PredictedEdit> {
        // 1. 构建上下文特征
        let features = self.extract_features(context);
        
        // 2. 模型推理
        let prediction = self.model.predict(&features);
        
        // 3. 置信度过滤
        if prediction.confidence > 0.8 {
            Some(prediction.edit)
        } else {
            None
        }
    }
}

6.4 Agentic Editing：代理式编辑

Zed 1.0 引入了 Agentic Editing——让 AI 代理完成复杂的多步骤任务：

pub struct AgentSession {
    model: Box<dyn LanguageModel>,
    tools: Vec<Box<dyn Tool>>,
    state: AgentState,
}

pub enum AgentState {
    Planning,    // 制定计划
    Executing,   // 执行步骤
    Reviewing,   // 等待用户确认
    Completed,   // 完成
}

impl AgentSession {
    pub async fn run(&mut self, task: &str) -> Result<()> {
        // 1. 制定计划
        let plan = self.make_plan(task).await?;
        
        // 2. 逐步执行
        for step in plan.steps {
            let result = self.execute_step(&step).await?;
            
            // 3. 关键步骤需要用户确认
            if step.requires_confirmation {
                self.state = AgentState::Reviewing;
                self.wait_for_user_confirmation().await?;
            }
        }
        
        self.state = AgentState::Completed;
        Ok(())
    }
}

七、性能优化：从毫秒到微秒

7.1 启动优化

Zed 的启动时间目标是 < 100ms。实现手段：

1. 延迟加载：主题、语言配置、插件等延迟到主窗口显示后加载
2. 二进制优化：LTO（Link Time Optimization）、PGO（Profile Guided Optimization）
3. 资源嵌入：默认配置编译进二进制，避免文件 I/O

// 延迟初始化模式
pub struct LazyInit<T> {
    value: OnceCell<T>,
    init: Box<dyn FnOnce() -> T>,
}

impl<T> LazyInit<T> {
    pub fn get(&self) -> &T {
        self.value.get_or_init(self.init)
    }
}

// 使用示例
pub struct App {
    theme: LazyInit<Theme>,
    languages: LazyInit<LanguageRegistry>,
    keybindings: LazyInit<KeybindingMap>,
}

7.2 渲染优化

GPUI 的渲染管线：

CPU 端：
  1. 布局计算（Layout）
  2. 样式解析（Style）
  3. 绘制命令生成（Paint）

GPU 端：
  4. 顶点缓冲上传
  5. 纹理绑定
  6. 绘制调用

关键优化：

// 批量绘制：减少 draw call
pub struct BatchedPainter {
    batches: Vec<DrawBatch>,
    current_batch: Option<DrawBatch>,
}

impl BatchedPainter {
    pub fn draw_text(&mut self, text: &str, style: TextStyle) {
        if self.current_batch.as_ref().map_or(false, |b| b.can_merge(&style)) {
            self.current_batch.as_mut().unwrap().push(text);
        } else {
            if let Some(batch) = self.current_batch.take() {
                self.batches.push(batch);
            }
            self.current_batch = Some(DrawBatch::new(style));
        }
    }
}

7.3 内存优化

Zed 的内存占用目标是 < 100MB（空项目）。实现手段：

1. 字符串去重：使用 Arc<str> 共享不可变字符串
2. 结构体优化：使用 smallvec、smallstring 减少堆分配
3. 缓存淘汰：LRU 缓存自动清理不活跃数据

use smallvec::SmallVec;

// 大部分情况下，行内存储，避免堆分配
pub type SmallVec4<T> = SmallVec<[T; 4]>;

// 示例：补全项通常不超过 4 个字段
pub struct CompletionItem {
    label: SmallString<[u8; 32]>,  // 短标签行内存储
    detail: Option<String>,         // 长详情才堆分配
    kind: CompletionItemKind,
    sort_text: SmallString<[u8; 16]>,
}

八、扩展生态：从插件到 Extensions

8.1 扩展架构

Zed 的扩展系统基于 WebAssembly（Wasm），保证安全隔离和跨平台兼容。

pub struct Extension {
    manifest: ExtensionManifest,
    wasm_module: Module,
    api: ExtensionApi,
}

pub struct ExtensionManifest {
    id: ExtensionId,
    name: String,
    version: String,
    contributes: Contributes,
}

pub struct Contributes {
    languages: Vec<LanguageContribution>,
    themes: Vec<ThemeContribution>,
    commands: Vec<CommandContribution>,
    // ...
}

8.2 扩展 API

扩展通过 API 与编辑器交互：

// 扩展侧代码（编译为 Wasm）
#[extension_api]
pub trait ZedExtension {
    fn activate(&mut self, ctx: &mut ExtensionContext);
    fn deactivate(&mut self);
}

pub struct ExtensionContext {
    pub editor: EditorApi,
    pub workspace: WorkspaceApi,
    pub languages: LanguageApi,
}

// 注册命令示例
impl MyExtension for ZedExtension {
    fn activate(&mut self, ctx: &mut ExtensionContext) {
        ctx.editor.register_command("myCommand", |editor| {
            // 执行自定义逻辑
        });
    }
}

8.3 热门扩展

截至 2026 年 5 月，Zed 扩展市场已有数百个扩展：

九、Vim 模式：为 Vim 用户打造

9.1 第一类 Vim 支持

Zed 的 Vim 模式不是简单的键位模拟，而是完整实现了 Vim 的编辑模型：

• Normal/Insert/Visual/Replace 模式
• 文本对象（text objects）：iw、aw、i"、a"、ip、ap...
• 操作符-动作（operator-motion）：d$、caw、yip...
• 寄存器（registers）："a、"b、无名寄存器、黑洞寄存器
• 宏（macros）：qa...q、@a

pub struct VimState {
    mode: VimMode,
    pending_operator: Option<Operator>,
    pending_count: Option<usize>,
    register: Register,
    macro_recording: Option<MacroRecording>,
}

pub enum VimMode {
    Normal,
    Insert,
    Visual { linewise: bool },
    Replace,
}

9.2 自定义键位

// ~/.config/zed/settings.json
{
  "vim": {
    "use_multiline_find": true,
    "use_system_clipboard": "always",
    "custom_digraphs": {
      "jk": "↔"
    }
  },
  "keymap": {
    "vim::Normal": {
      "space f": "file_finder::Toggle",
      "space b": "pane::ActivateNextItem"
    }
  }
}

十、实战：从 VS Code 迁移到 Zed

10.1 安装

# macOS
brew install --cask zed

# Linux
curl -f https://zed.dev/install.sh | sh

# Windows
# 从 https://zed.dev/download 下载安装包

10.2 配置迁移

Zed 的配置文件位于 ~/.config/zed/settings.json：

{
  // 主题
  "theme": {
    "mode": "system",
    "light": "One Light",
    "dark": "One Dark"
  },
  
  // 字体
  "buffer_font_family": "JetBrains Mono",
  "buffer_font_size": 14,
  
  // Vim 模式
  "vim_mode": true,
  
  // 软换行
  "soft_wrap": "preferred_line_length",
  "preferred_line_length": 100,
  
  // 格式化
  "formatter": "language_server",
  "format_on_save": "on",
  
  // LSP 设置
  "languages": {
    "Python": {
      "language_servers": ["pyright", "ruff"],
      "format_on_save": "on"
    },
    "Rust": {
      "language_servers": ["rust-analyzer"]
    }
  }
}

10.3 键位映射

从 VS Code 迁移的用户可以参考以下映射：

10.4 AI 配置

{
  "features": {
    "inline_completion_provider": "copilot"
  },
  "copilot": {
    "proxy": null,
    "proxy_strict_ssl": true
  }
}

十一、性能实测：Zed vs VS Code

测试环境：MacBook Pro M3 Pro，36GB 内存，macOS 15

11.1 启动时间

11.2 内存占用

11.3 输入延迟

测量方法：从按下按键到字符显示的时间

11.4 大文件性能

打开 100MB 日志文件：

十二、总结与展望

12.1 Zed 的核心价值

Zed 1.0 的发布，标志着编辑器领域的一个重要里程碑：

1. 性能革命：用 Rust + GPUI 打破了 Electron 的性能天花板
2. 协作原生：内置实时协作，无需额外服务
3. AI 原生：从设计之初就考虑 AI 集成，而非事后补丁
4. 开发者优先：Vim 模式、多光标、高级搜索——为专业开发者打造

12.2 适用场景

推荐使用 Zed：

• 追求极致性能的开发者
• 需要实时协作的团队
• Vim 用户
• 重视 AI 辅助编程的开发者
• 厌倦了 VS Code 卡顿的用户

暂不推荐：

• 依赖大量 VS Code 专属插件的用户
• 需要远程开发（SSH）的用户（功能尚在完善）
• Windows 用户（体验仍在优化中）

12.3 未来展望

根据 Zed 的公开路线图，未来将重点推进：

• 远程开发：SSH、Dev Containers 支持
• 调试器：基于 DAP 的原生调试支持
• 更多语言：完善语言服务器生态
• Windows 优化：提升 Windows 平台体验
• 扩展生态：开放更多 API，吸引社区贡献

12.4 写在最后

五年前，当 Atom 团队决定用 Rust 重写编辑器时，很多人觉得这是"过度工程"。五年后，Zed 1.0 用实打实的性能数据证明了：对用户体验的极致追求，永远值得投入。

正如 Zed 官网所说："Your last next editor"。这不仅仅是一个口号，更是一种信念——编辑器应该是你思维的延伸，而不是你工作的阻碍。

如果你还在忍受 VS Code 的卡顿，不妨试试 Zed。也许，这就是你最后一个编辑器。

参考资料

1. Zed 官网
2. Zed GitHub 仓库
3. GPUI 文档
4. Tree-sitter 官网
5. Language Server Protocol 规范
6. CRDT 论文：RGA 算法

字数：约 8500 字
选题来源：Zed编辑器 Rust 高性能 2026