Helm is providing completion on all functions in emacs using ‘completing-read’ and derived and ‘completion-in-region’, it uses generic functions for this.

For the functions using ‘completing-read’ and derived e.g ‘read-file-name’ helm have a user variable that allows controlling which function to use for a specific emacs command, it is ‘helm-completing-read-handlers-alist’, it allows also disabling helm completion for a specific command when the specified function is nil. See its documentation for more infos.

Sometimes you have helm functions that do the same completion as other emacs vanilla helmized functions, e.g ‘switch-to-buffer’ and ‘helm-buffers-list’, you have to understand that the native helm functions like ‘helm-buffers-list’ can receive new features, allow marking candidates, have several actions and much more whereas the emacs vanilla helmized functions have only a helm completion, one action and no more what emacs provide for this function, it is the intended behavior.

So generally you have better time using the native helm command generally much more featured than the emacs function helmized than ‘helm-mode’.

When creating a new buffer use C-u to choose a mode for your buffer in a list. This list is customizable, see ‘helm-buffers-favorite-modes’.

You have a command to kill buffer(s) and quit emacs and a command to kill buffers one by one (no marked) without quitting helm.

You can run this persistent kill buffer command either with the regular ‘helm-execute-persistent-action’ called with a prefix arg (C-u C-j) or with its specific command ‘helm-buffer-run-kill-persistent’ see binding below.

Remote buffers are prefixed with ’@’. Red => Buffer have its file modified on disk by an external process. Indianred2 => Buffer exists but its file have been deleted. Orange => Buffer is modified and its file not saved to disk. Italic => A non–file buffer.

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.

Helm is using ‘ffap’ partially or completely to find file at point depending on value of ‘helm-ff-guess-ffap-filenames’. You can use full ‘ffap’ by setting this to non-nil (annoying). Default value is nil which make ‘ffap’ working partially.

e.g. "fob" or "fbr" will complete "foobar" but "fb" will wait for a third char for completing.

Second hit on ‘C-j’ will display buffer filename. Third hit on ‘C-j’ will kill buffer filename. NOTE: ‘C-u C-j’ will display buffer directly.

You can also use ‘helm-follow-action-forward’ and ‘helm-follow-action-backward’ (‘C-<down’ and ‘C-<left>’).

It is useful when auto completion is enabled and when trying to create a new file or directory you want to prevent helm trying to complete what you are writing. NOTE: On a terminal C-<backspace> may not work, use in this case C-c <backspace>.

Just write the path in prompt and press ‘<RET>’. e.g. You can create "~/new/newnew/newnewnew/my_newfile.txt".

On insertion (no completion, i.e nothing at point):

• ‘C-c i’ => insert absolute file name.
• ‘C-u C-c i’ => insert abbreviate file name.
• ‘C-u C-u C-c i’ => insert relative file name.

On completion:

• target starts by ~/ => insert abbreviate file name.
• target starts by / or [a-z]:/ => insert full path.
• otherwise => insert relative file name.

Use of wilcard is supported to give a set of files to an action:

e.g. You can copy all the files with ".el" extension by using "*.el" and then run your copy action.

You can do the same but with "**.el" (note the two stars), this will select recursively all ".el" files under current directory.

Note that when copying recursively files, you may have files with same name dispatched in the different subdirectories, so when copying them in the same directory they would be overwrited. To avoid this helm have a special action called "backup files" that have the same behavior as the command line "cp –backup=numbered", it allows you copying for example many *.jpg files with the same name from different subdirectories in one directory. Files with same name are renamed like this: "foo.txt.~1~". NOTE: This command is available only when ‘dired-async-mode’ is used.

NOTE: When using an action that involve an external backend (e.g. grep), using "**" is not advised (even if it works fine) because it will be slower to select all your files, you have better time letting the backend doing it, it will be faster. However, if you know you have not many files it is reasonable to use this, also using not recursive wilcard (e.g. "*.el") is perfectly fine for this.

This feature ("**") is activated by default with the option ‘helm-file-globstar’. It is different than the bash shopt globstar feature in that to list files with a named extension recursively you just have to specify e.g "*.el" whereas in bash you have to specify "**/.el" which is not convenient as "**.el". The directory selection with "**/" like bash shopt globstar option is not supported yet.

