Ask HN: Where to begin with "modern" Emacs?

Welcome to Emacs!

- I write about Emacs things fairly frequently: https://xenodium.com

- I started making Emacs videos recently: https://www.youtube.com/xenodium

- For aggregated Emacs blogs, check out https://planet.emacslife.com

- For aggregated Emacs videos, https://emacs.tv

- The Emacs subreddit can be handy too https://www.reddit.com/r/emacs

- If on the fediverse, follow the #emacs hashtag

- Sacha Chua's Emacs News are great https://sachachua.com/blog/category/emacs-news

With respect to "modern", maybe these two posts could be of interest:

- Visual tweaks: https://xenodium.com/my-emacs-eye-candy

- macOS tricks: https://xenodium.com/awesome-emacs-on-macos

Enjoy the ride!

I saw what was possible with emacs via systemcrafters: https://systemcrafters.net/emacs-from-scratch/

And I should note I have been using it for about 25 years, and was mostly in the dark about what it was capable of, though many of those years were in environments where I was using versions 5-10 years out of date, and completely locked down/out of things like melpa.

As far as keeping up with whats latest and greatest, I think the real answer is there isn't a good online resource. There are emacs meetups and conferences and some are virtual, and you can ask around other power users and see what they are doing. I even find emacs packages to be pretty poor at selling themselves on why you should use them.

As an example, Ivy and Counsel are kind of game changers to the UI, but I don't think you get any idea of that from their manual or main github page: https://github.com/abo-abo/swiper

I maintain a pretty popular Emacs starter-kit called Bedrock. [1] I suggest starting with it, or at least taking a look at it to get some ideas!

Bedrock differs philosophically from Doom et al. in that Bedrock is meant to be as simple as possible. There's no magic, no extra package management system (looking at you Doom) to break or confuse. By default, it doesn't install any 3rd-party packages—it just sets better defaults. Recent versions of Emacs can do a lot, but the defaults are painfully outdated. Bedrock fixes that. It's basically a vanilla Emacs experience without some of the cruft carried over from the previous century.

Bedrock also comes with a curated set of packages to enhance Emacs beyond better defaults. You can load these into your config as you begin to need them. List here: [2] If you are looking for a set of "modern" packages, this is it. I do pretty well keeping up in this space, and a lot of these (esp. Vertico, Consult, Corfu, etc.) seem to be accepted as the de-facto best replacements for older packages like Helm, Ivy, etc. (That said, I should add some config for Casual—very neat package to help with seldom-used features of Emacs.)

Bedrock is meant to be understandable: clone it once, and then tweak from there. You'll find a lot of forks of Bedrock on GitHub as people have forked it and then built their own config on top.

I'm working on updating Bedrock for Emacs 31. There won't really be that many changes, so like, don't wait for 31 to start your Emacs journey, but know that Bedrock is actively maintained and that the packages I've curated for it are the best I could possibly find. :)

Oh, also, if you search "best Emacs packages", my blog post [3] will come up on the first page on basically every search engine I've tried. ;)

Happy hacking!

[1]: https://codeberg.org/ashton314/emacs-bedrock

[2]: https://codeberg.org/ashton314/emacs-bedrock#extras

[3]: https://lambdaland.org/posts/2024-05-30_top_emacs_packages/

I think the usual advice is to try the vanilla Emacs, maybe use better-defaults (either directly or just for inspiration), as it is a relatively light customization. The setups people use tend to be quite different, as do their opinions on packages, so I doubt there is a single satisfactory and agreed upon "source of truth". Others' setups may be useful to check out, possibly pages of emacswiki.org, chatter on the #emacs IRC channel at libera.chat.

Edit: As for heavily customized versions (Doom, spacemacs), I have not tried those myself, but occasionally saw people having issues with those, and others not being able to help them, since it was not clear what sort of magic is going on there. So I would not recommend those to new users, at least not if you would like to learn the basics and get a better hang of it, to be able to debug it, though some seem to be happy with those.

If you don't want to use a distribution like Doom (which I don't fwiw and I've been using emacs for 20-something years), then I'm a big fan of minimal-emacs [1] a compact init.el and early-init.el that configures vanilla emacs into a good, default state. From there I would pick and choose which packages I'm interested by going through the Systemcrafters's community [2] as others have mentioned and Reddit's r/emacs community. While Systemcrafters is a fun community I'm a bit reluctant to spend too much time there because it's more of a tinkering community than a day-to-day-usage focused community. Fine if you want to tinker all day with your config but not the best for getting work done.

