Install

# Debian 13 / Ubuntu 25.04+
sudo apt install helix

# Arch
sudo pacman -S helix

# Fedora
sudo dnf copr enable varlad/helix
sudo dnf install helix

# macOS
brew install helix

# Or with mise / cargo / a release binary
mise use helix@latest
cargo install --locked helix-term

# Verify
hx --version
hx --health           # check LSP servers, themes, runtime files

hx --health is worth running once: it tells you which LSP servers / formatters Helix would launch for each language and which ones aren't installed.

The selection-first model

In Vim: diw = delete inside word (the verb d applies to the noun iw).

In Helix: miwd = select inside word, delete (you select the noun, then verb the verb).

The reversal matters more than it sounds: you always see what you're about to operate on. Multi-cursor edits, repeated transformations, and complex selections become natural because the editor shows the selection live as you build it.

The first commands worth knowing

# Mode switches
i                  insert before cursor
a                  insert after cursor
o / O              new line below / above
v                  enter visual / extend selection mode
Esc                back to normal mode

# Movement
h j k l            left, down, up, right
w / b / e          word forward / back / end
gg / ge            file start / end
gh / gl            line start / end
%                  match brace / bracket

# Selections (the part that's new from Vim)
x                  select line
miw                select inside word
ma(                select inside parens
mab                select around block

# Operations on the selection
d                  delete
c                  change (delete + insert mode)
y / p              yank / paste
~                  toggle case
>                  indent right
=                  format
J                  join lines

# Multi-cursor
C                  add cursor on next line at same column
s                  select all occurrences of pattern inside current selection
&                  align cursors

Helix's space-mode is the catch-all command picker (analogous to VSCode's Ctrl-Shift-P):

space f            file picker (fuzzy across the repo)
space /            global search (live grep, requires ripgrep installed)
space b            buffer list
space j            jump list (where the cursor has been)
space p            paste from system clipboard
space y            yank to system clipboard
space k            LSP hover docs
space r            rename symbol via LSP
space a            code actions via LSP
:                  command line (write, quit, set, etc.)

LSP servers

Helix ships with default LSP configuration for ~100 languages. You install the language server binary; Helix launches it automatically when opening a matching file:

npm i -g typescript typescript-language-server
pip install python-lsp-server[all]
rustup component add rust-analyzer
go install golang.org/x/tools/gopls@latest

Open a file in that language; Helix starts the LSP, and goto-definition (gd), find-references (gr), hover (space k), rename (space r), code actions (space a), and diagnostics all work.

Config

Two files under ~/.config/helix/ (or %AppData%\helix\ on Windows):

# config.toml
theme = "github_dark"

[editor]
line-number = "relative"
mouse = true
true-color = true
auto-format = true
auto-save = false
bufferline = "multiple"
shell = ["bash", "-c"]

[editor.cursor-shape]
insert  = "bar"
normal  = "block"
select  = "underline"

[editor.statusline]
left   = ["mode", "spinner", "version-control"]
center = ["file-name"]
right  = ["diagnostics", "selections", "position", "file-encoding", "file-line-ending"]

[editor.lsp]
display-messages    = true
display-inlay-hints = true

[editor.indent-guides]
render = true
character = "▏"

[keys.normal]
C-s = ":w"
C-q = ":quit-all"
"`" = "match_brackets"

[keys.normal."space"]
e = "file_picker_in_current_buffer_directory"
# languages.toml — per-language overrides
[[language]]
name = "rust"
auto-format = true
formatter = { command = "rustfmt" }

[[language]]
name = "python"
formatter = { command = "ruff", args = ["format", "-"] }
language-servers = ["pylsp", "ruff"]

[[language]]
name = "typescript"
formatter = { command = "prettier", args = ["--parser", "typescript"] }

[language-server.ruff]
command = "ruff"
args = ["server"]

Themes

Helix bundles ~100 themes. Pick one with :theme <name> — live preview as you type. Persist via theme = "..." in config. Common picks:

  • github_dark / github_light — GitHub's own theme palette
  • catppuccin_mocha — mellow purple-tinged dark
  • tokyonight — same energy as the VSCode theme
  • dracula — the classic
  • nord — cool greys

What Helix doesn't have

  • Plugin system. 25.x adds a Steel-based scripting language and a plugin system, but it's still maturing; the philosophy is "ship the obvious features built-in, don't outsource them to a plugin ecosystem."
  • Vim-compatible keys. Muscle memory transfers about 70%, but the verb-first vs noun-first reversal means some shortcuts genuinely differ. There's no vim-mode.
  • GUI frontend. Terminal only (Helix in a GTK/Tauri shell is a community fork, not part of upstream).

Migration tips from Vim

  1. :tutor walks through the differences in 30 minutes; do it once.
  2. Map ; to insert mode if "i means 'inside'" trips you up (; = "insert_mode" in [keys.normal]).
  3. Stop reaching for plugins — the equivalent functionality is in space-mode or a built-in command. Spend an hour learning the built-ins before customizing.
  4. Read the official docs end-to-end. They're maybe 30 pages and cover everything.