Helix vs Neovim
Helix and Neovim compared as modal terminal editors: editing model, built-in LSP and tree-sitter, plugins and configuration, platforms, release cadence and how hard it is to switch, as of November 2026.
Quick Answer
Helix is an MPL-2.0 editor written in Rust that works out of the box. It uses Kakoune-style selection-first editing with multiple cursors built in, and ships tree-sitter, language-server support, fuzzy pickers and themes with no setup. It has no plugin system yet, and its last tagged release is 25.07.1 from July 2025, though development continues on master. Neovim is an Apache-2.0 fork of Vim configured in Lua. It keeps Vim's verb-then-object model and has the largest plugin ecosystem of any terminal editor. Its stable release is 0.12.6 (9 Oct 2026), and 0.12 added a built-in plugin manager, vim.pack. Pick Helix if you want a modern modal editor you don't have to configure. Pick Neovim if you want Vim keybindings, plugins, or an editor you can shape into exactly the tool you need.
Last updated November 2, 2026. Covers Neovim 0.12.6 (9 Oct 2026) and the 0.12/0.11 release notes, and Helix 25.07.1 plus master activity and the Steel plugin PR status through October 2026, from both projects' docs, changelogs and GitHub data.
| Feature | Helix | Neovim |
|---|---|---|
| Licence | MPL-2.0 | Apache-2.0 (parts under the Vim licence) |
| Written In | Rust | C, Lua and Vimscript |
| Editing Model | Selection → action (Kakoune-inspired) | Action → object (Vim operator + motion) |
| Multiple Cursors / Selections | Yes, core primitive (multiple selections) | Not in stable 0.12 (done on master for the 0.13 roadmap); plugins available |
| Language Server Support | Built in; default servers mapped per language, install the server binaries yourself | Built-in client: vim.lsp.config()/enable(), default mappings, completion, inline completion (0.12) |
| Tree-sitter | Built in for highlighting, indentation, textobjects and syntax-node selection | Built in; bundled parsers for C, Diff, Lua, Markdown, Vimscript, Vimdoc, query |
| Configuration | TOML (config.toml, languages.toml; project-local .helix/) | init.lua (Lua) or init.vim (Vimscript) |
| Plugin System | None yet (Steel plugin system in an open draft PR) | Yes: Lua/Vimscript plugins; built-in vim.pack manager (0.12, experimental) |
| Built-in Fuzzy Finder | Yes: file, buffer, symbol, diagnostics, jumplist and changed-file pickers | Not built in (via plugins) |
| Debugger (DAP) | Experimental built-in DAP support | Via plugins (DAP client plugins) |
| Official Binaries | Linux x86_64/aarch64 (tarball, AppImage, .deb), macOS x86_64/aarch64, Windows x86_64 | Linux x86_64/arm64 (tarball, AppImage), macOS x86_64/arm64 (10.15+), Windows x86_64/arm64 (MSI, zip; Windows 8+) |
| GUI Front Ends | None (terminal only; GUI planned eventually) | Many third-party GUIs via the UI protocol; :restart and :connect for UIs (0.12) |
| Latest Stable Release (Nov 2026) | 25.07.1 (18 Jul 2025); master active through Sep 2026 | 0.12.6 (9 Oct 2026); nightly daily |
| Funding | OpenCollective sponsorship | Sponsorships managed through OpenCollective |
Helix
A Rust-based modal text editor for the terminal, inspired by Kakoune, with multiple selections, tree-sitter and language-server support built in, released under the Mozilla Public License 2.0.
Pros
- Works with almost no configuration: tree-sitter highlighting, textobjects, LSP features, fuzzy pickers, surround, auto-pairs and themes are part of the editor
- Selection-first editing (select, then act) with multiple selections as a core primitive, so you see what a command will change before you run it
- Space-mode pickers for files, buffers, jumplist, changed files, document and workspace symbols, and diagnostics, with on-screen hints for every key
- Language table covers about 276 languages in the release docs, with default language servers already mapped; `hx --health` shows exactly what is missing
- Small configuration surface: one config.toml plus languages.toml, with per-project overrides in .helix/
- Official binaries for Linux (x86_64 and aarch64, AppImage, .deb), macOS (Intel and Apple silicon) and Windows, plus packages in Homebrew, Winget, Scoop, Arch, Fedora, Nix, Flatpak and Snap
Cons
- No plugin system: the Steel-based plugin PR (#8675) has been open as a draft since October 2023 and was still unmerged in late October 2026
- Last tagged release is 25.07.1 (18 July 2025); newer fixes and features land on master and require building from source
- Keybindings are not Vim's: years of Vim muscle memory work against you, and there is no official Vim-compatibility mode
- Debugging (DAP) and macro recording are still marked experimental in the keymap docs
- No GUI front end yet; the project says it would eventually like to prototype a WebGPU-based one
Best For
Developers who want a fast, modal terminal editor with IDE-style features on day one and would rather not maintain an editor configuration or plugin list.
Neovim
A community fork of Vim that modernises the codebase, adds a first-class Lua API, built-in LSP client and tree-sitter, and supports external GUIs, licensed under Apache 2.0 (with Vim-licensed parts).
Pros
- Keeps Vim's editing model and keybindings, so Vim skills, tutorials and decades of documentation carry over
- The largest plugin ecosystem of any terminal editor, configured and extended in Lua with a full API
- Built-in plugin manager since 0.12: vim.pack installs plugins from Git and pins them in a lockfile you can commit
- Built-in LSP client with vim.lsp.config()/vim.lsp.enable() (0.11) and default mappings such as grn, grr and gra; 0.12 added inline completion and an 'autocomplete' option
- Regular stable releases: 0.12.0 on 29 March 2026 and patch releases through 0.12.6 on 9 October 2026, plus nightly builds
- Official binaries for Linux, macOS and Windows on both x86_64 and arm64, and an embeddable core that many GUIs and editor integrations build on
Cons
- A useful IDE-like setup still means choosing and maintaining plugins (parsers, pickers, completion, file tree)
- Only a handful of tree-sitter parsers ship in core (C, Diff, Lua, Markdown, Vimscript, Vimdoc and query); others come from nvim-treesitter or manual installs
- vim.pack is labelled experimental in its own docs, though 'stable enough for daily use'
- Multiple cursors are not in stable 0.12: multicursor is ticked as done on the 0.13 roadmap, but 0.13 is not released yet
- Configuration drift is real: plugin APIs change and large configs need regular upkeep
Best For
Developers who know Vim or want to, and want an editor they can extend into exactly the tool they need, with a huge plugin ecosystem and predictable releases.
Editing model: selection first vs verb first
This is the difference that decides most switches, so start here. Neovim inherits Vim's grammar: an operator followed by a motion or text object. You type d then w to delete a word, or c then i( to change inside parentheses. You don't see what will be affected until the command runs, and you repeat edits with dot-repeat or macros. Helix follows Kakoune's selection-then-action model, which its own Migrating from Vim page sums up as: what you act on is selected first, and the action comes second. A cursor is just a one-character selection. You press w to select a word, see it highlighted, then press d. Multiple selections are a core primitive, not an add-on. You can split a selection on a regex, select every match in a file, or select syntax-tree nodes such as functions and arguments, then edit them all at once. For many refactors this replaces a macro with something you can see. The cost is muscle memory. Helix keys look like Vim's but behave differently often enough to trip you up for the first couple of weeks, and Helix offers no official Vim mode. Neovim users who want multiple cursors today use plugins. The 0.13 roadmap lists multicursor as done on master, but 0.13 had not shipped as of early November 2026.
Out-of-the-box features vs building your own editor
Helix's homepage pitch is IDE features with no additional configuration, and it largely delivers. Tree-sitter powers highlighting, indentation, textobjects and syntax-aware selection for about 276 languages in the release docs. Each language has its default language servers mapped in languages.toml, so once rust-analyzer or typescript-language-server is on your PATH, completion, go-to-definition, hover, rename, code actions and diagnostics just work. Space mode gives you pickers for files, buffers, the jumplist, changed files, symbols and diagnostics, with a hint popup listing every key. Helix 25.07 added a directory-explorer picker and EditorConfig support. Neovim has the same building blocks in core, wired differently. The built-in LSP client gained vim.lsp.config() and vim.lsp.enable() in 0.11, along with default mappings such as grn (rename), grr (references) and gra (code action). In 0.12 it gained inline completion, an 'autocomplete' option, :Undotree and :DiffTool. But core only bundles tree-sitter parsers for C, Diff, Lua, Markdown, Vimscript and Vimdoc, and there is no built-in fuzzy finder, so a comfortable setup still means picking plugins for parsers, pickers and usually completion. Expect an evening, or a starter distribution, before Neovim feels like an IDE. With Helix, expect about ten minutes installing language servers.
Extensibility: no plugins vs the biggest ecosystem
This is the hard line between the two. Helix has no plugin system. The FAQ on its homepage says one is intended but will take time. The most visible attempt, PR #8675 'Add Steel as an optional plugin system', was opened in October 2023, is still a draft, and was last updated on 22 October 2026 after hundreds of comments and commits. You can remap keys, pipe selections through shell commands and add languages in TOML, but you cannot add a Git UI, a test runner, a debugger front end or an AI completion plugin. If your workflow depends on any of those inside the editor, Helix is out today. Neovim is the opposite. Lua has full access to buffers, windows, the LSP client, tree-sitter and the UI protocol, and the ecosystem covers almost any workflow you can name. 0.12 added vim.pack, a built-in plugin manager that installs plugins from Git repositories, follows semver tags and writes a JSON lockfile you can commit, so you no longer need a third-party manager to get started. Its docs still call it experimental, though 'stable enough for daily use'. The trade-off is maintenance. Plugins change APIs, configs grow, and a broken update can cost you a morning. Helix avoids that whole category of problem by having nothing to break.
Releases, platforms and project health
Neovim ships on a predictable rhythm. 0.11.0 came out on 26 March 2025, 0.12.0 on 29 March 2026, and 0.12 patch releases continued through 0.12.6 on 9 October 2026, with nightly builds every day. Official binaries cover Linux x86_64 and arm64 (tarball and AppImage), macOS x86_64 and arm64 (10.15 or later) and Windows x86_64 and arm64 (MSI and zip, Windows 8 or later). The public roadmap names the next release, 0.13 'Batteries Included', and ticks off multicursor, an image API and a new directory browser that replaces netrw. Helix follows a calendar-versioned release model, but there has been no tagged release since 25.07.1 on 18 July 2025. The master branch is clearly alive: the GitHub API shows a steady stream of commits through June to September 2026, including new language servers and grammar updates. But anyone installing from a package manager is running 2025 code, and the install docs say that to get the latest version you must build from source. 25.07 itself drew changes from 195 contributors and included a breaking rewrite of command-line parsing, so read the changelog before upgrading keymaps. Both projects are funded through OpenCollective rather than by a company.
Switching cost and who should move
From Vim or Neovim to Helix, the hard part is unlearning, not configuration. Your init.lua does not carry over (Helix config is TOML), plugins have no equivalent, and operator-then-motion habits fight the selection model. Run the built-in tutor with hx --tutor and give it a real week before deciding. People who make the switch usually cite the absence of configuration upkeep and the visibility of multi-cursor edits. People who go back usually cite one missing plugin or Vim muscle memory. From Helix, or from no modal editor, to Neovim, the editing grammar is the steeper climb. Plan your first setup deliberately: a starter configuration or a short list of plugins (a parser manager, a picker, a completion source) managed with vim.pack keeps things understandable. On remote servers and in containers, both are single binaries that run fine over SSH and inside tmux or Zellij. Helix needs its runtime directory next to the binary for grammars and queries. Neovim's core runs anywhere, but your plugins need Git and network access to install. If your team pairs in Vim keybindings or shares dotfiles, Neovim is the lower-friction choice. If you are picking just for yourself and want the editor to stay out of your way, try Helix first.
Verdict
Choose Helix if you want a modal editor that is useful the moment you install it. Tree-sitter highlighting and textobjects, language-server features, fuzzy pickers, surround and themes are all built in, and the selection-first model with multiple cursors makes multi-site edits visible before you commit to them. It suits developers who are new to modal editing, or who are tired of maintaining a plugin list. Go in knowing two things. There is no plugin system, and the Steel plugin PR is still an open draft three years after it was opened. And the newest tagged release is 25.07.1 from July 2025, so if you want current fixes you will be building from master. Choose Neovim if you already think in Vim motions, need a specific plugin (a debugger UI, a test runner, a Git interface, an AI assistant), or want to tune the editor deeply in Lua. Neovim 0.12 narrowed the setup gap with vim.pack, default LSP mappings and inline completion, and it ships stable releases on a predictable schedule. For a team standard or a long-lived setup, Neovim is the safer bet. For a personal editor that just works with a little relearning, Helix is the better experience.