Kakoune

Kakoune#

Kakoune is a modal terminal editor that inverted Vim’s grammar; selections come before actions. Helix later picked up the same model. Designed by Maxime Coste in 2010 with “vi-like but stricter and more orthogonal” as the goal.

The Selections-First Model#

Kakoune flips Vim’s verb-then-noun grammar to noun-then-verb. The selection is always visible; you build it explicitly, then act on it. Multi-cursor falls out for free; if you select all matches of a pattern, every subsequent motion or edit applies to all of them.

Vim: d → i → w (delete inner word). Kakoune: w → d (select word, then delete).

The selection is always visible. You build a selection, then act on it. Multi-cursor follows naturally; if you select all matches of a pattern with s, the next motion or action applies to every selection.

Survival Cheat Sheet#

The minimum to be productive in Kakoune. Movement keys extend the current selection from the anchor; multi-cursor verbs (s, S, ,) operate on the set of selections; editing verbs (d, c, y) act on whatever is highlighted right now:

Selection / movement

Keys

Action

h j k l

← ↓ ↑ → (extends from anchor)

w / W

next word / WORD

b / B

prev word / WORD

e / E

end of word / WORD

x

extend selection by line

gg / ge

file top / end

%

select all

Multi-cursor

Keys

Action

s

regex-select within current selection

S

regex-split within current selection

,

clear all selections except one

C

copy selection to next line

&

align selections

Editing

Keys

Action

d

delete selection

c

change (delete + insert)

y / p

yank / paste

u / U

undo / redo

i / a

insert before / after selection

Files#

Kakoune keeps a tiny config surface area: one kakrc and an autoload directory. The configuration language is Kakoune’s own shell-like DSL, compact, focused on hooks and key maps, and not a full programming language:

  • ~/.config/kak/kakrc, main config.

  • ~/.config/kak/autoload/, auto-loaded scripts.

Configuration is in Kakoune’s own scripting language, a small, shell-like DSL.

External Tools, Not Plugins#

Kakoune’s design philosophy: don’t reimplement what shell tools do well. The editor exposes selections to external programs and reads the result back; | pipes through a command, $ substitutes the output, and the surrounding shell takes care of sort, format, search, and fuzzy-find:

  • Sort, pipe selection through sort.

  • Format, pipe through prettier / black / rustfmt.

  • Search, shell out to ripgrep.

  • Fuzzy find, shell out to fzf / sk.

The editor exposes selections to external programs and reads back the result. | pipes, $ reads from a command, etc.

LSP#

LSP support comes via kak-lsp, a separate bridge process that translates between Kakoune and language servers. The split makes LSP a configurable Unix component rather than a built-in feature, which is consistent with Kakoune’s “compose with shell tools” philosophy.

Less seamless than Helix or Neovim; more flexible about which LSP features you wire up.

Strengths#

What Kakoune wins on against Vim and Helix. The selection-first model and Unix-y shell-out approach are both genuinely better ideas; the trade is that you do more wiring yourself than in a batteries-included editor.

  • Selections-first is genuinely a clearer mental model for many.

  • Multi-cursor as a primary feature, not a special mode.

  • Composes with Unix tools, the right philosophy for a Unix editor.

  • Fast and lean.

Weaknesses#

The cost of the small-and-Unix-y design. The ecosystem is thin, most non-trivial features require external tooling you wire up yourself, and platform support outside Linux is limited.

  • Tiny ecosystem compared to Vim / Neovim / Helix.

  • External tooling required for most non-trivial features.

  • Window management is unique (tmux-like).

  • macOS / Windows support limited; primarily a Linux editor.

When to Pick Kakoune#

Pick Kakoune when you want the original selection-first design and prefer building your editing environment out of small, composed pieces. For most users, Helix is “Kakoune’s ideas with batteries included” and a better starting point.

  • You like the selections-first model and want the original.

  • You enjoy composing the editor with shell tools.

  • You’d rather wire up your own pipeline than adopt a plugin ecosystem.

For most users, Helix is “Kakoune’s ideas, with batteries included”. Kakoune itself is for those who want the original and prefer the Unix- y “small editor + external tools” approach.

Contents