Helix

https://docs.helix-editor.com
Admin
Helix is a post-modern text editor written in Rust that provides fast, efficient editing with...
Tokens:47,183
Snippets:791
Trust Score:9.6
Update:1 month ago
Show doc for...
Tokens:
Raw
### Language Server Configuration

Source: https://docs.helix-editor.com/print.html

Sets up a language server with its command, arguments, configuration, and environment variables. This example shows a basic setup for 'mylang-lsp' and a more detailed configuration for 'efm-lsp-prettier' including formatting options.

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

```toml
[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 } ] }
```

--------------------------------

### Install Helix using Snap

Source: https://docs.helix-editor.com/package-managers.html

Install Helix using Snapcraft. This command installs Helix as both '/snap/bin/helix' and '/snap/bin/hx'.

```bash
snap install --classic helix
```

--------------------------------

### Rust Code Example for Indentation Traversal

Source: https://docs.helix-editor.com/guides/indent.html

Illustrates the traversal path for indentation calculation starting from a specific node in a Rust code snippet. This example shows the cursor position and where the query starts for indentation analysis.

```rust
#![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
}
}

```

--------------------------------

### Install Helix on Windows using Scoop

Source: https://docs.helix-editor.com/package-managers.html

Install Helix using the Scoop package manager.

```bash
scoop install helix
```

--------------------------------

### Install Helix on Windows using Winget

Source: https://docs.helix-editor.com/package-managers.html

Install Helix using the Windows Package Manager (winget). Ensure App Installer is updated.

```bash
winget install Helix.Helix
```

--------------------------------

### Install Helix using Flatpak

Source: https://docs.helix-editor.com/package-managers.html

Install Helix from Flathub and run it. This method provides a sandboxed environment.

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

--------------------------------

### Detailed Language Configuration Example

Source: https://docs.helix-editor.com/print.html

A comprehensive example of language configuration for 'mylang', including scope, file types, comment tokens, indentation, and language servers.

```toml
[[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" ]
```

--------------------------------

### Install Helix on Windows using Chocolatey

Source: https://docs.helix-editor.com/package-managers.html

Install Helix using the Chocolatey package manager.

```bash
choco install helix
```

--------------------------------

### Install Helix on Fedora/RHEL

Source: https://docs.helix-editor.com/package-managers.html

Install Helix using the dnf package manager.

```bash
sudo dnf install helix
```

--------------------------------

### Install Helix on Ubuntu/Debian using PPA

Source: https://docs.helix-editor.com/package-managers.html

Add the PPA for Helix and update your package list, then install Helix. This is for systems older than Ubuntu 22.04, Mint 21, or Debian 12 if building from source is needed.

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

--------------------------------

### Basic Language Configuration

Source: https://docs.helix-editor.com/print.html

Example of a basic language configuration for 'rust' in `languages.toml`, disabling auto-formatting.

```toml
[[language]]
name = "rust"
auto-format = false
```

--------------------------------

### Install Helix on Arch Linux

Source: https://docs.helix-editor.com/package-managers.html

Install Helix from the 'extra' repository. Note that when installed this way, Helix is run with 'helix' instead of 'hx'.

```bash
sudo pacman -S helix
```

--------------------------------

### Example Function Call Syntax

Source: https://docs.helix-editor.com/syntax-aware-motions.html

Illustrates a common syntax for function calls in many programming languages.

```plaintext
func(arg1, arg2, arg3);
```

--------------------------------

### Install Helix on macOS using Homebrew

Source: https://docs.helix-editor.com/package-managers.html

Install Helix using the Homebrew package manager.

```bash
brew install helix
```

--------------------------------

### Rust Code Example for 'O' Indentation Traversal

Source: https://docs.helix-editor.com/guides/indent.html

Demonstrates the indentation traversal for the 'O' command in Helix, where the query starts from the line above the cursor. This highlights the starting position of the query and the cursor's relation to the new line insertion.

```rust
#![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 //                             │
} // ←──────────────────────────────────────────────╯
}

```

--------------------------------

### Install Helix (Reproducible Build)

Source: https://docs.helix-editor.com/print.html

Install the Helix terminal application using Cargo with a reproducible build profile. This command also builds the tree-sitter grammars.

```bash
# Reproducible
car go install --path helix-term --locked
```

--------------------------------

### Configure Indent Guides

