M-x helm-documentation

Table of Contents

M-x helm-documentation

— The Detailed Node Listing —

Helm Generic Help

Helm sources

Matching in Helm

Helm mode

Global commands

Helm Buffer

Helm Find Files

Operate on files

Misc. Remarks

Helm ‘generic’ read file name completion

Tips

Helm Generic files

Tips

Helm fd

Helm Grep

Tips

Helm GID

Helm AG

Helm git-grep

Helm PDFgrep Map

Helm Etags Map

Helm UCS

Helm bookmark name

Helm Eshell on file

Tips

Helm Ido virtual buffers

Helm Moccur

Tips

Helm Top

Helm Elisp package

Tips

Helm M-x

Tips

Helm Imenu

Helm colors

Helm Semantic

Helm kmacro

Helm kill ring

1 Helm Generic Help

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:

• RET selects the candidate from the list, executes the default action upon exiting the Helm session.
• C-j executes the default action but without exiting the Helm session. Not all sources support this.
• TAB displays a list of actions available on current candidate or all marked candidates. The default binding <tab> is ordinarily used for completion, but that would be redundant since Helm completes upon every character entered in the prompt.

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

https://github.com/emacs-helm/helm/wiki/Fuzzy-matching

Helm Completion vs Emacs Completion

https://github.com/emacs-helm/helm/wiki#helm-completion-vs-emacs-completion

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

https://github.com/emacs-helm/helm/wiki/Developing#creating-a-source

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

https://github.com/emacs-helm/helm/wiki/FAQ#why-is-a-customizable-helm-source-nil

Complex Examples Of Configuration

https://github.com/thierryvolpiatto/emacs-tv-config/blob/master/init-helm.el#L340

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).

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.

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.

Example:

(helm :sources (helm-build-sync-source "test"
                 :candidates (helm-dynamic-completion
                              ’(foo bar baz foab)
                              ’symbolp)
                 :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.

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.

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.

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.

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.

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:

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.

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:

• https://github.com/emacs-helm/helm/wiki/frame

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.

1.9 Helm’s basic operations and default key bindings

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).

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.

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.

1.12 Shortcuts for n-th first actions

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

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-relative³ package and helm-linum-relative-mode.

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

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.

1.14 Mouse control in Helm

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

• mouse-1 selects the candidate.
• mouse-2 executes the default action on selected candidate.
• mouse-3 pops up the action menu.

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.

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.

• To mark/unmark a candidate, use C-@. (See bindings below.) With a numeric prefix arg mark ARG candidates forward, if ARG is negative mark ARG candidates backward.
• To mark all visible unmarked candidates at once in current source use M-a. With a prefix argument, mark all candidates in all sources.
• To unmark all visible marked candidates at once use M-U.
• To mark/unmark all candidates at once use M-m. With a prefix argument, mark/unmark all candidates in all sources.

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.

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.

1.17 Frequently Used Commands

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.

• y mean yes
• no mean no
• ! mean yes for all
• q mean quit or abort current operation.

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

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.

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.

1.21 Global commands

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).

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.

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

https://github.com/emacs-helm/helm/wiki/Developing

1.24 Helm Map

2 Helm Buffer

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><negate-may-be><pattern-value>

‘<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.

Examples

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

• Match against buffer’s mode-name

  ‘*lisp’

  List only buffers whose mode-name name matches ‘lisp’.

  ‘*!lisp’

  List only buffers whose mode-name name does not match ‘lisp’.

  ‘*!lisp,!sh,!fun’

  List only buffers whose mode name does not match any of ‘lisp’, ‘sh’ or ‘fun’.

• Match against buffer’s content

  ‘@foo’

  List only those buffers that contain ‘foo’

  ‘@!foo’

  List only those buffers that do not contain ‘foo’.

  ‘@foo @bar’

  List only those buffers that contain both ‘foo’ and ‘bar’.

  ‘@foo @!bar’

  List only those buffers that contain ‘foo’ but not ‘bar’.

• Match against buffer’s directory

  ‘/src’

  List only buffers whose directory matches ‘src’.

