Using Multiple Buffers
**********************

The text you are editing in Emacs resides in an object called a buffer.  Each time you visit a file, a buffer is used to hold the file's text.  Each time you invoke Dired, a buffer is used to hold the directory listing.  If you send a message with C-x m, a buffer is used to hold the text of the message.  When you ask for a command's documentation, that appears in a buffer named *Help*.

Buffers exist as long as they are in use, and are deleted (``killed'') when no longer needed, either by you (see Kill Buffer) or by Emacs (e.g., when you exit Emacs, see Exiting).

Each buffer has a unique name, which can be of any length.  When a buffer is displayed in a window, its name is shown in the mode line (see Mode Line).  The distinction between upper and lower case matters in buffer names.  Most buffers are made by visiting files, and their names are derived from the files' names; however, you can also create an empty buffer with any name you want.  A newly started Emacs has several buffers, including one named *scratch*, which can be used for evaluating Lisp expressions and is not associated with any file (see Lisp Interaction).

At any time, one and only one buffer is selected; we call it the current buffer.  We sometimes say that a command operates on ``the buffer''; this really means that it operates on the current buffer.  When there is only one Emacs window, the buffer displayed in that window is current.  When there are multiple windows, the buffer displayed in the selected window is current.  See Windows.

A buffer's contents consist of a series of characters, each of which optionally carries a set of text properties (see Text properties) that can specify more information about that character.

Aside from its textual contents, each buffer records several pieces of information, such as what file it is visiting (if any), whether it is modified, and what major mode and minor modes are in effect (see Modes).  These are stored in buffer-local variables---variables that can have a different value in each buffer. See Locals.

A buffer's size cannot be larger than some maximum, which is defined by the largest buffer position representable by Emacs integers. This is because Emacs tracks buffer positions using that data type. For typical 64-bit machines, this maximum buffer size is 2^61 - 2 bytes, or about 2 EiB.  For typical 32-bit machines, the maximum is usually 2^29 - 2 bytes, or about 512 MiB.  Buffer sizes are also limited by the amount of memory in the system.

Creating and Selecting Buffers
==============================

C-x b BUFFER RET
     Select or create a buffer named BUFFER (switch-to-buffer).

C-x 4 b BUFFER RET
     Similar, but select BUFFER in another window (switch-to-buffer-other-window).

C-x 5 b BUFFER RET
     Similar, but select BUFFER in a separate frame (switch-to-buffer-other-frame).

C-x LEFT
     Select the previous buffer in the buffer list (previous-buffer).

C-x RIGHT
     Select the next buffer in the buffer list (next-buffer).

C-u M-g M-g
C-u M-g g
     Read a number N and move to line N in the most recently selected buffer other than the current buffer, in another window.

The C-x b (switch-to-buffer) command reads a buffer name using the minibuffer.  Then it makes that buffer current, and displays it in the currently-selected window.  An empty input specifies the buffer that was current most recently among those not now displayed in any window.

While entering the buffer name, you can use the usual completion and history commands (see Minibuffer).  Note that C-x b, and related commands, use permissive completion with confirmation for minibuffer completion: if you type RET when the minibuffer text names a nonexistent buffer, Emacs prints [Confirm] and you must type a second RET to submit that buffer name. See Completion Exit, for details.  For other completion options and features, see Completion Options.

If you specify a buffer that does not exist, C-x b creates a new, empty buffer that is not visiting any file, and selects it for editing.  The default value of the variable major-mode determines the new buffer's major mode; the default value is Fundamental mode.  See Major Modes.  One reason to create a new buffer is to use it for making temporary notes.  If you try to save it, Emacs asks for the file name to use, and the buffer's major mode is re-established taking that file name into account (see Choosing Modes).

For conveniently switching between a few buffers, use the commands C-x LEFT and C-x RIGHT.  C-x LEFT (previous-buffer) selects the previous buffer (following the order of most recent selection in the current frame), while C-x RIGHT (next-buffer) moves through buffers in the reverse direction.  Both commands support a numeric prefix argument that serves as a repeat count.

To select a buffer in a window other than the current one (see Windows), type C-x 4 b (switch-to-buffer-other-window).  This prompts for a buffer name using the minibuffer, displays that buffer in another window, and selects that window.

Similarly, C-x 5 b (switch-to-buffer-other-frame) prompts for a buffer name, displays that buffer in another frame (see Frames), and selects that frame.  If the buffer is already being shown in a window on another frame, Emacs selects that window and frame instead of creating a new frame.

See Displaying Buffers, for how the C-x 4 b and C-x 5 b commands get the window and/or frame to display in.

