Neovim 0.8 Released

Sometimes I need a terminal text editor. Something to quickly edit a config file, or perhaps even write something more substantial. Vim and Neovim are perfect and available on pretty much any machine which you'll have a terminal open to access.

I installed it, had some LSPs already on path. I configured it to show LSP messages and that was about it. It's very cool how gosh darn productive I can be, in such a short time due to the command palette built in.

Seems like folks are taking note too. There's a few intro videos on YouTube that do a good job posted in the last few weeks; apparently some big Vim-guy streamer checked it out last week. Active Matrix room and constant code improvements. And native nix flakes support too ;)

Btw, I find it a bit weird to include VsCode and Helix here together. Helix is perfectly usable as a Vim replacement for all basic text editing tasks, and a superior zero-config alternative in countless other scenarios.

Most important to me when I started tinkering with him was the speed/feature tradeoff, and portability. I was working on 7 machines at one point doing pretty quick edits of config files and Python scripts, so launch speed and availability across different environments drive me to vim.

Now there are alternatives, but back in 2015 these were all in their infancy. And now I _know_ vim and it keep adding more features. The incremental cost of adding language server support is much less than the cost of learning how to move around VSCode, so my (neo)vim config keeps growing slowly but surely

I prefer sticking to full terminal UI

When I used vscode I was frustrated by vsvim's latency & missing features (macros tended to have holes)

I didn't start using vim until I'd been programming for a decade already. Before that I mostly used SciTE

You may be more susceptible to over tinkering. In the past few years the most I've tinkered with my setup was when I decided to try out neovim's lsp feature, where previously I'd been using coc.nvim

EDIT: I'm also a tmux user and I can't live without a replacement for this plugin: https://github.com/christoomey/vim-tmux-navigator

VS Code is a proprietary, spyware-riddled, resource-wasting worked example of why "modern" software sucks. Also for my personal use, everything that's not vim suffers from being not vim; it would cost me effort to switch for no clear benefit, and I'd still need to retrofit the same control scheme into whatever it was because the muscle memory is too strong, at which point I might as well just use actual neo/vim.

> which were built to be used as rich development environments instead of extensible text editors

> spent months tweaking Neovim/Emacs configs

I think part of the difference might be of usecase; if you want an IDE, use an IDE. If you needed to spend that much time bending the tool to what you want, maybe it wasn't a good tool to use. When I open vim, it's because I want a text editor, and it provides a text editor.

If you want a bare ultra fast, terminal text editor, neovim is that out of the box.

If your only after LSP, tree sitter, embedded terminal, neovim's got your back.

Basically, neovim embodies the beauty of Linux. Use and pay only for what you want.

Not because I particularly like the language. But because I like that I can write something in a language that executes and accesses pretty much anything the editor can do.

Does helix or zed have the ability to do that? I didn't see it on their landing pages. What are the extensibility stories for these editors?

I don't want a full IDE/graphical editor. Eclipse is a mess, I'd use a JetBrains product first, but now we have VSCode as an alternative. Atom was hot for a while but has lost popularity.

Of the (linux) terminal text editors, the choices were mostly:

* Emacs * Vim/Neovim * Nano

And I prefer Vim over Emacs, I really like the modal experience.

I don't spend a huge amount of time tweaking things, I use Neovim mostly stock with some useful plugins for convenient shortcuts. Though I admit that getting the new treesitter/language server integrations working was annoying, compared to the original regex-based syntax highlighting.

My goal is not to recreate an IDE experience in Neovim, I just want an efficient text editor that is syntax-aware.

If I wanted an IDE then I'd use an actual IDE.

When helix is more ready, I will probably switch to it.

Despite that, I still often feel limited by the vim binding plugin for VSCode. It's never a problem though, because Cmd+J toggles the terminal visibility, and I escape into Neovim there when I need it.

I tried VSCode, and after several hours I still hadn't turned off all the features that I found undesirable.

For me, personally, that nvchad thing seems horrendous. I don't know about Helix; maybe it's better, but I can't be arsed to check it out as I don't expect any productivity jump to be worth the effort.

