When NeoMutt starts up it looks for two configuration files – one “system” file and one “user” file.

NeoMutt first reads the system configuration file, then the user configuration file. The two files are merged in the sense that "last setting wins". That is, if a setting is defined in both files, the user configuration file's value for that setting is the one that takes precedence and becomes effective.

NeoMutt searches for several different file names when looking for config. It looks for NeoMutt config files before Mutt config files and versioned config before plain config. For example:

This allows the user to create separate NeoMutt and Mutt config files on the same system.

NeoMutt is highly configurable because it's meant to be customized to your needs and preferences. However, this configurability can make it difficult when just getting started. A few sample neomuttrc files are available in the Contrib Repo.

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 real_name='John Smith' ; 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.

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, backticks are evaluated inside of double quotes, but not for single quotes.

“\” quotes the next character, just like in a shell. 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 real_name="John \"anonymous\" Doe"

“\\” 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 as it “escapes” the line end, provided that the split points don't appear in the middle of command names. Lines are first concatenated before interpretation so that a multi-line can be commented by commenting out the first line only.

set status_format="some very \
long value split \
over several lines"

It is also possible to substitute the output of a Unix command in an initialization file. This is accomplished by enclosing the command in backticks (``). In Example 3.5, “Using external command's output in configuration files”, the output of the Unix command “uname -a” will be substituted before the line is parsed. Since initialization files are line oriented, only the first line of output from the Unix command will be substituted.

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

