黄奕彬

外部精选

Xanadu Was Waiting for Agents

本文来自外部来源,不是黄奕彬的原创文章。本站提供原文入口,并在采集端生成 AI 结构化摘要、解读与中文翻译(如有),一切以原文为准。

阅读原文(zed.dev)
来源
Zed Blog ↗
作者 / 署名
Nathan Sobo、Nathan Sobo
发布日期
本站收录时间
原文域名
zed.dev

以上时间均为北京时间;来源更新时间由来源提供,不代表首次发布时间。

结构化摘要 AI 生成

背景与问题

文章回答的问题是:Ted Nelson 的 Project Xanadu 愿景为何数十年未能落地,以及为什么在 AI agents 出现后它变得可以实现。

背景:Nelson 于 1965 年提出 hypertext 一词,并构想 docuverse——系统保留文档所有版本、链接同时记录源与目标、引文按引用而非拷贝保存(transclusion),一切 intertwingled、xanalogical。

该愿景需要无限存储与永不过时的命名方案,两者在其后数十年都不存在;90 年代 Web 兴起时开发者选择了简单易用的扁平链接(目标移动即失效),维护成为用户的问题,Xanadu 沦为计算史上最著名的 vaporware。作者认为人类原本并不需要跟随每条链接,扁平已足够——直到 agents 到来。

方法或内容

文章以 Nelson 的历史愿景为叙事框架,阐述 Zed 的 Delta 与 DeltaDB 如何落实 xanalogical 计算。内容包括:

  • 回顾 Xanadu 的设计原则与失败原因:作者主张是依赖技术缺失,而非 Wired 所述的管理失误
  • 列举如今已齐备的依赖树:Lamport 时间戳(1978)、Merkle 树(1979,2005 年由 Git 普及)、CRDT(2011)、廉价存储、常开宽带、microVM(2018)、Tree-sitter 与 GPUI
  • 说明 DeltaDB 机制:文件底层是带稳定身份的 fragments,anchor 跨快照解析,对话与代码进入共享历史
  • 说明互操作策略:每个 Delta thread 也是一个 git 分支,可直接使用已有仓库
  • 指出 Nelson 唯一漏掉的依赖是一种新用户——agents

关键发现 / 结果

  • 1978 年 Lamport timestamps:每个人与 agent 的操作由 actor 加 Lamport 时间戳永久命名
  • 1979 年 Merkle 树(2005 年由 Git 普及):DeltaDB 以其派生的 Git commit 加上其上应用的 actor-and-timestamp delta ID 集合,命名 commit 之间的每个状态
  • 2011 年 CRDT 形式化,是 Zed 过去十年工作的核心;Delta worktree 可被不同大洲的多人与 agents 同时编辑
  • 存储成本:1981 年 1GB 需数万美元,如今一分钱;Delta 默认保留一切的所有版本
  • 2018 年 Firecracker 级 microVM:agents 可在对话中途配置新的隔离云机器
  • Tree-sitter(2018,Max Brunsfeld)与 GPUI:Delta thread 是其永久结构化历史的实时投影,重算而非存为扁平文档
  • 互操作:每个 thread 也是 git 分支,不打开 Delta 的队友看到正常 repo;Zed 过渡期将仓库镜像到 GitHub
  • agents 基于 anchor 坐标系形成 landmarks 的能力仍处探索阶段(原文明确称仍在探索)
  • 量化性能或采用数据:原文未说明

结论与意义

作者结论:Nelson 一生被指梦想太大,唯在一处「梦得太小」——没有想象出新的用户类型;agents(其形象早已出现在 Asimov 的 Multivac、Stephenson 的 Librarian 等科幻中)正是 Xanadu 等待六十年的用户。

作者希望 Delta threads 同时承接 Engelbart 与 Nelson 的愿景:实时会话留下永久且互联的文献,因为会话与记录是同一对象。边界:作者明确表示目标不是实现 Xanadu 本身;本文为设计阐述,未附性能或采用数据。

AI 解读 AI 生成

方法:按「时空变量」分析(时间 / 空间 / 变量,严格区分包含、相关与因果),对象包括原文作者、署名人员与关键技术及其实际原理;结论用「元反空」(元思考、反思考、空思考、综合)整理。

时间:何时发生,现在是否仍成立

