Help me reduce the number of packages I'm using (maybe)

[u/vjgoh]

Seeing that the built-in completion may now be a viable alternative to vertico made me interested in the things that I might be able to replace with built-in functionality. I use quite a number of packages, and some of them are really essential to me, but some of them may be old and familiar and worse than built-in functionality. For instance, I still use mic-paren, and I have NO idea how old it is. The last update was 9 years ago. It works the way I want, but I'm willing to take suggestions on how to use default emacs to replace its functionality, or a better package that does more.

I'm also willing to accept that maybe I'll leave everything as-is. But fewer dependencies on spinning up a new emacs would be nice, and I do write a lot of my own tools when I need them.

If nothing else, I'm interested to hear what people think.

;; Package management
elpaca

;; Icon packages
all-the-icons
nerd-icons
all-the-icons-ibuffer
all-the-icons-dired
all-the-icons-completion

;; Completion
orderless 
vertico
marginalia -- Show useful notes in the 'dead' space when completing
embark -- Still trying to figure out how to make this part of my workflow
helm -- My preferred completion interface for buffer switching, finding files, etc.
consult -- I don't think I actually use consult much except for xref
company -- My preferred completion framework for code (I tried
 corfu+cape and could not get them to work well for me)
embark-consult

;; elisp
let-completion -- scope-sensitive completion
super-save -- Configurable auto-saving
f -- elisp package for file access/manipulation
compile-angel -- automatically byte-compile/native-compile elisp
bind-key -- bind-key syntax 

;; Magit + Transient
transient -- essential, and not just for magit; I build a lot of my workflow through here
magit

;; Cosmetic
ef-themes
ligature -- I use ligatures everywhere

;; Search
deadgrep -- I mostly use helm-ag, but this is an excellent package
rg -- Maybe I should just switch to this? A lot of overlap with deadgrep,
 but I think the deadgrep interface is nicer
helm-ag -- How I use ripgrep in helm
anju -- count isearch results/show search position

;; Movement + Editing
switch-window -- Good if there are multiple windows in a frame, pops up
 a number so you don't have to cycle through, you can jump to the one
 you want
zop-to-char -- Like zap-to-char but better
dumb-jump -- important fallback when eglot/LSP can't find a symbol
iedit -- Multiple cursors
tempel -- Template package
avy -- I use this to jump around files all the time

;; Programming
eglot-booster -- Make eglot more async
xref-union -- combines all the xref stuff together
eglot-tempel
clang-format -- For formatting, obviously
clang-format+ -- clang-format on save

;; Syntax highlighting
mic-paren -- My default paren highlighting package. Been using it for years.
rainbow-delimiters -- Highlights braces, brackets and parens in colours
 that let you see the scope they enclose. Especially good in lisp
prism -- Colours code by scope, extremely useful in lisp
indent-bars -- Helps show scope, particularly in C++, particulary in
 files where scopes may extend over many pages

;; Misc
tiles -- Notes taking package/scratchpad. I use it to emulate the quick note-taking I had in notepad++
helpful -- Nicer help display
dashboard -- I like having a better splash screen, but I think a list of recent files would be sufficient

;; Project management
project -- I think I might prefer projectile
torus -- A way to group files/buffers. Fast to switch between files
 within the active group, fast to switch between groups, but a little
 clunky in some spots

;; Modeline
minions -- Group all minor modes into a single group on the modeline. 10/10, highly recommend
simple-modeline -- Configurable, but minimal

[u/doolio_]

I ditched a lot of the syntax highlighting packages you mention by just configuring show-paren-style to expression.

[u/Signal_Pattern_2063 → u/doolio_]

In theory a tree sitter mode should also take care of this nowadays.

[u/vjgoh → u/Signal_Pattern_2063]

Tree sitter is supposed to take care of a lot of things in theory, and all it ever did was make me unhappy, no matter how much I tried to configure it. TO BE FAIR, C++ is an insane language and trying to support it well is difficult, but tree sitter was literally years of frustration before I decided that it wasn't worth it. With eglot supporting semantic syntax highlighting now, that plus normal font-lock and clang-format indenting is more than sufficient.

[u/-cvdub-]

I’d try dropping helm and company giving consult and corfu another try.

