How many of you switched from ivy/counsel or helm to vertico/consult?

How many of you switched from ivy/counsel or helm to vertico/consult? I have been using Ivy/Counsel for past 4 years and have been hearing great things about vertico/consult/embark. What do you recommend ? Is it worth it?

I've been using Helm for many years, then switched to Ivy for at least as much with a brief Ido period in-between. Almost two years ago I switched to Selectrum which I then proceeded to replace with Vertico (both are very similar). Used alongside Embark, Consult, Orderless and Marginalia of course. While deciding between Helm and Ivy was hard as both had their advantages, I consider my current stack the best of them all. I don't feel like I'm missing anything from any of my past setups, especially due to Embark being as flexible as it is. For the record, [my config is available here](https://codeberg.org/vifon/emacs-config/src/branch/master/emacs.d/lisp/20-completing-read.el) if you'd like to borrow parts of it. TL;DR: Yep, go for it!

My experiences mirror those of /u/vifon quite closely. I found migrating from Helm to Ivy to be a bit of a chore and it made me reluctant to explore Selectrum, and later Vertico et. al. But it was actually a breeze to set up, despite it being 4 or 5 packages instead of one. The tricky bit was just conceptually understanding what packages were actually responsible for what capabilities and where the boundaries between, say, vertico and consult lie. The biggest advantage, however, is that the modularity makes configuration and extension much easier. I also find the stack to be more universal as it's all based on completing-read. There are very few cases where I'd expect vertico and consult to be appropriate that they aren't automatically controlling selections. I'm not one to care at all about if a package is 'lightweight' or to worry too much about bloat. But the performance, reliability, and configurability of vertico, consult, orderless, emark, and marginalia is hard to beat. Other easily assimilated tools like corfu and ctrlf demonstrate the nice extensibility and I suspect the philosophy of small, simple packages that extend the stack to become more and more common.

Yeah. Vertico with its multiform mode let me throw out hundreds of lines of fragile hackery that cobbled together the best parts of Helm and Ivy and Selectrum. Though those are all good pieces of software and paved the way for good completion in Emacs, Vertico is the first system that truly feels done right. Tremendous flexibility combined with plenty of power and UI and UX niceness. If you rely on very specific features of Helm, like tightly-coupled Helm packages, you may still want to keep it around. The Vertico ecosystem has solid replacements for most things, though.

I did and I don't regret it. More and more, when I install third-party packages, I prefer those that augment the existing Emacs infrastructure to those creating their isolated sandboxes.

Wow! This could have been my reply

I'll probably switch when my distro packages them, for now I'm still using ivy & counsel for convenience. I'd rather be using the ones that better integrate with Emacs' built-ins though.

To be honest - all of them are doing basically the same thing. Used vertico but had to switch to ivy because I had to use emacs 26 (not supported by vertico) … I don’t see any advantage / disadvantage apart from ivy being much faster with tramp and less configuration required - in general ivy is very mature. I don’t think agonising over which completion framework to use is time well spent.

I switched because Doom Emacs switched. There's still the option to use Ivy and Helm though. The `vertico` module on Doom Emacs contains the following packages: - consult - consult-flycheck - embark - embark-consult - marginalia - orderless - vertico - vertico-posframe - wgrep I don't think I'd wanna use it on my own, seems complicated having to integrate so many different packages to achieve the same workflows I had before. I wouldn't wanna do it myself.

I love the neat integration between vertico/consult/embark. A simple practical example: when you open "M-x menu" and type for a command, not only you can run the command at point, but also: - you can use Embark to open `describe-symbol`; - jump to the source code of the command; - export all the filtered items into an apropos buffer (where it would show the commands with their values and properties); - copy the selected item into a kill-ring, or - insert it into the current buffer; - etc. And the stuff works similarly for other things - grepping for something in the project? You still can export the results into a standalone buffer, insert or kill the thing at point. Spend some time learning how these packages work, I promise, there will be no regrets.