来源日期为北京时间 2026-09-01(Zed Blog)。文中时间锚点均为历史年份:1965 年 Nelson 提出 hypertext;90 年代 Web 兴起;2000 年代中期宽带超过拨号;1978、1979、2005、2011、2018 为各依赖技术出现或普及的年份。

对 Delta/DeltaDB 的描述是写作当时的工程现状陈述,未给出版本号或时间表;这些主张现在是否仍成立,原文未说明。

空间:谁的环境 / 场景

适用对象是 Zed 产品生态:Delta(承载 DeltaDB 的平台)、Delta worktree 与 Delta thread,以及开源 IDE Zed(macOS、Windows、Linux 可下载)。目标用户:与 AI agents 协作的软件开发者及团队。

使用形态:基于已有 Git 仓库工作;thread 即 git 分支;可镜像到 GitHub 与未迁移者协作;thread 数据在每位参与者机器与浏览器中实时复制;agents 可中途开通隔离 microVM。具体版本号与部署规格:原文未说明。

变量:实际改变了什么

  • 文件表示:屏幕上仍是一维字符串,底层 DeltaDB 改为带稳定身份的 fragments;anchor 跨快照解析 span,取代只在单一快照有效的行号
  • 记录方式:对话与代码共同进入共享历史,不再把讨论、中间状态与意图压扁进最终文件或 commit
  • 保留策略:默认保留一切的所有版本
  • 互操作姿态:不同于 Xanadu 拒绝与低级格式互通,Delta 直接使用已有 git 仓库;Zed 过渡期镜像到 GitHub
  • 价格、接口等其他变更:原文未说明

区分:包含 ≠ 相关 ≠ 因果

  • 因果(作者论证):Xanadu 失败主因是依赖树不存在(「在依赖树出现前几十年就完成了规格」);agents 到来使永久性与连接性成为必需。两者均为作者的因果解释,前者与 Wired 的「管理失误」归因相左,属观点而非实证
  • 相关/包含而非因果:文中列举的 Lamport 时间戳、Merkle 树、CRDT 等与 Delta 的可实现性是概念支撑与时间先后关系,未附量化证据
  • 「agents 是完美用户、会耐心跟随每条链接」是断言;agents 在 DeltaDB 上实际表现的因果证据:原文未说明
  • landmarks(早先 agents 反复读写的文件与符号成为后来者的地标)明确标注为探索中,非已验证结果

对象:作者/署名与关键技术原理

  • 署名:Nathan Sobo(结构化作者字段中的唯一姓名,字段内出现两次)。正文以第一人称写作,提到几年前曾撰文讨论 Engelbart 1968 年演示
  • Project Xanadu / docuverse:Nelson 1965 年起的项目;保留所有版本、链接记录源与目标、引文按引用保存(transclusion);系统自身承担复杂性与簿记负担
  • xanalogical 两原则:从不拷贝只引用;从不覆盖只留版本
  • DeltaDB:以派生自的 Git commit 加其上应用的 actor-and-timestamp delta ID 集合命名 commit 间状态;文件底层为带稳定身份的 fragments;anchor 在周边代码变化后仍可解析;保留因果元数据(哪个操作产生每个 fragment、基于哪个先前状态)
  • Delta thread:对话与代码的共享历史,是永久结构化历史的实时投影(Tree-sitter 支持输入时重解析、GPUI 每帧从应用状态派生界面);thread 即 git 分支
  • 支撑技术:Lamport timestamps(1978)、Merkle 树(1979,Git 2005)、CRDT(2011)、廉价存储、常开网络、Firecracker 级 microVM(2018)

元反空综合结论

  • 元:本质是一篇以 Ted Nelson 的 Xanadu 史为框架的设计哲学与产品阐述文,回答「为什么是现在、为什么是 Delta/DeltaDB」,把 Zed 的工程决策接驳到六十年的 hypertext 愿景
  • 反:最可能失效或有边界的部分:1)「agents 是缺失的完美用户、会耐心跟随每条链接」是论证性断言,无使用数据;2)「默认保留一切所有版本」的成本与规模边界未讨论;3)「每个 thread 都是 git 分支」的互操作承诺可能反过来限制 xanalogical 深度,Git 本身是相对扁平的格式;4) 对 Xanadu 失败的「依赖缺失」归因是作者观点,与 Wired 叙事相左;5) landmarks 等能力仍处探索阶段
  • 空:去掉叙事后剩余的必要事实:Zed 正在构建 Delta 与 DeltaDB;以 fragments、稳定身份与 anchor 表示代码;以 actor 加 Lamport 时间戳命名操作;CRDT 支持跨大洲并发编辑;默认全版本保留;thread 即 git 分支、可镜像 GitHub;agents 可中途开通隔离 microVM
  • 综合:文章可信地描述了 DeltaDB 的设计机制(有具体技术构件与出处),但「agents 将因此获益」的核心主张在本文中停留在论证层面,成立与否需实际使用数据检验