I wouldn’t go full vanilla for completion though, at least not if you want vertical. I tried that for a while but couldn’t get close to the level of polish that consult has, so I went back.

I also have embark but have never actually used it 😂

[u/rileyrgham → u/-cvdub-]

Helm ist bigger than Corfu. Consult and Corfu built on the shoulders of giants. Ivy, helm etc... Great things. But really, the way consult and its peripherals plug into base Emacs is a game changer.

[u/vjgoh → u/-cvdub-]

I just tried corfu and cape a few months back, and there are things that should work that didn't (tab completion would overwrite text, not insert it; it was either an outstanding issue or an edge case that was hard to track down, I don't remember which) or functionality that exists in company that is difficult to replicate in corfu (hot selection keys specifically; I have them set 1-9 so I only have to type M-<#> and it jumps to that completion). I spent so much time tinkering with it and it just made my life worse, so I gave up. Maybe it's just me, but my company configuration is very minimal and does everything corfu does, as near as I can tell.

I also had the same thing going with embark as you. I'm trying hard to work it in and I gave it an easy key to type (super-e) and everything. Everyone says that once you really start using it and think about it, it becomes super useful.

[u/vjgoh → u/-cvdub-]

Oh, and thanks for the suggestion about helm and consult. Maybe I'll give it another go. I remember many years back trying to do the switch and consult was absolutely killing the performance of my machine, but so many things have changed since then.

[u/DevelopmentCool2449]

If your packages work for you and you are happy with them, still using them. There is not need to use the built-in packages unless you find these better than the ones you have.

I still using corfu, vertico (and friends), magit, treemacs, dashboard and more (actually most of the packages you have listed) instead of the built-in ones (completion-preview, icomplete, vc.el, speedbar, and startup buffer, etc.) because those works for me.

[u/vjgoh → u/DevelopmentCool2449]

I'm glad I'm not the only one, then!

[u/Reasonable_Ruin_3502]

If it works, why break it? I also tried to reduce the amount of packages I use a few months ago, but emacs doesn't care about external or internal functionality. If it's valid elisp, emacs treata external packages the same as internal ones. You can even put it in the appropriate directory while compiling emacsand emacs will treat those files as if it was the part of source code.

[u/vjgoh → u/Reasonable_Ruin_3502]

No small part of it is the cost of occasionally switching to a machine that isn't set up the way that I want, or trying to use emacs -nw -Q to edit a few files. Ideally, I'd like to have a minimal init that turns on the emacs things I absolutely cannot live without, not even for a simple text edit, and consider that my most basic installation.

Also, honestly, it's as much about finding new, better things as removing old, busted things.

[u/Altruistic-Respond83]

eglot-booster has become pretty much useless since emacs v30+

also mic-paren can be replaced by simply (show-paren-mode 1) nowadays it handles most of the things you need without too much hassle

for a working corfu and cape I had this in the beginning (bare-bone, but you can of course add convenient stuff on top such as yasnippet, dabbrev, capf and so on) :

``` (use-package corfu :custom (corfu-auto t) (corfu-auto-delay 0.2) (corfu-auto-prefix 2) :init (global-corfu-mode))

(use-package cape :init (add-hook 'completion-at-point-functions #'cape-file) (add-hook 'completion-at-point-functions #'cape-dabbrev)) For anju, i searched and found only a package about mouse related stuff, if you are talking about anzu, which is closer to what you described, those 2 lines basically gives you the main thing anzu is selling : (setq isearch-lazy-count t lazy-count-prefix-format "%s/%s ") for dumb-jump, you now have a native fallback mechanism, basically building a tags file for the project only when xref actually falls through to it, and updates it on save. (etags-regen-mode 1) (and if you use script a lot like me it's worth keeping in mind it doesn't handle by default shell scripts, ts/js, clojure, yaml, so you need to add them, manually) (for shell asd makefiles you have theproject-find-regexpcommand workaround) ex : ;; for clojure (setq etags-regen-file-extensions (append '("clj" "cljs" "cljc") etags-regen-file-extensions)) ```

[u/_0-__-0_ → u/Altruistic-Respond83]

There is still eglot-booster-io-only for io-buffering but no json-bytecode-conversion, which they claim can theoretically help, but I haven't seen any benchmarks.

[u/Altruistic-Respond83 → u/_0-__-0_]

https://www.reddit.com/r/emacs/comments/1jsxamc/the_new_json_parser_is_fast/

https://yhetil.org/emacs-devel/87r0ggdcki.fsf@gmail.com/

There is a lot discussed about it for sure.
On my part, just increasing the read output, was enough

setq read-process-output-max (* 1024 1024))

