Helix

Docs for bleeding edge master can be found at https://docs.helix-editor.com/master.

See the usage section for a quick overview of the editor, keymap section for all available keybindings and the configuration section for defining custom keybindings, setting themes, etc. For everything else (e.g., how to install supported language servers), see the Helix Wiki.

Refer the FAQ for common questions.

Installing Helix

To install Helix, follow the instructions specific to your operating system. Note that:

• To get the latest nightly version of Helix, you need to build from source.

• To take full advantage of Helix, install the language servers for your preferred programming languages. See the wiki for instructions.

Pre-built binaries

Download pre-built binaries from the GitHub Releases page. The tarball contents include an hx binary and a runtime directory. To set up Helix:

1. Add the hx binary to your system's $PATH to allow it to be used from the command line.
2. Copy the runtime directory to a location that hx searches for runtime files. A typical location on Linux/macOS is ~/.config/helix/runtime.

To see the runtime directories that hx searches, run hx --health. If necessary, you can override the default runtime location by setting the HELIX_RUNTIME environment variable.

Package managers

• Linux
  • Ubuntu
  • Fedora/RHEL
  • Arch Linux extra
  • NixOS
  • Flatpak
  • Snap
  • AppImage
• macOS
  • Homebrew Core
  • MacPorts
• Windows
  • Winget
  • Scoop
  • Chocolatey
  • MSYS2

Linux

The following third party repositories are available:

Ubuntu

Add the PPA for Helix:

sudo add-apt-repository ppa:maveonair/helix-editor
sudo apt update
sudo apt install helix

Fedora/RHEL

sudo dnf install helix

Arch Linux extra

Releases are available in the extra repository:

sudo pacman -S helix

💡 When installed from the extra repository, run Helix with helix instead of hx.

For example:

helix --health

to check health

Additionally, a helix-git package is available in the AUR, which builds the master branch.

NixOS

Helix is available in nixpkgs through the helix attribute, the unstable channel usually carries the latest release.

Helix is also available as a flake in the project root. Use nix develop to spin up a reproducible development shell. Outputs are cached for each push to master using Cachix. The flake is configured to automatically make use of this cache assuming the user accepts the new settings on first use.

If you are using a version of Nix without flakes enabled, install Cachix CLI and use cachix use helix to configure Nix to use cached outputs when possible.

Flatpak

Helix is available on Flathub:

flatpak install flathub com.helix_editor.Helix
flatpak run com.helix_editor.Helix

Snap

Helix is available on Snapcraft and can be installed with:

snap install --classic helix

This will install Helix as both /snap/bin/helix and /snap/bin/hx, so make sure /snap/bin is in your PATH.

AppImage

Install Helix using the Linux AppImage format. Download the official Helix AppImage from the latest releases page.

chmod +x helix-*.AppImage # change permission for executable mode
./helix-*.AppImage # run helix

You can optionally add the .desktop file. Helix must be installed in PATH with the name hx. For example:

mkdir -p "$HOME/.local/bin"
mv helix-*.AppImage "$HOME/.local/bin/hx"

and make sure ~/.local/bin is in your PATH.

macOS

Homebrew Core

brew install helix

MacPorts

port install helix

Windows

Install on Windows using Winget, Scoop, Chocolatey or MSYS2.

Winget

Windows Package Manager winget command-line tool is by default available on Windows 11 and modern versions of Windows 10 as a part of the App Installer. You can get App Installer from the Microsoft Store. If it's already installed, make sure it is updated with the latest version.

winget install Helix.Helix

Scoop

scoop install helix

Chocolatey

choco install helix

MSYS2

For 64-bit Windows 8.1 or above:

pacman -S mingw-w64-ucrt-x86_64-helix

Building from source

• Configuring Helix's runtime files
  • Linux and macOS
  • Windows
  • Multiple runtime directories
  • Note to packagers
• Validating the installation
• Configure the desktop shortcut

Requirements:

Clone the Helix GitHub repository into a directory of your choice. The examples in this documentation assume installation into either ~/src/ on Linux and macOS, or %userprofile%\src\ on Windows.

• The Rust toolchain
• The Git version control system
• A C++14 compatible compiler to build the tree-sitter grammars, for example GCC or Clang

If you are using the musl-libc standard library instead of glibc the following environment variable must be set during the build to ensure tree-sitter grammars can be loaded correctly:

RUSTFLAGS="-C target-feature=-crt-static"

1. Clone the repository:

   git clone https://github.com/helix-editor/helix
   cd helix
   

2. Compile from source:

   cargo install --path helix-term --locked
   

   This command will create the hx executable and construct the tree-sitter grammars in the local runtime folder.

💡 If you do not want to fetch or build grammars, set an environment variable HELIX_DISABLE_AUTO_GRAMMAR_BUILD

💡 Tree-sitter grammars can be fetched and compiled if not pre-packaged. Fetch grammars with hx --grammar fetch and compile them with hx --grammar build. This will install them in the runtime directory within the user's helix config directory (more details below).

Configuring Helix's runtime files

Linux and macOS

The runtime directory is one below the Helix source, so either export a HELIX_RUNTIME environment variable to point to that directory and add it to your ~/.bashrc or equivalent:

export HELIX_RUNTIME=~/src/helix/runtime

Or, create a symbolic link:

ln -Ts $PWD/runtime ~/.config/helix/runtime

If the above command fails to create a symbolic link because the file exists either move ~/.config/helix/runtime to a new location or delete it, then run the symlink command above again.

Windows

Either set the HELIX_RUNTIME environment variable to point to the runtime files using the Windows setting (search for Edit environment variables for your account) or use the setx command in Cmd:

setx HELIX_RUNTIME "%userprofile%\source\repos\helix\runtime"

💡 %userprofile% resolves to your user directory like C:\Users\Your-Name\ for example.

Or, create a symlink in %appdata%\helix\ that links to the source code directory:

💡 On Windows, creating a symbolic link may require running PowerShell or Cmd as an administrator.

Multiple runtime directories

When Helix finds multiple runtime directories it will search through them for files in the following order:

1. runtime/ sibling directory to $CARGO_MANIFEST_DIR directory (this is intended for developing and testing helix only).
2. runtime/ subdirectory of OS-dependent helix user config directory.
3. $HELIX_RUNTIME
4. Distribution-specific fallback directory (set at compile time—not run time— with the HELIX_DEFAULT_RUNTIME environment variable)
5. runtime/ subdirectory of path to Helix executable.

This order also sets the priority for selecting which file will be used if multiple runtime directories have files with the same name.

Note to packagers

If you are making a package of Helix for end users, to provide a good out of the box experience, you should set the HELIX_DEFAULT_RUNTIME environment variable at build time (before invoking cargo build) to a directory which will store the final runtime files after installation. For example, say you want to package the runtime into /usr/lib/helix/runtime. The rough steps a build script could follow are:

1. export HELIX_DEFAULT_RUNTIME=/usr/lib/helix/runtime
2. cargo build --profile opt --locked
3. cp -r runtime $BUILD_DIR/usr/lib/helix/
4. cp target/opt/hx $BUILD_DIR/usr/bin/hx

