Helix

Helix is a modal terminal editor written in Rust. Modal like Vim, but with a selection-first model (inspired by Kakoune) and built-in LSP, Tree-sitter, and DAP with no plugins or configuration required.

The Big Idea

Vim is “verb + noun”: d then w deletes a word. Helix and Kakoune flip it to noun + verb: select a word with w, then d deletes the selection. You always see what you’re about to operate on.

The result is more discoverable (the editor shows the selection as you build it) and supports natural multi-cursor editing.

Modes

Key	Action
Esc	return to normal mode (from any other mode)
i	insert before selection
a	insert after selection (append)
I	insert at start of line
A	insert at end of line
o	open new line below, enter insert
O	open new line above, enter insert
v	enter select (extend) mode
:	enter command line

Movement

Movements also extend the selection (selection-first model). Hold v (or be in select mode) to keep the current head anchored as you grow the range.

Key	Action
h / j / k / l	left / down / up / right
w / b / e	next-word-start / prev-word-start / next-word-end
W / B / E	WORD variants (whitespace-delimited)
f<c> / F<c>	find next / previous occurrence of c on line
t<c> / T<c>	till next / previous occurrence of c
;	repeat last f / t
Alt-;	repeat last f / t in opposite direction
gg	jump to file start
ge	jump to file end
gl / gh	line end / line start
gs	first non-blank on line
Ctrl-d / Ctrl-u	half-page down / up
Ctrl-f / Ctrl-b	full-page down / up
Ctrl-i / Ctrl-o	jump forward / backward through jump list
Alt-.	repeat last motion

Selection

The headline feature. Build selections with motions, then a single verb acts on whatever is highlighted. Multiple selections are first-class; many bindings split, merge, or filter them.

Key	Action
x	select whole current line (extend down with repeated x)
X	extend selection backward by line
%	select whole file
s	regex-select within current selection (interactive)
S	regex-split current selection into multiple cursors
Alt-s	split selection on newlines (one cursor per line)
;	collapse selection to single point at cursor
Alt-;	flip selection anchor / head
,	keep only the primary selection
Alt-,	remove the primary selection (keep the rest)
( / )	previous / next selection in the multi-selection list
Alt-( / Alt-)	rotate selection contents backward / forward
_	trim whitespace from selection edges
Alt-_	merge consecutive selections into one

Editing

Key	Action
d	delete (cut) selection
c	change selection (delete + insert mode)
y	yank (copy) selection
p	paste after selection
P	paste before selection
R	replace selection with yanked content
r<c>	replace each character of selection with c
"<reg>	select register reg for next yank / paste
u	undo
U	redo
.	repeat last change
J	join selected lines
Alt-J	join lines without adding spaces
~	toggle case of selection
backtick	lowercase selection
Alt + backtick	uppercase selection
>	indent
<	dedent
=	auto-format selection (via LSP / formatter)
Ctrl-a / Ctrl-x	increment / decrement number under cursor

Multi-Cursor

Key	Action
C	add cursor below current selection
Alt-C	add cursor above
S	regex-split selection into one cursor per match
s	select all regex matches inside selection (one cursor each)
Alt-s	split on newlines
,	keep only the primary selection (drop others)
&	align all selections to the same column
( / )	previous / next selection (primary jumps)

Search

Key	Action
/	search forward
?	search backward
n	next match
N	previous match
*	set search pattern from current selection
Alt-*	clear search register
Space /	global search across the workspace

Goto Menu (g)

The g prefix opens a one-key menu. ga is “goto last accessed file”; gd is LSP go-to-definition.

Key	Action
gg	file start
ge	file end
gh / gl	line start / end
gs	first non-blank on line
gd	goto definition (LSP)
gD	goto declaration (LSP)
gy	goto type definition (LSP)
gr	goto references (LSP)
gi	goto implementation (LSP)
ga	goto last accessed file
gm	goto last modified file
gn / gp	next / previous buffer
gt / gb	top / bottom of screen
gc	center cursor’s line on screen (alt: zz)

Space Menu (LSP / Pickers)

The Space prefix opens the picker / LSP menu. The most-used shortcut is Space f (file picker, fuzzy).

Key	Action
Space f	file picker (fuzzy)
Space F	file picker, current working directory only
Space b	buffer picker
Space j	jumplist picker
Space s	symbol picker (current document)
Space S	symbol picker (workspace)
Space d	diagnostics picker (current document)
Space D	diagnostics picker (workspace)
Space /	global search (workspace)
Space '	re-open last picker
Space r	LSP rename symbol
Space a	LSP code action menu
Space k	LSP hover (signature, docs)
Space h	LSP signature help in insert mode
Space p	paste from system clipboard after
Space P	paste from system clipboard before
Space y	yank to system clipboard
Space Y	yank selection to clipboard, keep editor register too
Space R	replace with system-clipboard contents
Space c	comment selection (toggle line comments)
Space C	comment selection (block comment)
Space w	window-management sub-menu (see Windows)

Windows / Splits

Helix uses a Space w sub-menu (or Ctrl-w) for window operations. Splits and buffer-per-pane.