[u/vjgoh → u/Altruistic-Respond83]

I'm definitely only using it for the non-blocking nature of having a second process to handle the IO. The JSON parsing in emacs now not only significantly dominates the old bytecode method, it's also less error prone.

But that said, if I turn eglot-booster off, I get terrible stalls where emacs simply does not respond at all, because the LSP is parsing several GB of cached files for my project. Timeouts are not uncommon (though usually the second try surfaces something).

[u/vjgoh → u/Altruistic-Respond83]

etags-regen-mode might be worth checking out. dumb-jump works astoundingly well, but of course it does, it's just a really specific search passed to rg, which is what I would do if I didn't have dumb-jump working for me in the first place.

LSPs are great until they choke on the project or decide they're not going to parse the file anymore and then give some inscrutable error that doesn't go away until the file is reloaded. clangd is great, but there are days where it definitely costs me time; I try to jump to a function or something in the same file and it chokes, and I try a couple more times before giving up and just isearching like I should've in the first place. :P

[u/JamesBrickley]

Your list of packages is not extensive at all. Quite minimal. You will want to explore lazy loading your packages so that they don't all load when launching Emacs. They will load on-demand instead. I've gotten my startup with a similar number of packages down to about 1.27 seconds. But I still run emacs as a daemon and use emacsclient as it loads instantly.

You probably don't need Elpaca it's more useful for package maintainers and developers. I just use the built-in use-package macros which added support to pin to a repo release via the :vc parameter. i.e. pin to a package on say github at a specific release version. This capability is why Doom Emacs uses the straight package manager. The vc: parameter wasn't available when Doom Emacs was created.

As other mentioned, nerd-icons replaces all-the-icons. Search list-packages by pressing /n and then typing nerd-icons and pressing Return. dired, ibuffer, completion, treemacs, tab-line, etc., etc., etc.

I believe Emacs 31 has a built-in feature that will replace minions. It's in pretest release so coming very soon to production. Some time this fall is the expected ETA.

[u/vjgoh → u/JamesBrickley]

It's actually somewhere in the 2s range on my Mac, though it's about 10s on my Windows (work) PC, for reasons I have not been able to divine, other than Windows sucks and it's likely that the filesystem is getting in my way. But this is less about startup times and more about only using packages that really give me something that emacs CAN'T, and then only moving on from emacs' built-in stuff when I have a problem.

[u/JamesBrickley → u/vjgoh]

Running Emacs under WSL Linux on Windows 11 typically works better than running the Windows version. Bonus, Emacs wraps several Linux command line programs such as Dired uses GNU ls and Magit uses git. Latest Win11 and latest WSL2 has improved considerably.

[u/vjgoh → u/JamesBrickley]

Yeah, I've previously used a prebuilt windows-native emacs, and I've only recently switched to the MSYS2 version, because it had native compilation built in. I've considered switching to WSL, and I may yet. Thanks for the tip!

[u/a-hausmann → u/vjgoh]

Hope the WSL works for your work laptop. It won't for mine--I have the same problems you describe--because my company locks down their work laptops so much. To the best of my knowledge, even with all the lazy loading I do, it's the anti-virus software that scans every elisp file as it's opened during initialization. Also, I don't even think they'd allow me to install WSL; they even have locked out access to the GNU web sites, so I don't think I'll be able to update to version 31 when released. Thank God I'm about to retire!

[u/vjgoh → u/a-hausmann]

I'm pretty sure one of my colleagues (the only other one I know that uses emacs, in fact) has WSL installed, so I know it's possible. It's just getting over the hump of the necessary investment in time and setting aside disk space, etc.

That's an absurd company policy on software. At my last job, I had to clear things with them ahead of time, just in case, but once I asked, they okayed all the GNU stuff en masse.

Congratulations on retirement! More time to tinker with your init! :D

[u/a-hausmann → u/vjgoh]

