I made the jump from vim to emacs without relying on evil or spacemacs, working my way through the built-in tutorial (C-h t) and doing my own customization from the bottom up. Surprisingly, you don't need that much customization to get productive in emacs, so it's better to find out for yourself what you need.

The mnemonics of the emacs keybindings are part of what makes it so special, so it didn't make much sense to me to use evil-mode. Spacemacs is another layer of abstraction which makes it easier to get started, but ultimately hinders your customizability and understanding of the text editor you are using.

I know you specifically asked for tips that apart from perseverance, but I believe this is the reason I stuck with it for the past 2 years. But beware: mastering emacs is a lifelong hobby, where you sometimes sacrifice short-term productivity for long-term happiness.

> but ultimately hinders your customizability and understanding of the text editor you are using.

[Citation Needed] Spacemacs is just elisp. It is documented and you can explore its source the same as anything else in emacs. `SPC h d` + `which-key` is a godsend for learning and understanding what emacs offers.

I went from vim to emacs with evil mode (i used the doom distribution, which I think is great). However I went back after some months of usage. The main reason is performance. Many plugins are just not very performant with elisp but without them emacs is pointless for me. Also vim has better support for more languages in terms of LSP. In emacs I ran into a lot of outdated plugin issues.

I have customized my vim now with shortcuts very similar to Doom/spacemacs and many plugins. I am very happy with my setup at the moment. I don't care if it is against the vim philosophy as long as I get stuff done with it :)

My tip: if you want to try out emacs with evil, try the doom distribution. If you become a convert you still can configure your own if you want/need to later on.

I'm in the same situation. Started with Vim. Tried out Spacemacs and loved it. Switched to Doom for the performance gains. Finally, switched back to Vim (Neovim) with Doom-like keybinding; specifically setting leader to Space.

I haven't found anything that comes close to vim's performance as a text editor. In terms of plugins, there are some great ones for Neovim like tpope's rails plugins, coc.nvim, fzf, etc.

I just switched to Doom from a very trimmed down and customized version of Spacemacs. I liked Spacemacs layer concepts, but many of them I had installed for very basic functionality like syntax highlighting and code formatting, but to get that I had to pull in this huge layer containing multiple packages. Emacs was constantly getting bogged down by Spacemacs or becoming buggy at my attempts to speed it up.

Doom is so much better on the performance end, I don't feel the need to keep an emacs server running all the time just for occasional editing in the terminal. I'm interested to see how well it performs with emacs-native-comp. The Doom ui also feels a lot more cohesive. I've never been a vim user, so I use the default emacs bindings but still have a leader key; Doom's setup with the leader key is really well thought out and I'm glad that vim concept has made its way to emacs.

Interesting. I am a bit behind you and have recently transitioned to (Doom) Emacs. What plugins were slow for you? What things did you find indispensable and reimplement in vim?

To be clear, my issues were mostly not with doom but with emacs plugins themselves.

Well Magit was clearly the slowest. Used in big repos with a big list of changes it grinded for minutes before showing the "status" screen e.g.

Also various code completion plugins via LSPs were significantly slower than even VSCode and of course vim. While typing I often encountered lag even on fast systems. Not sure if the lag actually came from the LSP plugin or from something like Flycheck ui.

TBH the one thing I "reimplemented" was the keyboard shortcut system which extensively relies on leader(s). In the beginning I just mirrored doom shortcuts but after a while I customized, more suitable to my own needs.

Not really related to emacs but the vim plugins I would not like to miss are especially: coc.nvim, fzf.vim, ranger, vim-fugitive, vim-mergetool, vim-bookmarks

I would suggest a step further: start with Spacemacs/Doom, but if you decide to stick around, try to build your own Emacs configuration based on the part of Spacemacs/Doom that you like.

