The Battle

The battle between Vim (and now Neovim) and Emacs has raged for decades. It's one of the oldest debates in computing, right up there with tabs vs spaces. After going back and forth more times than I'd like to admit, let me share my perspective after spending significant time in neovim and significantly less time in Emacs.

The Philosophy Divide

At their core, these editors represent fundamentally different philosophies about what a text editor should be.

Neovim subscribes to the typical TUI philosophy: do one thing well, and compose with other tools. It's a text editor first and foremost, enhanced by modal editing that keeps your fingers on the home row. Pair it with tmux and you've got a lean, mean, coding machine.

Emacs, on the other hand, aspires to be an operating system that happens to edit text. It's infinitely extensible through Emacs Lisp, and users have built everything from email clients to games inside it.

I heard it multiple times and it never really clicked before I truly sat down and used it.

Emacs is an operating system that also happens to have a text editor in it.

My Journey: The Long Way Around

I started as a Neovim user. You know the drill, watch ThePrimeagen, buy a split keyboard, get to 100+ wpm.

LazyVim gave me a solid foundation, and over the course of a few years I tweaked my config into something I genuinely loved. Terminal-native, fast, and with vim bindings baked into the core rather than emulated. It worked.

But then I got curious about Emacs. The siren song of "infinite customizability" called to me. If I could build anything, surely I could build the perfect editor, right? Besides, if it wasn't worth it, why in the world are there people using Emacs over Neovim?!

I couln't resist, So I dove into Doom Emacs head first, set up my evil bindings to keep my muscle memory intact, and started building.

The first day was rough, it felt uncanny - just close enough to what I was used to, and different enough to cause me an insane amount of frustration.

The second day I created custom packages. I built a streamlined window management system using projectile and emacs tabs. I wrote my own zen mode with a terminal side panel where I could run my tools how I liked. I explored Magit, org-mode, TRAMP, vterm, Dash docs integration. All the things that make Emacs users evangelical about their editor.

The Double-Guessing Stage

I started hitting friction points, worse yet, they seemed to pop up every time I thought I had it all figured out.

One of the most frustrating was JSX/TSX commenting being broken. gcc would insert // instead of {/* */}. In Neovim with lazyvim it just works because the ecosystem was built with these modern workflows in mind from the start. It took a few hours before I found a package online that adressed this very thing.

jtsx-mode If you're reading this and use Emacs for web development, save yourself the headache and install it.

The kicker? I realized I had spent weeks in Emacs essentially recreating what I already had working in Neovim. All that custom window management? It was mimicking tmux panes and windows

Although to be fair - it was much more powerful and customizable for my usecases at this point

Alright, but what about the zen mode? I had the same thing in my Neovim setup!

But did I though? I set up my Emacs zen mode to allow me to create scoped org mode notes that can open up in the unused window space...hmm

The Turning Point

And that's when it clicked.

No, I wasnt just re-inventing the wheel.

Did my Neovim config already work perfectly fine, yes it did. But everything I "recreated" in my now evolving Emacs config was completely tailormade to exactly how I wanted to work, what I wanted to do, the needs of my particular projects.

This realization gave me the motivation I needed to push through. I stopped treating elisp as an unfamiliar obstacle and started treating it as a skill to develop. I stopped trying to recreate my Neovim setup and started asking what Emacs could do more for my current tasks and workflows. I polished just what I needed instead of endlessly tinkering.

Why Emacs Won (For Me)

Emacs isn't just more customizable. It's a fundamentally different paradigm. When you need something, you don't wait for a plugin author to build it. You don't hack around limitations. You just... do it. Everything is a buffer. Everything is programmable. The ceiling isn't higher; there effectively is no ceiling.

Then comes the Emacs specific packages that I've learned to love and use daily. Magit is still the best Git interface anywhere, full stop. Org-mode, even without the agenda features, offers interactive todos and checkboxes that feel native in a way no Neovim plugin has matched. TRAMP lets me edit remote files like they're local. And when I need something that doesn't exist? I write it in elisp and move on.

The Real Answer

Here's what I learned from all this back-and-forth: the debate isn't really about which editor is "better". It's about what you're optimizing for and what you're willing to invest.

If you want modern defaults with minimal friction, Neovim + LazyVim is genuinely excellent. You'll be productive immediately, and you can extend it with targeted Lua plugins when needed. It's fast, it's terminal-native, and the ecosystem has hit critical mass.

But if you're willing to push through the initial learning curve, to treat elisp as a skill worth developing rather than an obstacle to overcome, Emacs offers a development environment that is unmatched.

Am I glad I grew comfortable with Neovim and tmux? Absolutely. Will I continue using vim/evil bindings? Of course. But when given the option, will I now reach for Emacs first? 100%.

The eternal editor war will never end because both sides are right. Neovim is an amazing text editor. Emacs is amazing at everything else. Which matters more depends entirely on how you work and what you're willing to learn.

Now if you'll excuse me, I need to go tweak my Emacs config.