This page is about ways to browse the kill ring, choosing a kill to yank.

Browsing the Kill Ring

Use Edit -> Paste from Kill Menu

A quite simple standard way to browse and select the first couple of kill ring items is to use Edit → Paste from Kill Menu. In Emacs 24, F10 will open the menu bar, either the graphical one if the menu bar is enabled, or the textual one. Regardless of which one that opens you can navigate the first couple of kill ring items using your keyboard. – MaDa

Using the information from the standard paste menu

Similar to browse-kill-ring – makes it easy to access and yank text from the kill ring:

       (global-set-key "\C-cy" '(lambda ()
                                 (popup-menu 'yank-menu)))


browse-kill-ring.el – a package by ColinWalters, and later maintained by Nick Hurley. You can get it here:


browse-kill-ring+.el – Enhancements to browse-kill-ring.el.


Helm has build-in support for browsing the kill-ring when `helm-mode` is enabled.


Icicles – You can clean up the ring selectively during completion, deleting entries on the fly. And you can sort completions in various ways. All Icicles completion features are available, including progressive completion. Two ways:


Browse kill ring with InteractivelyDoThings, using kill-ring-ido.el.


KillRingSearch – incremental search of the kill ring


popup-kill-ring.el – interactively insert item from kill-ring


view-kill.el – Displays the entire kill ring as a menu.


wuxch-browse-kill-ring.el – key bindings, customization

Yet another way...

Yet another way to get access to the kill ring with completion. Let Anything, Icicles, Ido or any other library that customizes ‘completing-read’ do the rest:

         (defun konix/kill-ring-insert ()
           (let ((to_insert (completing-read "Yank : "
                                            (delete-duplicates kill-ring :test #'equal))))
            (when (and to_insert (region-active-p))
              ;; the currently highlighted section is to be replaced by the yank
              (delete-region (region-beginning) (region-end)))
            (insert to_insert)))

Using Anything

Similar function with Anything, a candidate selection framework. Start with ‘M-x anything-show-kill-ring’, narrow the list by typing some patterns(multiple patterns are space-delimited string), select with up/down/pgup/pgdown/C-p/C-n/C-v/M-v, choose with enter to insert an element of ‘kill-ring’.


I can’t praise browse-kill-ring enough – I don’t use it all that much, but when I need it there’s no replacing it. – Anonymous

Someone once said “The easiest way to invoke kill-ring browsing is just to use ‘M-y’ without first using ‘C-y’”. But when I try that (with Emacs 22) I just get “Previous command was not a yank”.

To get the “M-y immediately pulls up the kill ring” behavior, you need to run M-x browse-kill-ring-default-keybindings. Or, to put this in .emacs

 (require 'browse-kill-ring)

Here’s a “poor man’s kill-ring-browser”:

    (defun yank-browse (string)
      "Browse the `kill-ring' to choose which entry to yank."
       (minibuffer-with-setup-hook #'minibuffer-completion-help
         (let* ((kills (delete-dups (append kill-ring-yank-pointer kill-ring nil)))
                 (mapcar (lambda (string)
                           (let ((pos 0))
                             ;; FIXME: Maybe we should start by removing
                             ;; all properties.
                             (setq string (copy-sequence string))
                             (while (string-match "\n" string pos)
                               ;; FIXME: Maybe completion--insert-strings should
                               ;; do that for us.
                                (match-beginning 0) (match-end 0)
                                'display (eval-when-compile
                                           (propertize "\\n" 'face 'escape-glyph))
                               (setq pos (match-end 0)))
                             ;; FIXME: We may use the window-width of the
                             ;; wrong window.
                             (when (>= (* 3 (string-width string))
                                       (* 2 (window-width)))
                               (let ((half (- (/ (window-width) 3) 1)))
                                 ;; FIXME: We're using char-counts rather than
                                 ;; width-count.
                                  half (- (length string) half)
                                  'display (eval-when-compile
                                             (propertize "……" 'face 'escape-glyph))
                (table (lambda (string pred action)
                          ((eq action 'metadata)
                           '(metadata (category . kill-ring)))
                           (complete-with-action action entries string pred))))))
           ;; FIXME: We should return the entry from the kill-ring rather than
           ;; the entry from the completion-table.
           ;; FIXME: substring completion doesn't work well because it only matches
           ;; subtrings before the first \n.
           ;; FIXME: completion--insert-strings assumes that boundaries of
           ;; candidates are obvious enough, but with kill-ring entries this is not
           ;; true, so we'd probably want to display them with «...» around them.
           (list (completing-read "Yank: " table nil t)))))
      (setq this-command 'yank)
      (insert-for-yank string))

I adapted popup-kill-ring to replace a potential previous yank like the default M-y does (yank-pop).

diff --git a/libs/popup-kill-ring.el b/libs/popup-kill-ring.el
--- a/libs/popup-kill-ring.el
+++ b/libs/popup-kill-ring.el
@@ -280,6 +280,8 @@ and `pos-tip.el'"
                                            :scroll-bar t
                                            :isearch popup-kill-ring-isearch))
                    (when item
+                     (when (or (eq last-command 'cua--paste-rectangle) (eq last-command 'yank))
+                       (undo))
                      (setq num (popup-kill-ring-get-index item))
                      (when num
                        (let ((kill-ring-item (nth num kill-ring)))