Emacs can run compilers for languages such as C and Fortran, feeding the compilation log into an Emacs buffer. It can also parse the error messages and show you where the errors occurred.

M-x compile

Run a compiler asynchronously under Emacs, with error messages going to the *compilation* buffer.

M-x recompile, g (Compilation mode)

Invoke a compiler with the same command as in the last invocation of M-x compile.

M-x kill-compilation

Kill the running compilation subprocess.

To run make or another compilation command, type M-x compile. This reads a shell command line using the minibuffer, and then executes the command by running a shell as a subprocess (or inferior process) of Emacs. The output is inserted in a buffer named *compilation*. The current buffer's default directory is used as the working directory for the execution of the command, so by default compilation takes place in that directory. The default compilation command is make -k, which is usually correct for programs compiled using the make utility (the -k flag tells make to continue compiling as much as possible after an error). Make. If you have done M-x compile before, the command that you specified is automatically stored in the variable compile-command; this is used as the default the next time you type M-x compile. A file can also specify a file-local value for compile-command (File Variables). Starting a compilation displays the *compilation* buffer in another window but does not select it. While the compilation is running, the word run is shown in the major mode indicator for the *compilation* buffer, and the word Compiling appears in all mode lines. You do not have to keep the *compilation* buffer visible while compilation is running; it continues in any case. When the compilation ends, for whatever reason, the mode line of the *compilation* buffer changes to say exit (followed by the exit code: [0] for a normal exit), or signal (if a signal terminated the process). If you want to watch the compilation transcript as it appears, switch to the *compilation* buffer and move point to the end of the buffer. When point is at the end, new compilation output is inserted above point, which remains at the end. Otherwise, point remains fixed while compilation output is added at the end of the buffer. While compilation proceeds, the mode line shows the number of errors, warnings, and informational messages emitted by the compiler so far. If you change the variable compilation-scroll-output to a non-nil value, the *compilation* buffer scrolls automatically to follow the output. If the value is first-error, scrolling stops when the first error appears, leaving point at that error. For any other non-nil value, scrolling continues until there is no more output. To rerun the last compilation with the same command, type M-x recompile. This reuses the compilation command from the last invocation of M-x compile. It also reuses the *compilation* buffer and starts the compilation in its default directory, which is the directory in which the previous compilation was started. In *compilation* buffers this command is bound to g. Starting a new compilation also kills any compilation already running in *compilation*, as the buffer can only handle one compilation at any time. However, M-x compile and M-x recompile ask for confirmation before actually killing a compilation that is running; to always automatically kill the compilation without asking, change the variable compilation-always-kill to t. You can also kill a compilation process with the command M-x kill-compilation. To run two compilations at once, start the first one, then rename the *compilation* buffer (perhaps using rename-uniquely; Misc Buffer), then switch buffers and start the other compilation. This will create a new *compilation* buffer. You can control the environment passed to the compilation command with the variable compilation-environment. Its value is a list of environment variable settings; each element should be a string of the form "envvarname=value". These environment variable settings override the usual ones. Displaying extremely long lines in compilation output can slow Emacs down. Lines that are longer than compilation-max-output-line-length will have the portion that's exceeds that limit hidden behind a button that can be clicked on to reveal the hidden portion. Set this variable to nil to never hide anything.

The *compilation* buffer uses a major mode called Compilation mode. Compilation mode turns each error message in the buffer into a hyperlink; you can move point to it and type RET, or click on it with the mouse (Mouse References), to visit the locus of the error message in a separate window. The locus is the specific position in a file where that error occurred. The appearance of the *compilation* buffer can be controlled by customizing the faces which are used to highlight parts of the *compilation* buffer, e.g., compilation-error or compilation-warning, for error and warning messages respectively. Note that since those faces inherit from the error and warning faces, it is also possible to customize the parent face directly instead. Use M-x customize-group RET compilation to see the entire list of customization variables and faces. If you change the variable compilation-auto-jump-to-first-error to a non-nil value, Emacs automatically visits the locus of the first error message that appears in the *compilation* buffer. (This variable can also have the values if-location-known and first-known, which modify the conditions for automatically visiting the error locus.) Compilation mode provides the following additional commands. These commands can also be used in *grep* buffers, where the hyperlinks are search matches rather than error messages (Grep Searching).