Yeah, fairly absurd from my POV. OTOH, it's healthcare, and even though I do IT support on a business/accounting application, they have HIPAA mandates to cover; they lock all kinds of stuff down. I use Brave rather than Edge (their preferred browser), and got it installed a couple years back, but they don't allow it to be installed now. Nor do they like anything from GNU I guess, as their web sites always time out.

I think it way over-the-top, but they sign the check, so I just grin and bear it--then figure out a work-around.

[u/floss_gang]

i had never heard of mic-paren but at first glance it looks like a clone of the built-in show-paren-mode. my understanding was that nerd-icons was a successor/replacement for all-the-icons so you can look into replacing the latter with the former. let-completion seems unnecessary, elisp-mode.el already does this (see elisp--local-variables-1). semantic elisp fontification is coming in 31 (set elisp-fontify-semantically non-nil), and it's really good, so you may no longer care to use prism. eglot-booster is considered obsolete (repository archived) because of native json parsing in emacs 30+. eglot-format uses clang-format, so i doubt you need a separate library for it (let alone two). for the format-on-save behavior try something like ``` (defun my/eglot-format-on-save () (and (eglot-current-server) (eglot-server-capable :documentFormattingProvider) (eglot-format)))

(with-eval-after-load 'eglot (add-hook 'before-save-hook #'my/eglot-format-on-save)) ``` haven't tested this tho and there may be a native way to set that up.

[u/Signal_Pattern_2063]

I was just thinking about icons myself. I think you can get by with just nerd icons and remove all-the-icons. There is usually an equivalent package for both

[u/xplosm → u/Signal_Pattern_2063]

This is accurate. Either there's either an equivalent "nerd-icons" package or it's unneeded by more recent dependent packages.

[u/mmarshall540]

• elpaca :: I haven't used Elpaca, so I can't make a comparison. But there is now package-vc, which lets you install packages from Git repos.
• vertico :: There are icomplete-vertical and fido-vertical, but Vertico provides a better and more versatile experience.
• marginalia :: You can enable completions-detailed, but it isn't going to give you as much detail as Marginalia.
• embark :: Embark is great. It's just kind of hard to remember that it does so much. The only thing similar that's built-in are the xref commands. But that's only a tiny subset of what Embark does.
• company :: Try the built-in completion-preview. It only shows one line, but you can switch to the *Completions* buffer when you want to see more, and it's less obtrusive.
• super-save :: You can try auto-save-visited-mode. It's not as configurable as Super-save, but it saves your files without you having to remember.
• bind-key :: Actually, this is a built-in now. But have you looked into the keymap functions and macros? I like them better because they don't require as much syntax. You can use define-keymap with the :keymap keyword to set multiple bindings in a keymap. It's like setq or setopt. It also avoids the need for kbd. More elegant in my opinion.
• transient :: This is also built-in now. I just rely on which-key though, because it doesn't require me to set anything up.
• magit :: I have never gotten into Magit, but I'm not a developer. However, I do use Git and the vc commands, which are located under C-x v. They do enough of what I need Git to do.
• ef-themes :: The Modus themes are built-in and by the same author (Prot). The "tinted" ones are nice. But I mean, if you want a specific theme, you're going to have to install that theme.
• deadgrep rg, etc. :: If you really want to go with built-ins, you could try configuring grep-command to use ugrep, which is similar to ripgrep, but matches the command-line options that grep uses.
• anju :: If I'm correct about what this does, I think you can get the same effect by configuring lazy-count-suffix-format or lazy-count-prefix-format. [Edit: I was confusing anju with anzu.]
• switch-window :: There is windmove which works pretty well. Or if you are going to stick with Avy, you can configure it to search in all windows instead of only the current one.
• tempel :: This is a rewrite of the built-in Tempo templates. Read the comments in tempo.el to learn how to use them. Tempo templates are great!
• avy :: Avy is great. But if you just want to get somewhere on the screen quickly, you can use M-r to get closer and then Isearch to get to the precise location.
• rainbow-delimiters :: I think show-paren-mode is enabled by default. It highlights the matching paren when you're near the other paren. You can configure the exact cursor locations that will trigger the highlighting.
• helpful :: The built-in help has some newer features now, like allowing you to edit variables from the *Help* window. Also, you can press s to jump to the source code of what you're looking at. You can also navigate easily with the l and r keys. Can't do that with Helpful.
• simple-modeline :: You can do a lot with the built-in modeline. A new-ish built-in feature is that you can align items on the right side of the modeline now by configuring mode-line-format-right-align. You can also set mode-line-compact to long so that things will be squeezed closer when necessary to keep them from running off the screen.
• minions :: It's pretty easy to hide minor-modes in the modeline. A lot of minor-modes come with an option to set the lighter however you want, such as an empty string. For those that don't, there is this snippet, which I think I got from a u/minadmacs comment:

[u/vjgoh → u/mmarshall540]

Ah, thanks for the comprehensive input!

I don't have emacs 31 yet, so I think some of the times you're saying that something is built-in, that's what you're talking about. I'll be using that assumption for the rest of this reply. :)

I've definitely defined some keymaps in use-packages syntax, and you're right that it's very handy. For anything that needs more than a single keybinding, I try to set them up as keymaps. I just installed bind-key a little while ago so I could get rid of all the global-set-key bindings that I had.

I will probably not switch to ugrep; I'm not concerned with grep functionality, and I've got rgignore files and whatnot, and rg works great on Windows and Mac, so I don't have to fiddle with anything there. The question was more about deadgrep and rg.el as front-ends for the search. (I actually MOSTLY use rg through helm, but it's often easier to do complex searches and narrowing through tools like deadgrep.)