To avoid the output of backticks being parsed, place them inside double quotes. In Example 3.6, “Preventing the output of backticks from being parsed”, the output of the gpg decryption is assigned directly to $imap_pass, so that special characters in the password (e.g. “'”, “#”, “$”) are not parsed and interpreted specially by neomutt.

set imap_pass="`gpg --batch -q --decrypt ~/.neomutt/account.gpg`"

Both environment variables and NeoMutt variables can be accessed by prepending “$” to the name of the variable. For example,

set record = "+sent_on_$HOSTNAME"

will cause NeoMutt to save outgoing messages to a folder named “sent_on_kremvax” if the environment variable $HOSTNAME is set to “kremvax.”(See $record for details.)

If NeoMutt can't find a matching config variable, it will try to find a matching environment variable.

NeoMutt expands the variable when it is assigned, not when it is used. If the value of a variable on the right-hand side of an assignment changes after the assignment, the variable on the left-hand side will not be affected.

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

All configuration files are expected to be in the current locale as specified by the $charset variable which doesn't have a default value since it's determined by NeoMutt at startup. If a configuration file is not encoded in the same character set the $config_charset variable should be used: all lines starting with the next are recoded from $config_charset to $charset.

This mechanism should be avoided if possible as it has the following implications:

Usage:

NeoMutt supports grouping addresses logically into named groups. An address or regular expression can appear in several groups at the same time. These groups can be used in patterns(for searching, limiting and tagging) and in hooks by using group patterns. This can be useful to classify mail and take certain actions depending on in what groups the message is. For example, the NeoMutt user's mailing list would fit into the categories “mailing list” and “NeoMutt-related”. Using send-hook , the sender can be set to a dedicated one for writing mailing list messages, and the signature could be set to a NeoMutt-related one for writing to a NeoMutt list – for other lists, the list sender setting still applies but a different signature can be selected. Or, given a group only containing recipients known to accept encrypted mail, “auto-encryption” can be achieved easily.

The group command is used to directly add either addresses or regular expressions to the specified group or groups. The different categories of arguments to the group command can be in any order. The flags -rx and -addr specify what the following strings (that cannot begin with a hyphen) should be interpreted as: either a regular expression or an email address, respectively.

These address groups can also be created implicitly by the alias , lists , subscribe and alternates commands by specifying the optional -group option. For example,

alternates -group me address1 address2
alternates -group me -group work address3

would create a group named “me” which contains all three addresses and a group named “work” which contains only your work address address3 . Besides many other possibilities, this could be used to automatically mark your own messages in a mailing list folder as read or use a special signature for work-related messages.

The ungroup command is used to remove addresses or regular expressions from the specified group or groups. The syntax is similar to the group command, however the special character * can be used to empty a group of all of its contents. As soon as a group gets empty because all addresses and regular expressions have been removed, it'll internally be removed, too (i.e. there cannot be an empty group). When removing regular expressions from a group, the regex must be specified exactly as given to the group command or -group argument.

Usage:

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

The optional -group argument to alias causes the aliased address(es) to be added to the named group .

To add an alias:

# Some aliases, with comments and tags
alias alan   Alan Jones <alan@example.com>      # Al tags:friends
alias briony Briony Williams <bw@example.com>   # tags:friends
alias jim    James Smith <js@example.com>       # Pointy-haired boss

# An alias that references two other aliases
alias friends alan, briony

Aliases can given tags (labels) which can be used for searching or limiting. Tags consist of comma-separated strings after a comment of tags:. In the Address Book, you can search for a tag with ~Y friends or limit the view to friends.

To remove an alias or aliases ( “*” means all aliases):

unalias muttdude
unalias *

Note: The alias key is matched case insensitively when creating (checking for duplicates), removing, or expanding aliases.

Unlike other mailers, NeoMutt 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 .neomuttrc.

On the other hand, the <create-alias> function can use only one file, the one pointed to by the $alias_file variable (which is ~/.neomuttrc by default). This file is not special either, in the sense that NeoMutt 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.

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

To use aliases, you merely use the alias at any place in NeoMutt where NeoMutt 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, NeoMutt will bring up a menu with the matching aliases. In order to be presented with the full list of aliases, you must hit tab without 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 tag-entry key (default: <Space> or t), and use the exit key (default: q) to return to the address prompt.

Usage:

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

bind index g  group-reply
bind index gg first-entry

bind index g  noop
bind index gg first-entry

unbind index g
bind index gg first-entry

Usage:

The cd command changes NeoMutt's current working directory. This affects commands and functions like source, change-folder, and save-entry that use relative paths. Using cd without directory changes to your home directory.

Usage:

The charset-hook 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 NeoMutt.

The iconv-hook command defines a system-specific name for a character set. This is helpful when your systems character conversion library insists on using strange, system-specific names for character sets.

Usage:

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. The command is executed before loading any mailboxes matching regex . The -noregex switch controls whether regex is matched using a simple string comparison or a full regex match. If a mailbox matches multiple folder-hook s, they are executed in the order given in the .neomuttrc.

The regex parameter has mailbox shortcut expansion performed on the first character. See Mailbox Matching in Hooks for more details.

folder-hook work "set sort=threads"

The following example will set the sort variable to date-sent for all folders but to threads for all folders containing “work” in their name.

folder-hook . "set sort=date-sent"
folder-hook work "set sort=threads"

Usage:

Macros are a convenient way to automate various actions.

Usage:

If your terminal supports color, you can spice up NeoMutt by creating your own color scheme.

The types of objects that can be colored fall into two categories: Simple Colors such as the highlight in the index, and Color Lists such as the status bar. These lists can created complexing coloring rules.

# Make error messages white text on a red background
color error default red
color error white   default

TERM=xterm-direct neomutt

# Make error messages white text on a red background
color error white red
# Make questions bold, underlined, with light blue text (with default background)
color prompt bold underline cyan default

uncolor error
uncolor prompt

color sidebar_divider brightblack default

uncolor sidebar_divider

color compose header bold white default

uncolor compose header

color quoted brightblue default
color quoted1 brightgreen default
color quoted2 yellow default

uncolor quoted
uncolor quoted1
uncolor quoted2

# Highlight emails from work (entire line)
color index          cyan default "~f @work.com"
# Extra highlighting for the boss (just the author column)
color index_author   cyan red     "~f boss@work.com"

uncolor index          "~f @work.com"
# Clear all index_author colors
uncolor index_author   *

# Add some highlights to the body of an email
color body    bold red    default "(urgent|important)"
color body         yellow default "(warning|notice)"
# Make the label header red
color header       cyan   default "X-Label"

uncolor body    "(urgent|important)"
# Clear all body colors
uncolor body    *
uncolor header  "X-Label"

# Set the default color for the entire status line
color status blue white
# Highlight New, Deleted, or Flagged emails
color status brightred white '(New|Del|Flag):[0-9]+'
# Highlight the contents of the []s but not the [] themselves
color status red default '\[([^]]+)\]' 1

uncolor status '(New|Del|Flag):[0-9]+'
uncolor status *

Usage:

With various functions, NeoMutt will treat messages differently, depending on whether you sent them or whether you received them from someone else. For instance, when replying to a message that you sent to a different party, NeoMutt will automatically suggest to send the response to the original message's recipients – responding to yourself won't make much sense in many cases. (See $reply_to.)

Many users receive e-mail under a number of different addresses. To fully use NeoMutt's features here, the program must be able to recognize what e-mail addresses you receive mail under. That's the purpose of the alternates command: It takes a list of regular expressions, each of which can identify an address under which you receive e-mail.

As addresses are matched using regular expressions and not exact strict comparisons, you should make sure you specify your addresses as precise as possible to avoid mismatches. For example, if you specify:

alternates user@example

NeoMutt will consider “ some-user@example ” as being your address, too which may not be desired. As a solution, in such cases addresses should be specified as:

alternates '^user@example$'

The -group flag causes all of the subsequent regular expressions to be added to the named group.

The unalternates command can be used to write exceptions to alternates regex. If an address matches something in an alternates command, but you nonetheless do not think it is from you, you can list a more precise regex under an unalternates command.

To remove a regular expression from the alternates list, use the unalternates command with exactly the same regex . Likewise, if the regex for an alternates command matches an entry on the unalternates list, that unalternates entry will be removed. If the regex for unalternates is “*”, all entries on alternates will be removed.

Usage:

NeoMutt 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. NeoMutt also has limited support for auto-detecting mailing lists: it supports parsing mailto: links in the common List-Post: header which has the same effect as specifying the list address via the lists command (except the group feature). Once you have done this, the <list-reply> function will work for all known lists. Additionally, when you send a message to a known list and $followup_to is set, NeoMutt will add a Mail-Followup-To header. For unsubscribed lists, this will include your personal address, ensuring you receive a copy of replies. For subscribed mailing lists, the header will not, telling other users' mail user agents not to send copies of replies to your personal address.

More precisely, NeoMutt maintains lists of regular expressions for the addresses of known and subscribed mailing lists. Every subscribed mailing list is known. To mark a mailing list as known, use the list command. To mark it as subscribed, use subscribe .

You can use regular expressions with both commands. To mark all messages sent to a specific bug report's address on Debian's bug tracking system as list mail, for instance, you could say

subscribe [0-9]+.*@bugs.debian.org

as it's often sufficient to just give a portion of the list's e-mail address.

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

The -group flag adds all of the subsequent regular expressions to the named address group in addition to adding to the specified address 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 .

Usage:

This command is used to move read messages from a specified mailbox to a different mailbox automatically when you quit or change folders. regex is used to specifying the mailbox to treat as a “spool” mailbox and mailbox specifies where mail should be saved when read. The -noregex switch controls whether regex is matched using a simple string comparison or a full regex match.

The regex parameter has mailbox shortcut expansion performed on the first character. See Mailbox Matching in Hooks for more details.

Note that execution of mbox-hooks is dependent on the $move configuration variable. If set to “no”(the default), mbox-hooks will not be executed.

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

Usage:

This command specifies folders which can receive mail and which will be checked for new messages periodically.

The -label argument can be used to specify an alternative label to print in the sidebar or mailbox browser instead of the mailbox path. A label may be removed via the -nolabel argument. If unspecified, an existing mailbox label will be unchanged.

Use -nonotify to disable notifying when new mail arrives. The -notify argument can be used to re-enable notifying for an existing mailbox. If unspecified: a new mailbox will notify by default, while an existing mailbox will be unchanged.

To disable polling, specify -nopoll before the mailbox name. The -poll argument can be used to re-enable polling for an existing mailbox. If unspecified: a new mailbox will poll by default, while an existing mailbox will be unchanged.

folder can either be a local file or directory (Mbox/Mmdf or Maildir/Mh). If NeoMutt was built with POP and/or IMAP support, folder can also be a POP/IMAP folder URL. The URL syntax is described in Section 1.2, “URL Syntax”, POP and IMAP are described in Section 3, “POP3 Support” and Section 4, “IMAP Support” respectively.

NeoMutt provides a number of advanced features for handling (possibly many) folders and new mail within them, please refer to Chapter 28, New Mail Featurefor details (including in what situations and how often NeoMutt checks for new mail). Additionally, $new_mail_command can be used to run a command when new mail is detected.

The “unmailboxes” command is used to remove a token from the list of folders which receive mail. “unmailboxes” can be used on the mailbox path, “$folder”-abbreviated path, or description. Use “unmailboxes *” to remove all tokens.

Usage:

The my_hdr command allows you to create your own header fields which will be added to every message you send and appear in the editor if $edit_headers is set.

For example, if you would like to add an “Organization:” header field to all of your outgoing messages, you can put the command something like shown in Example 3.12, “Defining custom headers” in your .neomuttrc.

my_hdr Organization: A Really Big Company, Anytown, USA

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 compose 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

Usage:

fcc-save-hook is a shortcut, equivalent to doing both a fcc-hook and a save-hook with its arguments, including %-expansion on mailbox according to $index_format.

If the pattern is a plain string, or a regex, it will be expanded to a pattern using $default_hook.

fcc-hook is used to save outgoing mail in a mailbox other than $record. NeoMutt searches the initial list of message recipients for the first matching pattern and uses mailbox as the default “Fcc:” mailbox. If no match is found the message will be saved to $record mailbox.

fcc-hook [@.]aol\\.com$ +spammers

...will save a copy of all messages going to the aol.com domain to the “+spammers” mailbox by default.

save-hook is used to override the default mailbox used when saving messages. mailbox will be used as the default if the message matches pattern .

# default: save all to ~/Mail/<author name>
save-hook . ~/Mail/%F
# save from john@turing.ox.ac.uk and john@ox.ac.uk to $folder/smith
save-hook john@(turing\\.)?ox\\.ac\\.uk$ +smith
# save from aol.com to $folder/spam
save-hook aol\\.com$ +spam

Also see the fcc-save-hook command.

To provide more flexibility and good defaults, NeoMutt applies the expandos of $index_format to mailbox after it was expanded. See Message Matching in Hooks for information on the exact format of pattern .

Usage:

These commands can be used to execute arbitrary configuration commands based upon recipients of the message. pattern is used to match the message, see Message Matching in Hooks for details. command is executed when pattern matches.

If the pattern is a plain string, or a regex, it will be expanded to a pattern using $default_hook.

reply-hook is matched against the message you are replying to , instead of the message you are sending . send-hook is matched against all messages, both new and replies .

send2-hook is matched every time a message is changed, either by editing it, or by using the compose menu to change its recipients or subject. send2-hook is executed after send-hook , and can, e.g., be used to set parameters such as the $sendmail variable depending on the message's sender address.

For each type of send-hook or reply-hook , when multiple matches occur, commands are executed in the order they are specified in the .neomuttrc (for that type of hook).

Example: send-hook work " set mime_forward signature=''"

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

Usage:

This command can be used to execute arbitrary configuration commands before viewing or formatting a message based upon information about the message. command is executed if the pattern matches the message to be displayed. When multiple matches occur, commands are executed in the order they are specified in the .neomuttrc.

If the pattern is a plain string, or a regex, it will be expanded to a pattern using $default_hook.

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

Example:

message-hook ~A 'set pager=builtin'
message-hook '~f freshmeat-news' 'set pager="less \"+/^  subject: .*\""'

Usage:

When encrypting messages with PGP/GnuPG or OpenSSL, you may want to associate a certain 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 NeoMutt would normally use. The crypt-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. You may use multiple crypt-hooks with the same regex; multiple matching crypt-hooks result in the use of multiple keyids for a recipient. During key selection, NeoMutt will confirm whether each crypt-hook is to be used (unless the $crypt_confirm_hook option is unset). If all crypt-hooks for a recipient are declined, NeoMutt will use the original recipient address for key selection instead.

The meaning of keyid is to be taken broadly in this context: You can either put a numerical key ID or fingerprint here, an e-mail address, or even just a real name.

Usage:

This command is used to inject format strings dynamically into $index_format based on pattern matching against the current message.

If the pattern is a plain string, or a regex, it will be expanded to a pattern using $default_hook.

The $index_format expando %@name@ specifies a placeholder for the injection. Index-format-hooks with the same name are matched using pattern against the current message. Matching is done in the order specified in the .muttrc, with the first match being used. The hook's format-string is then substituted and evaluated.

Because the first match is used, best practice is to put a catch-all ~A pattern as the last hook. Here is an example showing how to implement dynamic date formatting:

set index_format="%4C %-6@date@ %-15.15F %Z (%4c) %s"

index-format-hook  date  "~d<1d"    "%[%H:%M]"
index-format-hook  date  "~d<1m"    "%[%a %d]"
index-format-hook  date  "~d<1y"    "%[%b %d]"
index-format-hook  date  "~A"       "%[%m/%y]"

Another example, showing a way to prepend to the subject. Note that without a catch-all ~A pattern, no match results in the expando being replaced with an empty string.

set index_format="%4C %@subj_flags@%s"

index-format-hook  subj_flags  "~f boss@example.com"    "** BOSS ** "
index-format-hook  subj_flags  "~f spouse@example.com"  ":-) "

Usage:

This command adds the named string to the beginning of 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. For example, Example 3.14, “Embedding push in folder-hook” shows how to automatically collapse all threads when entering a folder.

folder-hook . 'push <collapse-all>'

For using functions like shown in the example, it's important to use angle brackets ( “<” and “>”) to make NeoMutt recognize the input as a function name. Otherwise it will simulate individual just keystrokes, i.e. “ push collapse-all ” would be interpreted as if you had typed “c”, followed by “o”, followed by “l”, ..., which is not desired and may lead to very unexpected behavior.

Keystrokes can be used, too, but are less portable because of potentially changed key bindings. With default bindings, this is equivalent to the above example:

folder-hook . 'push \eV'

because it simulates that Esc+V was pressed (which is the default binding of <collapse-all> ).

Usage:

This command can be used to execute any function. Functions are listed in the function reference. “ exec function ” is equivalent to “ push <function> ”.

Usage:

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 (note: For efficiency reasons, patterns which scan information not available in the index, such as ~b, ~B, ~h, ~M, or ~X may not be used). 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.

Scoring occurs as the messages are read in, before the mailbox is sorted. Because of this, patterns which depend on threading, such as ~= , ~$ , and ~() , will not work by default. A workaround is to push the scoring command in a folder hook. This will cause the mailbox to be rescored after it is opened and input starts being processed:

folder-hook . 'push "<enter-command>score ~= 10<enter>"'

Usage:

NeoMutt has generalized support for external spam-scoring filters. By defining your spam regular expressions with the spam and nospam commands, you can limit , search , and sort your mail based on its spam attributes, as determined by the external filter. You also can display the spam attributes in your index display using the %H selector in the $index_format variable. (Tip: try %<H?[%H] > to display spam tags only when they are defined for a given message.)

Note: the value displayed by %H and searched by ~H is stored in the header cache. NeoMutt isn't smart enough to invalidate a header cache entry based on changing spam rules, so if you aren't seeing correct %H values, try temporarily turning off the header cache. If that fixes the problem, then once your spam rules are set to your liking, remove your stale header cache files and turn the header cache back on.

Your first step is to define your external filter's spam headers using the spam command. regex should be a regular expression that matches a header in a mail message. If any message in the mailbox matches this regular expression, it will receive a “spam tag” or “spam attribute”(unless it also matches a nospam regular expression – see below.) The appearance of this attribute is entirely up to you, and is governed by the format parameter. format can be any static text, but it also can include back-references from the regex expression. (A regular expression “back-reference” refers to a sub-expression contained within parentheses.) %1 is replaced with the first back-reference in the regex, %2 with the second, etc.

To match spam tags, NeoMutt needs the corresponding header information which is always the case for local and POP folders but not for IMAP in the default configuration. Depending on the spam header to be analyzed, $imap_headers may need to be adjusted.

If you're using multiple spam filters, a message can have more than one spam-related header. You can define spam rules for each filter you use. If a message matches two or more of these regular expressions, and the $spam_separator variable is set to a string, then the message's spam tag will consist of all the format strings joined together, with the value of $spam_separator separating them.

For example, suppose one uses DCC, SpamAssassin, and PureMessage, then the configuration might look like in Example 3.15, “Configuring spam detection”.

spam "X-DCC-.*-Metrics:.*(....)=many"         "90+/DCC-%1"
spam "X-Spam-Status: Yes"                     "90+/SA"
spam "X-PerlMX-Spam: .*Probability=([0-9]+)%" "%1/PM"
set spam_separator=", "

If then a message is received that DCC registered with “many” hits under the “Fuz2” checksum, and that PureMessage registered with a 97% probability of being spam, that message's spam tag would read 90+/DCC-Fuz2, 97/PM. (The four characters before “=many” in a DCC report indicate the checksum used – in this case, “Fuz2”.)

If the $spam_separator variable is unset, then each spam rule match supersedes the previous one. Instead of getting joined format strings, you'll get only the last one to match.

The spam tag is what will be displayed in the index when you use %H in the $index_format variable. It's also the string that the ~H pattern-matching expression matches against for <search> and <limit> functions. And it's what sorting by spam attribute will use as a sort key.

That's a pretty complicated example, and most people's actual environments will have only one spam filter. The simpler your configuration, the more effective NeoMutt can be, especially when it comes to sorting.

Generally, when you sort by spam tag, NeoMutt will sort lexically – that is, by ordering strings alphanumerically. However, if a spam tag begins with a number, NeoMutt will sort numerically first, and lexically only when two numbers are equal in value. (This is like UNIX's sort -n.) A message with no spam attributes at all – that is, one that didn't match any of your spam rules – is sorted at lowest priority. Numbers are sorted next, beginning with 0 and ranging upward. Finally, non-numeric strings are sorted, with “a” taking lower priority than “z”. Clearly, in general, sorting by spam tags is most effective when you can coerce your filter to give you a raw number. But in case you can't, NeoMutt can still do something useful.

The nospam command can be used to write exceptions to spam rules. If a header field matches something in a spam command, but you nonetheless do not want it to receive a spam tag, you can list a more precise regular expression under a nospam command.

If the regex given to nospam is exactly the same as the regex on an existing spam rule entry, the effect will be to remove the entry from the spam rules list, instead of adding an exception. Likewise, if the regex for a spam command matches an entry on the nospam rule list, that nospam entry will be removed. If the regex for nospam is “*”, all entries on both lists will be removed. This might be the default action if you use spam and nospam in conjunction with a folder-hook .

You can have as many spam or nospam commands as you like. You can even do your own primitive spam detection within NeoMutt – for example, if you consider all mail from MAILER-DAEMON to be spam, you can use a spam command like this:

spam "^From: .*MAILER-DAEMON"       "999"

Usage:

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 ~/.neomuttrc 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 is relative and the command source is executed from the context of a configuration file, then the filename is interpreted relative to the directory of that configuration file. If the command is executed outside of a configuration file, e.g. from the prompt, then the filename is interpreted relative to the current working directory (see cd on how to change the current working directory at runtime).

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

Usage:

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.

Usage:

As a security measure, NeoMutt will only add user-approved header fields from a mailto: URL. This is necessary since NeoMutt will handle certain header fields, such as Attach:, in a special way. The mailto_allow and unmailto_allow commands allow the user to modify the list of approved headers.

NeoMutt initializes the default list to contain only the Subject and Body header fields, which are the only requirement specified by the mailto: specification in RFC2368, and the Cc, In-Reply-To, References headers to aid with replies to mailing lists.