One thing I urge you to remember is that unlike neovim, Emacs isn't about just enabling and disabling plugins. Emacs is a Lisp environment. It really comes into its own when you program it. To that effect, I would read through the GNU Emacs info manual. Emacs ships with its manual in its inbuilt info reader and you can also find it in HTML [3] by GNU. Try not to think of your emacs as a constant soup of plugins and instead a codebase that you manage. The environment is very amenable to introspection, and there's inbuilt commands like `describe-key` and `describe-function` that pull up documentation for elisp. I'm a fan of the `helpful` package which I find to be a better version of `describe`.

[1]: https://github.com/jamescherti/minimal-emacs.d

[2]: https://systemcrafters.net

[3]: https://www.gnu.org/software/emacs/manual/

A lot of modern packages which began outside emacs have now been gradually been merged into the main emacs tree and come pre-installed (use-package for clean per package configuration, eglot for LSP support, tree-sitter, which-key etc). So you just need to learn how to configure them.

The most important packages which make emacs feel "modern" that are still outside the emacs tree for now are the ones which makes completion better, both in the main buffer and also in the minibuffer (what others may call your "command palette"). They are

- consult: search and navigation commands, provides candidates for...

- vertico: vertical display of candidates in the minibuffer

- marginalia: annotations for the candidates

- orderless: orderless fuzzy match for candidates

- embark: right mouse context menu for candidates

Getting these setup would make your whole journey onwards much smoother.

I'm a vim user, using orgmode. I've noticed the blog of Sascha Chua. She posts Emacs News and in these posts there are some orgmode gems. But she is posting more on Emacs. Maybe interesting to look these posts up: https://sachachua.com/topic/

Start by just opening it up and clicking on 'tutorial'. After that check out Options->Manage Emacs Packages and see if anything interests you. After that check out Melpa (<https://melpa.org>). Finally you can check out what other people do, for example Prot (<https://protesilaos.com/emacs/dotemacs>), you can look at Doom's source,...

You're basically about to go on a journey to a country you've never been, so my recommendation is to just read up about it and see if you find some things you want to experience.

You didn't say which platform you're on. For Linux, just use the emacs that comes with the distro. For Windows, download the official build for Windows. For macOS, I used to use emacsformacosx.com's version but now I use Homebrew's emacs-plus. It has a native-compiled version and is hella fast.

I use the regular package manager for emacs (package-install).

Been a user since the first version of GNU Emacs, back when RMS was trying to reproduce Gosling's emacs (which I used for a couple of years). That was the early 80's.

There is no such thing as top of the line.

There are preferences.

Asking where to begin with 'modern' Emacs is like asking where to begin with 'music'.

Just use stock until you find something you like better. It is one of the few pieces of software left where taste is king and there are no right answers.

I recommend starting with vanilla Emacs and just adding things as you find the need for them. Emacs comes with a lot of things OOTB. After a decade, my only essential package addon-ons are magit and yasnippet.

I have other packages installed, but they're esoteric for my own purposes.

I've been using emacs for a decade by now.

I'd look into spacemacs (what I use).

It's similar to doom, in that it makes some decisions for you, but you can very much have a customized experience.

I for instance have a lot of "stock" sections, and other things that are very customized that I've made myself.

Look into the "layers" (sets of packages that work together). I'd particularly recommend checking out the compleseus layer, which is a composition of consult, orderless, vertico, and embark.

They're all built to be composable (selection, pattern matching, selection interface, and context menu respectively), and they each add up to a brilliant emacs experience while reusing emacs' built-in frameworks (completing read). It's an alternative to helm and ivy (I've used each before).

