You can execute an external shell command from within Emacs using `
‘shell-command’). The output from the shell command is displayed in the minibuffer or in a separate buffer, depending on the output size.
To provide the region text to the shell command as input, use `
‘shell-command-on-region’). If you want the shell to replace the region text with the output from the shell command, use `
‘*Shell Command Buffer*’ is displayed briefly whenever you run a shell command. You can switch to that buffer using
If you are programming using an interpreted language, such as Perl or Python, or a shell script, such as BASH, you might want to run your entire program through the interpreter. To do that, use
‘C-x h’ (
‘mark-whole-buffer’), then use `
M-|’ to send all of the buffer text to the interpreter.
This function runs a command with the whole buffer as input:
(defun shell-command-on-buffer () "Asks for a command and executes it in inferior shell with current buffer as input." (interactive) (shell-command-on-region (point-min) (point-max) (read-shell-command "Shell command on buffer: ")))
You can also bind this function with a key:
(global-set-key (kbd "M-\"") 'shell-command-on-buffer)
Running external programs from emacs as Windows Manager programs (Dmenu/Rofi):
(defun e-run-command () "Run external system programs. Dmenu/Rofi-like. Tab/C-M-i to completion n-[b/p] for walk backward/forward early commands history." (interactive) (require 'subr-x) (start-process "RUN" "RUN" (string-trim-right (read-shell-command "RUN: "))))
Starting with Emacs 23,
‘TAB’ completion is available for `
M-!’ and `
M-|’. The following libraries provide such a feature for earlier Emacs versions:
Icicles enhances the vanilla
‘TAB’ completion for `
M-!’ and `
M-|’. Whenever there are two or more candidate completions, you can use any Icicles completion features (cycling, progressive completion, apropos completion, and so on). See Icicles - Completion in Comint Modes.
You can run a shell command asynchronously by adding an ampersand (
&) after it, if you have a UNIX or UNIX-like environment.
Here is some EmacsLisp code that modifies
‘shell-command’ to allow many commands to execute asynchronously (and show the command at the top of the buffer):
(defadvice erase-buffer (around erase-buffer-noop) "make erase-buffer do nothing") (defadvice shell-command (around shell-command-unique-buffer activate compile) (if (or current-prefix-arg (not (string-match "[ \t]*&[ \t]*\\'" command)) ;; background (bufferp output-buffer) (stringp output-buffer)) ad-do-it ;; no behavior change ;; else we need to set up buffer (let* ((command-buffer-name (format "*background: %s*" (substring command 0 (match-beginning 0)))) (command-buffer (get-buffer command-buffer-name))) (when command-buffer ;; if the buffer exists, reuse it, or rename it if it's still in use (cond ((get-buffer-process command-buffer) (set-buffer command-buffer) (rename-uniquely)) ('t (kill-buffer command-buffer)))) (setq output-buffer command-buffer-name) ;; insert command at top of buffer (switch-to-buffer-other-window output-buffer) (insert "Running command: " command "\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\n") ;; temporarily blow away erase-buffer while doing it, to avoid ;; erasing the above (ad-activate-regexp "erase-buffer-noop") ad-do-it (ad-deactivate-regexp "erase-buffer-noop"))))
Another way to run commands asynchronously, without Emacs stopping at all when the process is started, is using .
There is a little library called Execute.el that redefines `
M-!’ key for executing various external process. If you have problems when you want to execute two or more programs using `
M-!’ or `
M-&’, you may want to try this.
Alternatively, you can use the package Dizzee at []. The Dizzee package allows you to name various asynchronous subprocesses, and allows you to start, stop and reload them as needed. Also, there is the concept of process groups, which allows you to group together like processes. (For instance, you might have a “webdev” process group, which would start up an apache server, tomcat server, mysql, etc. etc.)
shell-commandruns the program as a child, even when done asynchronously
start-processalso runs as a child process
Both commands result in the child process being killed when emacs is shutdown. For a command to have the ability to stay alive past that point you’ll need to use
call-process to start the program as its own distinct process.
(call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS)
0 runs the program asynchronously, while
nil will wait for the process to exits before resuming emacs.
When running Emacs in a terminal (with
emacs -nw), is it possible to execute a command in the parent shell without suspending Emacs? I know that one can press
‘C-z’, type a command and then resume Emacs with
fg, but I would like to communicate with the parent shell from “within” Emacs. – VegardOye
I don’t know of a way to do exactly what you ask for – I’m not even sure what it would look like, given that in this scenario Emacs “owns” the terminal and the parent shell process is presumably blocking until Emacs either exits or (as you have indicated) suspends – but if you use a terminal multiplexer like GnuScreen or tmux there are various Emacs Lisp packages and utilities in this wiki’s ElispArea and in the various ELPA-like package repositories which enable Emacs to communicate with, and control, a shell – or indeed any other process – running in one of the (other) virtual terminals managed by screen/tmux.
Is there a built-in function that returns the output of a shell command as a string? For instance:
(message (WHATEVER "echo the message"))
Would display the message:
In the status bar?
(message (exec-to-string "pwd")) ;; or (insert (exec-to-string "ls /etc"))
This executes the command in some kind of shell, and (some) normal shell magic happens:
(shell-command-to-string "echo -test! $x-") "-test! - "
In this case, command history is not accessed with `
!’, but the shell variable
‘x’ is looked up and replaced with a space char. You can quote each “word” in your command seperately, and run the result, like this:
(defun execvp (&rest args) "Simulate C's execvp() function. Quote each argument seperately, join with spaces and call shell-command-to-string to run in a shell." (let ((cmd (mapconcat 'shell-quote-argument args " "))) (shell-command-to-string cmd)))
(execvp "touch" "'a'" "b" "$x") creates files called
‘b’, and `
$x’ in whatever directory you happen to be in.
Is it possible (desirable?) to automatically close buffer
*Shell Command Output* for commands that report
‘Shell command succeeded with no output’?
Quick solution: Use module execute.el and comment the line (display-buffer (process-buffer proc-obj))
How can you use
‘shell-command’ with programs that require input such as passords? Kind of annoying having to open a new buffer just to
‘scp’ a file.
;;Don't echo passwords when communicating with interactive programs: (add-hook 'comint-output-filter-functions 'comint-watch-for-password-prompt)
‘ex-defun’defines an EmacsLisp function that does its job by invoking an external interpreted language
‘run-command’allows creating dynamic lists of external commands and selecting from them using auto-completion