helix-editor.com

Helix is a terminal-based, modal text editor built in Rust. It is described on its official site as "a post-modern modal text editor," and it is aimed at developers who want modern editing features—multiple selections, syntax-aware navigation, and language server support—without assembling a large plugin configuration. It runs in a plain terminal and is designed to work over ssh or tmux.

Core editing model

Helix treats multiple selections as a core editing primitive, inspired by Kakoune. Instead of selecting text and then applying a command, commands operate on selections, which allows concurrent editing across several places in a file at once. This is the main conceptual difference from Vim-style editing, where multiple cursors are typically an add-on rather than the base model.

Built-in language intelligence

Two integrations do most of the heavy lifting:

• Tree-sitter produces error-tolerant syntax trees. Helix uses these for syntax highlighting, indent calculation, and code navigation, and lets you select syntax tree nodes (functions, classes, comments) rather than plain text ranges.
• Language server support provides language-specific auto-completion, goto definition, documentation, and diagnostics. The site states this works with no additional configuration.

What else is included

Helix ships with a set of features that would otherwise require plugins in other editors:

• Fuzzy finder for jumping to files and symbols
• Project-wide search
• Themes
• Auto-closing bracket pairs
• Surround integration

Because it is built in Rust and runs in the terminal, there is no Electron, VimScript, or JavaScript layer. The site notes this is relevant for battery life and for use over ssh, tmux, or a plain terminal.

How it compares

Current limitations

Two things are explicitly not available yet, according to the site's FAQ:

• No plugin system. One is intended eventually, but the site says it will take time.
• No GUI frontend yet. A WebGPU-based alternative frontend is something the project would like to prototype; the site points to a GitHub discussion rather than a release.

Who it is for

Helix fits if you work primarily in a terminal, want modal editing with multiple selections as the default model, and prefer built-in language features over a plugin ecosystem. If you depend on a mature plugin system or a graphical interface today, those are the two areas the project itself flags as unfinished.

Helix is a terminal-based modal text editor built in Rust. Its feature set centers on multiple selections as a core editing primitive, Tree-sitter-based syntax understanding, and built-in language server support — all without a plugin system or additional configuration. If you want an editor that works over SSH, tmux, or a plain terminal with modern defaults and minimal setup, Helix's features are designed for exactly that.

Multiple selections as a core primitive

Helix treats multiple cursors and multiple selections as a fundamental editing concept rather than an add-on. Inspired by Kakoune, commands operate on selections, which lets you edit concurrent parts of your code at once.

In practice, this means you select what you want to change first, then act on it — the selection comes before the command. This is a different mental model from Vim, where you typically issue an operator and then a motion.

Tree-sitter integration

Helix uses Tree-sitter to build error-tolerant, robust syntax trees. This powers several features:

• Syntax highlighting that stays accurate even in incomplete or malformed code
• Indent calculation based on the actual syntax structure
• Code navigation and selection of syntax tree nodes instead of plain text

Because the trees are error-tolerant, highlighting and navigation still work while you're mid-edit and the code doesn't fully parse.

Language server support

Helix integrates the Language Server Protocol with no additional configuration. For supported languages, this provides:

• Auto completion
• Go to definition
• Documentation lookup
• Diagnostics
• Other IDE-style features

The key detail is "no additional configuration" — language server support is built in rather than assembled through plugins.

Built-in modern features

Helix ships with a set of conveniences already included:

Platform and runtime characteristics

Helix is built in Rust and runs in the terminal. It explicitly avoids Electron, VimScript, and JavaScript. This means you can use it over SSH, tmux, or a plain terminal, and it is lightweight enough to be considerate of laptop battery life.

What Helix does not have (yet)

Two limitations are worth knowing before you commit:

• No plugin system. The project intends to add one eventually, but it will take time.
• No GUI frontend yet. A WebGPU-based alternative frontend is something the project would like to prototype, but it does not exist today.

How it differs from Kakoune and Vim

Helix's feature choices are best understood in contrast:

• Versus Kakoune: Kakoune is composable by design and relies on external tooling for splits and language server support. Helix integrates more of this directly, and uses Tree-sitter for highlighting and code analysis.
• Versus Vim: Helix started from scratch, making breaking changes based on Vim experience. The result is a smaller codebase, modern defaults, less config-file fiddling, and an easier start for people who have never used a modal editor.

Who these features suit

Helix is a reasonable fit if you want multiple selections, Tree-sitter syntax awareness, and language server features working out of the box in a terminal, and you don't need a plugin ecosystem or a GUI right now. If your workflow depends on a mature plugin system or a graphical frontend, those are the gaps to weigh against the built-in feature set.

