Why Kakoune

It's definitely never been easier and more free to tinker and write code than now. Cool times.

IMO learning the helix keybindings is definitely worth it. Install it, check with `hx --health` what LSPs you need and install these and that's it. And you still have so much configuration you could do, but don't really need.

I think the biggest benefit of going away from something like VSCode or IDEA is frictionless creation and integration of new tools. VSCode and IDEA usually require you to write plugins to achieve a deep level of customization for your needs, which causes a lot of friction. In an environment like Vim and Emacs, you can make quick scripts that create new features for your project that you wouldn't have created otherwise.

I'm currently using VSCode, but I don't code a lot these days. If you are looking to explore a new paradigm like that, I would go with Emacs as a practical option (with vi bindings) and Acme as a way to open your mind (but not very practical).

I've used all except Kakoune. For me, Neovim is the one that stuck. Helix is cool, but having no plugins is a deal breaker (for now!) The onboarding experience is much nicer for sure, and Helix's LSP is way easier to set up than Neovim's.

That being said, Neovim, once you get it set up, is great. The biggest hurdle for me was the config, but if you just start from scratch and make a light config (mines about 200-300 lines, with LSP, hints, etc) you can get through it. And you never have to touch it again, since most likely you configured it in a way you like. Well unless you wanna add the occasional plugin. There are also distros of Neovim that contain a fully baked IDE-lite experience, but honestly those have extremely complicated config, and often IME don't feel nice and light.

It's definitely not for everyone. There is that time investment to get started, but it's definitely been worth it for me.

My config: https://github.com/wrapperup/nvim-config

I use NeoVim. I used Vim previously and just know the built in basics very well.

NeoVim incorporating Lua as a first class language has allowed plugin authors to build plugins that are faster and better than plugins for Vim written in VimScript (or other languages like python/typescript which are much slower).

There is a strong community for neovim on reddit, youtube, etc and plugin authors do a nice job of building tools that work with each other.

Setting it up I agree is a pain, but once done its very little maintenance/work. Even when I've had to 'redo' my setup (eg switching package managers like vim plug to packer to lazy) its been easy and under 15 or so minutes.

I edit minor things in my config every few months. Everything flows quite nicely now and breaking changes are far less common than they used to be (at least among the plugins I use).

My vim config if you're curious (along with the rest of my dotfiles): https://github.com/sbernheim4/dotfiles/tree/master/vim

I haven't used Kakoune, but I've used emacs, Neovim, and Helix. I love the simplicity of Helix and how easy it is to get it up and running with language servers. Emacs and Neovim have amazing ecosystems, but I'm not willing to devote the time needed to keep my setup working and do the labor of installing and configuring so many plugins. I actually switched from emacs to a mix of VSCode and JetBrains IDEs (PyCharm, DataGrip) but I sometimes find myself copy-pasting blocks of text into emacs when I need to do anything fancy or repetitive. I used a Neovim integration for VSCode for a while but found it annoyingly buggy.

IDEs like VSCode and JetBrains seem to be in denial about coding being a text editing activity. Emacs and Neovim want you to take on a part-time job building and maintaining your own personal editor application out of a pile of spare parts. Helix to me is a very promising approach: a text editor that aspires to provide enough polished core features to be a productive coding environment.

I've used NeoVim, I was a long time emacs user in the 90's. Etc.

Honestly: I use Jetbrains IDEs now. It is worth having the little integrated tools, like the debugger, etc.

I have a nice NeoVim setup but it gets used less and less now.

Helix is very cool, and I liked playing around with it. But it doesn't support Copilot, which is an instant deal killer for a lot of people, myself included.

I'm sticking with Neovim, especially because I work close to a lot of embedded stuff where being handy with stock vim comes in handy quite frequently.

I have used all three. Vim for ~5 years, then kakoune for 2 years, then helix for 2 months, and back to kak for 2 years (with no end in sight). Kakoune is my favorite and helix is very nice, and I would never go back to vim.