In addition, C-x C-f, and any other command for visiting a file, can also be used to switch to an existing file-visiting buffer. See Visiting.

C-u M-g M-g, that is goto-line with a plain prefix argument, reads a number N using the minibuffer, selects the most recently selected buffer other than the current buffer in another window, and then moves point to the beginning of line number N in that buffer.  This is mainly useful in a buffer that refers to line numbers in another buffer: if point is on or just after a number, goto-line uses that number as the default for N.  Note that prefix arguments other than just C-u behave differently. C-u 4 M-g M-g goes to line 4 in the current buffer, without reading a number from the minibuffer.  (Remember that M-g M-g without prefix argument reads a number N and then moves to line number N in the current buffer.  See Moving Point.)

Emacs uses buffer names that start with a space for internal purposes. It treats these buffers specially in minor ways---for example, by default they do not record undo information.  It is best to avoid using such buffer names yourself.

Listing Existing Buffers
========================

C-x C-b
     List the existing buffers (list-buffers).

To display a list of existing buffers, type C-x C-b.  This pops up a buffer menu in a buffer named *Buffer List*.  Each line in the list shows one buffer's name, size, major mode and visited file. The buffers are listed in the order that they were current; the buffers that were current most recently come first.  This section describes how the list of buffers is displayed and how to interpret the various indications in the list; see Several Buffers, for description of the special mode in the *Buffer List* buffer and the commands available there.

. in the first field of a line indicates that the buffer is current.  % indicates a read-only buffer.  * indicates that the buffer is modified.  If several buffers are modified, it may be time to save some with C-x s (see Save Commands). Here is an example of a buffer list:

     CRM Buffer                Size  Mode              File
     . * .emacs                3294  Emacs-Lisp        ~/.emacs
      %  *Help*                 101  Help
         search.c             86055  C                 ~/cvs/emacs/src/search.c
      %  src                  20959  Dired by name     ~/cvs/emacs/src/
       * *mail*                  42  Mail
      %  HELLO                 1607  Fundamental       ~/cvs/emacs/etc/HELLO
      %  NEWS                481184  Outline           ~/cvs/emacs/etc/NEWS
         *scratch*              191  Lisp Interaction
       * *Messages*            1554  Messages

The buffer *Help* was made by a help request (see Help); it is not visiting any file.  The buffer src was made by Dired on the directory ~/cvs/emacs/src/.  You can list only buffers that are visiting files by giving the command a prefix argument, as in C-u C-x C-b.

list-buffers omits buffers whose names begin with a space, unless they visit files: such buffers are used internally by Emacs.

Miscellaneous Buffer Operations
===============================

C-x C-q
     Toggle read-only status of buffer (read-only-mode).

M-x rename-buffer RET BUFFER RET
     Change the name of the current buffer.

M-x rename-uniquely
     Rename the current buffer by adding <NUMBER> to the end.

M-x view-buffer RET BUFFER RET
     Scroll through buffer BUFFER.  See View Mode.

A buffer can be read-only, which means that commands to insert or delete its text are not allowed.  (However, other commands, like C-x RET f, can still mark it as modified, see Text Coding).  The mode line indicates read-only buffers with %% or %* near the left margin.  See Mode Line.  Read-only buffers are usually made by subsystems such as Dired and Rmail that have special commands to operate on the text.  Visiting a file whose access control says you cannot write it also makes the buffer read-only.

The command C-x C-q (read-only-mode) makes a read-only buffer writable, and makes a writable buffer read-only.  This works by setting the variable buffer-read-only, which has a local value in each buffer and makes the buffer read-only if its value is non-nil.  If you change the option view-read-only to a non-nil value, making the buffer read-only with C-x C-q also enables View mode in the buffer (see View Mode).

M-x rename-buffer changes the name of the current buffer.  You specify the new name as a minibuffer argument; there is no default. If you specify a name that is in use for some other buffer, an error happens and no renaming is done.

M-x rename-uniquely renames the current buffer to a similar name with a numeric suffix added to make it both different and unique. This command does not need an argument.  It is useful for creating multiple shell buffers: if you rename the *shell* buffer, then do M-x shell again, it makes a new shell buffer named *shell*; meanwhile, the old shell buffer continues to exist under its new name.  This method is also good for mail buffers, compilation buffers, and most Emacs features that create special buffers with particular names.  (With some of these features, such as M-x compile, M-x grep, you need to switch to some other buffer before using the command again, otherwise it will reuse the current buffer despite the name change.)