No. Helix does not currently have a plugin system. The project's own FAQ states that while there is no plugin system available today, the maintainers do intend to add one eventually — but it "will take some time," and the discussion is tracked on GitHub rather than on a published roadmap with dates.

That single fact answers the direct question, but it raises a practical one: if you can't extend Helix with plugins, what can you actually configure or rely on? The rest of this page covers what Helix ships with instead, and how to judge whether the missing plugin system matters for your workflow.

What "no plugin system" means in practice

In editors like Vim, Neovim, or VS Code, a large share of functionality arrives through third-party plugins: file trees, Git integration, fuzzy finders, language-specific tooling, and so on. Helix takes the opposite approach. Its FAQ explicitly contrasts itself with Kakoune by saying Helix "chooses to integrate more" — features that other editors delegate to external tooling or plugins are built in.

So the absence of plugins is not the same as the absence of features. It means you cannot add arbitrary third-party functionality, and you cannot write your own extensions in a scripting language, because there is no plugin API to target.

What Helix provides without plugins

According to the project's homepage, the following are built-in:

• Multiple selections — multiple cursors as a core editing primitive, inspired by Kakoune, where commands manipulate selections to allow concurrent editing.
• Tree-sitter integration — error-tolerant syntax trees used for syntax highlighting, indent calculation, and code navigation.
• Structural code manipulation — navigate and select functions, classes, comments, and other syntax tree nodes rather than plain text.
• Language server support — auto-completion, goto definition, documentation, and diagnostics, described as requiring "no additional configuration."
• Built-in utilities — fuzzy finder for files and symbols, project-wide search, themes, auto-closing bracket pairs, and surround integration.

The implementation detail matters here: Helix is built in Rust for the terminal, with no Electron, no VimScript, and no JavaScript. It runs over ssh, tmux, or a plain terminal. That design choice is part of why there is no scripting-based plugin layer — there is no embedded scripting runtime to extend.

How this compares to editors with plugin ecosystems

The Kakoune comparison is the most useful one, because both editors share the multiple-selection editing model. The difference, per Helix's FAQ, is that Kakoune expects you to assemble functionality from external tools, while Helix bundles it. If you are coming from Kakoune, you gain built-ins but lose the composability that comes from wiring tools together yourself.

Should the missing plugin system change your decision?

It depends on what you need:

• Choose Helix if the built-in set covers your work — modal editing with multiple selections, Tree-sitter highlighting and navigation, and LSP features without configuration. The FAQ's blunt answer to "Is it any good?" is simply "Yes."
• Avoid Helix for now if your workflow depends on a specific plugin, on writing your own extensions, or on a GUI. A GUI frontend is also only planned: the FAQ says "eventually, yes," with interest in prototyping a WebGPU-based alternative frontend, discussed on GitHub.

What to watch if you're waiting for plugins

Two things are explicitly framed as future work rather than shipped features: the plugin system and the GUI frontend. Both are described as eventual goals with ongoing GitHub discussion, and the plugin entry adds the caveat that it "will take some time." There is no stated timeline in the project's own material, so treat any specific date you see elsewhere as unverified.

If plugin support is a hard requirement for adopting an editor, Helix is not the right fit yet. If you mainly want a terminal editor with strong built-in defaults and less configuration fiddling, the missing plugin system may not affect you at all.

Helix is a modal terminal editor that differs from Vim and Neovim mainly by being written from scratch with modern defaults and a smaller codebase, and from Kakoune mainly by integrating more features directly instead of relying on external tooling. If you want a modal editor that works well over SSH or tmux with less configuration, Helix is designed for that. If you depend on a mature plugin ecosystem or a GUI, Helix may not fit yet, since it currently has no plugin system and no GUI frontend.

Helix vs Vim and Neovim

Helix’s own FAQ states that by starting from scratch, the project learned from Vim experience and made breaking changes. The result, according to the site, is a much smaller codebase and a modern set of defaults.

Key differences from the site:

• Smaller codebase and modern defaults: Helix is built in Rust for the terminal, with no Electron, no VimScript, and no JavaScript.
• Easier for modal-editor newcomers: The site says it’s easier to get started if you’ve never used a modal editor before.
• Less config fiddling: The site states there is much less fiddling with config files compared to Vim.
• Built-in features: Helix includes a fuzzy finder for files and symbols, project-wide search, themes, auto-closing bracket pairs, and surround integration.
• Multiple selections as a core primitive: Inspired by Kakoune, commands manipulate selections, allowing concurrent code editing.
• Tree-sitter integration: Used for syntax highlighting, indent calculation, and code navigation.
• Language server support: Language-specific auto-completion, goto definition, documentation, diagnostics, and other IDE features with no additional configuration.

For someone coming from Vim or Neovim, the practical trade-off is: you get a more integrated, modern-default experience out of the box, but you give up the extensive plugin and configuration ecosystem that Vim and Neovim users often rely on.

