Article

Winc: A Rust Editor That Starts in 0.1 Seconds and Sips 52 MB of RAM

Winc: A Rust Editor That Starts in 0.1 Seconds and Sips 52 MB of RAM

A thread on the LINUX DO forum has been running for two weeks and refuses to die. It pitches a brand-new desktop editor called Winc as the answer to IDE bloat: a Rust-built editor that runs on roughly 48 MB of memory, starts almost instantly, and still ships the Git integration, terminal, and previews people expect from a modern tool. The thread has drawn more than 700 posts and close to 10,000 views, with forum members testing it, arguing about the numbers, and filing feedback in real time. That kind of attention is unusual for a two-week-old project.

The short answer is that Winc is not another Electron wrapper. It is a native desktop editor written almost entirely in Rust, with its own CPU rasterizer doing the drawing. The project's own description makes the pitch plainly: it starts in 0.1 seconds and uses 52 MB of memory with 100,000 lines open. Note the small gap between the forum thread's "48 MB" headline and the project's measured 52 MB — the thread rounds the number down, and the project's own benchmark table is the more careful figure.

The numbers, and where they come from

Winc's repository, published under the name DEEIX-AI/Winc on GitHub, includes a small benchmark table in its README. The figures are the project's own measurements, taken on macOS, and the README says so directly — results will vary with hardware and system load. That honesty matters, because these numbers are the whole argument for the editor.