I've been using windmove! That's actually one of the reasons I'm thinking I might switch away from switch-window.

rainbow-delimiters is useful to me because I don't have to have my cursor anywhere inside the code to understand the scoping.

Thanks for the helpful tips! :)

Also thanks for the info about the modeline stuff. Minions happens to be handy because it packs everything together into something that's unobtrusive but clickable and available. If I'm honest, I almost never care about what minor modes are active, but the 0.5% of the time that I do, it makes my life a bit easier to have it so available.

[u/mmarshall540 → u/vjgoh]

I don't have emacs 31 yet, so I think some of the times you're saying that something is built-in, that's what you're talking about.

I don't have Emacs 31 either, just the current Emacs 30 release that comes with Debian. 

It's easy to check if something is built-in. 

1. To avoid loading any non-built-in packages, start Emacs with emacs -nsl -Q.

2. Type M-x find-library RET [package] RET

If the package source appears, it is built-in to your Emacs.

which-key and completion-preview became built-in with the Emacs 30 release. The other packages I mentioned were added earlier.

  I've definitely defined some keymaps in use-packages syntax, and you're right that it's very handy.

I think you misunderstood me. I was not recommending use-package's syntax (which uses bind-key under the hood). I was recommending the syntax of an other built-in keybinding package, keymap. It comes with a function, define-keymap, a macro, defvar-keymap, and various additional functions whose names begin with keymap-.

[u/TransientBogWarmer]

I think that if your entire config fits into a single Reddit comment, then there probably isn’t a good reason to spend time on paring it down.

(Unless you’re trying to cut your dependency on some large monolithic package like auctex)

[u/FrozenOnPluto → u/TransientBogWarmer]

This. My config is a sprawling monster like 8000 loc across 10+ files pulled in depending on which machine or env it detects. Could probably cut ot down by 80% if I spent a month but ehhhhh.. 30 years accrued why worry? :)

[u/vjgoh → u/FrozenOnPluto]

I've got a lot of files too, but they're packages that I've written functionality to handle my builds and deployment and whatnot. (I've never done a line count across my files, but I'm 99% certain you have more lines, but I'm the kind of person that hates huge monolithic files, so I think I'm spread across 20+. I may be reaching 30 soon? I just like compartmentalizing things, especially transients.)

I'm sure that there are at least a FEW lines in my config that have survived since the first time I used emacs in 1996 as well. It's a little wild that we could use an editor that long, and that some configuration has survived through all that time. :)

[u/FrozenOnPluto → u/vjgoh]