Helix vs Kakoune

The site’s FAQ directly addresses this: Helix differs from Kakoune mainly by having more things built-in.

• Kakoune: Composable by design, relying on external tooling to manage splits and provide language server support.
• Helix: Chooses to integrate more, including language server support with no additional configuration.
• Tree-sitter: Helix uses Tree-sitter for highlighting and code analysis.

So if you like Kakoune’s selection-first editing model but want splits and LSP support without assembling external tools, Helix is the more integrated option. If you prefer Kakoune’s composable philosophy and external tooling, Kakoune remains the fit.

What Helix does not have (as of the site’s FAQ)

• No plugin system currently: The site says there is currently no plugin system available, though there are intentions to eventually have one, and it will take some time.
• No GUI frontend yet: The site says a GUI is planned eventually, with interest in prototyping a WebGPU-based alternative frontend.

When Helix is a good fit

Based on the site’s description, Helix is worth considering if:

• You want a modal editor that runs in the terminal and works over SSH, tmux, or a plain terminal.
• You want modern defaults and built-in features without extensive configuration.
• You want multiple selections, Tree-sitter-based syntax features, and LSP support without extra setup.
• You are new to modal editors and want an easier starting point.

When to choose Vim, Neovim, or Kakoune instead

• Choose Vim or Neovim if you depend on a large plugin ecosystem, VimScript, or extensive configuration flexibility.
• Choose Kakoune if you prefer a composable design where splits and LSP are handled by external tooling.
• Wait on Helix if you need a plugin system or a GUI frontend today, since the site indicates these are planned but not currently available.

Quick comparison

The site’s FAQ sums up the positioning with a joke: “Post-modern?! It’s a joke. If Neovim is the modern Vim, then Helix is post-modern.”

No, Helix does not currently have a GUI frontend. It runs in the terminal, and the project has said a GUI is planned "eventually" — specifically, they would like to prototype a WebGPU-based alternative frontend. So if you need a graphical window today, Helix is not the right fit yet; if you are comfortable working in a terminal, it is usable now.

What Helix runs in today

Helix is built in Rust for the terminal. The site explicitly notes there is no Electron, no VimScript, and no JavaScript. That means:

• It works over ssh, inside tmux, or in a plain terminal.
• There is no separate windowed application to install or launch.
• Because it is terminal-native and lightweight, the site claims your laptop battery life will benefit.

The practical implication: your "frontend" is whatever terminal emulator you already use. Setup effort goes into the terminal and shell, not into a GUI app.

The GUI plan

The site's FAQ addresses this directly. Asked whether there are plans for a GUI frontend, the answer is "Eventually, yes!" with the stated intent to prototype a WebGPU-based alternative frontend, pointing to a GitHub discussion for details.

Two things worth being precise about:

• This is a stated intention, not a shipped feature. There is no release date or downloadable GUI build described on the site.
• "Alternative frontend" suggests a separate interface layer rather than a rewrite of the editor core, but the site does not specify architecture beyond the WebGPU mention.

If a GUI is a hard requirement for your workflow, treat this as "not available" rather than "coming soon."

How this compares to the plugin situation

The GUI question often comes up alongside plugins, and the answers have a similar shape. Helix currently has no plugin system, though the project intends to have one eventually and notes it will take time. So both a GUI and plugins are acknowledged as future work rather than present capabilities.

This matters for evaluating Helix: it is designed to integrate more functionality directly rather than relying on external tooling. The site contrasts this with Kakoune, which is composable by design and depends on external tools for splits and language server support. Helix instead builds more in.

What you get without a GUI

Since the interface is the terminal, the feature set is what determines whether Helix works for you. Built-in capabilities include:

• Multiple selections — multiple cursors as a core editing primitive, inspired by Kakoune, where commands manipulate selections for concurrent editing.
• Tree-sitter integration — error-tolerant syntax trees for syntax highlighting, indent calculation, and code navigation.
• Code manipulation — navigate and select functions, classes, comments, and syntax tree nodes rather than plain text.
• Language server support — auto completion, goto definition, documentation, and diagnostics with no additional configuration.
• Modern built-in features — fuzzy finder for files and symbols, project-wide search, themes, auto-closing bracket pairs, and surround integration.

Choosing based on your constraints

The site also notes that Helix differs from Vim by starting from scratch, making breaking changes, and producing a smaller codebase with modern defaults — easier for people who have never used a modal editor. That framing is about defaults, not about the interface being graphical.

If you want to try it

Install it and run it in your terminal. The expected result is a modal editor operating entirely within your existing terminal session — no separate window appears. The main friction point to expect is that everything, including file navigation and search, happens through the terminal and Helix's own keybindings rather than menus or a mouse-driven GUI.