I'm actually really curious what benefits people found over helm or ivy. I swapped from ivy a few months ago, tried it for about a month, then ultimately switched back. IIRC, my main issues were one missing ivy function that I used a lot that I couldn't easily replicate (can't remember specifically what it was at this point), plus some performance issues with my work repo. Vertico + friends sound really interesting, it just didn't make sense for me at the time

I did, I find it snappier and more modular than something like ivy

I switched and I like it. I had it set up in my regular config, switched to Doom, and then switched back. Here's my config for it. It's probably sloppy (and mostly just from their respective documentation) and anybody could do better, but maybe it will help. ``` ** Completion framework *** COMMENT Simple ido framework #+begin_src emacs-lisp (setq ido-enable-flex-matching t) (fido-vertical-mode 1) #+end_src *** SMOCE The SMOCE stack (Selectrum, Marginalia, Orderless, Consult, Embark) as mentioned on Reddit (https://www.reddit.com/r/emacs/comments/ppg98f/which_completion_framework_do_you_use_and_why/). Pretty nice video describing some of these things: https://www.youtube.com/watch?v=43Dg5zYPHTU **** Selectrum #+begin_src emacs-lisp (selectrum-mode +1) #+end_src This section will make the keybindings when I'm in the completion framework better suit my needs. The default has the delete key moving back one character and C-delete will delete the word. C-M-delete will delete up to the parent directory. I didn't want this. I like delete to delete contents up to parent, M-delete will delete a word and C-delete will delete a character. Seems to be working well so far! #+begin_src emacs-lisp (with-eval-after-load 'selectrum (define-key selectrum-minibuffer-map (kbd "DEL") 'delete-backward-char) (define-key selectrum-minibuffer-map (kbd "M-DEL") 'backward-kill-word) (define-key selectrum-minibuffer-map (kbd "C-<backspace>") 'selectrum-backward-kill-sexp)) #+end_src **** COMMENT Vertico #+begin_src emacs-lisp (vertico-mode +1) #+end_src **** Orderless #+begin_src emacs-lisp (setq completion-styles '(orderless)) ;; Persist history over Emacs restarts (savehist-mode) ;; Optional performance optimization ;; by highlighting only the visible candidates. (setq orderless-skip-highlighting (lambda () selectrum-is-active)) (setq selectrum-highlight-candidates-function #'orderless-highlight-matches) #+end_src **** Marginalia #+begin_src emacs-lisp (marginalia-mode 1) #+end_src **** Consult #+begin_src emacs-lisp (global-set-key (kbd "C-c h") 'consult-org-heading) (global-set-key (kbd "C-x b") 'consult-buffer) (global-set-key (kbd "C-x r b") 'consult-bookmark) #+end_src **** Embark This allows you to take actions on certain things. #+begin_src emacs-lisp (global-set-key (kbd "C-.") 'embark-act) #+end_src ```

I didn't switch: I went from `ido` to `ivy` years ago and have never felt the need to switch again.

every year someone is changing from ivy to selectrum, to vertico, to helm etc and each new year there is a new icomplete "alternative" but the truth is that all those are really the same, maybe the one that is different is somepoint is helm, but icomplete + fido-mode with all the internal emacs built-in completion mechanism if enough and pretty customizable and you don't need to install a lot of external package. &#x200B; for me icomplete + fido-mode was the easier to setup. not external dependencies and pretty customizable and work will all major modes &#x200B; [https://www.gnu.org/software/emacs/manual/html\_node/emacs/Icomplete.html](https://www.gnu.org/software/emacs/manual/html_node/emacs/Icomplete.html) https://www.youtube.com/watch?v=vtwYIKUZwEM

My thoughts exactly after trying the packages today. Will keep using embark though

I've struggled to grok the outlines of the completion frameworks in Emacs. Would you mind sharing the pages or documentation that helped you gain that understanding?

I have a simple question. I see that you remapped yank-pop to consult-yank-pop. I did the same but with counsel when using its version of yank-pop the next time I'd call it the first choice would be the one I selected previously. Do you have this same behaviour with your config or doesn't it bother you to have consult-yank-pop defaulting to the last killed selection?

I might try the alternatives one day if I feel going the config rabbit hole again, but frankly, Helm just works.

No, it always starts on the last killed selection. Now that you mention it, the behavior you describe would be more consistent with how `yank` works in general, though I think I prefer the current one.

Ah, too bad, I hoped someone had a solution to make it work the way I like it :-(

fido-mode is really awesome, but I can't get it to complete tramp hosts. Vertico works just fine with that. Haven't had much time to look into why, but if I can get that fixed then it's back to fido-mode

This! I also consider going back to the basics and leveraging the built-in packages. However, I'm using ivy now. I kinda like the partial completion with TAB and that completion buffer to not appear at all. Ofc there should be a way to configure this behavior in icomplete and fido-mode.

Try raising it with the upstream. It might be a worthwhile option, considering it would be more consistent.

Yeah, embark looked great. I don’t think I was anywhere close to getting the most out of that package

I still use ivy, it just works, and I don't want to be an alpha (or even beta) tester

Ever used ivy before?

I wrote about ivy/counsel compared to Verizon/consult/marginalia/embark/orderless here: https://reddit.com/r/emacs/comments/qfrxgb/_/hi6mfh7/?context=1

I used both Helm and Ivy before switching to vertico/consult/embark stack. I was a huge fan of Helm, but one day some update broke it and it became very sluggish. I didn't have time to figure out what broke it, and I thought: "I'll just switch to Ivy in the meantime..." Ivy felt so much faster. Later, that issue with Helm was fixed by the maintainers, but the noticeable difference in performance made me want to learn Ivy more. For a while, I kept using both Ivy and Helm - Ivy for the main stuff, Helm for things that I haven't figured out yet. When I heard everyone discussing @minad packages and how good they are, I felt like: "nah, it's just hype. Ivy is working great for me.." Then one day I was helping a friend with his config and had to install chemacs2, so I could compare my config with his. And since I could run multiple, different profiles, I thought to try out Doom. Out of curiosity, instead of choosing Ivy this time, I went with @minad's stack - Doom makes it so easy to switch between completion frameworks. I love both - Doom and @minad's stack.

Main advantage at least to me is I wouldn't have to remove and forget all my existing commands if a new ui package comes around. Helm had a bunch of consult like commands but specific to helm. Counsel had a bunch of consult like commands but specific to ivy. Consult has a bunch of commands that should work consistently independent of which ui choice you make (selectrum, vertico, even vido should work). Decoupling these things is for the better IMO. Reduces the load on each of the developers to have to maintain so much related stuff and makes it more of a priority to make each independent thing more configurable (cause they have to fit and work together) giving users more control. Edit: to clarify if tomorrow I decide to ditch vertico for new ui X, I don't then have to rebind all my consult commands or adapt them for x. They should ideally work both with the old and new uis.

I've been using Ido-mode for more than 15 years and have been hardly tempted by new alternatives

I'm not sure exactly what you're asking for, but here's a shot: I think a good place to start is to read the documentation for `completing-read` and play with some very simple examples, like put this in some elisp buffer: (completing-read "Animals: " '(cat dog walrus)) And see what happens when eval that if you have vertico-mode on or off. So you'll sort of get the sense that vertico (or selectrum) are for displaying possible completions from a completing-read. Without it, you can't explore the options, but you can still enter the first character and tab-complete them. But that's just for minibuffer completions. If you want completion in a regular buffer, generally prompted by a "TAB" you'd use `company` or maybe `corfu`. So then the question is: where the the completion options come from? Part of the answer is determined by the completion style, which the emacs docs describe as a set of rules for generating completions. Orderless and Prescient are examples. They will filter down a large list of possible completions based on certain criteria. Consult provides further tools to generate and combine lists for different purposes, as well as previewing selections as you cycle through them. So for example, if you have several themes downloaded, `consult-theme` can identify that and provide you with a completion list of the names of those themes. It also "does what you mean" when you select an option. So again, for `consult-theme`, it knows that if you select a theme from the list, it should disable any other active theme and enable the selected one, instead of just returning the selection as normal. Marginalia just adds some flair to the completion UI (vertico/selectrum) to show some documentation about each option. Embark is a bit of a separate thing entirely that is somewhat independent to, but plays well with, completions. It basically lets you call a context-aware function and enter the object you've selected as the argument to that function. So if you've selected a symbol in an elisp buffer, Embark would offer you various functions to run that can accept a symbol as an argument. I'll often use it to look up the documentation for functions, variables and so on for the currently-selected completion in a minibuffer.

That was an awesome comment! Thanks for the comparison. Does it have anything like prescient that lets you order candidates based on frequency? https://melpa.org/#/ivy-prescient

I just declared config bankruptcy recently and moved from ivy to v/c. It's too early to say whether I like it or not but I needed to get away from ivy's internal jank before I got too tied up with it. I did run into some issues with citar but that's a separate thing I think

I switched from ivy a while back, mostly working fine, tbh not feeling much of differences. But I miss ivy-resume so much, and I found most of the consult extension packages aren't mutual enough, sometimes buggy.

Still use ivy. It's unusable for me before these ivy alternatives can tell apart differenct candidates with same name. As an example, you can see how cousult-imenu deals with duplicated names by adding a counter at the end of them.

I was a selectrum/prescient user and I thought I'd miss it, but it turns out I don't. It turns out the standard `savehist-mode` has been close enough for me. The good news is that there's some work to [turn prescient into a real completion-style](https://github.com/radian-software/prescient.el/pull/125) so that it could be integrated easily. There is a note in the [vertico wiki on using prescient](https://github.com/minad/vertico/wiki#using-prescientel).

I've switched from Ivy recently because I like the cleaner and simpler interface. What bothered me most about Ivy was that paths were somehow special and couldn't be edited from the prompt. I also love the extended info you get from marginalia. You have to note though that, while it may seem vertico/consult/... are a nearly feature-complete replacement for Ivy/HELM, they're lacking in a few departments and aren't as easy to customise. One example is restoring a project-wide search session where it'll restore the prompt but not the position. Little things like these.

Doom Emacs swapped it to be the default pretty much straight after it was added in, and has also inspired many other vanilla users to do the same (my private config also uses what I refer to as the VEMCO stack (vertico, embark, marginalia, consult and orderless)) Any package made by /u/oantolin or minad (not sure if he has a reddit handle) is a guarantee of quality

I switch from helm to consult+vertico last year, thanks to System Crafters video

[deleted]

> I'm actually really curious what benefits people found over helm or ivy. Mainly I've found vertico & co. to be much faster. But it's also much simpler and has a less cluttered UI. It also feels more customizable because each piece of functionality is just a separate package that you can enable or disable.

It was very helpful!

They are considerably more efficient. Mostly you won't notice, but, at least last I checked, helm played very poorly with TRAMP.

That's a great point. I think I gave up on tramp entirely a few years back because of this, but if I could swap to vertico + friends and use tramp again that's a huge win

Yep, this is exactly why i've ended up switching to Vertico et al. It wasn't that Ivy wasn't doing the job functionality-wise - it totally was - but that i get a better completion mechanism 'for free' with an arbitrary package.

I don’t think there is any objective evidence that it is faster though