Vim vs Kakoune (October 2025): the modal showdown you actually feel in your fingers

vim vs Kakoune

You don’t use a modal editor so much as you speak it. Vim’s sentences start with a verb. Kakoune flips the grammar and starts with the object. That single twist—action→target vs selection→action—shifts everything: the way you think about refactors, how your hands travel, what “multicursor” even means. This guide compares Vim and Kakoune as they stand in October 2025, with fresh features, practical workflows, and a no-nonsense verdict so you can pick the one that fits your brain (and your keyboard).

TL;DR

Pick Vim if you need maximal portability (Linux/macOS/Windows native), a galaxy of plugins, and the comfort of the classic verb→motion editing language—now with modern niceties like virtual text, smooth scrolling, diff anchors, Wayland clipboard, and Vim9 performance.
Pick Kakoune if you crave selections-first editing, multicursor as a default, lean shell composability, and a snappy, minimalist core—plus a steady 2024–2025 release cadence and a cleaner kak-lsp setup for LSP.
Windows-only? Vim, full stop. Kakoune remains Unix-first (WSL/Cygwin works great; native Windows build isn’t the goal).
Big refactors, lots of carets at once? Kakoune’s selections model often wins. Mixed stacks, legacy servers, GUI needs? Vim’s portability and plugin ecosystem shine.

What’s new in 2024–2025 (practical impact, not changelog trivia)

Vim highlights

Virtual text and smooth scrolling make modern LSP UX (inlay hints, diagnostics overlays) feel native instead of bolted on.
Wayland clipboard landed in 9.1.x—copy/paste Just Works™ in Wayland sessions.
Diff anchors + inline word/char diffs make code reviews inside Vim far clearer.
Vim9 script keeps getting stronger (generics, tuples), so performance-friendly config is simpler than it used to be.
Daily ARM64 Windows builds and ongoing polish make Vim the safe bet for heterogenous fleets.

Kakoune highlights

2025.06 shipped quality-of-life upgrades (e.g., colored double underlines for diagnostics, git apply on your current selection), reinforcing the “selections first” superpower.
2024.05 added session/daemon improvements and smarter completion hooks that feel instantaneous.
kak-lsp v18 simplified minimal LSP setup to one eval + one enable and moved config into Kakoune options—cleaner, fewer files, less yak-shaving.

The editing models: verb→object vs object→verb

Concept	Vim	Kakoune
Mental model	Do something to text	Choose text, then do something
Typical flow	`ciw` (change inner word)	`w` to select the word, then `c` to change
Multicursor	Via plugins/visual block/regex; powerful but optional	Built-in default: every operation can fan out to many selections
Discoverability	Historic keystroke language, endless add-ons	Fewer built-ins, but highly interactive feedback while selecting
Shell philosophy	Plenty of built-ins; pipes are additive	Lean core + Unix filters; pipe selections through external tools

That model flip is not cosmetic. It decides who wins when you’re doing mass edits, sweeping structural changes, or surgical renames across dozens of spots at once.

LSP & IDE-ish features (2025 reality)

Vim (modern, plugin-driven)

Works everywhere and plays nice with corporate images.
3 popular routes:
1. vim-lsp (Vim9-native, lightweight),
2. ALE (linting + LSP),
3. coc.nvim (VS Code-like power via Node).
Virtual text + smooth scroll make diagnostics/inlay hints pleasant, not jittery.

Minimal Vim9 example (vim-plug + vim-lsp):

" ~/.vimrc (Vim9 can source legacy Vimscript just fine)
call plug#begin('~/.vim/plugged')
Plug 'yegappan/lsp'          " Vim9-native LSP client
Plug 'dense-analysis/ale'    " optional: linting/fixes
call plug#end()

" Basic LSP: enable per filetype
augroup LspBasics
  autocmd!
  autocmd FileType python,rust,go,typescript,javascript lua << EOF
    vim.cmd('LspStart')
  EOF
augroup END

Kakoune (lean core + kak-lsp)

Selections drive the LSP UX (code actions/rename apply exactly where you selected).
The 2024–2025 kak-lsp updates made the minimal config tiny:

# ~/.config/kak/kakrc
eval %sh{kak-lsp}
lsp-enable

Add filetype-specific servers via Kakoune options when you need them, not upfront.

Everyday refactors (how they feel)

Rename across many call sites
- Vim: build a quicklist (ripgrep → quickfix), jump, ciw + . repeat, or LSP rename.
- Kakoune: grow selections with motions/regex, act once (c/R/pipe) across all carets.
Edit function arguments
- Vim: plugins like sideways.vim, text objects, macros.
- Kakoune: pick the argument object, rotate selections, or git apply just the hunks you’ve highlighted.
Bulk cleanup
- Vim: visual block, macros, :global, substitutes—battle-tested.
- Kakoune: select all matches, split/filter selections by regex, pipe to sed/awk/jq, paste results back.

If your day is 80% “surgical changes at many points,” Kakoune’s native multicursor habitually saves keystrokes. If your day is a mix of editing + tooling + weird environments, Vim’s breadth wins.

OS support, terminals, and remote realities

Windows: Vim is native and polished (even ARM64 installers). Kakoune is happiest on Linux/macOS; on Windows you’ll typically run WSL or Cygwin/MSYS2.
Wayland: Vim finally ships native clipboard support in 9.1.x, smoothing daily ops on modern Linux desktops.
Remote work: Both fly over SSH. Kakoune’s client/server sessions are excellent for multi-terminal editing without re-tiling inside the editor.

Ecosystem & longevity

Vim: decades of muscle memory, massive plugin ecosystem, steady post-9.0 evolution (Vim9, virtual text, diff anchors), and ubiquitous preinstalls.
Kakoune: a focused community, sane defaults, and a deliberate feature set that nudges you to compose with the Unix toolbox instead of installing a hundred plugins.

Quick equivalence cheatsheet

Task	Vim (idea)	Kakoune (idea)
Change inner word	`ciw`	select word → `c`
Delete inside parentheses	`di(`	select the parentheses object → `d`
Case change	`gU`/`gu` motions	select → `~` (upper) / backtick (lower)
Multicursor rename	visual/select → `:s`/macro/LSP	grow all matches into selections → `c`/`R`
Peek diagnostics	plugin/LSP float + virtual text	select location → LSP show/hover on selection

(Exact keys vary with your config; the key point is flow: do→to in Vim vs choose→do in Kakoune.)

The verdict

You want one editor everywhere, minimal surprises, unlimited ecosystem: get Vim.
You want editing to feel like sculpting selections, with multicursor as the default primitive: get Kakoune.
Still unsure? Spend a week living in each: do your real work, not just tutorials. Your fingers will vote for you.

GigasBlade

Search This Blog