M-x helm-documentation

Table of Contents

Next:   [Contents]

M-x helm-documentation

Next: , Previous: , Up: Top   [Contents]

1 Helm Generic Help

Next: , Up: Helm Generic Help   [Contents]

1.1 Basics

Helm narrows down the list of candidates as you type a filter pattern. See Matching in Helm.

Helm accepts multiple space-separated patterns, each pattern can be negated with ‘!’.

Helm also supports fuzzy matching in some places when specified, you will find several variables to enable fuzzy matching in diverse sources.

Helm generally uses familiar Emacs keys to navigate the list. Here follow some of the less obvious bindings:

Note: In addition to the default actions list, additional actions appear depending on the type of the selected candidate(s). They are called filtered actions.

Additional Readings:

Fuzzy Matching


Helm Completion vs Emacs Completion


Next: , Previous: , Up: Helm Generic Help   [Contents]

1.2 Helm sources

Helm uses what’s called sources to provide different kinds of completions. Each Helm session can handle one or more source. A source is an alist object which is build from various classes, see here.

Additional Readings:

Creating a Helm source


Up: Helm sources   [Contents]

1.2.1 Configure sources

You will find in Helm sources already built and bound to a variable called generally helm-source-<something>. In this case it is an alist and you can change the attributes (keys) values using helm-set-attr function in your configuration. Of course you have to ensure before calling helm-set-attr that the file containing source is loaded, e.g. with with-eval-after-load. Of course you can also completely redefine the source but this is generally not elegant as it duplicate for its most part code already defined in Helm.

You will find also sources that are not built and even not bound to any variables because they are rebuilded at each start of a Helm session. In this case you can add a defmethod called helm-setup-user-source to your config:

(cl-defmethod helm-setup-user-source ((source helm-moccur-class))
  (setf (slot-value source ’follow) -1))

Additional Readings:

Helm FAQ: Why is a customizable helm source nil


Complex Examples Of Configuration


Next: , Previous: , Up: Helm Generic Help   [Contents]

1.3 Modify keybindings in Helm

Helm main keymap is helm-map, all keys bound in this map apply to all Helm sources. However, most sources have their own keymap, with each binding overriding its counterpart in helm-map, you can see all bindings in effect in the Commands section (available only if the source has its own keymap and documentation of course).

Next: , Previous: , Up: Helm Generic Help   [Contents]

1.4 Matching in Helm

All that you write in minibuffer is interpreted as a regexp or multiple regexps if separated by a space. This is true for most sources unless the developer of the source has disabled it or have choosen to use fuzzy matching. Even if a source has fuzzy matching enabled, Helm will switch to multi match as soon as it detects a space in the pattern. It may also switch to multi match as well if pattern starts with a ‘^’ beginning of line sign. In those cases each pattern separated with space should be a regexp and not a fuzzy pattern. When using multi match patterns, each pattern starting with ‘!’ is interpreted as a negation i.e. match everything but this.

Up: Matching in Helm   [Contents]

1.4.1 Completion-styles

Helm generally fetches its candidates with the :candidates function up to helm-candidate-number-limit and then applies match functions to these candidates according to helm-pattern. But Helm allows matching candidates directly from the :candidates function using its own completion-styles. Helm provides ’helm completion style but also ’helm-flex completion style for Emacs<27 that don’t have ’flex completion style, otherwise (emacs-27) ’flex completion style is used to provide fuzzy aka flex completion. By default, like in Emacs vanilla, all completion commands (e.g., completion-at-point) using completion-in-region or completing-read use completion-styles. Some Helm native commands like helm-M-x do use completion-styles. Any Helm sources can use completion-styles by using :match-dynamic slot and building their :candidates function with helm-dynamic-completion.


