It's a good question. I'm very critical of my tools and I'm a 10+ year vim user, so I've thought a lot about this.

vim's "killer feature" is its text editing language and modality. But plenty of other editors and IDEs offer vim emulation to varying degrees of success. So this can't be the reason to use (neo)vim-the-binary as my editor over, e.g., VSCode.

So for me the real advantage of vim is in its flexibility. I can make vim into whatever I want depending on the context. Because of this, I'm able to use the same vim in many different contexts, instead of having different tools for different tasks. Ironically, this is kind of like the emacs culture of doing everything inside of emacs.

For example, vim is my code editor, of course. But I also have a keybinding to pop up my wiki and immediately start editing a note in vim. I have another keybinding I use when I'm writing a long piece of text in a textbox (like now) -- the binding drops me into vim, I write my text, and when I exit the contents of the buffer are immediately copied to the clipboard for pasting into the textbox. In each of these contexts, I have access to the same familiar environment with all of my configuration, keybindings, etc.

I could probably wrangle VSCode into doing each of these things, but it would be clunky. Vim owes much of its flexibility to its lightweight terminal interface. I wouldn't want to open VSCode every time I want to write a quick note, for instance.

You can do that literary everywhere and with any editor, and even without editor. I created this when I was using vim: https://github.com/majkinetor/vim-omnipresence and this to be used with any OS control: https://github.com/majkinetor/isense-x (here used for AHK intelisense but that is just 1 usecase)

The real benefit of vim vs any editor is modality and there is AFAIK nothing similar in any editor even with emulators. Editing/moving over text is just way faster with vim then any other editor (not just slightly faster, light years faster). I use vscode now because vim requires A LOT of setup and even when automated its pain in the ass. VScode and its plugin sync on the other hand makes it very fast to install anywhere with your config and keys so it compensate for slower editing to me since I need to have my editor EVERYWHERE (literary hundreds of computers).

Sure, you can make a hotkey to launch any editor, but not every editor is as "pathologically configurable" as vim. The combination of vim being terminal-based, highly-configurable, and lightweight makes it nice to use in a variety of contexts.

Its not lightweight.

It is, compared to pretty much any currently in-use editor.

> Editing/moving over text is just way faster with vim then any other editor (not just slightly faster, light years faster).

Text? Yes. Code? No. Since editing moving code is a subset of refactoring, and Vim has no knowledge about code.

Well, this update is all about that so I guess... solved ?

It's on its way there, true :)

> vim's "killer feature" is its text editing language and modality. But plenty of other editors and IDEs offer vim emulation to varying degrees of success. So this can't be the reason to use (neo)vim-the-binary as my editor over, e.g., VSCode.

"varying degrees of success" is rather short of "sufficiently to not cause problems"; in my experience they're only good enough to get into the uncanny valley of "will this work" hesitation before every keystroke outside the most common.

> y. I can make vim into whatever I want depending on the context. Because of this, I'm able to use the same vim in many different contexts, instead of having different tools for different tasks.

Better to have specialised tools for whatever they are good at than a tool that's isn't good at any, and you have to spend time cmolding it to be a pale imitation of specialised tools.

> I wouldn't want to open VSCode every time I want to write a quick note, for instance.

Why would you open VSCode? You open a note-taking app.

I first became interested in Vim for the modular editing, but you can emulate that in other things.

What I stayed for, is how much closer to the "metal" it makes me feel. I started programming in IntelliJ, but using that I always wondered what was going on in the background. If I click on the green "play" icon, what happens? That magic is gone when using something like Vim without plugins. Configuring it to do everything you ever need yourself, however, can be quite a pain. So I gradually added plugins, to delegate the nitty gritty config work to plugin creators, making sure I understand what those plugins are actually doing, in order to not get back to a "I have no clue what my editor does" situation.

> Vscode or other powerful IDEs do the work much better.

The thing about Neovim is that this quote is becoming less true by the minute. Also, nvim can do some things that I don't think are possible in other editors. Have you tried embedding IntelliJ in your browser? :)

Work much better for you perhaps. I'm not sure why installing plugins invalidates Vim, when everyone I know that uses VSCode also installs many plugins.

The difference for me, is that I only have what I want.

My requirements for an editor are:

1) Fast <- Most important 2) Autocomplete 3) Fuzzy finding 4) Prettier/eslint or equivalent

If I need to jump on a server, I do not suddenly forget how to use Vim without my .vimrc.

For me, vim is appealing because of the composable keyboard commands that let you navigate through text in a very powerful way. When you get good with it, it's way quicker than using a mouse. It also makes you feel cool, which is most important of all.

You can install a vi emulator that does all of that in most modern text editors or IDEs, VSCode included.

"all of that" is a bit of an overstatement ime.

All modern IDEs have vim bindings.

All modern editors (except Atom) do a substandard job of actually BEING Vim. And frankly, I don't believe being Vim should be a goal of other editors.