MeasureResult (project's own benchmarks)
Cold start to first frame119 ms (median of 20 runs)
Resident memory, 100,000 lines open52 MB
Opening and editing a 1 GB file220 ms, with syntax highlighting

A cold start of 119 milliseconds changes how you use an editor. At that speed there is no reason to leave it running all day or hesitate before opening a config file from the command line. The 1 GB file figure is arguably more impressive: most editors either refuse files that large or grind to a halt on them, and Winc claims to open one, highlighted, in about a fifth of a second.

Treat these as the developer's claims, not independent verification. The numbers come from the project's own test setup on macOS, and nobody outside the project has published a reproducible benchmark yet. What is independently verifiable is the project's shape: created on November 4, 2026, it already has around 855 stars, more than 100 forks, nearly 600 commits, and nine releases in its first two weeks — a team shipping daily.

What you actually get besides speed

Speed alone does not make an editor usable, and Winc's feature list reads like a deliberate attempt to cover the daily workflow without turning into an IDE. Multiple cursors, find and replace, and smooth scrolling through very large files are the baseline. Syntax highlighting covers common programming, markup, data, and configuration languages, and there is a lightweight go-to-definition that works without a language server — a meaningful choice, since language servers are one of the main sources of memory and CPU weight in editors like VS Code.

AreaWhat it covers
EditingMultiple cursors, find and replace, native input methods, experimental Vim mode
FormattingWhole-file formatting via rustfmt, Prettier, Black, Ruff, and gofmt
PreviewMarkdown with math and Mermaid diagrams, images, SVG, PDF, Word documents, and spreadsheets
GitSide-by-side diffs with word-level highlights, staging by hunk, commit, push, commit graph, blame
ProjectFile tree, quick open, project search that follows .gitignore
TerminalIntegrated terminal that automatically loads project-local Python environments
RemoteExperimental SSH remote editing; on Windows, folders inside WSL distributions

Two details stand out. The Markdown preview is editable — added in version 0.1.626 on November 10 — so you can format text and manage task items from inside the preview. And Git, the terminal, and SSH remote are each modules that can be switched off entirely, so the editor can be as small as you want it to be. Sixteen built-in themes and a full interface in English and Simplified Chinese round out a package clearly designed with Chinese developers in mind.

No framework, its own rasterizer

The technical decision that makes the numbers possible is the rendering stack. Winc does not use Electron, Tauri, or a GPU framework. Windows come from winit, a low-level Rust windowing library, and everything on screen is drawn by the project's own CPU rasterizer; on macOS, frames are written directly to an IOSurface. The codebase is split into focused crates — winc-core for text and diffing, winc-render for glyphs and rasterization, winc-preview for document previews, winc-pty for terminal emulation.

That architecture is the reason the editor can promise instant keystrokes: there is no browser engine between your input and the screen. The trade-off is that building your own renderer means building your own everything — text layout, input methods, touch handling — and the README's long section on touchscreen gestures shows how much of that work is still being done by hand. It is a bet that control over the whole stack is worth the maintenance burden.

The honest caveats

A two-week-old editor deserves a skeptical read, and the forum thread is full of one. The first caveat is the benchmarks themselves: they are the developer's measurements on macOS, and the README warns they vary with hardware. Windows and Linux users should expect different numbers, and the project is, by its own admission, developed and tested mainly on macOS.

The second caveat is youth. Nine releases in two weeks means fast fixes, but also a moving target: interfaces change, features marked "experimental" — Vim mode and SSH remote editing among them — may behave unpredictably, and the project's long-term maintenance is unproven. The backing organization, DEEIX AI, is not a household name. The Apache 2.0 license at least means the code stays open whatever happens, and the repository already accepts contributions against its dev branch.

The third caveat is scope. Winc deliberately has no extension marketplace and no language-server support, which keeps it light but also means it cannot match the ecosystem of VS Code or the AI-assisted workflows many developers now rely on. If your workflow depends on a specific extension or an AI coding agent living inside your editor, Winc is not a replacement today. It is a fast, focused editor for people who mostly want to edit text, review diffs, and run a terminal.

Trying it out

Winc is free for macOS 11 and later (Apple silicon and Intel), Linux x86_64 (AppImage, deb, and an Arch repository), and Windows 10 version 1809 and later (NSIS installer, MSI, or a portable ZIP). Downloads come from the project's website, winc.si, with every version also listed on GitHub Releases.

The command line is part of the pitch, not an afterthought. From a terminal you can open the current folder, jump to a line and column, use it as your Git editor, or pipe build output straight into a buffer:

winc .                # open the current folder
winc file.rs:12:5     # open a file at a line and column
winc --wait file      # wait until the tab closes, for example as the Git editor
cargo build 2>&1 | winc -  # read standard input

Building from source needs Rust 1.99.1, with the toolchain pinned automatically. If you do try it, the project's own benchmark harness is part of the repository — cargo xtask bench measures startup, memory, and scrolling against the project's budgets — so the performance claims are testable rather than merely asserted.

Why the thread ran to 700 posts

Winc is easy to dismiss as another lightweight-editor announcement in a field that has seen dozens of them. But the discussion is not really about its feature list. It is about a frustration that has been building for years: editors keep getting heavier, and the tools that stay fast tend to give up the features people actually use. Winc's bet is that you do not have to choose — that a team willing to write its own renderer can have both the speed and the Git panel.

It is also part of a wider pattern in the Chinese developer community: rebuilding everyday tools natively in Rust instead of accepting the weight of web technology. We covered the same instinct in the story of a Rust project that walked away from WebView, and in NyaTerm, the Rust terminal built after WindTerm went quiet. Winc applies the same thinking to the editor — the tool developers stare at all day, where every millisecond of latency is felt.

Whether the bet holds depends on the next few months, not the first two weeks. The project needs to prove it can keep its benchmarks honest on all three platforms and stabilize the experimental features. But the early signs — a clean architecture, a fast release cadence, and a community thread still arguing about it two weeks in — are better than most new editors manage. If you have ever closed your editor just to reclaim a few hundred megabytes, it is worth an afternoon.

The discussion that inspired this article is on LINUX DO: 抛弃 IDE 的臃肿,占用仅 48 MB 的 Rust 编辑器 Winc. The project's README is the primary source for the benchmarks and feature list: DEEIX-AI/Winc on GitHub.

Keep reading
ChatGPT Plus vs Claude Pro vs Google AI Pro: Which $20 Subscription Gives You the Most AI?
Read next →