Source: https://docs.helix-editor.com/print.html

Customize the appearance and behavior of indent guides. You can enable them, change the character used, and specify the number of indent levels to skip.

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

--------------------------------

### Install cargo-deb for .deb Package Building

Source: https://docs.helix-editor.com/building-from-source.html

Install the cargo-deb tool, which is used for building .deb packages for Debian-based systems.

```bash
cargo install cargo-deb
```

--------------------------------

### Install Helix on macOS using MacPorts

Source: https://docs.helix-editor.com/package-managers.html

Install Helix using the MacPorts package manager.

```bash
sudo port install helix
```

--------------------------------

### Example Rust code with diagnostics

Source: https://docs.helix-editor.com/print.html

Illustrates how diagnostics are rendered inline within the code, showing errors and suggestions.

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

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

--------------------------------

### Install Helix (Optimized Build)

Source: https://docs.helix-editor.com/print.html

Install the Helix terminal application using Cargo with an optimized build profile. This command enables native CPU features and builds tree-sitter grammars.

```bash
# Optimized
car go install \
   --profile opt \
   --config 'build.rustflags="-C target-cpu=native"' \
   --path helix-term \
   --locked
```

--------------------------------

### Ignore File Example for Helix

Source: https://docs.helix-editor.com/editor.html

This example demonstrates how to use negative ignore rules in a Helix ignore file to unignore specific directories or files in the file picker and global search.

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

--------------------------------

### Install Helix on Windows using MSYS2

Source: https://docs.helix-editor.com/package-managers.html

Install Helix for 64-bit Windows 8.1 or above using the MSYS2 package manager.

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

--------------------------------

### Configure Indent Guides

Source: https://docs.helix-editor.com/editor.html

Customize the appearance and behavior of indent guides. You can enable/disable them, change the character used, and specify the number of indent levels to skip.

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

```

--------------------------------

### Example Function with Indentation Scopes

Source: https://docs.helix-editor.com/guides/indent.html

Illustrates how different indentation scopes ('tail' and 'all') affect the indentation of code blocks and closing braces.

```rust
#![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"
}

```

--------------------------------

### Install Helix as 'hx' using AppImage

Source: https://docs.helix-editor.com/package-managers.html

Move the downloaded Helix AppImage to a directory in your PATH and rename it to 'hx'. Ensure '~/.local/bin' is in your PATH.

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

--------------------------------

### Example of Inline Diagnostics in Rust

Source: https://docs.helix-editor.com/editor.html

Illustrates how Rust code with a scope error is displayed with inline diagnostics.

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

--------------------------------

### Compile Helix (Optimized Build)

Source: https://docs.helix-editor.com/building-from-source.html

Install the Helix terminal application with optimizations enabled. This command uses profile 'opt' and targets native CPU features for better performance.

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

--------------------------------

### Configure a Basic Language Server

Source: https://docs.helix-editor.com/languages.html

Set up a language server by defining its command, arguments, and initialization configuration in the `language-server` table.

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

--------------------------------

### Execute Shell Command Expansion

Source: https://docs.helix-editor.com/command-line.html

Expansions starting with '%' can execute shell commands. For example, `%sh{echo hi!}` will run the echo command and insert its output.

```helix
%sh{echo hi!}
```

--------------------------------

### Configure Formatter with Command Line Expansions

Source: https://docs.helix-editor.com/languages.html

Formatters can be configured using the `formatter` key, supporting command-line expansions like `%{buffer_name}` to pass dynamic arguments.

```toml
formatter = { command = "mylang-formatter" , args = ["--stdin", "--stdin-filename %{buffer_name}"] }
```

--------------------------------

### Example Helix Configuration

Source: https://docs.helix-editor.com/configuration.html

This TOML file demonstrates how to set global configuration parameters for the Helix editor, such as theme, line numbers, mouse support, cursor shape, and file picker settings.

```toml
theme = "onedark"

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

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

[editor.file-picker]
hidden = false

```

--------------------------------

### Configure Editor Gutters (Simple)

Source: https://docs.helix-editor.com/editor.html

Set the default gutters to display in the editor by providing an array of gutter types.

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

```

--------------------------------

### Example Helix Configuration

Source: https://docs.helix-editor.com/print.html