Vim:

    + ecosystem is nice. Plugins and matching keybinds in ACE/codemirror/whatever was cool for interop
    + having vi or vim on any Linux box is nice
    - you have to have plugins for basic things like pcre, correct colors (csapprox), and ale
    - at least when I stopped using vim, the multiple cursors plugin was nothing near as good as the other two. It was tacked on to a single-cursor editor, and you can tell

Hx (my knowledge is 1-2 years old):

    + felt completely natural coming from vim. If you use vim and don't want to warp your brain with new keybinds, try hx. It feels like vim+more. Kak feels like a different editor
    + many built-in features that require plugins in vim/kak
    + using LSP motions felt amazing
    + written in rust, which I love. The codebase is entirely readable and I contributed a patch after only about an hour first looking at it
    - hx didn't have motions for ()/<>/... Which I've come to rely on. Kak has m which is like Vim's f(v% if f was multiline
    - no advanced keybinds/bindsym in vim/map in kak. Config was toml so the most you could do was bind single chars to other single chars
    - no plugin support, though I found myself not really longing for any plugins because so much comes by default 
    - occasional crashes due to off-by-one errors and .unwraps sprinkled around

Kak:

    + editing feels amazing. Like the text is directly connected to your brain. This is because basically every action gives you feedback. For example, in vim, t(dt) gives you a cursor move and then the text is gone. t(v%d gives you feedback but takes way more keys, but in kak, md immediately selects the entire bracket after m and deletes it after d. Having visual feedback *as a requirement* (not an option like Vim's visual mode) is amazing. I didn't use hx enough to know if it feels like vim or kak in this regard
    + plugins exist. Kak-lsp is nice. Scripting your own keybinds feels more natural because the scripting language *is* the keybinds, contrary to vim. Basically imagine every keybind is like Vim's but with a :normal before it 
    + multisel feels compltetly natural. Not like an extension to what you're doing, but everything is multisel, and you just happen to have n=1 selection sometimes 
    +/- piping to external programs feels very natural. I have numerous scripts that take stdin and write to stout. In kak, I select whatever I want and just run |encode-url<ret> and it pipes every individual selection to my command and replaces them with my output. This is also bad because if I have 100 selections (not uncommon), it will spawn 100 shells to spawn my command 100 times
    - people keep saying it doesnt have a scripting language, which is misleading IMO. There are try blocks, %{} groups, and commands that you need to learn about. Look at hx if you're interesting in no scripting language. It reads a toml config file and that's it. 
    - a little overreliance on shell. I don't even know if windows can run kak because it uses shell so much. On one hand it's nice because I know Shell. On the other hand, interop feels weird. You echo commands and kak reads your stdout and evaluates it. It's clever and cool, but something about it feels weird. 
    - keybinds don't behavibe like vim or hx. You have to retrain your muscle memory, but IMO it's worth it. Using vim now though is painful 

Kak is great

I was using Kakoune for 3-4 years, and switched a year ago to Helix.

Kakoune is OK, but:

Some details of editing are too optimized for counting keystrokes in vim golf, less for thinking-free editing experience.

Configuring and extending text editor with shell scripts is ridiculous.

It's in C++. I want to be able to debug and submit changes to my most used dev tool and I don't want to be touching C++.

Having said that, I still miss the visual-mode-first experience of Kakoune (most moves in Kakoune change/modify selection, while Vim/Helix have visual mode instead).

Otherwise I think Helix already leaped over Kakoune in terms of functionality and polish, because it's just easier to contribute to (in Rust).

BTW. The difference between Vim and Kakoune/Helix is not that big. For basic Vim modes in shells and other tools, I don't really notice it. `hjkl` works all the same.

Helix is easier to jump into as it supports a lot of useful code editing features out of the box, but Kakoune has a more elegant and discoverable modal editing experience.

nvim. There isn't much software I can say that feels so comfortable to use for me.

A lot of people look at the learning curve and decide it's not worth the time investment, just so they can save time later on when they're more comfortable with it.

But to me it's not about time, it's about how smooth it feels to use, how I can translate thinking to typing/editing with the least friction possible, and nvim with my minimal set of plugins that I curated over years, that is it.

vis

I'm not sure I understand what the big deal is with selection-first. If I want vim to be selection-first, I just press v. It's just one keystroke!

The second point is the biggest reason why I haven't switch to Kakoune or Helix yet. I've used vim for just over a year now and I'm still annoyed at how unintuitive some things are, I still can't remember half of the shortcuts. I tried out Helix and it's great! I especially love the multiple cursors.

But I never use vim by itself, I use it in other apps. And there's a perfectly good Helix plugin for VSCode, but I also use vim mode in Obsidian (since I'm constantly switching back and forth between Obsidian and VSCode) and there is currently no plugin for anything else. I need my code editor and my note editor to have the same controls, otherwise my brain gets confused.

Once a Helix or Kakoune plugin is created for Obsidian, I am switching straight away.

Take a look at https://helix-editor.com/. It is basically a continuation of the ideas behind Kakoune but with a primary focus on modern day programming with a language-server. I use it for most of my programming today, because the language server support out of the box is just so much better than anything I managed do with Neovim.

ThePrimeAgen uses Dvorak and for raw typing speed has said it’s probably not worth. Fast typists on qwerty and Dvorak seem to be in line.

Stress on the good ol wrists and digits though? Not really sure. If there is a reason to switch, it’d be based on that.

The theories behind newer layouts are solid I think, but I’ve avoided adopting them simply because if I don’t regularly use QWERTY, my capacity for using machines other than my own suddenly takes a steep nosedive.

My preferred layout is HHKB/Tsangan, a minor variant on QWERTY that replaces Caps Lock with Control, moves Esc to the number row, collapses F-keys into a number row layer, and moves Backspace down where backslash/pipe are and even with that standard keyboards can be frustrating (you don’t realize how hard standard Esc and Backspace positions are to reach until you’ve tried this layout). I can’t imagine what it’d be like if I were using DVORAK or something.

I used Dvorak for awhile. It's okay, at least better than QWERTY. But it's super old, and keyboard layouts post-Colemak take advantage of rolling bigrams and trigrams, unlike Dvorak. I use Hands Down now. https://sites.google.com/alanreiser.com/handsdown

I have at various times in my life tried to use vim or emacs. Each time I get comfortable enough in them to appreciate them but I run into the same problem every single time: it is annoying to switch back out of them.

I had an acquaintance that told how he had spent years investing in Dvorak. He came back to QWERTY because he got a job where he had to jump onto others computers on occasion. The friction he felt fighting against his muscle memory was more annoying than any benefit he got from the supposed better Dvorak layout.

I now use VSCode for 90% of my stuff and I use vim whenever I ssh into boxes or if I really need a quick edit from the CLI. But I keep vim totally stock, not a single thing in my dot file. There are aspects of my previous highly-customized and personalized vim setup that I miss - but I am free from the frustration of them not being there.

As I get older, freedom from frustration has become more important than the marginal improvements of customization for efficiency.

If you do it, do it for comfort not speed.

And also consider Colemak-DH over Dvorak.

If you're worried about having to relearn Vim commands, it's not a big deal. You're not remembering the key positions but the mnemonics, so "dta" means "delete to a" not some key positions. You'll be fine.

sure, but that's the same argument against any form of incompatible change.

it was used against the fish shell for example. yet eventually it started getting acceptance. the same may happen with kakoune. i tried using it myself. i wasn't so much bothered by the changes. i had different issues. i got burned by kakoune overwriting a file without warning me. vim would not have done that. and i couldn't get over the fact that kak means shit in some languages. it will take some more effort to overcome that and give it another try.

This was exactly my thought process before switching to vim.

I come out of the woodworks every now and again whenever I see Dvorak mentioned in any context. I really despise its popularity as an alternative keyboard layout because I feel it wasted a good year of my life.

1) Few people will have benefit of learning Dvorak. What benefits they see comes from learning how to properly touch type by forcefully breaking bad habits with their original (usually QWERTY) keyboard layout.

