I live in a mixed world: Neovim (with LazyVim) for most days, Helix when I’m curious, and Zed when I want a sleek GUI. I steer clear of the usual VS Code–style IDE workflow. This is the story of why—plus a practical comparison of modern terminal (TUI) editors versus today’s GUI editors and IDEs.
The quiet superpower of TUI editors (and why they still win)
Text-mode editors didn’t stick around by accident. They’re fast, scriptable, and work everywhere—especially over SSH. You can even edit remote files directly from Vim/Neovim, which is a huge productivity boost when you live in terminals.
Because TUIs run inside a terminal, they’re naturally light on resources and feel snappy, even on modest hardware or remote machines. That’s a big part of their appeal for developers who value responsiveness over UI chrome.
The modern TUI lineup: Neovim, Helix, and Kakoune
Neovim: the endlessly customizable workhorse
Neovim added a built-in LSP client starting with 0.5, and has steadily refined it (0.11 made setup simpler), which gives you go-to-definition, rename, diagnostics, and more—without bolting on heavyweight external subsystems. Pair that with Tree-sitter for fast, incremental parsing and you get rich, resilient semantics as you type.
What makes Neovim sing in 2025 is the ecosystem around it. LazyVim bundles smart defaults, LSP wiring, and a curated plugin set so you don’t reinvent your config every time you switch machines. Under the hood it uses lazy.nvim, a performance-first plugin manager that aggressively lazy-loads modules to keep startup times low.
TL;DR: With Neovim + LazyVim you get an IDE-class experience, tuned for speed, but still 100% yours.
Helix: batteries-included, selections-first
Helix is a “post-modern” modal editor that leans into multiple selections as a first-class editing model (inspired by Kakoune) and ships with Tree-sitter and LSP out of the box. Its goal is “less configuration, more editing,” which makes it feel productive on day one—even if you never crack open a config file.
The trade-off: Helix intentionally has no plugin system yet (the team has discussed designs), which keeps things coherent but caps extensibility compared with Neovim. If you want deep customization and a galaxy of plugins, Neovim still wins.
Kakoune: the selection-oriented original
Kakoune pioneered the selection-first editing approach that influenced Helix. It’s modal, minimalist, and exceptionally fast, with oriented selections and multi-cursor operations at its core. If you love precise, interactive text manipulation, Kakoune’s model is a joy.
Where TUIs shine—and where GUI IDEs still pull ahead
TUIs excel at
- Speed and focus. Minimal UI, maximal keyboard flow, fewer moving parts.
- Remote/CLI workflows. SSH, tmux/screen, scripts—TUIs fit the Unix toolbox.
- Customizability (Neovim). Lua, Tree-sitter, and a mature plugin ecosystem let you build exactly the editor you want.
GUI IDEs still lead on
- “Big refactors” and code intelligence. JetBrains IDEs, in particular, wire refactorings, find-usages, inspections, and navigation deeply into the platform.
- Visual debugging & profiling. Integrated debuggers, breakpoints, watches, and profilers are polished and discoverable.
- Project wizards and one-stop UX. GUI IDEs bundle template generators, GUI-based VCS tools, structured settings, and dashboards out of the box.
Neovim can meet you halfway with DAP support via plugins like nvim-dap (you choose language adapters per stack), but it’s more setup than clicking a “Debug” button in a GUI.
The GUI side: VS Code, JetBrains, and Zed (my favorite GUI)
VS Code: extensible and familiar… but I don’t vibe with it
Facts first. VS Code is an Electron app (Chromium + Node.js) with a multi-process architecture: a main process, renderers for the UI, and an isolated “extension host” process for running extensions. That isolation is great for stability—but it also means more processes and sometimes more resource usage, especially with heavy extensions. Microsoft’s own docs and wiki detail the extension host and the process explorer for chasing high CPU / memory from extensions.
My take. I appreciate the marketplace and convenience, but the Electron feel, background churn, and “death by a thousand extensions” don’t suit how I like to work. I prefer the predictability and minimalism of a TUI that I can bend to my habits rather than a GUI I’m always trimming.
JetBrains IDEs: the heavy hitters (for a reason)
The good: unmatched refactoring depth, code inspections, navigation, and a first-class debugger. Profiling is built in (e.g., Async Profiler). If your workflow is restructuring large codebases all day, this is the gold standard.
The trade-offs: indexing powers those smarts—and indexing is resource-intensive. JetBrains documents that indexing runs when you open/switch branches, after large changes, or when plugins change; they’ve introduced “Shared Indexes” and other improvements, but it’s still heavy on big projects. You may even need to adjust heap settings.
Zed: the fast, modern GUI editor I actually love
Zed is written in Rust, with a custom GPU-accelerated UI framework (“GPUI”) designed for extremely low-latency editing. Its real-time multiplayer collaboration (with voice rooms), remote development, and growing AI tooling strike a balance between “feels instant” and “feels modern.” When I want a GUI without the weight of a full IDE, I open Zed.
Editor-by-editor: what it feels like to actually use them
- Neovim + LazyVim: lightning-fast startup, tight keyboard flow, Lua-powered customization, Tree-sitter semantics, and a distro that spares you weeks of yak-shaving. It’s my daily driver.
- Helix: immediate productivity with multiple selections, Tree-sitter, and LSP built in. Great when I want “sensible defaults” and zero plugin hunting—though I miss the long tail of Neovim plugins.
- Kakoune: the original selection-first mindset; ultra-direct, ultra-fast. A joy for text surgery.
- VS Code: ubiquitous and convenient—debugging, marketplace, and remote tooling are top-notch—but its Electron/multi-process design and extension host can balloon resource use. It’s not my aesthetic or performance profile.
- JetBrains (IntelliJ-family): if I’m doing massive refactors or spelunking huge codebases, nothing beats it. I just don’t love waiting on indexing on less-beefy machines.
- Zed: when I want a GUI that feels instant and collaboration-ready, Zed hits the sweet spot.
Why I ultimately stick with Neovim (with LazyVim)
- Keyboard-first focus with modal editing that keeps me in flow.
- Performance that feels instantaneous on local and remote machines.
- A curated, low-friction setup via LazyVim + lazy.nvim that still lets me personalize everything.
- A healthy middle path: when I need visual debugging or a polished GUI pass, I jump to Zed (or a JetBrains IDE for the gnarly refactor). Use the best tool for the job, not the same tool for every job.
Practical recommendations (2025)
Primarily TUI, with occasional GUI:
Use Neovim + LazyVim for daily coding; open Zed when you want a clean GUI, pairing, or “show the code” moments.
Heavier refactoring/debugging days:
Fire up a JetBrains IDE—accept the indexing tax, reap the refactoring and debugger benefits.
Curious about a fresh modal workflow:
Try Helix to experience selections-first editing with batteries included. Just know extensibility is intentionally limited (for now).
If you value speed, keyboard flow, and a minimal yet powerful workflow, Neovim (with LazyVim) is hard to beat. Helix offers an elegant, plugin-light alternative. Zed delivers a modern, collaborative GUI without IDE bloat. For the deepest refactors and integrated debugging, JetBrains still sets the bar--even if indexing and memory use are the price of admission.