This TOML snippet demonstrates common configuration options for the Helix editor, such as theme, line numbers, cursor shape, and file picker settings. Place this in `~/.config/helix/config.toml`.

```toml
theme = "onedark"

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

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

[editor.file-picker]
hidden = false
```

--------------------------------

### Configure Editor Gutters (Simple)

Source: https://docs.helix-editor.com/print.html

Set the gutters to display using a simple array of gutter types. This uses default settings for each gutter component.

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

--------------------------------

### Prepare Helix AppImage for PATH

Source: https://docs.helix-editor.com/print.html

Make the Helix AppImage executable and move it to a directory in your system's PATH. This allows you to run Helix using the 'hx' command.

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

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

--------------------------------

### Make Helix executable and run AppImage

Source: https://docs.helix-editor.com/package-managers.html

Download the Helix AppImage, change its permissions to make it executable, and then run it. Ensure the AppImage file is named correctly.

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

--------------------------------

### Helix Tutor Command

Source: https://docs.helix-editor.com/print.html

Access the interactive tutorial for Helix using the '--tutor' flag or the ':tutor' command. This is recommended for a full introduction to the editor.

```bash
hx --tutor
```

--------------------------------

### Define Theme Key with Full Styling

Source: https://docs.helix-editor.com/themes.html

Use this format to specify foreground, background, underline, and modifiers for a theme key.

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

--------------------------------

### Indentation Scopes: Tail and All

Source: https://docs.helix-editor.com/guides/indent.html

Demonstrates the use of 'tail' and 'all' scopes with @indent and @outdent captures to control which parts of a node are indented.

```tree-sitter query
((block) @indent
 (#set! "scope" "tail"))
("}" @outdent
 (#set! "scope" "all"))
```

--------------------------------

### Toggle boolean option in Helix

Source: https://docs.helix-editor.com/command-line.html

Use :toggle-option with just the option name to flip its boolean state. For example, :toggle-option auto-format.

```shell
:toggle-option auto-format
```

--------------------------------

### Example of End-of-Line Diagnostic in Rust

Source: https://docs.helix-editor.com/editor.html

Shows Rust code with both an inline diagnostic and an end-of-line diagnostic, indicating a variable name suggestion.

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

--------------------------------

### Insert Unicode Character

Source: https://docs.helix-editor.com/command-line.html

Use the %u{} expansion to insert a Unicode character by its hexadecimal codepoint. This example inserts a black circle.

```helix
:echo %u{25CF}
```

--------------------------------

### Paste from Register Example

Source: https://docs.helix-editor.com/print.html

Shows how to paste the content of register 'o' after the current selection. Registers provide a mechanism similar to clipboards in other editors.

```helix-script
"op
```

--------------------------------

### Create Symbolic Link for Runtime (Windows - Cmd)

Source: https://docs.helix-editor.com/print.html

Create a symbolic link for Helix runtime files using the `mklink` command in Windows Command Prompt. This links the AppData directory to the source code directory.

```cmd
cd %appdata%\helix
`mklink /D runtime "%userprofile%\src\helix\runtime"
```

--------------------------------

### Helix Indentation Query for 'O' command

Source: https://docs.helix-editor.com/print.html

Illustrates the starting position for the indentation query when inserting a new line above the cursor using the 'O' command.

```rust
#![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 //                             │
} // ←──────────────────────────────────────────────╯
}
```

--------------------------------

### Helix Indentation Query for 'o' command

Source: https://docs.helix-editor.com/print.html

Demonstrates the starting position for the indentation query when inserting a new line below the cursor using the 'o' command.

```rust
#![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
}
}
```

--------------------------------

### Check Helix health on Arch Linux

Source: https://docs.helix-editor.com/package-managers.html

After installing from the 'extra' repository, use 'helix --health' to check the editor's health.

```bash
helix --health
```

--------------------------------

### Open Multiple Files

Source: https://docs.helix-editor.com/print.html

Arguments are split by default on tabs and spaces. Use quotes to include spaces in filenames.

```helix
:open README.md CHANGELOG.md
```

```helix
:open 'a b.txt'
```

```helix
:open "a b.txt"
```

--------------------------------

### Insert Current Line Number

Source: https://docs.helix-editor.com/command-line.html

Use the %{} expansion to insert editor variables. This example inserts the current cursor line number into the statusline.

```helix
:echo %{cursor_line}
```
Tokens:
Raw