Key	Action
Ctrl-w s / Space w s	horizontal split
Ctrl-w v / Space w v	vertical split
Ctrl-w q / Space w q	close current window
Ctrl-w h / j / k / l	focus split left / down / up / right
Ctrl-w H / J / K / L	move current window left / down / up / right
Ctrl-w w	cycle focus through splits
Ctrl-w o	close every split except current
Ctrl-w t	move current buffer to a new tab
gn / gp	next / previous buffer (no split change)

View / Scroll

The z (or Z) prefix scrolls without moving the cursor.

Key	Action
zz	center cursor’s line on screen
zt	move cursor’s line to top of view
zb	move cursor’s line to bottom of view
zj / zk	scroll down / up one line (cursor follows)
Zj / Zk	scroll down / up (cursor stays in view)
Ctrl-y / Ctrl-e	scroll up / down one line

Tree-sitter Motions

Syntactic navigation. Helix knows the parse tree, so motions move by syntactic node rather than by character / word.

Key	Action
Alt-o	expand selection to parent syntax node
Alt-i	shrink selection to first child node
Alt-n	next sibling node
Alt-p	previous sibling node
[f / ]f	previous / next function definition
[c / ]c	previous / next class
[a / ]a	previous / next argument
[t / ]t	previous / next test
mi<obj>	select inside textobject (e.g. miw inside word, mi( inside parens)
ma<obj>	select around textobject (with delimiters)

Command Mode (:)

Command	Action
:w	write current buffer
:wa	write all buffers
:q	quit (fails if buffer is modified)
:q!	quit, discarding changes
:wq	write and quit
:o <path> / :open <path>	open file at path
:bc / :buffer-close	close current buffer
:bn / :bp	next / previous buffer
:format	format current buffer via LSP
:reload	reload buffer from disk
:reload-all	reload every open buffer
:config-reload	reload config.toml live
:set <key> <value>	set an option for this session
:theme <name>	switch theme
:lsp-restart	restart the language server
:lsp-stop	stop the language server
:show-directory	print current working directory
:cd <path>	change working directory

Macros and Registers

Helix has Vim-style macros with explicit registers.

Key	Action
Q	start / stop recording a macro
q<reg>	replay macro stored in register reg
"<reg>	select a register for the next yank / paste
Space y	yank to * (system clipboard)
Space p	paste from * (system clipboard)

Discovery

Command	Action
hx --tutor	launch the interactive tutor
hx --health	check language-server / formatter availability
:tutor	same as --tutor, in-editor
:help	open keymap help
hold any prefix key	hint popup lists what each next key does

Built-In Without Configuration

Out of the box, with no plugins. The list below is the entire setup that takes a Neovim user a weekend to assemble (LSP, Tree-sitter, DAP, fuzzy pickers, multi-cursor) and it ships with the binary. Install a language server and the rest just works:

• LSP for many languages, install the language server, Helix uses it. Goto definition, hover, rename, code actions, completions.

• Tree-sitter, syntax highlighting, indentation, motion by syntactic node.

• DAP (Debug Adapter Protocol), step debugging.

• Built-in pickers for files, buffers, symbols, diagnostics, git log, registers.

Files

Configuration is TOML, not Lua or Vimscript. Three files cover the whole surface area: editor behavior in config.toml, language servers and formatters in languages.toml, and themes in themes/. There is no plugin system in stable as of 2026.

• ~/.config/helix/config.toml, main config.

• ~/.config/helix/languages.toml, language servers and formatters.

• ~/.config/helix/themes/, custom themes.

Configuration is TOML, not Lua / Vimscript. There’s no plugin system yet (a plugin system is in progress as of 2026); you customize what exists, not what doesn’t.

Strengths

What Helix gets right that Vim and Neovim don’t. The headline is zero-setup productivity; the editor is fully usable the first time you launch it, with no plugin manager, no Lua scripting, and no copy-paste from someone else’s dotfiles.

• Zero-setup productivity, works on day one.

• Modern out-of-the-box, LSP, Tree-sitter, multi-cursor, fuzzy pickers all built in.

• Fast, Rust; instant startup.

• Discoverable modal, the noun-verb model exposes selections as you go.

Weaknesses

What you give up by picking the new modal editor. The plugin gap is the biggest one. If you depend on a specific Neovim plugin, Helix won’t have it, and the noun-verb model takes retraining for users coming from Vim.

• No plugin system in stable as of 2026 (in progress).

• Smaller ecosystem than Vim / Neovim.

• Different muscle memory, noun-verb retraining for Vim users.

• TOML config is less powerful than Lua scripting.

When to Pick Helix

The default for new modal users in 2026, and the path of least resistance for anyone who wants the modern feature set without becoming a Neovim configurator. If you need deep customization or specific Neovim plugins, Helix isn’t there yet.

• You want modal editing without spending a weekend on configuration.

• You like the Kakoune selection-first idea.

• You want LSP / Tree-sitter / multi-cursor as defaults, not plugins.

• You’re new to modal editing and want a productive Day 1.

If you need deep customization or specific Neovim plugins, Helix isn’t there yet; but it’s the best default modal editor for many users in 2026.