BUT! The scroll speed is absolutely wonderful. I've tried all the UIs and always find myself going back to the terminal, but this is something else.

Although I have to say fvim looks tempting as well and vimr(I'm not on MacOS anymore).

For those people mocking vim users and bragging about their IDE's. With languageserver and the other kind of refactoring daemons available for a whole host of languages nowadays these editors are much closer to IDE's than ever before.

The only things that are not really first class citizens are IMHO:

1. refactoring(outside of C++ and Java)

2. profiling

3. breakpoints

EDIT: I'm quite happy with the tmux setup I have but thanks for the suggestions. The main problem I see with neovim is that the separation of the python library while nice for update iterations causes issues with virtual environments.

Visited its page to have a look... I'm not sure why they'd put a screenshot with a variable width font, which automatically puts lots of people off when it comes to coding...

It's like having a screenshot of your bitmap editor, and showing it editing goatse.cx...

In fact, after reading you comment, I promptly startet to install it (still compiling as I type this). My use-case is creative writing: I'm very used to vim keybindings from coding, but prefer to have a variable-width fonts for writing.

Sorry about the confusion -- I think you've already discovered that (after 46 minutes)!

Aha, looked like a proportional font was used to me. I'd use a more well designed monospace font for the first impression!

Haven't seen this, -it usually goes the other way:

You're doing it wrong, you should use vim!

(I know enough vim to effectively use it to edit configs etc, but I just prefer my IDEs.)

Modern IDEs are following a platform + plugins architecture that is probably as flexible but more robust than whatever you can tape together around vim.

It's not that using an IDE with a vim mode is not a possible viable alternative, but it's a game of trade-offs, as usual.

I really hope in the future I'll find the time to do that, but for now I am content. It's always a trade-off.

Vim also starts up without any noticable delay and can be used for every text file, no matter in what context.

Only if you run it without any plugins. Unfortunately if you have a lot of third party packages, vim startup times start to get closer to emacs startup times (both of which are still better than any IDE I have used, of course). I keep a vim.norc alias in my alias file which launches vim with an empty .vimrc for this very reason.

I’m not very experienced with complex plugins, but most of what I’ve seen did nothing unless explicitly initiated. Maybe there are global variables to control that.

Most likely true, though i think the "I" part of "IDE" is woefully ignored and (at least to me) is much more important than a hodgepodge of barely related programs strung together with duct tape.

Omnisharp was literally the attempt of MonoDevelop to create an open source alternative to the Resharper engine.

The completion agents for VIM or VSCode do the presentation layer for the lower layer(the language server daemons, or custom completion agents. YouCompleteMe however is all that together in one not as fancy but I like it).

I get where you're coming from, but basically the difference is that vim by itself is a raw editor and until neovim came along never made an effort to merge the functionality that was required for something like this to happen in a nice fashion.

Editors like Oni are basically distributions like VSCode with defaults that are more inline with what you say plus a nicer presentation layer.

Java and NetBeans is (or was, before Oracle botched it) probably the best IDE (in terms of integration) for a toolset with a unixy background.

Though none of those compare to something like Smalltalk, Lisp or even Microsoft's QBasic and (pre-.NET) Visual Basic.

Note that i'm talking about how integrated the IDE is with the language and its tools, not about how good or bad the language is.

Vim didn't allow integration because there was no way interface to it, and it's not an easy codebase. Neovims work is proof of that. C++ compilers didn't allow integration because they were big monstrous projects and when you need to do proper c++ indexing you basically need to compile the whole project.

For C++ this changed with clang and even for clang it took a lot of iterations and bugs inside of libclang to allow for this capability.

Naturally one of the best C++ IDE's was therefore also by the producer of their own compiler (Visual Studio).

These boundaries are slowly fading, so these arguments are kinda moot. A few examples:

https://clang.llvm.org/extra/clangd/

https://github.com/Andersbakken/rtags

https://github.com/cquery-project/cquery

libclang might be a bit closer but it still is something separate from whatever IDE it is used for.

Honestly i do not believe it is even possible to what the sort of integration i'm talking about by stitching together separate projects no matter how many extension points and hooks those projects provide - by definition they aren't made with a singular coherent vision where everything is meant to work together, instead each project has its own idea of how it should work.

MSVC could in theory be able to do that since the IDE is made by the same company as the compiler, but in practice the teams behind it are probably acting as separate "sub-companies" inside the bigger organization. They're not seen as a single "C++ development environment" project but as two separate projects that happen to communicate with each other.

I'm not sure if 'philosophy' is the proper term here, but it is certainly about how you believe that software should be made and having that in mind at all times when designing it at all levels - be it the functionality to provide or how that will be implemented (e.g. a compiler that runs as a simple standalone application can just use globals for the state and perhaps not even free memory at shutdown - see dlang as an example - whereas a compiler meant to be integrated as a library cannot do that).

As an example, for a Borland-like approach (at least based on my understanding of it), adding a language extension to -say- provide meta-data for classes wouldn't be something that only the compiler developers cared about, but something that the developers of the compiler, the debugger (for being able to display the meta-data), the IDE (for editor auto-completion and automatic code editing - later Borland IDEs could modify the code - and debugger UI), the framework library (for taking advantage of it and providing a 'best use' scenario), etc. And all of those would influence the new functionality instead of being something that was added by the compiler team and then the rest would have to support (as it is done by pretty much every language that only exists as a standalone compiler or interpreter without any concern for IDEs, debuggers, UIs, etc nowadays).

If you're using pango 1.44, that is a known issue and there really isn't a proper workaround yet. Quite a few applications using grid based applications are currently broken with pango 1.44.

https://www.iterm2.com/documentation-scripting.html

VSCode with vim plugin handles this well with the Use Ctrl Keys option set. If you're in insert mode, ctrl + v will paste, otherwise ctrl + v will start visual mode. If you are selecting text, ctrl + c will copy.

Adding a bazillion one-off options like "Use Ctrl Keys" to avoid creating mappings, defeats the purpose of using vim, since creating mappings is the bare minimum way to configure it. (But Vim did so anyways for Windows, in the form of the "mswin.vim" plugin, which is enabled by default, causing confusion for users expecting vim to behave like vim.)

    inoremap <C-V> <C-R>+
    vnoremap <C-C> "+y
    cnoremap <C-V> <C-R>+

  vnoremap <C-X> "+ygvd

If you’re unfamiliar with registers look them up in the docs they are super useful. (Also have a look at the 0 register, e.g. “0p)

Nothing wrong with custom keybindings, obviously. But it sounds rather non-standard?

imap <C-V> <C-R>+

vmap <C-C> y

Most probably you want this as well:

cmap <C-V> <C-R>+

The C-v (Ctrl+lowercase v) is important for literal character insertion. (Insert a tab, escape, return, etc.)

You can remap it to <C-l> (L = literal), and then use <C-c> and <C-v> without shift:

    inoremap <C-l> <C-v>
    imap <C-v> <C-r>+
    cmap <C-v> <C-r>+
    xmap <C-c> "+y

TIL. This goes into my vimrc right now.

also per-window font-size, dimensions, line-spacing--so Nvim UIs can add unlimited decorations to windows while the editor navigation remains exactly the same (driven by Nvim).

You didn't even mention it's written in Rust!

1: https://github.com/qvacua/vimr

Either way, VimR is impressively nice looking. Thanks for the link!