2) Switch to Colemak or any more modern layout that takes advantage of bigrams/trigrams better. Colemak is genuinely superior to QWERTY beyond just learning to touch type.

I used to type 170~ WPM on QWERTY. Sustained. By all means an accomplished typist. I learned Dvorak well enough to get back up to 120~ WPM but saw no real benefits of using it: I already knew how to touch type. But QWERTY was causing my hands to cramp up over time and so I was on the search for improving that. I gave Colemak a try and it was a great relief. I only type 150~ WPM on Colemak after some years of using it but the lack of pain from typing for long periods of time is worth the small hit to my typing speed.

Almost every single person I see who touts benefits of learning Dvorak was typing <60WPM in QWERTY and did not know how to properly touch type. The benefits they see weren't from using Dvorak: it was from finally learning how to touch type properly.

Apologies as I know Dvorak wasn't really the focus of your post here. But in an attempt to perhaps make it still relevant: change every now and then is good. It can break you out of bad habits you didn't know you had learned and sometimes open you up to new ways of accomplishing something. As other replies have mentioned - I'm a big fan of Helix and gave up Neovim for it.

I have similar reasoning for not bothering to learn an FP language (I have dabbled though) and stick with imperative.

Every other keyboard you may need to use; for family, work, friends, is QWERTY. That is enough reason for me to stick with the norm. I already type 120wpm, which is only useful for a speed typing test. I never code, or even write documentation, at 120wpm.