(helm :sources (helm-build-sync-source "test"
                 :candidates (helm-dynamic-completion
                              ’(foo bar baz foab)
                 :match-dynamic t)
      :buffer "*helm test*")

By default Helm sets up completion-styles and always adds ’helm to it. However the flex completion styles are not added. This is up to the user if she wants to have such completion to enable this. As specified above use ’flex for emacs-27 and ’helm-flex for emacs-26. Anyway, ’helm-flex is not provided in completion-styles-alist if ’flex is present.

Finally Helm provides two user variables to control completion-styles usage: helm-completion-style and helm-completion-syles-alist. Both variables are customizable. The former allows retrieving previous Helm behavior if needed, by setting it to helm or helm-fuzzy, default being emacs which allows dynamic completion and usage of completion-styles. The second allows setting helm-completion-style per mode and also specifying completion-styles per mode (see its docstring). Note that these two variables take effect only in helm-mode i.e. in all that uses completion-read or completion-in-region, IOW all helmized commands. File completion in read-file-name family doesn’t obey completion-styles and has its own file completion implementation. Native Helm commands using completion-styles doesn’t obey helm-completion-style and helm-completion-syles-alist (e.g., helm-M-x).

Also for a better control of styles in native Helm sources (not helmized by helm-mode) using :match-dynamic, helm-dynamic-completion provides a STYLES argument that allows specifying explicitely styles for this source.

Note: Some old completion styles are not working fine with Helm and are disabled by default in helm-blacklist-completion-styles. They are anyway not useful in Helm because ’helm style supersedes these styles.

Next: , Previous: , Up: Helm Generic Help   [Contents]

1.5 Helm mode

helm-mode toggles Helm completion in native Emacs functions, so when you turn helm-mode on, commands like switch-to-buffer will use Helm completion instead of the usual Emacs completion buffer.

Next: , Up: Helm mode   [Contents]

1.5.1 What gets or does not get ‘helmized’ when helm-mode is enabled?

Helm provides generic completion on all Emacs functions using completing-read, completion-in-region and their derivatives, e.g. read-file-name. Helm exposes a user variable to control which function to use for a specific Emacs command: helm-completing-read-handlers-alist. If the function for a specific command is nil, it turns off Helm completion. See the variable documentation for more infos.

Next: , Previous: , Up: Helm mode   [Contents]

1.5.2 Helm functions vs helmized Emacs functions

While there are Helm functions that perform the same completion as other helmized Emacs functions, e.g. switch-to-buffer and helm-buffers-list, the native Helm functions like helm-buffers-list can receive new features that allow marking candidates, have several actions, etc. Whereas the helmized Emacs functions only have Helm completion, Emacs can provide no more than one action for this function. This is the intended behavior.

Generally you are better off using the native Helm command than the helmized Emacs equivalent.

Previous: , Up: Helm mode   [Contents]

1.5.3 Completion behavior with Helm and completion-at-point

Helm is NOT completing dynamically. That means that when you are completing some text at point, completion is done against this text and subsequent characters you add AFTER this text. This allows you to use matching methods provided by Helm, that is multi matching or fuzzy matching (see Matching in Helm).

Completion is not done dynamically (against helm-pattern) because backend functions (i.e. competion-at-point-functions) are not aware of Helm matching methods.

By behaving like this, the benefit is that you can fully use Helm matching methods but you can’t start a full completion against a prefix different than the initial text you have at point. Helm warns you against this by colorizing the initial input and sends a user-error message when trying to delete backward text beyond this limit at first hit on DEL. A second hit on DEL within a short delay (1s) quits Helm and delete-backward char in current-buffer.

Next: , Previous: , Up: Helm Generic Help   [Contents]

1.6 Helm help

C-x c h h: Show all Helm documentations concatenated in one org file.

From a Helm session, just hit C-h m to have the documentation for the current source followed by the global Helm documentation.

While in the help buffer, most of the Emacs regular key bindings are available; the most important ones are shown in minibuffer. However, due to implementation restrictions, no regular Emacs keymap is used (it runs in a loop when reading the help buffer). Only simple bindings are available and they are defined in helm-help-hkmap, which is a simple alist of (key . function). You can define or redefine bindings in help with helm-help-define-key or by adding/removing entries directly in helm-help-hkmap. See helm-help-hkmap for restrictions on bindings and functions.

The documentation of default bindings are:

KeyAlternative keysCommand
C-vSpace nextScroll up
M-vb priorScroll down
C-sIsearch forward
C-rIsearch backward
C-aBeginning of line
C-eEnd of line
C-frightForward char
C-bleftBackward char
C-ndownNext line
C-pupPrevious line
M-aBackward sentence
M-eForward sentence
M-fForward word
M-bBackward word
M->End of buffer
M-<Beginning of buffer
C-<SPACE>Toggle mark
C-M-SPACEMark sexp
RETFollow org link
C-%Push org mark
C-&Goto org mark-ring
TABOrg cycle
M-<TAB>Toggle visibility
M-wCopy region

Next: , Previous: , Up: Helm Generic Help   [Contents]

1.7 Customize Helm

Helm provides a lot of user variables for extensive customization. From any Helm session, type C-h c to jump to the current source custom group. Helm also has a special group for faces you can access via M-x customize-group RET helm-faces.

Note: Some sources may not have their group set and default to the helm group.

Next: , Previous: , Up: Helm Generic Help   [Contents]

1.8 Display Helm in windows and frames

You can display the Helm completion buffer in many different window configurations, see the custom interface to discover the different windows configurations available (See Customize Helm to jump to custom interface). When using Emacs in a graphic display (i.e. not in a terminal) you can as well display your Helm buffers in separated frames globally for all Helm commands or separately for specific Helm commands. See helm-display-function and helm-commands-using-frame.

There is a variable to allow reusing frame instead of deleting and creating a new one at each session, see helm-display-buffer-reuse-frame. Normally you don’t have to use this, it have been made to workaround slow frame popup in Emacs-26, to workaround this slowness in Emacs-26 use instead

(when (= emacs-major-version 26)
  (setq x-wait-for-event-timeout nil))

Additional Readings:

Warning: There is a package called posframe and also one called helm-posframe, you DO NOT need these packages to display helm buffers in frames.

Next: , Previous: , Up: Helm Generic Help   [Contents]

1.9 Helm’s basic operations and default key bindings

KeyAlternative KeysCommand
C-pUpPrevious line
C-nDownNext line
M-vpriorPrevious page
C-vnextNext page
Enter1Execute first (default) action / Select [1]
M-<First line
M->Last line
C-M-S-vM-prior, C-M-yPrevious page (other-window)
C-M-vM-nextNext page (other-window)
TabC-iShow action list
M-oleftPrevious source
C-orightNext source
C-k2Delete pattern (with prefix arg delete from point to end or all [2])
C-jPersistent action (Execute and keep Helm session)

Note: Any of these bindings are from helm-map and may be overriten by the map specific to the current source in use (each source can have its own keymap).

Next: , Previous: , Up: Helm Generic Help   [Contents]

1.10 The actions menu

You can display the action menu in the same window as helm candidates (default) or in a side window according to helm-show-action-window-other-window value.

When the action menu popup, the helm prompt is used to narrow down this menu, no more candidates.

When helm-allow-mouse is non nil, you can use as well mouse-3 (right click) in the candidate zone to select actions with the mouse once your candidate is selected.

Next: , Previous: , Up: Helm Generic Help   [Contents]

1.11 Action transformers

You may be surprized to see your actions list changing depending on the context. This happen when a source has an action transformer function which checks the current selected candidate and adds specific actions for this candidate.

Next: , Previous: , Up: Helm Generic Help   [Contents]

1.12 Shortcuts for n-th first actions

<f1><f12>: Execute n-th action where n is 1 to 12.

Next: , Previous: , Up: Helm Generic Help   [Contents]

1.13 Shortcuts for executing the default action on the n-th candidate

Helm does not display line numbers by default, with Emacs-26+ you can enable it permanently in all helm buffers with:

(add-hook ’helm-after-initialize-hook ’helm-init-relative-display-line-numbers)

You can also toggle line numbers with C-c l in current Helm buffer.

Of course when enabling global-display-line-numbers-mode Helm buffers will have line numbers as well. (Don’t forget to customize display-line-numbers-type to relative).

In Emacs versions < to 26 you will have to use linum-relative3 package and helm-linum-relative-mode.

Then when line numbers are enabled with one of the methods above the following keys are available4:

C-x <n>: Execute default action on the n-th candidate before currently selected candidate.

C-c <n>: Execute default action on the n-th candidate after current selected candidate.

n’ is limited to 1-9. For larger jumps use other navigation keys.

Next: , Previous: , Up: Helm Generic Help   [Contents]

1.14 Mouse control in Helm

A basic support for the mouse is provided when the user sets helm-allow-mouse to non-nil.

Note: When mouse control is enabled in Helm, it also lets you click around and lose the minibuffer focus: you’ll have to click on the Helm buffer or the minibuffer to retrieve control of your Helm session.

Next: , Previous: , Up: Helm Generic Help   [Contents]

1.15 Marked candidates

You can mark candidates to execute an action on all of them instead of the current selected candidate only. (See bindings below.) Most Helm actions operate on marked candidates unless candidate-marking is explicitely forbidden for a specific source.

Note: When multiple candidates are selected across different sources, only the candidates of the current source will be used when executing most actions (as different sources can have different actions). Some actions support multi-source marking however.

Next: , Previous: , Up: Helm Generic Help   [Contents]

1.16 Follow candidates

When helm-follow-mode is on (C-c C-f to toggle it), moving up and down Helm session or updating the list of candidates will automatically execute the persistent-action as specified for the current source.

If helm-follow-mode-persistent is non-nil, the state of the mode will be restored for the following Helm sessions.

If you just want to follow candidates occasionally without enabling helm-follow-mode, you can use C-<down> or C-<up> instead. Conversely, when helm-follow-mode is enabled, those commands go to previous/next line without executing the persistent action.

Next: , Previous: , Up: Helm Generic Help   [Contents]

1.17 Frequently Used Commands

C-tToggle vertical/horizontal split on first hit and swap Helm window on second hit.
C-c %Exchange minibuffer and header-line.
C-x C-fDrop into ‘helm-find-files’.
C-c C-kKill display value of candidate and quit (with prefix arg, kill the real value).
C-c C-yYank current selection into pattern.
C-c TABCopy selected candidate at point in current buffer.
C-c C-fToggle automatic execution of persistent action.
C-<down>Run persistent action then select next line.
C-<up>Run persistent action then select previous line.
C-c C-uRecalculate and redisplay candidates.
C-!Toggle candidate updates.

Next: , Previous: , Up: Helm Generic Help   [Contents]

1.18 Special yes, no or yes for all answers

You may be prompted in the minibuffer to answer by [y,n,!,q] in some places for confirmation.

When using ! you will not be prompted for the same thing in current operation any more, e.g. file deletion, file copy etc…

Next: , Previous: , Up: Helm Generic Help   [Contents]

1.19 Moving in helm-buffer

You can move in helm-buffer with the usual commands used in Emacs: (C-n, C-p, etc. See above basic commands. When helm-buffer contains more than one source, change source with C-o and M-o.

Note: When reaching the end of a source, C-n will not go to the next source when variable helm-move-to-line-cycle-in-source is non-nil, so you will have to use C-o and M-o.

Next: , Previous: , Up: Helm Generic Help   [Contents]

1.20 Resume previous session from current Helm session

You can use C-c n (helm-run-cycle-resume) to cycle in resumables sources. C-c n is a special key set with helm-define-key-with-subkeys which, after pressing it, allows you to keep cycling with further n.

Tip: You can bound the same key in global-map to helm-cycle-resume with helm-define-key-with-subkeys to let you transparently cycle sessions, Helm fired up or not. You can also bind the cycling commands to single key presses (e.g., S-<f1>) this time with a simple define-key. (Note that S-<f1> is not available in terminals.)

Note: helm-define-key-with-subkeys is available only once Helm is loaded.

You can also use C-x b to resume the previous session, or C-x C-b to have completion on all resumable buffers.

Next: , Previous: , Up: Helm Generic Help   [Contents]

1.21 Global commands

Up: Global commands   [Contents]

1.21.1 Resume Helm session from outside Helm

C-x c b revives the last Helm session. Binding a key to this command will greatly improve Helm interactivity, e.g. when quitting Helm accidentally.

You can call C-x c b with a prefix argument to choose (with completion!) which session you’d like to resume. You can also cycle in these sources with helm-cycle-resume (see above).

Next: , Previous: , Up: Helm Generic Help   [Contents]

1.22 Debugging Helm

Helm exposes the special variable helm-debug: setting it to non-nil will enable Helm logging in a special outline-mode buffer. Helm resets the variable to nil at the end of each session.

For convenience, C-h C-d allows you to turn on debugging for this session only. To avoid accumulating log entries while you are typing patterns, you can use C-! to turn off updating. When you are ready turn it on again to resume logging.

Once you exit your Helm session you can access the debug buffer with helm-debug-open-last-log. It is possible to save logs to dated files when helm-debug-root-directory is set to a valid directory.

Note: Be aware that Helm log buffers grow really fast, so use helm-debug only when needed.

Next: , Previous: , Up: Helm Generic Help   [Contents]

1.23 Writing your own Helm sources

Writing simple sources for your own usage is easy. When calling the helm function, the sources are added the :sources slot which can be a symbol or a list of sources. Sources can be built with different EIEIO classes depending on what you want to do. To simplify this, several helm-build-* macros are provided. Below there are simple examples to start with.

;; Candidates are stored in a list.
(helm :sources (helm-build-sync-source "test"
                 ;; A function can be used as well
                 ;; to provide candidates.
                 :candidates ’("foo" "bar" "baz"))
      :buffer "*helm test*")

;; Candidates are stored in a buffer.
;; Generally faster but doesn’t allow a dynamic updating
;; of the candidates list i.e the list is fixed on start.
(helm :sources (helm-build-in-buffer-source "test"
                 :data ’("foo" "bar" "baz"))
      :buffer "*helm test*")

Additional Readings:

For source code and complex examples


Previous: , Up: Helm Generic Help   [Contents]

1.24 Helm Map

C-cPrefix Command
C-hPrefix Command
C-xPrefix Command
ESCPrefix Command
<help>Prefix Command
<help> mhelm-help
C-h C-dhelm-enable-or-switch-to-debug
C-h chelm-customize-group
C-h mhelm-help
C-c C-fhelm-follow-mode
C-c TABhelm-copy-to-buffer
C-c C-khelm-kill-selection-and-quit
C-c C-uhelm-refresh
C-c C-yhelm-yank-selection
C-c %helm-exchange-minibuffer-and-header-line
C-c -helm-swap-windows
C-c 1helm-execute-selection-action-at-nth-+1
C-c 2helm-execute-selection-action-at-nth-+2
C-c 3helm-execute-selection-action-at-nth-+3
C-c 4helm-execute-selection-action-at-nth-+4
C-c 5helm-execute-selection-action-at-nth-+5
C-c 6helm-execute-selection-action-at-nth-+6
C-c 7helm-execute-selection-action-at-nth-+7
C-c 8helm-execute-selection-action-at-nth-+8
C-c 9helm-execute-selection-action-at-nth-+9
C-c >helm-toggle-truncate-line
C-c ?helm-help
C-c _helm-toggle-full-frame
C-c lhelm-display-line-numbers-mode
C-c n??
C-x C-bhelm-resume-list-buffers-after-quit
C-x C-fhelm-quit-and-find-file
C-x 1helm-execute-selection-action-at-nth-+1
C-x 2helm-execute-selection-action-at-nth-+2
C-x 3helm-execute-selection-action-at-nth-+3
C-x 4helm-execute-selection-action-at-nth-+4
C-x 5helm-execute-selection-action-at-nth-+5
C-x 6helm-execute-selection-action-at-nth-+6
C-x 7helm-execute-selection-action-at-nth-+7
C-x 8helm-execute-selection-action-at-nth-+8
C-x 9helm-execute-selection-action-at-nth-+9
C-x bhelm-resume-previous-session-after-quit
M-gPrefix Command
M-g ESCPrefix Command
M-<minibuffer-beginning-of-buffer(this binding is currently shadowed)
M-gPrefix Command
M-snext-matching-history-element(this binding is currently shadowed)
M-g ESCPrefix Command
M-g M-chelm-comint-input-ring
M-g M-hhelm-minibuffer-history

Next: , Previous: , Up: Top   [Contents]

2 Helm Buffer

Next: , Up: Helm Buffer   [Contents]

2.1 Pattern matching in helm-buffers

You can filter the buffer list based on one or more of the following components:

  1. buffer’s mode-name
  2. its content
  3. its directory
  4. its name

A buffer match pattern is a space-separated list of one or more directives. Each directive looks like


<pattern-type>’ determines how the ‘<pattern-value>’ is interpreted. ‘<pattern-type>’ can be one of the following:


Partially match ‘<pattern-value>’ against buffer’s mode-name


Partially match ‘<pattern-value>’ against buffer’s contents


Partially match ‘<pattern-value>’ against buffer’s directory


Fuzz-matching. The description of what the pattern does is not clear.

an empty string. Compare ‘<pattern-value>’ against buffer’s name.

<negate-may-be>’ determines the truth value of the match. It can be one of the following:

an empty string. ‘<pattern-value>’ must partially match the corresponding attribute


Negate the sense of above match.


Down below you see some common patterns, and how they are interpreted:

Next: , Previous: , Up: Helm Buffer   [Contents]

2.2 Tips

Creating buffers

When creating a new buffer, use C-u to choose a mode from a list. This list is customizable, see helm-buffers-favorite-modes.

Killing buffers

You can kill buffers either one by one or all the marked buffers at once.

One kill-buffer command leaves Helm while the other is persistent. Run the persistent kill-buffer command either with the regular helm-execute-persistent-action called with a prefix argument (C-u C-j) or with its specific command helm-buffer-run-kill-persistent. See the bindings below.

Switching to buffers

To switch to a buffer, press RET, to switch to a buffer in another window, select this buffer and press C-c o, when called with a prefix arg the buffer will be displayed vertically in other window. If you mark more than one buffer, the marked buffers will be displayed in different windows.

Saving buffers

If buffer is associated to a file and is modified, it is by default colorized in orange, see Meaning of colors and prefixes for buffers. You can save these buffers with C-x C-s. If you want to save all these buffers, you can mark them with C-M-SPC and save them with C-x C-s. You can also do this in one step with C-x s. Note that you will not be asked for confirmation.

Meaning of colors and prefixes for buffers

Remote buffers are prefixed with ’@’.


Buffer’s file was modified on disk by an external process.


Buffer exists but its file has been deleted.


Buffer is modified and not saved to disk.


A non-file buffer.


Tramp archive buffer.

Previous: , Up: Helm Buffer   [Contents]

2.3 Commands

M-g sGrep Buffer(s) works as zgrep too (‘C-u’ to grep all buffers but non-file buffers).
C-sMulti-Occur buffer or marked buffers (‘C-u’ to toggle force-searching current-buffer).
C-c oSwitch to other window.
C-c C-oSwitch to other frame.
C-x C-dBrowse project from buffer.
C-M-%Query-replace-regexp in marked buffers.
M-%Query-replace in marked buffers.
C-c =Ediff current buffer with candidate. With two marked buffers, ediff those buffers.
M-=Ediff-merge current buffer with candidate. With two marked buffers, ediff-merge those buffers.
C-=Toggle Diff-buffer with saved file without leaving Helm.
M-GRevert buffer without leaving Helm.
C-x C-sSave buffer without leaving Helm.
C-x sSave all unsaved buffers.
M-DDelete marked buffers and leave Helm.
C-c dDelete buffer without leaving Helm.
M-RRename buffer.
M-mToggle all marks.
M-aMark all.
C-]Toggle details.
C-c aShow hidden buffers.
C-M-SPCMark all buffers of the same type (color) as current buffer.

Next: , Previous: , Up: Top   [Contents]

3 Helm Find Files

Next: , Up: Helm Find Files   [Contents]

3.1 Overview

Quick pattern expansion

Creating a file or directory:

Helm-find-files supports fuzzy matching

Helm-find-files supports fuzzy matching. Narrowing by fuzzy matching kicks in only when there are atleast 3 characters in the pattern. What this means is this: If you have typed a pattern and do not see any filtering happening when you expect it to happen, do not jump the gun and conclude that fuzzy matching is broken. It is possible that your pattern is shorter than 3 characters, and you may have to type more characters to see the filter at work.

Toggle auto-completion

It is useful when trying to create a new file or directory and you don’t want Helm to complete what you are writing.

Note: On a terminal, the default binding C-<backspace> may not work. In this case use C-c <backspace>.

Use the wildcard to select multiple files

Use of wildcard is supported to run an action over a set of files.

Example: You can copy all the files with ‘.el’ extension by using ‘*.el’ and then run copy action.

Similarly, ‘**.el’ (note the two stars) will recursively select all ‘.el’ files under the current directory.

The ‘**’ feature is active by default in the option helm-file-globstar. It is different from the Bash ‘shopt globstar’ feature in that to list files with a named extension recursively you would write ‘**.el’ whereas in Bash it would be ‘**/*.el’. Directory selection with ‘**/’ like Bash ‘shopt globstar’ option is not supported yet.

Helm supports different styles of wildcards:

Of course in both styles you can specify one or two ‘*’.

Navigation summary

For a better experience you can enable auto completion by setting helm-ff-auto-update-initial-value to non-nil in your init file. It is not enabled by default to not confuse new users.

Filter out files or directories

You can show files or directories only with respectively S-<f4> and S-<f5>. These are toggle commands i.e. filter/show_all. Changing directory disable filtering.

Sort directory contents

When listing a directory without narrowing its contents, i.e. when pattern ends with ‘/’, you can sort alphabetically, by newest or by size by using respectively S-<f1>, S-<f2> or S-<f3>.

Note: When starting back narrowing i.e. entering something in minibuffer after ‘/’ sorting is done again with fuzzy sorting and no more with sorting methods previously selected.

Next: , Previous: , Up: Helm Find Files   [Contents]

3.2 Operate on files

Next: , Up: Operate on files   [Contents]

3.2.1 Create a file or a directory

Next: , Previous: , Up: Operate on files   [Contents]

3.2.2 Open files in separate windows

When marking multiple files (Marked candidates) or using wildcard (Use the wildcard to select multiple files), helm allow opening all this files in separate windows using an horizontal layout or a vertical layout if you used a prefix arg, when no more windows can be displayed in frame, next files are opened in background without being displayed. When using C-c o the current buffer is kept and files are displayed next to it with same behavior as above. When using two prefix args, files are opened in background without beeing displayed.

Next: , Previous: , Up: Operate on files   [Contents]

3.2.3 Open files

  1. Open files externally

Next: , Previous: , Up: Operate on files   [Contents]

3.2.4 Browse images directories with helm-follow-mode and navigate up/down

Before Emacs-27 Helm was using image-dired that works with external ImageMagick tools. From Emacs-27 Helm use native display of images with image-mode by default for Emacs-27 (see helm-ff-display-image-native), this allows automatic resize when changing window size, zooming with M-+ and M-- and rotate images as before.

You can also use helm-follow-action-forward and helm-follow-action-backward with C-<down> and C-<up> respectively. Note that these commands have different behavior when helm-follow-mode is enabled (go to next/previous line only).

Use C-u C-j to display an image or kill its buffer.

Tip: Use C-t and C-{ to display Helm window vertically and to enlarge it while viewing images. Note this may not work with exotic Helm windows settings such as the ones in Spacemacs.

Next: , Previous: , Up: Operate on files   [Contents]

3.2.5 Copy or Rename files

Note that when recursively copying files, you may have files with same name dispatched across different subdirectories, so when copying them in the same directory they will get overwritten. To avoid this Helm has a special action called ‘backup files’ that has the same behavior as the command line “cp -f –backup=numbered”: it allows you to copy many files with the same name from different subdirectories into one directory. Files with same name are renamed as follows: ‘foo.txt.~1~’. Like with the –force option of cp, it is possible to backup files in current directory.

This command is available only when dired-async-mode is active.

See Use the wildcard to select multiple files

  1. Query replace regexp on filenames

    Replace different parts of a file basename with something else.

    When calling this action you will be prompted twice as with query-replace, first for the matching expression of the text to replace and second for the replacement text. Several facilities, however, are provided to make the two prompts more powerfull.

    1. Syntax of the first prompt

      In addition to simple regexps, these shortcuts are available:

      Basename without extension


      Only extension




      Whole basename


    2. Syntax of the second prompt

      In addition to a simple string to use as replacement, here is what you can use:

      • A placeholder refering to what you have selected in the first prompt: ‘\@’.

        After this placeholder you can use a search-and-replace syntax à-la sed:


        You can select a substring from the string represented by the placeholder:

      • A special character representing a number which is incremented: ‘\#’.
      • Shortcuts for upcase, downcase and capitalize are available as=%u=, ‘%d’ and ‘%c’ respectively.
    3. Examples
      1. Recursively rename all files with ‘.JPG’ extension to ‘.jpg

        Use the helm-file-globstar feature described in recursive globbing by entering ‘**.JPG’ at the end of the Helm-find-files pattern, then hit M-@ and enter ‘JPG’ on first prompt, then ‘jpg’ on second prompt and hit RET.

        Alternatively you can enter ‘.%’ at the first prompt, then ‘jpg’ and hit RET. Note that when using this instead of using ‘JPG’ at the first prompt, all extensions will be renamed to ‘jpg’ even if the extension of one of the files is, say, ‘png’. If you want to keep the original extension you can use ‘%d’ at the second prompt (downcase).

      2. Batch-rename files from number 001 to 00x

        Use ‘\#’ inside the second prompt.

        Example 1: To rename the files




        use ‘%.’ as matching regexp and ‘foo-\#’ as replacement string.

        Example 2: To rename the files




        use as matching regexp ‘%.’ and as replacement string ‘\@-\#’.

      3. Replace a substring

        Use ‘%:<from>:<to>’.

        Example: To rename files




        use as matching regexp ‘%:1:2’ and as replacement string ‘%u’ (upcase).

        Note that you cannot use ‘%.’ and ‘.%’ along with substring replacement.

      4. Modify the string from the placeholder (\@)
        • By substring, i.e. only using the substring of the placeholder: ‘\@:<from>:<to>’. The length of placeholder is used for <to> when unspecified.

          Example 1: ‘\@:0:2’ replaces from the beginning to the second char of the placeholder.

          Example 2: \@:2: replaces from the second char of the placeholder to the end.

        • By search-and-replace: ‘\@/<regexp>/<replacement>/’.

          Incremental replacement is also handled in <replacement>.

          Example 3: ‘\@/foo/bar/’ replaces ‘foo’ by ‘bar’ in the placeholder.

          Example 4: ‘\@/foo/-\#/’ replaces ‘foo’ in the placeholder by 001, 002, etc.

      5. Clash in replacements (avoid overwriting files)

        When performing any of these replacement operations you may end up with same names as replacement. In such cases Helm numbers the file that would otherwise overwritten. For instance, should you remove the ‘-m<n>’ part from the files ‘emacs-m1.txt’, ‘emacs-m2.txt’ and ‘emacs-m3.txt’ you would end up with three files named ‘emacs.txt’, the second renaming overwriting first file, and the third renaming overwriting second file and so on. Instead Helm will automatically rename the second and third files as ‘emacs(1).txt’ and ‘emacs(2).txt’ respectively.

      6. Query-replace on filenames vs. serial-rename action

        Unlike the serial rename actions, the files renamed with the query-replace action stay in their initial directory and are not moved to the current directory. As such, using ‘\#’ to serial-rename files only makes sense for files inside the same directory. It even keeps renaming files with an incremental number in the next directories.

  2. Serial renaming

    You can use the serial-rename actions to rename, copy or symlink marked files to a specific directory or in the current directory with all the files numbered incrementally.

    Serial-rename by renaming

    Rename all marked files with incremental numbering to a specific directory.

    Serial-rename by copying

    Copy all marked files with incremental numbering to a specific directory.

    Serial-rename by symlinking

    Symlink all marked files with incremental numbering to a specific directory.

  3. Defining default target directory for copying, renaming, etc

    You can customize helm-dwim-target to behave differently depending on the windows open in the current frame. Default is to provide completion on all directories associated to each window.

  4. Copying/Renaming from or to remote directories

    Never use ssh tramp method to copy/rename large files, use instead its scp method if you want to avoid out of memory problems and crash Emacs or the whole system. Moreover when using scp method, you will hit a bug when copying more than 3 files at the time.5 The best way actually is using Rsync to copy files from or to remote, see Use Rsync to copy files. Also if you often work on remote you may consider using SSHFS instead of relying on tramp.

  5. Copying and renaming asynchronously

    If you have the async library installed (if you got Helm from MELPA you do), you can use it for copying/renaming files by enabling dired-async-mode.

    Note that even when async is enabled, running a copy/rename action with a prefix argument will execute action synchronously. Moreover it will follow the first file of the marked files in its destination directory.

    When dired-async-mode is enabled, an additional action named “Backup files” will be available. (Such command is not natively available in Emacs). See Use the wildcard to select multiple files for details.

  6. Use Rsync to copy files

    If Rsync is available, you can use it to copy/sync files or directories with some restrictions though:

    This command is mostly useful when copying large files as it is fast, asynchronous and provide a progress bar in mode-line. Each rsync process have its own progress bar, so you can run several rsync jobs, they are independents. If rsync fails you can consult the ‘*helm-rsync<n>*’ buffer to see rsync errors. An help-echo (move mouse over progress bar) is provided to see which file is in transfer. Note that when copying directories, no trailing slashes are added to directory names, which mean that directory is created on destination if it doesn’t already exists, see rsync documentation for more infos on rsync behavior. To synchronize a directory, mark all in the directory and rsync all marked to the destination directory or rsync the directory itself to its parent, e.g. ‘remote:/home/you/music’ ‘> =/home/you’.

    The options are configurable through helm-rsync-switches, but you can modify them on the fly when needed by using a prefix arg, in this case you will be prompted for modifications.

    Note: When selecting a remote file, if you use the tramp syntax for specifying a port, i.e. host#2222, helm will add automatically ‘-e ’ssh -p 2222’’ to the rsync command line unless you have specified yourself the ‘-e’ option by editing rsync command line with a prefix arg (see above).

Next: , Previous: , Up: Operate on files   [Contents]

3.2.6 Touch files

In the completion buffer, you can choose the default which is the current-time, it is the first candidate or the timestamp of one of the selected files. If you need to use something else, use M-n and edit the date in minibuffer. It is also a way to quickly create a new file without opening a buffer, saving it and killing it. To touch more than one new file, separate you filenames with a comma (‘,’). If one wants to create (touch) a new file with comma inside the name use a prefix arg, this will prevent splitting the name and create multiple files.

Next: , Previous: , Up: Operate on files   [Contents]

3.2.7 Delete files

You can delete files without quitting helm with C-c d or delete files and quit helm with M-D.

In the second method you can choose to make this command asynchronous by customizing helm-ff-delete-files-function.

Warning: When deleting files asynchronously you will NOT be WARNED if directories are not empty, that’s mean non empty directories will be deleted in background without asking.

A good compromise is to trash your files when using asynchronous method (see Trashing files).

When choosing synchronous delete, you can allow recursive deletion of directories with helm-ff-allow-recursive-deletes. Note that when trashing (synchronous) you are not asked for recursive deletion.

Note that helm-ff-allow-recursive-deletes have no effect when deleting asynchronously.

First method (persistent delete) is always synchronous.

Note that when a prefix arg is given, trashing behavior is inversed. See Trashing files.

  1. Trashing files

    If you want to trash your files instead of deleting them you can set delete-by-moving-to-trash to non nil, like this your files will be moved to trash instead of beeing deleted.

    You can reverse at any time the behavior of delete-by-moving-to-trash by using a prefix arg with any of the delete files command.

    On GNULinux distributions, when navigating to a Trash directory you can restore any file in ..Trash/files directory with the ’Restore from trash’ action you will find in action menu (needs the trash-cli package installed for remote files, see Here). You can as well delete files from Trash directories with the ’delete files from trash’ action. If you want to know where a file will be restored, hit M-i, you will find a trash info.

    Tip: Navigate to your Trash/files directories with helm-find-files and set a bookmark there with C-x r m for fast access to Trash.

    Note: Restoring files from trash is working only on system using the freedesktop trash specifications.7


    If you have an ‘ENV’ var ‘XDG_DATA_HOME’ in your .profile or .bash_profile and this var is set to something like ‘$HOME/.local/share’ (like preconized) move-file-to-trash may try to create ‘$HOME/.local/share/Trash’ (literally) and its subdirs in the directory where you are actually trying to trash files. because move-file-to-trash is interpreting ‘XDG_DATA_HOME’ literally instead of evaling its value (with substitute-in-file-name).

    1. Trashing remote files with tramp

      Trashing remote files (or local files with sudo method) is disabled by default because tramp is requiring the ’trash’ command to be installed, if you want to trash your remote files, customize helm-trash-remote-files. The package on most GNU/Linux based distributions is ‘trash-cli8.

      Note: When deleting your files with sudo method, your trashed files will not be listed with trash-list until you log in as root.

Next: , Previous: , Up: Operate on files   [Contents]

3.2.8 Checksum file

Checksum is calculated with the md5sum, sha1sum, sha224sum, sha256sum, sha384sum and sha512sum when available, otherwise the Emacs function secure-hash is used but it is slow and may crash Emacs and even the whole system as it eats all memory. So if your system doesn’t have the md5 and sha command line tools be careful when checking sum of larges files e.g. isos.

Next: , Previous: , Up: Operate on files   [Contents]

3.2.9 Grep files

When using an action that involves an external backend (e.g. grep), using ‘**’ is not recommended (even thought it works fine) because it will be slower to select all the files. You are better off leaving the backend to do it, it will be faster. However, if you know you have not many files it is reasonable to use this, also using not recursive wildcard (e.g. ‘*.el’) is perfectly fine for this.

See Use the wildcard to select multiple files for details.

  1. Grep files from helm-find-files

    You can grep individual files from helm-find-files by using C-s. This same command can also recursively grep files from the current directory when called with a prefix argument. In this case you will be prompted for the file extensions to use (grep backend) or the types of files to use (ack-grep backend). See the helm-grep-default-command documentation to set this up. For compressed files or archives, use zgrep with M-g z.

    Otherwise you can use recursive commands like M-g a or M-g g that are much faster than using C-s with a prefix argument. See helm-grep-ag-command and helm-grep-git-grep-command to set this up.

    You can also use ‘id-utils=’ GID with {{{kbd(M-g i)}}} by creating an ID index file with the =mkid’ shell command.

    All those grep commands use the symbol at point as the default pattern. Note that default is different from input (nothing is added to the prompt until you hit M-n).

    1. Grepping on remote files

      On remote files grep is not well supported by TRAMP unless you suspend updates before entering the pattern and re-enable it once your pattern is ready. To toggle suspend-update, use C-!.

  2. Recursive search from Helm-find-files
    1. You can use helm-browse-project (see binding below)
      M-x helm-browse-project

      If the current directory is under version control with either git or hg and helm-ls-git9 and/or helm-ls-hg10 are installed, it lists all the files under version control. Otherwise it falls back to Helm-find-files.

      C-u M-x helm-browse-project

      List all the files under this directory and other subdirectories (recursion) and this list of files will be cached.

      C-u C-u M-x helm-browse-project

      Same but the cache is refreshed.

    2. You can start a recursive search with ‘locate’, ‘find’ or ‘Fd

      See “Note” in the section on subdirectories.

      Using ‘locate’, you can enable the local database with a prefix argument. If the local database doesn’t already exists, you will be prompted for its creation. If it exists and you want to refresh it, give it two prefix args.

      When using locate the Helm buffer remains empty until you type something. Regardless Helm uses the basename of the pattern entered in the helm-find-files session by default. Hitting M-n should just kick in the locate search with this pattern. If you want Helm to automatically do this, add helm-source-locate to helm-sources-using-default-as-input.

      Note: On Windows use Everything with its command line es as a replacement of locate.11

    3. Recursive completion on subdirectories

      Starting from the directory you are currently browsing, it is possible to have completion of all directories underneath. Say you are at ‘/home/you/foo/’ and you want to go to ‘/home/you/foo/bar/baz/somewhere/else’, simply type ‘/home/you/foo/..else’ and hit C-j or enter the final ‘/’. Helm will then list all possible directories under ‘foo’ matching ‘else’.

      Note: Completion on subdirectories uses ‘locate’ as backend, you can configure the command with helm-locate-recursive-dirs-command. Because this completion uses an index, the directory tree displayed may be out-of-date and not reflect the latest change until you update the index (using ‘updatedb’ for ‘locate’).

      If for some reason you cannot use an index, the ‘find’ command from ‘findutils’ can be used instead. It will be slower though. You need to pass the basedir as first argument of ‘find’ and the subdir as the value for ’-(i)regex’ or ’-(i)name’ with the two format specs that are mandatory in helm-locate-recursive-dirs-command.


      find %s -type d -name ’*%s*’
      find %s -type d -regex .*%s.*$

      Fd12 command is now also supported which is regexp based and very fast. Here is the command line to use:

      fd --hidden --type d .*%s.*$ %s

      You can use also a glob based search, in this case use the –glob option:

      fd --hidden --type d --glob ’*%s*’ %s

Next: , Previous: , Up: Operate on files   [Contents]

3.2.10 Execute Eshell commands on files

Setting up aliases in Eshell allows you to set up powerful customized commands.

Your aliases for using eshell command on file should allow specifying one or more files, use e.g. ‘alias foo $1’ or ‘alias foo $*’, if you want your command to be asynchronous add at end ‘&’, e.g. ‘alias foo $* &’.

Adding Eshell aliases to your eshell-aliases-file or using the ‘alias’ command from Eshell allows you to create personalized commands not available in helm-find-files actions and use them from M-!.

Example: You want a command to uncompress some ‘*.tar.gz’ files from helm-find-files:

  1. Create an Eshell alias named, say, ‘untargz’ with the command

alias untargz tar zxvf $*’.

  1. Now from helm-find-files select the ‘*.tar.gz’ file (you can also

mark files if needed) and hit M-!.

Note: When using marked files with this, the meaning of the prefix argument is quite subtle. Say you have ‘foo’, ‘bar’ and ‘baz’ marked; when you run the alias command ‘example’ on these files with no prefix argument it will run ‘example’ sequentially on each file:

$ example foo
$ example bar
$ example baz

With a prefix argument however it will apply ‘example’ on all files at once:

$ example foo bar baz

Of course the alias command should support this.

If you add %s to the command line %s will be replaced with the candidate, this mean you can add extra argument to your command e.g. command -extra-arg %s or command %s -extra-arg. If you want to pass many files inside %s, don’t forget to use a prefix arg.

You can also use special placeholders in extra-args, see the specific info page once you hit M-!.

Previous: , Up: Operate on files   [Contents]

3.2.11 Attach files to a mail buffer (message-mode)

If you are in a message-mode or mail-mode buffer, that action will appear in action menu, otherwise it is available at any time with C-c C-a. It behaves as follows:

Next: , Previous: , Up: Helm Find Files   [Contents]

3.3 Working on Remote files with TRAMP

Tramp archive support (emacs-27+ only)

If your emacs have library tramp-archive.el, you can browse the content of archives with emacs and BTW helm-find-files. However this beeing experimental and not very fast, helm doesn’t provide an automatic expansion and detection of archives, you will have to add the final ‘/’ manually and may have to force update (C-c C-u) or remove and add again the final ‘/’ until tramp finish decompressing archive.

Using TRAMP with helm-find-files to read remote directories

helm-find-files works fine with TRAMP despite some limitations.

Next: , Previous: , Up: Helm Find Files   [Contents]

3.4 Misc. Remarks

Next: , Up: Misc Remarks   [Contents]

3.4.1 Find file at point

Helm uses ffap partially or completely to find file at point depending on the value of helm-ff-guess-ffap-filenames: if non-nil, support is complete (annoying), if nil, support is partial.

Note that when the variable helm-ff-allow-non-existing-file-at-point is non nil Helm will insert the filename at point even if file with this name doesn’t exists. If non existing file at point ends with numbers prefixed with ‘:’ the ‘:’ and numbers are stripped.

  1. Find file at line number

    When text at point is in the form of


    Helm finds this file at the indicated line number, here 1234.

  2. Find URL at point

    When a URL is found at point, Helm expands to that URL only. Pressing RET opens that URL using browse-url-browser-function.

  3. Find e-mail address at point

    When an e-mail address is found at point, Helm expands to this e-mail address prefixed with ‘mailto:’. Pressing RET opens a message buffer with that e-mail address.

Next: , Previous: , Up: Misc Remarks   [Contents]

3.4.2 Insert filename at point or complete filename at point

On insertion (not on completion, i.e. there is nothing at point):

C-c i

insert absolute file name.

C-u C-c i

insert abbreviated file name.

C-u C-u C-c i

insert relative file name.

C-u C-u C-u C-c i

insert basename.

On completion:

Target starts with ‘~/

insert abbreviate file name.

target starts with ‘/’ or ‘[a-z]:/

insert full path.


insert relative file name.

Next: , Previous: , Up: Misc Remarks   [Contents]

3.4.3 Edit marked files in a dired buffer

You can open a dired buffer containing only marked files with C-x C-q. With a prefix argument you can open this same dired buffer in wdired mode for editing. Note that wildcards are supported as well, so you can use e.g. ‘*.txt’ to select all ‘.txt’ files in the current directory or ‘**.txt’ to select all files recursively from the current directory. See Use the wildcard to select multiple files section above.

Next: , Previous: , Up: Misc Remarks   [Contents]

3.4.4 Bookmark the helm-find-files session

You can bookmark the helm-find-files session with C-x r m. You can later retrieve these bookmarks by calling helm-filtered-bookmarks or, from the current helm-find-files session, by hitting C-x r b.

Next: , Previous: , Up: Misc Remarks   [Contents]

3.4.5 Ignored or boring files

Helm-find-files can ignore files matching helm-boring-file-regexp-list or files that are git ignored, you can set this with helm-ff-skip-boring-files or helm-ff-skip-git-ignored-files.

Note: This will slow down helm, be warned.

Previous: , Up: Misc Remarks   [Contents]

3.4.6 Helm-find-files is using a cache

Helm is caching each directory files list in a hash table for faster search, when a directory is modified it is removed from cache so that further visit in this directory refresh cache. You may have in some rare cases to refresh directory manually with C-c C-u for example when helm-find-files session is running and a file is modified/deleted in current visited directory by an external command from outside Emacs.

Previous: , Up: Helm Find Files   [Contents]

3.5 Commands

C-x C-fRun ‘locate’ (‘C-u’ to specify locate database, ‘M-n’ to insert basename of candidate).
C-x C-dBrowse project (‘C-u’ to recurse, ‘C-u C-u’ to recurse and refresh database).
C-c /Run ‘find’ shell command from this directory.
C-sRun Grep (‘C-u’ to recurse).
M-g pRun Pdfgrep on marked files.
M-g zRun zgrep (‘C-u’ to recurse).
M-g aRun AG grep on current directory.
M-g gRun git-grep on current directory.
M-g iRun gid (id-utils).
M-.Run Etags (‘C-u’ to use thing-at-point, ‘C-u C-u’ to reload cache).
M-RRename Files (‘C-u’ to follow).
M-@Query replace on marked files.
M-CCopy Files (‘C-u’ to follow).
M-VRsync Files (‘C-u’ to edit command).
M-BByte Compile Files (‘C-u’ to load).
M-LLoad Files.
M-SSymlink Files.
M-HHardlink files.
M-YRelative symlink Files.
M-DDelete Files.
M-TTouch files.
M-KKill buffer candidate without leaving Helm.
C-c dDelete file without leaving Helm.
M-eSwitch to prefered shell.
M-!Eshell command on file (‘C-u’ to apply on marked files, otherwise treat them sequentially).
C-c =Ediff file.
M-=Ediff merge file.
C-c iComplete file name at point.
C-c oSwitch to other window.
C-c C-oSwitch to other frame.
C-c C-xOpen file with external program (‘C-u’ to choose).
C-c C-vPreview file with external program.
C-c XOpen file externally with default tool.
M-lRotate image left.
M-rRotate image right.
M-+Zoom in image.
M–Zoom out image.
C-lGo to parent directory.
M-pSwitch to the visited-directory history.
C-c hSwitch to file name history.
M-iShow file properties in a tooltip.
M-aMark all visible candidates.
C-c DELToggle auto-expansion of directories.
M-UUnmark all candidates, visible and invisible ones.
C-c C-aAttach files to message buffer.
C-c pPrint file, (‘C-u’ to refresh printer list).
C-{Enlarge Helm window.
C-}Narrow Helm window.
C-]Toggle basename/fullpath.
C-c rFind file as root.
C-x C-vFind alternate file.
C-c @Insert org link.
C-x r mSet bookmark to current directory.
C-x r bJump to bookmark list.
S-<f1>Sort alphabetically
S-<f2>Sort by newest
S-<f3>Sort by size
S-<f4>Show only directories
S-<f5>Show only files

Next: , Previous: , Up: Top   [Contents]

4 Helm ‘generic’ read file name completion

This is ‘generic’ read file name completion that have been ‘helmized’ because you have enabled helm-mode. Don’t confuse this with helm-find-files which is a native helm command, see Helm functions vs helmized Emacs functions.

Next: , Up: Helm ‘generic’ read file name completion   [Contents]

4.1 Tips

Next: , Up: Tips (1)   [Contents]

4.1.1 Navigation

  1. Enter ‘~/’ at end of pattern to quickly reach home directory
  2. Enter ‘/’ at end of pattern to quickly reach the file system root
  3. Enter ‘./’ at end of pattern to quickly reach default-directory

    (As per its value at the beginning of the session.)

    If you already are in the default-directory this will move the cursor to the top.

  4. Enter ‘../’ at end of pattern will reach upper directory, moving cursor on top

    This is different from using M-x helm-find-files-up-one-level in that it moves the cursor to the top instead of remaining on the previous subdir name.

  5. You can complete with partial basename

    It starts from the third character of the pattern.

    For instance ‘fob’ or ‘fbr’ will complete ‘foobar’ but ‘fb’ needs a third character in order to complete it.

Next: , Previous: , Up: Tips (1)   [Contents]

4.1.2 Persistent actions

By default helm-read-file-name uses the persistent actions of helm-find-files.

  1. Use C-u C-j to display an image
  2. C-j on a filename will expand to this filename in Helm-buffer

    Second hit displays the buffer filename. Third hit kills the buffer filename.

    Note: C-u C-j displays the buffer directly.

  3. Browse images directories with helm-follow-mode and navigate up/down

Next: , Previous: , Up: Tips (1)   [Contents]

4.1.3 Delete characters backward

When you want to delete characters backward, e.g. to create a new file or directory, auto-update may come in the way when it keeps updating to an existent directory. In that case, type C-<backspace> and then ‘<backspace>’. This should not be needed when copying/renaming files because autoupdate is disabled by default in that case.

Note: On a terminal, the default binding C-<backspace> may not work. In this case use C-c <backspace>.

Next: , Previous: , Up: Tips (1)   [Contents]

4.1.4 Create new directories and files

  1. You can create a new directory and a new file at the same time

    Simply write the path in prompt and press RET, e.g. ‘~/new/newnew/newnewnew/my_newfile.txt’.

  2. To create a new directory, append a ‘/’ at to the new name and press RET
  3. To create a new file, enter a filename not ending with ‘/

    File and directory creation works only with some commands (e.g. find-file) and it will not work with others where it is not intended to return a file or a directory (e.g list-directory).

Previous: , Up: Tips (1)   [Contents]

4.1.5 Exiting minibuffer with empty string

You can exit minibuffer with empty string with Uses keymap helm-read-file--map, which is not currently defined. M-x helm-cr-empty-string. It is useful when some commands are prompting continuously until you enter an empty prompt.

Previous: , Up: Helm ‘generic’ read file name completion   [Contents]

4.2 Commands

C-lGo to parent directory.
C-c DELToggle auto-expansion of directories.
C-]Toggle basename.
C-c hFile name history.
C/M-RETReturn empty string unless ‘must-match’ is non-nil.
C-oGo to next source.
M-oGo to previous source.