You can rename your files by replacing only part of filenames matching a regexp.

e.g Rename recursively all files with ".JPG" extension to ".jpg": Use the helm-file-globstar feature described in previous section by entering at end of helm-find-files pattern "**.JPG", then hit ‘M-%‘, at first prompt enter "JPG", at second "jpg" and hit ‘RET‘.

Shortcut for basename without extension, only extension or all are available:

• Basename without extension => "%."
• Only extension => ".%"
• All => "%"

So in the example above you could do instead: At first prompt enter ".%", at second "jpg" and hit ‘RET‘. Note that when using this instead of using "JPG" at first prompt, all extensions will be renamed to "jpg" even if the extension of one of the files is e.g "png".

If you want to rename a serie of files from number 001 to 00x use \# inside the replacement string when you will be prompted for it.

e.g To rename the files "foo.jpg" "bar.jpg" and "baz.jpg" to "foo-001.jpg" "foo-002.jpg" "foo-003.jpg"

Use as replace regexp "%." and as replacement string "foo-\#". Where "%." is same as regexp ".*\.jpg".

Note: You can do this with the serial renames actions you will find in the action menu for more sophisticated renaming, but using query replace regexp on filenames is a fast way for most common serial replacements.

Note also that unlike the serial rename actions the renamed files stay in their initial directory and are not renamed to current directory, IOW use this (\#) to rename files inside current directory.

In the second prompt (replace regexp with) shortcut for ‘upcase’, ‘downcase’ and ‘capitalize’ are available, respectively ‘%u’, ‘%d’ and ‘%c’.

If you use async library (if you have installed helm from MELPA you do) you can enable async for copying/renaming etc… your files by enabling ‘dired-async-mode’.

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

You can bookmark your ‘helm-find-files’ session with ‘C-x r m’. You can retrieve later these bookmarks easily by using M-x helm-filtered-bookmarks or from the current ‘helm-find-files’ session just hitting ‘C-x r b’.

You can grep individual files from ‘helm-find-files’ by using ‘C-s’. This same command can grep also recursively files from current directory when called with a prefix arg, you will be prompted in this case 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 setup this. For compressed files or archives, use zgrep with ‘M-g z’.

Otherwise you can use other recursive commands like ‘M-g a’ or ‘M-g g’ that are much more faster than using ‘C-s’ with a prefix arg. See ‘helm-grep-ag-command’ and ‘helm-grep-git-grep-command’ to setup this.

You can also use the gid shell command ‘M-g i’ from id-utils by creating an ID index file with the ‘mkid’ shell command coming with the id-utils package.

All these grep commands are using symbol at point as default pattern. Note that default is a different thing than input (nothing is added to prompt until you hit ‘M-n’).

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 your "*.tar.gz" files from ‘helm-find-files’:

1. Create an alias named untargz (or whatever) in eshell with the

command "alias untargz tar zxvf $*"

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

mark files if needed) and hit ‘M-!’.

Note:

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

example foo example bar example baz

However with a prefix arg it will apply ‘example’ on each file:

example foo bar baz

Of course the alias command should support this.

‘helm-find-files’ is working fine with tramp with however some limitations.

• By default filenames are not highlighted when working on remote directories,

this is controled by ‘helm-ff-tramp-not-fancy’ variable, if you change this, expect helm becoming very slow unless your connection is super fast.

• Grepping files is not very well supported when used incrementally, see above

grep section.

• Locate is not working on remote directories.

By default ‘helm-read-file-name’ use the persistent actions of ‘helm-find-files’

When you want to delete backward characters, e.g. to create a new file or directory, autoupdate may keep updating to an existent directory preventing you from doing so. In this 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 C-<backspace> may not work, use in this case C-c <backspace>.

You can add after writing search pattern any of the locate command line options. e.g. -b, -e, -n <number>…etc. See Man locate for more infos.

