Next Previous Contents

## 3. Configuration

While the default configuration (or ``preferences'') make Mutt usable right out of the box, it is often desirable to tailor Mutt to suit your own tastes. When Mutt is first invoked, it will attempt to read the ``system'' configuration file (defaults set by your local system administrator), unless the ``-n'' command line option is specified. This file is typically `/usr/local/share/mutt/Muttrc` or `/etc/Muttrc`. Mutt will next look for a file named `.muttrc` in your home directory. If this file does not exist and your home directory has a subdirectory named `.mutt`, mutt try to load a file named `.mutt/muttrc`.

`.muttrc` is the file where you will usually place your commands to configure Mutt.

In addition, mutt supports version specific configuration files that are parsed instead of the default files as explained above. For instance, if your system has a `Muttrc-0.88` file in the system configuration directory, and you are running version 0.88 of mutt, this file will be sourced instead of the `Muttrc` file. The same is true of the user configuration file, if you have a file `.muttrc-0.88.6` in your home directory, when you run mutt version 0.88.6, it will source this file instead of the default `.muttrc` file. The version number is the same which is visible using the ``-v'' command line switch or using the `show-version` key (default: V) from the index menu.

## 3.1 Syntax of Initialization Files

An initialization file consists of a series of commands. Each line of the file may contain one or more commands. When multiple commands are used, they must be separated by a semicolon (;).

> `

>     set realname='Mutt user' ; ignore x-

> `