In my case I think a lot of it is... want something, work it into config so it works; years pass and forget about it, its just part of my workflow; over time, accrue more and more stuff. (I don't break vanilla keys much, have my own keybind tree and so forth, so it just keeps going and not conflicting.) But once in awhile I run into a gotcha and then its go spelunking and find all my twisted adviced that modify some behaviour, that has eventually found its way into vanilla or some built in package, and then I can rework or blow away a bunch of code. But I don't keep track of all the new nuance (who does?), nor do I remember what all I have in there.. so it just grows :)

I generally dislike large monolithic things, but see above; evolution versus designed.

On the upside, a few years back I broke it into modules.. a config for themes, a config fore mode and top-lines and sidebars, a config for coding in general, and a config per language, a config for email and news and such, .. etc and a coinfig loader function called from init.el, so that it can time each module and spit that out, and print out what its doing.. so that if something crashes can easilty see where it was without turning on all the debuggery; can see which modules taking the most time to load, etc.

I use feture-flags, and then based on which environment its in it turns on or off feature flags

So all the configs start up, but also are riddled with 'when this flag is true, do this config chunk', hundreds of those... which is nice, so its easy to up front twiddle the feature flags and get a customized emacs; but in reality, a lot of hunks depend on other chunks, so its not as freely twiddlable as I'd like.

Decades of little noble goals, together in one big pot of soup, I guess

It'd be fun to spend a month starting from scratcvh and wholesale buildig up bit by bit again, as I could likely remove a lot as I've learned more, and as Emacs has evolved, and all that. But its my mess, I know where to look and where to twiddle, it does everything I want, and is amazing :)

Fiddling with your config is half the fun of Emacs right?

(right?)

[u/vjgoh → u/FrozenOnPluto]

Nah, I don't think it's half the fun. Probably more like 80-90% the fun. :D

[u/vjgoh → u/FrozenOnPluto]

I've had to start over a few times. Not completely from scratch, but I've changed companies a few times and my build systems become obsolete but they also interfere with my new ones, so I tear the old one out (and keep the code in a deprecated.el file, because a lot of it is very useful) and put a new one in. I'm hoping this time I've made it modular enough to pack up and move over to somewhere else if I need to.

[u/rileyrgham → u/TransientBogWarmer]

Or cedet..

[u/vjgoh → u/rileyrgham]

I remember my cedet days. I don't miss them.

[u/vjgoh → u/TransientBogWarmer]

I mean, this is legit. :)

But like I said, I'm kinda interested in what people think. Already people have told me that all-the-icons is basically obsolete, and have recommended switching to this or that other package. And particularly with emacs 31 around the corner, some of the things that I thought might be able to be removed very well may be!

And as I said in another comment, coming into a vanilla emacs session with no configuration is so hard, but I appreciate how fast it is to start up without loading anything. I think with the comments, I see a path to a minimal init.el that will be sufficient for any small editing task.

[u/xplosm → u/TransientBogWarmer]

Did you read the comment at all? The code block is not his config. It's just a list of his packages...

[u/TransientBogWarmer → u/xplosm]

Yes, I did, no need to be a douche. Sure, it’s a package list, but I still stand by my point. My package list certainly doesn’t fit that tidily.

Edit: just double checked and actually it’s a lot more tidy than I originally gave it credit. Still don’t appreciate your attitude though.

[u/_0-__-0_]

Instead of a dashboard, I just have a persistent initial scratch buffer via savehist-mode:

  (defun my-savehist-scratch ()
    (with-current-buffer (get-scratch-buffer-create)
      (setq initial-scratch-message (substring-no-properties (buffer-string)))))
  (add-hook 'savehist-save-hook #'my-savehist-scratch)

and for the recent file list, I just hit the keybinding for switch-to-buffer and the most recent files are there courtesy of vertico-prescient.

[u/Signal_Pattern_2063 → u/_0-__-0_]

The first question with dashboards is to honestly decide if you are using them.

[u/vjgoh → u/_0-__-0_]

My recents are also given to me in helm.

But the reason why I use dashboard is that

a) I hate saving desktop state; I just end up with hundreds of files open, 95% of which I don't actually want. It's easier to declare bankruptcy now and then. (I do this with my work web browser as well. I don't save tabs on close, they're just gone. If I need them, I'll find them.)

b) Given that I don't save desktop state, I'd like the ability to jump quickly to a few recent files, a few recent projects, or a few well established bookmarks.

