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!

• chipotle_coyote

  yesterday at 3:09 AM

  Sort of side question, but why do you set the command key to be Emacs' meta key? I've sort of waffled on that myself -- the plus to doing it is that it matches Windows (which I am in too much of the time) and Linux, but the minus is that it not only breaks 20+ years of muscle memory I have with MacOS, it collides with a few other global hotkeys. (Recent collisions I've noticed are Alfred's clipboard manager, which defaults to Shift-Command-\ (M-|, shell-command-on-region), and the system-level screenshot hotkey on Shift-Command-5 (M-%, query-replace).

  • hibbelig

    yesterday at 11:52 AM

    For the keys you don’t need to type quickly, M-x can also be typed as ESC x. For any character x.

    So it works well with M-|, but not so well with M-f, for example.

  • xenodium

    yesterday at 10:19 AM

    Ah yes. I find the ⌘ key placement a little more ergonomic/convenient, but at the end of the day, pick whatever works for ya.

    Thinking back, I prolly didn't use those two commands often enough to internalize M-| or M-% bindings, so the system-level handling didn't bother me. While I do replace things all the time, I typically use multiple cursors (I do use bindings for that). If I need querying, I just type `M-x que RET` which gets picked up by a completion frameworks (in my case ivy).

    Relatedly, I also use Hammerspoon on macOS and set some global key bindings using the ⌥ key.

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

• omnicognate

  last Saturday at 7:10 PM

  Vertico and Consult are the successors to Ivy and Counsel. They're more cleanly integrated with the native capabilities. I've found them a big improvement.

  Systemcrafters have a video on moving to them, but I haven't watched it.

• senkora

  last Saturday at 5:53 PM

  +1 to systemcrafters. It is probably the closest community to what you are looking for.

  • ews

    last Saturday at 7:23 PM

    +2 , it's an amazing resource for emacs and guix

• MkLouis

  last Saturday at 9:08 PM

  +1 from me aswell.

  I personally started with SystemsCrafters and after I started to grok Emacs I went to use DoomEmacs. I found DistroTubes literate DoomEmacs Config a good starting point to see whats possible. https://gitlab.com/dwt1/dotfiles/-/blob/master/.config/doom/...

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/

• kingkongjaffa

  today at 1:32 PM

  I used spacemacs in the past primarily to drive org-mode. Fell out of love with it after a few years and moved to pen and paper bullet journal.

  Interested in trying emacs again with something simpler, will give bedrock a try!

• aquariusDue

  yesterday at 12:47 AM

  Thank you for making and maintaining Bedrock! In the past I've used Emfy as a starting point but some time ago I declared Emacs bankruptcy and started from Bedrock, every chance I get I recommend it now.

• presto8

  yesterday at 5:14 PM

  +1 for emacs-bedrock! It helped me get started with reasonable defaults out-of-box. From there, I started adjusting it to my own needs.

• stebian_dable

  yesterday at 7:50 AM

  Bedrock is a great starting point. Plays well with https://github.com/bbatsov/crux also.

• scott01

  last Saturday at 9:55 PM

  I’ve recently rewrote my configuration and used Bedrock as a new starting point. It’s great, thanks very much for making it!

• weakfish

  last Saturday at 6:58 PM

  Great, thank you! I will definitely reference this.

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.

• tammer

  last Saturday at 6:14 PM

  I will second the recommendation to start with vanilla emacs. That isn't to disparage releases like spacemacs & doom. I simply found those to be more useful once I fully understood the power that comes with a fully reprogrammable editor. There is a learning curve and there is also a mental model to adopt, and I think that adopting the mental model is easier when starting raw and building up from scratch. Once you feel comfortable maybe try spacemacs or doom to see if they offer advantages for your workflow.

  I also highly recommend the resources at https://www.masteringemacs.org

• SoftTalker

  last Saturday at 6:35 PM

  Another vote for vanilla, learn the basics and then add packages for what you need.

  I have spent my entire career using vanilla emacs with a few other packages. A lot of things, including org-mode, are included by default in modern emacs.

  The problem with learning heavily customized distributions like Doom is that they won't be installed elsewhere and if you have to use emacs on another system you won't have what you're familiar with. Weigh that relative to how often that happens in your work.

• pfortuny

  last Saturday at 6:44 PM

  Yes, before playing football, children just mess around with a ball. The thing is to end up using the ball properly, not to play as Messi.

• weakfish

  last Saturday at 6:58 PM

  I think that's the route I'm gonna go, I want my configuration to be transparent and built so that I can understand it top-to-bottom. I've tried Doom, but it felt too magical.

  • nairadithya

    yesterday at 11:08 AM

    As a Doom user, the benefit is largely in discovering the absolutely vast plethora of features that Emacs and Emacs packages lend to you in a nice set of defaults and aesthetics that shouldn't feel too alien as a Neovim user. I encourage you to give it a week in parallel with your actual config.

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/

• alfiedotwtf

  yesterday at 3:21 AM

  > 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

  +1

  I found the best way to approach Emacs was to start with an empty init.el and then just start using it. Every time something annoyed me or I thought “there should be a package to do X”, I stopped what I was doing and went hunting…

  By doing it this way, you’re actually using it from the start and get to slowly taylor it to your personal needs.

  Also, I am not yet an Elisper, and so for the macros I’ve wanted to write, ChatGPT has been really helpful.

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.

• scott01

  last Saturday at 10:03 PM

  I second this approach. After setting these ones up, together with lsp-mode and company-mode (I like experience better than eglot), my configuration stayed mostly the same. I also kept adding new shortcuts for functions I needed (like symbol rename or function list), and am currently at a point when Emacs became a very efficient editor for me personally. I also moved most of these shortcuts over to yyIntelliJ editor at work where Emacs is not very practical due to lack of convenient debugger (C++, Unreal Engine).

  • alfiedotwtf

    yesterday at 3:26 AM

    I wanted to go down the Egypt path, but lsp-mode supports DAP whilst the now-built-in Eglot doesn’t?! :(

• last Saturday at 9:01 PM

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'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/

I was in the same boat until a couple of months ago.

Long time vim/neovim user, used fennel to configure it lastly, but I wanted to see what Emacs has to offer to compare.

I started by reading Mastering Emacs by Mickey Petersen and from there start adding things that I felt I needed (configure key bindings, project.el, eglot, LSP things, helm, corfu, vterm, flycheck, etc)

I still have things to do, but I'm not in a hurry, I'm quite comfortable with Emacs right now, so will approach them shortly.

There's also Protesilaos' Stavrou channel on YouTube with a good amount of videos covering Emacs' topics in depth. I highly recommend them.

(Btw, I still don't know what Vertigo and Consult provide, but I can navigate through files, text search and replacement, functions and all with comfort, so not sure if I'm missing something.)

• skydhash

  today at 11:36 AM

  > I still don't know what Vertigo and Consult provide

  Emacs have this whole completion things, but it’s a bit bare as it’s somewhat similar to bash completion (a lot of tab-bing). Vertico add incremental completion and present the candidates in a vertical list, so it’s more like filtering than completions.

  Consult provides a lot of collections for completions and some niceties on top of some existing completion sources. Two of its main features are narrowing (kinda like selectibg a subcollection) and asynchronous sources (you can have something like ripgrep powering the sources of completion candidates).

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

• aquariusDue

  yesterday at 12:52 AM

  Great list!

  For modal editing but more similar to the kakoune/helix model there's the meow package which I prefer compared to evil, for some people it might be worth looking into as its more customizable and allows you to have as much or as little modal editing as you want. I use meow and regular Emacs key chords at the same time without issue for example.

• kccqzy

  last Saturday at 10:40 PM

  > Don't use doom etc, just standard emacs, otherwise you won't have any understanding of what is happening and how to fix it.

  Doom and Spacemacs are IMO sufficiently good abstractions that you will almost never need to have understanding of the underlying system and to fix things. Sure for curiosity's sake you should still learn what's happening under the hood. But the abstraction is almost never leaky. I think everyone beginning Emacs should start with Doom or Spacemacs and optionally build their own config later on.

  • flimflamboi

    yesterday at 4:05 AM

    [dead]

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.

• rcfox

  last Saturday at 5:54 PM

  > For Linux, just use the emacs that comes with the distro.

  Are the major distros shipping packages with tree-sitter support yet?

  • baobun

    last Saturday at 6:04 PM

    Yes. All of them.

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.

• kleinishere

  last Saturday at 7:11 PM

  Came here to find this. MANY upvotes.

  I used Doom for a couple months.

  Then started considering a vanilla eMacs. I started taking notes on packages I found highly recommended and interesting.

  Then I found this. And the author has done all that work and then made it into a “let me walk through a config” including a lot of the most recommended packages and sensible configs.

  Gives you the lesson of building a config, knowing what’s in your config, and then being fluent in changing it.

  He also has more notes on his blog about the packages + more : https://www.jamescherti.com/essential-emacs-packages/

  And I now feel comfortable making changes myself.

+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.

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 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.

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.

• theflyinghorse

  yesterday at 5:04 PM

  Using tabs requires so much discipline imo. I just end up having 2000 tabs open, and so I chose to not have tabs at all.

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

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.

• wyclif

  yesterday at 11:14 AM

  You mean the `Include` directive, right? Not "load"...but I guess that's just shorthand for the concept.

  So you split your main ~/.ssh/config file into smaller, reusable files stored in a subdirectory like ~/.ssh/config.d/. The main config file then "includes" (loads) these modular files automatically. So for instance, you might have:

  ~/.ssh/config.d/10-general.conf

  ~/.ssh/config.d/20-work.conf

  ~/.ssh/config.d/30-github.conf

  Can confirm this works great in teams or on multi-host setups, as it keeps things organized without cluttering a single massive config file and it works across tools like ssh, scp, rsync, etc.

  • wafflemaker

    today at 3:59 PM

    It also makes automation easier. I have a script auto adding vagrant VMs under known names when working on a project with vagrant. And had to go at great lengths to avoid nuking the main config file.

    And same for for Emacs: it's much easier to vibe code some changes (don't know ELisp that well). And then when knowledge of the language matures I can look at fixes and at least know what was the idea behind them.

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?

• skydhash

  today at 11:49 AM

  In lieu of the terminal, I use shell-mode for CLI tools. For the rare TUIs i need there’s always ansi-term. And there’s shell-command and async-shell-command for one-off things and `compile` for anything that present a report about files (build, lint, and test).

• binary132

  yesterday at 1:42 AM

  I usually just use emacs in one terminal tab and tmux / bash in another. The more you get familiar with emacs though, the more you tend to get things done in emacs without using a terminal at all. Magit and the file interface are both generally a lot better than terminal living. You _can_ drop into a shell window, but in my experience it’s usually easier just to keep a terminal around if you need it.

• rich_sasha

  yesterday at 1:40 AM

  I use Emacs exclusively in the terminal, with standard platform terminals (iterm on Mac, windows terminal on windows). Works great.

  • pkulak

    yesterday at 1:43 AM

    You mean, you use eMacs in terminal mode? I thought that was frowned upon? Isn’t a lot of the benefit is eMacs that you can get a true GUI, with no keybinding limitations, varying font sizes, etc?

    • rich_sasha

      yesterday at 11:30 AM

      I wasn't aware of any frowniness! Sure, there are some features you can only access via gui, but I'd say they are extremely minimal in my workflow:

      - real buttons in GUI

      - rendering inline images/LaTeX

      - varies fonts (eg font sizes)

      There may be others but I can't think of them. Neither of the above is things I do more often than a handful of times a year.

      Meanwhile, terminal Emacs plays well with tmux and SSH which I do a lot of. For example, a workflow I have is to SSH to a Linux box, start a tmux session and have Emacs/ipython/jupyter with port forwarding open on the remote box. I can steal this tmux session from any new connection. It also survives if the machine I'm sshing from dies or reboots. I can't think of a way to make it work with GUI emacs.

    • brucehoult

      yesterday at 3:11 AM

      I guess some people can frown on anything.

      I 99% of the time use emacs in a terminal. 90% of the time over ssh or in a non-GUI VM/docker etc.

      I usually install emacs-nox to speed up the install.

      Vanilla emacs is fine. Maximum I scp my .emacs file from another machine, but there's actually very little in it. Mostly it's disabling the menu bar, tool bar, and scroll bars.

      Usually all I'll do is adjust things such as indenting and other code formatting things to match the codebase I'm working on -- which varies from project to project anyway, and you need to do with any editor to avoid making a mess.

      I do have one little elisp function that tries to find and open the header file for the C file I'm currently in, or the c, cc, cpp, c++ file for the header file I'm in.

      I'll reproduce that below, if anyone cares. Please don't laugh too much at my elisp -- I probably wrote that in the 90s.

          ;;;;;;;;;;;; Automatic switching between source and header files ;;;;;;;;;;;;;;;;
          
          (defvar c++-source-extension-list '("c" "cc" "C" "cpp" "c++" "pcc" "pc"))
          (defvar c++-header-extension-list '("h" "hh" "H" "hpp"))
          (defvar c++-header-ext-regexp "\\.\\(hpp\\|h\\|\hh\\|H\\)$")
          (defvar c++-source-ext-regexp "\\.\\(cpp\\|c\\|\cc\\|C\\|pcc\\|pc\\)$")
          
          (defun toggle-source-header()
            "Switches to the source buffer if currently in the header buffer and vice versa."
            (interactive)
            (let* ((buf (current-buffer))
                   (name (file-name-nondirectory (buffer-file-name)))
                   (check (lambda (regexp extns)
                            (let ((offs (string-match regexp name)))
                              (if offs
                                  (let ((file (substring name 0 offs)))
                                    (loop for ext in extns
                                          for test-file = (concat file "." ext)
                                          do (if (file-exists-p test-file)
                                                 (return (find-file test-file))))))))))
          
              (or (funcall check c++-header-ext-regexp c++-source-extension-list)
                  (funcall check c++-source-ext-regexp c++-header-extension-list))))
          
          (global-set-key [?\C-c ?`] 'toggle-source-header)

    • ksherlock

      yesterday at 2:47 AM

      The emacs GUI is basically a dog-shit terminal emulator that only runs emacs. Just run emacs in the terminal.

    • yablak

      yesterday at 6:26 AM

      You can set up the terminal+tmux to forward all the important keys to console emacs. I like iterm2 for its extreme configurability. Others say kitty terminal with the kitty term emacs library is great. I never got that working with tmux.

    • ksherlock

      yesterday at 4:06 PM

      By the way, Richard Stallman uses emacs from a text console. A text console! Not an xterm, not a terminal emulator, the text console.

• Scarblac

  yesterday at 1:07 AM

  If you want to quickly edit a file, you can also open emacs in the terminal with "emacs -nw".

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.

• etothemacs

  yesterday at 3:57 AM

  [dead]

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.

• avtar

  yesterday at 3:17 AM

  > as far as I can tell, no operating system does this in a way that really works besides OSX

  AFAIK this is an easy setting in desktop environments such as Cosmic, Gnome, and KDE. But I've been using keyd on Linux distros for a while:

  https://github.com/rvaiya/keyd#quickstart

  Using the config in the above example results in Caps Lock acting as Esc if used on its own or as Ctrl if it's held down.

• johanvts

  yesterday at 1:36 AM

  Get a kinesis advantage, you won’t regret it.

• teddyh

  yesterday at 12:21 AM

  > I must bind caps-lock to control, and […] no operating system does this in a way that really works besides OSX.

  What? This has worked for me in X11 for at least two years now:

    setxkbmap -model pc104 us -option ctrl:nocaps
  

  (If you still need a Caps Lock key, there’s -option ctrl:swapcaps)

  • nasduia

    yesterday at 1:14 AM

    Yes, and that option is in most desktop environments' keyboard configuration dialogs.

  • bjoli

    yesterday at 6:36 AM

    I always use "two shift keys activates caps".

• kwoff

  yesterday at 12:57 AM

  Not sure if it counts as "really works", but on Windows with PowerToys you can enable Keyboard Manager and 'Remap a key'. (Might want to remap right-Ctrl to CapsLock, in case it turns CapsLock on.) There's also old Registry hacks to do the same thing.

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.

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.

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.

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.

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.

• flimflamboi

  yesterday at 4:04 AM

  [dead]

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.

• etothemacs

  yesterday at 4:01 AM

  [dead]

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.

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

• skydhash

  today at 11:58 AM

  I have a 1200+ lines of config, but they’re mostly nice-to-haves and full-blown apps. But I can do fine with vanilla if needed. My EDITOR is mg which is barest than bare emacs.

  Also, vanilla emacs have full support for customize, so I can just go there to quicly setup settings. The reason my config is huge is because I dislike customize and prefer setting options via code.

• teddyh

  yesterday at 2:01 AM

  I’m sorry to inform you that it is perfectly possible. When I encounter a system which has a completely stock and unconfigured Emacs, I generally only modify one or two settings, and then I’m perfectly happy to use it in that state. I’ve used Emacs for 30 years, and I still use it heavily every day.

• ashton314

  yesterday at 4:48 AM

  One of the sharpest people I know—he's a professor and hacks on the LLVM for a living—uses stock Emacs in the terminal with no discernible customization.

• bjoli

  yesterday at 6:41 AM

  Linus Torvalds lives in pretty much vanilla microemacs.

• alfiedotwtf

  yesterday at 3:31 AM

  People have been doing this since the 70s :)

• etothemacs

  yesterday at 4:00 AM

  [dead]

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...

• skydhash

  today at 12:04 PM

  No need to be fast with Emacs. You can just input chords with two hands.

  But I’ve remapped caps to control and use the side of my pinky instead. My hands are big though.

• avtar

  last Saturday at 9:03 PM

  +1 It's been ages since I last tried Emacs but one of the main reasons it didn't resonate with me was the constant hand contortions required for key chords. I'm pretty sure I tried evil mode as well. Projects such as Combobulate, Vertico, etc. being mentioned in this thread weren't around back then and seem intriguing. Curious to learn about any other projects or workarounds that help with ergonomics.

• aquariusDue

  yesterday at 12:58 AM

  Rebind Capslock to act as Ctrl when held and Esc when pressed, use a modal editing package like evil or meow. There's also devil-mode which does some smart heuristics on your semicolon so you can press it instead of holding Ctrl or Meta (Alt).

  That's pretty much it without delving too much into specifics, it's important to note that most of Emacs' functionality can be called via M-x (the original command palette) and selected or searched for easily. No need to play piano with hard to remember key chords for rarely used stuff.

• tmtvl

  last Saturday at 9:08 PM

  I type Dvorak and I use the opposite modifier key to whichever key I want to modify. So, for example, for Control+A I would hold the right control key and press a. Aside from that, an active hobby with plenty of stretching and strengthening for the entire body.

• Kholin

  yesterday at 3:39 AM

  I'm using a QMK split keyboard, remap the Left Space key as Ctrl key so that I can press it with my left thumb finger.

• jibal

  last Saturday at 11:06 PM

  r/emacs on Reddit has many discussions about this.

• etothemacs

  yesterday at 4:02 AM

  [dead]

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

Just use Doom. Its good.

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

[dead]

[dead]

[flagged]

• baobun

  last Saturday at 6:11 PM

  > > What frame should I get for my fixie bicycle?

  > Just buy my brand of electric bike instead, it comes preassembled and you won't gst grease on your hands

  • roman_soldier

    last Saturday at 11:05 PM

    Emacs is not modern, to achieve the functionality of a modern editor/ide, with all the lessons/research done since the 70/80's it's going to take a huge amount of configuring. It's logical that using a modern editor like VS Code would be much more efficient.

    • jibal

      last Saturday at 11:17 PM

      Perhaps you should read the OP again ... your comments are off topic (Edit: obviously--the topic is not editors in general, and I'm obviously not guilty of what the response accuses me of).

      Also examine https://news.ycombinator.com/newsguidelines.html

      • roman_soldier

        last Saturday at 11:48 PM

        How is my comment off topic? VS Code is an editor as is emacs. There is nothing in the guidelines link that would constitute my post being wrong, however it does say

        'Please don't post shallow dismissals, especially of other people's work. A good critical comment teaches us something.'

        and

        'Please don't complain that a submission is inappropriate. If a story is spam or off-topic, flag it. Don't feed egregious comments by replying; flag them instead. If you flag, please don't also comment that you did.'

        Maybe it would help if you reread the guidelines yourself.

    • flimflamboi

      yesterday at 4:06 AM

      [dead]

  • noosphr

    last Saturday at 6:19 PM

    I'd say push tricycle.

    After all chains are too complicated an you hardly need them in the kids playground.

[flagged]

• mackeye

  last Saturday at 6:39 PM

  ime, the benefit of vscode over a text editor (i prefer kakoune, which has present, but low, community support vs. n?vim/emacs) was relatively seamless debug sessions. almost any other element is exceeded in an editor, to me --- the git integration of vscode is subpar, most vscode plugins i'd need have standalone counterparts (tinymist is the best example), etc. in emacs, these are exacerbated, as git integration is emacs is excellent (as i hear), and many integrations for emacs are well-maintained. what do you see as the benefit of vscode over an editor?

  i haven't used cursor, and i've used clion only minimally. visual studio is quite a standup ide experience, and i'd use it were i on windows. but vscode doesn't seem particularly above the competition in terms of sheer capabilities.

  • sexyman48

    last Saturday at 7:48 PM

    [flagged]

    • mackeye

      last Saturday at 10:57 PM

      did you have an issue with the parentheses or the capitalization :)

      • jibal

        last Saturday at 11:21 PM

        Your comment was fine.