中文译文 AI 生成

今年,我时常想起 Ted Nelson。

Nelson 是计算领域的先驱,他在 1965 年创造了 hypertext 这个词,作为那个日后将定义他整个职业生涯的项目——Project Xanadu——的一部分。借助 Xanadu,他对计算可能成为的样子抱有一个具体的愿景,并将其称为 docuverse。

他设想了一个能保留文档每一个版本的系统;hypertext 链接会同时知晓自己的源与目标,引文将以引用(而非复制)的方式保存,从而使任何被纳入的文本都保持其身份与出处。在计算的这一版本中,一切都将是 intertwingled 且 xanalogical 的。我们谈论的是精确到 span 的归属。

所谓 xanalogical,就是遵循两条规则:永不复制,始终引用(用一个 Nelson 式的造词来说,即 transclusion)。永不覆盖,始终保留版本。按 Nelson 的设计,Xanadu 会自行管理系统的复杂性与庞大的簿记负担,因此用户只会体验到一个永不遗忘的系统所带来的好处。

无限簿记的愿景,需要无限存储与一套面向未来的命名方案成为现实,而在 Nelson 研发 Xanadu 的那几十年里,这两样都不存在。于是,当 web 技术在 90 年代爆发时,开发者绕过了 xanalogical 计算,转而选择省事:链接只是简单的字符串,一旦目标移动就会失效。

维护变成了用户的问题——而不再是系统的责任——但任何人都能轻松快速地交付,他们也确实这么做了。Xanadu 从一个新时代的承诺,黯淡成了计算界最著名的 vaporware。

Nelson 花了整个职业生涯来解释:web 是对 hypertext 本应成为之物的扁平化拙劣模仿。他是对的,但这无关紧要,因为人们其实并不需要能够追踪每一条链接或比较每一个版本。

我们是一个不安分的物种,更倾向于去追随那些我们看到别人在追随的链接、阅读别人正在阅读的版本。扁平,就已经足够好了。

然后,agent 到来了。

让 agent 成为别扭协作者的那些特质,恰恰也让它成为 Nelson 系统中的完美公民。Agent 能追随的潜台词层次,比人们头脑一次所能容纳的更多,比如一条引文背后的出处、围绕它的各种讨论,以及附着在确切运行过的代码上的堆栈跟踪。

基于片段的表示让这些引用无损,因此随着文本变化,每一层仍附着在同一个 span 上。Agent 可以把这些维度放在一起阅读、引用它们以便人类审计其工作,并且每一次都耐心地追随每一条链接。但这些链接需要真实存在于某处,agent 才能找到它们。

如今,当我重新审视 Nelson 的愿景,我认出了 DeltaDB 的设计目标,以及 Delta 的承诺。在为了迁就人类注意力时长极限而把历史压扁了几十年之后,我们正处于一个新的现实之中,而某种更……xanalogical 的东西能更好地服务它。

如何在部件存在之前构建一个系统

几年前,我撰文谈到观看 Engelbart 1968 年演示的经历,以及我的领悟:要构建一个协作编辑器,他的团队必须发明它将要依赖的一切:一门新的编程语言、操作系统,以及显示器。

Nelson 遇到了同样的问题(但资金比 Engelbart 所享有的少得多)。他无法构建 Xanadu,因为它的大多数部件并不存在,比如一种不经任何权威机构签发的内容命名方式,或便宜到永远不必删除的存储。

他的团队多年来手工打造自己的数据结构,但项目最终夭折。《Wired》将 Nelson 的故事描绘为一个管理失当的故事,但我认为,他只是在 Xanadu 的依赖树出现之前的几十年,就已写好了它的规格。

依赖树如今已经存在