Next: , Previous: , Up: Top   [Contents]

5 Helm Generic files

Next: , Up: Helm Generic files   [Contents]

5.1 Tips

Next: , Up: Tips (2)   [Contents]

5.1.1 Locate

You can append to the search pattern any of the locate command line options, e.g. ‘-b’, ‘-e’, ‘-n <number>’, etc. See the locate(1) man page for more details.

Some other sources (at the moment ‘recentf’ and ‘file in current directory’) support the ‘-b’ flag for compatibility with locate when they are used with it.

When you enable fuzzy matching on locate with helm-locate-fuzzy-match, the search will be performed on basename only for efficiency (so don’t add ‘-b’ at prompt). As soon as you separate the patterns with spaces, fuzzy matching will be disabled and search will be done on the full filename. Note that in multi-match, fuzzy is completely disabled, which means that each pattern is a match regexp (i.e. ‘helm’ will match ‘helm’ but ‘hlm’ will not match ‘helm’).

Note: On Windows use Everything with its command line es as a replacement of locate.13

Next: , Previous: , Up: Tips (2)   [Contents]

5.1.2 Browse project

When the current directory is not under version control, don’t forget to refresh the cache when files have been added/removed in the directory.

Previous: , Up: Tips (2)   [Contents]

5.1.3 Find command