• Match against buffer’s name in a fuzzy way
• Match against a combination of above criterion.

  ‘*lisp ^helm @moc’

  List only buffers that are in ‘lisp’ mode, whose name starts start with ‘helm’ and contains ‘moc’.

  ‘*lisp ^helm moc’

  List only buffers that are in ‘lisp’ mode, whose name starts start with ‘helm’ and whose name contains ‘moc’

  ‘*!lisp !helm’

  List only buffers that are NOT in ‘lisp’ mode and whose name does NOT match ‘helm’.

  ‘/helm/ w3’

  List only buffers whose directory matches ‘helm’ and whose name matches ‘w3’.

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 ’@’.

Red

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

Indianred2

Buffer exists but its file has been deleted.

Orange

Buffer is modified and not saved to disk.

Italic

A non-file buffer.

Yellow

Tramp archive buffer.

2.3 Commands

3 Helm Find Files

3.1 Overview

Quick pattern expansion

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

  The value of default-directory is the one at the beginning of the session. If you already are in the default-directory this will move the cursor to the top.

• Enter ‘../’ at end of pattern will reach upper directory, moving cursor to the top

  This is different from using C-l in that it moves the cursor to the top instead of remaining on the previous subdir name.

• Enter ‘..name/’ at end of pattern to start a recursive search

  It searches directories matching ‘name’ under the current directory, see the “Recursive completion on subdirectories” section below for more details.

• Any environment variable (e.g. ‘$HOME’) at end of pattern gets expanded
• Any valid filename yanked after pattern gets expanded
• Special case: URL at point

  The quick expansions do not take effect at the end of a URL, you must kill the pattern first (C-k).

Creating a file or directory:

• To create a new file, enter a filename not ending with ‘/’

  Note that when you enter a new name, this one is prefixed with [?] if you are in a writable directory. If you are in a directory where you have no write permission the new file name is not prefixed and is colored in red. There is not such distinction when using Tramp, new filename just appears on top of buffer.

• To create a new directory, append a ‘/’ to the new name and press RET
• You can create a new directory and a new file at the same time

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

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:

• ‘sh’ style, the ones supported by ‘file-expand-wildcards’. e.g. ‘*.el’, ‘*.[ch]’ which match respectively all ‘.el’ files or all ‘.c’ and ‘.h’ files.
• ‘bash’ style (partially) In addition to what allowed in ‘sh’ style you can specify file extensions that have more than one character like this: ‘*.{sh,py}’ which match ‘.sh’ and ‘.py’ files.

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.

• Navigate with arrow keys

  You can use <right> and <left> arrows to go down or up one level, to disable this customize helm-ff-lynx-style-map. Note that using setq will NOT work.

• Use C-j (persistent action) on a directory to go down one level

  On a symlinked directory a prefix argument expands to its true name.

• Use C-l or DEL on a directory to go up one level

  DEL behavior

  DEL by default deletes char backward.

  But when helm-ff-DEL-up-one-level-maybe is non nil DEL behaves differently depending on the contents of helm-pattern. It goes up one level if the pattern is a directory ending with ‘/’ or disables HFF auto update and delete char backward if the pattern is a filename or refers to a non existing path. Going up one level can be disabled if necessary by deleting ‘/’ at the end of the pattern using C-b and C-k.

  Note that when deleting char backward, Helm takes care of disabling update giving you the opportunity to edit your pattern for e.g. renaming a file or creating a new file or directory. When helm-ff-auto-update-initial-value is non nil you may want to disable it temporarily, see Toggle auto-completion for this.

• Use C-r to walk back the resulting tree of all the C-l or DEL you did

  The tree is reinitialized each time you browse a new tree with C-j or by entering some pattern in the prompt.

• RET behavior

  It behaves differently depending on helm-selection (current candidate in helm-buffer):

  candidate basename is ‘.’

  Open it in dired.

  candidate is a directory

  Expand it.

  candidate is a file

  Open it.

  If you have marked candidates and you press RET on a directory, Helm will navigate to this directory. If you want to exit with RET with default action with these marked candidates, press RET a second time while you are on the root of this directory e.g. ‘/home/you/dir/.’ or press RET on any file which is not a directory. You can also exit with default action at any moment with f1.

  Note that when copying, renaming, etc. from helm-find-files the destination file is selected with helm-read-file-name.