Both webpages prominently state that the editors are written in Rust. This reduces my interest in both projects.

As a user, I do not care what language my editor is implemented in. Maybe I want a fast editor, or maybe I want a feature-rich editor. The closest I would come to caring about this is if I want an extensible editor - can I extend these editors using Rust?

Lacking any explanation as to why I should care that the editor is written in Rust, the conclusion I draw is that the creators of the editor were interested in an exercise in writing an editor in Rust - which I'm sure is a wonderful learning experience for the creators, but I don't see why that would make me interested in using the editor.

Moved to neovim because it felt faster than vim 7.x and it was fresh and exciting (couldn't believe the progress the project was making in a short period of time, compared with vim). Then I stayed because of the native LSP support and nvim-metals (among others).

Things work, to the point that I'm not really using the editor but editing (if that makes sense). It is completely invisible to me. It is my editor.

Just about 30 years of muscle memory for ed, then vi, eventually vim, and recently neovim. Also because one flavour or another is pretty much guaranteed to be available on any server I log into - as a contractor, it's handy to know there's a (to me) usable editor wherever I end up.

> I've spent months tweaking Neovim/Emacs configs in the past

I had a brief spell of Emacs madness at uni but then recovered and I've had pretty much the same vimrc since picking up vim modulo adding things like go-vim and surround in the last few years.

I switched away from VSC because I grew frustrated with the constant lag and terrible loading times.

The modern native stuff is either MacOS only or a proprietary newcomer, leaving me with no trust that I can stick with it long term.

And I'm a Nix user, so neovim doesn't randomly break for me, all versions are pinned. And if stuff does break when I chose to update my pinned versions it's trivial to rollback.

These days I've been using the LunarVim suite of neovim enhancements and I like it quite a bit.

https://www.lunarvim.org/

95% of my coding workflow takes place in the terminal (along with tmux and iTerm2) and neovim fits very nicely there.

This created an imperative around efficiency per keystroke that, somewhat shockingly, remains the most thorough and successful mainstream attempt to get the most from every keystroke.

With modern technology and decades more experience it seems inevitable that someone could do better today (though even with those benefits not everyone is Bill Joy), but I’m not aware of anyone who has successfully attempted to beat vi/emacs for the “will learn arbitrarily hard tools to be fast” crowd, which necessarily counts the “my RSI is so bad I need my money’s worth out of every key press” crowd, and several other big blocks of badass hackers.

People still use these tools because they still have the highest ceilings on the effort/power scalability curve. That doesn’t make them right for everyone, but it makes them right for a lot of people.

Maybe I should spend more time on it, but my settings work for me and I can't really be bothered/find coding projects much more alluring than editing a config.

Why emacs, then? Mostly that I like the keybindings more than anything else. Emacs extensions in vs code are a poor imitation at best. I'm not really into modal editing either. Maybe I'd just have to spend the time to learn that, but I'm quite productive with emacs, so I don't see the incentive. I have keyboards with thumb clusters, so it's comfortable and quick to press key combinations in parallel. Switching between modes and executing key presses is inherently serial in comparison. I assume with practice I could get very quick at that as well -- after all, typing is also serial, but can still be fast. I just don't see any value proposition to switching.

WebStorm was great, it was really magical how it just knows how this or that code relates to another piece of code, navigating around was a bliss. Where is that variable defined? Jump to definition, and you're there. You want to know what's that function does, even if it's somewhere in third-party libraries? No problem, jump to definition. The fuzzy-finder for everything (literally. From file names to methods to editor's commands and variables) was also amazing.

At some point though I got a bit annoyed with the fact that it took 5 seconds to start it up (multiply that by amount of different projects you need to open), and it's general resource hungry-ness. So I started experimenting with Neovim 0.3 (at the time), and pretty quickly managed to get near-webstorm experience with gutentags, fzf and amazing vim-fugitive for all the git things I did in the command line. And with resent native lsp & treesitter, it doesn't