Recursively search files using the ‘find’ shell command.

Candidates are all filenames that match all given globbing patterns. This respects the options helm-case-fold-search and helm-findutils-search-full-path.

You can pass arbitrary ‘find’ options directly after a ‘*’ separator. For example, this would find all files matching ‘book’ that are larger than 1 megabyte:

book * -size +1M

Previous: , Up: Helm Generic files   [Contents]

5.2 Commands

C-]Toggle basename.
C-sRun grep (‘C-u’ to recurse).
M-g zRun zgrep.
M-g pRun PDFgrep on marked files.
M-CCopy file(s)
M-RRename file(s).
M-SSymlink file(s).
M-HHardlink file(s).
M-DDelete file(s).
M-BByte compile Elisp file(s) (‘C-u’ to load).
M-LLoad Elisp file(s).
C-=Ediff file.
C-c =Ediff-merge file.
C-c oSwitch to other window.
M-iShow file properties.
C-c C-xOpen file with external program (‘C-u’ to choose).
C-c XOpen file externally with default tool.
C-c @Insert org link.

Next: , Previous: , Up: Top   [Contents]

6 Helm fd

Next: , Up: Helm fd   [Contents]

6.1 Tips

The Fd14 command line tool is very fast to search files recursively. You may have to wait several seconds at first usage when your hard drive cache is ‘cold’, then once the cache is initialized searchs are very fast. You can pass any Fd options15 before pattern, e.g. ‘-e py foo’.

