After sharing a bit of my journey with HUME and Claude Code, I'll try to show you what I think are the nice touches of HUME, and if I manage to spark your curiosity, you'll find some links at the end of the article to download and try it.
If you are new to modal editors, there are many introductions on the web, including this brief page on HUME's user manual.
To keep this article short, I'll assume you are already familiar with the main concepts of modal editors.
1. Select first, then act
What's the fuss about this paradigm? Vim's grammar is verb first, object second: dw deletes a word, ci" changes inside quotes. You type the whole command blind and find out what it did afterwards.
Kakoune, Helix and HUME turn that around. Motions select, and operators act on whatever is selected: w selects the next word, then d deletes it. The selection is always visible, so you see exactly what d will hit before you press it. There is no invisible "cursor as a point": the cursor is just a one-character selection.
Vim has visual mode for this, but that means two models: operators that take a motion, and operators that act on a visual selection. In a select-then-act editor you have to learn just one model.
2. Keybinds and muscle memory
HUME embraces the Helix and Kakoune model, but since I've been a Vim user for a long time, you'll probably find HUME's keybinds a mix of both worlds. I tried to make them as intuitive and pragmatic as possible, keeping muscle memory when it made sense, and changing when there was (in my humble opinion) a better option.
For example: you are moving your cursor and want to select the current word. In Vim that means typing vaw; in HUME you press mm. One letter, faster, easier to remember.
Why mm? Because m is the prefix for a lot of match commands, like mi" (match inside quotes) or ms( (match the surrounding parens). Think of mm as a shortcut for maw (match around the word).
Every select-then-act editor needs a way to extend selections. In HUME every movement or selection command has a Ctrl- counterpart that extends instead of moving or selecting, so f. moves to the next full stop, while Ctrl-f. extends to the next full stop (this requires a terminal that supports the kitty keyboard protocol, and many modern ones do: iTerm2, WezTerm, kitty, Ghostty etc).
There's also an extend mode if you prefer one (like Vim's visual mode or Helix's select mode), but one-shot extends spare you the mode switch. Normal mode stays predictable: its commands only move or select, never extend. In Helix, for example, x selects the current line, and pressing it again extends the selection to the next one. In HUME, x only selects, and Ctrl-x is what extends. Extending lives only in extend mode or behind Ctrl-, so you always know what a key will do.
3. A paste that does what you meant
Every Vim user knows this one. You yank a word, select another word, and paste over it. Then you try to paste the same word somewhere else, and you get the word you just replaced. Some of the oldest code in my vimrc is a couple of functions and a custom keybind that juggle registers for this exact reason.
In HUME this works right out of the box, since the overwritten text is simply discarded. Paste again and you get a second copy instead, since replacing text with itself would make no sense.
HUME also keeps a kill ring of your last 10 deletes and yanks, and p tries to guess whether you want the last thing you cut here or something you copied in another app.
Right after a paste, [ and ] swap it for an older or newer kill-ring entry, so "the thing I deleted three edits ago" is two keystrokes away.
And if you just don't like guessing, the core:classic-paste plugin gives you p for the kill ring and Ctrl-v for the clipboard, GUI style.
4. Everything is Scheme
I've always been fascinated by Lisp, so HUME uses Scheme for everything: your config, your keybinds and your plugins. There's no vimrc and no separate plugin language. Your init.scm is a real program, with conditionals, loops and functions.
Vim's autocmd FileType becomes a hook:
(register-hook! 'on-language-set (lambda (pane lang) (when (equal? lang "python") (set-buffer-option! pane "indent-width" 4) (set-buffer-option! pane "indent-style" "soft")))) A plugin in ten lines
A plugin is just a directory with a plugin.scm in it. Here's a complete one that adds a :trim-trailing command, removing trailing spaces and tabs from the selected lines, or from the whole buffer:
(define-typed-command! "trim-trailing" "Remove trailing spaces and tabs." (lambda (pane) (when (selections-charwise? pane) (select-all pane)) (when (sift-within pane "(?m)[ \t]+$") (delete-selection pane) (keep-primary-selection pane)))) Look at what it does: select the buffer, narrow the selection to every run of trailing whitespace, delete. That's the same select-then-act sequence you'd type by hand (%, s, d). The scripting API speaks the same language as the keys, so once you know how to do something interactively, you mostly know how to script it.
Plugins all the way down
The big features are built on the same API that's available to you. The fuzzy pickers, LSP support, live git diff and the undo tree are all core plugins: HUME starts lean, and you turn each one on with a single line in your config. If you don't like how one works, you can replace it with your own. grep.hume, a live grep picker, is an example of a plugin living in its own repo.
The Writing Plugins guide covers the rest: hooks, custom pickers, completion sources, async processes, lazy loading.
What's missing, and what's next
There are still a few features missing, and some are already being worked on, like persistent undo and persistent sessions. Other planned features are in ROADMAP.md, many other will come as I continue using and developing it.
The Scheme API will expand too. I add commands only when I have a real use case for them, so many will likely be added as soon as I (or someone else) write a new plugin. I have a couple of them on my roadmap too...
Try it
Getting started takes a few minutes: download the archive for your platform from the releases page, run HUME, then type :tutor for the interactive tutorial.
The migration guides map what you already know onto HUME:
Everything else is in the user manual and the repository. Feedback, bug reports and contributions are very welcome, and if you write a plugin, I'd love to see it!
