1. 39
  1.  

  2. 13

    If anyone’s looking for anything that’s like this but isn’t, vis is similar and what I’ve been using.

    1. 4

      I second this comment. vis is lightweight, uses lua as its extension language, supports multiple cursors and implements sam’s structured regular expressions.

      1. 3

        vis looks nice too. So now I want vis’s Sam style regular expressions and command language together with Kakoune’s noun-verb command mode.

        1. 2

          Interesting! It says that there’s support for syntax highlighting, but I didn’t find whether it has some built-in highlighting for some core set of languages (C, Javascript, etc). Do you have to provide your own grammars for anything you want highlighted?

          1. 2

            Comes with a bunch.

          2. 2

            Wow, all these years (well, not that many, but enough) of using the crude :%s to select and subsequently replace selected stuff in vim, when it seems like vis makes this sooo much easier and more powerful. I’m going to have to give this a try. Thanks for sharing!

            1. 1

              The crude :%s is part of a language that you could build upon. You can specify ranges, regex, and things other than search with % and s. Sure if all you want is search then it may be overkill, but at some point one can expect to outgrow the simple features, otherwise we would all just code in tiny.

            2. 1

              Vis is pretty cool. The codebase is approachable and is well documented. Even though I use Emacs for my day to day I use vis as my $EDITOR as its better suited for for bash’s C-x C-e as well as occasionally taking advantage of its use as an interactive filter.

              1. 1

                Lack of a functional theme with a light background is a bit of a showstopper for this. Need to write my own theme before I can see if I like it.

                1. 1

                  Well, you can also disable syntax highlighting.

                  1. 3

                    Well, you can also just not take any right turns if your right indicator is broken.

                    Either way, it would still leave me with a black background and various UI elements, which I don’t like.

                    1. 2

                      I don’t think the two are comparable, I prefer editing without syntax highlighting. There are various community provided themes: https://github.com/martanne/vis/wiki/Themes

              2. 9

                If anyone is interested in seeing Kakoune in action, without installing it: there is website showing bunch of VimGolf challenges solved with Kakoune - Kakoune Tv. Nice thing is that every key press is explained there.

                Of course golfing is a bit different from normal usage (but in case of Kakoune optimal solutions are usually close to things you do every day).

                1. 8

                  I’ve been using kakoune for around a year now for some things, coming from both Vim and Spacemacs. The noun-verb ordering is a revelation. Being able to see what I’m operating on before you hit a button is a big bonus.

                  1. 2

                    Can’t you do this with Vim’s visual mode? v2wd instead of d2w.

                    1. 1

                      Sort of. In a way, it’s as if you’re in visual mode by default. But the fact that the cursor works differently, combined with multiple selections and better integration with search, it is arguably more ergonomic.

                  2. 5

                    I don’t know about you, but these days my work mostly involves navigating around a huge code base, finding relations between classes, identifying where to do the change and then write some code. Thus most of these editors seems to be focused at writing lots of code fast when what I need the most is going around and finding my way in the code fast.

                    So while I may save some time with Kakoune’s editing pattern, I will lose much more if I don’t have a reliable “Go To Definition”.

                    1. 2

                      Kakoune has an integration for the langserver protocol, which gives you that fairly reliably, I find. Maybe not as good as full-blown IDEs, but I’ve found it more than good enough for most cases.

                    2. 3

                      What is the motivation for this editor? It’s not clear why I would choose this over anything else, especially when many programming environments support Emacs/vim style interaction.

                      1. 13

                        You can read the justification here. Largely it is based on the idea of switching commands from vim’s verb-object pattern to an object-verb pattern, which enables the useful behavior of showing the user what they’re modifying before they modify it.

                        Combined with some other useful features like multiple selections, and a client-server model like neovim, I have to admit it’s pretty appealing to me. I’ve been a vim user for about 20 years, however, and it would likely take quite a lot of retraining to switch now. Edit: Not to mention the fact that no official Windows support is planned; I prefer to use the same editor on all operating systems if possible.

                        1. 8

                          I was a Vim user for 20 years, and after using Kakoune for two or three weeks I started finding Vim frustrating and clumsy. That’s partially because Kakoune’s more orthogonal keymap makes Vim’s x and v redundant, so it replaces them with other commands, but also because of Kakoune’s movement-is-selection model. In Vim, to delete a word, I hit w until I reach the end of it (but not past it!) and then db to delete it, or sometimes bdw if I haven’t had my coffee yet. In Kakoune, I hit w until it’s highlighted, and then d.

                          1. 4

                            Wait, in vim, why don’t you do it the other way around, use w to go the beginning and then dw? Or daw (delete, around, word) if you’re inside a word?

                            1. 1

                              Oops! It’s been so long since I used Vim that I forgot wworks differently there.

                            2. 1

                              This is something i have explored when trying out versor-mode for Emacs. I had no idea Kakoune did the same thing. It’s a very powerful paradigm to start treating editor navigation as a coordinate system for various dimensions of a text file.

                              In versor-mode, these coordinate axes are an explicit modal choice, but setting it implicitly based on the last navigation command sounds highly useful.

                          2. 1

                            As Vim moves more towards the Emacs model of “Do it all inside” (following Neovim’s lead), I became less inclined to buy into this model. So the thing that really made me look at Kakoune isn’t what it did – but what the author insists it shall NOT do. From giving window control over to like i3/tmux/$X to delegating to the shell – I think this approach has value, and I think it will continue to benefit from this core decision.

                            1. 2

                              This looks interesting and powerful, and seems like it would be easy to pick up for a Vim user.

                              Has anybody used it enough to give a quick review?

                              1. 15

                                I’ve used it for about 3 years now,. I’m involved in the community, a little bit in the development and I’ve written a few plugins for it.

                                • Multiple selections as a core feature instead of an afterthought. You get immediate feedback when doing batch changes. In fact, even though kakoune supports them, I never use macros.
                                • Swapping verb/object. This might seem like a novelty at first, but it has the direct advantage that you always see what you operate on. The second advantage, less immediately obvious, is that you get structural regex for free. You simply chain multiple selections actions and then do the operation(s) you want.
                                • Generally well designed. Features make sense, and they interact well together. The boundaries of what the editor should do are pretty clearly defined, for example instead of implementing window multiplexing, it defers that to your favorite terminal emulator (or tmux) through a plugin.
                                • Extremely lean and performant. The only dependencies are the C++ standard library and ncurses, and the compiled binary is ~3MB. It can handle huge files, and large number of files as well. Its (custom) regex engine supports feature I haven’t seen elsewhere, such as efficient backwards matching.

                                The first two points in particular allow me to do complex text processing very quickly, I don’t have to think hard about a regex and what its result might be, I just do things on the fly.

                                Some downsides:

                                • The shell being core to the extension model. (posix) shell is a pretty poor language to write things in, full of pitfalls and inefficiencies. It’s not all that bad since it is possible to make pretty complex things with it (such as an lsp client), and the number of plugins that have come out show that it does actually work.
                                • unlike vim/emacs, you can’t really use it as a text canvas for implementing a custom UI. You probably won’t be able to do a magit-like interface with kakoune’s extension model, but the kakoune mantra would be to delegate that to another tool anyway.
                                • no code folding (yet?) for those who care about that
                                1. 3

                                  I gave it a little try a few years ago & wrote about it here. Basically, I thought it was nice & neat but not enough to make me switch from vim/emacs and their whole giant ecosystems.

                                  1. 1

                                    seems like it would be easy to pick up for a Vim user.

                                    The more experienced a Vim user you are – the more painful it is IMHO. The “nearly Vim but not” can really get under your skin. If you work hard at it is a 2-3 week adjustment, but it can backslide a bit if you are switching back and forth.

                                  2. 1

                                    This looks interesting and powerful, and seems like it would be easy to pick up for a Vim user.

                                    Has anybody used it enough to recommend it?

                                    1. 1

                                      Has anyone tried switching vim up to support object-verb?

                                      1. 2

                                        Just use visual mode.

                                        1. 1

                                          This would make Vim’s . (dot) command a lot less powerful.

                                          1. 1

                                            Or evil-mode?