The Fd command line can be customized with helm-fd-switches user variable. Always use ‘--color always’ as option otherwise you will have no colors. To customize colors see Fd colorized16.

Note: Starting from fd version 8.2.1, you have to provide the env var LS_COLORS to Emacs to have a colorized output, the easiest way is to add to your ‘~/.profile’ file ‘eval $(dircolors)’. Another way is using ‘setenv’ in your init file. This is not needed when running Emacs from a terminal either with ‘emacs -nw’ or ‘emacs’ because emacs inherit the env vars of this terminal.17

Search is (pcre) regexp based18, and multi patterns are not supported.

Previous: , Up: Helm fd   [Contents]

6.2 Commands

Uses keymap helm-fd-map, which is not currently defined.

M-x helm-ff-run-grepRun grep (‘C-u’ to recurse).
M-x helm-ff-run-zgrepRun zgrep.
M-x helm-ff-run-pdfgrepRun PDFgrep on marked files.
M-x helm-ff-run-copy-fileCopy file(s)
M-x helm-ff-run-rename-fileRename file(s).
M-x helm-ff-run-symlink-fileSymlink file(s).
M-x helm-ff-run-hardlink-fileHardlink file(s).
M-x helm-ff-run-delete-fileDelete file(s).
M-x helm-ff-run-byte-compile-fileByte compile Elisp file(s) (‘C-u’ to load).
M-x helm-ff-run-load-fileLoad Elisp file(s).
M-x helm-ff-run-ediff-fileEdiff file.
M-x helm-ff-run-ediff-merge-fileEdiff-merge file.
M-x helm-ff-run-switch-other-windowSwitch to other window.
M-x helm-ff-properties-persistentShow file properties.
M-x helm-ff-run-open-file-externallyOpen file with external program (‘C-u’ to choose).
M-x helm-ff-run-open-file-with-default-toolOpen file externally with default tool.
M-x helm-ff-run-insert-org-linkInsert org link.
M-x helm-fd-previous-directoryMove to previous directory.
M-x helm-fd-next-directoryMove to next directory.

