Helix User Guide

Helix is a modal text editor for the terminal, written in Rust. Its editing model is heavily inspired by Kakoune and Neovim: you select first, then act. Helix ships with multiple-selection editing, built-in Language Server Protocol (LSP) support, smart incremental syntax highlighting via tree-sitter, and a debugger client — all configured through plain TOML files, with no plugins or external dependencies required to get started.

This guide takes you from installation through everyday editing, multi-cursor workflows, language-server features, configuration, and a complete keybinding and command reference.

Note

The Helix binary is named hx. A few package managers (notably Arch's extra repository) install it as helix instead. If hx is not found after installation, try helix.

Table of Contents

1. Quick Start
2. Installation
3. Core Concepts
4. Everyday Editing
5. Multiple Selections
6. Search and Replace
7. Textobjects and Surround
8. Working with Files, Buffers, and Splits
9. Pickers and Fuzzy Finding
10. Language Server Features
11. The Command Line
12. Shell Integration
13. Registers and Macros
14. Configuration
15. Key Remapping
16. Themes
17. Configuring Languages and Language Servers
18. Workspace Trust
19. Migrating from Vim
20. Troubleshooting
21. Frequently Asked Questions
22. Reference

1. Quick Start

If you just want to start editing immediately, here is the shortest path.

Tip

Helix ships with an interactive tutorial. Run hx --tutor (or :tutor from inside the editor) for a hands-on introduction. It is the single best way to learn the editing model, and most new users finish it in well under an hour.

Install, then open a file

macOS

brew install helix
hx myfile.txt

Linux (Fedora/RHEL)

sudo dnf install helix
hx myfile.txt

Windows

winget install Helix.Helix
hx myfile.txt

The five things to know first

Important

Helix is modal. When you launch it you are in normal mode, where letter keys run commands instead of inserting text. To type literal characters you must first enter insert mode with i, a, o, or similar. If keys seem to "do strange things," you are almost certainly in normal mode — press Esc and try i.

Verify your setup

hx --health

Config file: default
Language file: default
Log file: ~/.cache/helix/helix.log
Runtime directories: ~/.config/helix/runtime
...

The health check reports where Helix looks for runtime files, your config, and which language servers and grammars are available. Run it any time something is not working as expected.

2. Installation

The recommended way to install Helix is through your operating system's package manager. For the latest nightly features you can build from source.

Note

To take full advantage of Helix you should also install the language servers for the languages you use (for example rust-analyzer for Rust, gopls for Go, typescript-language-server for TypeScript). See Configuring Languages and Language Servers and the Language Server Configurations wiki.

Package managers

Linux

macOS

Windows

Pre-built binaries

Download a tarball from the GitHub Releases page. It contains an hx binary and a runtime directory.

1. Add hx to your $PATH.
2. Copy the runtime directory to a location Helix searches — a typical Linux/macOS location is ~/.config/helix/runtime.

# Example for a Linux/macOS tarball
mkdir -p ~/.config/helix
cp -r runtime ~/.config/helix/runtime

Tip

Run hx --health to see exactly which runtime directories Helix searches. You can override the default location by setting the HELIX_RUNTIME environment variable.

The Linux AppImage is another self-contained option:

chmod +x helix-*.AppImage
mkdir -p "$HOME/.local/bin"
mv helix-*.AppImage "$HOME/.local/bin/hx"   # ensure ~/.local/bin is in PATH

Building from source

Requirements:

• The Rust toolchain
• Git
• A C++14-compatible compiler (GCC or Clang) to build the tree-sitter grammars

git clone https://github.com/helix-editor/helix
cd helix
cargo install --path helix-term --locked

For an optimized build tuned to your CPU:

cargo install \
   --profile opt \
   --config 'build.rustflags=["-C", "target-cpu=native"]' \
   --path helix-term \
   --locked

Either command creates the hx executable and compiles the tree-sitter grammars into the local runtime folder.

Important

When building from source you must point Helix at its runtime files. On Linux/macOS, either export HELIX_RUNTIME or create a symlink:

export HELIX_RUNTIME=~/src/helix/runtime          # add to ~/.bashrc
# or
ln -Tsf $PWD/runtime ~/.config/helix/runtime

On Windows, set HELIX_RUNTIME via setx HELIX_RUNTIME "%userprofile%\src\helix\runtime" or create a directory junction in %appdata%\helix\.

Note

If you use the musl-libc standard library, set RUSTFLAGS="-C target-feature=-crt-static" during the build so tree-sitter grammars load correctly. To skip grammar building entirely, set HELIX_DISABLE_AUTO_GRAMMAR_BUILD. You can fetch and build grammars later with hx --grammar fetch and hx --grammar build.

After building, validate the installation with hx --health.

3. Core Concepts

Helix's power comes from a small set of consistent ideas. Understanding them up front makes everything else feel natural.

Modes

Helix is a modal editor — different modes interpret your keystrokes differently.

In addition, several minor modes are entered from normal mode for grouped commands: view (z), goto (g), match (m), window (Ctrl-w), and space (Space).

Selection-first editing

Inspired by Kakoune, Helix follows the selection → action model: you select what you want to act on (a word, a line, a paragraph) and then apply the action (delete, change, yank). This is the reverse of Vim's verb-then-object grammar.

A cursor is just a single-width selection. Whenever you move, you are really moving a selection — which is why every movement immediately shows you exactly what an action will affect.

Multiple selections

Multiple selections are a first-class, everyday tool — not an advanced feature. Instead of "find and replace all," the idiomatic Helix approach is to select every instance at once (one selection per match) and then edit them all simultaneously. See Multiple Selections.

Motions

Motions move the cursor or modify selections — w to the next word, f to find a character, gg to the top of the file. Because Helix is selection-first, motions in normal mode replace the selection, while the same motions in select mode extend it.

4. Everyday Editing

This section covers the bread-and-butter keys you will use constantly. The Reference contains the exhaustive tables; what follows is the working set.

Moving around

Note

Unlike Vim, f, F, t, and T are not confined to the current line — they search across line boundaries.

Entering insert mode

Press Esc to return to normal mode. Changes are grouped into a single undo step per insert-mode session.

Making changes

Tip

The "delete a word" muscle memory from Vim (dw) becomes wd in Helix: select the word first (w), then delete (d). Likewise cw → wc (or ec). See Migrating from Vim for a full mapping.

A first editing example

To change the word foo under your cursor to bar:

1. w (or e) to select the word.
2. c to change it — Helix deletes foo and enters insert mode.
3. Type bar.
4. Esc to return to normal mode.

5. Multiple Selections

Multiple selections are the defining Helix workflow. Master them and large edits become trivial.

Creating selections

The canonical "select all, edit all" workflow

To rename every occurrence of count to total across a file:

1. % — select the whole file.
2. s — open a regex prompt for selecting matches.
3. Type count and press Enter — now every match is its own selection.
4. c — change all selections at once; type total.
5. Esc, then , to collapse back to a single cursor.

Tip

Use s to narrow within a selection and S to split a selection. Combine with Alt-s to put a cursor on every line, then A to append at the end of every line simultaneously — a fast way to add a trailing character (like ; or ,) to many lines.

Note

The status line shows the primary selection index out of the total number of active selections (for example 2/14), so you always know how many cursors are live.

6. Search and Replace

Helix has no dedicated :substitute command — search-and-replace is expressed through multiple selections.

Searching

Search operates on the / register by default. The search prompt accepts full regular expressions. With editor.search.smart-case enabled (the default), a lowercase pattern is case-insensitive while a pattern containing an uppercase letter is case-sensitive.

Replacing across a selection

To replace foo with bar inside the current selection:

sfoo<ret>cbar<esc>,

• s opens a regex prompt and selects every match inside the selection.
• foo<ret> finalizes the matches (a cursor on each).
• c changes them; type bar.
• <esc> returns to normal mode; , keeps only the primary selection.

To do this for the whole file, prefix with % to select everything first:

%sfoo<ret>cbar<esc>,

Workspace-wide search

Press Space then / to run a global search across the workspace folder. Results open in a fuzzy picker. After you jump to a result, press Space then ' to reopen the same results list.

Tip

The global search picker uses regex (not fuzzy matching). Press Enter without typing a filter to reuse the contents of the search register — for example * Space-/ Enter searches for the word currently under the cursor.

7. Textobjects and Surround

Textobjects

Textobjects let you select structured pieces of text — a word, a paragraph, or, with tree-sitter, a function or class.

• mi<object> — select inside the object
• ma<object> — select around the object

Note

The structural textobjects (f, t, a, c, T, x) require an active tree-sitter grammar and a textobject query file for the language. Coverage varies by language — see the language support matrix.

You can also navigate by textobject using the unimpaired bindings: ]f/[f for next/previous function, ]t/[t for next/previous type, and so on.

Surround

Helix has built-in surround support similar to vim-surround:

Surround works with multiple selections too. To change every (use) to [use]:

1. % to select the whole file.
2. s, type use, Enter to put a selection on each match.
3. mr([ to replace the parentheses with square brackets.

8. Working with Files, Buffers, and Splits

Buffers

Buffers are in-memory representations of open files. You can have many open at once.

Saving and quitting

Splits (windows)

Press Ctrl-w to enter window mode, then:

You can also open files directly into a split from the command line: :vsplit <path> (:vs) or :hsplit <path> (:hs, :sp). Launch Helix with --vsplit or --hsplit to open multiple files side by side from the shell.

9. Pickers and Fuzzy Finding

Pickers are interactive selection windows. Most are reached from space mode.

Navigating and filtering

Within a picker, Tab/Shift-Tab (or arrow keys, or Ctrl-n/Ctrl-p) move between entries, Enter opens the selection, and Ctrl-s / Ctrl-v open it in a horizontal / vertical split. Ctrl-t toggles a preview. Esc closes the picker.

Most pickers use fzf-style fuzzy matching. When a picker has multiple columns you can target one column by prefixing its name with % (abbreviated to any prefix). For example, in the global search picker:

helix %p .toml !lang

searches for "helix" within files whose path ends in .toml but does not contain "lang".

Tip

Insert register contents into a picker query with Ctrl-r followed by a register name — for example Ctrl-r . inserts the current selection, and Ctrl-r % inserts the current file path.

10. Language Server Features

Helix has built-in LSP support. Install the language server for your language (see the wiki), make sure it is on your $PATH, and Helix uses it automatically for matching files.

Note

Mappings marked (LSP) in the keymap reference require an active language server, and those marked (TS) require a tree-sitter grammar for the file type.

Completion pops up automatically as you type (configurable). In the completion menu, Tab / Shift-Tab cycle entries, Enter accepts, and Ctrl-c rejects.

Useful LSP commands from the command line:

Debugging (DAP)

Helix includes a Debug Adapter Protocol client. Debug commands live under Space G (experimental): Space Gl launches a debug target, Space Gb toggles a breakpoint, Space Gc continues, Space Gi/Space Go/Space Gn step in/out/over. You can also start a session from the command line with :debug-start (:dbg).

11. The Command Line

Press : to open the command line and run a typable command like :write or :open. The command line supports quoting, flags, and expansions.

Quoting

Arguments are split on spaces and tabs. Wrap an argument containing spaces in single quotes or backticks to keep it together:

:open 'a b.txt'

Double quotes behave the same but additionally expand their contents (see below). On Unix you can also escape a space with a backslash: :open a\ b.txt.

Flags

Flags modify command behavior, for example :sort --reverse (or -r). Type - to see completions for the current command's flags. Use -- to mark the end of flags so following arguments are treated literally: :open -- -a.txt.

Expansions

Anything beginning with % is an expansion — Helix replaces it before running the command. The general form is %[<kind>]<open><contents><close>, where the delimiters can be (), [], {}, <>, or the single characters ', ", |.

With no <kind>, the expansion is a variable:

Other expansion kinds:

• Shell — %sh{...} runs the contents through your shell and inserts the output. Example: :echo %sh{date}.
• Unicode — %u{...} inserts a codepoint. Example: :echo %u{25CF} prints ●.
• Register — %reg{a} inserts the contents of register a.

:echo %sh{git blame -L %{cursor_line},+1 %{buffer_name}}

Caution

Expansions are only evaluated when you press Enter. To use a literal % in a shell command, double it: :echo %sh{date -u +'%%Y-%%m-%%d'}.

Note

A few commands pass their argument straight to the shell and do not interpret quotes (though expansions still apply): :insert-output, :append-output, :pipe, :pipe-to, and :run-shell-command.

12. Shell Integration

Helix can pipe selections through external commands directly from normal mode.

For example, to sort and de-duplicate selected lines, pipe them through sort -u with |. To filter selections to only those that match a pattern, use $ with grep -q pattern.

The equivalent command-line forms are :pipe, :pipe-to, :insert-output, :append-output, and :run-shell-command (:sh, :!).

Tip

The shell used for these commands is the editor.shell setting — ["sh", "-c"] on Unix and ["cmd", "/C"] on Windows by default. Override it in your config if you prefer a different shell.

13. Registers and Macros

Registers

Registers store text and other data, much like a multi-slot clipboard. Select a register with " before an action — "ay yanks to register a, "op pastes from register o.

Default registers used when none is specified:

Special registers:

Tip

Use the system clipboard directly via space mode: Space y yanks to the clipboard, Space p / Space P paste from it, and Space R replaces selections with its contents.

Macros

Macros are experimental. To record into register a: "aQ, perform your edits, then Q again to stop. Replay with "aq.

14. Configuration

Helix is configured with a config.toml file in your config directory:

• Linux / macOS: ~/.config/helix/config.toml
• Windows: %AppData%\helix\config.toml

Tip

Open your config instantly with :config-open. After editing, apply changes with :config-reload (no restart needed). On Unix you can also reload by sending USR1: pkill -USR1 hx.

A typical starter config:

theme = "onedark"

[editor]
line-number = "relative"
mouse = false
cursorline = true
color-modes = true
bufferline = "multiple"

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

[editor.file-picker]
hidden = false

[editor.indent-guides]
render = true

Common everyday settings

Note

The complete, every-key configuration reference — all [editor.*] subsections, statusline elements, gutters, soft-wrap, inline diagnostics, and more — lives in the Helix Admin Guide. This section covers the settings most users reach for first.

Project-local configuration

Place a config.toml and/or languages.toml inside a .helix/ directory at the root of a project. Those settings are merged on top of your global config and the built-in defaults, so you can tune behavior per repository.

my-project/
└── .helix/
    ├── config.toml
    └── languages.toml

Important

Loading project-local config and starting language servers can execute code defined by the repository. By default Helix protects you with Workspace Trust — you will be prompted before these features run in a new workspace.

You can also run Helix with a one-off config file: hx -c path/to/custom-config.toml.

15. Key Remapping

Helix supports one-way key remapping through config.toml. There are three kinds of things you can bind a key to:

• Static commands — built-in commands like move_char_left (see the static command reference).
• Typable commands — anything you can run from :, like :write.
• Macros — a sequence of keys, written as a string starting with @.

[keys.normal]
C-s = ":w"                                   # Ctrl-s to save
C-o = ":open ~/.config/helix/config.toml"    # open your config
a = "move_char_left"                          # rebind a single key
"C-S-esc" = "extend_line"                     # Ctrl-Shift-Escape
g = { a = "code_action" }                     # 'ga' shows code actions
"ret" = ["open_below", "normal_mode"]         # run multiple commands in order
"A-x" = "@x<A-d>"                             # a macro: select line, delete without yank

[keys.insert]
j = { k = "normal_mode" }                     # 'jk' exits insert mode

Modifiers and special keys

Modifiers use the prefixes C- (Ctrl), S- (Shift), and A- (Alt); combine with a dash, e.g. C-S-esc. The Super/Windows/Command key is Meta-, Cmd-, or Win- (requires a terminal supporting the enhanced keyboard protocol).

Special key names include space, ret (Enter), esc, tab, backspace, del, ins, home, end, pageup, pagedown, left/right/up/down, and lt/gt for </>. Disable a key by binding it to no_op.

Note

Within a macro string, wrap modifier keys in angle brackets — <A-x>, <C-x> — to distinguish them from the literal letters A or C. Also, - cannot follow a modifier; write Alt + - as A-minus.

Defining your own minor modes

You can nest bindings to create custom minor modes:

# A new minor mode bound to '+'
[keys.normal."+"]
m = ":run-shell-command make"
c = ":run-shell-command cargo build"
t = ":run-shell-command cargo test"

16. Themes

Set a theme at the top of config.toml, or switch at runtime with :theme <name>:

theme = "catppuccin_mocha"

You can configure separate light and dark themes; on terminals that report a light/dark preference, Helix switches automatically:

[theme]
dark = "catppuccin_frappe"
light = "catppuccin_latte"
# fallback = "catppuccin_frappe"   # used if the terminal expresses no preference

Creating your own theme

Create ~/.config/helix/themes/mytheme.toml (or %AppData%\helix\themes\ on Windows) and reference it as theme = "mytheme". Each line styles one scope:

"ui.background" = { bg = "#1e1e2e" }
"keyword" = { fg = "mauve", modifiers = ["bold"] }
"ui.text" = "#cdd6f4"

[palette]
mauve = "#cba6f7"

Colors are CSS hex strings (#RGB or #RRGGBB) or names from the [palette]. You can extend an existing theme with inherits = "boo_berry".

Note

The names default and base16_default are reserved built-ins and cannot be overridden. Helix does not support transparency (no alpha channel). The full list of themeable scopes (syntax and UI) is documented in the Helix Admin Guide.

17. Configuring Languages and Language Servers

Language-specific behavior — which language server to use, indentation, formatters, file-type detection — is set in languages.toml. There are three locations, merged in order of increasing precedence:

1. Built-in defaults (shipped with Helix).
2. Your config directory: ~/.config/helix/languages.toml.
3. Project-local: <project>/.helix/languages.toml.

Overriding a language

# ~/.config/helix/languages.toml
[[language]]
name = "rust"
auto-format = false
indent = { tab-width = 4, unit = "    " }

Commonly used [[language]] keys:

Configuring a language server

[language-server.mylang-lsp]
command = "mylang-lsp"
args = ["--stdio"]
config = { provideFormatter = true }
environment = { "ENV1" = "value1" }

[[language]]
name = "mylang"
language-servers = ["mylang-lsp"]

A language can use multiple servers, and you can enable or disable individual features per server with only-features / except-features:

[[language]]
name = "typescript"
language-servers = [
  { name = "efm-lsp-prettier", only-features = ["format"] },
  "typescript-language-server",
]

File-type detection

file-types accepts plain extensions and glob tables (matched against the full path, always using / as the separator even on Windows):

file-types = ["toml", { glob = "Makefile" }, { glob = ".github/workflows/*.yaml" }]

Globs take priority over extension matches.

Tree-sitter grammars

Grammars are declared in [[grammar]] sections and fetched/built with hx --grammar fetch and hx --grammar build. To limit which grammars are processed, set a top-level use-grammars key before any [[language]] or [[grammar]] section:

use-grammars = { only = ["rust", "c", "cpp"] }
# or
use-grammars = { except = ["yaml", "json"] }

Tip

Change a single buffer's language on the fly with :set-language <name> (:lang). Run :lang with no argument to see the current language.

18. Workspace Trust

Because LSP and project-local configuration can execute code, Helix gates them behind a workspace trust mechanism. No workspace is trusted by default.

• When you open a file in a new, undecided workspace, Helix prompts you about trust.
• Choosing Never excludes the workspace so you are not prompted again.
• :workspace-trust trusts the current workspace; :workspace-untrust revokes it.

Trusted and excluded workspaces are stored (newline-delimited) in ~/.local/share/helix/trusted_workspaces and .../excluded_workspaces.

Caution

You can restore the old, unguarded behavior — loading every .helix/config.toml and starting language servers without permission — by setting editor.insecure = true. Only do this if you understand the code-execution risk.

19. Migrating from Vim

The biggest adjustment is the selection → action order. In Vim you say "delete a word" (dw); in Helix you "select a word, then delete" (wd). Here are the most common translations:

Note

Helix has no block-selection mode. Use multiple cursors instead: add cursors on lines below with C, then move them together. There are no named bookmarks; save a location to the jumplist with Ctrl-s and return via Ctrl-o / Ctrl-i or the jumplist picker (Space j).

20. Troubleshooting

The following entries combine Helix's documented behavior with real issues reported by the community.

Error: keys seem to insert random commands instead of text

Cause: You are in normal mode, where letter keys run commands. Solution: Press Esc to ensure you are in normal mode, then press i to enter insert mode before typing. Prevention: Watch the mode indicator on the status line (NOR, INS, SEL).

Error: hx: command not found

Cause: The binary is not on your $PATH, or your package manager installed it as helix (notably Arch's extra repository). Solution: Try running helix. Otherwise add the install location to $PATH. Verify with hx --health (or helix --health). Prevention: When using pre-built binaries or AppImages, install hx into a directory already on your PATH such as ~/.local/bin.

Error: syntax highlighting or indentation is missing

Cause: The tree-sitter grammar for the language isn't built, or runtime files aren't found. Solution: Run hx --health <language> to check. Fetch and build grammars with hx --grammar fetch && hx --grammar build, and confirm HELIX_RUNTIME points to a valid runtime directory. Prevention: When building from source, always configure the runtime directory (see Building from source).

Error: language server features (gd, hover, completion) do nothing

Cause: No language server is installed/on PATH, or the workspace is untrusted. Solution: Install the appropriate server and ensure it is on $PATH. Run hx --health to confirm Helix detects it. Trust the workspace if prompted (:workspace-trust). Restart the server with :lsp-restart. Prevention: Consult the Language Server Configurations wiki.

Error: some keybindings don't work in my terminal

Cause: Your terminal intercepts certain key combinations, or lacks support for the enhanced keyboard protocol (this affects Shift-Tab, Super-key bindings, and some Alt combinations).

Warning

A known long-standing example is Alt/Opt + _ not working on macOS (#2280). This is generally a terminal-level key-handling limitation rather than a Helix bug.

Solution: Check your terminal's key mappings for conflicts and, where available, enable the enhanced/Kitty keyboard protocol. See the Terminal Support wiki. Prevention: Prefer a terminal with good protocol support (e.g. Kitty, WezTerm, recent Alacritty/foot) for the smoothest binding experience.

Error: the editor crashed or panicked

Cause: Certain edge cases have produced panics — for example navigating the jumplist after :reload-all (#13149) or specific selection/change interactions (#12582). Several such cases have been fixed in recent releases. Solution: Update to the latest release or nightly. If it still reproduces, capture the log (hx -v for more verbosity, or :log-open) and file an issue with steps to reproduce. Prevention: Keep Helix current; many crash fixes ship in each release.

Error: opening a directory misbehaves

Cause: Passing a directory to hx opens the file picker / explorer; some platform edge cases have been reported (#14785). Solution: Open a specific file, or use Space f from within Helix. Update to the latest version.

Where is the log file?

Open it with :log-open, or start Helix with a custom path: hx --log /tmp/helix.log and tail -f /tmp/helix.log in another terminal. Increase verbosity with repeated -v flags (hx -vv).

21. Frequently Asked Questions

Q: Do I need to install plugins to be productive? No. LSP, tree-sitter syntax highlighting, multiple cursors, fuzzy pickers, and a debugger client are all built in. A formal plugin system is planned but not required for everyday use.

Q: How do I learn the editing model quickly? Run hx --tutor (or :tutor). It is an interactive, hands-on tutorial and the fastest way to internalize selection-first editing.

Q: How do I save and quit? :w saves, :q quits, :wq (or :x) does both. :wqa saves all buffers and closes all views.

Q: Why don't :%s/foo/bar/ and other :substitute-style commands exist? Helix expresses replacement through multiple selections: %sfoo<ret>cbar<esc>,. See Search and Replace.

Q: How do I copy to the system clipboard? Use space-mode clipboard commands: Space y to yank, Space p/Space P to paste. Or yank to the + register directly ("+y).

Q: How do I change the theme without editing my config? Run :theme <name> and use Tab to browse available themes interactively.

Q: Where do my config files go? ~/.config/helix/config.toml and languages.toml on Linux/macOS; %AppData%\helix\ on Windows. Project-local overrides go in a .helix/ folder.

Q: How do I reload my config without restarting? :config-reload. On Unix you can also send USR1: pkill -USR1 hx.

Q: Can I use Helix like a non-modal editor? Insert mode includes a few movement and editing keys (arrows, Ctrl-w to delete a word) for newcomers, but Helix is designed around modal editing and you will get the best experience by learning it. You can disable the insert-mode arrow keys once comfortable.

Q: How do I add a trailing character to many lines at once? x to select a line (repeat to extend), or % for the whole file, then Alt-s to split on newlines (a cursor per line), then A, type the character, Esc.

Q: How do I see every command and its keybinding? Open the command palette with Space ?, or consult the Reference below.

Q: What languages are supported? Several hundred, via tree-sitter grammars, with language-server support for most mainstream languages. See the language support matrix.

Q: My Alt/Shift/Super keybindings don't register — is Helix broken? Usually not. This is a terminal key-handling limitation. Enable the enhanced keyboard protocol in your terminal where possible, and check the Terminal Support wiki.

22. Reference

Command-line flags

hx [FLAGS] [files] — open files by passing paths. A path may include a position: file.rs:10:2 opens at line 10, column 2; +N file opens at line N; + opens at the last line.

Keymap reference

Bindings marked (LSP) require a language server; (TS) require a tree-sitter grammar.

Movement (normal mode)

Changes (normal mode)

Selection manipulation

Minor-mode entry keys (normal mode)

Goto mode (g)

Space mode (Space) — pickers and LSP

View mode (z / sticky Z)

Match mode (m)

Window mode (Ctrl-w)

Insert-mode keys

Unimpaired (bracket) motions

Typable command reference

Run these from the command line (:). Aliases are shown after the canonical name.

Note

This is the everyday subset. Every command also appears in the in-editor command palette (Space ?), which always reflects your exact version, including debugger (:debug-*) and tree-sitter inspection (:tree-sitter-*) commands.

Static command reference

Static commands are the building blocks you bind keys to (see Key Remapping). They number in the hundreds; below is an orientation by category. For the complete list with current default bindings, open the command palette (Space ?) or see the source static_commands! macro in helix-term/src/commands.rs.

Language support

Helix supports several hundred languages through tree-sitter, with per-language capabilities that vary across syntax highlighting, tree-sitter textobjects, auto-indent, code navigation tags, rainbow brackets, and default language servers. A few examples:

To see the full, version-accurate matrix for your build, consult the generated language support page in the Helix book, or run hx --health <language> for a specific language.