Thanks to the amazing use-package[1] macro (which Spacemacs/Doom also uses) most configurations are self-contained to a certain extent. Searching for use-package in GitHub[2] will yields plenty of results which can be mostly be taken as a reference for your own liking. It should be relatively easy to port part of Spacemacs/Doom to vanilla use-package, e.g. starting with this (which sets up use-package alongside with evil):

    (require 'package)
    (setq package-enable-at-startup nil)
    (add-to-list 'package-archives '("melpa" . "https://melpa.org/packages/"))

    (package-initialize)
    (unless (package-installed-p 'use-package)
      (package-refresh-contents)
      (package-install 'use-package))

    (eval-when-compile
      (require 'use-package))

    (use-package evil
      :ensure t
      :config
      (evil-mode t) 

    (use-package evil-leader
      :after evil
      :ensure t
      :config
      (evil-leader/set-leader "<SPC>")
      (global-evil-leader-mode t))

To add Magit, one could take a look at Spacemacs's git/packages.el[2], search documentation on what each package does, and proceed on porting configuration, only the part that you actually uses, e.g.:

    (use-package evil-magit
      :ensure t
      :after (magit evil))

    (use-package magit
      :ensure t
      :config
      (evil-leader/set-key ("gs" #'magit-status))

Since most configurations based on use-package are self-contained, when stuck I also like to use GitHub search to look on how other people configure a certain package[3]. In most cases the configuration should be reusable as-is.

Finally, use-package is highly extensible. There is straight.el[4] which adds extension to use-package to fetch from Git and pin a version in a lockfile, which adds reproducibility to Emacs configuration. There's also el-patch[5] from the same author that allows patching package on the fly without the need to maintain separate forks.

[1]: https://github.com/jwiegley/use-package

[2]: https://github.com/syl20bnr/spacemacs/blob/d46eacd83842815b2...

[3]: https://github.com/search?l=Emacs+Lisp&p=4&q=use-package&typ...

[4]: https://github.com/raxod502/straight.el

[5]: https://github.com/raxod502/el-patch

I'd recommend Doom for anyone that wants to base their own configurations on one of these. It's not as big of an abstraction layer on top of vanilla emacs, so it's easier to pull apart and reuse.

I've used vim for about 5 years and switched directly to "vanilla" emacs (no evil or doom).

My main motivator was similar to yours. Most functionality I used came from plugins, but the language used to write plugins or other modifications felt crippled. When I came across orgmode, during my years on the university, I tried it in vim, through some Plugin. I liked how the format allowed me to dump most of my brain in plain text, but it still felt unnatural to edit it with vim.

During a history course on computer science, I learned more about lisp and its integration in emacs. At that point I decided to try it out. I wanted the full experience, to be able to form an honest opinion. So, I forced myself to do an entire course using emacs instead vim. No evil, just plain emacs. During this time, I fell in love and never looked back.

I still like vim, I just don't find any use for it anymore, except quick editing on servers. Knowing vi key bindings is useful, as vi is almost always present. However, I think that known/understanding emacs key bindings is underrated. Understanding the logic of emacs key bindings will not only makes you more proficient at handling emacs, it also makes moving around most shells more efficient. I know you can configure shells (or more specific: readline) to use vi key bindings, but the default is emacs!

My advise in learning emacs would be: dedicate some time on using it for something real. I'd say, don't get too tempted by the vimify plugins, as they will hide some of the logic of how emacs works. This might slow down or dumb down the learning process. But I'm not discouraging the use of vim plugins all together, just make sure you understand the core product, before modifying it beyond recognition.

You just have to recognize that Lisp is the only true path, and let that guide you to salvation.

That’s not even a joke. The ability to write elisp and bind it to keys is much more useful than the “text editing as programming language” paradigm of vi. Vi is the better text editor, hands down. But enacts is the better text and software environment.

One of the easiest ways is to start using emacs for something you didn't use vim for before, like org-mode. Or just for magit, but not text editing yet. Either way, you can stay in your fast, happy path in vim as long as you like, and trickle in small edits in emacs until it becomes more comfortable.

So you can avoid the heavy slam of new-editor-awkwardness in your important work.

I do recommend spacemacs, it (looks like, I'm vanilla emacs myself out of habit) has many packages and customizations atop of a vim-ish keybinding.

I’d recommend Doom Emacs over Spacemacs for a few reasons: Spacemacs tries to be everything-for-everyone and it is far too dense for someone trying to learn Emacs. Evil-mode is its “killer feature” but that’s available without Spacemacs. Doom Emacs is more like Vanilla Emacs with an obvious lean towards evil-mode. It comes with sensible defaults and loads up so much faster than Spacemacs does.

1. You have to get comfortable editing your own config, as much or even more than editing your own .vimrc. I don't think you have to become a lisp master, just understand what is going on like you probably do with vimscript.

2. Consider using Doom Emacs as a starting point. It's fast and works like you would expect out of the box. You can use it like Vim and discover aditional features as you need them. And most importantly, it's (almost) as easy to configure as vanilla.

Perseverance is the name of the game, much like it is in everything else we do.

I’ve been learning Vim and Emacs concurrently with Doom Emacs. I find that if I don’t use the tools for actual work, where speed/familiarity is necessary, I become acclimated to the new environment and start transitioning to its use full-time. Just editing configs is enough to get familiar and it’s low-stakes as far as fucking things up goes.

I was in exactly the same situation you're in. Wrote about this a while ago: https://rohitpaulk.com/articles/vim-to-emacs.

Took me a couple of weeks to acclimatise, but overall the switch was worth it. If you haven't tried it yet, I'd suggest Doom over Spacemacs (details in the article).

I used vim and vi for about 25 years before switching to Emacs. I had many thousands of lines of configuration in my .vimrc that I needed to port over, because I didn't want to lose any functionality over vim.

It took a really long time and a lot of effort to get Emacs to do everything that I could do with vim, but I finally did it, and now Emacs does not only pretty much everything vim ever did for me, but does a lot more.

I don't regret the switch or the time and effort it took in the slightest. However, there are a couple of things I do miss about vim and occasionally even fire up vim for.

One is the inferiority of Emacs' regex engine, in certain important respects, like \zs and \ze in vim, which have no Emacs regex equivalent. Those patterns let one match on the beginning or ending of a regex pattern while leaving the position of the cursor/point somewhere else and highlighting a subset of the entire match. That can be pretty useful in certain situations, but it's not enough to leave Emacs and go back to vim.

Another aspect where I find vim superior is in handling large files and files with very long lines. It's just way more performant than Emacs in those situations. Emacs does have long-lines-mode, but it's a hack, and doesn't work in dynamic buffers (like shell buffers) anyway. For handling such files I sometimes temporarily switch back to vim, and back to Emacs after I'm done with that file.

Other than that, there's really nothing about vim that I miss. Though, since I've left vim I have heard that neovim has achieved integration in to various IDEs and other apps that I wish Emacs had.

Anyway, back to the original question about tips for someone else making the transition from vim to Emacs: Apart from perseverance and the use of evil, I'd suggest making hydras for every major mode that you use. That's made Emacs way more useful for me.

Oh, and learn eLisp! If I hadn't known and loved Lisp, I would not have switched from vim to Emacs. There's just no way I could have ever configured Emacs to have all that vim-like functionality (and more besides) if I hadn't known eLisp and actually enjoyed using it.

That Emacs itself and the entire Emacs ecosystem was written in a Lisp was actually a major draw for me to make the switch from vim to Emacs, and in fact it is what's made writing that mountain of configuration not only bearable but actually fun and interesting.

If you hate Lisp, stay far away from Emacs. If you like Lisp, run to Emacs! :) If you don't care one way or the other, give Lisp and Emacs a try.. you might learn to love them, like I do.

I've always been an emacs user, so no help from me I'm afraid. But I've read from other vimmers that doom emacs is a very good transition when migrating from vim to emacs, better than spacemacs. I've tried both, and I feel like doom is easier to use overall, so take that as you will.

It's not bad to stick with vim either anyway, it's a great tool itself.

I use vim every now and then, and I have the exact same experience of "well, if only I could just do X like in emacs, this would go way faster". In the end they're different cultures.

Here's a getting-started post I wrote when I switched from Vim to Emacs.

https://fnune.com/2017/12/27/making-emacs-work-like-my-vim-s...

Since then, I'm back to using Vim. I'm planning to write about that, too...

For me the thing is that emacs can be overwhelming. So focus on doing one task at a time. I still don't know the whole spacemacs interface. I know where my major mode keybinds are. I know how to deal with my .spacemacs. I know where to find documentation. I deal with everything else on a case by case basis.

As others have mentioned, `C-h t` should be enough to get you comfortable using it as your daily driver. From there the sky is the limit!