The commands M-x append-to-buffer and M-x insert-buffer can also be used to copy text from one buffer to another. See Accumulating Text.

Killing Buffers
===============

If you continue an Emacs session for a while, you may accumulate a large number of buffers.  You may then find it convenient to kill the buffers you no longer need.  (Some other editors call this operation close, and talk about ``closing the buffer'' or ``closing the file'' visited in the buffer.)  On most operating systems, killing a buffer releases the memory Emacs used for the buffer back to the operating system so that other programs can use it.  Here are some commands for killing buffers:

C-x k BUFFER RET
     Kill buffer BUFFER (kill-buffer).

M-x kill-some-buffers
     Offer to kill each buffer, one by one.

M-x kill-matching-buffers
     Offer to kill all buffers matching a regular expression.

C-x k (kill-buffer) kills one buffer, whose name you specify in the minibuffer.  The default, used if you type just RET in the minibuffer, is to kill the current buffer.  If you kill the current buffer, another buffer becomes current: one that was current in the recent past but is not displayed in any window now.  If you ask to kill a file-visiting buffer that is modified, then you must confirm with yes before the buffer is killed.

The command M-x kill-some-buffers asks about each buffer, one by one.  An answer of yes means to kill the buffer, just like kill-buffer.  This command ignores buffers whose names begin with a space, which are used internally by Emacs.

The command M-x kill-matching-buffers prompts for a regular expression and kills all buffers whose names match that expression. See Regexps.  Like kill-some-buffers, it asks for confirmation before each kill.  This command normally ignores buffers whose names begin with a space, which are used internally by Emacs. To kill internal buffers as well, call kill-matching-buffers with a prefix argument.

The Buffer Menu feature is also convenient for killing various buffers.  See Several Buffers.

If you want to do something special every time a buffer is killed, you can add hook functions to the hook kill-buffer-hook (see Hooks).

If you run one Emacs session for a period of days, as many people do, it can fill up with buffers that you used several days ago.  The command M-x clean-buffer-list is a convenient way to purge them; it kills all the unmodified buffers that you have not used for a long time.  An ordinary buffer is killed if it has not been displayed for three days; however, you can specify certain buffers that should never be killed automatically, and others that should be killed if they have been unused for a mere hour.  These defaults, and other aspects of this command's behavior, can be controlled by customizing several options described in the doc string of clean-buffer-list.

You can also have this buffer purging done for you, once a day, by enabling Midnight mode.  Midnight mode operates each day at midnight; at that time, it runs clean-buffer-list, or whichever functions you have placed in the normal hook midnight-hook (see Hooks).  To enable Midnight mode, use the Customization buffer to set the variable midnight-mode to t.  See Easy Customization.

Operating on Several Buffers
============================

M-x buffer-menu
     Begin editing a buffer listing all Emacs buffers.

M-x buffer-menu-other-window
     Similar, but do it in another window.

The Buffer Menu opened by C-x C-b (see List Buffers) does not merely list buffers.  It also allows you to perform various operations on buffers, through an interface similar to Dired (see Dired).  You can save buffers, kill them (here called deleting them, for consistency with Dired), or display them.

To use the Buffer Menu, type C-x C-b and switch to the window displaying the *Buffer List* buffer.  You can also type M-x buffer-menu to open the Buffer Menu in the selected window. Alternatively, the command M-x buffer-menu-other-window opens the Buffer Menu in another window, and selects that window.

The Buffer Menu is a read-only buffer, and can be changed only through the special commands described in this section.  The usual cursor motion commands can be used in this buffer.  The following commands apply to the buffer described on the current line:

d
     Flag the buffer for deletion (killing), then move point to the next line (Buffer-menu-delete).  The deletion flag is indicated by the character D on the line, before the buffer name.  The deletion occurs only when you type the x command (see below).

C-d
     Like d, but move point up instead of down (Buffer-menu-delete-backwards).

s
     Flag the buffer for saving (Buffer-menu-save).  The save flag is indicated by the character S on the line, before the buffer name.  The saving occurs only when you type x.  You may request both saving and deletion for the same buffer.

x
     Perform all flagged deletions and saves (Buffer-menu-execute).

u
     Remove all flags from the current line, and move down (Buffer-menu-unmark).  With a prefix argument, moves up after removing the flags.

DEL
     Move to the previous line and remove all flags on that line (Buffer-menu-backup-unmark).

M-DEL
     Remove a particular flag from all lines (Buffer-menu-unmark-all-buffers).  This asks for a single character, and unmarks buffers marked with that character; typing RET removes all marks.

U
     Remove all flags from all the lines (Buffer-menu-unmark-all).