Next: , Previous: , Up: Top   [Contents]

7 Helm Grep

Up: Helm Grep   [Contents]

7.1 Tips

With Helm supporting Git-grep and AG/RG, you are better off using one of them for recursive searches, keeping grep or ack-grep to grep individual or marked files. See Helm AG.

Next: , Up: Tips (4)   [Contents]

7.1.1 Meaning of the prefix argument

  1. With grep or ack-grep

    Grep recursively, in this case you are prompted for types (ack-grep) or for wild cards (grep).

  2. With AG or RG

    the prefix arg allows you to specify a type of file to search in.

Next: , Previous: , Up: Tips (4)   [Contents]

7.1.2 You can use wild cards when selecting files (e.g. ‘*.el’)

Note that a way to grep specific files recursively is to use e.g. ‘**.el’ to select files, the variable helm-file-globstar controls this (it is non nil by default), however it is much slower than using grep recusively (see helm-find-files documentation about this feature).

Next: , Previous: , Up: Tips (4)   [Contents]

7.1.3 Grep hidden files

You may want to customize your command line for grepping hidden files, for AG/RG use ‘--hidden’, see man page of your backend for more infos.

Next: , Previous: , Up: Tips (4)   [Contents]

7.1.4 You can grep in different directories by marking files or using wild cards

Next: , Previous: , Up: Tips (4)   [Contents]

7.1.5 You can save the result in a helm-grep-mode buffer

See commands below.

Once in that buffer you can use ‘emacs-wgrep19 to edit your changes, for Helm the package name is ‘wgrep-helm’, it is hightly recommended.

Next: , Previous: , Up: Tips (4)   [Contents]

7.1.6 Helm-grep supports multi-matching

(Starting from version 1.9.4.)

Simply add a space between each pattern as for most Helm commands.

Note: Depending the regexp you use it may match as well the filename, this because we pipe the first grep command which send the filename in output.

Next: , Previous: , Up: Tips (4)   [Contents]

7.1.7 See full path of selected candidate

Add (helm-popup-tip-mode 1) in your init file or enable it interactively with M-x helm-popup-tip-mode however it is generally enough to just put your mouse cursor over candidate.

