helix-vim

Since I see Helix being mentioned here, I'll start this comment by noting that I am the author of the helix-vim[1] repo which has been shared very widely at this point. I still stand by everything I wrote in that repo, but these days I'm a very happy NixVim user, with my own little mini NeoVim distro, JeezyVim.[2] I hate to do the "Nix fixes this" meme, but in this case, it really does fix this particular issue of the NeoVim plugin ecosystem and its constant breaking change update culture being a nightmare for end users. You can build something that works and pin the dependencies all the way down and have a NeoVim config which will pretty much work forever. Yes, the initial investment is significant, but for me it's absolutely worth it to be able to provision any machine, any VM, any bare metal server and have my entire NeoVim config comp

I tried to re-learn from Vim to Helix but failed. No sure if this is a muscle memory problem or perhaps article is right about the cons Kakoune-like approach for me. Even adapting with something like https://github.com/LGUG2Z/helix-vim did not work. So if you like Helix it probably a good thing that you did not learn the vim at the time.

I really enjoy Helix. The toml configuration and built-in Treesitter and LSP support are stellar. It works well enough to be a daily driver. But after 20 years of Vim muscle memory, I can't deal with the keybindings. Not that they're inherently worse, just different - I'm perfectly happy with vim motions and relearning to type is pretty low on my list of priorities. Luckily there is a compatibility hack, not perfect but it's close enough: https://github.com/LGUG2Z/helix-vim

I want to like Helix, I really, really want to. It's lean, fast, polished, purely console based so it fits my workflows perfectly... but the almost-like-vim-but-not-really key bindings are a deal breaker. I just can't make the switch. If Helix were completely different in this regard, like Emacs is, I could handle--and I know because I use both vim and Emacs regularly pretty fluently. But Helix is way too close to the vim keybindings to discern it from a memory muscle perspective. I use vim keybindings everywhere else (zsh, all readline-based apps via a setting in ~/.inputrc, VSCode), so getting used to slight differences in just one editor is extremely hard because I can't just drop all other apps. I recently tried this: https://github.com/LGUG2Z/helix-vim which attempts to provide vim mappings to Helix. It's funny how the description in

There is this configuration: https://github.com/LGUG2Z/helix-vim This switches most keybinds to be vi-like.

There's this config you might like: https://github.com/LGUG2Z/helix-vim We can't invert the bindings though (wd -> dw) because that would require a big internal change to add operator pending mode: When you press `d` in vim, that enters the operator pending mode, where it will wait for an object to be specified, in this case `w` and then delete it. In a selection first model, `d` is very simple: it just always deletes the selection. So you select a word, then delete.

I think there is a config that maps more to vim, try this https://github.com/LGUG2Z/helix-vim/raw/master/config.toml

> https://github.com/LGUG2Z/helix-vim/blob/master/config.toml Thanks, I may give Helix another spin with that config. I saw the note about it being necessary to recompile, which I can't be bothered to do so I guess I won't get everything but it may get me through most of the day with less frustration (especially now I've turned mouse support off too; the cursor moving when I click to raise my terminal window was incredibly frustrating).

In addition to the helix resource, you may or may not want to look at: https://github.com/LGUG2Z/helix-vim/blob/master/config.toml I think most of the "muscle memory" bindings there are a bad idea (helix is different from vim - if you don't want that, I recommend neovim). As for "dd" - that would be (as indicated in your quote) select line, delete (yd) in neovim. Similar for delete to end-of-line - the second form is probably the "most helix like" - in being somewhat discoverable and "interactive" v(isual mark) return (end of line) d(elete). As for filtering selection through pipe, or reading command output - they are also different: "!" in normal mode is "insert-output" (r! in vim), while pipe is "filter" - eg, after selecting three lines, hit "|" then input "sort<enter>" - and the selection is piped through sort. As a long time vim user