Get AI summaries of any video or article — Sign up free
Microsoft’s new vim alternative is written in Rust??? thumbnail

Microsoft’s new vim alternative is written in Rust???

Theo - t3․gg·
5 min read

Based on Theo - t3․gg's video on YouTube. If you like this content, support the original creators by watching, liking and subscribing to their content.

TL;DR

Microsoft’s edit is a new default command-line text editor for 64-bit Windows, built to ship with Windows 11 after Windows Insider preview.

Briefing

Microsoft has launched edit, a lightweight command-line text editor built from scratch in Rust, designed to feel like classic MS-DOS-era editing while solving a specific Windows gap: 64-bit Windows ships without a default CLI editor. The project is small enough to bundle across Windows editions, aims for strong Unicode and terminal (VT) output for smoother SSH integration, and takes a modeless approach to avoid the “how do I exit Vim?” learning cliff that trips up new users.

edit’s core pitch is pragmatic. Microsoft says it wanted a small binary so it could ship with Windows variants without triggering image-size bloat fights, while still providing decent Unicode support. It also chose a VT-output-centered design rather than console APIs, explicitly to integrate cleanly with SSH. Mouse support is included, and the editor is positioned as a better baseline than Notepad for terminal workflows—something users can click through, select, and edit without wrestling with modal controls.

The Rust angle is central to the buzz. edit is fully open source under the MIT license and hosted on GitHub, with multiple contributors. The transcript notes that the Windows terminal team is behind the effort, and speculates that the project may double as an internal Rust exploration—especially since Microsoft has historically used C++ and other languages in similar areas. That speculation is reinforced by the way the project’s design decisions map to Rust-specific engineering tradeoffs: the team built a custom terminal UI library because existing terminal UI frameworks didn’t map well to plain C or were too large for the bundling constraint. An arena allocator is used to make Rust tree-building less painful, and the codebase is described as relatively compact—around 16k lines of Rust—making it a feasible reference for learning.

edit also reflects a deliberate rejection of existing editors. Microsoft compares options including Nano, Kilo, Micro, and Yori, and calls out why they didn’t fit the Windows default-editor requirements—either because they were too large to bundle or lacked first-party Windows support. The project’s modeless design is another key differentiator: instead of modal editing, it aims to behave more like familiar text editors, reducing friction for new users.

In practice, the editor is presented as functional rather than gimmicky: it supports basic file operations, navigation, undo/redo, and word wrap, with syntax highlighting kept minimal for plain Markdown use in the demo. Although the transcript claims Windows is the primary target, it also notes that building or running it on other platforms is possible by compiling from source.

The overall takeaway is that edit isn’t meant to replace Vim or Neovim for power users. It’s a default CLI editor for Windows—small, fast to learn, and engineered to meet OS-level constraints—while simultaneously serving as a public, MIT-licensed Rust showcase that Microsoft can use to test ideas and share them with the broader ecosystem.

Cornell Notes

Microsoft’s edit is a new command-line text editor built from scratch in Rust, aimed at filling a missing default-editor role in 64-bit Windows. The design prioritizes a small binary size (under ~250K for Windows), strong Unicode support, and VT-based terminal output to work smoothly with SSH. Unlike modal editors like Vim, edit is modeless to reduce the “how do I exit?” barrier for new users, and it includes mouse support for terminal selection and editing. The project is MIT licensed, open on GitHub, and backed by the Windows terminal team, with the Rust implementation and compact codebase (~16k lines) making it a useful reference for learning and experimentation.

Why does edit exist specifically for 64-bit Windows, and what problem does it target?

The project is motivated by the lack of a default CLI text editor in 64-bit Windows “in the box.” The transcript contrasts this with 32-bit Windows, which historically shipped with the MS-DOS editor, and notes that the 64-bit editor disappeared starting with Windows 10. edit is meant to be the built-in command-line editing experience that ships with Windows 11 after a preview in the Windows Insider program.

What engineering constraints shaped edit’s design choices?

Microsoft’s stated constraints include keeping the binary small enough to bundle across Windows editions without inflating the Windows image size. The transcript cites a target of less than ~250K for the Windows build and also mentions the need for decent Unicode support. For terminal integration, the editor is built around VT output rather than console APIs, explicitly to support seamless SSH integration.

How does edit’s interaction model differ from Vim, and why does that matter for adoption?

edit is modeless, unlike modal editors such as Vim. The transcript links this to a common stumbling block for both new and experienced programmers: remembering how to exit Vim. By avoiding mode switching, edit aims to feel closer to familiar text editors (like Nano-style expectations) so it can serve as a default editor for users who may not want to learn modal command patterns.

What’s the significance of the project being written in Rust, and what does the transcript suggest about Microsoft’s intent?

edit is described as fully Rust-based and MIT licensed, with an open GitHub repository and multiple contributors. The transcript speculates that the Windows terminal team’s involvement may reflect internal Rust experimentation, especially because Microsoft previously used C++ in many terminal-adjacent components. The compact Rust codebase (~16k lines) and the custom terminal UI library are presented as evidence of a deliberate engineering effort rather than a quick fork.

Why build a custom terminal UI library instead of reusing existing ones?

The transcript says the team built its own terminal UI library because popular terminal UI frameworks didn’t map well to plain C, and the ones that did fit were too large for the bundling requirement. Since the editor must ship with Windows, keeping the binary small is a hard constraint, so the team created a smaller, purpose-built approach.

What does the transcript imply about edit’s role in the broader editor ecosystem?

edit is framed as a legitimate, functional default CLI editor rather than a replacement for Neovim or Vim. The transcript argues it likely won’t become the primary coding editor for power users, but it could still be valuable as a learning resource and as a public Rust reference that other developers can study and reuse ideas from.

Review Questions

  1. What specific Windows packaging constraints (binary size and integration requirements) does Microsoft cite as reasons for building edit from scratch?
  2. How does edit’s modeless design change the user experience compared with modal editors like Vim?
  3. What terminal integration choices (VT output vs console APIs) does edit make, and how does that relate to SSH support?

Key Points

  1. 1

    Microsoft’s edit is a new default command-line text editor for 64-bit Windows, built to ship with Windows 11 after Windows Insider preview.

  2. 2

    The editor is written in Rust and released as open source under the MIT license on GitHub.

  3. 3

    edit targets OS-level constraints: a very small Windows binary size (under ~250K) and strong Unicode support.

  4. 4

    VT output is a core design choice to enable smoother SSH integration compared with console-API approaches.

  5. 5

    The editor is modeless to reduce the learning friction associated with modal editors like Vim.

  6. 6

    Mouse support is included for terminal workflows, enabling click-based navigation and text selection.

  7. 7

    The project rejects existing editors (Nano, Kilo, Micro, Yori, etc.) due to size and Windows support limitations, leading to a from-scratch implementation.

Highlights

edit is positioned as the missing default CLI editor for 64-bit Windows, replacing a gap that has existed since the MS-DOS editor was removed starting with Windows 10.
The project’s VT-output-first design is explicitly tied to seamless SSH integration, not just local terminal behavior.
A compact Rust codebase (about 16k lines) and a custom terminal UI library make edit unusually approachable as a reference implementation.
edit is modeless by design, aiming to avoid the “how do I exit Vim?” barrier for new users.

Topics

  • Rust Editor
  • Windows 11
  • VT Output
  • Modeless UI
  • Open Source MIT

Mentioned

  • VT
  • SSH
  • HN
  • NIH