The commands for removing flags, d and C-d, accept a numeric argument as a repeat count.

The following commands operate immediately on the buffer listed on the current line.  They also accept a numeric argument as a repeat count.

~
     Mark the buffer as unmodified (Buffer-menu-not-modified). See Save Commands.

%
     Toggle the buffer's read-only status (Buffer-menu-toggle-read-only).  See Misc Buffer.

t
     Visit the buffer as a tags table (Buffer-menu-visit-tags-table).  See Select Tags Table.

The following commands are used to select another buffer or buffers:

q
     Quit the Buffer Menu (quit-window).  The most recent formerly visible buffer is displayed in its place.

RET
f
     Select this line's buffer, replacing the *Buffer List* buffer in its window (Buffer-menu-this-window).

o
     Select this line's buffer in another window, as if by C-x 4 b, leaving *Buffer List* visible (Buffer-menu-other-window).

C-o
     Display this line's buffer in another window, without selecting it (Buffer-menu-switch-other-window).

1
     Select this line's buffer in a full-frame window (Buffer-menu-1-window).

2
     Set up two windows on the current frame, with this line's buffer selected in one, and a previously current buffer (aside from *Buffer List*) in the other (Buffer-menu-2-window).

b
     Bury this line's buffer (Buffer-menu-bury) (i.e., move it to the end of the buffer list).

m
     Mark this line's buffer to be displayed in another window if you exit with the v command (Buffer-menu-mark).  The display flag is indicated by the character > at the beginning of the line. (A single buffer may not have both deletion and display flags.)

v
     Select this line's buffer, and also display in other windows any buffers flagged with the m command (Buffer-menu-select). If you have not flagged any buffers, this command is equivalent to 1.

The following commands affect the entire buffer list:

S
     Sort the Buffer Menu entries according to their values in the column at point.  With a numeric prefix argument N, sort according to the N-th column (tabulated-list-sort).

}
     Widen the current column width by N (the prefix numeric argument) characters.