我们今天能够构建 Delta,是因为其他人六十年的路线图交付了 docuverse 缺失的部件:内核开发、照片存储、serverless 冷启动、协作光标。我觉得很迷人的一点是:这些突破平日里各有平凡的本职工作,却将开启计算的下一个时代。

  • 一座为无中心世界而设的时钟。Lamport 时间戳,1978 年。每个人和每个 agent 的每一次操作,都由一个 actor 加一个 Lamport 时间戳来命名,且永远如此。
  • 不会说谎的名字。Merkle 树,1979 年,2005 年由 Git 变得稀松平常。一个 Git commit hash 命名一个确切且不可变的项目状态;DeltaDB 则通过一个状态所派生自的 Git commit,加上在其之上应用的一组由 actor 与时间戳构成的 delta ID,来命名 commit 之间的每一个状态。
  • 无需协调的收敛。CRDT 于 2011 年被形式化,也是 Zed 自身过去十年工作的核心。一个 Delta worktree 可以被身处不同大洲的多人和多个 agent 同时编辑。
  • 便宜到不必删除的存储。1981 年,一个 gigabyte 要花费数万美元;如今只需一美分。我们默认保留一切东西的每一个版本。
  • 复制一切的网络。始终在线的高速宽带在 2000 年代中期超越了拨号上网。每一条 thread 都是活跃的、被复制的数据,存在于每个参与者的机器上,也存在于浏览器中。
  • 毫秒之间即可召唤的机器。Firecracker 级的 microVM,2018 年。Delta 中的 agent 可以在对话进行中途开通一台新的隔离云机器。
  • 作为永久内容之上视图的文档。Max Brunsfeld 的 Tree-sitter,2018 年,快到能在你打字的同时重新解析。GPUI,随 Zed 一同开创,快到每当绘制一帧都能从应用状态推导出一个全新界面。一条 Delta thread 是对其永久结构化历史的实时投影,是重新计算得出的,而非作为扁平化文档存储的。

在一个细节上——纵观他一路被人说梦想太大的整个职业生涯——Nelson 反而梦得太小了。他缺失的最后一个依赖,是一种新型用户。他没有想象出人工读者,尽管它们早已存在于科幻小说之中(比如 Asimov 的 Multivac,或 Stephenson 的 Librarian)。

尽管 Xanadu 曾因组件缺失而被阻隔数十年,但它最需要的是完美的用户。

为什么 docuverse 正在版本控制中成形

大多数实际的代码创作一直都发生在 commit 与 commit 之间,但过去把上下文压平所造成的伤害较小,因为我们靠人类记忆就能应付(而且反正也没人会去读按键变更的完整记录)。

但 agent 的头脑中什么也不保留,而且它们会把所有东西都读一遍,因此我们需要一种方法,用 Nelson 明确规定的两样东西来捕捉这个新的事实来源:永久性与连接性。

每一条 Delta thread 都兑现了这一承诺。对话与代码被一同记录在一份共享的历史中。在屏幕上,文件看起来仍然是一维的字符串,但在底层,DeltaDB 将它表示为一个个具有稳定身份的片段。

这些身份让我们得以创建锚点:对区间的引用,即便周边代码发生变化,它们依然可以被解析。行号能表达文本在某个快照中出现的位置,而锚点保存的是我们所指的那个区间,令其跨越各个快照依然成立。

我们一直在探索 agent 如何能在这一坐标系之上进行构建。先前 agent 反复读取、编辑、引用或回访过的文件与符号,可以成为下一个 agent 的地标,既可以对照如今实际存在的代码加以解析,又能链接回那些理解得以形成的对话。

通过保存在这种表层表示之下的因果元数据——比如每个片段由哪个操作产生、它又建立在哪个先前状态之上——DeltaDB 为模型提供了一种途径,使其能够遍历的不仅是当前代码,还包括代码的来源、积累的关注以及先前的推理。

避开 Xanadu 的诅咒

Xanadu 还有最后一种失败模式,这一种是自找的:它拒绝与较弱的格式互操作。在我们向世界推出 DeltaDB 之际,我们正从那个错误中吸取教训。我们会与你已有的 git 仓库配合工作。

每条 thread 同时也是一条 git 分支,因此从未打开过 Delta 的队友看到的是一个正常的仓库;而且由于这些文件是真实的文件,它能与 agent 可使用的任何工具无缝集成。你可以继续把仓库镜像到 GitHub,与任何还没准备好切换的人协作(在过渡期,我们的开源 IDE Zed 采取的就是这种做法)。

Engelbart 和 Nelson 是早期计算的先知,但我们从未完整交付过他们任何一人的愿景:从前者那里,我们采纳了鼠标(以及最终的多人编辑);从后者那里,我们拿走了 hypertext 这个词。两个想法都存活了下来,但都没有达到各自创造者所想象的深度。

