Helix: the modal editor that needs no configuration

In an era where editors race to embed AI assistants, Helix goes the other way: a modal editor written in Rust, no plugin system, no AI features, and a README that lists exactly four capabilities. With 46,133 stars and an MPL-2.0 license (per GitHub API on 2026-09-08), it sits among the most trusted editors in the modal class — and its three design decisions are worth disassembling more than its feature list.

TL;DR

• Helix inherits Kakoune thoroughly: selection → action — pick the object first, act second.
• LSP, tree-sitter, the debug adapter, and git diff all live in the workspace as dedicated crates, not plugins.
• Configuration is one small config.toml; the interactive tutor hx --tutor ships inside the binary.
• Stable releases follow CalVer about twice a year (25.01, 25.07) while master keeps moving (per GitHub API on 2026-09-08).
• The lesson for Wakii: a runnable tutor beats a readable doc; and agent features must never slow plain editing down.

Selection first, action second

Vim teaches the action → object model: to delete inside a word, you type the verb first and the object second. Kakoune reverses that order, and Helix credits the inheritance openly — the README introduces it as “A Kakoune / Neovim inspired editor, written in Rust” (helix-editor/helix README, accessed 2026-09-08).

The project’s guide names the model: “Helix follows the selection → action model” (book/src/usage.md @ commit 079a789). You see the object first — the selection is highlighted on screen — and then type the action. Even the cursor definition follows suit: “A cursor is simply a single width selection.”

vim:    [verb] → [object]      act first, see the object later
helix:  [object] → [verb]      see the object first, act second

The biggest design consequence is multiple selections. To replace several occurrences of a word in Helix, you select all of them first — each occurrence becomes a selection — and then a single change action applies to all of them at once. A selection is not a side effect of the cursor; it is the central data structure that every action consumes.

LSP and tree-sitter in the core, not in plugins

Helix has no plugin runtime — and the way it avoids needing one is to put every capability in the core, one crate per capability. The workspace splits into more than fifteen crates:

crate	role
helix-core	text primitives + syntax
helix-view	document + editor state
helix-term	TUI runtime
helix-lsp	LSP client
helix-dap	debug adapter
helix-vcs	git diff gutter

(source: root directory @ commit 079a789, probed 2026-09-08 — plus helix-event, helix-loader, helix-tui, helix-parsec, helix-stdx)

The syntax layer deserves a close look. helix-core/src/syntax.rs is built on tree_house, the project’s own tree-sitter integration:

use tree_house::{
    highlighter,
    query_iter::QueryIter,
    tree_sitter::{
        query::{InvalidPredicateError, UserPredicate},
        Capture, Grammar, InactiveQueryCursor, InputEdit, Node, Pattern, Query, RopeInput, Tree,
    },
    Error, InjectionLanguageMarker, LanguageConfig as SyntaxConfig, Layer,
};

(source: helix-core/src/syntax.rs @ commit 079a789, probed 2026-09-08)

Highlighting runs incrementally directly on the rope (the text data is a ropey::RopeSlice), and InjectionLanguageMarker shows that language injection — highlighting SQL embedded in a Python string, say — is handled in the same layer. No marketplace, no plugin ABI, no added attack surface: every feature gets reviewed like core code.

One config.toml against configuration sprawl

The configuration chapter in the guide opens with exactly one file: config.toml in your OS config directory. The example in the docs is compact enough to quote in full:

theme = "onedark"

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

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

(source: book/src/configuration.md @ commit 079a789, accessed 2026-09-08)

Defaults are chosen for you, deliberately — you only override what you want different. The :config-open command opens the config file inside the editor itself, no path hunting required. And onboarding lives inside the binary: hx --tutor opens an interactive tutorial that runs in the real editor, offline, with no docs tab needed. That is how an opinionated tool treats newcomers: good defaults plus a runnable lesson, instead of a 40-option checklist you must read first.

An editor with no AI, and why it is still worth studying

The four README features: modal editing, multiple selections, built-in LSP, tree-sitter — not a single line mentions AI or agents. In 2026, an editor with 46,000 stars (per GitHub API on 2026-09-08) sitting out the AI assistant race is a readable stance: the editor stays a sharp, predictable tool; agents live outside and attach to any editor through a terminal. Among editors, Helix is the valuable counter-pole: not every project needs to embed agents, and for the ones that do, the price of embedding is never breaking the plain editing experience.

The release cadence speaks the same language: stable builds ship on CalVer about twice a year (25.01 in January 2025, 25.07 in July 2025, with 25.07.1 on 2025-07-18), while master got a fresh push on 2026-09-01 (per GitHub API on 2026-09-08). Development never stops — but a release is a stability snapshot, not a weekly feature-delivery channel.

Wakii takes the opposite direction — an agent-first IDE — yet shares one onboarding principle: it runs right after install, no environment assembly required. That principle lives on the getting started page, and how the built-in agent team works from the first minute is told in the zero-setup agent team.

What Wakii learns

• ADOPT — a runnable tutor shipped with the product: hx --tutor lets a newcomer take the lesson inside the real tool, offline, no external docs. Wakii has no equivalent surface today — getting-started is a document to read, and the registry has no tutor. Concrete proposal: ship a sandbox sample story in the kit that runs end-to-end offline, so newcomers learn by running one real story in a safe environment.
• WATCH — the “plain editing must not get slower” stance: Helix embeds no AI, so it pays nothing; Wakii does embed agents, so the thing to track is keyboard-first responsiveness as each agent feature lands. Condition to promote to DIRECTION: a measured regression in editing experience tied to a specific agent feature.
• N/A — the CalVer cadence of two releases a year: right for a mature personal editor; Wakii is an agent platform where a fast release pace is the deliberate product choice (two releases on the same day, 2026-09-05, verified). Not applicable.

If you are curious about the opposite pole — an IDE where the agent is the center — the agents and kit docs describe how Wakii’s nine-agent team divides the work in every story.