Regarding (1), I used Vim for 19 years, and I had strong muscle memory. However, I found it took only about a week to get comfortable with Kakoune. Its multiple-selection-oriented editing just mapped really well onto how I was already using Vim, which is to say, making extensive use of visual mode and highlightsearch. I have met Vim purists who tell me this is missing the point of Vim. If so, all the more reason to make the switch. But if verb-motion works better for you than selection-verb, by all means continue using Vim; it's a great editor.

It's worth getting a physical keyboard that's actually ergonomic, like a Keyboardio, ergodox, dactyl, or whatever. Just pick the one you are most excited about using.

It's significantly less valuable, but still worth learning an alternative keyboard layout, though Dvorak specifically isn't nearly as good as modern alternative like Colemak or Workman.

Vim is incredible for every reason except its keybinds. Technically, you can remap them, but that quickly devolves into dependency hell... learning to type using the Workman layout is why I'm an Emacs user today. One of these days I'll get around to making a truly configurable modular editor...that will most likely be an Emacs config.

I switched from a standard split ergo keyboard to a split orthographic with curved rows (Glove80 specifically). I'm still questioning my move. I was pretty damn fast with the standard split, and I'm still struggling with special characters on the Glove80. It feels like it's coming though, and at least it's fun. And perhaps it will reduce wrist and finger strain as I get older.

i remember him mentioning that he had at least heard of it in a post from years ago.

vis is cool but its structural regular expressions are much less easier to use since kakoune's give you feedback in real time. it is nice that vis actually has a lua API though.

> I wonder if the author has ever heard of vis[0]

Yes.

https://github.com/martanne/vis/wiki/Differences-from-Kakoun...

https://github.com/mawww/kakoune/wiki#onboarding

> which imho fulfills far better each one of those premises

Not very motivated for such a harsh critic..

Note that all of those (but with some limitations on multiple selections via RE) are available in Ex/Vi and Ed previously.

> I wonder if the author has ever heard of vis[0] which imho fulfills far better each one of those premises

Same goes for Sam…

>so it's not a good thing that Kakoune "requires" them

It doesn't. Author learned them because they made plugins and complex custom commands. The configuration language allows embedding shell scripts but Kakoune provides a POSIX interface so can use whatever language you want for plugins. Regexes are needed to be productive utilizing the full extend of text manipulation provided. Can do without but you miss a big reason for using Kakoune in first place.

Odd choice of words. I'd say that perl, awk, regex etc are great ergonomic tools - if anything too ergonomic. The main problem with them - and the probable source of their bad reputations - is that the ease and comfort (the 'ergonomics') of just cobbling something together something that works and then throwing it out there does not encourage good engineering practices.

Do I need good engineering practices in my day-to-day text editing? Mostly not for what I do myself, but I'm grateful that the maintainers of the emacs packages I use have better tools to work with.