Next: , Previous: , Up: Tips (4)   [Contents]

7.1.8 Open file in other window

The command C-c o allow you to open file in other window horizontally or vertically if a prefix arg is supplied.

Previous: , Up: Tips (4)   [Contents]

7.1.9 Performance over TRAMP

Grepping works but it is badly supported as TRAMP doesn’t support multiple processes running in a short delay (less than 5s) among other things.

Helm uses a special hook to suspend the process automatically while you are typing. Even if Helm handles this automatically by delaying each process by 5s, you are adviced to this manually by hitting C-! (suspend process) before typing, and hit again C-! when the regexp is ready to send to the remote process. For simple regexps, there should be no need for this.

Another solution is to not use TRAMP at all and mount your remote file system via SSHFS.

Next: , Previous: , Up: Top   [Contents]

8 Helm GID

Still supported, but mostly deprecated, using AG/RG or Git-grep is much more efficient, also ‘id-utils’ seems no more maintained.

Up: Helm GID   [Contents]

8.1 Tips

Helm-GID reads the database created with the ‘mkid’ command from id-utils. The name of the database file can be customized with helm-gid-db-file-name, it is usually ‘ID’.

Helm-GID use the symbol at point as default-input. This command is also accessible from helm-find-files which allow you to navigate to another directory to consult its database.

Note: Helm-GID supports multi-matches but only the last pattern entered will be highlighted since there is no --color-like option in GID itself.

Next: , Previous: , Up: Top   [Contents]

9 Helm AG

Up: Helm AG   [Contents]

9.1 Tips

Helm-AG is different from grep or ack-grep in that it works on a directory recursively and not on a list of files. It is called helm-AG but it support several backend, namely AG, RG and PT. Nowaday the best backend is Ripgrep aka RG, it is the fastest and is actively maintained, see helm-grep-ag-command and helm-grep-ag-pipe-cmd-switches to configure it.

You can ignore files and directories with a ‘.agignore’ file, local to a directory or global when placed in the home directory. (See the AG man page for more details.) That file follows the same syntax as helm-grep-ignored-files and helm-grep-ignored-directories.

As always you can access Helm AG from helm-find-files.

Starting with version 0.30, AG accepts one or more TYPE arguments on its command line. Helm provides completion on these TYPE arguments when available with your AG version. Use a prefix argument when starting a Helm-AG session to enable this completion. See RG and AG man pages on how to add new types.

Note: You can mark several types to match in the AG query. The first AG versions providing this feature allowed only one type, so in this case only the last mark will be used.

Next: , Previous: , Up: Top   [Contents]

10 Helm git-grep

Helm-git-grep searches the current directory, i.e. the default directory or the directory in Helm-find-files. If this current directory is a subdirectory of a project and you want to also match parent directories (i.e the whole project), use a prefix argument.

Up: Helm git-grep   [Contents]

10.1 Commands

M-<down>Next File.
M-<up>Previous File.
M-x helm-yank-text-at-pointYank text at point in minibuffer.
C-c oJump to other window.
C-c C-oJump to other frame.
<left>Run default action (same as ‘RET’).
C-x C-sSave to a ‘helm-grep-mode’ enabled buffer.

Next: , Previous: , Up: Top   [Contents]

11 Helm PDFgrep Map

Up: Helm PDFgrep Map   [Contents]

11.1 Commands

M-<down>Next file.
M-<up>Previous file.
M-x helm-yank-text-at-pointYank text at point in minibuffer.

Next: , Previous: , Up: Top   [Contents]

12 Helm Etags Map

Up: Helm Etags Map   [Contents]

12.1 Commands

M-<down>Next file.
M-<up>Previous file.
M-x helm-yank-text-at-pointYank text at point in minibuffer.

Next: , Previous: , Up: Top   [Contents]

13 Helm UCS

Next: , Up: Helm UCS   [Contents]

13.1 Tips

Use commands below to insert unicode characters in current buffer without leaving Helm.

Previous: , Up: Helm UCS   [Contents]

13.2 Commands

Uses keymap helm-ucs-map, which is not currently defined.

M-x helm-ucs-persistent-insertInsert character.
M-x helm-ucs-persistent-forwardForward character.
M-x helm-ucs-persistent-backwardBackward character.
M-x helm-ucs-persistent-deleteDelete character backward.
M-x helm-ucs-persistent-insert-spaceInsert space.

Next: , Previous: , Up: Top   [Contents]

14 Helm bookmark name

Up: Helm bookmark name   [Contents]

14.1 Commands

Uses keymap helm-bookmark-map, which is not currently defined.

M-x helm-bookmark-run-jump-other-windowJump other window.
M-x helm-bookmark-run-deleteDelete bookmark.
M-x helm-bookmark-run-editEdit bookmark.
M-x helm-bookmark-toggle-filenameToggle bookmark location visibility.

Next: , Previous: , Up: Top   [Contents]

15 Helm Eshell on file

Next: , Up: Helm Eshell on file   [Contents]

15.1 Tips

Next: , Up: Tips (8)   [Contents]

15.1.1 Pass extra arguments after filename

Normally the command or alias will be called with file as argument. For instance

<command> candidate_file

But you can also pass an argument or more after ‘candidate_file’ like this:

<command> %s [extra_args]

candidate_file’ will be added at ‘%s’ and the command will look at this:

<command> candidate_file [extra_args]
  1. Use placeholders in extra arguments

    placeholder for file without extension: \@ placeholder for incremental number: \#

    candidate_file’ will be added at ‘%s’ and \@ but without extension.

    <command %s \@>

    candidate_file’ will be added at ‘%s’ and \# will be replaced by an incremental number.

    <command> %s \#

    Here examples:

    Say you want to use the ‘convert’ command to convert all your .png files in a directory to .jpg.

    This will convert all your files to jpg keeping the same basename.

    convert %s \@.jpg

    This will convert all your files to foo-001.jpg, foo-002.jpg etc…

    convert %s foo-\#.jpg

    You can of course combine both placeholders if needed.

    convert %s \@-\#.jpg

Next: , Previous: , Up: Tips (8)   [Contents]

15.1.2 Specify marked files as arguments


<command> file1 file2...

Call helm-find-files-eshell-command-on-file with one prefix argument. Otherwise you can pass one prefix argument from the command selection buffer.

Note: This does not work on remote files.

With two prefix-args the output is printed to the current-buffer.

With no prefix argument or a prefix argument value of ’(16) (C-u C-u) the command is called once for each file like this:

<command> file1
<command> file2

Previous: , Up: Tips (8)   [Contents]

15.1.3 Run eshell commands asynchronously

You can run your commands asynchronously by adding ‘&’ at end of any commands, e.g. ‘foo %s &’. You can also directly setup your alias in the eshell alias file with e.g. ‘alias foo $1 &’.

Note: If you use ‘&’ in a command with marked files and your command accept many files as argument don’t forget to pass the prefix arg to ensure you run only one command on all marked async.

Previous: , Up: Helm Eshell on file   [Contents]

15.2 Commands

Uses keymap helm-esh-on-file-map, which is not currently defined.

Next: , Previous: , Up: Top   [Contents]

16 Helm Ido virtual buffers

Up: Helm Ido virtual buffers   [Contents]

16.1 Commands

Uses keymap helm-buffers-ido-virtual-map, which is not currently defined.

M-x helm-ff-run-switch-other-windowSwitch to other window.
M-x helm-ff-run-switch-other-frameSwitch to other frame.
M-x helm-ff-run-grepGrep file.
M-x helm-ff-run-zgrepZgrep file.
M-x helm-ff-run-delete-fileDelete file.
M-x helm-ff-run-open-file-externallyOpen file externally.

Next: , Previous: , Up: Top   [Contents]

17 Helm Moccur

Next: , Up: Helm Moccur   [Contents]

17.1 Tips

Next: , Up: Tips (9)   [Contents]

17.1.1 Searching in many buffers

Start from helm-buffers-list or helm-mini, mark some buffers and hit Uses keymap ‘helm-buffer-map\[helm-buffers-run-occur]. A prefix arg will change the behavior of ‘helm-occur-always-search-in-current’ i.e. add current buffer or not to the list of buffers to search in.

Next: , Previous: , Up: Tips (9)   [Contents]

17.1.2 Matching

Multiple regexp matching is allowed, simply enter a space to separate the regexps.

Matching empty lines is supported with the regexp ‘^$’, you then get the results displayed as the buffer-name and the line number only. You can save and edit these results, i.e. add text to the empty line.

Next: , Previous: , Up: Tips (9)   [Contents]

17.1.3 Automatically match symbol at point

Helm can automatically match the symbol at point while keeping the minibuffer empty, ready to be written to when ‘helm-source-occur’ and ‘helm-source-moccur’ are member of ‘helm-sources-using-default-as-input’.

Next: , Previous: , Up: Tips (9)   [Contents]

17.1.4 Yank word at point in minibuffer

Use C-w as many times as needed, undo with C-. Note that C-w and {{{kbd(C-)}}} are not standard keybindings, but bindings provided with special helm feature ‘helm-define-key-with-subkeys’.

Next: , Previous: , Up: Tips (9)   [Contents]

17.1.5 Preselection

When helm-occur search symbol at point the current line is preselected in the source related to current-buffer. When ‘helm-occur-keep-closest-position’ is non nil helm-occur will select the line which is the closest from the current line in current-buffer after updating.

Next: , Previous: , Up: Tips (9)   [Contents]

17.1.6 Jump to the corresponding line in the searched buffer

You can do this with ‘\<helm-map’, which is not currently defined. M-x helm-execute-persistent-action’ (persistent-action), to do it repeatedly you can use C-<down> and C-<up> or enable helm-follow-mode with C-c C-f. Follow mode is enabled by default in helm-occur.

Next: , Previous: , Up: Tips (9)   [Contents]

17.1.7 Switch to buffer in other window

The command Uses keymap helm-moccur-map, which is not currently defined. M-x helm-moccur-run-goto-line-ow allow you to switch to buffer in other window horizontally or vertically if a prefix arg is supplied.