M-g M-n, M-g n, C-x `

Visit the locus of the next error message or match (next-error).

M-g M-p, M-g p

Visit the locus of the previous error message or match (previous-error).

M-n

Move point to the next error message or match, without visiting its locus (compilation-next-error).

M-p

Move point to the previous error message or match, without visiting its locus (compilation-previous-error).

M-@}

Move point to the next error message or match occurring in a different file (compilation-next-file).

M-@{

Move point to the previous error message or match occurring in a different file (compilation-previous-file).

C-c C-f

Toggle Next Error Follow minor mode, which makes cursor motion in the compilation buffer produce automatic source display.

g

Re-run the last command whose output is shown in the *compilation* buffer.

M-x next-error-select-buffer

Select a buffer to be used by next invocation of next-error and previous-error.

To visit errors sequentially, type C-x ` (next-error), or equivalently M-g M-n or M-g n. This command can be invoked from any buffer, not just a Compilation mode buffer. The first time you invoke it after a compilation, it visits the locus of the first error message. Each subsequent M-g M-n visits the next error, in a similar fashion. If you visit a specific error with RET or a mouse click in the *compilation* buffer, subsequent M-g M-n commands advance from there. When M-g M-n finds no more error messages to visit, it signals an error. C-u M-g M-n starts again from the beginning of the compilation buffer, and visits the first locus. M-g M-p or M-g p (previous-error) iterates through errors in the opposite direction. The next-error and previous-error commands don't just act on the errors or matches listed in *compilation* and *grep* buffers; they also know how to iterate through error or match lists produced by other commands, such as M-x occur (Other Repeating Search). If the current buffer contains error messages or matches, these commands will iterate through them; otherwise, Emacs looks for a buffer containing error messages or matches amongst the windows of the selected frame (if the variable next-error-find-buffer-function is customized to the value next-error-buffer-on-selected-frame), then for a buffer used previously by next-error or previous-error, and finally all other buffers. Any buffer these commands iterate through that is not currently displayed in a window will be displayed. You can use the next-error-select-buffer command to switch to a different buffer to be used by the subsequent invocation of next-error. By default, the next-error and previous-error commands skip less important messages. The variable compilation-skip-threshold controls this. The default value, 1, means to skip anything less important than a warning. A value of 2 means to skip anything less important than an error, while 0 means not to skip any messages. When Emacs visits the locus of an error message, it momentarily highlights the relevant source line. The duration of this highlight is determined by the variable next-error-highlight for the locus in the selected buffer, and next-error-highlight-no-select for the locus in non-selected buffers. Also you can customize the variable next-error-message-highlight that defines how to highlight the current error message in the buffer that contains messages. If the *compilation* buffer is shown in a window with a left fringe (Fringes), the locus-visiting commands put an arrow in the fringe, pointing to the current error message. If the window has no left fringe, such as on a text terminal, these commands scroll the window so that the current message is at the top of the window. If you change the variable compilation-context-lines to t, a visible arrow is inserted before column zero instead. If you change the variable to an integer value n, these commands scroll the window so that the current error message is n lines from the top, whether or not there is a fringe; the default value, nil, gives the behavior described above. Compilation output can sometimes be very verbose, and much of it isn't of particular interest to a user. The compilation-hidden-output user option should either be a regexp or a list of regexps, and output that matches will be made invisible. For instance, to hide the verbose output from recursive makefiles, you can say something like:

(setq compilation-hidden-output
      '("^make[^\n]+\n"))

To parse messages from the compiler, Compilation mode uses the variable compilation-error-regexp-alist which lists various error message formats and tells Emacs how to extract the locus from each. A similar variable, grep-regexp-alist, tells Emacs how to parse output from a grep command (Grep Searching). Sometimes compilation-error-regexp-alist doesn't correctly determine the filename that is the source of the error. Use user option compilation-transform-file-match-alist to make any necessary adjustments, such as adding or changing a directory component, or even considering certain compiler messages not error messages at all. Compilation mode also defines the keys SPC and DEL to scroll by screenfuls; M-n (compilation-next-error) and M-p (compilation-previous-error) to move to the next or previous error message; and M-@{} (=compilation-next-file) and M-@= (compilation-previous-file) to move to the next or previous error message for a different source file. You can type C-c C-f to toggle Next Error Follow mode. In this minor mode, ordinary cursor motion in the compilation buffer automatically updates the source buffer, i.e., moving the cursor over an error message causes the locus of that error to be displayed. The features of Compilation mode are also available in a minor mode called Compilation Minor mode. This lets you parse error messages in any buffer, not just a normal compilation output buffer. Type M-x compilation-minor-mode to enable the minor mode. For instance, in an Rlogin buffer (Remote Host), Compilation minor mode automatically accesses remote source files by FTP (File Names).

This section includes various techniques and advice for using a shell and its features in compilation buffers. This material is specific to local compilations, and will most probably not work in (or be irrelevant to) compilation buffers whose default directory is on remote hosts. The M-x compile command uses a shell to run the compilation command, but specifies the option for a noninteractive shell. This means, in particular, that the shell should start with no prompt. If you find your usual shell prompt making an unsightly appearance in the *compilation* buffer, it means you have made a mistake in your shell's init file by setting the prompt unconditionally. (This init file may be named .bashrc, .profile, .cshrc, .shrc, etc., depending on what shell you use.) The shell init file should set the prompt only if there already is a prompt. Here's how to do it in bash:

if [ "$@{PS1+set@}" = set ]
then PS1=@dots{}
fi

And here's how to do it in csh:

if ($?prompt) set prompt = @dots{}

If you want to customize the value of the TERM environment variable passed to the compilation subshell, customize the variable comint-terminfo-terminal (Shell Options). Emacs does not expect a compiler process to launch asynchronous subprocesses; if it does, and they keep running after the main compiler process has terminated, Emacs may kill them or their output may not arrive in Emacs. To avoid this problem, make the main compilation process wait for its subprocesses to finish. In a shell script, you can do this using $! and wait, like this:

(sleep 10; echo 2nd)& pid=$!  # @r{Record pid of subprocess}
echo first message
wait $pid                     # @r{Wait for subprocess}

If the background process does not output to the compilation buffer, so you only need to prevent it from being killed when the main compilation process terminates, this is sufficient:

nohup @var{command}; sleep 1

On MS-DOS, asynchronous subprocesses are not supported, so M-x compile runs the compilation command synchronously (i.e., you must wait until the command finishes before you can do anything else in Emacs). MS-DOS.

Just as you can run a compiler from Emacs and then visit the lines with compilation errors, you can also run grep and then visit the lines on which matches were found. This works by treating the matches reported by grep as if they were errors. The output buffer uses Grep mode, which is a variant of Compilation mode (Compilation Mode).

M-x grep, M-x lgrep

Run grep asynchronously under Emacs, listing matching lines in the buffer named *grep*.

M-x grep-find, M-x find-grep, M-x rgrep

Run grep via find, and collect output in the *grep* buffer.

M-x zrgrep

Run zgrep and collect output in the *grep* buffer.

M-x kill-grep

Kill the running grep subprocess.

To run grep, type M-x grep, then enter a command line that specifies how to run grep. Use the same arguments you would give grep when running it normally: a grep-style regexp (usually in single-quotes to quote the shell's special characters) followed by file names, which may use wildcards. If you specify a prefix argument for M-x grep, it finds the identifier (Xref) in the buffer around point, and puts that into the default grep command. Your command need not simply run grep; you can use any shell command that produces output in the same format. For instance, you can chain grep commands, like this:

grep -nH -e foo *.el | grep bar | grep toto

The output from grep goes in the *grep* buffer. You can find the corresponding lines in the original files using M-g M-n, RET, and so forth, just like compilation errors. Compilation Mode, for detailed description of commands and key bindings available in the *grep* buffer. Some grep programs accept a --color option to output special markers around matches for the purpose of highlighting. You can make use of this feature by setting grep-highlight-matches to t. When displaying a match in the source buffer, the exact match will be highlighted, instead of the entire source line. Highlighting is provided via matching the ANSI escape sequences emitted by grep. The matching of the sequences is controlled by grep-match-regexp, which can be customized to accommodate different grep programs. As with compilation commands (Compilation), while the grep command runs, the mode line shows the running number of matches found and highlighted so far. The grep commands will offer to save buffers before running. This is controlled by the grep-save-buffers variable. The possible values are either nil (don't save), ask (ask before saving), or a function which will be used as a predicate (and is called with the file name as the parameter and should return non-nil if the buffer is to be saved). Any other non-nil value means that all buffers should be saved without asking. The default is ask. By default, grep matches are shown with the file names prefixed to each line. But if the variable grep-use-headings is customized to a non-nil value, the matches are split into sections, one section for each file with matches, and the file names are shown in the section headings using a special face grep-heading. The command M-x grep-find (also available as M-x find-grep) is similar to M-x grep, but it supplies a different initial default for the command—one that runs both find and grep, so as to search every file in a directory tree. See also the find-grep-dired command, in Dired and Find. The commands M-x lgrep (local grep) and M-x rgrep (recursive grep) are more user-friendly versions of grep and grep-find, which prompt separately for the regular expression to match, the files to search, and the base directory for the search. Case sensitivity of the search is controlled by the current value of case-fold-search. The command M-x zrgrep is similar to M-x rgrep, but it calls zgrep instead of grep to search the contents of gzipped files. These commands build the shell commands based on the variables grep-template (for lgrep) and grep-find-template (for rgrep). The files to search can use aliases defined in the variable grep-files-aliases. Directories listed in the variable grep-find-ignored-directories are automatically skipped by M-x rgrep. The default value includes the data directories used by various version control systems. By default, the shell commands constructed for lgrep, rgrep, and zgrep are abbreviated for display by concealing the part that contains a long list of files and directories to ignore. You can reveal the concealed part by clicking on the button with ellipsis, which represents them. You can also interactively toggle viewing the concealed part by typing M-x grep-find-toggle-abbreviation. To disable this abbreviation of the shell commands, customize the option grep-find-abbreviate to a nil value.

Flymake mode is a minor mode that performs on-the-fly syntax checking for many programming and markup languages, including C, C++, Perl, HTML, and TeX/LaTeX. It is somewhat analogous to Flyspell mode, which performs spell checking for ordinary human languages in a similar fashion (Spelling). As you edit a file, Flymake mode runs an appropriate syntax checking tool in the background, using a temporary copy of the buffer. It then parses the error and warning messages, and highlights the erroneous lines in the buffer. The syntax checking tool used depends on the language; for example, for C/C++ files this is usually the C compiler. Flymake can also use build tools such as make for checking complicated projects. To enable Flymake mode, type M-x flymake-mode. You can jump to the errors that it finds by using M-x flymake-goto-next-error and M-x flymake-goto-prev-error. To display a detailed overview of the diagnostics for the current buffer, use the command M-x flymake-show-buffer-diagnostics; to display a similar overview of diagnostics for the entire project (Projects), use M-x flymake-show-project-diagnostics. For more details about using Flymake, see Flymake.

The GUD (Grand Unified Debugger) library provides an Emacs interface to a wide variety of symbolic debuggers. It can run the GNU Debugger (GDB), as well as LLDB, DBX, SDB, XDB, Guile REPL debug commands, Perl's debugging mode, the Python debugger PDB, and the Java Debugger JDB. Emacs provides a special interface to GDB, which uses extra Emacs windows to display the state of the debugged program. GDB Graphical Interface. Emacs also has a built-in debugger for Emacs Lisp programs. The Lisp Debugger.

(gud-def @var{function} @var{cmdstring} @var{binding} @var{docstring})

+--------------------------------+--------------------------------+
|   GUD interaction buffer       |   Locals/Registers buffer      |
|--------------------------------+--------------------------------+
|   Primary Source buffer        |   I/O buffer for debugged pgm  |
|--------------------------------+--------------------------------+
|   Stack buffer                 |   Breakpoints/Threads buffer   |
+--------------------------------+--------------------------------+

Emacs has major modes for several variants of Lisp. They use the same editing commands as other programming language modes (Programs). In addition, they provide special commands for executing Lisp expressions.

Emacs Lisp mode

The mode for editing Emacs Lisp source files. It defines C-M-x to evaluate the current top-level Lisp expression. Lisp Eval.

Lisp Interaction mode

The mode for an interactive Emacs Lisp session. It defines C-j to evaluate the expression before point and insert its value in the buffer. Lisp Interaction.

Lisp mode

The mode for editing source files of programs that run in Lisps other than Emacs Lisp. It defines C-M-x to evaluate the current top-level expression in an external Lisp. External Lisp.

Inferior Lisp mode

The mode for an interactive session with an external Lisp which is being run as a subprocess (or inferior process) of Emacs. External Lisp.

Scheme mode

Like Lisp mode, but for Scheme programs.

Inferior Scheme mode

Like Inferior Lisp mode, but for Scheme.

Emacs Lisp code is stored in files whose names conventionally end in .el. Such files are automatically visited in Emacs Lisp mode. Emacs Lisp code can be compiled into byte-code, which loads faster, takes up less space, and executes faster. By convention, compiled Emacs Lisp code goes in a separate file whose name ends in .elc. For example, the compiled code for foo.el goes in foo.elc. Byte Compilation. Emacs Lisp code can also be compiled into native code: machine code not unlike the one produced by a C or Fortran compiler. Native code runs even faster than byte-code. Natively-compiled Emacs Lisp code is stored in files whose names end in .eln. Native Compilation. To load an Emacs Lisp file, type M-x load-file. This command reads a file name using the minibuffer, and executes the contents of that file as Emacs Lisp code. It is not necessary to visit the file first; this command reads the file directly from disk, not from an existing Emacs buffer. If an Emacs Lisp file is installed in the Emacs Lisp load path (defined below), you can load it by typing M-x load-library, instead of using M-x load-file. The M-x load-library command prompts for a library name rather than a file name; it searches through each directory in the Emacs Lisp load path, trying to find a file matching that library name. If the library name is /foo/, it tries looking for files named foo.elc, foo.el, and foo. (If Emacs was built with native compilation enabled, load-library looks for a .eln file that corresponds to foo.el and loads it instead of foo.elc.) The default behavior is to load the first file found. This command prefers .eln files over .elc files, and prefers .elc files over .el files, because compiled files load and run faster. If it finds that lib.el is newer than lib.elc, it issues a warning, in case someone made changes to the .el file and forgot to recompile it, but loads the .elc file anyway. (Due to this behavior, you can save unfinished edits to Emacs Lisp source files, and not recompile until your changes are ready for use.) If you set the option load-prefer-newer to a non-nil value, however, then rather than the procedure described above, Emacs loads whichever version of the file is newest. If Emacs was built with native compilation, and it cannot find the .eln file corresponding to lib.el, it will load a lib.elc and start native compilation of lib.el in the background, then load the .eln file when it finishes compilation. Emacs Lisp programs usually load Emacs Lisp files using the load function. This is similar to load-library, but is lower-level and accepts additional arguments. How Programs Do Loading. The Emacs Lisp load path is specified by the variable load-path. Its value should be a list of directories (strings). These directories are searched, in the specified order, by the M-x load-library command, the lower-level load function, and other Emacs functions that find Emacs Lisp libraries. An entry in load-path can also have the special value nil, which stands for the current default directory, but it is almost always a bad idea to use this, because its meaning will depend on the buffer that is current when load-path is used by Emacs. (If you find yourself wishing that nil were in the list, most likely what you really want is to use M-x load-file.) The default value of load-path is a list of directories where the Lisp code for Emacs itself is stored. If you have libraries of your own in another directory, you can add that directory to the load path. Unlike most other variables described in this manual, load-path cannot be changed via the Customize interface (Easy Customization), but you can add a directory to it by putting a line like this in your init file (Init File):

(add-to-list 'load-path "/path/to/my/lisp/library")

It is customary to put locally installed libraries in the site-lisp directory that is already in the default value of load-path, or in some subdirectory of site-lisp. This way, you don't need to modify the default value of load-path. Similarly to load-path, the list of directories where Emacs looks for *.eln files with natively-compiled Lisp code is specified by the variable native-comp-eln-load-path. Some commands are autoloaded; when you run them, Emacs automatically loads the associated library first. For instance, the M-x compile command (Compilation) is autoloaded; if you call it, Emacs automatically loads the compile library first. In contrast, the command M-x recompile is not autoloaded, so it is unavailable until you load the compile library. Automatic loading can also occur when you look up the documentation of an autoloaded command (Name Help), if the documentation refers to other functions and variables in its library (loading the library lets Emacs properly set up the hyperlinks in the *Help* buffer). To disable this feature, change the variable help-enable-autoload to nil. Automatic loading also occurs when completing names for describe-variable and describe-function, based on the prefix being completed. To disable this feature, change the variable help-enable-completion-autoload to nil. Once you put your library in a directory where Emacs can find and load it, you may wish to make it available at startup. This is useful when the library defines features that should be available automatically on demand, and manually loading the library is thus inconvenient. In these cases, make sure the library will be loaded by adding suitable forms to your init file: either load or require (if you always need to load the library at startup), or autoload if you need Emacs to load the library when some command or function is invoked. For example:

;; Loads @file{my-shining-package.elc} unconditionally.
 (require 'my-shining-package)
 ;; Will load @file{my-shining-package.elc} when @code{my-func} is invoked.
 (autoload 'my-func "my-shining-package")

Note that installing a package using package-install (Package Installation) takes care of placing the package's Lisp files in a directory where Emacs will find it, and also extends load-path as needed, making the above manual customizations unnecessary for such packages.

Emacs Lisp mode is the major mode for editing Emacs Lisp. Its mode command is M-x emacs-lisp-mode. Emacs provides several commands for evaluating Emacs Lisp expressions. You can use these commands in Emacs Lisp mode, to test your Emacs Lisp code as it is being written. For example, after re-writing a function, you can evaluate the function definition to make it take effect for subsequent function calls. These commands are also available globally, and can be used outside Emacs Lisp mode.

M-:

Read a single Emacs Lisp expression in the minibuffer, evaluate it, and print the value in the echo area (eval-expression).

C-x C-e

Evaluate the Emacs Lisp expression before point, and print the value in the echo area (eval-last-sexp).

C-M-x (in Emacs Lisp mode), M-x eval-defun

Evaluate the defun containing or after point, and print the value in the echo area (eval-defun).

M-x eval-region

Evaluate all the Emacs Lisp expressions in the region.

M-x eval-buffer

Evaluate all the Emacs Lisp expressions in the buffer.

M-: (eval-expression) reads an expression using the minibuffer, and evaluates it. (Before evaluating the expression, the current buffer switches back to the buffer that was current when you typed M-:, not the minibuffer into which you typed the expression.) The command C-x C-e (eval-last-sexp) evaluates the Emacs Lisp expression preceding point in the buffer, and displays the value in the echo area. When the result of an evaluation is an integer, it is displayed together with the value in other formats (octal, hexadecimal, and character if eval-expression-print-maximum-character, described below, allows it). If M-: or C-x C-e is given a prefix argument, it inserts the value into the current buffer at point, rather than displaying it in the echo area. If the prefix argument is zero, any integer output is inserted together with its value in other formats (octal, hexadecimal, and character). Such a prefix argument also prevents abbreviation of the output according to the variables eval-expression-print-level and eval-expression-print-length (see below). Similarly, a prefix argument of -1 overrides the effect of eval-expression-print-length. C-x C-e (eval-last-sexp) treats defvar expressions specially. Normally, evaluating a defvar expression does nothing if the variable it defines already has a value. But this command unconditionally resets the variable to the initial value specified by the defvar; this is convenient for debugging Emacs Lisp programs. defcustom and defface expressions are treated similarly. Note the other commands documented in this section, except eval-defun, do not have this special feature. The eval-defun command is bound to C-M-x in Emacs Lisp mode. It evaluates the top-level Lisp expression containing or following point, and prints the value in the echo area. In this context, a top-level expression is referred to as a "defun", but it need not be an actual defun (function definition). This command handles defvar=/=defcustom=/=defface forms the same way that eval-last-sexp does. With a prefix argument, C-M-x instruments the function definition for Edebug, the Emacs Lisp Debugger. Instrumenting for Edebug. The command M-x eval-region parses the text of the region as one or more Lisp expressions, evaluating them one by one. M-x eval-buffer is similar but evaluates the entire buffer. The options eval-expression-print-level and eval-expression-print-length control the maximum depth and length of lists to print in the result of the evaluation commands before abbreviating them. Supplying a zero prefix argument to eval-expression or eval-last-sexp causes lists to be printed in full. eval-expression-debug-on-error controls whether evaluation errors invoke the debugger when these commands are used; its default is t. eval-expression-print-maximum-character prevents integers which are larger than it from being displayed as characters.

When Emacs starts up, it contains a buffer named *scratch*, which is provided for evaluating Emacs Lisp expressions interactively. Its major mode is Lisp Interaction mode. You can also enable Lisp Interaction mode by typing M-x lisp-interaction-mode. If you kill the *scratch* buffer, you can recreate it with the M-x scratch-buffer command. In the *scratch* buffer, and other Lisp Interaction mode buffers, C-j (eval-print-last-sexp) evaluates the Lisp expression before point, and inserts the value at point. Thus, as you type expressions into the buffer followed by C-j after each expression, the buffer records a transcript of the evaluated expressions and their values. All other commands in Lisp Interaction mode are the same as in Emacs Lisp mode. At startup, the *scratch* buffer contains a short message, in the form of a Lisp comment, that explains what it is for. This message is controlled by the variable initial-scratch-message, which should be either a documentation string, or nil (which means to suppress the message). An alternative way of evaluating Emacs Lisp expressions interactively is to use Inferior Emacs Lisp mode, which provides an interface rather like Shell mode (Shell Mode) for evaluating Emacs Lisp expressions. Type M-x ielm to create an *ielm* buffer which uses this mode. For more information, see that command's documentation.

Lisp mode is the major mode for editing programs written in general-purpose Lisp dialects, such as Common Lisp. Its mode command is M-x lisp-mode. Emacs uses Lisp mode automatically for files whose names end in .l, .lsp, or .lisp. You can run an external Lisp session as a subprocess or inferior process of Emacs, and pass expressions to it to be evaluated. To begin an external Lisp session, type M-x run-lisp. This runs the program named lisp, and sets it up so that both input and output go through an Emacs buffer named *inferior-lisp*. To change the name of the Lisp program run by M-x run-lisp, change the variable inferior-lisp-program. The major mode for the *lisp* buffer is Inferior Lisp mode, which combines the characteristics of Lisp mode and Shell mode (Shell Mode). To send input to the Lisp session, go to the end of the *lisp* buffer and type the input, followed by RET. Terminal output from the Lisp session is automatically inserted in the buffer. When you edit a Lisp program in Lisp mode, you can type C-M-x (lisp-eval-defun) to send an expression from the Lisp mode buffer to a Lisp session that you had started with M-x run-lisp. The expression sent is the top-level Lisp expression at or following point. The resulting value goes as usual into the *inferior-lisp* buffer. Note that the effect of C-M-x in Lisp mode is thus very similar to its effect in Emacs Lisp mode (Lisp Eval), except that the expression is sent to a different Lisp environment instead of being evaluated in Emacs. The facilities for editing Scheme code, and for sending expressions to a Scheme subprocess, are very similar. Scheme source files are edited in Scheme mode, which can be explicitly enabled with M-x scheme-mode. You can initiate a Scheme session by typing M-x run-scheme (the buffer for interacting with Scheme is named *scheme*), and send expressions to it by typing C-M-x.