Emacs + Meow is an underrated combo

In my head, code editors fall on a spectrum of intuition on one side or flexibility on the other. Easy versus malleable. I know this is an oversimplification, but bear with me for a bit.

On one hand, we have VS Code, Sublime Text and similar editors, which are pretty intuitive for newcomers and don't need a manual . They can be extended with plugins, but the inner workings of the editor are only used by plugin developers. The common way to use these editors is to understand the default, prescribed workflow, maybe change a few surface-level things, install some plugins and get going.

On the other end of the spectrum are hyper-flexible editors like Emacs and Neovim. These are not for beginners, but the steep learning curve also exposes you to the internal mechanisms of the editor, giving you a mental model of how the editor works as a system rather than as an interface. And once you understand a system, you understand how to change it, extend it, repurpose it or even limit it.

A characteristic feature of these editors is that there is no single prescribed workflow. You are encouraged to evolve one based on your usage and preferences. The editor gives you the tools; you build the house. Your house looks nothing like mine.

Two arbitrary people using VS Code are likely to have mostly similar workflows. Two arbitrary people using Neovim might do it so differently they'd find it difficult to use each other's setup. Because VS Code optimizes for intuition by prescribing a workflow, while Neovim optimizes for flexibility by giving you the means to build your workflow.

Now that we have established a simplistic mental model, it's time to break it. There are two categories of editors that are hard to place on this spectrum:

Distributions. Things like Spacemacs , Doom Emacs or the various Neovim distros are trying to bring the intuition of modern editors to the flexible ones, but in my experience, they achieve neither. Their setup does little to educate you about the underlying flexibility, but they are also not a breeze to use for newcomers. Every time I have tried to use one of these, I have given up in a few weeks. The defaults take you far, but not far enough.0 When you have to get your hands dirty to change that one obscure thing, you are left clueless. Perhaps the problem lies with my expectations and not with the distros, but they're not for me.

Helix , the underdog that flies in the face of convention. It's nowhere near as malleable as Vim or Emacs, and its learning curve is decidedly steeper than that of Sublime Text. And yet, learning Helix pays off, because it has made excellent design decisions. There are no plugins, but most of the time, you don't need any. Its selection-first editing approach makes so much more sense than Vim's action-first model. For me, it consumes far fewer mental cycles thinking what a given action will do in Helix compared to the guesswork involved in Vim.

A couple years ago, I started using Helix. And to learn it, I applied the same strategy that I did while learning to touch-type: force myself to slowly and painstakingly use the correct idioms until they become muscle memory. And they did. The effort to learn Helix paid off really well without the maintenance burden of a hand-crafted configuration. For my day-to-day JS and Python needs, Helix was more than enough.

Only when I took an interest in Scheme and Fennel (both Lisp dialects) did I feel the need to try something new: for programming in Lisp dialects, Emacs remains the unbeaten king. So I found myself at a crossroads: stick with Helix's comfort and live with limited integration with Lisps, or move to Emacs and rewire my muscle memory in favour of a better Lisp editing environment.

I bet on the latter, and it worked.

My first attempt was to try Doom Emacs + Evil mode and retrofit Helix-like keybindings into Evil mode. It worked to an extent, but for the aforementioned reasons, I found myself spending more time in the config file than doing any actual programming. It was fun, mind you, but I was learning more about configuring individual packages than about Emacs itself.

So my second pass was to roll up my sleeves and craft my system from the ground up. Instead of going for a full-blown distribution, I started with vanilla GNU Emacs. Then I pulled the bread-and-butter stuff from Crafted Emacs , a highly modular system that takes care of the inconvenient defaults but gives you far more control over what new packages you add. It prefers building upon what is included with Emacs instead of reinventing the wheel. But most importantly, it educates you and encourages you to actually write some Emacs Lisp instead of treating it like glorified settings dialog.

Using this knowledge, I was able to replicate ~90% of my previous Doom setup with about 1/3rd as many packages, and what's more, I understand every single line of my config .

When it comes to replicating Helix's selection-first editing model, Crafted Emacs doesn't offer any pre-built configuration. But it does offer a philosophy: pick something that relies on the Emacs built-ins rather than something that deviates from the platform.

Going by that, the answer was clear: Meow mode .

From its introduction:

Meow aims to blend modal editing into Emacs with minimal interference with its original key-bindings, avoiding most of the hassle introduced by key-binding conflicts. This leads to lower necessary configuration and better integration. More is achieved with fewer commands to remember.

Meow's ergonomics are so similar to Helix that you can do some basic editing and navigation right away without even going through the tutorial.

The only differences that stood out to me are:

Reverse operations work differently. In Helix, you would undo with u and redo with U. In Meow, you would undo with u but then change directions with ; and reuse u to redo. Likewise for finding the next match of a pattern with n. I don't prefer one approach over the other, so this was just a matter or adjusting my muscle memory.

Multiple cursor editing works differently. I won't explain it in detail, but this is one area where I find Helix's approach more intuitive. For any serious multi-cursor workload, I fire up VSCodium and get on with my day.

Lastly, two more packages gave me a complete, productive Lisp experience:

Avy lets you jump anywhere in a few keystrokes, effectively eliminating the need for a mouse.

Paredit lets you handle Lisp code in a more structural manner. Instead of treating it as a collection of words and symbols, you treat it as a tree of expressions. It's as if you're directly editing the AST, because with Lisps, you pretty much are.

After spending a few months with this setup, I feel right at home, not just with Lisp programming, but with any language. I even took the Org Mode pill and started maintaining a part of my to-dos in Emacs itself.

I'm still exploring ways to personalize this new environment and am open to suggestions, but the rhythm is in place.

If you want to see my config, head to my dotfiles repo . If you found this post useful, feel free to reach out and share your thoughts.

Happy hacking.