我们至今仍把实时会话与持久记录分离开来:讨论、中间状态与意图被压平成最终的文件或 commit,而绑定在路径与行号上的链接则随着代码的移动而失效。我希望 Delta thread 能同时实现这两种愿景:一种留下永久且相互连接的文献的实时会话,因为会话与记录是同一个对象。

我们构建 Delta 与 DeltaDB 所需的每一项特性,Nelson 都在我出生之前就规定好了。尽管我的目标并不是实现 Xanadu,我仍然能体会到 Nelson 当年在期盼一个怀抱已久的愿景落入人们手中时,必定感到的那种焦躁不安。

对一个想法来说,等待它的用户,六十年是一段很长的时间。而现在,他们已经来了。

相关文章

看看 Zed 团队的其他类似博客。

在找一款更好的编辑器?

今天你就可以在 macOS、Windows 或 Linux 上试用 Zed。立即下载!

我们正在招聘!

如果你对我们博客所涉及的话题充满热情,请考虑加入我们的团队,帮助我们一起交付软件开发的未来。

展开原文提取正文(采集端自动提取,可能有缺失)

Ted Nelson has been on my mind a lot this year. Nelson was a pioneer in computing, and in 1965 he coined the word hypertext as part of the project that would define his career: Project Xanadu. With Xanadu, he had a specific vision of what computing could be, which he called the docuverse. He imagined a system that could keep every version of a document; hypertext links would know both their source and destination, and quotations would be kept by reference (rather than copy) so any included text maintained its identity and source. Everything, in this version of computing, would be intertwingled and xanalogical. We're talking about attribution down to the span. To be xanalogical is to follow two rules: Never copy, always reference (also known by a Nelsonism, transclusion). Never overwrite, always version. As Nelson designed it, Xanadu would manage the system's complexity and massive bookkeeping burden itself, so users only experienced the benefits of a system that could never forget. The vision of unlimited bookkeeping requires the reality of unlimited storage and a future-proof naming scheme, neither of which existed for the decades that Nelson worked on Xanadu. So when web technology exploded in the '90s, developers bypassed xanalogical computing in favor of ease: links are simple strings which break if their target moves. Maintenance became users' problems — instead of the system's responsibility — but it was easy for anyone to ship fast, and they did. Xanadu faded from the promise of a new era into computing's most famous vaporware. Nelson has spent his career explaining that the web is a flattened parody of what hypertext was meant to be. He's right, but it didn't matter because people didn't actually need to be able to follow every link or compare every version. We're a restless species, and more inclined to follow the links or read the versions we see others pursuing. Flat was good enough. Then agents arrived. What makes an agent an awkward collaborator also makes it a perfect citizen for Nelson's system. Agents can follow more layers of subtext than people can hold in their heads at once, such as the sources behind a quotation, any discussion around it, and stack traces attached to the exact code that ran. A fragment-based representation makes those references lossless, so each layer stays attached to the same span as the text changes. Agents can read these dimensions together, cite them so humans can audit their work, and patiently follow every link, every time. But those links need to actually exist somewhere in order for an agent to find them. When I revisit Nelson's vision now, I recognize DeltaDB's design goals and the promise of Delta. After decades of squashing history to meet the limits of the human attention span, we're in a new reality that would be better served by something more... xanalogical. How to build a system before the parts exist A few years ago I wrote about watching Engelbart's 1968 demo and my realization that to build a collaborative editor, his team had to invent everything it would rely on: a new programming language, operating system, and displays. Nelson had the same problem (but with way less funding than Engelbart enjoyed). He couldn't build Xanadu because most of its parts didn't exist, such as a way to name content that no authority issues, or storage cheap enough to never delete. His teams hand-built their own data structures for years, but the project died on the vine. Wired depicted Nelson's story as one of mismanagement, but I think he'd just specified Xanadu decades before its dependency tree existed. The dependency tree exists today We can build Delta today because sixty years of other people's roadmaps delivered the docuverse's missing pieces: kernel development, photo storage, serverless cold starts, collaborative cursors. I think it's fascinating that breakthroughs have ordinary day jobs, yet will enable the next era of computing. A clock for a world with no center. Lamport timestamps, 1978. Every operation by every human and agent is named by an actor plus a Lamport timestamp, forever. Names that can't lie. Merkle trees, 1979, made ordinary by Git in 2005. A Git commit hash names an exact immutable project state; DeltaDB names every state between commits by the Git commit it descends from and the set of actor-and-timestamp delta IDs applied above it. Convergence without coordination. CRDTs, formalized in 2011, and the center of Zed's own work for the past decade. A Delta worktree can be edited by several people and agents on different continents at once. Storage too cheap to delete. A gigabyte cost tens of thousands of dollars in 1981; it costs a penny now. We keep every version of everything by default. Networks that replicate everything. Always-on and fast broadband overtook dial-up in the mid-2000s. Every thread is live, replicated data on every participant's machine and in the browser. Machines summoned in milliseconds. Firecracker-class microVMs, 2018. Agents in Delta can provision a new isolated cloud machine mid-conversation. Documents as views over permanent content. Max Brunsfeld's Tree-sitter, 2018, fast enough to reparse as you type. GPUI, pioneered with Zed, fast enough to derive a fresh interface from application state whenever a frame is drawn. A Delta thread is a live projection of its permanent structured history, recomputed rather than stored as a flattened document. On one detail — across a career of being told his dreams were too big — Nelson dreamt too small. The final dependency he was missing was a new kind of user. He didn't imagine artificial readers, though they existed in science fiction (like Asimov's Multivac, or Stephenson's Librarian). Though Xanadu was blocked for decades by missing components, what it needed most was the perfect user. Why the docuverse is materializing in version control Most actual code creation has always happened between commits, but it used to hurt less to flatten the context because we got by on human memory (and nobody was going to read full records of keystroke changes anyway). But agents keep nothing in their heads, and they'll read everything, so we need a way to capture the new source of truth using exactly what Nelson specified: permanence and connection. Every Delta thread delivers on that promise. The conversation and the code are captured together in a shared history. On screen, a file still looks like a one-dimensional string of characters but underneath, DeltaDB represents it as fragments with stable identities. Those identities let us create anchors: references to spans that can still be resolved after surrounding code changes. A line number can express where text appears in one snapshot, while an anchor preserves which span we mean across snapshots. We have been exploring how agents can build on that coordinate system. The files and symbols earlier agents repeatedly read, edited, cited, or returned to can become landmarks for the next agent, resolved against the code as it exists now and linked back to the conversations where that understanding was formed. By preserving the causal metadata beneath that surface representation, like which operation produced each fragment and what prior state it built on, DeltaDB gives the model a way to traverse not just the current code, but its provenance, accumulated attention, and prior reasoning. Avoiding Xanadu's curse Xanadu had a final failure mode, this one self-inflicted: it refused to interoperate with lesser formats. As we introduce DeltaDB to the world, we're learning from that mistake. We'll work with the git repository you already have. Every thread is also a git branch, so teammates who never open Delta see a normal repo, and because the files are real, it integrates seamlessly with any tool an agent can use. You can keep mirroring your repo to GitHub to work with anyone who isn't ready to make the switch (that's our approach for our open source IDE, Zed, during this transitional period). Engelbart and Nelson were prophets of early computing, yet we never shipped either's vision whole: from the former we adopted the mouse (and eventually multiplayer editing), and from the latter we took the word hypertext. Both ideas survived, but neither at the depth their creators imagined. We still split the live session from the durable record: discussion, intermediate states, and intent are flattened into a final file or commit, while links tied to paths and line numbers decay as the code moves. I hope for Delta threads to meet both visions at once: a live session that leaves behind a permanent, connected literature, because the session and the record are the same object. Every property we needed to build Delta and DeltaDB was specified by Nelson before I was born. And though my goal is not to realize Xanadu, I still feel some of the antsiness Nelson must have experienced while hoping for a long-held vision to land in people's hands. Sixty years is a long time for an idea to wait for its users. They're here now.Related PostsCheck out similar blogs from the Zed team.Looking for a better editor? You can try Zed today on macOS, Windows, or Linux. Download now!We are hiring! If you're passionate about the topics we cover on our blog, please consider joining our team to help us ship the future of software development.

原文入口

阅读原文(zed.dev)

原文将在新窗口打开。收录时间不是内容更新时间;正文、译文与解读的版权归原作者/来源所有,本站仅作个人阅读辅助并保留原文入口;页面时间均为北京时间。

作者/署名来自原文结构化字段(Atom/RSS/HTML meta/JSON-LD;GitHub release 显示的是发布者账号),未经模型补充。

了解来源批准与收录规则