The hash mark, or pound sign (``#''), is used as a ``comment'' character. You can use it to annotate your initialization file. All text after the comment character to the end of the line is ignored. For example,

> `

>     my_hdr X-Disclaimer: Why are you listening to me? # This is a comment

> `

Single quotes (') and double quotes (") can be used to quote strings which contain spaces or other special characters. The difference between the two types of quotes is similar to that of many popular shell programs, namely that a single quote is used to specify a literal string (one that is not interpreted for shell variables or quoting with a backslash [see next paragraph]), while double quotes indicate a string for which should be evaluated. For example, backtics are evaluated inside of double quotes, but not for single quotes.

\ quotes the next character, just as in shells such as bash and zsh. For example, if want to put quotes ``"'' inside of a string, you can use ``\'' to force the next character to be a literal instead of interpreted character.

> `

>     set realname="Michael \"MuttDude\" Elkins"

> `

``\\'' means to insert a literal ``\'' into the line. ``\n'' and ``\r'' have their usual C meanings of linefeed and carriage-return, respectively.

A \ at the end of a line can be used to split commands over multiple lines, provided that the split points don't appear in the middle of command names.

It is also possible to substitute the output of a Unix command in an initialization file. This is accomplished by enclosing the command in backquotes (``). For example,

> `

>     my_hdr X-Operating-System: `uname -a`

> `

The output of the Unix command ``uname -a'' will be substituted before the line is parsed. Note that since initialization files are line oriented, only the first line of output from the Unix command will be substituted.

UNIX environments can be accessed like the way it is done in shells like sh and bash: Prepend the name of the environment by a ``$dollar;''. For example,

> `

>     set record=+sent_on_$HOSTNAME

> `

The commands understood by mutt are explained in the next paragraphs. For a complete list, see the command reference.

## 3.2 Defining/Using aliases

Usage: `alias` key address [ , address, ... ]

It's usually very cumbersome to remember or type out the address of someone you are communicating with. Mutt allows you to create ``aliases'' which map a short string to a full address.

Note: if you want to create an alias for a group (by specifying more than one address), you must separate the addresses with a comma (``,'').

To remove an alias or aliases:

`unalias` addr [ addr ... ]

> `

>     alias muttdude me@cs.hmc.edu (Michael Elkins)
>     alias theguys manny, moe, jack

> `

Unlike other mailers, Mutt doesn't require aliases to be defined in a special file. The `alias` command can appear anywhere in a configuration file, as long as this file is sourced. Consequently, you can have multiple alias files, or you can have all aliases defined in your muttrc.

On the other hand, the create-alias function can use only one file, the one pointed to by the $alias_file variable (which is `~/.muttrc` by default). This file is not special either, in the sense that Mutt will happily append aliases to any file, but in order for the new aliases to take effect you need to explicitly source this file too.

For example:

> `

>     source /usr/local/share/Mutt.aliases
>     source ~/.mail_aliases
>     set alias_file=~/.mail_aliases

> `

To use aliases, you merely use the alias at any place in mutt where mutt prompts for addresses, such as the To: or Cc: prompt. You can also enter aliases in your editor at the appropriate headers if you have the $edit_headers variable set.

In addition, at the various address prompts, you can use the tab character to expand a partial alias to the full alias. If there are multiple matches, mutt will bring up a menu with the matching aliases. In order to be presented with the full list of aliases, you must hit tab with out a partial alias, such as at the beginning of the prompt or after a comma denoting multiple addresses.

In the alias menu, you can select as many aliases as you want with the select-entry key (default: RET), and use the exit key (default: q) to return to the address prompt.

## 3.3 Changing the default key bindings

Usage: `bind` map key function

This command allows you to change the default key bindings (operation invoked when pressing a key).

map specifies in which menu the binding belongs. The currently defined maps are:

- generic
- alias
- attach
- browser
- editor
- index
- compose
- pager
- pgp
- postpone

key is the key (or key sequence) you wish to bind. To specify a control character, use the sequence \Cx, where x is the letter of the control character (for example, to specify control-A use ``\Ca''). Note that the case of x as well as \C is ignored, so that \CA, \Ca, \cA and \ca are all equivalent. An alternative form is to specify the key as a three digit octal number prefixed with a ``\'' (for example \177 is equivalent to \c?).

In addition, key may consist of:

> `

>     \t              tab
>     <Tab>                tab
>     \r              carriage return
>     \n              newline
>     \e              escape
>     <esc>                escape
>     <up>            up arrow
>     <down>          down arrow
>     <left>          left arrow
>     <right>         right arrow
>     <pageup>        Page Up
>     <pagedown>      Page Down
>     <backspace>     Backspace
>     <delete>        Delete
>     <insert>        Insert
>     <enter>         Enter
>     <home>          Home
>     <end>           End
>     <Space>              Space bar
>     <f1>            function key 1
>     <f10>           function key 10

> `

key does not need to be enclosed in quotes unless it contains a space (`` '').

function specifies which action to take when key is pressed. For a complete list of functions, see the reference. The special function `noop` unbinds the specify key sequence.

## 3.4 Defining aliases for character sets

Usage: `charset-hook` alias charset

This command defines an alias for a character set. This is useful to properly display messages which are tagged with a character set name not known to mutt.

## 3.5 Setting variables based upon mailbox

Usage: `folder-hook` [!]regexp command

It is often desirable to change settings based on which mailbox you are reading. The folder-hook command provides a method by which you can execute any configuration command. pattern is a regular expression specifying in which mailboxes to execute command before loading. If a mailbox matches multiple folder-hook's, they are executed in the order given in the muttrc.

Note: if you use the ``!'' shortcut for $spoolfile at the beginning of the pattern, you must place it inside of double or single quotes in order to distinguish it from the logical not operator for the expression.

Note that the settings are not restored when you leave the mailbox. For example, a command action to perform is to change the sorting method based upon the mailbox being read:

> `

>     folder-hook mutt set sort=threads

> `

However, the sorting method is not restored to its previous value when reading a different mailbox. To specify a default command, use the pattern ``.'':

> `

>     folder-hook . set sort=date-sent

> `

## 3.6 Keyboard macros

Usage: `macro` menu key sequence [ description ]

Macros are useful when you would like a single key to perform a series of actions. When you press key in menu menu, Mutt will behave as if you had typed sequence. So if you have a common sequence of commands you type, you can create a macro to execute those commands with a single key.

key and sequence are expanded by the same rules as the key bindings. There are some additions however. The first is that control characters in sequence can also be specified as ^x. In order to get a caret (`^'') you need to use ^^. Secondly, to specify a certain key such as up or to invoke a function directly, you can use the format <key name> and <function name>. For a listing of key names see the section on key bindings. Functions are listed in the function reference.

The advantage with using function names directly is that the macros will work regardless of the current key bindings, so they are not dependent on the user having particular key definitions. This makes them more robust and portable, and also facilitates defining of macros in files used by more than one user (eg. the system Muttrc).

Optionally you can specify a descriptive text after sequence, which is shown in the help screens.

Note: Macro definitions (if any) listed in the help screen(s), are silently truncated at the screen width, and are not wrapped.

## 3.7 Using color and mono video attributes

Usage: `color` object foreground background [ regexp ]
Usage: `color` index foreground background [ pattern ]
Usage: `uncolor` index pattern [ pattern ... ]

If your terminal supports color, you can spice up Mutt by creating your own color scheme. To define the color of an object (type of information), you must specify both a foreground color and a background color (it is not possible to only specify one or the other).

object can be one of:

- attachment
- body (match regexp in the body of messages)
- bold (hiliting bold patterns in the body of messages)
- error (error messages printed by Mutt)
- header (match regexp in the message header)
- hdrdefault (default color of the message header in the pager)
- index (match pattern in the message index)
- indicator (arrow or bar used to indicate the current item in a menu)
- markers (the ``+'' markers at the beginning of wrapped lines in the pager)
- message (informational messages)
- normal
- quoted (text matching $quote_regexp in the body of a message)
- quoted1, quoted2, ..., quotedN (higher levels of quoting)
- search (hiliting of words in the pager)
- signature
- status (mode lines used to display info about the mailbox or message)
- tilde (the ``~'' used to pad blank lines in the pager)
- tree (thread tree drawn in the message index and attachment menu)
- underline (hiliting underlined patterns in the body of messages)

foreground and background can be one of the following:

- white
- black
- green
- magenta
- blue
- cyan
- yellow
- red
- default
- colorx

foreground can optionally be prefixed with the keyword `bright` to make the foreground color boldfaced (e.g., `brightred`).

If your terminal supports it, the special keyword default can be used as a transparent color. The value brightdefault is also valid. If Mutt is linked against the S-Lang library, you also need to set the COLORFGBG environment variable to the default colors of your terminal for this to work; for example (for Bourne-like shells):

> `

>     set COLORFGBG="green;black"
>     export COLORFGBG

> `

Note: The S-Lang library requires you to use the lightgray and brown keywords instead of white and yellow when setting this variable.

Note: The uncolor command can be applied to the index object only. It removes entries from the list. You must specify the same pattern specified in the color command for it to be removed. The pattern ``*'' is a special token which means to clear the color index list of all entries.

Mutt also recognizes the keywords color0, color1, ..., color N-1 (N being the number of colors supported by your terminal). This is useful when you remap the colors for your display (for example by changing the color associated with color2 for your xterm), since color names may then lose their normal meaning.

If your terminal does not support color, it is still possible change the video attributes through the use of the ``mono'' command:

Usage: `mono` <object> <attribute> [ regexp ]

where attribute is one of the following:

- none
- bold
- underline
- reverse
- standout

## 3.8 Ignoring (weeding) unwanted message headers

Usage: `[un]ignore` pattern [ pattern ... ]

Messages often have many header fields added by automatic processing systems, or which may not seem useful to display on the screen. This command allows you to specify header fields which you don't normally want to see.

You do not need to specify the full header field name. For example, ``ignore content-'' will ignore all header fields that begin with the pattern ``content-''.

To remove a previously added token from the list, use the ``unignore'' command. Note that if you do ``ignore x-'' it is not possible to ``unignore x-mailer,'' for example. The ``unignore'' command does not make Mutt display headers with the given pattern.

``unignore *'' will remove all tokens from the ignore list.

For example:

> `

>     # Sven's draconian header weeding
>     ignore *
>     unignore from date subject to cc
>     unignore organization organisation x-mailer: x-newsreader: x-mailing-list:
>     unignore posted-to:

> `

## 3.9 Mailing lists

Usage: `[un]lists` address [ address ... ]
Usage: `[un]subscribe` address [ address ... ]

Mutt has a few nice features for handling mailing lists. In order to take advantage of them, you must specify which addresses belong to mailing lists, and which mailing lists you are subscribed to. Once you have done this, the list-reply function will work for all known lists. Additionally, when you send a message to a subscribed list, mutt will add a Mail-Followup-To header to tell other users' mail user agents not to send copies of replies to your personal address. Note that the Mail-Followup-To header is a non-standard extension which is not supported by all mail user agents. Adding it is not bullet-proof against receiving personal CCs of list messages. Also note that the generation of the Mail-Followup-To header is controlled by the followup_to configuration variable.

More precisely, Mutt maintains lists of known and subscribed mailing lists. Every subscribed mailing list is known. To mark a mailing list as known, use the ``lists'' command. To mark it as subscribed, use ``subscribe''.

Specify as much of the address as you need to to remove ambiguity. For example, if you've subscribed to the Mutt mailing list, you will receive mail addresssed to mutt-users@mutt.org. So, to tell Mutt that this is a mailing list, you could add ``lists mutt-users'' to your initialization file. To tell mutt that you are subscribed to it, add ``subscribe mutt-users'' to your initialization file instead. If you also happen to get mail from someone whose address is mutt-users@example.com, you could use ``lists mutt-users@mutt.org'' or ``subscribe mutt-users@mutt.org'' to match only mail from the actual list.

The ``unlists'' command is used to remove a token from the list of known and subscribed mailing-lists. Use ``unlists *'' to remove all tokens.

To remove a mailing list from the list of subscribed mailing lists, but keep it on the list of known mailing lists, use ``unsubscribe''.

## 3.10 Using Multiple spool mailboxes

Usage: `mbox-hook` [!]pattern mailbox

This command is used to move read messages from a specified mailbox to a different mailbox automatically when you quit or change folders. pattern is a regular expression specifying the mailbox to treat as a ``spool'' mailbox and mailbox specifies where mail should be saved when read.

Unlike some of the other hook commands, only the first matching pattern is used (it is not possible to save read mail in more than a single mailbox).

## 3.11 Defining mailboxes which receive mail

Usage: `mailboxes` [!]filename [ filename ... ]

This command specifies folders which can receive mail and which will be checked for new messages. By default, the main menu status bar displays how many of these folders have new messages.

When changing folders, pressing space will cycle through folders with new mail.

Pressing TAB in the directory browser will bring up a menu showing the files specified by the `mailboxes` command, and indicate which contain new messages. Mutt will automatically enter this mode when invoked from the command line with the `-y` option.

Note: new mail is detected by comparing the last modification time to the last access time. Utilities like `biff` or `frm` or any other program which accesses the mailbox might cause Mutt to never detect new mail for that mailbox if they do not properly reset the access time. Backup tools are another common reason for updated access times.

Note: the filenames in the `mailboxes` command are resolved when the command is executed, so if these names contain shortcut characters (such as ``='' and ``!''), any variable definition that affect these characters (like $folder and $spool) should be executed before the `mailboxes` command.

## 3.12 User defined headers

Usage:
`my_hdr` string
`unmy_hdr` field [ field ... ]

The ``my_hdr'' command allows you to create your own header fields which will be added to every message you send.

For example, if you would like to add an ``Organization:'' header field to all of your outgoing messages, you can put the command

> my_hdr Organization: A Really Big Company, Anytown, USA

in your `.muttrc`.

Note: space characters are not allowed between the keyword and the colon (``:''). The standard for electronic mail (RFC822) says that space is illegal there, so Mutt enforces the rule.

If you would like to add a header field to a single message, you should either set the edit_headers variable, or use the edit-headers function (default: ``E'') in the send-menu so that you can edit the header of your message along with the body.

To remove user defined header fields, use the ``unmy_hdr'' command. You may specify an asterisk (``*'') to remove all header fields, or the fields to remove. For example, to remove all ``To'' and ``Cc'' header fields, you could use:

> unmy_hdr to cc

## 3.13 Defining the order of headers when viewing messages

Usage: `hdr_order` header1 header2 header3

With this command, you can specify an order in which mutt will attempt to present headers to you when viewing messages.

``unhdr_order *'' will clear all previous headers from the order list, thus removing the header order effects set by the system-wide startup file.

> `

>     hdr_order From Date: From: To: Cc: Subject:

> `

## 3.14 Specify default save filename

Usage: `save-hook` [!]pattern filename

This command is used to override the default filename used when saving messages. filename will be used as the default filename if the message is From: an address matching regexp or if you are the author and the message is addressed to: something matching regexp.

See Message Matching in Hooks for information on the exact format of pattern.

Examples:

> `

>     save-hook me@(turing\\.)?cs\\.hmc\\.edu$ +elkins
>     save-hook aol\\.com$ +spam

> `

Also see the fcc-save-hook command.

## 3.15 Specify default Fcc: mailbox when composing

Usage: `fcc-hook` [!]pattern mailbox

This command is used to save outgoing mail in a mailbox other than $record. Mutt searches the initial list of message recipients for the first matching regexp and uses mailbox as the default Fcc: mailbox. If no match is found the message will be saved to $record mailbox.

See Message Matching in Hooks for information on the exact format of pattern.

Example: `fcc-hook aol.com$ +spammers`

The above will save a copy of all messages going to the aol.com domain to the `+spammers' mailbox by default. Also see the fcc-save-hook command.

## 3.16 Specify default save filename and default Fcc: mailbox at once

Usage: `fcc-save-hook` [!]pattern mailbox

This command is a shortcut, equivalent to doing both a fcc-hook and a save-hook with its arguments.

## 3.17 Change settings based upon message recipients

Usage: `send-hook` [!]pattern command

This command can be used to execute arbitrary configuration commands based upon recipients of the message. pattern is a regular expression matching the desired address. command is executed when regexp matches recipients of the message. When multiple matches occur, commands are executed in the order they are specified in the muttrc.

See Message Matching in Hooks for information on the exact format of pattern.

Example: `send-hook mutt "set mime_forward signature=''"`

Another typical use for this command is to change the values of the $attribution, $signature and $locale variables in order to change the language of the attributions and signatures based upon the recipients.

Note: the send-hook's are only executed ONCE after getting the initial list of recipients. Adding a recipient after replying or editing the message will NOT cause any send-hook to be executed. Also note that my_hdr commands which modify recipient headers, or the message's subject, don't have any effect on the current message when executed from a send-hook.

## 3.18 Choosing the PGP key of the recipient

Usage: `pgp-hook` pattern keyid

When encrypting messages with PGP, you may want to associate a certain PGP key with a given e-mail address automatically, either because the recipient's public key can't be deduced from the destination address, or because, for some reasons, you need to override the key Mutt would normally use. The pgp-hook command provides a method by which you can specify the ID of the public key to be used when encrypting messages to a certain recipient.

## 3.19 Adding key sequences to the keyboard buffer

Usage: `push` string

This command adds the named string to the keyboard buffer. The string may contain control characters, key names and function names like the sequence string in the macro command. You may use it to automatically run a sequence of commands at startup, or when entering certain folders.

## 3.20 Message Scoring

Usage: `score` pattern value
Usage: `unscore` pattern [ pattern ... ]

The `score` commands adds value to a message's score if pattern matches it. pattern is a string in the format described in the patterns section. value is a positive or negative integer. A message's final score is the sum total of all matching `score` entries. However, you may optionally prefix value with an equal sign (=) to cause evaluation to stop at a particular entry if there is a match. Negative final scores are rounded up to 0.

The `unscore` command removes score entries from the list. You must specify the same pattern specified in the `score` command for it to be removed. The pattern ``*'' is a special token which means to clear the list of all score entries.

## 3.21 Setting variables

Usage: `set` [no|inv]variable[=value] [ variable ... ]
Usage: `toggle` variable [variable ... ]
Usage: `unset` variable [variable ... ]
Usage: `reset` variable [variable ... ]

This command is used to set (and unset) configuration variables. There are four basic types of variables: boolean, number, string and quadoption. boolean variables can be set (true) or unset (false). number variables can be assigned a positive integer value.

string variables consist of any number of printable characters. strings must be enclosed in quotes if they contain spaces or tabs. You may also use the ``C'' escape sequences \n and \t for newline and tab, respectively.

quadoption variables are used to control whether or not to be prompted for certain actions, or to specify a default action. A value of yes will cause the action to be carried out automatically as if you had answered yes to the question. Similarly, a value of no will cause the the action to be carried out as if you had answered ``no.'' A value of ask-yes will cause a prompt with a default answer of ``yes'' and ask-no will provide a default answer of ``no.''

Prefixing a variable with ``no'' will unset it. Example: `set noaskbcc`.

For boolean variables, you may optionally prefix the variable name with `inv` to toggle the value (on or off). This is useful when writing macros. Example: `set invsmart_wrap`.

The `toggle` command automatically prepends the `inv` prefix to all specified variables.

The `unset` command automatically prepends the `no` prefix to all specified variables.

Using the enter-command function in the index menu, you can query the value of a variable by prefixing the name of the variable with a question mark:

> `

>     set ?allow_8bit

> `

The question mark is actually only required for boolean and quadoption variables.

The `reset` command resets all given variables to the compile time defaults (hopefully mentioned in this manual). If you use the command `set` and prefix the variable with ``&'' this has the same behavior as the reset command.

With the `reset` command there exists the special variable ``all'', which allows you to reset all variables to their system defaults.

## 3.22 Reading initialization commands from another file

Usage: `source` filename

This command allows the inclusion of initialization commands from other files. For example, I place all of my aliases in `~/.mail_aliases` so that I can make my `~/.muttrc` readable and keep my aliases private.

If the filename begins with a tilde (``~''), it will be expanded to the path of your home directory.

If the filename ends with a vertical bar (|), then filename is considered to be an executable program from which to read input (eg. `source ~`bin/myscript|/).

## 3.23 Removing hooks

Usage: `unhook` [ * | hook-type ]

This command permits you to flush hooks you have previously defined. You can either remove all hooks by giving the ``*'' character as an argument, or you can remove all hooks of a specific type by saying something like `unhook send-hook`.

Next Previous Contents