If anyone is considering moving editors, I was recently in the same boat and I can’t recommend enough lazyvim + the ebook “lazyvim for ambitious developers”.
This gets you a fully featured vscode-like baseline (navigation, language integration, integrated terminal, the whole thing).
I had tried many times to switch to vim/emacs and the initial barrier to get a workable system always kept me from pushing forward. With this I was able to make neovim my daily driver at work after just a couple weekends playing with it.
I felt the same way about vim. I never had the patience to get started and configure everything to get the full benefits.
I just switched over to Omarchy for my personal OS and I know that it comes with a pre-configured neovim (using lazyvim) setup that looks like a fully-fledged IDE.
I personally have been using Helix as my editor at home and work. The fact that everything generally works on download is what got me using it.
I think some of the big features of VSCode are the extensions and, equivalently, the nice debug support. I just started using VSCode about a week ago thanks to moving to a project that uses scons as its primary supported build tool, and I've learned to hate scons and love VSCode over that time. The completely manual tasks/launch/etc stuff is kind of weird at first, but then becomes amazing and far more convenient, after you get used to it. And the 'debugger' (kind of weird to frame it that way as its extension based, like everything) is amazing - extremely fast, great visualizations, and so on.
How would vim compare?
I can't help you much, as currently I happen to use ruby at work and native debugging is enough - you can drop into an interactive console at a breaking point adding a single line, with no tooling.
Here's the chapter on debugging in the book I mentioned if you want to take a look: https://lazyvim-ambitious-devs.phillips.codes/course/chapter...
> I happen to use ruby at work and native debugging is enough - you can drop into an interactive console at a breaking point adding a single line, with no tooling.
If you've only ever used this type of debugging, you should really try out a real IDE debugger once. The difference in productivity when you can use your IDE to navigate to, say, the usages of a function and then just press a keyboard shortcut to put a breakpoint on the line with that usage is immense.
Compare this to the native debug support: you have to leave the interactive debugger, move to your editor, find usages, note down the file name and line number, then go back to your interactive debugger and type a manual break command (break my_file.rb:2517 or something). All of that context switching and remembering is replaced by a single keyboard shortcut in Emacs, VS Code, or any other integrated debugger. And no, adding manual breakpoints in your source code is not simpler - what I'm describing works interactively while your code is already running, whereas a breakpoint statement requires you to restart the whole process.
>If you've only ever used this type of debugging, you should really try out a real IDE debugger once.
It's the opposite, I learned to program with java for android so a full IDE was my first experience. As I moved to node and then go and ruby I just gradually used it less and less as I generally 'debug' creating tests to check/reproduce behavior.
I do think I should improve my debugging, but mostly in terms of profiling. I very rarely feel the need to see a codepath run line by line.
I'm not saying my system is better or worse to be clear, I've just naturally gravitated to not using the debugger - I couldn't tell you why.
I have inline debugging with gdb in neovim.
<leader>+b/B: add/remove breakpoint
<leader>+n/N: step/over
... and so on.
To start it just run :termdebug. If you change the debugger to rr you can even replay.
It's a shame the language support is poor, but I'm sure they'll add DAP support eventually.
This is exactly what I meant by an integrated debugger. I probably should have used the term IDE less, as that brings to mind Visual Studio or Eclipse and such - but I just meant any integrated editor+debugger, whether neovim, Emacs, or whatever else.
I think many people don't know or underestimate Zed. Native, fast, with extensions, with Vim mode support.
And sadly it is also not accessible to screen readers. VS Code for all its flaws is really, really good for screen reader accessibility. In fact, I'd go as far as to say that it's not only one of the most accessible code editors we have, but one of the most accessible electron apps overall. So losing it to this Microsoft stuff would be a huge deal to anyone who relies on screen reader or accessibility tools. :(
Or don't want. I don't want an AI infected editor.
Zed is much less AI-infected than VSCode. In fact, in Zed there’s a single button to disable all AI features.
but doing that would you not end up with less than vscode?
The reason I didn't explore Zed is their for profit model.
There might be awesome people and work behind it now, but I've already been burned enough times by rug pulls and shittyfication. I don't want to be planning another move 5 years from now.
Despite all its flaws, I am on Windows for work, and many projects have SDKs that have no clue Zed exists.
I suggest the opposite and not starting with all the plugins and instead try to learn the vim way of doing things. Being too locked in to the old ways could prevent discovering all the great things vim can do.
The examples you mention already exist.
- navigation: plenty of native navigation in neovim, does lazy add anything specific?
- language integration: lsp, requires config sure but git clone isn't much work.
- integrated terminal: just run `:term`
Learning to think in vim means unlearning a lot of old habits. Today I only use fzf.vim, nvim-lspconfig and a theme, not even a plugin manager (I will migrate to the native one that's in nightly when it reaches stable though). Pretty much vanilla Neovim. I'm considering trying nvim-dap to get better debugger support but so far I'm fine with :termdebug for the languages it supports (c/go/rust just works).
When I find something I want vim to do I start with a keybinding, then a function, and maybe if it's complex add a plugin. Adding half of the available plugins just because creates an unnecessary attack vector you now have to keep an eye on.
I do get the benefit of not depending on plugins, really. Long term my current config could rot (abandoned projects, moving dependencies, etc), while a simple config is stable. But I'm happy removing dependencies one at a time.
For example, <leader> ft toggles a terminal in a bottom split. This is familiar enough that I knew I could rely on it whenever needed.
Could I have used :term and manually set splits each time? or learn tmux? or use ctrl+z and fg to move back and forth ? Sure, but that's extra cognitive load.
Maybe I want to focus first on becoming fluid with regex for search and replace, or improving the flow for running unit tests, or get used to using macros as a replacement for multicursor. There's a lot of gaps to cover, each small enough that it's "just do X" for a veteran, but enough when added up that I would much rather pay the cost gradually.
> Could I have used :term and manually set splits each time?
That's when you know you want to create a keybinding, here's a suggestion that opens a split below the current window with 10% height and starts a terminal: `nnoremap <leader>ft :belowright 10 split | terminal<CR>`
But is a terminal really what you want or do you just want to run a command? Maybe just `:!command` is enough 9/10 times that you reach for <leader>ft? In that case a common binding is `nnoremap ! :!` which puts you in that mode with a single key.
> get used to using macros as a replacement for multicursor
This exact example was how I realized the vim way is better than my assumptions. I used to install a multicursor plugin and bind to Ctrl+d because that's what I knew. When I learned macros and s/old/new it became irrelevant.
You seem to already know a lot of the possibilities that you can learn, I didn't and discoverability in vim isn't great. So I just forced myself to search for whatever I didn't know how to achieve and many times ended up learning something extremely powerful.
Today I have all sorts of useful little functions, <leader>m is make, or gcc if no Makefile exists. And now I've extended it to generate mermaid charts in markdown files and open them in my imageviewer and so on.
That's the true power of vim to me, adding standard tools from the system in keybindings and just getting it to do things MY WAY, not how I was taught it should work. It follows the unix philosophy and batteries included is by definition not part of that mentality.
Same with Emacs. Needs some feature? Just write something quick in Elisp and have a new command. The primitives are versatile and a lot of tasks can be reduced to a few commands instead of a long interaction with the terminal/GUI.
> I had tried many times to switch to vim/emacs and the initial barrier to get a workable system always kept me from pushing forward
What’s that initial barrier? Both Vim and emacs has great documentation that includes a tutorial, a guide, and a reference.
What people often defines as workable system is replicating their old editors instead of learning the current one. Like adding a file tree on the side
>What people often defines as workable system is replicating their old editors instead of learning the current one. Like adding a file tree on the side
Well, kinda. I define a workable system as a system I, personally, can work with straight away, with a minimum loss of productivity. It is not at all meant as a judgement on how good plain vim/emacs are.
This workability indeed might require temporally replicating old habits while I learn the new ones, which lazyvim does. Vscode-like file trees, global search, or integrated terminal, for example.
It's also about discoverability, like the helpers shown through which-key. And the guarantee that a set of default plugins play well with each other, so that I can leave toying with the config for whenever I have the time.
Some people might think this is a crutch for properly learning the tool, but this is not my experience. I'm much more likely to get comfortable with vim and learn further if I can be in it 8 hours a day from the start. At first I used the integrated terminal to run git commands, now I invoke lazygit, which I love. At first I used the file tree to navigate, now I have custom commands to bring a file and its test suite side to side on a keypress. This gradual curve is what I was missing earlier.
Yeah, for most of us in the real world, we can't afford to be way underproductive for a week while we learn and set up our new editor from scratch. Learning vim is one of the greatest gifts I think I gave myself, and I'm extremely glad I did it, but it was not easy. A more gradual curve or even a crutch is completely fine in my opinion. I've seen plenty of people get started with vim just by putting them key bindings in their IDE and getting used to the motions, and then gradually moving over. The main key is to iterate, and not stagnate
> This workability indeed might require temporally replicating old habits while I learn the new ones, which lazyvim does
I'm not judging your for it, but to me that sounds like learning the violin by plucking the strings like a guitar. You're increasing the learning period by following old habits which may even be harmful.
I think it's better to just use the new editor sparingly, learning what you need, then switch fully once you're comfortable. A filetree is never necessary unless you're actually exploring and a file manager would be better for that. Vim has global search with `grep` and the terminal is available through `ctrl-z` and the `:terminal` command.
I've seen people touting Neovim setup that are just making things complex and fragile for no reason.
>that sounds like learning the violin by plucking the strings like a guitar.
I'd compare it more to learning photography without going for manual aperture and developing analog film straight away. You'll have a better experience if you learn stuff like framing with an automated camera that frees you to shoot a hundred pictures daily and focus on a certain skill.
I am increasing the learning period, that much is true. But if I can make use of my daily 8 hours of work as practice, that makes up for the delay, because I can get much more practice.
Maybe a student or a hobbyist can afford to spend 3 minutes nailing the regex while they learn to search and replace, I just can't be fighting that kind of friction regularly at work.
IMO, it’s still the wwrong approach. Vim and Emacs are just editors. Very much like Notepad. You don’t have to learn the extra stuff.
Once you are comfortable with basic notepad-like usage, you can then learn more advanced features. But emacs and vim are different from VSCode because those advanced things are supposed to be tweaked to personal preferences, not be handed down from high. When you start with something like Lazyvim, you’re missing on everything that makes vim, vim. You just have a walmart version of VSCode.
Learning an entirely new editor is a barrier. Documentation or not, that's brand new muscle memory you have to develop alongside the actual task of coding.
I get that using vim typically includes obsessive forms of efficiency, but some people just want to focus on coding in a way that's comfortable to them. Sometimes that means having a side panel.
>Sometimes that means having a side panel.
I do not even need that. Modal editing is enough to keep me away from all the VI clones. I hate it with a passion.
I have a fully customized Emacs that I use for anything Lispy and it's great for that purpose but everything else is just "ok".
I try to use Zed but since it is a commercial offering it is just a matter of time until it gets entshitified too.
Vscode is/was really good but it seems to get worse and it's Microsoft.... I run out of editors it seems.
Honest question, what is it that you hate about modal editing?
> Honest question, what is it that you hate about modal editing?
It's annoying. I'm fine with being in one mode. I'm fine with selecting 7 lines and typing "whatever". I hate "7ddiwhatever<esc>".
And yes, it may be the case that you are faster in VI(m) than I am in (choose the editor) but that doesn't matter. For me speed of typing is never critical.
I tried Helix and Kakoune too. They all have the same problems.
First. It adds friction. Every damn time I need to write, I forget to enter insert mode. You have no idea how many times I ended up with a strange buffer. Hopefully there is undo. But it gets boring fast. I need to write as soon I enter the editor. I don't need to move the cursor to read the text that visible on the current page.
Second, how the hell I'm supposed to make small movements when I'm in insert mode, with the arrow keys? Like move cursor to the left by 3 chars. Do I enter normal mode, press l 3 times. Or delete the whole word and rewrite it?
Third. Why some movements are symbols? Like, line ending is $. Beginning of line is 0. so much so for home row movements.
Fourth. Could never remember if f or t includes the char I'm looking for.
Fifth. How cumbersome is to press ESC on the top left corner every damn time. Yes, there exists Ctrl+[. But still. So much so - again - homerow movement.
Not directly related to modal editing.
Sixth. I could not make copy/paste work reliably in remote a linux server from a Windows machine via SSH. Hell, I could not make it work with WSL2.
Sevent. Debuggers sucks. There is no comparison to JetBrains Debugger GUI. Not even VSCode come close to it.
Sorry for the rant.
The rant is fine. I'll just provide some explanation.
First: Vim comes from vi, which is a visual mode for ex, which is a supercharged version of ed, which is (the standard editor) a line editor. With ed, you don't really write, you issue commands that does things to the file. Think of the file as a long roll of paper and the program as an assistant. So a command could be "replace your on line 14 with you're" or "delete line 34 to 45". Ex added more commands, Vi made it interactive, and Vim added even more features (syntax highlighting, scripting, location list,...). But still the same mode of interaction remains. The cursor is what you control. It's not just an indicator where the next character will appear or be deleted. It's the starting point of more powerful interactions.
Second. You're not supposed to move the cursor that much in insert mode. For 3 characters to the left, I just backspace and rewrite. For more, I go to normal mode and use F, f, T, or t which will land me to the character I want. Then I can use something like x (delete character) or r (replace character) without having to enter insert mode. There's a lot of movement beside hjkl, and I rarely uses h or l for things that further away than two characters.
Third. There's not a lot of key on the keyboard. $ is end of line in most regex dialect, ^ is beginning of line which would be actually the first character, but most people would assume it's the first non-whitespace character, so that's how they went. In C, curly braces mark blocks of code, so it's a small leap to use it for blocks of text, aka paragraphs.
Fourth. My mnemonics are f (find) and t (to). The latter does not include the character.
Firth. A lot of people remaps the caps lock to either Ctrl or ESC.
Sixth. They're different computers so there's no shared clipboard. Sharing information between the clipboard can be done using escape sequences, but I've never bother to. I just maximize the current buffer so I can use the terminal selection. And if I wanted more than a screen (dmesg), I'd pipe the command to a file and then download that file with sftp.
Seventh. Jetbrains only have debuggers for a handful of programming languages while `printf` is universal. And there's no law forbidding installing an IDE alongside your editor.
I think if you google ADM-3A terminal keyboard you'll see half your issues explained :)
There's a ton of historical baggage there. Thankfully, a bit of it can be resolved by setting esc and/or ctrl in caps lock.
Is there a good solution to managing "workspace", especially handling multi-folder workspace? I have a project where code lives in giant monorepo, and the files I edit don't have the same root (more precisely, the root is too large to open in the editor). I haven't found a good solution outside VSCode yet.
Well the file picker can be limited to the current directory and its descendants, and the global search picker is by default. Beyond that, dunno.
How about switching from VS Code to VS Codium? Same experience without the microsoft telemetry. I suppose Copilot won't be included due to licensing constraints.
How does the extension model work with MS? I did a similar move to chromium and eventually had to move to firefox when they pulled the plug on ad blockers.
There's https://open-vsx.org/. I've seen in the repo people talk about tweaking workarounds to use the proprietary MS stuff.