How to Use Helix: The Beginner's Guide (First File, the Selection-First Lesson, Multi-Cursor, and the LSP Habit)

CodexFuse Team · 2026-10-30T12:29:14.372Z · 10 min read

If you have ever watched a developer fly through code without touching the mouse and wondered how they do it, you have probably seen modal editing in action. Helix is a modern, terminal-based text editor that brings that keyboard-first style to a new generation of developers. This guide explains how to use Helix: how to install it, run its built-in tutor, understand its selection-first editing model, use multiple cursors, connect language servers, and configure it to your taste. If you already version your projects with Git, Helix fits naturally into that workflow — our Git beginner guide covers the version-control side of the same terminal-first setup.

What is the Helix editor?

Helix is a modal text editor that runs in your terminal. It is written in Rust and takes inspiration from Kakoune and Vim, but it ships with modern features built in rather than bolted on: tree-sitter syntax highlighting, multiple selections, and first-class support for the Language Server Protocol (LSP). The official documentation describes its core idea in three words: selection first, then action.

That phrase is the whole mental model. In most editors you pick an action and then point at the text it should affect. In Helix you do the opposite: you select the text first, watching the highlight so you know exactly what will change, and then you press the key for the action. A cursor is simply treated as a single-character-wide selection. Once this clicks, the rest of the editor feels inevitable.

Helix's other headline feature is that it arrives pre-configured with sensible defaults. You do not need a plugin manager or a weekend of configuration to get syntax highlighting, fuzzy file finding, or LSP-powered autocomplete — those work out of the box. The binary you type to launch it is hx (on Arch Linux's extra repository it is helix instead — a quirk the official install docs call out explicitly).

How do you install Helix?

The typical way to install Helix is through your operating system's package manager, according to the official installation docs. Pick your platform:

You can also download pre-built binaries from the project's GitHub Releases page. The tarball contains an hx binary and a runtime directory: put the binary on your PATH and copy the runtime folder to a location hx searches, typically ~/.config/helix/runtime on Linux and macOS. Running hx --health afterwards shows you which runtime directories Helix is actually using — a useful sanity check we will return to in the language-server section.

To confirm the install worked, type hx --version in your terminal. If you see a version number, you are ready for the most important step in this whole guide.

What should you do right after installing Helix?

Run the built-in interactive tutor before you read a single cheat sheet. Type hx --tutor (or open Helix and type :tutor) and work through the lessons inside the editor itself. The official usage docs point every newcomer to this tutor first, and the advice is worth taking literally: the tutor teaches cursor movement, modes, selections, and saving by having you perform them, which sticks far better than memorizing a table of keys.

The tutor takes roughly fifteen minutes. Finish it, then come back here for the concepts that turn the mechanics into a workflow.

How do Helix's modes work?

Helix is modal, which means the keys on your keyboard do different things depending on the mode you are in. There are three modes you will use constantly:

• Normal mode (shown as NOR in the status line) is the default. Keys are editing commands here — pressing j moves down a line instead of typing the letter j.
• Insert mode (shown as INS) is for typing text directly. Press i in Normal mode to enter it.
• Select mode (sometimes called extend mode) is for growing selections. Press v in Normal mode to enter it.

You always return to Normal mode with Esc, and you will press it hundreds of times a day. Because Esc sits far from the home row on most keyboards, many Helix users remap Caps Lock to Escape at the operating-system level — the official tutorial itself suggests this. For the complete list of Helix keybindings beyond this starter set, the official documentation includes a full keymap reference covering every mode.

For your first file, run hx file.txt. You land in Normal mode. Press i, type a sentence, press Esc, and you have completed the core loop: navigate and command in Normal mode, type in Insert mode, Esc to switch back.

What does "selection first" actually mean in Helix?

This is the lesson that separates Helix users from people who bounce off it in ten minutes, so it is worth stating plainly one more time: in Helix you select the text first, then you act on it. Vim-trained fingers expect the opposite — an action followed by a target, like dw to delete a word. In Helix the motion keys themselves create selections, and the action key comes last.

Here is the muscle-memory starter set from the official tutorial. Each of these both moves and selects:

• x selects the entire current line.
• e selects to the end of the current word; b selects back to its beginning.
• t followed by a character selects up to (but not including) that character — t; selects to the next semicolon. f works the same way but includes the character.
• ; collapses the selection back to a cursor.

Once something is selected, the actions are single letters: y yanks (copies) the selection, d deletes it, p pastes after the cursor, and c changes it — deleting the selection and dropping you into Insert mode so you can type the replacement. Because you can see the highlight before you act, you always know exactly what d or c is about to touch. That visible confirmation is the whole point of the philosophy.

Try it on one line of text: press x to select the line, y to yank it, then p a few times to paste copies. Then put your cursor on a word, press e to select it, and press c to replace it. You have just learned the pattern behind nearly everything in Helix.

How do multiple cursors work in Helix?

Multiple cursors — more precisely, multiple selections — are a core interaction in Helix, not a plugin feature. The official docs describe the standard workflow for renaming every instance of a word: first create one selection per instance, then press c and edit them all at the same time.

The fastest way to feel this is the C key. With a selection active, pressing capital C copies the selection to the line below, adding a second cursor. Press it a few more times and you have a column of cursors; type once and the text appears in all of them. It is the quickest route from "I need to edit these five similar lines" to done.

For the scattered-matches case, the pattern is % then s: % selects the whole file, and s opens a select: prompt where you type a search pattern. Every match becomes its own selection, and a single c lets you rewrite them all simultaneously. When you are finished, , collapses everything back to the primary cursor.

How do you set up language servers in Helix?

Helix speaks the Language Server Protocol out of the box, which is what powers go-to-definition, hover documentation, autocompletion, and format-on-save. One thing to understand up front: the language servers themselves are separate programs you install on your own — Helix detects and talks to them, but it does not bundle them.

Make hx --health a habit. Run it after installing Helix and again after installing any language server; it reports which servers Helix can find for each language and which are missing. The wiki's language-server pages carry per-language install instructions, since the command differs for Rust's rust-analyzer, Python's pyright, TypeScript's typescript-language-server, and everything else.

When a server needs non-default settings, they go in languages.toml next to your main config — and you can drop a .helix/languages.toml file at the root of a project to override settings for that project only. If your editor auto-formats on save, that is the LSP doing it: the official FAQ notes that formatting happens when the language server supports it and auto-format is enabled. Checking hx --health first and configuring second is the order that saves you from debugging the wrong layer.

How do you configure Helix?

Helix keeps its configuration in TOML files — no scripting language to learn. Your personal config lives at ~/.config/helix/config.toml on Linux and macOS, or %AppData%\helix\config.toml on Windows. The quickest way to open it is from inside the editor: type :config-open in Normal mode.

A sensible first edit is the theme. Helix bundles popular themes including gruvbox, tokyonight, dracula, everforest, github, and catppuccin. Type :theme to pick one interactively, or set it permanently with theme = "tokyonight" in config.toml. Small quality-of-life tweaks use the same file — for example, the official FAQ shows setting a bar-style cursor in Insert mode:

[editor.cursor-shape]
insert = "bar"

Key remapping lives under [keys.normal] and [keys.insert] in the same file. One caution worth heeding: the TOML schema evolves between releases, so when you copy a snippet from a blog post or forum thread, check it against the current configuration docs before pasting it into your own file.

Helix vs Vim and Neovim: what is actually different?

Helix is often described as "Vim-like," which is true about the keyboard grammar and misleading about the philosophy. If you are coming from Vim or Neovim, three differences matter:

None of this makes Helix "better" in any absolute sense — Neovim's plugin ecosystem can do things Helix cannot, and Vim runs everywhere. The honest pitch is narrower: if you want modal editing with modern IDE features and you would rather edit text than maintain an editor configuration, Helix removes the second job. Our VS Code beginner guide covers the other end of the spectrum, for when you want a full graphical IDE instead of a terminal editor.

Your first 15 minutes with Helix: a walkthrough

Here is the whole guide condensed into one practice session. Do it in order, in a scratch file:

1. Install Helix with your package manager and confirm it with hx --version.
2. Run hx --tutor and complete the interactive lessons (about 15 minutes).
3. Open a scratch file with hx notes.txt. Press i, type three lines, press Esc.
4. Move with h, j, k, l. Press x to select a line, y to yank it, p to paste it twice.
5. Put the cursor on a word and press e — watch the word highlight. Press c, type a replacement, press Esc. That is selection-first editing.
6. Select a line with x, then press C three times to stack cursors on the lines below. Type something and watch it appear in all four. Press , to collapse back to one cursor.
7. Press Space then f to open the file picker; Space then ? opens the command palette for discovering keys you have not learned yet.
8. Save with :w and quit with :q (or :wq for both). Run hx --health in your shell to see which language servers are available.
9. Open your config with :config-open, set a theme, save, and restart Helix.

Developers who live in the terminal often pair Helix with a multiplexer so the editor survives dropped connections and shares the screen with a shell — our tmux beginner guide walks through that setup. And when your scratch file grows into a real project, our GitHub beginner guide picks up where this guide leaves off: pushing that code to a remote repository.

Sources

• Helix official documentation — Usage page (docs.helix-editor.com/usage.html): modal editing model, selection → action philosophy, multiple selections, tutor access via hx --tutor / :tutor. Fetched 2026-10-30.
• Helix official documentation — Installation page (docs.helix-editor.com/install.html): package-manager-first install guidance, pre-built binary + runtime directory setup, hx --health runtime check. Fetched 2026-10-30.
• Helix official documentation — Package Managers page (docs.helix-editor.com/package-managers.html): PPA, dnf, pacman, Homebrew, winget, Scoop, Chocolatey, Flatpak, Snap, AppImage commands; Arch helix vs hx naming note. Fetched 2026-10-30.
• Helix GitHub Wiki — "1. Tutorial: Getting Started" (github-wiki-see.page mirror): opening files, NOR/INS modes, movement, selection-first lesson, yank/paste/delete/change, undo/redo, save/quit commands, goto-word, search, registers, t/f motions. Fetched 2026-10-30.
• Helix GitHub Wiki — FAQ (github-wiki-see.page mirror): hx --tutor as the learning entry point, collapsing to a single cursor with ,, :config-open, cursor-shape config example, LSP auto-format on save, hx -v logging. Fetched 2026-10-30.
• kwmiebach's Helix tutor gist (gist.github.com): the interactive in-editor tutor lesson script — modes, cursor movement, exiting, saving. Fetched 2026-10-30.
• "A Walkthrough on Helix — A Post-Modern Modal Text Editor" (readmedium.com): Kakoune/Neovim inspiration, Rust implementation, built-in LSP, config file paths, :theme, bundled themes, Space-mode pickers, hx --health for language-server status, DAP experimental note. Fetched 2026-10-30.

Frequently asked questions

Is Helix hard to learn if I have never used Vim?

Coming in fresh is arguably easier than switching from Vim. You have no verb-first muscle memory to unlearn, so the selection-first model is simply "how editing works" rather than a habit to fight. Run hx --tutor first and give it a week of real use before judging it.

Does Helix work on Windows?

Yes. The official package-manager docs list Winget (winget install Helix.Helix), Scoop, Chocolatey, and MSYS2 as supported install routes, and the config file lives at %AppData%\helix\config.toml on Windows.

Do I need to install plugins for autocompletion in Helix?

No — that is one of Helix's main selling points. Autocompletion, go-to-definition, and hover docs come from language servers over LSP, which Helix supports natively. You only need to install the language server binaries themselves; run hx --health to see which ones Helix can find.

How is Helix different from Neovim?

Three things: Helix selects text before acting on it (Neovim acts first, then takes a target), Helix ships LSP and tree-sitter support with no plugins, and Helix configures with TOML files instead of Lua. Neovim's plugin ecosystem remains far larger, so the choice is really about whether you want a batteries-included editor or a customizable platform.

Where is the Helix config file?

On Linux and macOS it is ~/.config/helix/config.toml; on Windows it is %AppData%\helix\config.toml. Type :config-open inside Helix to open it directly, and remember to verify any copied config snippet against the current documentation, since the TOML schema changes between releases.