I tried VSCode once, which was a fiasco -- for some reason it failed jumping to definition in a basic react project with typescript. Oh well.

Helix looks really cool, I'm playing around the idea of using it more, though I still will have to keep (Neo)vim around for vim-fugitive. Slightly concerned with how much muscle-memory re-training will needed though, then again it didn't took me too much to get to the same level of ease of use with Doom Emacs. Speaking of which, it worked flawlessly (and has even better git tool), but still was terribly slow at times, so in the end got too annoying to work with.

So in the end it boils down to Neovim being fast, not getting in the way, and habit, I guess.

I usually try something on my local machine and switch to the server and do this back and forth and sometimes the other way around, I have a test server where I test something before trying it on my local machine. Having the same text editor on all of these environments mean I don't have to context switch much, also I have my own custom config which I have been improving over the years and the fact I have multiple vim instances running right now and they are all consuming less than 120MB memory and the fact it responds really really fast is a really nice addition.

When I first started using vim I remember I asked one of my friends the following, "what the hell is wrong with people, why do they love using this god awful garbage" I remember my friend asking me to keep trying for a little while longer. Thank heavens I took his advice, I can't really remember when it happened but one day it just made sense.

Then I saw a neovim config file, and how good it looked with lua scripting, changed my old vim config in to a neovim one, and now I use neovim.

(plus I still have trust issues with a certain multi billion dollar company)

I've never understood the advantage of "rich development environments". The refactoring tools and other fancy aids seem to never work. I wind up using regexes + manual intervention anyway. Also, I don't want to use git through a gui. Leave me be in the terminal where I have everything I need at my fingertips as fast as I can think.

Syntax highlighting, linting, completion, and docs are all nice, but I have that in vim. I can run vim in the dev instance I'm ssh-ed into (which is 99.99% of how I work, anyway -- my work laptop is ancient and they won't replace it). I just can't see what those tools add, even for very large codebases.

My configuration for vim began in the 90's. I've never put that much work into it at any one time, though it has grown quite complex over time. There are a bunch of plugins I use manged in the config file. 90% of the functionality I need works without those plugins, but even when I need to install them from scratch it's easy to go from "scp config file over" to "full setup" with one command.