This way the resulting hx binary will always look for its runtime directory in /usr/lib/helix/runtime if the user has no custom runtime in ~/.config/helix or HELIX_RUNTIME.

Validating the installation

To make sure everything is set up as expected you should run the Helix health check:

hx --health

For more information on the health check results refer to Health check.

Configure the desktop shortcut

If your desktop environment supports the XDG desktop menu you can configure Helix to show up in the application menu by copying the provided .desktop and icon files to their correct folders:

cp contrib/Helix.desktop ~/.local/share/applications
cp contrib/helix.png ~/.icons # or ~/.local/share/icons

It is recommended to convert the links in the .desktop file to absolute paths to avoid potential problems:

sed -i -e "s|Exec=hx %F|Exec=$(readlink -f ~/.cargo/bin/hx) %F|g" \
  -e "s|Icon=helix|Icon=$(readlink -f ~/.icons/helix.png)|g" ~/.local/share/applications/Helix.desktop

To use another terminal than the system default, you can modify the .desktop file. For example, to use kitty:

sed -i "s|Exec=hx %F|Exec=kitty hx %F|g" ~/.local/share/applications/Helix.desktop
sed -i "s|Terminal=true|Terminal=false|g" ~/.local/share/applications/Helix.desktop

Using Helix

For a full interactive introduction to Helix, refer to the tutor which can be accessed via the command hx --tutor or :tutor.

💡 Currently, not all functionality is fully documented, please refer to the key mappings list.

Modes

Helix is a modal editor, meaning it has different modes for different tasks. The main modes are:

• Normal mode: For navigation and editing commands. This is the default mode.
• Insert mode: For typing text directly into the document. Access by typing i in normal mode.
• Select/extend mode: For making selections and performing operations on them. Access by typing v in normal mode.

Buffers

Buffers are in-memory representations of files. You can have multiple buffers open at once. Use pickers or commands like :buffer-next and :buffer-previous to open buffers or switch between them.

Selection-first editing

Inspired by Kakoune, Helix follows the selection → action model. This means that whatever you are going to act on (a word, a paragraph, a line, etc.) is selected first and the action itself (delete, change, yank, etc.) comes second. A cursor is simply a single width selection.

Multiple selections

Also inspired by Kakoune, multiple selections are a core mode of interaction in Helix. For example, the standard way of replacing multiple instance of a word is to first select all instances (so there is one selection per instance) and then use the change action (c) to edit them all at the same time.

Motions

Motions are commands that move the cursor or modify selections. They're used for navigation and text manipulation. Examples include w to move to the next word, or f to find a character. See the Movement section of the keymap for more motions.

Registers

• User-defined registers
• Default registers
• Special registers

In Helix, registers are storage locations for text and other data, such as the result of a search. Registers can be used to cut, copy, and paste text, similar to the clipboard in other text editors. Usage is similar to Vim, with " being used to select a register.

User-defined registers

Helix allows you to create your own named registers for storing text, for example:

• "ay - Yank the current selection to register a.
• "op - Paste the text in register o after the selection.

If a register is selected before invoking a change or delete command, the selection will be stored in the register and the action will be carried out:

• "hc - Store the selection in register h and then change it (delete and enter insert mode).
• "md - Store the selection in register m and delete it.

Default registers

Commands that use registers, like yank (y), use a default register if none is specified. These registers are used as defaults:

Special registers

Some registers have special behavior when read from and written to.

When yanking multiple selections to the clipboard registers, the selections are joined with newlines. Pasting from these registers will paste multiple selections if the clipboard was last yanked to by the Helix session. Otherwise the clipboard contents are pasted as one selection.

Surround

Helix includes built-in functionality similar to vim-surround. The keymappings have been inspired from vim-sandwich:

You can use counts to act on outer pairs.

Surround can also act on multiple selections. For example, to change every occurrence of (use) to [use]:

1. % to select the whole file
2. s to split the selections on a search term
3. Input use and hit Enter
4. mr([ to replace the parentheses with square brackets

Multiple characters are currently not supported, but planned for future release.

Selecting and manipulating text with textobjects

In Helix, textobjects are a way to select, manipulate and operate on a piece of text in a structured way. They allow you to refer to blocks of text based on their structure or purpose, such as a word, sentence, paragraph, or even a function or block of code.

• ma - Select around the object (va in Vim, <alt-a> in Kakoune)
• mi - Select inside the object (vi in Vim, <alt-i> in Kakoune)

💡 f, t, etc. need a tree-sitter grammar active for the current document and a special tree-sitter query file to work properly. Only some grammars currently have the query file implemented. Contributions are welcome!

Navigating using tree-sitter textobjects

Navigating between functions, classes, parameters, and other elements is possible using tree-sitter and textobject queries. For example to move to the next function use ]f, to move to previous type use [t, and so on.

For the full reference see the unimpaired section of the key bind documentation.

💡 This feature relies on tree-sitter textobjects and requires the corresponding query file to work properly.

Moving the selection with syntax-aware motions

Alt-p, Alt-o, Alt-i, and Alt-n (or Alt and arrow keys) allow you to move the selection according to its location in the syntax tree. For example, many languages have the following syntax for function calls:

func(arg1, arg2, arg3);

A function call might be parsed by tree-sitter into a tree like the following.

(call
  function: (identifier) ; func
  arguments:
    (arguments           ; (arg1, arg2, arg3)
      (identifier)       ; arg1
      (identifier)       ; arg2
      (identifier)))     ; arg3

Use :tree-sitter-subtree to view the syntax tree of the primary selection. In a more intuitive tree format:

            ┌────┐
            │call│
      ┌─────┴────┴─────┐
      │                │
┌─────▼────┐      ┌────▼────┐
│identifier│      │arguments│
│  "func"  │ ┌────┴───┬─────┴───┐
└──────────┘ │        │         │
             │        │         │
   ┌─────────▼┐  ┌────▼─────┐  ┌▼─────────┐
   │identifier│  │identifier│  │identifier│
   │  "arg1"  │  │  "arg2"  │  │  "arg3"  │
   └──────────┘  └──────────┘  └──────────┘

If you have a selection that wraps arg1 (see the tree above), and you use Alt-n, it will select the next sibling in the syntax tree: arg2.

// before
func([arg1], arg2, arg3)
// after
func(arg1, [arg2], arg3);

Similarly, Alt-o will expand the selection to the parent node, in this case, the arguments node.

func[(arg1, arg2, arg3)];

There is also some nuanced behavior that prevents you from getting stuck on a node with no sibling. When using Alt-p with a selection on arg1, the previous child node will be selected. In the event that arg1 does not have a previous sibling, the selection will move up the syntax tree and select the previous element. As a result, using Alt-p with a selection on arg1 will move the selection to the "func" identifier.

Using pickers

Helix has a variety of pickers, which are interactive windows used to select various kinds of items. These include a file picker, global search picker, and more. Most pickers are accessed via keybindings in space mode. Pickers have their own keymap for navigation.

Filtering Picker Results

Most pickers perform fuzzy matching using fzf syntax. Two exceptions are the global search picker, which uses regex, and the workspace symbol picker, which passes search terms to the LSP. Note that OR operations (|) are not currently supported.

If a picker shows multiple columns, you may apply the filter to a specific column by prefixing the column name with %. Column names can be shortened to any prefix, so %p, %pa or %pat all mean the same as %path. For example, a query of helix %p .toml !lang in the global search picker searches for the term "helix" within files with paths ending in ".toml" but not including "lang".

You can insert the contents of a register using Ctrl-r followed by a register name. For example, one could insert the currently selected text using Ctrl-r-., or the directory of the current file using Ctrl-r-% followed by Ctrl-w to remove the last path section. The global search picker will use the contents of the search register if you press Enter without typing a filter. For example, pressing *-Space-/-Enter will start a global search for the currently selected text.

Keymap

• Normal mode
  • Movement
  • Changes
    • Shell
  • Selection manipulation
  • Search
  • Minor modes
    • View mode
    • Goto mode
    • Match mode
    • Window mode
    • Space mode
      • Popup
      • Completion Menu
      • Signature-help Popup
    • Unimpaired
• Insert mode
• Select / extend mode
• Picker
• Prompt

💡 Mappings marked (LSP) require an active language server for the file.

💡 Mappings marked (TS) require a tree-sitter grammar for the file type.

⚠️ Some terminals' default key mappings conflict with Helix's. If any of the mappings described on this page do not work as expected, check your terminal's mappings to ensure they do not conflict. See the wiki for known conflicts.

Normal mode

Normal mode is the default mode when you launch helix. You can return to it from other modes by pressing the Escape key.

Movement

NOTE: Unlike Vim, f, F, t and T are not confined to the current line.

Changes

Shell

Selection manipulation

Search

Search commands all operate on the / register by default. To use a different register, use "<char>.

Minor modes

These sub-modes are accessible from normal mode and typically switch back to normal mode after a command.

These modes (except command mode) can be configured by remapping keys.

View mode

Accessed by typing z in normal mode.

View mode is intended for scrolling and manipulating the view without changing the selection. The "sticky" variant of this mode (accessed by typing Z in normal mode) is persistent and can be exited using the escape key. This is useful when you're simply looking over text and not actively editing it.

Goto mode

Accessed by typing g in normal mode.

Jumps to various locations.

Match mode

Accessed by typing m in normal mode.

Please refer to the relevant sections for detailed explanations about surround and textobjects.

TODO: Mappings for selecting syntax nodes (a superset of [).

Window mode

Accessed by typing Ctrl-w in normal mode.

This layer is similar to Vim keybindings as Kakoune does not support windows.

Space mode

Accessed by typing Space in normal mode.

This layer is a kludge of mappings, mostly pickers.

💡 Global search displays results in a fuzzy picker, use Space + ' to bring it back up after opening a file.

Popup

Displays documentation for item under cursor. Remapping currently not supported.

Completion Menu

Displays documentation for the selected completion item. Remapping currently not supported.

Any other keypresses result in the completion being accepted.

Signature-help Popup

Displays the signature of the selected completion item. Remapping currently not supported.

Unimpaired

These mappings are in the style of vim-unimpaired.

Insert mode

Accessed by typing i in normal mode.

Insert mode bindings are minimal by default. Helix is designed to be a modal editor, and this is reflected in the user experience and internal mechanics. Changes to the text are only saved for undos when escaping from insert mode to normal mode.

💡 New users are strongly encouraged to learn the modal editing paradigm to get the smoothest experience.

These keys are not recommended, but are included for new users less familiar with modal editors.

As you become more comfortable with modal editing, you may want to disable some insert mode bindings. You can do this by editing your config.toml file.

[keys.insert]
up = "no_op"
down = "no_op"
left = "no_op"
right = "no_op"
pageup = "no_op"
pagedown = "no_op"
home = "no_op"
end = "no_op"

Select / extend mode

Accessed by typing v in normal mode.

Select mode echoes Normal mode, but changes any movements to extend selections rather than replace them. Goto motions are also changed to extend, so that vgl, for example, extends the selection to the end of the line.

Search is also affected. By default, n and N will remove the current selection and select the next instance of the search term. Toggling this mode before pressing n or N makes it possible to keep the current selection. Toggling it on and off during your iterative searching allows you to selectively add search terms to your selections.

Picker

Keys to use within picker. Remapping currently not supported. See the documentation page on pickers for more info. Prompt keybinds also work in pickers, except where they conflict with picker keybinds.

Prompt

Keys to use within prompt, Remapping currently not supported.

Commands

Command mode can be activated by pressing :. The built-in commands are:

Language Support

The following languages and Language Servers are supported. To use Language Server features, you must first configure the appropriate Language Server.

You can check the language support in your installed helix version with hx --health.

Also see the Language Configuration docs and the Adding Languages guide for more language configuration information.

Migrating from Vim

Helix's editing model is strongly inspired from Vim and Kakoune, and a notable difference from Vim (and the most striking similarity to Kakoune) is that Helix follows the selection → action model. This means that whatever you are going to act on (a word, a paragraph, a line, etc.) is selected first and the action itself (delete, change, yank, etc.) comes second. A cursor is simply a single width selection.

See also Kakoune's Migrating from Vim and Helix's Migrating from Vim.

TODO: Mention textobjects, surround, registers

Configuration

To override global configuration parameters, create a config.toml file located in your config directory:

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

💡 You can easily open the config file by typing :config-open within Helix normal mode.

Example config:

theme = "onedark"

[editor]
line-number = "relative"
mouse = false

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

[editor.file-picker]
hidden = false

You can use a custom configuration file by specifying it with the -c or --config command line argument, for example hx -c path/to/custom-config.toml. You can reload the config file by issuing the :config-reload command. Alternatively, on Unix operating systems, you can reload it by sending the USR1 signal to the Helix process, such as by using the command pkill -USR1 hx.

Finally, you can have a config.toml local to a project by putting it under a .helix directory in your repository. Its settings will be merged with the configuration directory config.toml and the built-in configuration.

Editor

• [editor] Section
• [editor.statusline] Section
• [editor.lsp] Section
• [editor.cursor-shape] Section
• [editor.file-picker] Section
• [editor.auto-pairs] Section
• [editor.search] Section
• [editor.whitespace] Section
• [editor.indent-guides] Section
• [editor.gutters] Section
  • [editor.gutters.line-numbers] Section
  • [editor.gutters.diagnostics] Section
  • [editor.gutters.diff] Section
  • [editor.gutters.spacer] Section
• [editor.soft-wrap] Section
• [editor.smart-tab] Section
• [editor.inline-diagnostics] Section

[editor] Section

[editor.clipboard-provider] Section

Helix can be configured wither to use a builtin clipboard configuration or to use a provided command.

For instance, setting it to use OSC 52 termcodes, the configuration would be:

[editor]
clipboard-provider = "termcode"

Alternatively, Helix can be configured to use arbitary commands for clipboard integration:

[editor.clipboard-provider.custom]
yank = { command = "cat",  args = ["test.txt"] }
paste = { command = "tee",  args = ["test.txt"] }
primary-yank = { command = "cat",  args = ["test-primary.txt"] } # optional
primary-paste = { command = "tee",  args = ["test-primary.txt"] } # optional

For custom commands the contents of the yank/paste is communicated over stdin/stdout.

[editor.statusline] Section

Allows configuring the statusline at the bottom of the editor.

The configuration distinguishes between three areas of the status line:

[ ... ... LEFT ... ... | ... ... ... CENTER ... ... ... | ... ... RIGHT ... ... ]

Statusline elements can be defined as follows:

[editor.statusline]
left = ["mode", "spinner"]
center = ["file-name"]
right = ["diagnostics", "selections", "position", "file-encoding", "file-line-ending", "file-type"]
separator = "│"
mode.normal = "NORMAL"
mode.insert = "INSERT"
mode.select = "SELECT"

The [editor.statusline] key takes the following sub-keys:

The following statusline elements can be configured:

[editor.lsp] Section

[editor.cursor-shape] Section

Defines the shape of cursor in each mode. Valid values for these options are block, bar, underline, or hidden.

💡 Due to limitations of the terminal environment, only the primary cursor can change shape.

[editor.file-picker] Section

Set options for file picker and global search. Ignoring a file means it is not visible in the Helix file picker and global search.

All git related options are only enabled in a git repository.

Ignore files can be placed locally as .ignore or put in your home directory as ~/.ignore. They support the usual ignore and negative ignore (unignore) rules used in .gitignore files.

Additionally, you can use Helix-specific ignore files by creating a local .helix/ignore file in the current workspace or a global ignore file located in your Helix config directory:

• Linux and Mac: ~/.config/helix/ignore
• Windows: %AppData%\helix\ignore

Example:

# unignore in file picker and global search
!.github/
!.gitignore
!.gitattributes

[editor.auto-pairs] Section

Enables automatic insertion of pairs to parentheses, brackets, etc. Can be a simple boolean value, or a specific mapping of pairs of single characters.

To disable auto-pairs altogether, set auto-pairs to false:

[editor]
auto-pairs = false # defaults to `true`

The default pairs are (){}[]''""``, but these can be customized by setting auto-pairs to a TOML table:

[editor.auto-pairs]
'(' = ')'
'{' = '}'
'[' = ']'
'"' = '"'
'`' = '`'
'<' = '>'

Additionally, this setting can be used in a language config. Unless the editor setting is false, this will override the editor config in documents with this language.

Example languages.toml that adds <> and removes ''

[[language]]
name = "rust"

[language.auto-pairs]
'(' = ')'
'{' = '}'
'[' = ']'
'"' = '"'
'`' = '`'
'<' = '>'

[editor.auto-save] Section

Control auto save behavior.

[editor.search] Section

Search specific options.

[editor.whitespace] Section

Options for rendering whitespace with visible characters. Use :set whitespace.render all to temporarily enable visible whitespace.

Example

[editor.whitespace]
render = "all"
# or control each character
[editor.whitespace.render]
space = "all"
tab = "all"
nbsp = "none"
nnbsp = "none"
newline = "none"

[editor.whitespace.characters]
space = "·"
nbsp = "⍽"
nnbsp = "␣"
tab = "→"
newline = "⏎"
tabpad = "·" # Tabs will look like "→···" (depending on tab width)

[editor.indent-guides] Section

Options for rendering vertical indent guides.

Example:

[editor.indent-guides]
render = true
character = "╎" # Some characters that work well: "▏", "┆", "┊", "⸽"
skip-levels = 1

[editor.gutters] Section

For simplicity, editor.gutters accepts an array of gutter types, which will use default settings for all gutter components.

[editor]
gutters = ["diff", "diagnostics", "line-numbers", "spacer"]

To customize the behavior of gutters, the [editor.gutters] section must be used. This section contains top level settings, as well as settings for specific gutter components as subsections.

Example:

[editor.gutters]
layout = ["diff", "diagnostics", "line-numbers", "spacer"]

[editor.gutters.line-numbers] Section

Options for the line number gutter

Example:

[editor.gutters.line-numbers]
min-width = 1

[editor.gutters.diagnostics] Section

Currently unused

[editor.gutters.diff] Section

The diff gutter option displays colored bars indicating whether a git diff represents that a line was added, removed or changed. These colors are controlled by the theme attributes diff.plus, diff.minus and diff.delta.

Other diff providers will eventually be supported by a future plugin system.

There are currently no options for this section.

[editor.gutters.spacer] Section

Currently unused

[editor.soft-wrap] Section

Options for soft wrapping lines that exceed the view width:

Example:

[editor.soft-wrap]
enable = true
max-wrap = 25 # increase value to reduce forced mid-word wrapping
max-indent-retain = 0
wrap-indicator = ""  # set wrap-indicator to "" to hide it

[editor.smart-tab] Section

Options for navigating and editing using tab key.

Due to lack of support for S-tab in some terminals, the default keybindings don't fully embrace smart-tab editing experience. If you enjoy smart-tab navigation and a terminal that supports the Enhanced Keyboard protocol, consider setting extra keybindings:

[keys.normal]
tab = "move_parent_node_end"
S-tab = "move_parent_node_start"

[keys.insert]
S-tab = "move_parent_node_start"

[keys.select]
tab = "extend_parent_node_end"
S-tab = "extend_parent_node_start"

[editor.inline-diagnostics] Section

Options for rendering diagnostics inside the text like shown below

fn main() {
  let foo = bar;
            └─ no such value in this scope
}

The (first) diagnostic with the highest severity that is not shown inline is rendered at the end of the line (as long as its severity is higher than the end-of-line-diagnostics config option):

fn main() {
  let baz = 1;
  let foo = bar; a local variable with a similar name exists: baz
            └─ no such value in this scope
}

The new diagnostic rendering is not yet enabled by default. As soon as end of line or inline diagnostics are enabled the old diagnostics rendering is automatically disabled. The recommended default setting are:

[editor]
end-of-line-diagnostics = "hint"
[editor.inline-diagnostics]
cursor-line = "warning" # show warnings and errors on the cursorline inline

Themes

To use a theme add theme = "<name>" to the top of your config.toml file, or select it during runtime using :theme <name>.

Creating a theme

Create a file with the name of your theme as the file name (i.e mytheme.toml) and place it in your themes directory (i.e ~/.config/helix/themes or %AppData%\helix\themes on Windows). The directory might have to be created beforehand.

💡 The names "default" and "base16_default" are reserved for built-in themes and cannot be overridden by user-defined themes.

Overview

Each line in the theme file is specified as below:

key = { fg = "#ffffff", bg = "#000000", underline = { color = "#ff0000", style = "curl"}, modifiers = ["bold", "italic"] }

Where key represents what you want to style, fg specifies the foreground color, bg the background color, underline the underline style/color, and modifiers is a list of style modifiers. bg, underline and modifiers can be omitted to defer to the defaults.

To specify only the foreground color:

key = "#ffffff"

If the key contains a dot '.', it must be quoted to prevent it being parsed as a dotted key.

"key.key" = "#ffffff"

For inspiration, you can find the default theme.toml here and user-submitted themes here.

The details of theme creation

Color palettes

It's recommended to define a palette of named colors, and refer to them in the configuration values in your theme. To do this, add a table called palette to your theme file:

"ui.background" = "white"
"ui.text" = "black"

[palette]
white = "#ffffff"
black = "#000000"

Keep in mind that the [palette] table includes all keys after its header, so it should be defined after the normal theme options.

The default palette uses the terminal's default 16 colors, and the colors names are listed below. The [palette] section in the config file takes precedence over it and is merged into the default palette.

Modifiers

The following values may be used as modifier, provided they are supported by your terminal emulator.

💡 The underlined modifier is deprecated and only available for backwards compatibility. Its behavior is equivalent to setting underline.style="line".

Underline style

One of the following values may be used as a value for underline.style, providing it is supported by your terminal emulator.

Inheritance

Extend other themes by setting the inherits property to an existing theme.

inherits = "boo_berry"

# Override the theming for "keyword"s:
"keyword" = { fg = "gold" }

# Override colors in the palette:
[palette]
berry = "#2A2A4D"

Scopes

The following is a list of scopes available to use for styling:

Syntax highlighting

These keys match tree-sitter scopes.

When determining styling for a highlight, the longest matching theme key will be used. For example, if the highlight is function.builtin.static, the key function.builtin will be used instead of function.

We use a similar set of scopes as Sublime Text. See also TextMate scopes.

• attribute - Class attributes, HTML tag attributes

• type - Types

  • builtin - Primitive types provided by the language (int, usize)
  • parameter - Generic type parameters (T)
  • enum
    • variant

• constructor

• constant (TODO: constant.other.placeholder for %v)

  • builtin Special constants provided by the language (true, false, nil etc)
    • boolean
  • character
    • escape
  • numeric (numbers)
    • integer
    • float

• string (TODO: string.quoted.{single, double}, string.raw/.unquoted)?

  • regexp - Regular expressions
  • special
    • path
    • url
    • symbol - Erlang/Elixir atoms, Ruby symbols, Clojure keywords

• comment - Code comments

  • line - Single line comments (//)
  • block - Block comments (e.g. (/* */)
    • documentation - Documentation comments (e.g. /// in Rust)

• variable - Variables

  • builtin - Reserved language variables (self, this, super, etc.)
  • parameter - Function parameters
  • other
    • member - Fields of composite data types (e.g. structs, unions)
      • private - Private fields that use a unique syntax (currently just ECMAScript-based languages)

• label

• punctuation

  • delimiter - Commas, colons
  • bracket - Parentheses, angle brackets, etc.
  • special - String interpolation brackets.

• keyword

  • control
    • conditional - if, else
    • repeat - for, while, loop
    • import - import, export
    • return
    • exception
  • operator - or, in
  • directive - Preprocessor directives (#if in C)
  • function - fn, func
  • storage - Keywords describing how things are stored
    • type - The type of something, class, function, var, let, etc.
    • modifier - Storage modifiers like static, mut, const, ref, etc.

• operator - ||, +=, >

• function

  • builtin
  • method
    • private - Private methods that use a unique syntax (currently just ECMAScript-based languages)
  • macro
  • special (preprocessor in C)

• tag - Tags (e.g. <body> in HTML)

  • builtin

• namespace

• special

• markup

  • heading
    • marker
    • 1, 2, 3, 4, 5, 6 - heading text for h1 through h6
  • list
    • unnumbered
    • numbered
    • checked
    • unchecked
  • bold
  • italic
  • strikethrough
  • link
    • url - URLs pointed to by links
    • label - non-URL link references
    • text - URL and image descriptions in links
  • quote
  • raw
    • inline
    • block

• diff - version control changes

  • plus - additions
    • gutter - gutter indicator
  • minus - deletions
    • gutter - gutter indicator
  • delta - modifications
    • moved - renamed or moved files/changes
    • conflict - merge conflicts
    • gutter - gutter indicator

Interface

These scopes are used for theming the editor interface:

• markup
  • normal
    • completion - for completion doc popup UI
    • hover - for hover popup UI
  • heading
    • completion - for completion doc popup UI
    • hover - for hover popup UI
  • raw
    • inline
      • completion - for completion doc popup UI
      • hover - for hover popup UI

Key remapping

Helix currently supports one-way key remapping through a simple TOML configuration file. (More powerful solutions such as rebinding via commands will be available in the future).

There are three kinds of commands that can be used in keymaps:

• Static commands: commands like move_char_right which are usually bound to keys and used for movement and editing. A list of static commands is available in the Keymap documentation and in the source code in helix-term/src/commands.rs at the invocation of static_commands! macro.
• Typable commands: commands that can be executed from command mode (:), for example :write!. See the Commands documentation for a list of available typeable commands or the TypableCommandList declaration in the source code at helix-term/src/commands/typed.rs.
• Macros: sequences of keys that are executed in order. These keybindings start with @ and then list any number of keys to be executed. For example @miw can be used to select the surrounding word. For now, macro keybindings are not allowed in keybinding sequences due to limitations in the way that command sequences are executed. Modifier keys (e.g. Alt+o) can be used like "<A-o>", e.g. "@miw<A-o>"

To remap keys, create a config.toml file in your helix configuration directory (default ~/.config/helix on Linux systems) with a structure like this:

💡 To set a modifier + key as a keymap, type A-X = ... or C-X = ... for Alt + X or Ctrl + X. Combine with Shift using a dash, e.g. C-S-esc. Within macros, wrap them in <>, e.g. <A-X> and <C-X> to distinguish from the A or C keys.

# At most one section each of 'keys.normal', 'keys.insert' and 'keys.select'
[keys.normal]
C-s = ":w" # Maps Ctrl-s to the typable command :w which is an alias for :write (save file)
C-o = ":open ~/.config/helix/config.toml" # Maps Ctrl-o to opening of the helix config file
a = "move_char_left" # Maps the 'a' key to the move_char_left command
w = "move_line_up" # Maps the 'w' key move_line_up
"C-S-esc" = "extend_line" # Maps Ctrl-Shift-Escape to extend_line
g = { a = "code_action" } # Maps `ga` to show possible code actions
"ret" = ["open_below", "normal_mode"] # Maps the enter key to open_below then re-enter normal mode
"A-x" = "@x<A-d>" # Maps Alt-x to a macro selecting the whole line and deleting it without yanking it

[keys.insert]
"A-x" = "normal_mode"     # Maps Alt-X to enter normal mode
j = { k = "normal_mode" } # Maps `jk` to exit insert mode

Minor modes

Minor modes are accessed by pressing a key (usually from normal mode), giving access to dedicated bindings. Bindings can be modified or added by nesting definitions.

[keys.insert.j]
k = "normal_mode" # Maps `jk` to exit insert mode

[keys.normal.g]
a = "code_action" # Maps `ga` to show possible code actions

# invert `j` and `k` in view mode
[keys.normal.z]
j = "scroll_up"
k = "scroll_down"

# create 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"

Special keys and modifiers

Ctrl, Shift and Alt modifiers are encoded respectively with the prefixes C-, S- and A-. Special keys are encoded as follows:

Keys can be disabled by binding them to the no_op command.

Languages

Language-specific settings and settings for language servers are configured in languages.toml files.

languages.toml files

There are three possible locations for a languages.toml file:

1. In the Helix source code, which lives in the Helix repository. It provides the default configurations for languages and language servers.

2. In your configuration directory. This overrides values from the built-in language configuration. For example, to disable auto-LSP-formatting in Rust:

   # in <config_dir>/helix/languages.toml
   
   [language-server.mylang-lsp]
   command = "mylang-lsp"
   
   [[language]]
   name = "rust"
   auto-format = false
   

3. In a .helix folder in your project. Language configuration may also be overridden local to a project by creating a languages.toml file in a .helix folder. Its settings will be merged with the language configuration in the configuration directory and the built-in configuration.

Language configuration

Each language is configured by adding a [[language]] section to a languages.toml file. For example:

[[language]]
name = "mylang"
scope = "source.mylang"
injection-regex = "mylang"
file-types = ["mylang", "myl"]
comment-tokens = "#"
indent = { tab-width = 2, unit = "  " }
formatter = { command = "mylang-formatter" , args = ["--stdin"] }
language-servers = [ "mylang-lsp" ]

These configuration keys are available:

File-type detection and the file-types key

Helix determines which language configuration to use based on the file-types key from the above section. file-types is a list of strings or tables, for example:

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

When determining a language configuration to use, Helix searches the file-types with the following priorities:

1. Glob: values in glob tables are checked against the full path of the given file. Globs are standard Unix-style path globs (e.g. the kind you use in Shell) and can be used to match paths for a specific prefix, suffix, directory, etc. In the above example, the { glob = "Makefile" } config would match files with the name Makefile, the { glob = ".git/config" } config would match config files in .git directories, and the { glob = ".github/workflows/*.yaml" } config would match any yaml files in .github/workflow directories. Note that globs should always use the Unix path separator / even on Windows systems; the matcher will automatically take the machine-specific separators into account. If the glob isn't an absolute path or doesn't already start with a glob prefix, */ will automatically be added to ensure it matches for any subdirectory.
2. Extension: if there are no glob matches, any file-types string that matches the file extension of a given file wins. In the example above, the "toml" config matches files like Cargo.toml or languages.toml.

Language Server configuration

Language servers are configured separately in the table language-server in the same file as the languages languages.toml

For example:

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

[language-server.efm-lsp-prettier]
command = "efm-langserver"

[language-server.efm-lsp-prettier.config]
documentFormatting = true
languages = { typescript = [ { formatCommand ="prettier --stdin-filepath ${INPUT}", formatStdin = true } ] }

These are the available options for a language server.

A format sub-table within config can be used to pass extra formatting options to Document Formatting Requests. For example, with typescript:

[language-server.typescript-language-server]
# pass format options according to https://github.com/typescript-language-server/typescript-language-server#workspacedidchangeconfiguration omitting the "[language].format." prefix.
config = { format = { "semicolons" = "insert", "insertSpaceBeforeFunctionParenthesis" = true } }

Configuring Language Servers for a language

The language-servers attribute in a language tells helix which language servers are used for this language.

They have to be defined in the [language-server] table as described in the previous section.

Different languages can use the same language server instance, e.g. typescript-language-server is used for javascript, jsx, tsx and typescript by default.

The definition order of language servers affects the order in the results list of code action menu.

In case multiple language servers are specified in the language-servers attribute of a language, it's often useful to only enable/disable certain language-server features for these language servers.

As an example, efm-lsp-prettier of the previous example is used only with a formatting command prettier, so everything else should be handled by the typescript-language-server (which is configured by default). The language configuration for typescript could look like this:

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

or equivalent:

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

Each requested LSP feature is prioritized in the order of the language-servers array. For example, the first goto-definition supported language server (in this case typescript-language-server) will be taken for the relevant LSP request (command goto_definition). The features diagnostics, code-action, completion, document-symbols and workspace-symbols are an exception to that rule, as they are working for all language servers at the same time and are merged together, if enabled for the language. If no except-features or only-features is given, all features for the language server are enabled. If a language server itself doesn't support a feature, the next language server array entry will be tried (and so on).

The list of supported features is:

• format
• goto-definition
• goto-declaration
• goto-type-definition
• goto-reference
• goto-implementation
• signature-help
• hover
• document-highlight
• completion
• code-action
• workspace-command
• document-symbols
• workspace-symbols
• diagnostics
• rename-symbol
• inlay-hints

Tree-sitter grammar configuration

The source for a language's tree-sitter grammar is specified in a [[grammar]] section in languages.toml. For example:

[[grammar]]
name = "mylang"
source = { git = "https://github.com/example/mylang", rev = "a250c4582510ff34767ec3b7dcdd3c24e8c8aa68" }

Grammar configuration takes these keys:

Where source is a table with either these keys when using a grammar from a git repository:

Choosing grammars

You may use a top-level use-grammars key to control which grammars are fetched and built when using hx --grammar fetch and hx --grammar build.

# Note: this key must come **before** the [[language]] and [[grammar]] sections
use-grammars = { only = [ "rust", "c", "cpp" ] }
# or
use-grammars = { except = [ "yaml", "json" ] }

When omitted, all grammars are fetched and built.

Guides

This section contains guides for adding new language server configurations, tree-sitter grammars, textobject queries, and other similar items.

Adding new languages to Helix

In order to add a new language to Helix, you will need to follow the steps below.

Language configuration

1. Add a new [[language]] entry in the languages.toml file and provide the necessary configuration for the new language. For more information on language configuration, refer to the language configuration section of the documentation. A new language server can be added by extending the [language-server] table in the same file.
2. If you are adding a new language or updating an existing language server configuration, run the command cargo xtask docgen to update the Language Support documentation.

💡 If you are adding a new Language Server configuration, make sure to update the Language Server Wiki with the installation instructions.

Grammar configuration

1. If a tree-sitter grammar is available for the new language, add a new [[grammar]] entry to the languages.toml file.
2. If you are testing the grammar locally, you can use the source.path key with an absolute path to the grammar. However, before submitting a pull request, make sure to switch to using source.git.

Queries

1. In order to provide syntax highlighting and indentation for the new language, you will need to add queries.
2. Create a new directory for the language with the path runtime/queries/<name>/.
3. Refer to the tree-sitter website for more information on writing queries.
4. A list of highlight captures can be found on the themes page.

💡 In Helix, the first matching query takes precedence when evaluating queries, which is different from other editors such as Neovim where the last matching query supersedes the ones before it. See this issue for an example.

Common issues

• If you encounter errors when running Helix after switching branches, you may need to update the tree-sitter grammars. Run the command hx --grammar fetch to fetch the grammars and hx --grammar build to build any out-of-date grammars.
• If a parser is causing a segfault, or you want to remove it, make sure to remove the compiled parser located at runtime/grammars/<name>.so.
• If you are attempting to add queries and Helix is unable to locate them, ensure that the environment variable HELIX_RUNTIME is set to the location of the runtime folder you're developing in.

Adding textobject queries

Helix supports textobjects that are language specific, such as functions, classes, etc. These textobjects require an accompanying tree-sitter grammar and a textobjects.scm query file to work properly. Tree-sitter allows us to query the source code syntax tree and capture specific parts of it. The queries are written in a lisp dialect. More information on how to write queries can be found in the official tree-sitter documentation.

Query files should be placed in runtime/queries/{language}/textobjects.scm when contributing to Helix. Note that to test the query files locally you should put them under your local runtime directory (~/.config/helix/runtime on Linux for example).

The following captures are recognized:

Example query files can be found in the helix GitHub repository.

Queries for textobject based navigation

Tree-sitter based navigation in Helix is done using captures in the following order:

• object.movement
• object.around
• object.inside

For example if a function.around capture has been already defined for a language in its textobjects.scm file, function navigation should also work automatically. function.movement should be defined only if the node captured by function.around doesn't make sense in a navigation context.

Adding indent queries

Helix uses tree-sitter to correctly indent new lines. This requires a tree- sitter grammar and an indent.scm query file placed in runtime/queries/ {language}/indents.scm. The indentation for a line is calculated by traversing the syntax tree from the lowest node at the beginning of the new line (see Indent queries). Each of these nodes contributes to the total indent when it is captured by the query (in what way depends on the name of the capture.

Note that it matters where these added indents begin. For example, multiple indent level increases that start on the same line only increase the total indent level by 1. See Capture types.

By default, Helix uses the hybrid indentation heuristic. This means that indent queries are not used to compute the expected absolute indentation of a line but rather the expected difference in indentation between the new and an already existing line. This difference is then added to the actual indentation of the already existing line. Since this makes errors in the indent queries harder to find, it is recommended to disable it when testing via :set indent-heuristic tree-sitter. The rest of this guide assumes that the tree-sitter heuristic is used.

Indent queries

When Helix is inserting a new line through o, O, or <ret>, to determine the indent level for the new line, the query in indents.scm is run on the document. The starting position of the query is the end of the line above where a new line will be inserted.

For o, the inserted line is the line below the cursor, so that starting position of the query is the end of the current line.

#![allow(unused)]
fn main() {
fn need_hero(some_hero: Hero, life: Life) -> {
    matches!(some_hero, Hero { // ←─────────────────╮
        strong: true,//←╮  ↑  ↑                     │
        fast: true,  // │  │  ╰── query start       │
        sure: true,  // │  ╰───── cursor            ├─ traversal 
        soon: true,  // ╰──────── new line inserted │  start node
    }) &&            //                             │
//  ↑                                               │
//  ╰───────────────────────────────────────────────╯
    some_hero > life
}
}

For O, the newly inserted line is the current line, so the starting position of the query is the end of the line above the cursor.

#![allow(unused)]
fn main() {
fn need_hero(some_hero: Hero, life: Life) -> { // ←─╮
    matches!(some_hero, Hero { // ←╮          ↑     │
        strong: true,//    ↑   ╭───╯          │     │
        fast: true,  //    │   │ query start ─╯     │
        sure: true,  //    ╰───┼ cursor             ├─ traversal
        soon: true,  //        ╰ new line inserted  │  start node
    }) &&            //                             │
    some_hero > life //                             │
} // ←──────────────────────────────────────────────╯
}

From this starting node, the syntax tree is traversed up until the root node. Each indent capture is collected along the way, and then combined according to their capture types and scopes to a final indent level for the line.

Capture types

• @indent (default scope tail): Increase the indent level by 1. Multiple occurrences in the same line do not stack. If there is at least one @indent and one @outdent capture on the same line, the indent level isn't changed at all.
• @outdent (default scope all): Decrease the indent level by 1. The same rules as for @indent apply.
• @indent.always (default scope tail): Increase the indent level by 1. Multiple occurrences on the same line do stack. The final indent level is @indent.always – @outdent.always. If an @indent and an @indent.always are on the same line, the @indent is ignored.
• @outdent.always (default scope all): Decrease the indent level by 1. The same rules as for @indent.always apply.
• @align (default scope all): Align everything inside this node to some anchor. The anchor is given by the start of the node captured by @anchor in the same pattern. Every pattern with an @align should contain exactly one @anchor. Indent (and outdent) for nodes below (in terms of their starting line) the @align node is added to the indentation required for alignment.
• @extend: Extend the range of this node to the end of the line and to lines that are indented more than the line that this node starts on. This is useful for languages like Python, where for the purpose of indentation some nodes (like functions or classes) should also contain indented lines that follow them.
• @extend.prevent-once: Prevents the first extension of an ancestor of this node. For example, in Python a return expression always ends the block that it is in. Note that this only stops the extension of the next @extend capture. If multiple ancestors are captured, only the extension of the innermost one is prevented. All other ancestors are unaffected (regardless of whether the innermost ancestor would actually have been extended).

@indent / @outdent

Consider this example:

#![allow(unused)]
fn main() {
fn shout(things: Vec<Thing>) {
    //                       ↑
    //                       ├───────────────────────╮ indent level
    //                    @indent                    ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄
    //                                               │
    let it_all = |out| { things.filter(|thing| { //  │      1
    //                 ↑                       ↑     │
    //                 ├───────────────────────┼─────┼┄┄┄┄┄┄┄┄┄┄┄┄┄┄
    //              @indent                 @indent  │
    //                                               │      2
        thing.can_do_with(out) //                    │
    })}; //                                          ├┄┄┄┄┄┄┄┄┄┄┄┄┄┄
  //↑↑↑                                              │      1
} //╰┼┴──────────────────────────────────────────────┴┄┄┄┄┄┄┄┄┄┄┄┄┄┄
// 3x @outdent
}

((block) @indent)
["}" ")"] @outdent

Note how on the second line, we have two blocks begin on the same line. In this case, since both captures occur on the same line, they are combined and only result in a net increase of 1. Also note that the closing }s are part of the @indent captures, but the 3 @outdents also combine into 1 and result in that line losing one indent level.

@extend / @extend.prevent-once

For an example of where @extend can be useful, consider Python, which is whitespace-sensitive.

]
  (parenthesized_expression)
  (function_definition)
  (class_definition)
] @indent

class Hero:
    def __init__(self, strong, fast, sure, soon):#  ←─╮
        self.is_strong = strong #                     │
        self.is_fast = fast     # ╭─── query start    │
        self.is_sure = sure     # │ ╭─ cursor         │
        self.is_soon = soon     # │ │                 │
        #     ↑            ↑      │ │                 │
        #     │            ╰──────╯ │                 │
        #     ╰─────────────────────╯                 │
        #                                             ├─ traversal
    def need_hero(self, life):         #              │  start node
        return (                       #              │
            self.is_strong             #              │
            and self.is_fast           #              │
            and self.is_sure           #              │
            and self.is_soon           #              │
            and self > life            #              │
        ) # ←─────────────────────────────────────────╯

Without braces to catch the scope of the function, the smallest descendant of the cursor on a line feed ends up being the entire inside of the class. Because of this, it will miss the entire function node and its indent capture, leading to an indent level one too small.

To address this case, @extend tells helix to "extend" the captured node's span to the line feed and every consecutive line that has a greater indent level than the line of the node.

(parenthesized_expression) @indent

]
  (function_definition)
  (class_definition)
] @indent @extend

class Hero:
    def __init__(self, strong, fast, sure, soon):#  ←─╮
        self.is_strong = strong #                     │
        self.is_fast = fast     # ╭─── query start    ├─ traversal
        self.is_sure = sure     # │ ╭─ cursor         │  start node
        self.is_soon = soon     # │ │ ←───────────────╯
        #     ↑            ↑      │ │                 
        #     │            ╰──────╯ │
        #     ╰─────────────────────╯
    def need_hero(self, life):
        return (
            self.is_strong
            and self.is_fast
            and self.is_sure
            and self.is_soon
            and self > life
        )

Furthermore, there are some cases where extending to everything with a greater indent level may not be desirable. Consider the need_hero function above. If our cursor is on the last line of the returned expression.

class Hero:
    def __init__(self, strong, fast, sure, soon):
        self.is_strong = strong
        self.is_fast = fast
        self.is_sure = sure
        self.is_soon = soon

    def need_hero(self, life):
        return (
            self.is_strong
            and self.is_fast
            and self.is_sure
            and self.is_soon
            and self > life
        ) # ←─── cursor
    #←────────── where cursor should go on new line

In Python, the are a few tokens that will always end a scope, such as a return statement. Since the scope ends, so should the indent level. But because the function span is extended to every line with a greater indent level, a new line would just continue on the same level. And an @outdent would not help us here either, since it would cause everything in the parentheses to become outdented as well.

To help, we need to signal an end to the extension. We can do this with @extend.prevent-once.

(parenthesized_expression) @indent

]
  (function_definition)
  (class_definition)
] @indent @extend

(return_statement) @extend.prevent-once

@indent.always / @outdent.always

As mentioned before, normally if there is more than one @indent or @outdent capture on the same line, they are combined.

Sometimes, there are cases when you may want to ensure that every indent capture is additive, regardless of how many occur on the same line. Consider this example in YAML.

  - foo: bar
# ↑ ↑
# │ ╰─────────────── start of map
# ╰───────────────── start of list element
    baz: quux # ←─── cursor
    # ←───────────── where the cursor should go on a new line
    garply: waldo
  - quux:
      bar: baz
    xyzzy: thud
    fred: plugh

In YAML, you often have lists of maps. In these cases, the syntax is such that the list element and the map both start on the same line. But we really do want to start an indentation for each of these so that subsequent keys in the map hang over the list and align properly. This is where @indent.always helps.

((block_sequence_item) @item @indent.always @extend
  (#not-one-line? @item))

((block_mapping_pair
    key: (_) @key
    value: (_) @val
    (#not-same-line? @key @val)
  ) @indent.always @extend
)

Predicates

In some cases, an S-expression cannot express exactly what pattern should be matched. For that, tree-sitter allows for predicates to appear anywhere within a pattern, similar to how #set! declarations work:

(some_kind
  (child_kind) @indent
  (#predicate? arg1 arg2 ...)
)

The number of arguments depends on the predicate that's used. Each argument is either a capture (@name) or a string ("some string"). The following predicates are supported by tree-sitter:

• #eq?/#not-eq?: The first argument (a capture) must/must not be equal to the second argument (a capture or a string).

• #match?/#not-match?: The first argument (a capture) must/must not match the regex given in the second argument (a string).

• #any-of?/#not-any-of?: The first argument (a capture) must/must not be one of the other arguments (strings).

Additionally, we support some custom predicates for indent queries:

• #not-kind-eq?: The kind of the first argument (a capture) must not be equal to the second argument (a string).

• #same-line?/#not-same-line?: The captures given by the 2 arguments must/must not start on the same line.

• #one-line?/#not-one-line?: The captures given by the fist argument must/must span a total of one line.

Scopes

Added indents don't always apply to the whole node. For example, in most cases when a node should be indented, we actually only want everything except for its first line to be indented. For this, there are several scopes (more scopes may be added in the future if required):

• tail: This scope applies to everything except for the first line of the captured node.
• all: This scope applies to the whole captured node. This is only different from tail when the captured node is the first node on its line.

For example, imagine we have the following function

#![allow(unused)]
fn main() {
fn aha() { // ←─────────────────────────────────────╮
  let take = "on me";  // ←──────────────╮  scope:  │
  let take = "me on";             //     ├─ "tail"  ├─ (block) @indent
  let ill = be_gone_days(1 || 2); //     │          │
} // ←───────────────────────────────────┴──────────┴─ "}" @outdent
                                         //                scope: "all"
}

We can write the following query with the #set! declaration:

((block) @indent
 (#set! "scope" "tail"))
("}" @outdent
 (#set! "scope" "all"))

As we can see, the "tail" scope covers the node, except for the first line. Everything up to and including the closing brace gets an indent level of 1. Then, on the closing brace, we encounter an outdent with a scope of "all", which means the first line is included, and the indent level is cancelled out on this line. (Note these scopes are the defaults for @indent and @outdent—they are written explicitly for demonstration.)

Adding Injection Queries

Writing language injection queries allows one to highlight a specific node as a different language. In addition to the standard language injection options used by tree-sitter, there are a few Helix specific extensions that allow for more control.

And example of a simple query that would highlight all strings as bash in Nix:

((string_expression (string_fragment) @injection.content)
  (#set! injection.language "bash"))

Capture Types

• @injection.language (standard): The captured node may contain the language name used to highlight the node captured by @injection.content.

• @injection.content (standard): Marks the content to be highlighted as the language captured with @injection.language et al.

• @injection.filename (extension): The captured node may contain a filename with a file-extension known to Helix, highlighting @injection.content as that language. This uses the language extensions defined in both the default languages.toml distributed with Helix, as well as user defined languages.

• @injection.shebang (extension): The captured node may contain a shebang used to choose a language to highlight as. This also uses the shebangs defined in the default and user languages.toml.

Settings

• injection.combined (standard): Indicates that all the matching nodes in the tree should have their content parsed as one nested document.

• injection.language (standard): Forces the captured content to be highlighted as the given language

• injection.include-children (standard): Indicates that the content node’s entire text should be re-parsed, including the text of its child nodes. By default, child nodes’ text will be excluded from the injected document.

• injection.include-unnamed-children (extension): Same as injection.include-children but only for unnamed child nodes.

Predicates

• #eq? (standard): The first argument (a capture) must be equal to the second argument (a capture or a string).

• #match? (standard): The first argument (a capture) must match the regex given in the second argument (a string).

• #any-of? (standard): The first argument (a capture) must be one of the other arguments (strings).