Next: , Previous: , Up: Tips (9)   [Contents]

17.1.8 Save the results

Similarly to Helm-grep, you can save the results with C-x C-s. Once in the saved buffer, you can edit it, see below.

Of course if you don’t save the results, you can resume the Helm session with helm-resume.

Next: , Previous: , Up: Tips (9)   [Contents]

17.1.9 Refresh the resumed session

When the buffer(s) where you ran helm-(m)occur get(s) modified, the Helm buffer will flash red as a warning. You can refresh the buffer by running C-c C-u. This can be done automatically by customizing helm-moccur-auto-update-on-resume.

Next: , Previous: , Up: Tips (9)   [Contents]

17.1.10 Refresh a saved buffer

Type g to update the buffer.

Next: , Previous: , Up: Tips (9)   [Contents]

17.1.11 Edit a saved buffer

First, install ‘wgrep20 and then:

  1. C-c C-p (wgrep-change-to-wgrep-mode) to edit the buffer(s).
  2. C-x C-s to save your changes.

Tip: Use the excellent ‘iedit21 to modify all occurences at once in the buffer.

Next: , Previous: , Up: Tips (9)   [Contents]

17.1.12 Search in region

When searching in current-buffer with helm-occur, if a region is found helm will search in this region only. If you marked this region with mark-defun the symbol that was at point before marking defun will be used when helm-source-occur is member of helm-sources-using-default-as-input.

Previous: , Up: Tips (9)   [Contents]

17.1.13 Switch to next or previous source

See [BROKEN LINK: Moving in ‘helm-buffer’].

Previous: , Up: Helm Moccur   [Contents]

17.2 Commands

C-c oGo to line in other window.
C-c C-oGo to line in new frame.
C-x C-sSave results in new buffer.

Next: , Previous: , Up: Top   [Contents]

18 Helm Top

Up: Helm Top   [Contents]

18.1 Commands

Uses keymap helm-top-map, which is not currently defined.

M-x helm-top-run-sort-by-comSort by commands.
M-x helm-top-run-sort-by-cpuSort by CPU usage.
M-x helm-top-run-sort-by-userSort alphabetically by user.
M-x helm-top-run-sort-by-memSort by memory.

Next: , Previous: , Up: Top   [Contents]

19 Helm Elisp package

Next: , Up: Helm Elisp package   [Contents]

19.1 Tips

Next: , Up: Tips (10)   [Contents]

19.1.1 Compile all your packages asynchronously

If you use async (if you have installed Helm from MELPA you do), only ‘helm’, ‘helm-core’, and ‘magit’ are compiled asynchronously. If you want all your packages compiled asynchronously, add this to your init file:

(setq async-bytecomp-allowed-packages ’(all))

Next: , Previous: , Up: Tips (10)   [Contents]

19.1.2 Upgrade Elisp packages

On initialization (when Emacs is fetching packages on remote), if Helm finds packages to upgrade, it will start in the upgradable packages view showing the packages available for upgrade.

On subsequent runs, you will have to refresh the list with C-c C-u. If Helm finds upgrades you can switch to upgrade view (see below) to see what packages are available for upgrade or simply hit C-c U to upgrade them all.

To see upgradable packages hit M-U.

Then you can install all upgradable packages with the ‘upgrade all’ action (C-c C-u), or upgrade only specific packages by marking them and running the ‘upgrade’ action (visible only when there are upgradable packages). Of course you can upgrade a single package by just running the ‘upgrade’ action without marking it (C-c u or RET) .

Warning: You are strongly advised to restart Emacs after upgrading packages.

Previous: , Up: Tips (10)   [Contents]

19.1.3 Meaning of flags prefixing packages

(Emacs ≥25)

Previous: , Up: Helm Elisp package   [Contents]

19.2 Commands

Uses keymap helm-el-package-map, which is not currently defined.

M-x helm-el-package-show-allShow all packages.
M-x helm-el-package-show-installedShow installed packages only.
M-x helm-el-package-show-uninstalledShow non-installed packages only.
M-x helm-el-package-show-upgradeShow upgradable packages only.
M-x helm-el-package-show-built-inShow built-in packages only.
M-x helm-el-run-package-installInstall package(s).
M-x helm-el-run-package-reinstallReinstall package(s).
M-x helm-el-run-package-uninstallUninstall package(s).
M-x helm-el-run-package-upgradeUpgrade package(s).
M-x helm-el-run-package-upgrade-allUpgrade all packages.
M-x helm-el-run-visit-homepageVisit package homepage.

Next: , Previous: , Up: Top   [Contents]

20 Helm M-x

Up: Helm M-x   [Contents]

20.1 Tips

Next: , Up: Tips (11)   [Contents]

20.1.1 You can get help on any command with persistent action (C-j)

Next: , Previous: , Up: Tips (11)   [Contents]

20.1.2 Prefix arguments

You can pass prefix arguments after starting helm-M-x. A mode-line counter will display the number of given prefix arguments.

If you pass prefix arguments before running helm-M-x, it will be displayed in the prompt. The first C-u after helm-M-x clears those prefix arguments.

Note: When you specify prefix arguments once helm-M-x is started, the prefix argument apply on the next command, so if you hit RET, it will apply on the selected command, but if you type a new character at prompt to narrow down further candidates, the prefix arg will apply to self-insert-command (e.g. if you type C-u eeeee’ will be inserted in prompt) so select the command you want to execute before specifying prefix arg.

Next: , Previous: , Up: Tips (11)   [Contents]

20.1.3 Completion styles in helm-M-x

By default helm-M-x use ’helm completion style, if you want to enable fuzzy matching aka flex, see Completion-styles.

Previous: , Up: Tips (11)   [Contents]

20.1.4 Duplicate entries in helm-M-x history

helm-M-x history obey to history variables, if you have duplicates in your helm-M-x history set history-delete-duplicates to non nil.

Next: , Previous: , Up: Top   [Contents]

21 Helm Imenu

Up: Helm Imenu   [Contents]

21.1 Commands

Uses keymap helm-imenu-map, which is not currently defined.

M-x helm-imenu-next-sectionGo to next section.
M-x helm-imenu-previous-sectionGo to previous section.

Next: , Previous: , Up: Top   [Contents]

22 Helm colors

Up: Helm colors   [Contents]

22.1 Commands

Uses keymap helm-color-map, which is not currently defined.

M-x helm-color-run-insert-nameInsert the entry name.
M-x helm-color-run-kill-nameKill the entry name.
M-x helm-color-run-insert-rgbInsert entry in RGB format.
M-x helm-color-run-kill-rgbKill entry in RGB format.

Next: , Previous: , Up: Top   [Contents]

23 Helm Semantic

Up: Helm Semantic   [Contents]

23.1 Commands

Uses keymap helm-semantic-map, which is not currently defined.

Next: , Previous: , Up: Top   [Contents]

24 Helm kmacro

Next: , Up: Helm kmacro   [Contents]

24.1 Tips

Use persistent action to run your kmacro as many times as needed. You can browse the kmacros with helm-next-line and helm-previous-line.

Note: You can’t record keys running Helm commands except helm-M-x, under the condition that you don’t choose a command using Helm completion.

Previous: , Up: Helm kmacro   [Contents]

24.2 Commands

Uses keymap helm-kmacro-map, which is not currently defined.

Previous: , Up: Top   [Contents]

25 Helm kill ring

Next: , Up: Helm kill ring   [Contents]

25.1 Tips

Every Helm session lets you save a candidate to the kill-ring / clipboard / primary-selection with C-c C-k.

To save space, Helm-kill-ring truncates the candidates longer than helm-kill-ring-max-offset. ‘ Uses keymap helm-kill-ring-map, which is not currently defined. M-x helm-kill-ring-kill-selection’ then saves the whole text and not the truncated value. The view of truncated candidates can be toggled; see the command list below.

As opposed to yank, numeric prefix arguments are ignored with helm-show-kill-ring: there is no need for them since selection happens within Helm. Moreover Helm has Shortcuts for executing the default action on the n-th candidate.

It is recommended to globally bind M-y to helm-show-kill-ring. Once in the Helm-kill-ring session you can navigate to next/previous line with M-y and M-u for convenience. Of course M-x helm-next-line and M-x helm-previous-line are still available.

It is possible to delete candidates from the kill ring with ‘ Uses keymap helm-kill-ring-map, which is not currently defined. M-x helm-kill-ring-delete’ but also persistently with ‘ Uses keymap helm-kill-ring-map, which is not currently defined. M-x helm-kill-ring-run-persistent-delete’.

You can concatenate marked candidates and yank them in the current buffer, thus creating a new entry in the kill ring. Candidates are concatenated with helm-kill-ring-separator as default but you can change interactively the separator while yanking by using two prefix args. When you have something else than ‘\n’ as default value for helm-kill-ring-separator and you want to use ‘\n’ from prompt, use C-q C-j to enter a newline in prompt.

To not push a new entry in the kill ring, use C-c TAB instead of RET (note that you can’t change separator with this).

When inserting candidates with the default action (RET), point is placed at the end of the candidate and mark at the beginning. You can revert this behavior by using a prefix argument, i.e. C-u RET, like the regular yank command does.

Previous: , Up: Helm kill ring   [Contents]

25.2 Commands

Uses keymap helm-kill-ring-map, which is not currently defined.

M-x helm-next-lineNext line.
M-x helm-previous-linePrevious line.
M-x helm-kill-ring-deleteDelete entry.
M-x helm-kill-ring-toggle-truncatedToggle truncated view of candidate.
M-x helm-kill-ring-kill-selectionKill non-truncated of selection.



Behavior may change depending context in some source e.g. helm-find-files.


Delete from point to end or all depending on the value of helm-delete-minibuffer-contents-from-point.




Note that the key bindings are always available even if line numbers are not displayed. They are just useless in this case.




how-to-rsync-files-between-two-remotes for the command line to use.










Locate on Windows




Locate on Windows