• TAB behavior

  Normally TAB is bound to helm-select-action in helm-map which display the action menu.

  You can change this behavior by setting in helm-find-files-map a new command for TAB:

  (define-key helm-find-files-map (kbd "C-i") ’helm-ff-TAB)
  

  It will then behave slighly differently depending of helm-selection:

  candidate basename is ‘.’

  open the action menu.

  candidate is a directory

  expand it (behave as C-j).

  candidate is a file

  open action menu.

  Called with a prefix arg open menu unconditionally.

• C-j behaviour

  C-j on a filename expands to that filename in the Helm buffer. Second hit displays the buffer filename. Third hit kills the buffer filename.

  C-u C-j displays the buffer directly.

  If you have mounted your filesystem with mountavfs, you can expand archives in the ‘~/.avfs’ directory with C-j. Expand archives as directories in a avfs directory

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.

3.2 Operate on files

3.2.1 Create a file or a directory

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.

3.2.3 Open files

1. Open files externally
   • Open file with external program (C-c C-x,C-u to choose).

     Helm is looking what is used by default to open file externally (mailcap files) but have its own variable helm-external-programs-associations to store external applications. If you call the action or its binding without prefix arg Helm will see if there is an application suitable in helm-external-programs-associations, otherwise it will look in mailcap files. If you want to specify which external application to use (and its options) use a prefix arg.

     Note: What you configure for Helm in helm-external-programs-associations will take precedence on mailcap files.

   • Preview file with external program (C-c C-v).

     Same as above but doesn’t quit Helm session, it is apersistent action.

   • Open file externally with default tool (C-c X).

     This uses xdg-open which sucks most of the time, but perhaps it works fine on Windows. This is why it is kept in Helm.

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.

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

      ‘.%’

      Substring

      ‘%:<from>:<to>’

      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:

        "\@/<regexp>/<replacement>/
        

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

        =\@:<from>:<to>=
        

      • 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

         foo.jpg
         bar.jpg
         baz.jpg
         

         to

         foo-001.jpg
         foo-002.jpg
         foo-003.jpg
         

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

         Example 2: To rename the files

         foo.jpg
         bar.jpg
         baz.jpg
         

         to

         foo-001.jpg
         bar-002.jpg
         baz-003.jpg
         

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

      3. Replace a substring

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

         Example: To rename files

         foo.jpg
         bar.jpg
         baz.jpg
         

         to

         fOo.jpg
         bAr.jpg
         bAz.jpg
         

         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.⁵ 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:

   • Copying from/to tramp sudo method may not work (permissions).
   • Copying from remote to remote is not supported (rsync restriction) however you can mount a remote with sshfs and copy to it (best), otherwise you have to modify the command line with a prefix arg.⁶

   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).

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.

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.⁷

   Warning:

   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-cli’⁸.

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

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.

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-git⁹ and/or helm-ls-hg¹⁰ 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.¹¹

   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.

      Examples:

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

      ‘Fd’¹² 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
      

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-!.

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:

• If you are in a (mail or message) buffer, files are attached there.
• If you are not in a mail buffer but one or more mail buffers exist, you are prompted to attach files to one of these mail buffers.
• If you are not in a mail buffer and no mail buffer exists, a new mail buffer is created with the attached files in it.

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.

• Grepping files is not very well supported when used incrementally. See Grepping on remote files.
• Locate does not work on remote directories.

