Let's share your top 3 packages that you can't live without.

For me, 1. Evil :: [https://github.com/emacs-evil/evil](https://github.com/emacs-evil/evil) 2. Swiper :: [https://github.com/abo-abo/swiper](https://github.com/abo-abo/swiper) 3. Magit :: [https://github.com/magit/magit](https://github.com/magit/magit)

- PDF tools: https://github.com/vedang/pdf-tools - Dumb Jump: https://github.com/jacktasia/dumb-jump - Highlight Symbol: https://github.com/nschum/highlight-symbol.el The last two are invaluable for exploring new code: Dumb Jump to navigate around unfamiliar code bases (and my own scripts) without an LSP running in the background, and Highlight Symbol to highlight function/variable names to see where the functions/variables are used in the code (also very helpful for debugging to check for misspellings or wrong variable usage).

EXWM https://github.com/ch11ng/exwm Modus themes https://github.com/protesilaos/modus-themes Corfu https://github.com/minad/corfu

I like Highlight Symbol too! I got the information from here :: [https://xenodium.com/emacs-highlight-symbol-mode/](https://xenodium.com/emacs-highlight-symbol-mode/) <- Informative website for Emacs users

1) helm (or vertico+orderless) for usable completion 2) lsp-mode for coding 3) magit for git

