Beyond that?, I just run LazyVim unmodified. It supports Copilot out of the box, which was my killer feature for it. Last year I even wrote a set of shell scripts I can curl into any new Ubuntu machine to fully automate all the setup for me, which might be of use to you as well, if you want to skip all the configuration. It also installs fzf, fd, rg, and a whole bunch of other useful tools all at once.
I had the same problem with configuring (neo)vim, it's simply too much work to get a reasonable IDE experience. Using an already well tested and documented configuration helped me to make the switch.
But yeah, webdev had me switch to Lunarvim (my favorite among all those nvim distros)
Keep nvim as minimal as possible IMO.
I am also firmly in the vanilla config camp.
Neovim is very usable out of the box. Once you are invested in the interface (modal editing) then look to get 'fancy'.
I think the big config approach just tries to make the editor an IDE. You don't most of that to try it out.
Start simple.
I suggest to take someone's lua config and start from there. Kickstart.nvim is a good one: https://github.com/nvim-lua/kickstart.nvim
Despite what others may say to convince you otherwise, this is the only correct answer ;)
There's another faction, of users who have come to vim/emacs in the era of decent IDEs. I think a lot of these people have come in due to the keyboard focus of these vs. IDEs, or because they are very quick and responsive (though recent IDEs themselves are finally really fast, too), or due to aesthetics or because it's percieved as being "hardcore" or "cool".
IMO if you're productive with what you're using now, stick with it. But try other things and see if they click. This goes both for the Unix graybeards and the IDE kids.
I then left it backgrounded in my brain for a couple decades, only using it here and there when I didn't have a GUI available, while I used JetBrains IDEs. I couldn't be bothered to do all the customization.
But the past few weeks, I got pissed at JetBrains for the way they're handling the CLion->RustRover transition, and my CLion license ran out and I said f'it, and spent a weekend really tuning emacs for my workflow. And, honestly, it's kind of awesome.
The key point being I can make it do whatever I want really. So the learning curve really comes down to what I put on it. LSP + Company Mode + Rustic Mode + Treemacs + Projectile is a pretty good approximation of an IDE. And then I just went through and tuned it up with the bindings I wanted, adjusting things as I went.
I had never in 30 years invested this much time into emacs before, and it was entirely worth it.
Anyways, the TLDR is: it's not just the "I want to be hardcore" and "I am ancient", there's real practical value to the depth of these tools that's actually hard to get out of other "editors", even VS Code. I can't speak for Vim, I have never liked that way of editing, but with Emacs it's really about building your own lightsabre.
I've heard that a lot of vim folks get similar behavior via tmux and leverage other shell tools.
I'm not going to argue you should switch, because it is an investment. It is like owning a house, you have autonomy but you're also on the hook to fix the air conditioner. You also can't just drop it and move to the next editor. Your hands and workflows become tied to your editor. Keybindings may be similar, but it is not the full story. Either way, it is a journey getting good with your tools, so enjoy it!
I feel naked without those commands at my fingertips. It's not even about speed, without it it's like... it's like woodworking with a table knife
If I were to take up modal editing now, I'd go for Helix. It's a better editing paradigm (Kakoune inspired) and it aims at just working out of the box.
I finally opted for Lunarvim but I believe all those Neovim distributions are great
The amount of time you need setup *vim in order to make it a useful editor is not justified, i have seen people waste weeks on it and the only reason is if you have a condition that vim helps to masquerade.
Personally m waiting to get enough money to justify a kinesis keyboard, that will the only reason to improve my neovim knowledge... as for the moment the vim keybindings for vscode are as good as neovim.
[1]: https://github.com/neovim/nvim-lspconfig/
[2]: https://github.com/neovim/nvim-lspconfig/blob/master/doc/ser...
It's a single file and you can pretty easily use it as a starting point for your own config.
And it comes with the which-key.nvim [2] plugin that helps you learn vim motions.
Along the way there are innumberable little choices that you make that shape it into something completely your own. Plus you know it's never going away or getting enshittified because it's open source and has been for decades.
Now, does it actually make you more productive? Or is any productivity you gain swallowed up by tinkering with configuration? That's an open question, and a valid one. People who enjoy an out-of-the-box IDE experience are fine by me - different strokes and all. I just enjoy working in an environment that is always gradually evolving according to my needs, even if it means putting in the work.
Also, I started using vim basically at the same time I started using Linux and really learning to program. There were plenty of other editors and IDEs around at the time. Even for the languages I was learning. I still use vim, but not those editors.
I will break vim into two parts: its philosophy(s) and its technical implementation. I think both are valuable, but for separate reasons.
First the technical implementation
Because I've been using vim for so long and from such a foundational stage for me, vim is largely just how I think about editing text now. Not just insert vs normal mode, either. Vim includes a whole host of features for editing text. I've been using it pretty regularly for many years now and still learn about new features. The rabbit hole is huge.
To the point that I find a lot of plugins either re-implement built-in features or outright go against the philosophies in vim (more on this later). Personally, I spend as much time (or more) trying to remove plugins as I do trying to find new ones to solve a need.
Plugins have better SEO, but worse integration with the editor, on average. Because of this, I might use a plugin for a bit just to solve a need, but then upon reading up on vim documentation (some of the best around), I might find a way to do something better than my current plugin-based way.
A frequent example is when I need to open a file that doesn't have built-in highlighting support. Instead of adding another plugin that might include more than just syntax support, I might really just need to alias it as another language. e.g. Jenkinsfiles are mostly just Groovy, so the following line is all I personally needed to make editing Jenkinsfiles in vim acceptable [0]:
au BufNewFile,BufRead Jenkinsfile setf groovy
None of that is to say "don't use plugins". Some people use hundreds of plugins, others use zero or very few. Both are correct. Personally, I still think that it's really easy to get carried away with plugins in attempts to try and turn vim into vscode or an IDE. If that's your goal, save yourself a ton of headache and just use vscode or an IDE. Truly ask yourself what it is you are trying to achieve with vim and work towards that, not feature parity with a completely different piece of software. [1]
Probably the biggest watershed moment for me was learning to use vim's buffers to manage multiple open files instead of always using vim's tabs. It has tabs, but they are a different metaphor from "tabs" in most editors. That still resulted in me adding a plugin to display open buffers at the top of the view, but that is an incredibly simple plugin that augments built-in vim functionality rather than try to shoehorn vim's tabs to work like tabs in other editors.
Getting a bit more philosophical
If you'll pardon a somewhat-forced metaphor, vim is a box full of handtools, not an all-in-one power tool. Each one can accomplish the vast majority of what the other can do and neither is inherently better than the other, but their ways of doing so differs greatly.
In particular, vim (like handtools) expects you to learn how to use it. It expects you to not only read the manual, but to keep referencing it and gradually learning new techniques for doing things. It expects you to sharpen it. It expects you to oil it. It will cut you if you abuse it [2]. This is also true for the power tools and other editors, but the whole point of using those is that your expected learning and maintenance is greatly reduced.
The payoff for those years (yes, years) of dedicated learning, at least in my experience, is that you will have a closer understanding of how the tool works. You will gradually develop a sense as though the tool itself has wants and needs. To be entirely too romantic, it is a symbiosis. Again, the way I think about editing text is in vim's commands and metaphors [3].
The other reward for that time spent is that vim doesn't really change. Sure, it's still updated (thankfully) and gets new features, but it is glacially slow to really change anything fundamental. This is often cited as a bad thing, but I personally love it as it means I can depend on it. I don't have to worry about my tool changing out from under me. That is rare in software, especially these days.
Sometimes even a master woodworker might still need a 3D printer, but having mastery over a hammer and chisel can pay dividends.
[0]: That line creates an autocommand for whenever a file called Jenkinsfile is opened or read, set its filetype to groovy instead.
[1]: There is an old article called Linux Is Not Windows. It's been a while since I've read it, so I might not agree with everything in it, but it presents a really great point: the only way Linux can be better than Windows is by being different. That means you will have to change your mindset before you understand it and/or like it.
[2]: Pretty big stretch here. It's not buggy and won't really do damage. I really just mean "cut" as more of "will be slower/harder than it might be otherwise".
[3]: I should point out that, while tools like vscode have plugins and settings to emulate vim's commands and a couple of modes, I have always found those lacking for my needs. I hope it's clear by now that vim is far more (to me, at least) than just using hjkl to move, dd to delete a line, etc.
My simple config does include vim-commentary, vim-surround (both supported by jetbrains too) and fzf.vim.
Neovim is bizarrely confusing and difficult to configure. The UIs are all weird terminal windows with no buttons, it isn't clear which of the dozens of folders are actually being used for configuration files, it isn't clear how the actual attributes are being declared, it's a disaster.
But it does take time, and doesn't come "out of the box" with the creature comforts you're probably used to, and has "weird" ways of doing things that are very old but there's usually good reasons for them.
Being familiar with vi keybindings can be useful if you ever find yourself on a minimal system with no other editors available, but the subset of knowledge you need in that situation would be much smaller than if you wanted to use Neovim as your primary development environment. I think Emacs/Vim/Neovim and the like are better suited to users who actually enjoy the process of configuring stuff like LSPs and code completions in a way that's fine-tuned to their personal preferences and works the same across all programming languages.
You won't get the deep magic of emacs, or the benefit of learning vi key bindings (sadly there's not yet a helix mode for gnu readline) - but you get a great modal editing experience, good defaults and great discoverability.
I moved from vim/neovim a while back - and now I find vi/vim verb-object (d[delete]w[ord]) yanky compared hx visual select/object-verb (wd).
I've been using vim for some 15-20 years prior.
https://github.com/helix-editor/helix/issues/1596
What does g; do?
Helix has (experimental?) macro record/playback q/Q?
Unfortunately I reliably labor to get might visual selection correct in helix and then mistype a key and it's gone. Glad to hear it's coming!
`g;` takes the cursor to the location of the most recent change you made (and then the one before that, etc.). <C-o> in helix doesn't ever seem to get it right (unless I remember to <C-s>, which I never do).
Also glad to hear about macro support.
I should take another look at if they are interested in contributors. One of my main interests in helix is that I enjoy rust and don't know C/C++, so I feel like I could maybe "give back." That said, my first issue I raised was not taken very seriously (and is a show-stopper for helix on windows in my case).
Wonder how I missed that. I'm getting a re-education in helix today -- thank you! I'll go through `hx --tutor` again before I insert any more feet in my mouth.
I often use `viwd` instead of `dw` to create a selection before deleting.
What I like about neovim is that it's as fast as greased lightning. If I could say the same thing about Emacs there would be no competition.
> Transform your Neovim into a full-fledged IDE
Why would I go over the trouble of debugging my editor for simple stuff like having LSP completions and semantic highlighting? It's insanely difficult for me to wrap my mind around vim packages, configs, etc., when VSCode/GoLand/et al. do a pretty darn job being decent editors that you don't need to hack on and just work out of the box.
Don't get me wrong, I'm not throwing shade on vim/emacs, I'm just wondering what am I missing since everyone's been super happy and productive with vim for ages, and if I'm approaching these tools the wrong way...