As someone who has to use IntelliJ when doing Kotlin/Java, I miss all the wonderful things that my Vim can do. Sure IntelliJ even lets me load my init.vim for maximum compatibility... and it's simply not that great.

Lastly, almost all modern editors suck down a ton of memory... whether it's Electron or JVM based. Sublime is an exception here.

My experience is that many of them are shoddy experiences. Some might be really good though.

Exactly. They all emulate up to a point, and that point seems different with every emulator. Then slipping out of vi mode to do something specific to that editor/environment ruins the flow.

Although the emulations are getting really good. For instance this [0] VSCode plugin isn't even an emulation. It embed neovim into VSC, even loads your init.vim file. Snappy too.

[0] https://github.com/asvetliakov/vscode-neovim

I've used it quite a bit but I've had it desync from the server state somehow on multiple occasions making the experience not all that pleasant.

Better still, all modern IDEs have tools that actually work with code, not text.

And navigating code is significantly fatser in an IDE than in Vim. This includes things like juping to definitions and implementations, finding call sites, fuzzy search on symbols (not text) and dozens and dozens of other things.

The advantage is that vi is a language.

You can speak that language in Vscode... kiiiiind of, just like you can speak evil to emacs. But these are dialects, vim is the real deal.

Neovim with a ton of plugins offers a lot of what an IDE brings to the table, and lets your fingers speak fluent vim at the same time.

So when you're randomly shelled in to some stock install that's got vi (realistically this is mostly vim but it doesn't have to be) you can keep speaking your native language for whatever text editing you might happen to do.

Neovim also "just works" over SSH, and vim fragmentation has always been a thing anyway (e.g. debian shipping vim-tiny by default which is technically vim but also very lacking).

Also using IDEs vs text editors with plugins is a matter of preference (and flamewar) and I disagree with your last statement.

> Vscode or other powerful IDEs do the work much better.

Better how?

As much as I respect VSC and IDEA authors - they are often 'too much' and too heavy. IDEA (and its children like Goland) in particular.

VSCode is also way too bloated for me.

> the real advantage of [vim] is its installed everywhere, and just works over ssh.

I've always thought this is a very silly reason to use vim, when almost any text editor can remotely access files via ssh, and FUSE tools like sshfs exist.

I use vim extensively as both an IDE and config file editor, but almost never actually run it remotely on servers. I would rather not lose my configs and have to have two separate sets of muscle memory.

I tried out neovim because of VSCode. The VSCode vim plugins are generally unsatisfying. They’re vim emulators at best. The plugin that uses neovim as a server is amazing.

I tried running it with neovim stable, but it always warned me that was unsupported and I got occasional bugs that required a VSCode reload. Thus, I’ve been on 0.5 nightly for a while. I didn’t know why the VSCode plugin demanded it. I think after reading this post, it’s the LSP support.

With text editors, it’s nice to have the UI be entirely made up of text. Makes it easier to think about how one would edit their text editor.

Ah and vim is text editor, not really an ide.

From my experience, plugins add 'nice to haves', while the main benefit of vim is the core (modal editing, fast navigation, etc.).

If I get on a linux machine other than my workstation, I'll generally not install any plugins and still be able to get the job done without getting frustrated.

Honestly, I don't have any system I can access where "vi" is not actually vim any more.

The people who actually use neovim disagree with the first and last sentences in your comment.

Shhh, we're playing a game of "pretend pure opinion is a fact and hope no one notices".

I have to disagree with "powerful IDEs do the work much better". It's just not true. Neovim with a few plugins (less than 10 is certainly enough) can definitely compete with IDEs.

I've used emacs for about 10 years (written plugins, declared emacs.d bankruptcy, gone all-in on org-mode), so I'm familiar with the pros of configurable editors.

Here's a list of more advanced functionality built into Intellij that would be difficult to replicate:

- Bullet-proof navigation and advanced refactoring that works every time across a wide variety of languages.

- Database integration: syntax highlighting for SQL code in strings, runnable sql, database introspection

- Debugging: consistency and polish across languages, not relying on external tools that might not be installed, visual debugger

Text-editors struggle with the "integrated" aspect of an IDE. It's not terribly difficult to coerce text editors to perform well for a single language. It's much harder to integrate plugins and provide a consistent experience.

There's good reasons to use text editors (learn how it all works, extreme customization, magit, lightweight) but there's many development tasks Intellij is just better at.

I mean, it's a trade-off. IntelliJ is better at some things, and worse at others. There are certain programming languages where I prefer IntelliJ (mainly Java and PHP), and there are other cases where I prefer Neovim (Rust, Julia, Python, LaTeX, markdown).

> Text-editors struggle with the "integrated" aspect of an IDE.

Neovim integrates a lot better with my terminal heavy workflows than IntelliJ does.

I use vim + LSP because it's generally faster & responsive than VS Code.