The reason I recommend spacemacs (I'm sure doom could be the same, I just didn't know it) is because it is an easy way to see what packages other people find useful and how to use them, and it has similar conventional across different packages (so you can run tests in the same way no matter whether you're using rust, or python or whatever other language).

https://github.com/jamescherti/minimal-emacs.d is a great starting point for owning your config.

On macOS: Install from emacs-plus in Homebrew

On Linux: Install from your distro’s pkg manager.

I was advised to start with vanilla eMacs to get the hang of the system.

I now feel it was bad advice.

As someone who grew up with good dx tools like Sublime, it’s really hard to be productive in vanilla eMacs.

I’d suggest going with Doom, but don’t enable any package except Evil, LSP, Treesitter and Projectile.

This will give you a Vim like experience with basic project management.

As you become more comfortable, you can enable more packages.

This way you will stay productive and learn on the back of the community wisdom.

+1 to just use Doom. Even if you disable all of Doom's extra modules/plugin configurations, it still includes a lot of emacs black magic that makes emacs much faster. It's very slow without that.

The question is about Emacs configuration, but the keybindings might also be unfamiliar if you're coming from Vim. When I was learning I printed https://www.gnu.org/software/emacs/refcards/pdf/refcard.pdf and taped the two pages to my desk right in front of the keyboard for probably a 3-4 weeks. It was useful and also felt great when I didn't need it any longer.

I started with prelude[1], I wanted something batteries included to use as my main editor right away, but not as structurally different from vanilla as Doom or Spacemacs. Then after a couple of years I rewrote my config line by line looking at what prelude did and keeping only what I needed.

I’m happy with result, but this was 7 years ago so there may be better options than prelude to do something similar today.

[1] https://github.com/bbatsov/prelude

Are you looking for an ide experience or just a text editor with some options?

If a full IDE is what you are seeking go with DOOM. It will give you a fully put together experience.

If you just want a text editor that you want to slowly add to go vanilla.

Doom is like getting a fully furnished apartment where you can choose the furniture and curtain colors. Vanilla is an empty plot of land that you need to build a foundation, house, and connect to city services all on your own.

I'm not on level as power users here, but have one good tip on having good and clean configuration.

Just like config.d dir in ~.ssh/, you can have a 'load' instruction in your emacs.el/init.el file and a separate directory for configs. This way you can easily do see what does what (by name) and have even more comments in the beginning of files.

So even if you added some modification late at night/under influence of substances, you can still tell that you were thinking and easily switch it off or improve it.

Edit: and love your question, even tho I used Emacs for over 10 years, I've learned a lot in here.

My Emacs setup typically involves:

- An LSP: https://emacs-lsp.github.io/lsp-mode/tutorials/CPP-guide/ - Neotree to browse the file system: https://github.com/jaypei/emacs-neotree - Awesome-tab for tabs: https://github.com/manateelazycat/awesome-tab

If you want more, look at the extensions section of the LSP page and then go down the rabbit hole.

I likewise do not use Doom or any of the bundled variants because I want full control and understanding of my config. But those variants are still useful to learn what's out there and selectively add things to your mix.

I made ocomacs for this purpose, it's designed as a minimal config layer which is more of a pattern to follow than a "does everything for you" framework.

https://github.com/ocodo/ocomacs

My hang up is that I live in the terminal. What eMacs folks seem to do is use the terminal in eMacs, kinda in place of tmux? Is that right? And what terminal is the best? Is it really as nice as something like Foot? What happens if you open a text file in an eMacs terminal?

IANAD I am not a developer.

I got into vim because it made total sense to me as a way to transfer thoughts to words, I loved it , I lived it and I love it and live it. Then I heard about emacs org-mode – after trying for ages to find the "software to organise my life" (pick your poison).

I found it to be totally workable, initially, via doom-emacs.

Then they said "You won't believe Magit".

I didn't leave my wife, instead I invited everyone into my world.

True, I had been fooling around looking for a wife. I hit on vim. She was perfect. In her world there were people who knew all about perfection – no surprise – until I met her beautiful sister. I fell in love with her. Then I met a relation of hers (her name was Magic, also beautiful) and I invited them all back to what became their place where I am now welcome too.

For me, the "modern" way is when I meet any problem on updating my emacs config files, just ask Claude or Gemini, they will help you to find solutions for the most of common problems. The "traditional" way is to know the basic keybindings, and write an actual project directly, whenever you found there's lack of a feature, just search and config for it. After a period, you'll got a stable config for long term use.

I will just add a comment on an aspect of using emacs that no one else mentioned: (1) I find that I must bind caps-lock to control, and (2) as far as I can tell, no operating system does this in a way that really works besides OSX. So now I am stuck using OSX because I use emacs. When I use a GNU/Linux machine, I do it by ssh-ing in over the network from an OSX machine. I think you may find this to be something you have to deal with as well.

I think I made a similar move about 6 years ago now. Started on Doom Emacs for the first 2-3 years, and honestly, for most users I think Doom Emacs is all you'll ever need. If you ever decide you want a bit more control over your config, which is what the case was for me, then it maybe makes sense to start writing your own configuration and learning about more of the native features. Would definitely recommend system crafters' emacs from scratch series that others have linked here -- extremely helpful.

I’ve been an Emacs user for more than a decade and I would recommend just using Doom especially if you are coming from a Vim background.

I started before Doom existed but ended up in a configuration similar to Doom but more brittle. I ended up just declaring .emacs bankruptcy and started over with Doom and was pleasantly surprised that my over 2000 line configuration became less than 30 customized lines.

If you want to do it the hard way I’d start with figuring out elpa and going from there installing the specific plugins that you want. Likely, evil being a first.

Vanilla emacs to start, and then the approach I take to finding interesting packages and config is to read the Emacs Weekly News from Sacha Chua (which often links to articles and videos describing packages and configs). There sometimes are articles or videos linked from there that talk about configuring from a vanilla setup that are likely what you are looking for.

Mickey Peterson's blog/book Mastering Emacs is where I wish I had started.

https://www.masteringemacs.org/article/beginners-guide-to-em...

Sacha Chua maintains a blog roll with a huge part of the Emacs community represented, also: https://planet.emacslife.com/

Also everything Prot writes is great, here's his getting started guide: https://protesilaos.com/codelog/2024-11-28-basic-emacs-confi...

I suggest trying out Doom and maybe some other configs to see what's available, and if you want to roll your own you can choose the things you like most from them. I came to emacs from [n]vim and using evil-mode was _very_ helpful in making the switch easier so I recommend that

If you want to fully own your config you can learn what Doom does and tweak it and simplify instead of getting only part of those improvements stretched over a longer period of time

i run a basic emacs configuration within docker, so it has all the underlying executables & binaries installed where emacs looks for them. runs exactly the same on linux & macos. https://hub.docker.com/r/wwarner/emacs-native or https://github.com/wwarner/emacs-native-dockerfiles

I’ve rebuilt my emacs config a few times for exactly this reason!

Some of the things I’ve found work well for me:

- it’s pretty obvious, but it took me a while to figure it out: make your `~/.emacs.d` into a git (jj, hg, whatever) repo. You don’t need a remote but as you try things out it’s nice to be able to step back in time.

- know what you want to build. For me I’m generally trying to make emacs do something that I’ve seen a colleague’s editor do: integrating language servers for source navigation; integrating a debug server for a nice visual debugging experience.

- some people manage their emacs configuration as org-mode files. This is neat because you get an experience similar to Jupiter notebooks: you can intermix commentary and elisp. I haven’t ever gotten to this point but it looks neat when I see others do it.

There are some good YouTube channels and blogs that talk about configuration, or that test different packages. I’ve found “Emacs from Scratch” and “Emacs Rocks” to be really useful.

There’s a lot to customize and select from. Without steering you one way or another, here are some changes I’ve made recently or packages that I use:

1. For language servers, I find `lsp-mode` to be easier and more full-featured than `elgot`.

2. `dap-mode` plays nicely with `lsp-mode` and makes debugging straightforward.

3. I’ve tried, and use, a few different plugins for AI coding: `greger.el` is the first one I tried, but I’ve started using `xenodium/agent-shell` more. If you want to write (or hack on) an AI agent written in elisp, there’s `steveyegge/efrit`.

4. You’re probably accustomed to some sort of “tab completion” from neovim. Within emacs you’ll need to set up a “completion framework”; there’s a bunch to choose from. Watch some videos and experiment. You’ll probably find one that feels a lot like you’re used to (whether that’s completion-as-arrow-navigable-dropdown-at-cursor, or completion-in-side-panel, or whatever).

Your muscle memory of how to move around in a document and how to tell your editor “I want to do something new now (see a list of open files, go to a new file, etc)” isn’t going to translate into emacs very well. It’s like shifting from a laptop keyboard to some weird split keyboard with thumb paddles: muscle memory won’t be satisfied, and you might just “not like” emacs due to that. There’s `evil.el` (“Emacs VI Layer”) which teaches emacs to recognize vim-style commands. I think vims have fantastic macro recording and replaying functionality - emacs has it as well, but making a recursive macro is harder for me, for some reason - and evil makes emacs’s macros feel on par with the vims.

Another tripping hazard coming from a vim-like is that “undo” operates differently in emacs. I think the vims have a fairly linear undo: like a browser history back button. emacs stores an undo tree, which can lead to surprising behavior at first.

If you’ve written or tweaked plugins for your editor and enjoy tinkering with your tools, then a vanilla greenfield approach to emacs will probably be very satisfying for you.

If you want something that “just works” which you can experiment with and gradually learn more about over time, then you might get more mileage out of spacemacs.

I think vim-style users tend to launch vim many many times through the day. cd here, edit a file; save, quit, edit the next file. emacs can act like an editor, but if you think of it as a highly customizable IDE, then you’ll get more use out of it. My uptime on emacs is generally measured in months, whereas for me vim is in seconds to minutes. I mention this because the startup time for emacs can be quite slow compared to vim; just don’t pay that cost over and over.

Most comments here are giving you fish instead of teaching you how to fish.

The emacs subreddit is pretty active. Search reddit for recent-ish threads for whatever you want to do.

I’m deeply skeptical that it is possible to use Emacs full time without an overly complicated config (:->

Org-mode. But it's already part of the package...

...because Emacs is a mature ecosystem: Meaning many and probably most tools predate developer-gets-famous-on-internet thinking, have been refined over decades, were built by people to get their job done, and often that job was something where programming was incidental to the task at hand.

Another question to all those who use emacs, what do you do to avoid emacs pinky? I've been hesitant to start using emacs for that reason, since I've had pinky pain quite often in the past two years and I'm pretty sure emacs would push me over the edge...

Check out the book Mastering Emacs, and then his blog. It’s a goldmine for what you’re after

Open Emacs and press <return> to read the tutorial. This gives you the basics to be productive.

Understandably, some people complain that it shouldn't need a tutorial or the defaults are bad. There's validity to that angle. There's also validity to Emacs pre-dating GUIs, the IBM keyboard, and the x86 instruction set. Once you get past the history of windows and killing, you can explore. The history is also super interesting!

https://www.emacswiki.org/emacs?EmacsHistory

https://dl.acm.org/doi/abs/10.1145/3386324

After you've read the tutorial, go wild. Try stuff out. Break things. Fix them. Learn your limits. Learn that there are very few limits imposed by Emacs itself.

Hands down, the best resource for Emacs is Emacs itself. Especially, the Emacs manual and the Elisp manual. The "An Introduction to Programming in Emacs Lisp" is also excellent if you're not familiar with Lisp. Learn to read Info files and learn the help system (basically C-h f and C-h v)

https://www.gnu.org/software/emacs/manual/

Emacs really is a flagship of Freedom, with all its pain and glory. It lets you exist at the threshold of your zone of proximal development. Every bit you put into Emacs, you get a return on investment.

Welcome to the Emacs community! It's full of weirdos and wizards, as well as regular folk. Stick around and I'm sure you'll make friends in no time.

Don't use doom etc, just standard emacs, otherwise you won't have any understanding of what is happening and how to fix it. Here's a list of what I think is important, roughly more important to less:

    - corfu+marginalia+vertico+embark+orderless is the standard completion stack now
    - magit (maybe also see also the "casual" the transient front end for other modes)
    - avy
    - (fset 'yes-or-no-p 'y-or-n-p)           ; 'Y' or 'N' instead of 'Yes' or 'No'
    - (setq confirm-kill-emacs 'y-or-n-p)
    - evil (optionally if you like vim keybinds, you still need to know basic emacs))
    - if using evil: evil-collection, evil-args, evil-goggles, evil-traces, evil-escape, evil-nerd-commenter, evil-lion, evil-surround, etc are not "standard" but still useful 
    - configure melpa source
    - which-key
    - helpful
    - undo-fu
    - gptel
    - projectile
    - eglot
    - saveplace
    - desktop
    - uniquify
    - dired/wdired
    - flycheck/flymake
    - treesitter
      

    - general (for making your own keybinds)
    - some kind of multicursor mode (I use iedit but it's simple)
    - yasnippet
    - org (usefulness depends on the person)

Also, very important, learn the help system (C-h <key>), especially C-h f, C-h k, C-h w, C-h c. And the info system

Doom is still a good reference for which packages people find interesting; don't dismiss it out of hand. I do think it's quite heavy handed in terms of altering core input behavior, tho.

Just use Doom. Its good.

Emacs nano https://github.com/rougier/nano-emacs

[dead]

[dead]

[flagged]

[flagged]