{
     Narrow the current column width by N (the prefix numeric argument) characters.

T
     Delete, or reinsert, lines for non-file buffers (Buffer-menu-toggle-files-only).  This command toggles the inclusion of such buffers in the buffer list.

Normally, the buffer *Buffer List* is not updated automatically when buffers are created and killed; its contents are just text.  If you have created, deleted or renamed buffers, the way to update *Buffer List* to show what you have done is to type g (revert-buffer).  You can make this happen regularly every auto-revert-interval seconds if you enable Auto Revert mode in this buffer, as long as it is not marked modified.  Global Auto Revert mode applies to the *Buffer List* buffer only if global-auto-revert-non-file-buffers is non-nil. See global-auto-revert-non-file-buffers, for details.

Indirect Buffers
================

An indirect buffer shares the text of some other buffer, which is called the base buffer of the indirect buffer.  In some ways it is a buffer analogue of a symbolic link between files.

M-x make-indirect-buffer RET BASE-BUFFER RET INDIRECT-NAME RET
     Create an indirect buffer named INDIRECT-NAME with base buffer BASE-BUFFER.

M-x clone-indirect-buffer RET
     Create an indirect buffer that is a twin copy of the current buffer.

C-x 4 c
     Create an indirect buffer that is a twin copy of the current buffer, and select it in another window (clone-indirect-buffer-other-window).

The text of the indirect buffer is always identical to the text of its base buffer; changes made by editing either one are visible immediately in the other.  But in all other respects, the indirect buffer and its base buffer are completely separate.  They can have different names, different values of point, different narrowing, different markers, different major modes, and different local variables.

An indirect buffer cannot visit a file, but its base buffer can.  If you try to save the indirect buffer, that actually works by saving the base buffer.  Killing the base buffer effectively kills the indirect buffer, but killing an indirect buffer has no effect on its base buffer.

One way to use indirect buffers is to display multiple views of an outline.  See Outline Views.

A quick and handy way to make an indirect buffer is with the command M-x clone-indirect-buffer.  It creates and selects an indirect buffer whose base buffer is the current buffer.  With a numeric argument, it prompts for the name of the indirect buffer; otherwise it uses the name of the current buffer, with a <N> suffix added.  C-x 4 c (clone-indirect-buffer-other-window) works like M-x clone-indirect-buffer, but it selects the new buffer in another window.  These functions run the hook clone-indirect-buffer-hook after creating the indirect buffer.

The more general way to make an indirect buffer is with the command M-x make-indirect-buffer.  It creates an indirect buffer named INDIRECT-NAME from a buffer BASE-BUFFER, prompting for both using the minibuffer.

Convenience Features and Customization of Buffer Handling
=========================================================

This section describes several modes and features that make it more convenient to switch between buffers.

Making Buffer Names Unique
--------------------------

When several buffers visit identically-named files, Emacs must give the buffers distinct names.  The default method adds a suffix based on the names of the directories that contain the files.  For example, if you visit files /foo/bar/mumble/name and /baz/quux/mumble/name at the same time, their buffers will be named name<bar/mumble> and name<quux/mumble>, respectively. Emacs adds as many directory parts as are needed to make a unique name.

You can choose from several different styles for constructing unique buffer names, by customizing the option uniquify-buffer-name-style.

The forward naming method includes part of the file's directory name at the beginning of the buffer name; using this method, buffers visiting the files /u/rms/tmp/Makefile and /usr/projects/zaphod/Makefile would be named tmp/Makefile and zaphod/Makefile.

In contrast, the post-forward naming method would call the buffers Makefile|tmp and Makefile|zaphod.  The default method post-forward-angle-brackets is like post-forward, except that it encloses the unique path in angle brackets.  The reverse naming method would call them Makefile\tmp and Makefile\zaphod.  The nontrivial difference between post-forward and reverse occurs when just one directory name is not enough to distinguish two files; then reverse puts the directory names in reverse order, so that /top/middle/file becomes file\middle\top, while post-forward puts them in forward order after the file name, as in file|top/middle.  If uniquify-buffer-name-style is set to nil, the buffer names simply get <2>, <3>, etc. appended.

Which rule to follow for putting the directory names in the buffer name is not very important if you are going to look at the buffer names before you type one.  But as an experienced user, if you know the rule, you won't have to look.  And then you may find that one rule or another is easier for you to remember and apply quickly.

Fast minibuffer selection
-------------------------

Icomplete global minor mode provides a convenient way to quickly select an element among the possible completions in a minibuffer.  When enabled, typing in the minibuffer continuously displays a list of possible completions that match the string you have typed.

At any time, you can type C-j to select the first completion in the list.  So the way to select a particular completion is to make it the first in the list.  There are two ways to do this.  You can type more of the completion name and thus narrow down the list, excluding unwanted completions above the desired one.  Alternatively, you can use C-. and C-, to rotate the list until the desired buffer is first.

M-TAB will select the first completion in the list, like C-j but without exiting the minibuffer, so you can edit it further.  This is typically used when entering a file name, where M-TAB can be used a few times to descend in the hierarchy of directories.

To enable Icomplete mode, type M-x icomplete-mode, or customize the variable icomplete-mode to t (see Easy Customization).

An alternative to Icomplete mode is Fido mode.  This is very similar to Icomplete mode, but retains some functionality from a popular extension called Ido mode (in fact the name is derived from ``Fake Ido'').  Among other things, in Fido mode, C-s and C-r are also used to rotate the completions list, C-k can be used to delete files and kill buffers in-list.  Another noteworthy aspect is that flex is used as the default completion style (see Completion Styles).  To change this, add the following to your initialization file (see Init File):

     (defun my-icomplete-styles ()
       (setq-local completion-styles '(initials flex)))
     (add-hook 'icomplete-minibuffer-setup-hook 'my-icomplete-styles)

To enable Fido mode, type M-x fido-mode, or customize the variable fido-mode to t (see Easy Customization).

Customizing Buffer Menus
------------------------

M-x bs-show
     Make a list of buffers similarly to M-x list-buffers but customizable.

M-x ibuffer
     Make a list of buffers and operate on them in Dired-like fashion.

M-x bs-show pops up a buffer list similar to the one normally displayed by C-x C-b, but whose display you can customize in a more flexible fashion.  For example, you can specify the list of buffer attributes to show, the minimum and maximum width of buffer name column, a regexp for names of buffers that will never be shown and those which will always be shown, etc.  If you prefer this to the usual buffer list, you can bind this command to C-x C-b.  To customize this buffer list, use the bs Custom group (see Easy Customization), or invoke bs-customize.

MSB global minor mode (``MSB'' stands for ``mouse select buffer'') provides a different and customizable mouse buffer menu which you may prefer.  It replaces the mouse-buffer-menu commands, normally bound to C-Down-mouse-1 and C-F10, with its own commands, and also modifies the menu-bar buffer menu.  You can customize the menu in the msb Custom group.

IBuffer is a major mode for viewing a list of buffers and operating on them in a way analogous to that of Dired (see Dired), including filtering, marking, sorting in various ways, and acting on buffers.