FRESH
Hacker News
Hacker News Hacker News- 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!
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
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/
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.
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
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.
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.
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 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 have other packages installed, but they're esoteric for my own purposes.
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.
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).
On macOS: Install from emacs-plus in Homebrew
On Linux: Install from your distro’s pkg manager.
I’m happy with result, but this was 7 years ago so there may be better options than prelude to do something similar today.
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.
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.
- 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 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.
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.
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...
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.
The emacs subreddit is pretty active. Search reddit for recent-ish threads for whatever you want to do.
...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.
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.
- 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