Some other sources (at the moment recentf and file in current directory sources) 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 your patterns with spaces, fuzzy matching will be disabled and search will be done on the full filename. Note that in multimatch fuzzy is completely disabled, which mean that each pattern should be a compliant regexp matching pattern (i.e "helm" will match "helm" but "hlm" will NOT match "helm").

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

Recursively search files using "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 options directly to find after a "*" separator. For example, this would find all files matching "book" that are larger than 1 megabyte:

book * -size +1M

However now that helm support git-grep and AG, you have better time using one of those for your recursives search.

Once in this buffer you can use emacs-wgrep (external package not bundled with helm) to edit your changes.

Just add a space between each pattern like in most helm commands.

Grepping on remote file will work only with grep, not ack-grep, but it is anyway bad supported as tramp doesn’t support multiple process running in a short delay (less than 5s actually) among other things, so I strongly advice hitting ‘C-!’ (i.e suspend process) before entering anything in pattern, and hit again ‘C-!’ when your regexp is ready to send to remote process, even if helm is handling this by delaying each process at 5s. Or even better don’t use tramp at all and mount your remote file system on SSHFS.

Normally your command or alias will be called with file as argument. E.g.,

<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 your command will look at this:

<command> ’candidate_file’ [extra_args]

E.g. <command> file1 file2 …

Call ‘helm-find-files-eshell-command-on-file’ with one prefix-arg Otherwise you can pass one prefix-arg from the command selection buffer. NOTE: This is not working on remote files.

With two prefix-arg before starting or from the command selection buffer the output is printed to your ‘current-buffer’.

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

<command> file1 <command> file2 etc…

Multiple regexp matching is allowed, just enter a space to separate your regexps.

Matching empty lines is supported with the regexp "^$", you will get the results with only the buffer-name and the line number, you can of course save and edit these results (i.e add text to the empty line) .

You can match automatically the symbol at point, but keeping the minibuffer empty ready to write into. This is disabled by default, to enable this you have to add ‘helm-source-occur’ and ‘helm-source-moccur’ to ‘helm-sources-using-default-as-input’.

You can do this with ‘C-j’ (persistent-action), to do it repetitively you can use ‘C-<up>’ and ‘C-<down>’ or enable ‘helm-follow-mode’ with ‘C-c C-f’.

Same as with helm-grep, you can save the results with ‘C-x C-s’. Of course if you don’t save your results, you can get back your session with ‘helm-resume’.

When the buffer(s) where you ran helm-(m)occur have been modified, you will be warned of this with the buffer flashing to red, you can refresh the buffer by running ‘C-c C-u’. This can be done automatically by customizing ‘helm-moccur-auto-update-on-resume’.

Type ‘g’ to update your buffer.

First, install wgrep https://github.com/mhayashi1120/Emacs-wgrep and then:

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

Tip: Use the excellent iedit https://github.com/tsdh/iedit to modify occurences in your buffer.

When using async (if you have installed from MELPA you do), only helm, helm-core, and magit are compiled asynchronously, if you want all your packages compiled async, add to your init file:

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

On initial start (when emacs is fetching packages on remote), if helm find package to upgrade it will start in the upgradables packages view showing the packages availables to upgrade. On further starts, you will have to refresh the list with ‘C-c C-u’, if helm find upgrades you will have a message telling you some packages are available for upgrade, you can switch to upgrade view (see below) to see what packages are available for upgrade or just hit ‘C-c U’. to upgrade all.

To see upgradables packages hit <M-U>.

Then you can install all upgradables packages with the upgrade all action (‘C-c C-u’), or upgrade only the specific packages by marking them (the new ones) and running the upgrade action (visible only when there is upgradables 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.

• The flag "S" that prefix package names mean that this package is one of ‘package-selected-packages’.

This feature is only available with emacs-25.

• The flag "U" that prefix package names mean that this package is no more needed.

This feature is only available with emacs-25.

When you want pass prefix args, you should pass prefix args AFTER starting ‘helm-M-x’, you will see a prefix arg counter appearing in mode-line notifying you the number of prefix args entered.

If you pass prefix args before running ‘helm-M-x’, it will be displayed in prompt, then the first C-u after ‘helm-M-x’ will be used to clear that prefix args.