So in summary, I use vim because it's part of a larger set of standard unix-y tools that are heavily ingrained into muscle memory. The biggest advantage of vim in many ways is that it's a relatively rich environment (e.g. linting, syntax highlighting, doc hints, etc) that I can ctrl-Z to immediately be back in the terminal with. Other than that, it gets out of my way, and I don't think about the editor at all, I think about what I'm doing (decades of muscle memory helps a lot, though -- I'm incapable of not using vim keybindings to edit code, I think).

I should move over to neovim, but mostly haven't yet. That's more due to a couple of weird plugins than anything else, though.

VS Code has always felt clunky to me. It always felt like a halfway house between the speed and simplicity of Vim and the maximalism offered by JetBrains IDEs. I also just generally don’t love GUI apps for code because I desire to be right in my shell.

NeoVim offers LSP, Tree Sitter, DAP, and easy extensibility to reach full parity with any IDE, but with the benefit of it being:

* Faster (both in processing speed but also in my workflow). I can navigate significantly faster in Vim than I can in any other editor. * More familiar, to me.

I can’t speak to Helix as I’ve never heard of it, but in general, the Vim community is very strong and long-lasting - it’s been a top tier editor for the past few decades and will likely continue to keep that place (albeit NeoVim is the currently favored flavor for me).

Beyond that, the extensibility of Neovim is unmatched in VSCode.

I also do most of my development in a VM and VS code remote shell is significantly slower for me than just ssh + neovim.

> huge amount of work, hoop jumping, and fragility to reach parity

This seems inaccurate. Maybe it’s because I use NixOS but my editor experience is literally the least fragile piece of software I use. I’ve ran into far more issues in both GoLand and VS Code than I have in Neovim. Perhaps because Neovim is less of a walled garden?

It took me about a weekend to properly learn Lua and how Neovim works, and after that, I was set.

> spent months tweaking

I don’t know what process you took, but properly learning the tool from the ground up and minimally adding useful plugins as you go should not take much time at all. I don’t really touch my editor config unless I need to install a new LSP server - it always just works.

—

At the end of the day, the best tool is the one that enables you to be most productive. I find almost anything outside of the terminal clunky (the main exception is my browser).

For similar reasons, I prefer the command line to GUI-based applications, that all seem to be built around either a love of clicking through a long series of cascading menus, or memorizing obtuse shortcuts. TUI applications like Vim integrate much more readily with my other command line tools, so it creates a much more seamless workflow.

I was always bummed OniVim v2 didn't take off.

It was a native IDE but fully supported VS Code plugin system.

* +20 years of muscle memory

* Total customizability, when you get good at configuring and writing small scripts it feels like you can do anything. VSC feels like it's all about plugins

* On the fly remaps. E.g writing latex and quickly add insert mode remaps for things you are currently writing about ":imap CO2 $CO_{2}" for a prettier version of CO2 as you type. Playing around with Zig? With ":map ,t :w<CR>:!zig test %<CR>" you can type ,t and it saves and tests the current file.

* Write simple scheme files for pattern matching with Treesitter to conceal unnecessary clutter in some programming languages

* Snippets, other editors have this as well but with Luasnip I program every aspect of how it works exactly as I want it

* Even with a bunch of plugins it starts in less than 100ms

For another point I don't see being brought up, I love the .vimrc file. You can version control your entire editor config in one file. Other editors tend to spread config out across different files (one per plugin for example).

I've had to spend time configuring every editor I've used, but all that time is tracked and documented in vim. I can have everything set up instantly.

If you're a front-end dev there's really nothing better. Also the https://www.tabnine.com/ integration feels like magic, it predicts the next block you're going to type with scary accuracy. I'm excited to see where AI IDE integration goes.

But I still hate how VSCode is like a browser that will grind to a halt if you install (or misconfigure) too many extensions.

- I like terminals because there is nearly nothing disturbing you, and it's usually quick to have something

- there are many little features that looks like nothing but are really really useful when you use them. I'm a big fan of C-a / C-x to increment / decrement a number, coupled with https://github.com/nishigori/increment-activator it's super useful (to change a boolean, a date, a number, etc). The "." to repeat last command, the "*" to search what is under the cursor are other great features. An occasional macro made with "q" may save a lot of time when you need to do a repetitive task, for refactoring for instance, and you can even repeat them according to some patterns with ":g". I'm not sure if those features have handy equivalents on other IDEs.

- I didn't spent that much time doing my config, just adding little changes here and there when necessary, over the years I've got a environment really adapted to my taste.

- I'm currently doing mostly Python, and vanilla (neo)vim is normally good enough, but I'm using Coc (https://github.com/neoclide/coc.nvim) for a little while, and it add a lot of helping stuff easily. Pyright + snippets are useful.

- when something cool happens somewhere else, you often have somebody adapting it to vim. I can use snippets and emmet which are occasionally very useful.

At the end, I don't feel the need to change, it works well, and over the time I could add some neat features to improve it (snippets, emmet, CoC, tagbar, etc). I'm not sure if changing to something like VScodium would worth the time to learn something new (and I like working with terminals).

Vim or neovim inside tmux are really nice, though. You can just use the normal general-purpose linux ecosystem rather than learning an IDE.

- First and foremost, I love the text editing features Vim has (eg. the movements, modes, keys etc). It just feels great on my hands.

- It's minimal. Well, you are free to make it as minimal or as bloated as you would like to ;)

- For me, it sort of gamifies text editing. I don't claim that using Vim makes me x-times more efficient at programming than someone else, but I do enjoy the thrill of learning a new, quicker way to make some changes.

- Vim/Neovim offers me a seemingly endless amount of things to learn. Some may see this as a negative thing, but I see it as a feature. It's truly like a skill or a hobby. You can learn the basics and be perfectly fine, but you can also dive deep into more ways to improve. I love this.

- I love how configurable it is, and also that you can actually learn about how it works.

- Also if I'm being honest, I feel like a myself and a lot of other Neovim users are basically masochists to some extent.

Every time I try VS Code, I get frustrated within 10 minutes and close it.

It’s a resource hog and the UI is kinda all over the place. The Vim plugin isn’t bad, but it only goes so far with the basic motions. It’s fine for basic editing but when you need to go deeper, it can’t go there.

I haven’t tried embedding Neovim yet, but that seems to be kinda of a hack. Besides I already have Neovim, so why would I embed it into a lesser editor?

But it still feels like a huge amount of work, hoop jumping, and _fragility_ just to reach parity with VS Code/Helix/Zed

I already have a Vim configuration I’ve been using for many years, so it was no big deal using it with Neovim.

I would also push back on the so-called fragility. I’ve been using Neovim for a 2-3 years and it hasn’t crashed once and I’ve done a lot of experimenting. In fact, I’m pretty impressed how well the many different plugins all work together. For example, I use the Tokyo Night colorscheme and it supports a bunch of the standard and 3rd party plugins by default:

* TreeSitter * LSP Diagnostics * LSP Trouble * LSP Saga * Git Signs * Git Gutter * Telescope * NvimTree * WhichKey * Indent Blankline * Dashboard * BufferLine * Lualine * Lightline * Neogit * vim-sneak * Fern * Barbar * Scrollbar * Mini

In a way, it’s not new—lots of old-school Vim plugins I’ve used also work great with the rest of the plugin ecosystem.

Vim was designed from the start to be part of a rich development environment. An IDE typically is a monolithic application; Vim and Neovim are designed to work as the centerpiece of a system of applications used by developers where they can use the best in class utilities as extensions to Neovim.

Vim works with linters, compilers, extensions, command line utilities and has done so for decades--and that was before Treesitter, LSPs and being able to be embedded.

> If you use Neovim, can you share why you chose it over VS Code

Who said you can't use both? Neovim is a text editor, and VS Code is an IDE. There is overlap, but they serve different purposes.

I use Emacs because it has a lot of capabilities that make little sense in an IDE. I don't think many people use VS Code for reading email, for example.

And I use VS Code when it's more convenient than Emacs (e.g. debugging).

- I like I can use the same editor on any platform. I'm a wearable computing nerd having several HMDs and small devices (devterm, raspberry pie, etc.).

- If it's my own platform, it's easy to compile it. It runs in a console and most of my plugins work on embedded, desktop and server systems. (could even compile it and use it on my hacked google glass .. with a twiddler one handed keyboard :D ).

- I like the use of keyboard-only and mode switching. It's more an hobby than anything else. I also use qtbrowser and Nyxt.

Also growing up with a very different Microsoft ("Linux is evil communism"), I still feel uncomfortable using VSCode.

https://mobile.twitter.com/hillelogram/status/15676069643974...

The central point of the thread was that VS Code is designed to be extended by dedicated editor extension developers while Vim is designed to be extended by basically all users of Vim. There are tradeoffs to both approaches.

I also use vscode and other IDEs. Why make it seem like one has to choose? That's like saying 'why do you use a hammer, i like screwdrivers better'.

I used Vim because every GUI editor was an ugly, siloed proprietary mess that was mostly just wrapped around a bunch of open source command line tools, while Vim was an ugly, open source, programmable mess that was mostly just wrapped around a bunch of open source command line tools.

I am using vim/neovim for almost 15 years now. I was introduced to vim within _days_ after I started programming. I have a workflow where I open and close my editor several times per minute (although I'm now slowly moving away from this workflow) - startup speed matters a lot for this, of course. I never bothered to learn another editor or IDE because of the speed I get with (neo)vim. Moving my hands away from the homerow for interacting with IDE features just feels like driving a Porsche in a 10mph zone. I have muscle memory in my hands for over 10 years now!

I switched from vim to neovim at around neovim 0.5 mostly for ideological reasons, but I stayed for lua based plugins and a IMO better community. I rewrote my complete neovim configuration (which I took over from vim of course) about a month ago to be pure Lua and to be more streamlined... I don't consider this work or hoop-jumping at all, but optimizing my editing environment to safe time when actually editing source code (or emails fwiw).

On a side-note, I also use vim-ish bindings for everything else, for me DE/WM, Email client (which uses neovim to write emails actually), etc etc. I just don't see a point in un-learning all this.

There’s others, too, but none seem to have a big and healthy community like (Neo)Vim.

You can run your current .vimrc using neovim.

Newer plugin development seems to be much more on the nvim side than vim as well. (Although I do feel fzf is superior to telescope, at least out of the box.)

I'm happy neovim exists, it rekindled vim development.

Also, someone correct me if I'm wrong, but isn't the bus factor 1 on vim?

https://neovimcraft.com — For neovim specific plugins

I may end up sticking with og vim but my heart has always been with neovim. regular vim would undoubtedly still be stuck in the stone age (including with no :terminal) had neovim not started some competition. I get the feeling that VimL's evolution was done in a way that made it quite difficult or impossible for neovim to merge/rebase into. Hopefully that wasn't intentional.

https://github.com/nvim-telescope/telescope.nvim

Then again, most of my time these days I spend in JetBrains Clion with Vim emulation, as it is much better suited to the kinds of projects that I currently work on than Vim or Neovim ever was. So take my opinion on Vim vs Neovim with a grain of salt.

- configuring in lua (much easier than vimscript, imho) - treesitter - built-in language server protocol - plugins (id call them "projects") like telescope

Plus Vim and Neovim can co-exist on the same machine without an issue to try it out [1].

[1]: https://neovim.io/doc/user/nvim.html#nvim-from-vim

However, I would imagine that well over 90% of Vim users don't use a single plugin. At all. They defined some look and feel defaults in a ".vimrc" file 10+ years ago, and never thought about it again. At least that's my user profile, anyway.

So to me, the NeoVim story is mostly Internet drama, about some salty devs who didn't get their patches merged and have been publicly jihading ever since. It's not enough to merely use NeoVim, you have be angry about it.

A big deal was splitting the editor engine from the interface so that it's embeddable in other editors.

I'm also a heavy user of terminal though, and that was the one thing I spent extra time on, because there were subtle differences that I didn't like. If you give neovim a shot again, try this in your ~/.config/nvim/init.vim (aside: I do miss the simpler path of ~/.vimrc):

  " Neovim's default terminal mode bindings aren't great.                                                                  
  " This makes them behave like vim's.
  tnoremap <Esc> <C-\><C-n><C-w>
  tnoremap <C-w> <C-\><C-n><C-w>

  "Always enter the terminal in insert mode
  autocmd BufWinEnter,WinEnter,BufEnter term://* startinsert
  autocmd TermOpen,TermEnter * startinsert
  command! -nargs=0 Terminal :vsplit | term

The former sucks to do in vim, I couldn't get it working in tmux at all, and I don't think the latter is possible?

Apart from that I'm treating it like vim and using all my existing vimrc and vimscript plugins. It's been good.

I certainly haven’t experienced any slowness with opening files with Neovim with Treesitter. It certainly enables much better syntax highlighting, among other things [1]. If anything, it’s faster than the regex-based syntax highlighting that Vim traditionally used.

CoC is a 3rd party LSP plugin that works with Vim and Neovim.

[1]: https://neovim.io/doc/treesitter/

What's wrong with the default colorscheme?

I don't know why but even if I install same plugins with same config on various machines of same Linux distro version, some just throw errors on every launch while others tend to work and it's getting to the point of annoyance to keep using it.

It does feel like it's piling up parts hoping they don't fall apart.

Using vs code with remote config does make it feel saner.

https://github.com/topics/neovim-guis

Of course the vast majority of devs use whatever suits them, GUI or not.

And you couldn't have picked an editor with a worse GUI story.

ed is the standard text editor.

https://www.gnu.org/fun/jokes/ed-msg.html