Installation

We provide pre-built binaries on the GitHub Releases page.

OSX

A Homebrew tap is available:

brew tap helix-editor/helix
brew install helix

Linux

NixOS

A flake containing the package is available in the project root. The flake can also be used to spin up a reproducible development shell for working on Helix.

Arch Linux

Binary packages are available on AUR:

• helix-bin contains the pre-built release
• helix-git builds the master branch

Build from source

git clone --recurse-submodules --shallow-submodules -j8 https://github.com/helix-editor/helix
cd helix
cargo install --path helix-term

This will install the hx binary to $HOME/.cargo/bin.

Helix also needs it's runtime files so make sure to copy/symlink the runtime/ directory into the config directory (for example ~/.config/helix/runtime on Linux/macOS). This location can be overriden via the HELIX_RUNTIME environment variable.

Usage

(Currently not fully documented, see the keymappings list for more.)

Surround

Functionality similar to vim-surround is built into helix. The keymappings have been inspired from vim-sandwich:

• ms - Add surround characters
• mr - Replace surround characters
• md - Delete surround characters

ms acts on a selection, so select the text first and use ms<char>. mr and md work on the closest pairs found and selections are not required; use counts to act in outer pairs.

It can also act on multiple seletions (yay!). For example, to change every occurance of (use) to [use]:

• % to select the whole file
• s to split the selections on a search term
• Input use and hit Enter
• mr([ to replace the parens with square brackets

Multiple characters are currently not supported, but planned.

Textobjects

Currently supported: word, surround.

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

Textobjects based on treesitter, like function, class, etc are planned.

Configuration

To override global configuration parameters create a config.toml file located in your config directory (i.e ~/.config/helix/config.toml).

LSP

To display all language server messages in the status line add the following to your config.toml:

[lsp]
display-messages = true

Themes

First you'll need to place selected themes in your themes directory (i.e ~/.config/helix/themes), the directory might have to be created beforehand.

To use a custom theme add theme = <name> to your config.toml or override it during runtime using :theme <name>.

The default theme.toml can be found here, and user submitted themes here.

Creating a theme

First create a file with the name of your theme as file name (i.e mytheme.toml) and place it in your themes directory (i.e ~/.config/helix/themes).

Each line in the theme file is specified as below:

key = { fg = "#ffffff", bg = "#000000", modifiers = ["bold", "italic"] }

where key represents what you want to style, fg specifies the foreground color, bg the background color, and modifiers is a list of style modifiers. bg 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"

Possible modifiers:

Possible keys:

These keys match tree-sitter scopes. We half-follow the common scopes from macromates language grammars with some differences.

For a given highlight produced, styling will be determined based on the longest matching theme key. So it's enough to provide function to highlight function.macro and function.builtin as well, but you can use more specific scopes to highlight specific cases differently.

Color palettes

You can define a palette of named colors, and refer to them from 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"

Remember that the [palette] table includes all keys after its header, so you should define the palette after normal theme options.

Keymap

Normal mode

Movement

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

Changes

Selection manipulation

Insert Mode

Search

TODO: The search implementation isn't ideal yet -- we don't support searching in reverse, or searching via smartcase.

Diagnostics

NOTE: [ and ] will likely contain more pair mappings in the style of vim-unimpaired

Select / extend mode

I'm still pondering whether to keep this mode or not. It changes movement commands to extend the existing selection instead of replacing it.

NOTE: It's a bit confusing at the moment because extend hasn't been implemented for all movement commands yet.

View mode

View mode is intended for scrolling and manipulating the view without changing the selection.

Goto mode

Jumps to various locations.

NOTE: Some of these features are only available with the LSP present.

Match mode

Enter this mode using m from normal mode. See the relavant section in Usage for an explanation about surround and textobject usage.

Object mode

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

Window mode

This layer is similar to vim keybindings as kakoune does not support window.

Space mode

This layer is a kludge of mappings I had under leader key in neovim.

Picker

Keys to use within picker.

Key Remapping

One-way key remapping is temporarily supported via a simple TOML configuration file. (More powerful solutions such as rebinding via commands will be available in the feature).

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

# At most one section each of 'keys.normal', 'keys.insert' and 'keys.select'
[keys.normal]
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 Control-Shift-Escape to extend_line

[keys.insert]
A-x = "normal_mode" # Maps Alt-X to enter normal mode

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

Commands can be found in the source code at helix-term/src/commands.rs

Hooks