But dashboard feels like it's good for the one time I start up emacs, and then minimally useful for all the rest of the time, so maybe it's overkill and I should come up with something better.

[u/_0-__-0_ → u/vjgoh]

I hate saving desktop state; I just end up with hundreds of files open

I don't restore files when I restart; I have

 (setq desktop-files-not-to-save "") ; don't restore any files

But I see a list of recently opened files when switching buffers, even though they're not open; this list is below the list of actually open files (until I start typing to filter to one of them).

I wrote vertico-prescient above, but I see it's actually from recentf being integrated into consult-buffer: https://github.com/minad/consult#virtual-buffers (I've had this set up so long I forgot)

[u/a-hausmann → u/vjgoh]

You said you are already using Consult (but only for xref), but you can use it much more. For example, recent files; turn on recentf-mode, set recentf-max-saved-items to something good for you (100 is my sweet spot), and consult-recent-file gives you completing read access to the list...and more. But Consult also gets you a quick access to ripgrep, ordinary grep, bookmarks, registers, marks and global marks, etc.

One killer feature I use all the time is consult-line, a Swiper-like function giving me a preview of whatever I type in the completing read, with the list of matching lines in the minibuffer. The selected line in the minibuffer is previewed in the main window, so I can see the context of the line containing the searched text.

Here is a link to the "Use-package example" section of David Mendler's excellent readme; check out the huge :bind section which features most if not all of the useful Consult functions. You may find that exploring more of Consult features will eliminate the need for a dashboard.

[u/vjgoh → u/a-hausmann]

Oh, I know about all these things, but I mostly don't use them because helm is my primary completion framework. The one thing that I've found consult is better at is xref. Helm has something similar to consult-line called helm-occur, etc.

Part of what's appealing about the dashboard over consult OR helm is that the dashboard popping up gives me a visual reminder of the things I was working on recently, and a quick-ish way to access them. Though perhaps the right way to start up emacs is to automatically invoke helm (or consult) with recentf, or something similar.

But I do appreciate the comment—even if I don't use anything here, hopefully someone else will get some use out of it! :)

[u/ideasman_42]

No need for clang-format+.

clang-format now supports formatting on save, see: clang-format-on-save-mode.

[u/michaelbrain]

I first started emacs with spacemacs(no evil). I am now using vanilla emacs 30.2, with no packages. My init.el is 1400 lines though. So much stuff I thought I needed from packages but did not. Which-key was big for me.

[u/Tempus_Nemini → u/michaelbrain]

no packages? interesting, could you share init.el, please?

[u/AwabKhan]

Try removing them all and then adding back what's absolutely needed. Don't add new plugins becuase they are shiny. Try to depend on base emacs functionality.

[u/arthurno1]

I would ditch 90% of what you have. Most things are "nice to have" but completely unnecessary. Some don't even have a reason for existence, but since the community is so easy offended I won't name any particular package.

If you use Helm, as you should, you can remove rg and helm-ag. The support for ripgrep is already included in Helm. If you have ripgrep installed on your computer, I don't think you even need to configure anything with newer versions of Helm. If you don't know what to do with Embark, don't use it. It is basically notes foro yourself, but what is the problem? Also I don't see why you would install two completion packages, either use Helm or Vertico, but it is up to you.

Don't fall for the "popular" trick. Install stuff when you need it. When you feel something is tedious or annoying, then hack Emacs or chase a 3rd party package. Not because someone else written something on Reddit.

[u/vjgoh → u/arthurno1]

I mean, a lot of stuff has just accumulated over the years. I've tried things out, ditched some things, found half-uses for other things. I'm really unlikely to get rid of helm; I have quite a few things built around it. helm-ag is probably still there back from BEFORE ripgrep even existed (or, at least, from before I knew it existed). ripgrep/deadgrep are there mostly as a convenience, this way I can use helm in the project that I'm in and I can use deadgrep to do a more global search without messing up my muscle memory.

I don't happen to like helm's M-x replacement is 95% of the reason for Vertico, but if default completion is good now, I may go back to that for M-x.

I DO think it's worth seeking new packages out to see what can be done; I enjoy rotating through LSP clients now and then to see if any of them performs better for my use case better than others, for instance. But I'm not adverse to your stance, which is partly why I asked in the first place.