Without any order [magit](https://github.com/magit/magit), [lispy](https://github.com/abo-abo/lispy) and [minions](https://github.com/tarsius/minions).

I should try 'Corfu' for auto-complition. Thanks!

- `tree-sitter`: https://github.com/emacs-tree-sitter/elisp-tree-sitter - `eyebrowse`: https://github.com/wasamasa/eyebrowse - `eglot`: https://github.com/joaotavora/eglot

1. restart-emacs 2. restart-emacs 3. restart-emacs

built in functionality as of Emacs 29

The truly foundational packages, that I would be hopelessly lost without, have to be: 1. [use-package](https://github.com/jwiegley/use-package) for configuring my packages 2. [general.el](https://github.com/noctuid/general.el) for configuring my keybindings 3. [wordel](https://github.com/progfolio/wordel) for everything else

elfeed, notmuch and ess (emacs speak statistics)

multiple-cursors ace-window company

I could survive with only org mode and helm.

1. `avy` 2. `perspective` 3. `embark`

Eglot, use-package, and magit.

Evil evil-collection org-mode

Evil, lsp-mode, and org-mode.

1. org-mode 2. org-roam 3. notmuch The first because it's the base tools to collect pretty anything from org-attached/linked files to mails to anything else. Org-roam to easy access anything. Notmuch to manage mails. Witch org of course came a big set of packages, to support org there is Emacs, with it's built-in like dired. With org-roam there is ivy and co for a search&narrowing access to anything. Pinning those three and their needed dependency, what they bring with them, it's essentially my most basic daily driver. I'd like to add a forth EXWM, since after using it I can't go back to other WMs/DEs/DSs BUT I can eventually use i3 and similar having to choose just three...

I'm curious about ESS: may I ask what you do with it?

If you're only using two other packages, use-package probably isn't all that necessary.

true, but I'm installing each one \~50 times

ess, elfeed, auctex

I cut my teeth on OG Emacs in the 80s so if needs be I could live without any packages but with that said the clear choice for me is: Org-mode because every other package is either a non essential nicety like lsp-mode (which is GREAT and I use all the time but we got along with out it in an earlier day) or there is an alternative. I similarly love Magit but I can always use the command line. Now, there are plenty of packages that I love but I think org-mode is the only one truly essential to my day to day.

evil, lsp-mode, vertico/consult

(Not parent): I use ess regularly as it provides a very powerful R repl. I can keep state in some of these R sessions for a while (weeks), and have multiple different sessions in any Emacs server. There is practically no startup cost to get a new one going so I often drop an R repl in a directory just to visualize a new data set quickly. I always use an interactive ess session when developing a complicated R script and sending things from the script file to ess for testing is seamless. I wish run-python was as strong as ess.

Data Analytics using R. It opens a connection to a R shell and allows you to send your code/interact with objects from emacs

1. Evil 2. Helm-swoop https://github.com/emacsorphanage/helm-swoop 3. elscreen (±= tabs) https://wikemacs.org/wiki/Elscreen

1. Shell 2. Dired 3. Melpa

Evil Magit (you can't just go back to regular git) Lsp

1. evil 2. magit 3. org

Evil Vertico Lsp mode

Mine are not as bright choice as others ...honestly, 1. which-key 2. vertico, marginalia 3. Notmuch interface & EMMS ....and many more.

magit use-package mc

1. evil 2. counsel/ivy 3. org-mode

- [exwm](https://github.com/ch11ng/exwm): Emacs X Window Manager. - [elfeed](https://github.com/skeeto/elfeed/): An Emacs web feeds client. - [vundo](https://github.com/casouri/vundo): Visualize the undo tree.

1. Which-key. Literally the perfect extension and no reason not to have it. 2. Dirvish. Transforms dired from a file manager everyone says is good, into one that actually looks good. 3. Use-package. Even for configuring built-in features, it's far and away the best way to manage a config. I'm a heavy evil user, but viper is built in and I'd use it in a pinch. Vertico+marginalia+orderless+corfu+embark is a nice stack, but the default completion isn't that horrendous. And org is built in so I'm not counting it.

>The first because it's the base tools to collect pretty anything from org-attached/linked files to mails to anything else. Org-roam to easy access anything. Notmuch to manage mails. Org is very valuable and most importantly, it is part of the standard distribution and just works out of the box. For any of the amazing packages you have to download from melpa there is always the risk of package dependency hell.

- Org-Mode - Which-Key - Vertico

There's many more than 3 but if I had to choose I would say Evil, because I just love vim keybindings, org roam, because it has become an integral part of my workflow, especially for university and Ivy because default completion system is just not it. But I could easily think of top 5 or top 10 as well. I use a lot of stuff

* mu4e * magit * elpher (Didn't include Ebuku because, even though i can't live without it, i wrote it, so it seemed weird to include it.)

I would say: - org-mode - helm (or ivy) - eldoc

Posts like this one make me feel like a masochistic perfectionist for every few months returning to vanilla emacs to rebuild my config from the smoldering dumpster fire it always turns into. Currently I'd say: 1. Paredit 2. Sly 3. Magit

erlang-mode sql-mode go-mode I don't want to live without magic and ido and dired and vterm and all the rest but I could. Without the programming modes I'd have nothing to commit to git or run in a terminal and so on.

Helm, org mode, magit, projectile

1. Org mode 2. Helm 3. Multiple Cursors

Magit, org, and I suppose selectrum? Truthfully I could probably survive without any of them, and did (other than org) for a year in which I only used unconfigured emacs (installing needed major modes with package.el), but those are the three whose loss I would feel the most, in order. That said, no-littering has only been excluded due to the presupposition that these would be my only three packages.

I should try to use Sly. Thanks! https://github.com/joaotavora/sly

1.hydra:: [https://github.com/abo-abo/hydra](https://github.com/abo-abo/hydra) 2.magit:: [https://github.com/magit/magit](https://github.com/magit/magit) 3.objed:: [https://github.com/clemera/objed.git](https://github.com/clemera/objed.git)

1. Vertico 2. Magit 3. Eglot

> I'd like to add a forth EXWM, since after using it I can't go back to other WMs/DEs/DSs BUT I can eventually use i3 and similar having to choose just three... Losing the unified buffer/window and keymap management you get with EXWM is really rough though once you get used to it. There is nothing else that comes close. Even going back to StumpWM would be very unsatisfactory after a few years of EXWM.

1. Evil 2. Org 3. package.el (is that a cop out?)

1. Evil 2. Magit 3. lsp It's hard to select just three it's like picking your three favorite kids :D 4. Org mode 5. Believe it or not "compile.el"

- lsp - undo-tree - org-mode

Evil, magit, vertico+consult

- org-mode - evil-mode + evil-leader - persp mode (perspectives)

compile.el is severely underrated.

Love how much magit appears. My number one too. I’ve been digging a new lightweight editor written on rust called [Helix](https://helix-editor.com/). Trouble is lazy-git and similar tools just can’t hold a candle to magit.

hungry-delete Swiper flyspell

org-mode, which-key & hydra

Does org count, even if it is there by default? 1. org 2. magit 3. undo-tree

I'm curious about how useful hungry-delete is for you and why `delete-horizontal-space` isn't 🤔

I suppose it is most useful when you copy text from a different source and paste it to emacs. The text format is often inconsistent in the copied text and hungry-delete helps in quickly making it legible. Also, I think it helps in counsel-find-file where hitting backspace key shifts to upper directory.

magit, org mode, yeah pretty much it

May you share how's your workflow with avy? I find it super interesting, I've read Karthink's article, but still can't find a lot of everyday usage

Oh thanks :-)

In any complex software there is the dependency hell risk...

[deleted]

Sure, but well... 3 options, I can perhaps swap org-roam with EXWM, since I can replace it with something else like a manually maintained org-mode bookmark (linksmarks for instance) file, but it's a bit overburdens maintain by hand such setup...

I have combed my init file and currently have 105 packages I `use` daily. But to list the first three I encounter every day: - exwm - orgmode - gnus I should probably also include `straight.el use-package`

oh, I forgot `Telega`. I also use that very heavily, sometimes first-thing in the day.

> vundo: Visualize the undo tree. How had I not seen this before? Looks like a nice, simple solution to this age-old problem. Although undo-tree works pretty well also: I only ever had a problem with it once or twice, IIRC.

Technically Org is part of Emacs, though... ;)

Yeah, remembered that after I posted it :-)

[removed]

[removed]

https://github.com/abo-abo/avy https://github.com/nex3/perspective-el https://github.com/oantolin/embark

https://github.com/joaotavora/eglot

https://github.com/emacs-ess/ESS https://github.com/skeeto/elfeed https://www.gnu.org/software/auctex/

https://github.com/justbur/emacs-which-key https://github.com/minad/vertico https://github.com/minad/marginalia# \# Notmuch https://notmuchmail.org/notmuch-emacs/ https://protesilaos.com/codelog/2021-05-15-emacs-notmuch/

https://github.com/alexluigit/dirvish

https://github.com/nflath/hungry-delete

https://github.com/abo-abo/hydra

https://github.com/org-roam/org-roam

https://github.com/iqbalansari/restart-emacs

https://github.com/emacsmirror/elpher

[https://github.com/emacs-helm/helm](https://github.com/emacs-helm/helm) [https://github.com/bbatsov/projectile](https://github.com/bbatsov/projectile)

https://github.com/magnars/multiple-cursors.el

https://github.com/emacs-evil/evil-collection

https://github.com/zevlg/telega.el

https://github.com/abo-abo/ace-window https://github.com/company-mode/company-mode

It's available in MELPA too. Let me paste a few lines of Elisp that I use to make multiple cursors behave a bit more like Notepad++'s approach: `(defun mc-dpoggio--remove-fake-cursor-on-top-or-add-below ()` `(interactive)` `(if (not (null (mc/furthest-cursor-before-point)))` `(mc/remove-fake-cursor (mc/furthest-cursor-before-point))` `(mc/mark-next-lines 1)))` `(defun mc-dpoggio--remove-fake-cursor-at-bottom-or-add-above ()` `(interactive)` `(if (not (null (mc/furthest-cursor-after-point)))` `(mc/remove-fake-cursor (mc/furthest-cursor-after-point))` `(mc/mark-previous-lines 1)))` Bind to something like `C-M-<up>` and `C-M-<down>`.

Yes, that's the one.

I like to do as little mouse-moving as possible while coding, so I bound various `avy` goto commands in the `goto-map` (`M-g`). I mostly use line, word and char to jump to (almost) any visible position. I also bound the copy, kill and move commands for lines and regions, can save some time when refactoring, dealing with boilerplate. I can see why this is not particularly useful if switching from keyboard to mouse doesn't bother you. I might just be a curmudgeon. I haven't read karthink's article, but I'll have a look. Always learn something new.

Magit Consult Eglot

Vundo came much later which is probably why. It also isn't compatible with undo-tree so most people would have to abandon all their existing undo history to migrate. That said it is compatible with emacs builtin undo (and undo-fu) which makes it arguably better in the DRY property since undo tree basically reimplements undo from the ground up to work similar to vim. I have both as separate module in my config but am still using undo-tree until I have a chance to properly find out whether undo-fu+vundo is a good enough substitute for my workflow. I'd recommend trying vundo out tho, it looks just as user friendly in the few times I've experimented with it.

I mostly use it with link-hint. Basically highlights every link (org mode, markdown, customize menu widgets, etc.) With avy like markers and opens the one you jump to.

1. Howm ;; [https://howm.osdn.jp/](https://howm.osdn.jp/) just looking for others or to combine. i like howm a lot

xeft citre rg

What do you like about eglot vs lsp mode?

What do you like about eglot over lspmode?

Well, I found eglot more aligned with personal preference. It works out of the box (almost 0 additional configuration to get it working), and it's light weight. I've used lsp-mode a few years before and I found the overlays it created a bit distracting and somewhat slower than eglot. Again it's just a matter of personal preference and both are great additions to the programmer arsenals.

At the time I had to pick one over the other `lsp-mode` was slower in comparison, mostly due to how much it was trying to accomplish while still making it too difficult for users to enable things gradually rather than spend time disabling the superfluous

Im not sure about the internals of MC, but `(not (null x))` looks like an antipattern to me, probably you can use just `x` instead, besides that you can just bind it in `if-let` to avoid calling it twice

in terms of usability (not configuration/help stuff) the most often used ones are `ace-window` (it depends on `avy`, but it's not my fault :) `telega` `ivy`

Yes, it’s the first time I actually re-read that and damn, that’s awful. The let, it feels a bit like over optimization, I mean, it’s not like I’m intensively calling this… however it’s true, I’m looping through the overlays (the fake cursors) twice. I’m from my phone now, so I’m not editing stuff. Maybe later. Thank u anyways.

for me it’s magit, org-mode and counsel/ivy/swiper

Thanks for that. Yes, Telega is absolutely incredible if you are a Telegram and Emacs user. I use it daily guaranteed just so I can save messages on my phone and easily get them on my desktop emacs. For instance, every evening I write my journal entry on my phone after my work time is over, and then I pull it into my orgmode daily journal the next day.

Hm, I didn't realize that undo-tree actually replaces Emacs's undo implementation; I thought it merely visualizes it. I suppose that could explain the occasional problems with it. Merely visualizing it seems like a good idea, so vundo seems like a good idea, too. :) Thanks.

1. Gnus - email, mailinglists, RSS-feeds, blogging. 2. easypg - seamless handling of encrypted files - my password manager is a txt.gpg file. 3. rg.el - search files, and - with wgrep - edit directly in the search-results. Runner up for me are tramp, magit, jabber.el and dumb-jump.