• A TRAMP syntax crash course

  Please refer to TRAMP’s documentation for more details.

  • Connect to host 192.168.0.4 as user ‘foo’:

    /scp:192.168.0.4@foo:
    

  • Connect to host 192.168.0.4 as user ‘foo’ on port 2222:

    /scp:192.168.0.4@foo#2222:
    

  • Connect to host 192.168.0.4 as root using multihops syntax:

    /ssh:192.168.0.4@foo|sudo:192.168.0.4:
    

  Note: You can also use tramp-default-proxies-alist when connecting often to the same hosts.

  As a rule of thumb, prefer the scp method unless using multihops (which only works with the ssh method), especially when copying large files.

  You need to hit C-j once on top of a directory on the first connection to complete the pattern in the minibuffer.

• Display color for directories, symlinks etc… with tramp

  Starting at helm version 2.9.7 it is somewhat possible to colorize fnames by listing files without loosing performances with external commands (ls and awk) if your system is compatible. For this you can use helm-list-dir-external as value for helm-list-directory-function.

  See helm-list-directory-function documentation for more infos.

• Completing host

  As soon as you enter the first ‘:’ after method e.g ‘/scp:’ you will have some completion about previously used hosts or from your ‘~/.ssh/config’ file, hitting C-j or right on a candidate will insert this host in minibuffer without addind the ending ‘:’, second hit insert the last ‘:’. As soon the last ‘:’ is entered TRAMP will kick in and you should see the list of candidates soon after.

  When connection fails, be sure to delete your TRAMP connection with M-x helm-delete-tramp-connection before retrying.

• Editing local files as root

  Use the sudo method:

  /sudo:host:
  

  or

  simply /sudo::.
  

3.4 Misc. Remarks

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

   ~/elisp/helm/helm.el:1234
   

   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.

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.

Otherwise

insert relative file name.

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.

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.

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.

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.

3.5 Commands

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.

4.1 Tips

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.

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

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>.

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).

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.

4.2 Commands

5 Helm Generic files

5.1 Tips

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.¹³

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.

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

5.2 Commands

6 Helm fd

6.1 Tips

The Fd¹⁴ 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 options¹⁵ 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 colorized¹⁶.

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.¹⁷

Search is (pcre) regexp based¹⁸, and multi patterns are not supported.

6.2 Commands

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

7 Helm Grep

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.

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.

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).

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.

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

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-wgrep’¹⁹ to edit your changes, for Helm the package name is ‘wgrep-helm’, it is hightly recommended.

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.

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.

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.

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.

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.

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.

9 Helm AG

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.

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.

10.1 Commands

11 Helm PDFgrep Map

11.1 Commands

12 Helm Etags Map

12.1 Commands

13 Helm UCS

13.1 Tips

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

13.2 Commands

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

14 Helm bookmark name

14.1 Commands

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

15 Helm Eshell on file

15.1 Tips

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
   

15.1.2 Specify marked files as arguments

Example:

<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
...

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.

15.2 Commands

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

16 Helm Ido virtual buffers

16.1 Commands

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

17 Helm Moccur

17.1 Tips

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.

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.

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’.

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’.

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.

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.

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.

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.

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.

17.1.10 Refresh a saved buffer

Type g to update the buffer.

17.1.11 Edit a saved buffer

First, install ‘wgrep’²⁰ 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 ‘iedit’²¹ to modify all occurences at once in the buffer.

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.

17.1.13 Switch to next or previous source

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

17.2 Commands

18 Helm Top

18.1 Commands

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

19 Helm Elisp package

19.1 Tips

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))

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.

19.1.3 Meaning of flags prefixing packages

(Emacs ≥25)

• The flag ‘S’ that prefixes package names means that the packages belong to package-selected-packages.
• The flag ‘U’ that prefix package names mean that this package is no more needed.

19.2 Commands

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

20 Helm M-x

20.1 Tips

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

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 e ‘eeee’ will be inserted in prompt) so select the command you want to execute before specifying prefix arg.

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.

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.

21 Helm Imenu

21.1 Commands

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

22 Helm colors

22.1 Commands

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

23 Helm Semantic

23.1 Commands

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

24 Helm kmacro

24.1 Tips

• Start recording a kmacro with f3.
• End the kmacro recording with f4.
• Run helm-execute-kmacro to list all your kmacros.

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.

24.2 Commands

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

25 Helm kill ring

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.

25.2 Commands

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