neomuttrc(5)

📦

this version · 13 versions

🌸 NAME 🌸

neomuttrc — Configuration file for the NeoMutt Mail User Agent (MUA)

okay so this is the neomuttrc(5) page, bestie — the config-file manual for NeoMutt. 💌

🦋 DESCRIPTION 🦋

A NeoMutt configuration file is literally 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 (“;”). Slay.

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. 💅

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 which should be evaluated. For example, backticks are evaluated inside of double quotes, but not single quotes. Yes, this is giving shell-brain, iykyk. 🐚

“\” quotes the next character, just as in shells such as Bash and Zsh. For example, if you want to put quotes (“"”) inside of a string, you can use “\” to force the next character to be a literal instead of interpreted character.

“\” means to insert a literal “\” into the line. “\n” and “\r” have their usual C meanings of line feed (LF) and carriage return (CR), 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. Do not break the command name, bestie — that is not the vibe. 🙈

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 (command).

Unix environment variables can be accessed like the way it is done in shells like sh and Bash: Prepend the name of the variable by a dollar (“$”) sign. 💸

🌈 COMMANDS 🌈

🛠️ Configuration Commands 🛠️

The following are the commands understood by NeoMutt:

🪝 `account-hook`

account-hook regex command

This hook is executed whenever you access a remote mailbox. Useful to adjust configuration settings to different IMAP or POP servers. 🛰️

🏷️ `alias` / `unalias`

alias [ -group name ... ] key address [, address ... ]
unalias [ -group name ... ] { * | key ... }

alias defines a surrogate key for the given address(es). Each address will be resolved into either an email address (user@example.com) or a named email address (User Name <user@example.com>). The address may be specified in either format, or in the format user@example.com (User Name).

Note: If you want to create an alias for more than one address, you must separate the addresses with a comma (“,”). Comma is the glue, bestie. 🫶

unalias removes the alias corresponding to the given key or all aliases when “*” is used as an argument.

The optional -group flag causes the address(es) to be added to or removed from the named group.

🔁 `alternates` / `unalternates`

alternates [ -group name ... ] regex [ regex ... ]
unalternates [ -group name ... ] { * | regex ... }

alternates is used to inform NeoMutt about alternate addresses where you receive mail; you can use regular expressions (regex) to specify alternate addresses. This affects NeoMutt's idea about messages from you, and messages addressed to you. 👑

unalternates can be used to write exceptions to alternates regular expression. To remove a regular expression from the alternates list, use the unalternates command with exactly the same regex or use “*” to remove all entries.

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

🎀 `alternative_order` / `unalternative_order`

alternative_order mime-type[/mime-subtype] [ mime-type[/mime-subtype] ... ]
unalternative_order { * | mime-type[/mime-subtype] ... }

alternative_order command permits you to define an order of preference that is used by NeoMutt to determine which part of a multipart/alternative body to display. A mime-subtype of “*” matches any multipart/alternative subtype, as does an empty mime-subtype. ✨

unalternative_order removes entries from the ordered list or deletes the entire list when “*” is used as an argument.

📎 `attachments` / `unattachments`

attachments { + | - }disposition mime-type [ mime-type ... ]
unattachments { + | - }disposition mime-type [ mime-type ... ]
attachments ?
unattachments *

You can make your message index display the number of qualifying attachments in each message, or search for messages by attachment count. You also can configure what kinds of attachments qualify for this feature with the attachments and unattachments commands.

disposition is the attachment's Content-Disposition type — either inline or attachment. You can abbreviate this to I or A.

Disposition is prefixed by either a + symbol or a - symbol. If it's a +, you're saying that you want to allow this disposition and MIME type to qualify. If it's a -, you're saying that this disposition and MIME type is an exception to previous + rules.

mime-type is the MIME type of the attachment you want the command to affect. A MIME type is always of the format major/minor. The major part of mime-type must be literal text (or the special token “*”), but the minor part may be a regular expression. Therefore, */.* matches any MIME type. 🔥

Note that the first MIME part is treated slightly differently: It is almost always the message text. Thus, it is not counted as an attachment if its disposition is inline and it is not a multipart/* or message/* MIME-type.

Entering the command attachments ? as a command will list your current settings in neomuttrc format, so that it can be pasted elsewhere.

Entering the command unattachments * as a command will clear all attachment settings.

👀 `auto_view` / `unauto_view`

auto_view mime-type[/mime-subtype] [ mime-type[/mime-subtype] ... ]
unauto_view { * | mime-type[/mime-subtype] ... }

This command permits you to specify that NeoMutt should automatically convert the given mime-types to text/plain when displaying messages. For this to work, there must be a mailcap(5) entry for the given mime-type with the copiousoutput option set. A mime-subtype of “*” matches any multipart/alternative subtype, as does an empty mime-subtype. 🦋

⌨️ `bind` / `unbind`

bind map[,map ... ] key function
unbind { * | map | [,map...]} [ key ]

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

map specifies in which menu the binding belongs. Multiple maps may be specified by separating them with commas (no additional whitespace is allowed). The currently defined maps are: alias, attach, browser, compose, editor, generic, index, mix, pager, pgp, postpone, query and smime.

key is the key (or key sequence) you wish to bind, e.g. \Ca for control-A. In addition, key may be specified as a three digit octal number prefixed with a “\” or as a symbolic name. The <what-key> function can be used to explore keycode and symbolic names for the keys on your keyboard.

function specifies which action to take when key is pressed. Note that the function name is to be specified without angle brackets.

Missing key sequence in unbind command means unbind all bindings in menus given in map.

For more information on keys and functions, please consult the NeoMutt manual.

🔤 `charset-hook` / `iconv-hook`

charset-hook alias charset
iconv-hook charset local-charset

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

iconv-hook defines a system-specific name for a character set. This is useful when your system's iconv(3) implementation does not understand MIME character set names (such as iso-8859-1), but instead insists on being fed with implementation-specific character set names (such as 8859-1). In this specific case, you'd put iconv-hook iso-8859-1 8859-1 into your configuration file. 💜

🎨 `color` / `uncolor`

color object [ attribute ... ] foreground background
color { header | body } [ attribute ... ] foreground background regex
color status foreground background [regex [ num ]]
color index-object [ attribute ... ] foreground background pattern
color compose composeobject foreground background
color compose composeobject [ attribute ... ] foreground background
uncolor { index-object | header | body } { * | pattern ... }

If your terminal supports color, these commands can be used to assign foreground/background combinations to certain objects. The currently defined objects are: attach_headers, attachment, body, bold, error, hdrdefault, header, index, index_author, index_collapsed, index_date, index_flags, index_label, index_number, index_size, index_subject, index_tag, index_tags, indicator, markers, message, normal, progress, prompt, quoted, quotedN, search, signature, status, stripe_even, stripe_odd, tilde, tree, underline.

If the sidebar is enabled the following objects are also valid: sidebar_background, sidebar_divider, sidebar_flagged, sidebar_highlight, sidebar_indicator, sidebar_new, sidebar_ordinary, sidebar_spool_file.

The body and header objects allow you to restrict the colorization to a regular expression. The index-object permits you to select colored messages by pattern.

The header and body match regex in the header/body of a message, index-object can match pattern in the message index. Note that IMAP server-side searches (=b, =B, =h) are not supported for color index patterns.

The status object optionally takes an regex and a match number. If the regex is given, only the matching parts are colored. If additionally the match number is given, only that sub-match of the regex is colored.

Valid composeobjects include header, security_encrypt, security_sign, security_both, security_none.

Valid colors include: default, black, red, green, yellow, blue, magenta, cyan, white, #RRGGBB, colorN. 🌈

okay so valid attributes include: none, bold, underline, reverse, and standout. 💅

The uncolor command can be applied to the index, header, and body objects only — that's the whole guest list. 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 list of all entries.

for further information on colorization, please consult the NeoMutt manual. ✨

crypt-hook regex keyid

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. The meaning of keyid is to be taken broadly: this can be a different email address, a numerical keyid, or even just an arbitrary search string. You may use multiple crypt-hooks with the same regex; multiple matching crypt-hooks result in the use of multiple *keyid*s for a recipient. 🔑

index-format-hook name [!]pattern format-string

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

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 .neomuttrc, with the first match being used. The hook's format-string is then substituted and evaluated. 🎀

exec function [ function ... ]

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

fcc-save-hook pattern mailbox
fcc-hook pattern mailbox
save-hook pattern mailbox

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.

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.

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.

To provide more flexibility and good defaults, NeoMutt applies the expandos of $index_format to mailbox after it was expanded. See PATTERNS section below or consult section “Message Matching in Hooks” in NeoMutt manual for information on the exact format of pattern. 💌

folder-hook [-noregex] regex command

When NeoMutt enters a folder which matches regex (or, when regex is preceded by an exclamation mark, does not match regex), the given command is executed. The -noregex switch controls whether regex is matched as simple string equality or as a full regex match.

When several folder-hooks match a given mail folder, they are executed in the order given in the configuration file. 📁

group [ -group name ... ] { -rx regex ... | -addr address ... }
ungroup [ -group name ... ] { * | -rx regex ... | -addr address ... }

group 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.

ungroup 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.

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

Once defined, these address groups can be used in patterns to search for and limit the display to messages matching a group. 🫶

hdr_order header [ header ... ]
unhdr_order { * | header ... }

With the hdr_order command you can specify an order in which NeoMutt will attempt to present these 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. 🌸

ifdef symbol "config-command [ args ... ]"
ifndef symbol "config-command [ args ... ]"
finish

The ifdef feature introduces three new commands to NeoMutt and allow you to share one config file between versions of NeoMutt that may have different features compiled in. 🧚

Example symbols and what they mean:

sidebar_format — config variable
status-color, imap — compiled-in feature
pgp-menu, group-related — function
index-format-hook, tag-transforms — command
my_var — my variable
lmdb, tokyocabinet — store (database)
HOME, COLUMNS — environment variable

A list of compile-time symbols can be seen in the output of the command neomutt -v (in the “Compile options” section).

finish is particularly useful when combined with ifndef. 🦋

ignore string [ string ... ]
unignore { * | string ... }

The ignore command allows you to specify header fields which you don't normally want to see in the pager. You do not need to specify the full header field name. For example, ignore content- will ignore all header fields that begin with the string content-, and ignore * will ignore all headers.

To remove a previously added token from the list, use the unignore command. For example, unignore * will remove all tokens from the ignore list. 🙈

lists [ -group name ... ] regex [ regex ... ]
unlists [ -group name ... ] { * | regex ... }
subscribe [ -group name ... ] regex [ regex ... ]
unsubscribe [ -group name ... ] { * | regex ... }

NeoMutt maintains two lists of mailing list address regular expressions, a list of subscribed mailing lists, and a list of known mailing lists. All subscribed mailing lists are known. 💖

The lists command adds a mailing list address to the list of known mailing lists. The unlists command removes a mailing list from the lists of known and subscribed mailing lists.

The subscribe command adds a mailing list to the lists of known and subscribed mailing lists. The unsubscribe command removes it from the list of subscribed mailing lists.

The -group flag adds all of the subsequent regular expressions to the named group. 🎀

macro menu[,menu ... ] key sequence [ description ]
unmacro { * | menu | [,menu...]} [ key ]

This command binds the given sequence of keys to the given key in the given menu or menus. For currently defined menus, see bind command above. To specify multiple menus, put only a comma between the menus.

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

Missing key sequence in unmacro command means unmacro all macros in menus given in menu. 💅

mailboxes [[-label label] | -nolabel]
          [[-notify | -nonotify]
          [-poll | -nopoll]
          mailbox] [ ... ]
named-mailboxes label mailbox [label mailbox ... ]
unmailboxes { * | mailbox ... }

The mailboxes specifies folders which can receive mail and which will be checked for new messages. When changing folders, pressing Space will cycle through folders with new mail. 📬

The named-mailboxes is an alternative to mailboxes -label label. NeoMutt can be configured to display the label instead of the mailbox path.

The unmailboxes command is used to remove a file name from the list of folders which can receive mail. If * is specified as the file name, the list is emptied. ✨

mailto_allow { * | header-field ... }
unmailto_allow { * | header-field ... }

As a security measure, NeoMutt will only add user-approved *header-field*s from a mailto: URL. This is necessary since NeoMutt will handle certain *header-field*s, 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-field*s, 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.

echo message

Prints message to the message window. After printing the message, echo will pause for the number of seconds specified by $sleep_time. 🗣️

cd directory

Changes the current working directory. 📂

mbox-hook [-noregex] regex mailbox

When NeoMutt changes to a mail folder which matches regex, mailbox will be used as the “mbox” folder, i.e. read messages will be moved to that folder when the mail folder is left. The -noregex switch controls whether regex is matched as simple string equality or as a full regex match.

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. 💀

💅 oh and ps — the first matching mbox-hook applies. First one wins, that's it, that's the rule.

`message-hook` ✨

message-hook pattern command

Before NeoMutt shows you a message (or formats it up for replying/forwarding), it checks: does the message match pattern? If yes, it runs command. And plot twist — if the pattern is preceded by an exclamation mark, it's the opposite: run the command when the message does not match. 🙃

When multiple message-hooks match, they get executed in the order they occur in your configuration file. Order matters, bestie, so place them thoughtfully. 🎀

`mime_lookup` / `unmime_lookup` 🦋

mime_lookup mime-type[/mime-subtype] [ mime-type[/mime-subtype] ... ]
unmime_lookup { * | mime-type[/mime-subtype] ... }

This one lets you define a list of "data" MIME content types where NeoMutt will try to figure out the actual file type from the file name — instead of using a mailcap(5) entry given for the original MIME type. Think of it as "bestie, look at the filename, not the label". For instance, you may add the application/octet-stream MIME type to this list. 💖

Also! The unmime_lookup command is there to disable this feature for any particular MIME type if it had been set — like, say, in a global neomuttrc. Undoing a vibe, lowkey.

`mono` / `unmono` 🌈

mono object attribute
mono { header | body } attribute regex
mono index-object attribute pattern
unmono { index-object | header | body } { * | pattern ... }

For terminals that don't support color 😭 you can still assign attributes to objects. No color? No problem. Mono mode ate.

`my_hdr` / `unmy_hdr` 🎀

my_hdr string
unmy_hdr { * | field ... }

With my_hdr you can define headers that get added to the messages you compose. And unmy_hdr will remove the given user-defined headers. Add header, remove header, the circle of life. ✨

`open-hook` / `close-hook` / `append-hook` 🗜️

open-hook regex "shell-command"
close-hook regex "shell-command"
append-hook regex "shell-command"

These give you a way to handle compressed folders, which is honestly iconic. The regex specifies which folders count as compressed (e.g. "\.gz$"). And the commands tell NeoMutt how to uncompress a folder (open-hook), compress a folder (close-hook), or append a compressed mail to a compressed folder (append-hook). 🫶

The shell-command is a printf(3)-like format string and must contain two placeholders — one for from (%f) and one for to (%t) filenames — and these should be placed inside single quotes to prevent unintended shell expansions. Do not skip the quotes, I'm begging. 😭

Examples, straight up:

append-hook '\.gz$' "gzip --stdout '%t' >> '%f'"
close-hook '\.gz$' "gzip --stdout '%t' > '%f'"
open-hook '\.gz$' "gzip --stdout --decompress '%f' > '%t'"

`push` 💅

push string

This command adds the named string to the beginning of the keyboard buffer. Yes, it's cutting the line. 👑

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

Okay and this part is important: for using functions, it's crucial to use angle brackets (< and >) so NeoMutt recognizes the input as a function name. Otherwise it will just simulate individual keystrokes. Function name ≠ keys, iykyk. ⭐

`reply-hook` / `send-hook` / `send2-hook` 🔥

reply-hook pattern command
send-hook pattern command
send2-hook pattern command

These bad boys execute arbitrary configuration commands based on the recipients of the message. pattern is used to match the message — see the section "Message Matching in Hooks" in the manual for the details. command is executed when pattern matches.

Now, the differences, because they matter:

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.
Heads up: reply-hooks are matched before the send-hook, regardless of the order specified in the user's configuration file. Chronology who? Not here. 🙈
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.
And a lil note: send-hooks are only executed once, after getting the initial list of recipients. One and done. 🎯

`score` / `unscore` 🍓

score pattern value
unscore { * | pattern ... }

The score command adds value to a message's score if pattern matches it. pattern is a string in the format described in the PATTERNS section below. value is a positive or negative integer. A message's final score is the sum total of all matching score entries. Math but make it mail. ✨

The unscore command removes score entries from the list. And no cap: you must specify the same pattern you specified in the score command for it to be removed. The pattern * is a special token which means... clear the list of ALL score entries. Nuclear option, but a valid one. 💀

`set` / `unset` / `reset` / `toggle` 🧚

set { [ no | inv | & | ? ]variable } [ ... ]
set { variable=value | variable+=increment | variable-=decrement } [ ... ]
unset variable  [ variable ... ]
reset variable  [ variable ... ]
toggle variable [ variable ... ]
set variable ?

These commands are how you set and manipulate configuration variables. The whole toolkit, bestie.

NeoMutt knows four basic types of variables: boolean, number, string, string list and quadoption. (Yes, we said four. We're counting with vibes today. 💀)

Boolean variables can be set (true), unset (false), or toggled.
Number variables can be assigned a positive integer value. Their value can be incremented += and decremented -=.
String list variables use += for appending increment to the string list and -= for removal decrement from the string list.
String variables consist of any number of printable characters and must be enclosed in quotes if they contain spaces or tabs. You may also use the escape sequences \n and \t for newline and tab, respectively. Content of a string variable can be extended using +=.
Quadoption variables control whether or not to be prompted for certain actions, or to specify a default action:
- yes → the action is carried out automatically, as if you'd answered "yes" to the question.
- no → the action is carried out as if you'd answered "no".
- ask-yes → causes a prompt with a default answer of "yes".
- ask-no → provides a default answer of "no".

The toggle command automatically prepends the inv prefix to all specified variables. The unset command automatically prepends the no prefix to all specified variables. And if you use set with the variable prefixed by &, that has the same behavior as the reset command. Same energy, different spelling. 🌀

The reset command resets all given variables to the compile time defaults. And with reset there exists the special variable all, which lets you reset all variables to their system defaults. One command to reset them all. 👑

Using the <enter-command> function, you can query the value of a variable by suffixing the name of the variable with a question mark:

:set allow_8bit?

The old prefix query syntax is also still supported, grandfathered in and thriving:

:set ?allow_8bit

`setenv` / `unsetenv` 🌸

setenv { ?variable | variable value }
unsetenv variable

You can alter the environment that NeoMutt passes on to its child processes using the setenv and unsetenv operators. Yes, it's giving "raising the children your way". 🫶

You can also query current environment values by prefixing a ? character. Easy.

`sidebar_pin` / `sidebar_unpin` 📌

sidebar_pin mailbox [ mailbox ...]
sidebar_unpin { * | mailbox ... }

The sidebar_pin command specifies mailboxes that will always be displayed in the sidebar — even if $sidebar_new_mail_only is set and the mailbox does not contain new mail. Stubborn in the best way. 💅

The sidebar_unpin command removes a mailbox from the list of always-displayed mailboxes. Use sidebar_unpin * to remove all mailboxes. Clean slate, periodt.

`source` 📂

source filename

This command allows the inclusion of initialization commands from other files. If the filename begins with a tilde (~), it will be expanded to the path of your home directory. Home sweet home. 🏠

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|

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 — like 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).

⚠️ Note: a hook remembers the configuration file it was defined in and sets the context to that file when executing its commands. As a result, a source command inside a hook is executed in the context of the configuration file the hook was defined in. Thus relative filenames are interpreted relative to the configuration file the hook is defined in. Context is everything, bestie.

`spam` / `nospam` 🚫

spam regex format
nospam { * | regex }

NeoMutt has generalized support for external spam-scoring filters, and that's genuinely so cool of it. By defining your spam *regex*s 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. And here's a tip from the manual itself — try this:

"%<H?[%H] >"

That displays spam tags only when they are defined for a given message. Conditional slay. 💖

For further information on spam-scoring filters, please consult the section "Spam Detection" in the NeoMutt manual.

`subjectrx` / `unsubjectrx` 🎀

subjectrx regex replacement
unsubjectrx { * | regex }

The subjectrx command specifies a regular expression which, if detected in a message subject, causes the subject to be replaced with the replacement value. The replacement is subject to substitutions in the same way as for the spam command:

%L → the text to the left of the match
%R → the text to the right of the match
%1 → the first subgroup in the match (etc.)

If you simply want to erase the match, set it to "%L%R". Poof, gone. 🌬️

Any number of subjectrx commands may coexist. Collect them like stickers.

🚨 Note this well: the replacement value replaces the entire subject, not just the match! Like, the whole thing. Don't come for me when your subject line looks different than you expected.

unsubjectrx removes a given subjectrx from the substitution list. And if * is used as the argument, all substitutions will be removed. 🦋

subscribe-to imap-folder-uri
unsubscribe-from imap-folder-uri

okay bestie these two are your direct line to the IMAP server's little folder guest list 💅 — they literally tell the server subscribe me to this folder or unsubscribe me from it. The argument has to be an IMAP URI, no exceptions, like subscribe-to imaps://mail.example.org/inbox.

Subscription is, like, a whole IMAP protocol feature where the server manages a list of subscribed folders — it's not a NeoMutt invention, the server is the one holding the clipboard 📋. Clients like NeoMutt can then query that list whenever they want.

And NeoMutt does use that list in various situations, so if you're curious peep $imap_list_subscribed and $imap_check_subscribed 👀.

timeout-hook command
startup-hook command
shutdown-hook command

The Global Hooks feature is what brings these three into NeoMutt — they get called when global events go down. startup-hook and shutdown-hook are the ones most likely to be useful to users of notmuch(1), just saying 🫶.

timeout-hook — runs a command periodically when NeoMutt checks for new mail. It gets called every $timeout seconds.
startup-hook — before NeoMutt opens the first mailbox when it's first starting up, it runs this hook for the given command. First-day-of-school energy ✨
shutdown-hook — before NeoMutt is about to exit, and before the mailbox is closed, it runs this hook for the given command. The graceful goodbye 🎀

unhook { * | hook-type }

The cleanup era 🌸 — this command lets you flush hooks you previously defined. You've got two vibes to choose from:

pass the * character as the argument and all your hooks get removed, like, gone gone
pass a specific hook-type and only the hooks of that type get yeeted — something like unhook send-hook does exactly what it says on the tin 💅

Pick your fighter, but know that the * option is the nuclear one 🔥

🌸 PATTERNS 🌸

okay so lots of NeoMutt commands let you pass in a pattern to match messages — think limit, tag-pattern, delete-pattern, the above mentioned hook commands, etc. The “Pattern modifiers” table is basically the cheat sheet, and it shows several ways to select messages. Here’s every single one, bestie, no skips 💅

🎀 Pattern Modifier 🎀

~A — all messages. literally every single one ✨
=B STRING — messages which contain STRING in the whole message. If IMAP is enabled, it searches for STRING on the server, rather than downloading each message and searching it locally 🦋
=b STRING — messages which contain STRING in the message body. If IMAP is enabled, it searches for STRING on the server, rather than downloading each message and searching it locally 💖
~B EXPR — messages which contain EXPR in the whole message 🌸
~b EXPR — messages which contain EXPR in the message body 🎀
%C GROUP — messages either “To:”, “Cc:” or “Bcc:” to any member of GROUP 👑
%c GROUP — messages carbon-copied to any member of GROUP 💌
~C EXPR — messages either “To:”, “Cc:” or “Bcc:” EXPR 🫶
~c EXPR — messages carbon-copied to EXPR 💜
~D — deleted messages 💀
~d MIN-MAX — messages with “date-sent” in a date range 📅
%e GROUP — messages which contain a member of GROUP in the “Sender:” field 🌈
~E — expired messages 😭
~e EXPR — messages which contain EXPR in the “Sender:” field 🍓
%f GROUP — messages originating from any member of GROUP 🧚
~F — flagged messages 🔥
~f EXPR — messages originating from EXPR ⭐
~G — cryptographically encrypted messages 🔐
~g — cryptographically signed messages ✍️
=h STRING — messages which contain STRING in the message header. If IMAP is enabled, it searches for STRING on the server, rather than downloading each message and searching it locally; STRING must be of the form “Header: substring” (see below) 👀
~H EXPR — messages with spam attribute matching EXPR 🚫
~h EXPR — messages which contain EXPR in the message header 📨
~i EXPR — messages which match EXPR in the “Message-ID:” field 🆔
~I QUERY — messages whose Message-ID field is included in the results returned from an external search program, when the program is run with QUERY as its argument. See $external_search_command 🔎
~k — messages containing PGP key material 🔑
~K EXPR — messages blind carbon-copied to EXPR 🙈
%L GROUP — messages either originated or received by any member of GROUP 🌟
~L EXPR — messages either originated or received by EXPR 💫
~l — messages addressed to a known mailing list 📬
~M EXPR — messages which contain a mime Content-Type matching EXPR 🧩
~m <MAX — messages with numbers less than MAX *) 🔢

okay continuing the pattern parade 🎉 these are the rest of the search patterns — same energy, all the facts, no cap:

~m >MIN — messages with numbers greater than MIN *)
~m MIN,MAX — messages with offsets (from the selected message) in the range MIN to MAX *)
~m MIN-MAX — message in the range MIN to MAX *)
~m N — just message number N *)
~N — new messages ✨
~n MIN-MAX — messages with a score in the range MIN to MAX **)
~O — old messages
~P — messages from you (consults $from, alternates, and local account/hostname information) 🫶
~p — messages addressed to you (consults $from, alternates, and local account/hostname information)
~Q — messages which have been replied to
~R — read messages
~r MIN-MAX — messages with “date-received” in a date range
~S — superseded messages
~s EXPR — messages having EXPR in the “Subject:” field
~T — tagged messages 🏷️
~t EXPR — messages addressed to EXPR
~U — unread messages
~u — messages addressed to a subscribed mailing list
~V — cryptographically verified messages 🔐
~v — message is part of a collapsed thread.
~w EXPR — newsgroups matching EXPR
~X MIN-MAX — messages with MIN to MAX attachments **)
~x EXPR — messages which contain EXPR in the “References:” or “In-Reply-To:” field
~y EXPR — messages which contain EXPR in their keywords
~Y EXPR — messages whose tags match EXPR
~z MIN-MAX — messages with a size in the range MIN to MAX **) ***)
=/ STRING — IMAP custom server-side search for STRING. Currently only defined for Gmail. See section “Gmail Patterns” in NeoMutt manual. 📬
~= — duplicated messages (see $duplicate_threads)
~# — broken threads (see $strict_threads)
~$ — unreferenced message (requires threaded view)
~(PATTERN) — messages in threads containing messages matching PATTERN, e.g. all threads containing messages from you: ~(~P) — it's giving "the whole group chat, not just the one text" 💅
~<(PATTERN) — messages whose immediate parent matches PATTERN, e.g. replies to your messages: ~<(~P)
~>(PATTERN) — messages having an immediate child matching PATTERN, e.g. messages you replied to: ~>(~P)

Where EXPR is a regular expression, and GROUP is an address group. 📌

Okay bestie, the starred notes are not skippable, they're literally load-bearing:

*) The message number ranges (introduced by “~m”) are even more general and powerful than the other types of ranges. Read on and see section “Message Ranges” in manual. 🔥

**) The forms “<MAX”, “>MIN”, “MIN-” and “-MAX” are allowed, too.

***) The suffixes “K” and “M” are allowed to specify kilobyte and megabyte respectively. 🍓

okay bestie, special attention time 💅 — when you're using regular expressions inside patterns, NeoMutt's parser will strip one level of backslash (\), which is normally used for quoting. So if you actually want a backslash in the regular expression, you need to use two backslashes (\\) instead. no cap.

You can force NeoMutt to treat EXPR as a simple STRING instead of a regular expression by using = instead of ~ in the pattern name. For example, =b *.* will find all messages that contain the literal string *.*. Simple substring matches are less powerful than regular expressions, but they can be considerably faster. This is especially true for IMAP folders, because substring matches can be performed on the server instead of by fetching every message. IMAP treats =h specially: it must be of the form Header: substring and will not partially match header names. The substring part may be omitted if you simply wish to find messages containing a particular header without regard to its value.

Patterns matching lists of addresses (notably c, C, p, P and t) match if there is at least one match in the whole list. If you want to make sure that all elements of that list match, you need to prefix your pattern with ^.

This example matches all mails which only has recipients from Germany.

Matching all addresses in address lists: ^~C \.de$

You can restrict address pattern matching to aliases that you have defined with the @ modifier. This example matches messages whose recipients are all from Germany and who are known to your alias list.

Matching restricted to aliases: ^@~C \.de$

To match any defined alias, use a regular expression that matches any string. This example matches messages whose senders are known aliases.

Matching any defined alias: @~f .

🧚 Nesting and Boolean Operators 🧚

Logical AND is performed by specifying more than one criterion.

For example: ~t work ~f smith

would select messages which contain the word “work” in the list of recipients and that have the word “smith” in the From: header field.

NeoMutt also recognizes the following operators to create more complex search patterns:

! — logical NOT operator
| — logical OR operator
() — logical grouping operator

Here is an example illustrating a complex search pattern. This pattern will select all messages which do not contain “work” in the To: or Cc: field and which are from “smith”.

Using boolean operators in patterns: !(~t work|~c work) ~f smith

Here is an example using white space in the regular expression (note the ' and " delimiters). For this to match, the mail's subject must match the ^Junk +From +Me$ and it must be from either Jim +Somebody or Ed +SomeoneElse:

Quoting regex: '~s "^Junk +From +Me$" ~f ("Jim +Somebody"|"Ed +SomeoneElse")'

Note: If a regular expression contains parenthesis, or a vertical bar (|), you must enclose the expression in double or single quotes since those characters are also used to separate different parts of NeoMutt's pattern language.

For example: ~f "user@(home\.org|work\.com)"

Without the quotes, the parenthesis wouldn't end. This would be separated to two OR'd patterns: ~f user@(home\.org and work\.com). They are never what you want.

🎀 Searching by Date 🎀

NeoMutt supports two types of dates, absolute and relative for the ~d and ~r pattern.

🦋 Absolute Dates

Dates must be in dd[/mm[/[CC]YY]] format (day, month, century and year — all parts, with the exception of day, are optional, defaulting to the current month and year). An example of a valid range of dates is:

Limit to messages matching: ~d 20/1/95-31/10

Alternatively, you may use YYYYMMDD to specify a date.

When given a two-digit year, NeoMutt will interpret values less than 70 as lying in the 21st century (i.e., 38 means 2038 and not 1938, and 00 is interpreted as 2000), and values greater than or equal to 70 as lying in the 20th century.

If you omit the MINimum (first) date, and just specify -dd/mm/YY, all messages before the given date will be selected. If you omit the MAXimum (second) date, and specify dd/mm/YY-, all messages after the given date will be selected. If you specify a single date with no dash (-), only messages sent/received on the given date will be selected.

You can add error margins to absolute dates. An error margin is a sign (+ or -), followed by a digit, followed by one of the units in table “Date units” below. As a special case, you can replace the sign by a * character, which is equivalent to giving identical plus and minus error margins.

Date units, bestie:

d — Days
w — Weeks
m — Months
y — Years
S — Seconds
M — Minutes
H — Hours

Example: To select any messages two weeks around January 15, 2001, you'd use the following pattern:

Limit to messages matching: ~d 15/1/2001*2w

It is possible to give multiple error margins:

which cumulate: ~d 1/1/2001-1w+2w*3d

🌸 Relative Dates

This type of date is relative to the current date, and may be specified as:

<offset for messages newer than offset units
=offset for messages exactly offset units old
>offset for messages older than offset units

offset is specified as a positive number with one of the units from table “Date units”.

Example: To select messages less than 1 month old, you would use:

Limit to messages matching: ~d <1m

Note: All dates used when searching are relative to the local time zone, so unless you change the setting of your $index_format to include a %[...] format, these are not the dates shown in the main index.

💖 CONFIGURATION VARIABLES 💖

🩷 abort_backspace

Type: boolean
Default: yes

If set, hitting backspace against an empty prompt aborts the prompt.

🩷 abort_key

Type: string
Default: "007"

Specifies the key that can be used to abort prompts. The format is the same as used in bind commands. The default is equivalent to Ctrl-G. Note that the specified key should not be used in other bindings, as the abort operation has higher precedence and the binding will not have the desired effect.

Example:

set abort_key = "<Esc>"

Please note that when using <Esc> as the abort key, you may also want to set the environment variable ESCDELAY to a low value or even 0 which will reduce the time that ncurses waits to distinguish singular <Esc> key presses from the start of a terminal escape sequence. The default time is 1000 milliseconds and thus quite noticeable.

🩷 abort_noattach

Type: quadoption
Default: no

If set to yes, when composing messages containing the regular expression specified by $abort_noattach_regex and no attachments are given, composition will be aborted. If set to no, composing messages as such will never be aborted.

Example:

set abort_noattach_regex = "\\<attach(|ed|ments?)\\>"

🩷 abort_noattach_regex

Type: regular expression
Default: "\<(attach|attached|attachments?)\>"

Specifies a regular expression to match against the body of the message, to determine if an attachment was mentioned but mistakenly forgotten. If it matches, $abort_noattach will be consulted to determine if message sending will be aborted.

Like other regular expressions in NeoMutt, the search is case sensitive if the pattern contains at least one upper case letter, and case insensitive otherwise.

🩷 abort_nosubject

Type: quadoption
Default: ask-yes

If set to yes, when composing messages and no subject is given at the subject prompt, composition will be aborted. If set to no, composing messages with no subject given at the subject prompt will never be aborted.

🩷 abort_unmodified

Type: quadoption
Default: yes

If set to yes, composition will automatically abort after editing the message body if no changes are made to the file (this check only happens after the first edit of the file). When set to no, composition will never be aborted.

🩷 account_command

Type: command
Default: ""

If set, this command is used to retrieve account credentials. The command is invoked passing a number of --key value arguments with the specifics of the account to lookup. The command writes to standard output a number of key: value lines. Currently supported arguments are --hostname, --username, and --type, where type can be any of imap, imaps, pop, pops, smtp, smtps, nntp, and nntps. Currently supported output lines are login, username, and password.

🩷 alias_file

Type: path
Default: "~/.neomuttrc"

The default file where aliases made by the <create-alias> function get saved. Anything added to this file is encoded in the charset from $config_charset if that's set — otherwise it's whatever your current charset is. 💖

Note: NeoMutt will not automatically source this file, bestie. If this option points at a dedicated alias file, you gotta explicitly run the source command yourself for it to actually get executed. No autopilot here. 🫶

The default for this option is the currently used neomuttrc file, or ~/.neomuttrc if no user neomuttrc was found.

alias_format

Type: string Default: "%3n %f%t %-15a %-56r | %c"

Specifies the format of the data displayed for the <alias> menu. The following printf(3)-style sequences are available:

%a — Alias name
%c — Comment
%f — Flags — currently, a "d" for an alias marked for deletion
%n — Index number
%r — Address which alias expands to
%t — Character which indicates if the alias is tagged for inclusion
%Y — Comma-separated tags
%>X — right justify the rest of the string and pad with character "X"
%|X — pad to the end of the line with character "X"
%*X — soft-fill with character "X" as pad

allow_8bit

Type: boolean Default: yes

Controls whether 8-bit data is converted to 7-bit using either Quoted-Printable or Base64 encoding when sending mail. ✨

allow_ansi

Type: boolean Default: no

Controls whether ANSI color codes in messages (and color tags in rich text messages) are to be interpreted. Messages containing these codes are rare, but if this option is set, their text will be colored accordingly. 👀

Note that this may override your color choices, and even present a security problem, since a message could include a line like [-- PGP output follows ... and give it the same color as your attachment color (see also $crypt_timestamp). Lowkey sketchy, so be careful bestie. 💀

arrow_cursor

Type: boolean Default: no

When set, an arrow ("->") will be used to indicate the current entry in menus instead of highlighting the whole line. On slow network or modem links this will make response faster because there is less that has to be redrawn on the screen when moving to the next or previous entries in the menu. Efficiency slay. ⚡

arrow_string

Type: string Default: "->"

Specifies the string of arrow_cursor when arrow_cursor is enabled. Cute.

ascii_chars

Type: boolean Default: no

If set, NeoMutt will use plain ASCII characters when displaying thread and attachment trees, instead of the default ACS characters. 🌈

ask_bcc

Type: boolean Default: no

If set, NeoMutt will prompt you for blind-carbon-copy (Bcc) recipients before editing an outgoing message. 🙈

ask_cc

Type: boolean Default: no

If set, NeoMutt will prompt you for carbon-copy (Cc) recipients before editing the body of an outgoing message.

ask_followup_to

Type: boolean Default: no

If set, NeoMutt will prompt you for follow-up groups before editing the body of an outgoing message.

ask_x_comment_to

Type: boolean Default: no

If set, NeoMutt will prompt you for x-comment-to field before editing the body of an outgoing message.

assumed_charset

Type: string list Default: ""

This variable is a colon-separated list of character encoding schemes for messages without character encoding indication. Header field values and message body content without character encoding indication would be assumed that they are written in one of this list. By default, all the header fields and message body without any charset indication are assumed to be in "us-ascii". 🎀

For example, Japanese users might prefer this:

set assumed_charset="iso-2022-jp:euc-jp:shift_jis:utf-8"

However, only the first content is valid for the message body. iykyk.

attach_charset

Type: string list Default: ""

This variable is a colon-separated list of character encoding schemes for text file attachments. NeoMutt uses this setting to guess which encoding files being attached are encoded in, to convert them to a proper character set given in $send_charset.

If unset, the value of $charset will be used instead. For example, the following configuration would work for Japanese text handling:

set attach_charset="iso-2022-jp:euc-jp:shift_jis:utf-8"

Note: for Japanese users, "iso-2022-*" must be put at the head of the value as shown above if included. Like, literally at the front, no negotiations. 💅

attach_format

Type: string Default: "%u%D%I %t%4n %T%d %> [%.7m/%.10M, %.6e%<C?, %C>, %s] "

This variable describes the format of the "attachment" menu. The following printf(3)-style sequences are understood:

%C — Charset
%c — Requires charset conversion ("n" or "c")
%D — Deleted flag
%d — Description (if none, falls back to %F)
%e — MIME content-transfer-encoding
%f — Filename
%F — Filename in content-disposition header (if none, falls back to %f)
%I — Disposition ("I" for inline, "A" for attachment)
%m — Major MIME type
%M — MIME subtype
%n — Attachment number
%Q — "Q", if MIME part qualifies for attachment counting
%s — Size (see formatstrings-size)
%T — Graphic tree characters
%t — Tagged flag
%u — Unlink (=to delete) flag
%X — Number of qualifying MIME parts in this part and its children (please see the "attachments" section for possible speed effects)
%>X — Right justify the rest of the string and pad with character "X"
%|X — Pad to the end of the line with character "X"
%*X — Soft-fill with character "X" as pad

For an explanation of "soft-fill", see the $index_format documentation. 📖

attach_save_dir

Type: path Default: "./"

The directory where attachments are saved. 🍓

attach_save_without_prompting

Type: boolean Default: no

This variable, when set to true, will cause attachments to be saved to the 'attach_save_dir' location without prompting the user for the filename. Straight to business, no questions asked.

attach_sep

Type: string Default: "\n"

The separator to add between attachments when operating (saving, printing, piping, etc) on a list of tagged attachments.

attach_split

Type: boolean Default: yes

If this variable is unset, when operating (saving, printing, piping, etc) on a list of tagged attachments, NeoMutt will concatenate the attachments and will operate on them as a single attachment. The $attach_sep separator is added after each attachment. When set, NeoMutt will operate on the attachments one by one. One at a time, queen behavior. 👑

attribution_intro

Type: string Default: "On %d, %n wrote:"

This is the string that will precede a replied-to message which is quoted in the main body of the reply (this is the case when $include is set).

For a full listing of defined printf(3)-like sequences see the section on $index_format. See also $attribution_locale.

attribution_locale

Type: string Default: ""

The locale used by strftime(3) to format dates in the attribution strings. Legal values are the strings your system accepts for the locale environment variable $LC_TIME.

This variable is to allow the attribution date format to be customized by recipient or folder using hooks. By default, NeoMutt will use your locale environment, so there is no need to set this except to override that default.

Affected variables are: $attribution_intro, $attribution_trailer, $forward_attribution_intro, $forward_attribution_trailer, $indent_string. ✨

attribution_trailer

Type: string Default: ""

Similar to the $attribution_intro variable, this is the string that will come after a replied-to message which is quoted in the main body of the reply (this is the case when $include is set).

For a full listing of defined printf(3)-like sequences see the section on $index_format. See also $attribution_locale.

auto_edit

Type: boolean Default: no

When set along with $edit_headers, NeoMutt will skip the initial send-menu (prompting for subject and recipients) and allow you to immediately begin editing the body of your message. The send-menu may still be accessed once you have finished editing the body of your message. Main character energy: body first, menu later. 💅

Note: when this option is set, you can't use send-hooks that depend on the recipients when composing a new (non-reply) message, as the initial list of recipients is empty.

Also see $fast_reply.

Type: boolean Default: no

When set, NeoMutt assumes the presence of a List-Post header means the recipient is subscribed to the list. Unless the mailing list is in the "unsubscribe" or "unlist" lists, it will be added to the "subscribe" list. Parsing and checking these things slows header reading down, so this option is disabled by default. Trade-offs, bestie. 😭

auto_tag

Type: boolean Default: no

When set, functions in the index menu which affect a message will be applied to all tagged messages (if there are any). When unset, you must first use the <tag-prefix> function (bound to ";" by default) to make the next function apply to all tagged messages.

beep

Type: boolean Default: yes

When this variable is set, NeoMutt will beep when an error occurs. 🔊

beep_new

Type: boolean Default: no

When this variable is set, NeoMutt will beep whenever it prints a message notifying you of new mail. This is independent of the setting of the $beep variable. Two separate beep situations, fr fr. 🦋

bounce — Type: quadoption · Default: ask-yes Controls whether you will be asked to confirm bouncing messages. If set to yes, you don't get asked if you want to bounce a message. Setting this variable to no is not generally useful, and thus not recommended, because you are unable to bounce messages.
bounce_delivered — Type: boolean · Default: yes When this variable is set, NeoMutt will include Delivered-To headers when bouncing messages. Postfix users may wish to unset this variable.
braille_friendly — Type: boolean · Default: no When this variable is set, NeoMutt will place the cursor at the beginning of the current line in menus, even when the $arrow_cursor variable is unset, making it easier for blind persons using Braille displays to follow these menus. The option is unset by default because many visual terminals don't permit making the cursor invisible.
browser_abbreviate_mailboxes — Type: boolean · Default: yes When this variable is set, NeoMutt will abbreviate mailbox names in the browser mailbox list, using '~' and '=' shortcuts.

The default "alpha" setting of $sort_browser uses locale-based sorting (using strcoll(3)), which ignores some punctuation. This can lead to some situations where the order doesn't make intuitive sense. In those cases, it may be desirable to unset this variable.

browser_sort_dirs_first — Type: boolean · Default: no If this variable is set, the browser will group directories before files.
catchup_newsgroup — Type: quadoption · Default: ask-yes If this variable is set, NeoMutt will mark all articles in newsgroup as read when you quit the newsgroup (catchup newsgroup).
certificate_file — Type: path · Default: "~/.mutt_certificates" This variable specifies the file where the certificates you trust are saved. When an unknown certificate is encountered, you are asked if you accept it or not. If you accept it, the certificate can also be saved in this file and further connections are automatically accepted.

You can also manually add CA certificates in this file. Any server certificate that is signed with one of these CA certificates is also automatically accepted.

Example:

set certificate_file=~/.neomutt/certificates

(OpenSSL and GnuTLS only)

change_folder_next — Type: boolean · Default: no When this variable is set, the <change-folder> function mailbox suggestion will start at the next folder in your "mailboxes" list, instead of starting at the first folder in the list.
charset — Type: string · Default: "" Character set your terminal uses to display and enter textual data. It is also the fallback for $send_charset.

Upon startup NeoMutt tries to derive this value from environment variables such as $LC_CTYPE or $LANG.

Note: It should only be set in case NeoMutt isn't able to determine the character set used correctly.

check_mbox_size — Type: boolean · Default: no When this variable is set, NeoMutt will use file size attribute instead of access time when checking for new mail in mbox and mmdf folders.

This variable is unset by default and should only be enabled when new mail detection for these folder types is unreliable or doesn't work.

Note that enabling this variable should happen before any "mailboxes" directives occur in configuration files regarding mbox or mmdf folders because NeoMutt needs to determine the initial new mail status of such a mailbox by performing a fast mailbox scan when it is defined. Afterwards the new mail status is tracked by file size changes.

check_new — Type: boolean · Default: yes Note: this option only affects maildir and MH style mailboxes.

When set, NeoMutt will check for new mail delivered while the mailbox is open. Especially with MH mailboxes, this operation can take quite some time since it involves scanning the directory and checking each file to see if it has already been looked at. If this variable is unset, no check for new mail is performed while the mailbox is open.

collapse_all — Type: boolean · Default: no When set, NeoMutt will collapse all threads when entering a folder.
collapse_flagged — Type: boolean · Default: yes When unset, NeoMutt will not collapse a thread if it contains any flagged messages.
collapse_unread — Type: boolean · Default: yes When unset, NeoMutt will not collapse a thread if it contains any unread messages.
color_directcolor — Type: boolean · Default: no When set, NeoMutt will use and allow 24bit colours (aka truecolor aka directcolor). For colours to work properly support from the terminal is required as well as a properly set TERM environment variable advertising the terminals directcolor capability, e.g. "TERM=xterm-direct".

NeoMutt tries to detect whether the terminal supports 24bit colours and enables this variable if it does. If this fails for some reason, you can force 24bit colours by setting this variable manually. You may also try to force a certain TERM environment variable by starting NeoMutt from a terminal as follows (this results in wrong colours if the terminal does not implement directcolors):

TERM=xterm-direct neomutt

Note: This variable must be set before using any color commands.

compose_confirm_detach_first — Type: boolean · Default: yes When set, NeoMutt will prompt for confirmation when trying to use <detach-file> on the first entry in the compose menu. This is to help prevent irreversible loss of the typed message by accidentally hitting 'D' in the menu.

Note: NeoMutt only prompts for the first entry. It doesn't keep track of which message is the typed message if the entries are reordered, or if the first entry was already deleted.

compose_format — Type: string · Default: "-- NeoMutt: Compose [Approx. msg size: %l Atts: %a]%>-" Controls the format of the status line displayed in the "compose" menu. This string is similar to $status_format, but has its own set of printf(3)-like sequences:

%a     Total number of attachments
%h     Local hostname
%l     Approximate size (in bytes) of the current message (see
       formatstrings-size)
%v     NeoMutt version string
%>X    right justify the rest of the string and pad with
       character "X"
%|X    pad to the end of the line with character "X"
%*X    soft-fill with character "X" as pad

See the text describing the $status_format option for more information on how to set $compose_format.

compose_show_user_headers — Type: boolean · Default: yes When set, Neomutt will display user-defined headers (set via my_hdr or from editing with edit-headers).
config_charset — Type: string · Default: "" When defined, NeoMutt will recode commands in rc files from this encoding to the current character set as specified by $charset and aliases written to $alias_file from the current character set.

Please note that if setting $charset it must be done before setting $config_charset.

Recoding should be avoided as it may render unconvertible characters as question marks which can lead to undesired side effects (for example in regular expressions).

confirm_append — Type: boolean · Default: yes When set, NeoMutt will prompt for confirmation when appending messages to an existing mailbox.
confirm_create — Type: boolean · Default: yes When set, NeoMutt will prompt for confirmation when saving messages to a mailbox which does not yet exist before creating it.
content_type — Type: string · Default: "text/plain" Sets the default Content-Type for the body of newly composed messages.
copy — Type: quadoption · Default: yes This variable controls whether or not copies of your outgoing messages will be saved for later references. Also see $record, $save_name, $force_name and "fcc-hook".
copy_decode_weed — Type: boolean · Default: no Controls whether NeoMutt will weed headers when invoking the <decode-copy> or <decode-save> functions.
count_alternatives — Type: boolean · Default: no When set, NeoMutt will recurse inside multipart/alternatives while performing attachment searching and counting (see attachments).

Traditionally, multipart/alternative parts have simply represented different encodings of the main content of the email. Unfortunately, some mail clients have started to place email attachments inside one of alternatives. Setting this will allow NeoMutt to find and count matching attachments hidden there, and include them in the index via %X or through ~X pattern matching.

crypt_auto_encrypt — Type: boolean · Default: no Setting this variable will cause NeoMutt to always attempt to PGP encrypt outgoing messages. This is probably only useful in connection to the "send-hook" command. It can be overridden by use of the pgp menu, when encryption is not required or signing is requested as well. If $smime_is_default is set, then OpenSSL is used instead to create S/MIME messages and settings can be overridden by use of the smime menu instead. (Crypto only)
crypt_auto_pgp — Type: boolean · Default: yes

This one's the master switch for whether NeoMutt is even allowed to just go ahead and turn on PGP encryption/signing for your messages on its own. It's got a whole little squad of friends that shape the vibe — check $crypt_auto_encrypt, $crypt_reply_encrypt, $crypt_auto_sign, $crypt_reply_sign and $smime_is_default. 💅

🌸 `crypt_auto_sign`

Type: boolean
Default: no

Set this and NeoMutt will always try to cryptographically sign your outgoing mail. Lowkey eager. You can override it from the pgp menu when you don't actually want a signature, or when you want encryption too. And if $smime_is_default is set, then OpenSSL is the one making your S/MIME messages instead, and you override stuff from the smime menu rather than the pgp menu. (Crypto only) 🔐

🦋 `crypt_auto_smime`

Type: boolean
Default: yes

Your S/MIME counterpart to the PGP one — controls whether NeoMutt may automatically enable S/MIME encryption/signing for messages. Same squad of related options: $crypt_auto_encrypt, $crypt_reply_encrypt, $crypt_auto_sign, $crypt_reply_sign and $smime_is_default. 🎀

✨ `crypt_chars`

Type: character string
Default: "SPsK "

This is the glow-up for the characters used in cryptography flags. Five slots, five meanings, and yes the fifth default really is a space (mind the trailing space in "SPsK ", bestie, it's load-bearing) 🙈

1 — default S — the mail is signed, and the signature is successfully verified ✅
2 — default P — the mail is PGP encrypted 🔒
3 — default s — the mail is signed ✍️
4 — default K — the mail contains a PGP public key 🗝️
5 — default <space> — the mail has no crypto info, it's giving nothing 💀

🧚 `crypt_confirm_hook`

Type: boolean
Default: yes

Set this and you'll get a confirmation prompt for keys whenever the crypt-hook command is used. Unset it and that prompt just… doesn't happen. Which is generally considered unsafe, especially when typos are in the mix — like, one wrong character and you've hooked the wrong key, no cap. Be careful out there. 🫶

💜 `crypt_opportunistic_encrypt`

Type: boolean
Default: no

Set this and NeoMutt will automatically enable and disable encryption based on whether it can locate all the message recipients' keys. Iconic lazy-girl automation.

When this is on, NeoMutt re-checks encryption every single time the TO, CC, and BCC lists get edited. And if $edit_headers is set, it'll also do the check each time the message is edited.

While this is enabled, you can't manually enable/disable encryption — she's driving now. The pgp or smime menus do offer a selection to temporarily disable this option for the current message, though.

Oh and one thing: if $crypt_auto_encrypt or $crypt_reply_encrypt turn encryption on for a message, this option gets disabled for that message. You can manually re-enable it from the pgp or smime menus. (Crypto only) 🔥

🌈 `crypt_opportunistic_encrypt_strong_keys`

Type: boolean
Default: no

Turning this on makes $crypt_opportunistic_encrypt pickier — it'll only search for "strong keys", meaning keys with full validity according to the web-of-trust algorithm. A key with marginal or no validity will not trigger opportunistic encryption. Standards!

For S/MIME, the behavior depends on the backend:

Classic S/MIME will filter for certificates with the 't' (trusted) flag in the .index file.
The GPGME backend uses the same filters as with OpenPGP, and depends on GPGME's logic for assigning the GPGME_VALIDITY_FULL and GPGME_VALIDITY_ULTIMATE validity flag. 🌟

🎀 `crypt_protected_headers_read`

Type: boolean
Default: yes

When set, NeoMutt will display protected headers ("Memory Hole") in the pager, and will update the index and header cache with the revised headers. 📬

So what are protected headers? They're stored inside the encrypted or signed part of an email, to prevent disclosure or tampering. More deets at https://github.com/autocrypt/protected-headers — and heads up, currently NeoMutt only supports the Subject header.

Encrypted messages using protected headers often substitute the exposed Subject header with a dummy value (see $crypt_protected_headers_subject). NeoMutt will update its concept of the correct subject after the message is opened, i.e. via the <display-message> function. So if you reply to a message before opening it, NeoMutt will end up using the dummy Subject header — be sure to open such a message first, bestie, or your subject line is gonna be a lie 😭 (Crypto only)

🌸 `crypt_protected_headers_save`

Type: boolean
Default: no

When $crypt_protected_headers_read is set and a message with a protected Subject gets opened, NeoMutt will save the updated Subject into the header cache by default. That means you can search/limit based on the protected Subject header if the mailbox is re-opened, without re-opening the message every single time. Convenient!

But for mbox/mh mailbox types, or if header caching isn't set up, you'd have to re-open the message each time the mailbox was reopened before you could see or search/limit on the protected subject again. Annoying but that's the deal.

When this variable is set, NeoMutt additionally saves the protected Subject back in the clear-text message headers. Better usability, sure — but the tradeoff is reduced security. 🙈

The protected Subject header, which may have previously been encrypted, is now stored in clear-text in the message headers. Copying the message elsewhere, via NeoMutt or external tools, could expose this previously encrypted data. Please make sure you understand the consequences of this before you enable this variable. (Crypto only)

Like, fr fr, know what you're signing up for. 🫶

⭐ `crypt_protected_headers_subject`

Type: string
Default: "..."

When $crypt_protected_headers_write is set and the message is marked for encryption, whatever's in here gets substituted into the Subject field in the message headers. That's why the default is just "..." — the dummy placeholder vibe. 💀

Want no substitution at all? Unset this variable, or set it to the empty string. (Crypto only)

🦋 `crypt_protected_headers_write`

Type: boolean
Default: no

Set this and NeoMutt will generate protected headers for signed and encrypted emails. ✍️

Again: protected headers are stored inside the encrypted or signed part of an email, to prevent disclosure or tampering. More info at https://github.com/autocrypt/protected-headers

Currently NeoMutt only supports the Subject header. (Crypto only)

💖 `crypt_reply_encrypt`

Type: boolean
Default: yes

If set, automatically PGP or OpenSSL encrypt replies to messages which are encrypted. Reply to a locked message, your reply stays locked. Obsessed with the consistency. 🔒 (Crypto only)

🌈 `crypt_reply_sign`

Type: boolean
Default: no

If set, automatically PGP or OpenSSL sign replies to messages which are signed. Matching energy ✨

Note: this does not work on messages that are encrypted and signed! (Crypto only)

🧚 `crypt_reply_sign_encrypted`

Type: boolean
Default: no

If set, automatically PGP or OpenSSL sign replies to messages which are encrypted. This one makes sense in combination with $crypt_reply_encrypt, because it lets you sign all messages which are automatically encrypted. 🎀

It also works around that problem noted in $crypt_reply_sign — namely that NeoMutt isn't able to find out whether an encrypted message is also signed. Clever girl. (Crypto only)

🔥 `crypt_timestamp`

Type: boolean
Default: yes

If set, NeoMutt will include a time stamp in the lines surrounding PGP or S/MIME output, so spoofing such lines is more difficult. Anti-clownery measures, we love to see it. 👑

If you're using colors to mark these lines and relying on them, you may unset this setting. (Crypto only)

👑 `crypt_use_gpgme`

Type: boolean
Default: yes

This controls whether the GPGME-enabled crypto backends get used. If it's set and NeoMutt was built with GPGME support, the gpgme code for S/MIME and PGP will be used instead of the classic code. 🚀

Important: you need to set this option in .neomuttrc — it won't have any effect when used interactively. Put it in the config file, bestie, not the command line.

Also note: the GPGME backend does not support creating old-style inline (traditional) PGP encrypted or signed messages (see $pgp_auto_inline). Not available, not happening. 💀

🌟 `crypt_use_pka`

Type: boolean
Default: no

Controls whether NeoMutt uses PKA (see http://www.g10code.de/docs/pka-intro.de.pdf) during signature verification. Heads up: only supported by the GPGME backend. 🗝️

💜 `crypt_verify_sig`

Type: quadoption
Default: yes
If "yes" — always attempt to verify PGP or S/MIME signatures ✅
If "ask-*" — ask whether or not to verify the signature 🤔
If "no" — never attempt to verify cryptographic signatures 🚫

(Crypto only)

🎀 `date_format`

Type: string
Default: "!%a, %b %d, %Y at %I:%M:%S%p %Z"

Okay so real talk: instead of using $date_format, it's encouraged to use "%[fmt]" directly in the corresponding format strings, where "fmt" is the value of $date_format. That gives you way more fine-grained control over the different menu needs. Fancy! 💅

This variable controls the format of the date printed by the "%d" sequence in $index_format. It gets passed to the strftime(3) function to process the date — see the man page for the proper syntax.

Unless the first character in the string is a bang ("!"), the month and week day names are expanded according to the locale. If the first character is a bang, the bang gets discarded, and the month and week day names in the rest of the string are expanded in the C locale (that is, in US English). ⭐

Format strings that use this variable:

UI: $folder_format, $index_format, $mailbox_folder_format, $message_format
Composing: $attribution_intro, $forward_attribution_intro, $forward_attribution_trailer, $forward_format, $indent_string

🦋 `debug_file`

Type: path
Default: "~/.neomuttdebug"

Debug logging is controlled by the variables $debug_file and $debug_level. $debug_file specifies the root of the filename — NeoMutt will add "0" to the end. So you get .neomuttdebug0, iykyk. 📝

Each time NeoMutt is run with logging enabled, the log files are rotated. A maximum of five log files are kept, numbered 0 (most recent) to 4 (oldest). Spring cleaning for your debug logs 🌸

...and yeah, you can also flip this on straight from the command line like this:

neomutt -l mylog

`fcc_clear` 🎀

Type: boolean · Default: no

Set this and FCCs get stored unencrypted and unsigned, even when the actual message is encrypted and/or signed. It's giving "secret message, public filing cabinet" 💀

Note: $fcc_before_send forces the default (unset) behavior of this option. (PGP only!)

See also: $pgp_self_encrypt, $smime_self_encrypt

`flag_chars` 🚩

Type: character string · Default: "*!DdrONon- "

This one controls the characters used in several flags. Position by position, no cap:

1 — * — The mail is tagged.
2 — ! — The mail is flagged as important.
3 — D — The mail is marked for deletion.
4 — d — The mail has attachments marked for deletion.
5 — r — The mail has been replied to.
6 — O — The mail is Old (Unread but seen).
7 — N — The mail is New (Unread but not seen).
8 — o — The mail thread is Old (Unread but seen).
9 — n — The mail thread is New (Unread but not seen).
10 — - — The mail is read — %S expando.
11 — <space> — The mail is read — %Z expando.

`flag_safe` 🔒

Type: boolean · Default: no

If set, flagged messages can't be deleted. Protecting the girlies who got flagged, we love to see it 🫶

`folder` 📁

Type: mailbox · Default: "~/Mail"

This is the default location of your mailboxes. A + or = at the beginning of a pathname gets expanded to the value of this variable.

⚠️ Lowkey important: if you change this variable (from the default) value, make sure the assignment happens before you use + or = for any other variables, because expansion takes place when handling the mailboxes command. Order matters, bestie!

`folder_format` 🌸

Type: string · Default: "%2C %t %N %F %2l %-8.8u %-8.8g %8s %d %i"

Customize your file browser display to your personal taste — it's your aesthetic ✨ This string is similar to $index_format but has its own set of printf(3)-like sequences:

%a — Alert: 1 if user is notified of new mail
%C — Current file number
%d — Date/time folder was last modified
%D — Date/time folder was last modified using $date_format. It is encouraged to use "%[fmt]" instead, where "fmt" is the value of $date_format.
%f — Filename ("/" is appended to directory names, "@" to symbolic links and "*" to executable files)
%F — File permissions
%g — Group name (or numeric gid, if missing)
%i — Description of the folder
%l — Number of hard links
%m — * Number of messages in the mailbox
%n — * Number of unread messages in the mailbox
%N — "N" if mailbox has new mail, " " (space) otherwise
%p — Poll: 1 if Mailbox is checked for new mail
%s — Size in bytes (see formatstrings-size)
%t — "*" if the file is tagged, blank otherwise
%u — Owner name (or numeric uid, if missing)
%[fmt] — Date/time folder was last modified using an strftime(3) expression
%>X — Right justify the rest of the string and pad with character "X"
%|X — Pad to the end of the line with character "X"
%*X — Soft-fill with character "X" as pad

For an explanation of "soft-fill", see the $index_format documentation 👀

* = can be optionally printed if nonzero

Heads up: %m, %n, and %N only work for monitored mailboxes. %m requires $mail_check_stats to be set. %n requires $mail_check_stats to be set (except for IMAP mailboxes).

`followup_to` 💌

Type: boolean · Default: yes

Controls whether or not the "Mail-Followup-To:" header field gets generated when sending mail. When set, NeoMutt will generate this field when you're replying to a known mailing list, specified with the "subscribe" or "lists" commands.

This field has two purposes, and honestly both ate:

Preventing you from receiving duplicate copies of replies to messages which you send to mailing lists.
Ensuring that you do get a reply separately for any messages sent to known lists to which you are not subscribed.

The header will contain only the list's address for subscribed lists, and both the list address and your own email address for unsubscribed lists. Without this header, a group reply to your message sent to a subscribed list will be sent to both the list and your address — resulting in two copies of the same email for you 😭

`followup_to_poster` 📰

Type: quadoption · Default: ask-yes

If this variable is set and the keyword "poster" is present in the Followup-To header, the follow-up to newsgroup function is not permitted. Instead, the message will be mailed to the submitter of the message via mail. Respecting the poster's boundaries, periodt 💅

`force_name` 🫡

Type: boolean · Default: no

Similar to $save_name, except that NeoMutt will store a copy of your outgoing message by the username of the address you are sending to — even if that mailbox doesn't exist. Chaotic? Maybe. Iconic? Also maybe 🔥

Also see: the $record variable.

`forward_attachments` 📎

Type: quadoption · Default: ask-yes

When forwarding inline (i.e. $mime_forward unset or answered with "no" and $forward_decode set), attachments which cannot be decoded in a reasonable manner will be attached to the newly composed message if this quadoption is set or answered with "yes". Salvage mission, slay 🧚

`forward_attribution_intro` 🎬

Type: string · Default: "----- Forwarded message from %f -----"

This is the string that will precede a message which has been forwarded in the main body of a message (when $mime_forward is unset). For a full listing of defined printf(3)-like sequences, see the section on $index_format.

See also: $attribution_locale

`forward_attribution_trailer` 🎬

Type: string · Default: "----- End forwarded message -----"

This is the string that will follow a message which has been forwarded in the main body of a message (when $mime_forward is unset). For a full listing of defined printf(3)-like sequences, see the section on $index_format.

See also: $attribution_locale

`forward_decode` 🔤

Type: boolean · Default: yes

Controls the decoding of complex MIME messages into text/plain when forwarding a message. The message header is also RFC2047 decoded.

This variable is only used if $mime_forward is unset — otherwise $mime_forward_decode is used instead. Don't mix them up bestie.

`forward_decrypt` 🔐

Type: boolean · Default: yes

Controls the handling of encrypted messages when forwarding a message. When set, the outer layer of encryption is stripped off. This variable is only used if $mime_forward is set and $mime_forward_decode is unset.

`forward_edit` 📝

Type: quadoption · Default: yes

This quadoption controls whether or not the user is automatically placed in the editor when forwarding messages. For those who always want to forward with no modification, use a setting of "no" — just yeet it straight out 🌈

`forward_format` 💬

Type: string · Default: "[%a: %s]"

Controls the default subject when forwarding a message. It uses the same format sequences as the $index_format variable. Cute lil subject line, we're obsessed 🎀

`forward_quote` ❝

Type: boolean · Default: no

When set, forwarded messages included in the main body of the message (when $mime_forward is unset) will be quoted using $indent_string.

`forward_references` 🧵

Type: boolean · Default: no

When set, forwarded messages set the "In-Reply-To:" and "References:" headers in the same way as normal replies would. Hence the forwarded message becomes part of the original thread instead of starting a new one. Keeping the thread together — that's main character energy 👑

`from` 📮

Type: e-mail address · Default: ""

When set, this variable contains a default "from" address. It can be overridden using "my_hdr" (including from a "send-hook") and $reverse_name. This variable is ignored if $use_from is unset.

If not specified, then it may be read from the environment variable $EMAIL.

`from_chars` 🏷️

Type: character string · Default: ""

Controls the character used to prefix the %F and %L fields in the index. Position by position, bestie:

1 — Mail is written by you and has a To address, or has a known mailing list in the To address.
2 — Mail is written by you and has a Cc address, or has a known mailing list in the Cc address.
3 — Mail is written by you and has a Bcc address.
4 — All remaining cases.

If this is empty or unset (default), the traditional long "To ", "Cc " and "Bcc " prefixes are used. If set but too short to include a character for a particular case, a single space will be prepended to the field. To prevent any prefix at all from being added in a particular case, use the special value CR (aka ^M) for the corresponding character.

This slightly odd interface is necessitated by NeoMutt's handling of string variables — one can't tell a variable that is unset from one that is set to the empty string. The struggle is real 😭

`gecos_mask` 🧐

Type: regular expression · Default: "^[^,]*"

A regular expression used by NeoMutt to parse the GECOS field of a password entry when expanding the alias. The default value will return the string up to the first "," encountered.

If the GECOS field contains a string like "lastname, firstname" then you should set it to ".*". Simple as that, periodt 💅

Okay so this one is useful if you ever see this little behavior: you address an e-mail to user ID "stevef" whose full name is "Steve Franklin". If NeoMutt expands "stevef" to '"Franklin" stevef@foo.bar' then you should set the $gecos_mask to a regular expression that will match the whole name so NeoMutt will expand "Franklin" to "Franklin, Steve". slay, now the expansion actually makes sense 💅

`greeting` 💌

Type: string Default: ""

When set, this is the string that will precede every message as a greeting phrase to the recipients. yes bestie, it's giving little hello before the main character message ✨

The "Format strings" are similar to the strings used in the "C" function printf to format output (see the man page for more detail). The following sequences are defined in NeoMutt:

%n — Recipient's real name
%u — User (login) name of recipient
%v — First name of recipient

`group_index_format` 📰

Type: string Default: "%4C %M%N %5s %-45.45f %d"

This variable allows you to customize the newsgroup browser display to your personal taste. it's giving customize-your-own-adventure energy, honestly 🦋 This string is similar to "index_format", but has its own set of printf()-like sequences:

%a — Alert: 1 if user is notified of new mail
%C — Current newsgroup number
%d — Description of newsgroup (becomes from server)
%f — Newsgroup name
%M — - if newsgroup not allowed for direct post (moderated for example)
%N — N if newsgroup is new, u if unsubscribed, blank otherwise
%n — Number of new articles in newsgroup
%p — Poll: 1 if Mailbox is checked for new mail
%s — Number of unread articles in newsgroup
%>X — Right justify the rest of the string and pad with character "X"
%|X — Pad to the end of the line with character "X"
%*X — Soft-fill with character "X" as pad

`hdrs`

Type: boolean Default: yes

When unset, the header fields normally added by the "my_hdr" command are not created. This variable must be unset before composing a new message or replying in order to take effect. If set, the user defined header fields are added to every new message. timing matters, bestie — this one's a little diva about when it takes effect 💅

`header`

Type: boolean Default: no

When set, this variable causes NeoMutt to include the header of the message you are replying to into the edit buffer. The $weed setting applies. quote the original, but make it fashion ✨

`header_cache`

Type: path Default: ""

This variable points to the header cache database. If the path points to an existing directory, NeoMutt will create a dedicated header cache database per folder. Otherwise, the path points to a regular file, which will be created as needed and used as a shared global header cache for all folders. By default it is unset so no header caching will be used.

Header caching can greatly improve speed when opening POP, IMAP MH or Maildir folders, see "caching" in the NeoMutt Guide for details. it's giving speed boost, no cap 🚀

`header_cache_backend`

Type: string Default: ""

This variable specifies the header cache backend. If no backend is specified, the first available backend will be used in the following order: tokyocabinet, kyotocabinet, qdbm, rocksdb, gdbm, bdb, tdb, lmdb. the way it just goes down the list until something says yes 😭

`header_cache_compress_level`

Type: number Default: 1

When NeoMutt is compiled with lz4, zstd or zlib, this option can be used to setup the compression level. squish it, but like, responsibly 🎀

`header_cache_compress_method`

Type: string Default: ""

When NeoMutt is compiled with lz4, zstd or zlib, the header cache backend can use these compression methods for compressing the cache files. This results in much smaller cache file sizes and may even improve speed. smaller files AND maybe faster? obsessed 💖

`header_color_partial`

Type: boolean Default: no

When set, color header regexes behave like color body regexes: color is applied to the exact text matched by the regex. When unset, color is applied to the entire header.

One use of this option might be to apply color to just the header labels.

See "color" for more details. precise coloring is such main character energy 🌸

`help`

Type: boolean Default: yes

When set, help lines describing the bindings for the major functions provided by each menu are displayed on the first line of the screen. little baby tutorial line, we love to see it 🫶

Note: The binding will not be displayed correctly if the function is bound to a sequence rather than a single keystroke. Also, the help line may not be updated if a binding is changed while NeoMutt is running. Since this variable is primarily aimed at new users, neither of these should present a major problem.

`hidden_host`

Type: boolean Default: no

When set, NeoMutt will skip the host name part of $hostname variable when adding the domain part to addresses. secretive little hostname moment 🕵️‍♀️

`hidden_tags`

Type: string list Default: "unread,draft,flagged,passed,replied,attachment,signed,encrypted"

This variable specifies a list of comma-separated private notmuch/imap tags which should not be printed on screen. keep those tags lowkey, bestie 🙈

`hide_limited`

Type: boolean Default: no

When set, NeoMutt will not show the presence of messages that are hidden by limiting, in the thread tree. if it's limited, we don't need the little ghost reminder 👻

`hide_missing`

Type: boolean Default: yes

When set, NeoMutt will not show the presence of missing messages in the thread tree. missing messages stay missing, periodt 💅

`hide_thread_subject`

Type: boolean Default: yes

When set, NeoMutt will not show the subject of messages in the thread tree that have the same subject as their parent or closest previously displayed sibling. no repeating the same subject twenty times, we stan a clean thread 🌈

`hide_top_limited`

Type: boolean Default: no

When set, NeoMutt will not show the presence of messages that are hidden by limiting, at the top of threads in the thread tree. Note that when $hide_limited is set, this option will have no effect. team player note: $hide_limited can totally override this vibe ⭐

`hide_top_missing`

Type: boolean Default: yes

When set, NeoMutt will not show the presence of missing messages at the top of threads in the thread tree. Note that when $hide_missing is set, this option will have no effect. same deal — $hide_missing is the main character here 💖

`history`

Type: number Default: 10

This variable controls the size (in number of strings remembered) of the string history buffer per category. The buffer is cleared each time the variable is set.

Note that strings (e.g. commands) starting with a space are never recorded in the history. This is for example useful to prevent leaking sensitive information into the history file or for one off tests.

Also note that a string is not added to the history if it exactly matches its immediate predecessor, e.g. executing the same command twice in a row results in only one copy being added to the history. To prevent duplicates over all entries use $history_remove_dups. history hygiene, bestie — it's real 🧼

`history_file`

Type: path Default: "~/.mutthistory"

The file in which NeoMutt will save its history.

Also see $save_history. your history lives here, cute 🎀

`history_format`

Type: string Default: "%s"

Controls the format of the entries of the history list. This string is similar to $index_format, but has its own set of printf(3)-like sequences:

%C — Line number
%s — History match
%>X — right justify the rest of the string and pad with character "X"
%|X — pad to the end of the line with character "X"
%*X — soft-fill with character "X" as pad

`history_remove_dups`

Type: boolean Default: no

When set, all of the string history will be scanned for duplicates when a new entry is added. Duplicate entries in the $history_file will also be removed when it is periodically compacted. declutter the timeline, we love to see it ✨

`honor_disposition`

Type: boolean Default: no

When set, NeoMutt will not display attachments with a disposition of "attachment" inline even if it could render the part to plain text. These MIME parts can only be viewed from the attachment menu.

If unset, NeoMutt will render all MIME parts it can properly transform to plain text. attachment menu only, no sneaky inline moment 😤

`honor_followup_to`

Type: quadoption Default: yes

This variable controls whether or not a Mail-Followup-To header is honored when group-replying to a message. respect the followup-to, bestie 🫶

`hostname`

Type: string Default: ""

Specifies the fully-qualified hostname of the system NeoMutt is running on containing the host's name and the DNS domain it belongs to. It is used as the domain part (after "@") for local email addresses.

If not specified in a config file, then NeoMutt will try to determine the hostname itself.

Optionally, NeoMutt can be compiled with a fixed domain name.

Also see $use_domain and $hidden_host. identity crisis? not on NeoMutt's watch 🦋

`idn_decode`

Type: boolean Default: yes

When set, NeoMutt will show you international domain names decoded. Note: You can use IDNs for addresses even if this is unset. This variable only affects decoding. (IDN only) decoding only, bestie — don't panic 🌸

`idn_encode`

Type: boolean Default: yes

When set, NeoMutt will encode international domain names using IDN. Unset this if your SMTP server can handle newer (RFC6531) UTF-8 encoded domains. (IDN only) server can do UTF-8? then unset away, iykyk 💅

`ignore_list_reply_to`

Type: boolean Default: no

Affects the behavior of the <reply> function when replying to messages from mailing lists (as defined by the "subscribe" or "lists" commands). When set, if the "Reply-To:" field is set to the same value as the "To:" field, NeoMutt assumes that the "Reply-To:" field was set by the mailing list to automate responses to the list, and will ignore this field. To direct a response to the mailing list when this option is set, use the <list-reply> function; <group-reply> will reply to both the sender and the list. mailing list drama, handled 💅

`imap_authenticators`

Type: string list Default: ""

...and it's a colon-separated list of auth methods that NeoMutt is allowed to try when logging in to an IMAP server, in the order it should try them 💅. Each method is either "login" or the right-hand side of an IMAP "AUTH=xxx" capability string, like "digest-md5", "gssapi" or "cram-md5" — this one is case-insensitive, slay. If it's unset (which is the default), NeoMutt will just try every available method, going from most-secure to least-secure. Very demure, very mindful.

Example:

set imap_authenticators="gssapi:cram-md5:login"

Note, bestie: NeoMutt will only fall back to other authentication methods if the previous ones are unavailable. If a method is available but the authentication fails, NeoMutt will not connect to the IMAP server. Like, at all. Periodt.

🌸 `imap_check_subscribed`

Type: boolean · Default: no

When you set this, NeoMutt fetches the whole set of subscribed folders from your server every time a mailbox is selected, and adds them into the set of mailboxes it polls for new mail — exactly as if you'd issued individual "mailboxes" commands yourself 🫶.

🦋 `imap_condstore`

Type: boolean · Default: no

Set this and NeoMutt uses the CONDSTORE extension (RFC7162) if the server advertises it. Ngl, NeoMutt's current implementation is pretty basic — it's only used for the initial message fetching and for flag updates.

For some IMAP servers, turning this on slightly speeds up downloading initial messages. Unfortunately Gmail is not one of those, and shows worse performance when it's enabled 😭. Your mileage may vary.

✨ `imap_deflate`

Type: boolean · Default: yes

When set, NeoMutt uses the COMPRESS=DEFLATE extension (RFC4978) if the server advertises it. In general you get good compression efficiency, which speeds up reading large mailboxes — even on fairly good connections. We love an efficient queen 💅.

🎀 `imap_delim_chars`

Type: string · Default: "/."

This holds the list of characters NeoMutt uses as folder separators for IMAP paths, when no separator is provided on the IMAP connection.

⭐ `imap_fetch_chunk_size`

Type: number (long) · Default: 0

When it's set to a value greater than 0, new headers get downloaded in groups of this many headers per request. If you have a very large mailbox, this can prevent a timeout and disconnect when opening the mailbox — because it sends a FETCH per set of this many headers instead of one single FETCH for all the new headers. Little chunks, big slay 🍓.

💜 `imap_headers`

Type: string · Default: ""

NeoMutt requests these header fields — on top of the default headers ("Date:", "From:", "Sender:", "Subject:", "To:", "Cc:", "Message-Id:", "References:", "Content-Type:", "Content-Description:", "In-Reply-To:", "Reply-To:", "Lines:", "List-Post:", "X-Label:") — from IMAP servers before it displays the index menu. You might wanna add more headers for spam detection 👀.

Note: this is a space separated list, and the items should be uppercase and not contain the colon — e.g. "X-BOGOSITY X-SPAM-STATUS" for the "X-Bogosity:" and "X-Spam-Status:" header fields.

🌈 `imap_idle`

Type: boolean · Default: no

When set, NeoMutt tries to use the IMAP IDLE extension to check for new mail in the current mailbox. Some servers (dovecot was literally the inspiration for this option) react badly to NeoMutt's implementation 😬. If your connection seems to freeze up periodically, try unsetting this one.

🔥 `imap_keep_alive`

Type: number · Default: 300

This variable sets the maximum amount of time, in seconds, that NeoMutt waits before polling open IMAP connections — so the server doesn't close them before NeoMutt is done with them. The default is well within the RFC-specified minimum amount of time (30 minutes) before a server is allowed to do that, but in practice the RFC does get violated every now and then 💀. Reduce this number if you keep getting disconnected from your IMAP server due to inactivity.

🧚 `imap_list_subscribed`

Type: boolean · Default: no

This one configures whether IMAP folder browsing looks for only subscribed folders or all folders. You can toggle it in the IMAP browser with the <toggle-subscribed> function.

💖 `imap_login`

Type: string · Default: ""

Your login name on the IMAP server. This variable defaults to the value of $imap_user.

🫶 `imap_oauth_refresh_command`

Type: command · Default: ""

The command to run to generate an OAUTH refresh token for authorizing your connection to your IMAP server. This command runs on every connection attempt that uses the OAUTHBEARER or XOAUTH2 authentication mechanisms. See "oauth" for details ✨.

🎀 `imap_pass`

Type: string · Default: ""

Specifies the password for your IMAP account. If it's unset, NeoMutt prompts you for your password when you invoke the <imap-fetch-mail> function or when it tries to open an IMAP folder.

Warning: you should only use this option when you're on a fairly secure machine, because the superuser can read your neomuttrc even if you're the only one who can read the file 🙈. Keep that in mind, bestie.

👑 `imap_passive`

Type: boolean · Default: yes

When set, NeoMutt will not open new IMAP connections to check for new mail — it'll only check over existing IMAP connections. Super useful if you don't wanna be prompted for user/password pairs when you invoke NeoMutt, or if opening the connection is slow.

🦋 `imap_peek`

Type: boolean · Default: yes

When set, NeoMutt avoids implicitly marking your mail as read whenever you fetch a message from the server. This is generally a good thing, but it can make closing an IMAP folder somewhat slower. This option exists to appease speed freaks 🏎️.

⭐ `imap_pipeline_depth`

Type: number · Default: 15

Controls how many IMAP commands may be queued up before they get sent to the server. A deeper pipeline reduces the amount of time NeoMutt has to wait for the server, and can make IMAP servers feel so much more responsive. But not all servers correctly handle pipelined commands, so if you're having problems, you might want to try setting this variable to 0.

Note: changes to this variable have no effect on open connections.

🌸 `imap_poll_timeout`

Type: number · Default: 15

This variable sets the maximum amount of time, in seconds, that NeoMutt waits for a response when polling IMAP connections for new mail — before timing out and closing the connection. Set it to 0 to disable timing out entirely.

💜 `imap_qresync`

Type: boolean · Default: no

When set, NeoMutt uses the QRESYNC extension (RFC7162) if the server advertises it. NeoMutt's current implementation is basic — only used for initial message fetching and flag updates.

Note: this feature is currently experimental. If you experience strange behavior, like duplicate or missing messages, please file a bug report to let us know 🫶.

🌈 `imap_rfc5161`

Type: boolean · Default: yes

When set, NeoMutt uses the IMAP ENABLE extension (RFC5161) to select CAPABILITIES. Some servers (notably Coremail System IMap Server) do not properly respond to ENABLE commands, which might cause NeoMutt to hang 😭. If your connection seems to freeze at login, try unsetting this. See also https://github.com/neomutt/neomutt/issues/1689.

🍓 `imap_send_id`

Type: boolean · Default: no

When set, NeoMutt sends an IMAP ID command (RFC2971) to the server when logging in, if the server advertises it. This command provides info about the IMAP client, such as "NeoMutt" and the current version. Little intro moment, iconic 💅.

✨ `imap_server_noise`

Type: boolean · Default: yes

When set, NeoMutt displays warning messages from the IMAP server as error messages. Since these messages are often harmless, or generated because of configuration problems on the server that are totally out of the user's hands, you may wish to suppress them at some point.

🎀 `imap_user`

Type: string · Default: ""

The name of the user whose mail you intend to access on the IMAP server. This variable defaults to your user name on the local machine.

🌸 `implicit_auto_view`

Type: boolean · Default: no

If set to "yes", NeoMutt looks for a mailcap entry with the "copiousoutput" flag set for every MIME attachment it doesn't have an internal viewer defined for. If it finds such an entry, NeoMutt uses the viewer defined in that entry to convert the body part to text form 🦋.

💖 `include`

Type: quadoption · Default: ask-yes

Controls whether or not a copy of the message(s) you're replying to gets included in your reply.

🔥 `include_encrypted`

Type: boolean · Default: no

Controls whether or not NeoMutt includes separately encrypted attachment contents when replying.

This variable was added to prevent accidental exposure of encrypted contents when replying to an attacker 😨. If a previously encrypted message were attached by the attacker, they could trick an unwary recipient into decrypting it and including the message in their reply. Genuinely scary stuff — keep it off.

🧚 `include_only_first`

Type: boolean · Default: no

Controls whether or not NeoMutt includes only the first attachment of the message you're replying to.

👑 `indent_string`

Type: string · Default: "> "

Specifies the string to prepend to each line of text quoted in a message you're replying to. You are strongly encouraged not to change this value, since it tends to agitate the more fanatical netizens 😭💀.

The value of this option is ignored if $text_flowed is set, because the quoting mechanism is strictly defined for format=flowed. Rules are rules, bestie.

This option is a format string, please see the description of $index_format for supported printf(3)-style sequences.

💖 `index_format`

Type: string Default: "%4C %Z %{%b %d} %-15.15L (%<l?%4l&%4c>) %s"

Okay bestie, this is the variable that lets you customize the message index display to your personal taste. It's giving main character energy for your whole inbox view.

"Format strings" are similar to the strings used in the C function printf(3) to format output (see the man page for more details). For an explanation of the %<...> construct, see the status_format description. The following sequences are defined in NeoMutt:

%a — Address of the author
%A — Reply-to address (if present; otherwise: address of author)
%b — Filename of the original message folder (think mailbox)
%B — Same as %K
%c — Number of characters (bytes) in the body of the message (see formatstrings-size)
%C — Current message number
%cr — Number of characters (bytes) in the raw message, including the header (see formatstrings-size)
%d — Date and time of message using date_format and sender's timezone. It is encouraged to use "%{fmt}" instead, where "fmt" is the value of $date_format.
%D — Date and time of message using date_format and local timezone. It is encouraged to use "%[fmt]" instead, where "fmt" is the value of $date_format.
%e — Current message number in thread
%E — Number of messages in current thread
%f — Sender (address + real name), either From: or Return-Path:
%F — Author name, or recipient name if the message is from you
%Fp — Like %F, but plain. No contextual formatting is applied to recipient name
%g — Message tags (e.g. notmuch tags/imap flags)
%Gx — Individual message tag (e.g. notmuch tags/imap flags)
%H — Spam attribute(s) of this message
%i — Message-id of the current message
%I — Initials of author
%J — Message tags (if present, tree unfolded, and != parent's tags)
%K — The list to which the letter was sent (if any; otherwise: empty)
%l — number of lines in the unprocessed message (may not work with maildir, mh, and IMAP folders)
%L — If an address in the "To:" or "Cc:" header field matches an address Defined by the user's "subscribe" command, this displays "To <list-name>", otherwise the same as %F
%m — Total number of message in the mailbox
%M — Number of hidden messages if the thread is collapsed
%n — Author's real name (or address if missing)
%N — Message score
%O — Original save folder where NeoMutt would formerly have Stashed the message: list name or recipient name If not sent to a list
%P — Progress indicator for the built-in pager (how much of the file has been displayed)
%q — Newsgroup name (if compiled with NNTP support)
%r — Comma separated list of "To:" recipients
%R — Comma separated list of "Cc:" recipients
%s — Subject of the message
%S — Single character status of the message ("N"/"O"/"D"/"d"/"!"/"r"/"*")
%t — "To:" field (recipients)
%T — The appropriate character from the $to_chars string
%u — User (login) name of the author
%v — First name of the author, or the recipient if the message is from you
%W — Name of organization of author ("Organization:" field)
%x — "X-Comment-To:" field (if present and compiled with NNTP support)
%X — Number of MIME attachments (please see the "attachments" section for possible speed effects)
%y — "X-Label:" field, if present
%Y — "X-Label:" field, if present, and (1) not at part of a thread tree, (2) at the top of a thread, or (3) "X-Label:" is different from Preceding message's "X-Label:"
%Z — A three character set of message status flags. The first character is new/read/replied flags ("n"/"o"/"r"/"O"/"N"). The second is deleted or encryption flags ("D"/"d"/"S"/"P"/"s"/"K"). The third is either tagged/flagged ("*"/"!"), or one of the characters Listed in $to_chars.
%zc — Message crypto flags
%zs — Message status flags
%zt — Message tag flags
%@name@ — insert and evaluate format-string from the matching "index-format-hook" command
%{fmt} — the date and time of the message is converted to sender's time zone, and "fmt" is expanded by the library function strftime(3); if the first character inside the braces is a bang ("!"), the date is formatted ignoring any locale settings. Note that the sender's time zone might only be available as a numerical offset, so "%Z" behaves like "%z".
%[fmt] — the date and time of the message is converted to the local time zone, and "fmt" is expanded by the library function strftime(3); if the first character inside the brackets is a bang ("!"), the date is formatted ignoring any locale settings.
%(fmt) — the local date and time when the message was received, and "fmt" is expanded by the library function strftime(3); if the first character inside the parentheses is a bang ("!"), the date is formatted ignoring any locale settings.
%>X — right justify the rest of the string and pad with character "X"
%|X — pad to the end of the line with character "X"
%*X — soft-fill with character "X" as pad

Date format expressions can be constructed based on relative dates. Using the date formatting operators along with nested conditionals, the date format can be modified based on how old a message is. See the section on "Conditional Dates" for an explanation and examples ✨

ngl, there's a lil footnote about %l you should know: for mbox/mmdf, "%l" applies to the unprocessed message, and for maildir/mh, the value comes from the "Lines:" header field when present (the meaning is normally the same). Thus the value depends on the encodings used in the different parts of the message and has little meaning in practice. 😭

"Soft-fill" deserves some explanation: Normal right-justification will print everything to the left of the "%>", displaying padding and whatever lies to the right only if there's room. By contrast, soft-fill gives priority to the right-hand side, guaranteeing space to display it and showing padding only if there's still room. If necessary, soft-fill will eat text leftwards to make room for rightward text. iconic behaviour fr 💅

Note that these expandos are supported in "save-hook", "fcc-hook" and "fcc-save-hook", too. 🫶

🎀 `inews`

Type: command Default: ""

If set, specifies the program and arguments used to deliver news posted by NeoMutt. Otherwise, NeoMutt posts article using current connection to news server. The following printf-style sequence is understood:

%a — account url
%p — port
%P — port if specified
%s — news server name
%S — url schema
%u — username

Example:

set inews="/usr/local/bin/inews -hS"

🦋 `ispell`

Type: command Default: "ispell"

How to invoke ispell (GNU's spell-checking software). typo-correcting queen behaviour ✨

🌸 `keep_flagged`

Type: boolean Default: no

If set, read messages marked as flagged will not be moved from your spool mailbox to your $mbox mailbox or to the "mbox" specified by a mbox-hook command.

heads up bestie: $keep_flagged only has an effect if $move is set. no $move, no party 🥲

💜 `local_date_header`

Type: boolean Default: yes

If set, the date in the Date header of emails that you send will be in your local timezone. If unset a UTC date will be used instead to avoid leaking information about your current location. 🔒 privacy icon behaviour

⭐ `mail_check`

Type: number Default: 5

This variable configures how often (in seconds) NeoMutt should look for new mail. Also see the $timeout variable. five seconds is so real of it

🌈 `mail_check_recent`

Type: boolean Default: yes

When set, NeoMutt will only notify you about new mail that has been received since the last time you opened the mailbox. When unset, NeoMutt will notify you if any new mail exists in the mailbox, regardless of whether you have visited it recently.

💖 `mail_check_stats`

Type: boolean Default: no

When set, NeoMutt will periodically calculate message statistics of a mailbox while polling for new mail. It will check for unread, flagged, and total message counts. (Note: IMAP mailboxes only support unread and total counts).

Because this operation is more performance intensive, it defaults to unset, and has a separate option, $mail_check_stats_interval, to control how often to update these counts.

Message statistics can also be explicitly calculated by invoking the <check-stats> function. 🧚

🍓 `mail_check_stats_interval`

Type: number Default: 60

When $mail_check_stats is set, this variable configures how often (in seconds) NeoMutt will update message counts.

👑 `mailbox_folder_format`

Type: string Default: "%2C %<n?%6n& > %6m %i"

This variable allows you to customize the file browser display to your personal taste. It's only used to customize network mailboxes (e.g. imap). This string is identical in formatting to the one used by "$folder_format". matchy-matchy 💅

🧚 `mailcap_path`

Type: string list Default: "~/.mailcap:/usr/share/neomutt/mailcap:/etc/mailcap:/etc/mailcap:/usr/etc/mailcap:/usr/local/etc/mailcap"

This variable specifies a list of colon-separated files to consult when attempting to display MIME bodies not directly supported by NeoMutt. The default value is generated during startup: see the "mailcap" section of the manual. 🔥

lowkey notice that /etc/mailcap shows up twice in that default? yeah. it's in the original. we don't ask questions, we just copy it exactly 😭💀

$mailcap_path gets straight-up overridden by the environment variable $MAILCAPS, jsyk. And the default search path? That comes from RFC1524, no cap. 🦋

`mailcap_sanitize` 💅

Type: boolean Default: yes

If you set this, NeoMutt keeps the characters it'll allow in mailcap % expandos to a nice, well-defined safe set only. It's the safe choice bestie, but honestly we're not 100% sure it doesn't break some of the fancier MIME stuff out there. 🙈

DON'T CHANGE THIS SETTING UNLESS YOU ARE REALLY SURE WHAT YOU ARE DOING! like fr fr, that's not a vibe warning, that's a real one. 😭

`maildir_check_cur` 🎀

Type: boolean Default: no

Set it and NeoMutt polls both the new and cur directories of a maildir folder for new messages. Super handy when other programs are touching the folder too (looking at you, dovecot) and moving new messages over to cur. Heads up though: turning this on might slow down polling for new messages in big folders, because NeoMutt has to scan all the cur messages. ⭐

`maildir_field_delimiter` 🌸

Type: string Default: ":"

This is the value used as the maildir field delimiter. It's a single character, and it exists to accommodate maildir mailboxes on platforms where : isn't allowed in a filename. On those platforms the recommended alternative is ;. Neomutt supports all non-alphanumeric values except for -, ., \, /. 📌 Note: this only applies to maildir-style mailboxes — setting it does absolutely nothing to other mailbox types.

`maildir_header_cache_verify` 🔥

Type: boolean Default: yes

Checks whether Maildir-unaware programs other than NeoMutt have gone and modified maildir files while the header cache is in use. The catch? It costs you one stat(2) per message every single time the folder is opened — which can be mega slow for NFS folders. 💀

`maildir_trash` 💜

Type: boolean Default: no

Set it and messages you marked as deleted get saved with the maildir trashed flag instead of being unlinked. Note: only applies to maildir-style mailboxes — other mailbox types don't care, setting it does nothing there. 🫶

`mark_macro_prefix` ✨

Type: string Default: "'"

The prefix for macros made with mark-message. So a new macro automatically generated with <mark-message>a gets composed from this prefix plus the letter a. Cute, right? 🎀

`mark_old` 🌈

Type: boolean Default: yes

Controls whether NeoMutt marks new unread messages as old when you exit a mailbox without reading them. With it set, next time you fire up NeoMutt those messages show up with an "O" next to them in the index menu, telling you they're old. 👑

`markers` ⭐

Type: boolean Default: yes

Controls how wrapped lines display in the internal pager. Set it and a "+" marker shows up at the beginning of wrapped lines.

Also see the $smart_wrap variable.

`mask` 🦋

Type: regular expression Default: "!^\.[^.]"

A regular expression used in the file browser, optionally preceded by the not operator "!". Only files whose names match this mask get shown. The match is always case-sensitive, no exceptions. 💅

`mbox` 🍓

Type: mailbox Default: "~/mbox"

Specifies the folder that read mail from your $spool_file folder gets appended into.

Also see the $move variable.

`mbox_type` 🎀

Type: enumeration Default: mbox

The default mailbox type used when creating new folders. Can be any of "mbox", "MMDF", "MH" or "Maildir". ✨

This can also be set using the -m command-line option.

`me_too` 🙈

Type: boolean Default: no

If unset, NeoMutt removes your address (see the "alternates" command) from the list of recipients when you reply to a message. So unset = your own address gets yeeted from the reply list. 😭

`menu_context` 🌸

Type: number Default: 0

Controls how many lines of context you get when scrolling through menus. (Similar to $pager_context.) 🫶

`menu_move_off` 💜

Type: boolean Default: yes

When unset, the bottom entry of menus will never scroll up past the bottom of the screen — unless there are fewer entries than lines. When set, the bottom entry is free to move off the bottom. ✨

`menu_scroll` 🔥

Type: boolean Default: no

When set, menus scroll up or down one line when you try to move across a screen boundary. If unset, the screen gets cleared and the next or previous page of the menu is displayed instead — which is genuinely useful for slow links so you avoid a ton of redraws. ⭐

`message_cache_clean` 🧚

Type: boolean Default: no

If set, NeoMutt cleans out obsolete entries from the message cache whenever the mailbox is synchronized. You probably only wanna flip this on every once in a while, since it can be a little slow — especially for chonky folders. 💀

`message_cache_dir` 👑

Type: path Default: ""

Point this at a directory and NeoMutt caches copies of messages from your IMAP and POP servers right there. You're free to remove entries at any time, it's your cache, live your life. 💅

When you set this variable to a directory, NeoMutt only needs to fetch every remote message once, and it can do regular expression searches as fast as it does for local folders. Slay.

Also see the $message_cache_clean variable.

`message_format` 🌈

Type: string Default: "%s"

This is the string displayed in the "attachment" menu for attachments of type message/rfc822. For a full listing of the defined printf(3)-like sequences, peep the section on $index_format. 🦋

`meta_key` 🎀

Type: boolean Default: no

If set, NeoMutt is forced to interpret keystrokes with the high bit (bit 8) set as if you'd pressed the Esc key plus whatever key remains after the high bit has been removed. So like, if the key you pressed has an ASCII value of 0xf8, it's treated as if you pressed Esc then "x" — because removing the high bit from 0xf8 gives you 0x78, which is the ASCII character "x". Math! 🧮

`mh_purge` 💜

Type: boolean Default: no

When unset, NeoMutt mimics mh's behavior and renames deleted messages to ,<old file name> in mh folders instead of actually deleting them. So the message stays on disk but programs reading the folder just ignore it. If the variable is set, the message files get simply deleted, periodt. 🔥

This option is similar to $maildir_trash for Maildir folders.

`mh_seq_flagged` ⭐

Type: string Default: "flagged"

The name of the MH sequence used for flagged messages. 🎀

`mh_seq_replied` 🌸

Type: string Default: "replied"

The name of the MH sequence used to tag replied messages.

`mh_seq_unseen` 🦋

Type: string Default: "unseen"

The name of the MH sequence used for unseen messages.

`mime_forward` ✨

Type: quadoption Default: no

When set, the message you're forwarding gets attached as a separate message/rfc822 MIME part instead of being included in the main body of the message. Super useful for forwarding MIME messages so the receiver can properly view the message exactly as it was delivered to you. If you like switching between MIME and not-MIME from mail to mail, set this variable to "ask-no" or "ask-yes". 🫶

Also see $forward_decode and $mime_forward_decode.

`mime_forward_decode` 🔥

Type: boolean Default: no

Controls the decoding of complex MIME messages into text/plain when forwarding a message while $mime_forward is set. Otherwise $forward_decode gets used instead.

`mime_forward_rest` 🌈

Type: quadoption Default: yes

When you're forwarding multiple attachments of a MIME message from the attachment menu, attachments that can't be decoded in a reasonable manner get attached to the newly composed message — if this option is set. 👑

`mime_type_query_command` 🧚

Type: command Default: ""

This specifies a command to run to determine the mime type of a new attachment while you're composing a message. Unless $mime_type_query_first is set, it's only run if the attachment's extension isn't found in the mime.types file.

The string may contain a "%s", which gets substituted with the attachment filename. NeoMutt adds quotes around the string substituted for "%s" automatically, following shell quoting rules, so you should avoid adding your own. If no "%s" is found in the string, NeoMutt appends the attachment filename to the end of the string. 🎀

The command should output a single line containing the attachment's mime type.

Suggested values are "xdg-mime query filetype" or "file -bi". 💅

`mime_type_query_first` 🦋

Type: boolean Default: no

When set, $mime_type_query_command gets run before the mime.types lookup. ⭐

`mix_entry_format` 💜

Type: string Default: "%4n %c %-16s %a"

This variable describes the format of a remailer line on the mixmaster chain selection screen. The following printf(3)-like sequences are supported:

%a — the remailer's e-mail address
%c — remailer capabilities
%n — the running number on the menu
%s — the remailer's short name
%>X — right justify the rest of the string and pad with character "X"
%|X — pad to the end of the line with character "X"
%*X — soft-fill with character "X" as pad

(Mixmaster only) 🔥

`mixmaster` 🎀

Type: command Default: "mixmaster"

This variable contains the path to the Mixmaster binary on your system. It's used with various sets of parameters to gather the list of known remailers, and to finally send a message through the mixmaster chain. (Mixmaster only) ✨

`move` 🌸

Type: quadoption Default: no

If this variable is set, NeoMutt moves read messages from your spool mailbox to your $mbox mailbox — or to the "mbox" specified by a mbox-hook command. 🫶

`pager_read_delay`

Type: number Default: 0

The number of seconds that have to elapse after first opening a new message in the pager before that message gets marked as read. Like a lil' grace period, bestie 🫶

A value of 0 results in the message being marked read unconditionally. For any other value, if you navigate to another message or exit the pager before the timeout hits, the message stays marked unread. This setting is ignored if $pager is set. Noted. 💀

`pager_skip_quoted_context`

Type: number Default: 0

How many lines of context to show before the unquoted text when you use the <skip-quoted> function. When it's set to a positive number, at most that many lines of the previous quote get displayed. If the previous quote is shorter than that, the whole quote is displayed. No truncation drama. ✨

Heads up: the now deprecated skip_quoted_offset is an alias for this variable, and it should no longer be used. Like, it still works but it's so last season. 🙈

`pager_stop`

Type: boolean Default: no

When set, the internal-pager will not move to the next message when you're at the end of a message and you invoke the <next-page> function. It just... stops. Respects the boundary. Slay. 🛑

`pattern_format`

Type: string Default: "%2n %-15e %d"

This one describes the format of the "pattern completion" menu ✨. The following printf(3)-style sequences are understood:

%d — pattern description
%e — pattern expression
%n — index number
%>X — right justify the rest of the string and pad with character "X"
%|X — pad to the end of the line with character "X"
%*X — soft-fill with character "X" as pad

`pgp_auto_decode`

Type: boolean Default: no

If set, NeoMutt will automatically attempt to decrypt traditional PGP messages whenever you perform an operation which ordinarily would result in the contents of the message being operated on 👀.

For example: if you display a pgp-traditional message which hasn't been manually checked with the <check-traditional-pgp> function, NeoMutt will automatically check the message for traditional pgp. It's giving proactive. 🙌

`pgp_auto_inline`

Type: boolean Default: no

This option controls whether NeoMutt generates old-style inline (traditional) PGP encrypted or signed messages under certain circumstances. This can be overridden by use of the pgp menu, when inline is not required. Heads up: the GPGME backend does not support this option 💀.

Note that NeoMutt might automatically use PGP/MIME for messages which consist of more than a single MIME part. NeoMutt can be configured to ask before sending PGP/MIME messages when inline (traditional) would not work.

Also see the $pgp_mime_auto variable.

Also note that using the old-style PGP message format is strongly deprecated. Like, seriously. Don't. (PGP only)

`pgp_check_exit`

Type: boolean Default: yes

If set, NeoMutt will check the exit code of the PGP subprocess when signing or encrypting. A non-zero exit code means the subprocess failed. Simple as that, fr fr. (PGP only) 🔍

`pgp_check_gpg_decrypt_status_fd`

Type: boolean Default: yes

If set, NeoMutt will check the status file descriptor output of $pgp_decrypt_command and $pgp_decode_command for GnuPG status codes indicating successful decryption. Specifically it checks for:

the presence of DECRYPTION_OKAY ✅
the absence of DECRYPTION_FAILED ❌
that all PLAINTEXT occurs between the BEGIN_DECRYPTION and END_DECRYPTION status codes

If unset, NeoMutt will instead match the status fd output against $pgp_decryption_okay. (PGP only)

`pgp_clear_sign_command`

Type: command Default: ""

This format is used to create an old-style "clearsigned" PGP message. Note that the use of this format is strongly deprecated ⚠️.

This is a format string, see the $pgp_decode_command command for possible printf(3)-like sequences. Note that in this case, %r expands to the search string, which is a list of one or more quoted values such as email address, name, or keyid. (PGP only)

`pgp_decode_command`

Type: command Default: ""

This format string specifies a command which is used to decode application/pgp attachments 🧚.

The PGP command formats have their own set of printf(3)-like sequences:

%a — The value of $pgp_sign_as if set, otherwise the value of $pgp_default_key
%f — Expands to the name of a file containing a message
%p — Expands to PGPPASSFD=0 when a pass phrase is needed, to an empty string otherwise. Note: this may be used with a %<...> construct
%r — One or more key IDs (or fingerprints if available)
%s — Expands to the name of a file containing the signature part of a multipart/signed attachment when verifying it

(PGP only) 🔐

`pgp_decrypt_command`

Type: command Default: ""

This command is used to decrypt a PGP encrypted message 🔓.

This is a format string, see the $pgp_decode_command command for possible printf(3)-like sequences. (PGP only)

Note: when decrypting messages using gpg, a pinentry program needs to be invoked unless the password is cached within gpg-agent. Currently, the pinentry-tty program (usually distributed with gpg) isn't suitable for being invoked by NeoMutt. You are encouraged to use a different pinentry-program when running NeoMutt in order to avoid problems 😭.

`pgp_decryption_okay`

Type: regular expression Default: ""

If you assign text to this variable, then an encrypted PGP message is only considered successfully decrypted if the output from $pgp_decrypt_command contains the text 🕵️.

Why would you want this? It's used to protect against a spoofed encrypted message — one with multipart/encrypted headers but containing a block that isn't actually encrypted (e.g. simply signed and ascii armored text). Rude. Not today. 💅

Note that if $pgp_check_gpg_decrypt_status_fd is set, this variable is ignored. (PGP only)

`pgp_default_key`

Type: string Default: ""

This is the default key-pair to use for PGP operations 🔑. It'll be used for encryption (see $postpone_encrypt and $pgp_self_encrypt).

It will also be used for signing unless $pgp_sign_as is set.

The (now deprecated) pgp_self_encrypt_as is an alias for this variable, and should no longer be used. (PGP only)

`pgp_encrypt_only_command`

Type: command Default: ""

This command is used to encrypt a body part without signing it 🔒.

`pgp_encrypt_sign_command`

Type: command Default: ""

This command is used to both sign and encrypt a body part ✍️🔒. Two jobs, one command, main character energy.

This is a format string, see the $pgp_decode_command command for possible printf(3)-like sequences. (PGP only)

`pgp_entry_format`

Type: string Default: "%4n %t%f %4l/0x%k %-4a %2c %u"

This variable lets you customize the PGP key selection menu to your personal taste 🎀. If $crypt_use_gpgme is set, then it applies to the S/MIME key selection menu too. The string is similar to $index_format, but it has its own set of printf(3)-like sequences:

%a — Algorithm
%c — Capabilities
%f — Flags
%i — Key fingerprint (or long key id if non-existent)
%k — Key id
%l — Key length
%n — Number
%p — Protocol
%t — Trust/validity of the key-uid association
%u — User id
%[<s>] — Date of the key where <s> is an strftime(3) expression
%>X — Right justify the rest of the string and pad with character "X"
%|X — Pad to the end of the line with character "X"
%*X — Soft-fill with character "X" as pad

See the section "Sending Cryptographically Signed/Encrypted Messages" of the user manual for the meaning of the letters some of these sequences expand to 📖.

(Crypto only) or (PGP only when GPGME disabled)

`pgp_export_command`

Type: command Default: ""

This command is used to export a public key from the user's key ring 📤.

This is a format string, see the $pgp_decode_command command for possible printf(3)-like sequences. (PGP only)

`pgp_get_keys_command`

Type: command Default: ""

This command gets invoked whenever NeoMutt needs to fetch the public key associated with an email address 🔎. Of the sequences supported by $pgp_decode_command, %r is the only printf(3)-like sequence used with this format.

Note that in this case, %r expands to the email address, not the public key ID — because the key ID is unknown, which is literally why NeoMutt is invoking this command in the first place 💀. (PGP only)

`pgp_good_sign`

Type: regular expression Default: ""

If you assign a text to this variable, then a PGP signature is only considered verified if the output from $pgp_verify_command contains the text ✅.

Use this variable if the exit code from the command is 0 even for bad signatures. Annoying, but here we are. (PGP only)

`pgp_ignore_subkeys`

Type: boolean Default: yes

...and that's where this part wraps up, bestie — more coming right up 🌸

Setting this variable will cause NeoMutt to ignore OpenPGP subkeys. Instead, the principal key will inherit the subkeys' capabilities. Unset this if you want to play interesting key selection games. (PGP only)

pgp_import_command — Type: command, Default: ""

This command is used to import a key from a message into the user's public key ring. 💖

This is a format string — peep the $pgp_decode_command command for the possible printf(3)-like sequences. (PGP only)

pgp_list_pubring_command — Type: command, Default: ""

This command is used to list the public key ring's contents. The output format must be analogous to the one used by:

gpg --list-keys --with-colons --with-fingerprint

Note: gpg's fixed-list-mode option should not be used. It produces a different date format which may result in NeoMutt showing incorrect key generation dates. 💀

This is a format string, see the $pgp_decode_command command for possible printf(3)-like sequences. (PGP only)

pgp_list_secring_command — Type: command, Default: ""

This command is used to list the secret key ring's contents — yes, the spicy one 🌶️. The output format must be analogous to the one used by:

gpg --list-keys --with-colons --with-fingerprint

Note: gpg's fixed-list-mode option should not be used. It produces a different date format which may result in NeoMutt showing incorrect key generation dates.

This is a format string, see the $pgp_decode_command command for possible printf(3)-like sequences. (PGP only)

pgp_long_ids — Type: boolean, Default: yes

If set, use 64 bit PGP key IDs; if unset, use the normal 32 bit key IDs. NOTE: Internally, NeoMutt has transitioned to using fingerprints (or long key IDs as a fallback). This option now only controls the display of key IDs in the key selection menu and a few other places. (PGP only)

pgp_mime_auto — Type: quadoption, Default: ask-yes

This option controls whether NeoMutt will prompt you for automatically sending a (signed/encrypted) message using PGP/MIME when inline (traditional) fails (for any reason). 🫶

Also note that using the old-style PGP message format is strongly deprecated. (PGP only)

pgp_reply_inline — Type: boolean, Default: no

Setting this variable will cause NeoMutt to always attempt to create an inline (traditional) message when replying to a message which is PGP encrypted/signed inline. This can be overridden by use of the pgp menu, when inline is not required. This option does not automatically detect if the (replied-to) message is inline; instead it relies on NeoMutt internals for previously checked/flagged messages. 😌

Also note that using the old-style PGP message format is strongly deprecated. (PGP only)

pgp_retainable_sigs — Type: boolean, Default: no

If set, signed and encrypted messages will consist of nested multipart/signed and multipart/encrypted body parts. 🪆

This is useful for applications like encrypted and signed mailing lists, where the outer layer (multipart/encrypted) can be easily removed, while the inner multipart/signed part is retained. (PGP only)

pgp_self_encrypt — Type: boolean, Default: yes

When set, PGP encrypted messages will also be encrypted using the key in $pgp_default_key. (PGP only)

pgp_show_unusable — Type: boolean, Default: yes

If set, NeoMutt will display non-usable keys on the PGP key selection menu. This includes keys which have been revoked, have expired, or have been marked as "disabled" by the user. 👀 (PGP only)

pgp_sign_as — Type: string, Default: ""

If you have a different key pair to use for signing, you should set this to the signing key. Most people will only need to set $pgp_default_key. It is recommended that you use the keyid form to specify your key (e.g. 0x00112233). (PGP only)

pgp_sign_command — Type: command, Default: ""

This command is used to create the detached PGP signature for a multipart/signed PGP/MIME body part. ✍️

This is a format string, see the $pgp_decode_command command for possible printf(3)-like sequences. (PGP only)

pgp_sort_keys — Type: sort order, Default: address

Specifies how the entries in the pgp menu are sorted. The following are legal values:

address — sort alphabetically by user id
keyid — sort alphabetically by key id
date — sort by key creation date
trust — sort by the trust of the key

If you prefer reverse order of the above values, prefix it with "reverse-". 🔄 (PGP only)

pgp_strict_enc — Type: boolean, Default: yes

If set, NeoMutt will automatically encode PGP/MIME signed messages as quoted-printable. Please note that unsetting this variable may lead to problems with non-verifyable PGP signatures, so only change this if you know what you are doing. 😬 (PGP only)

pgp_timeout — Type: number (long), Default: 300

The number of seconds after which a cached passphrase will expire if not used. ⏳ (PGP only)

pgp_use_gpg_agent — Type: boolean, Default: yes

If set, NeoMutt expects a gpg-agent(1) process will handle private key passphrase prompts. If unset, NeoMutt will prompt for the passphrase and pass it via stdin to the pgp command. 🔑

Note that as of version 2.1, GnuPG automatically spawns an agent and requires the agent be used for passphrase management. Since that version is increasingly prevalent, this variable now defaults set.

NeoMutt works with a GUI or curses pinentry program. A TTY pinentry should not be used.

If you are using an older version of GnuPG without an agent running, or another encryption program without an agent, you will need to unset this variable. (PGP only)

pgp_verify_command — Type: command, Default: ""

This command is used to verify PGP signatures. ✅

This is a format string, see the $pgp_decode_command command for possible printf(3)-like sequences. (PGP only)

pgp_verify_key_command — Type: command, Default: ""

This command is used to verify key information from the key selection menu.

This is a format string, see the $pgp_decode_command command for possible printf(3)-like sequences. (PGP only)

pipe_decode — Type: boolean, Default: no

Used in connection with the <pipe-message> function. When unset, NeoMutt will pipe the messages without any preprocessing. When set, NeoMutt will attempt to decode the messages first. 🚿

Also see $pipe_decode_weed, which controls whether headers will be weeded when this is set.

pipe_decode_weed — Type: boolean, Default: yes

For <pipe-message>, when $pipe_decode is set, this further controls whether NeoMutt will weed headers. 🌿

pipe_sep — Type: string, Default: "\n"

The separator to add between messages when piping a list of tagged messages to an external Unix command.

pipe_split — Type: boolean, Default: no

Used in connection with the <pipe-message> function following <tag-prefix>. If this variable is unset, when piping a list of tagged messages NeoMutt will concatenate the messages and will pipe them all concatenated. When set, NeoMutt will pipe the messages one by one. In both cases the messages are piped in the current sorted order, and the $pipe_sep separator is added after each message. 🧵

pop_auth_try_all — Type: boolean, Default: yes

If set, NeoMutt will try all available authentication methods. When unset, NeoMutt will only fall back to other authentication methods if the previous methods are unavailable. If a method is available but authentication fails, NeoMutt will not connect to the POP server. 💅

pop_authenticators — Type: string list, Default: ""

This is a colon-separated list of authentication methods NeoMutt may attempt to use to log in to an POP server, in the order NeoMutt should try them. Authentication methods are either "user", "apop" or any SASL mechanism, e.g. "digest-md5", "gssapi" or "cram-md5". This option is case-insensitive. If this option is unset (the default) NeoMutt will try all available methods, in order from most-secure to least-secure. 🔐

Example:

set pop_authenticators="digest-md5:apop:user"

pop_check_interval — Type: number, Default: 60

This variable configures how often (in seconds) NeoMutt should look for new mail in the currently selected mailbox if it is a POP mailbox. ⏰

pop_delete — Type: quadoption, Default: ask-no

If set, NeoMutt will delete successfully downloaded messages from the POP server when using the <fetch-mail> function. When unset, NeoMutt will download messages but also leave them on the POP server. 🙈

pop_host — Type: string, Default: ""

The name of your POP server for the <fetch-mail> function. You can also specify an alternative port, username and password, i.e.:

[pop[s]://][username[:password]@]popserver[:port]

where "[...]" denotes an optional part. 🎀

pop_last — Type: boolean, Default: no

If this variable is set, NeoMutt will try to use the "LAST" POP command for retrieving only unread messages from the POP server when using the <fetch-mail> function. 🦋

pop_oauth_refresh_command

Type: command
Default: ""

okay so this is the command NeoMutt runs to generate an OAUTH refresh token so it can authorize your connection to your POP server 💅 it gets run on every single connection attempt that uses the OAUTHBEARER authentication mechanism — every one, no skipping. See oauth for the deets ✨

pop_pass

Type: string
Default: ""

your POP account password goes here 🔑 if you leave it unset, NeoMutt will just prompt you for it when you open a POP mailbox, which honestly is the chiller move.

⚠️ warning bestie: only use this option when you're on a fairly secure machine, because the superuser can read your neomuttrc — even if you're the only one who can read the file. like, they can still get in. be careful 🫶

pop_reconnect

Type: quadoption
Default: ask-yes

controls whether NeoMutt will try to reconnect to the POP server if the connection gets lost 😭

pop_user

Type: string
Default: ""

your login name on the POP server 💖 this variable defaults to your user name on the local machine.

post_moderated

Type: quadoption
Default: ask-yes

if this is set to yes, NeoMutt will post articles to newsgroups that don't have permissions for posting (like moderated ones) 📰 note: if the news server doesn't support posting to that newsgroup, or is totally read-only, that posting just won't have any effect. it's giving "sent into the void" 💀

postpone

Type: quadoption
Default: ask-yes

controls whether or not messages get saved in the $postponed mailbox when you decide not to send immediately 🎀 if it's set to ask-yes or ask-no, you'll get prompted with Save (postpone) draft message? when you quit from the compose screen.

also see the $recall variable 👀

postpone_encrypt

Type: boolean
Default: no

when this is set, postponed messages that are marked for encryption get self-encrypted 🔐 NeoMutt will first try to encrypt using whatever's in $pgp_default_key or $smime_default_key. if those aren't set, it'll try the deprecated $postpone_encrypt_as. (Crypto only) 💅

postpone_encrypt_as

Type: string
Default: ""

this is a deprecated fall-back variable for $postpone_encrypt ⚠️ please use $pgp_default_key or $smime_default_key instead, bestie. (Crypto only) 🧚

postponed

Type: mailbox
Default: "~/postponed"

NeoMutt lets you indefinitely "postpone sending a message" that you're editing 🦋 when you choose to postpone a message, NeoMutt saves it in the mailbox specified by this variable.

also see the $postpone variable ✨

preconnect

Type: string
Default: ""

if set, this is a shell command to be executed if NeoMutt fails to establish a connection to the server 🖥️ super useful for setting up secure connections, e.g. with ssh(1). if the command returns a nonzero status, NeoMutt gives up opening the server. example:

set preconnect="ssh -f -q -L 1234:mailhost.net:143 mailhost.net \
sleep 20 < /dev/null > /dev/null"

mailbox "foo" on "mailhost.net" can now be reached as {localhost:1234}foo 🔥

note: for this example to work, you must be able to log in to the remote machine without having to enter a password. no cap.

preferred_languages

Type: string list
Default: ""

this variable specifies a list of comma-separated languages 🌈 RFC8255: user preferred languages to be searched in parts and display. example:

set preferred_languages="en,fr,de"

print

Type: quadoption
Default: ask-no

controls whether or not NeoMutt really prints messages 🖨️ it's set to ask-no by default because some people accidentally hit p way too often 😭 like, bestie, the struggle is real.

print_command

Type: command
Default: "lpr"

this specifies the command pipe that should be used to print messages 📠

print_decode

Type: boolean
Default: yes

used in connection with the <print-message> function 👑 if this option is set, the message is decoded before it's passed to the external command specified by $print_command. if this option is unset, no processing gets applied to the message when printing it. that latter setting may be useful if you're using some advanced printer filter that's able to properly format e-mail messages for printing ✨

also see $print_decode_weed, which controls whether headers will be weeded when this is set 👀

print_decode_weed

Type: boolean
Default: yes

for <print-message>, when $print_decode is set, this further controls whether NeoMutt will weed headers 🌿

print_split

Type: boolean
Default: no

used in connection with the <print-message> function 💅 if this option is set, the command specified by $print_command is executed once for each message which is to be printed. if this option is unset, the command specified by $print_command is executed only once, and all the messages are concatenated, with a form feed as the message separator 🎀

those who use the enscript(1) program's mail-printing mode will most likely want to set this option. iykyk.

prompt_after

Type: boolean
Default: yes

if you use an external $pager, setting this variable will cause NeoMutt to prompt you for a command when the pager exits rather than returning to the index menu 🦋 if unset, NeoMutt will return to the index menu when the external pager exits.

query_command

Type: command
Default: ""

this specifies the command NeoMutt will use to make external address queries 📇 the string may contain a %s, which will be substituted with the query string the user types. NeoMutt will add quotes around the string substituted for %s automatically according to shell quoting rules, so you should avoid adding your own — don't double up, bestie 🙈 if no %s is found in the string, NeoMutt will append the user's query to the end of the string. see "query" (https://neomutt.org/guide/advancedusage.html#query) for more information ✨

query_format

Type: string
Default: "%3c %t %-25.25n %-25.25a | %e"

this variable describes the format of the "query" menu 🌸 the following printf(3)-style sequences are understood:

%a — destination address
%c — current entry number
%e — * extra information
%n — destination name
%t — "*" if current entry is tagged, a space otherwise
%Y — comma-separated tags
%>X — right justify the rest of the string and pad with "X"
%|X — pad to the end of the line with "X"
%*X — soft-fill with character "X" as pad

for an explanation of "soft-fill", see the $index_format documentation 👑

= can be optionally printed if nonzero, see the $status_format documentation. 💅

quit

Type: quadoption
Default: yes

this variable controls whether quit and exit actually quit from NeoMutt 🚪 if this option is set, they do quit. if it's unset, they have no effect. and if it's set to ask-yes or ask-no, you get prompted for confirmation when you try to quit.

in order to quit from NeoMutt if this variable is unset, you must send the signal SIGINT to NeoMutt 😳 this can usually be achieved by pressing CTRL+C in the terminal. dramatic but valid.

quote_regex

Type: regular expression
Default: "^([ \t]*[|>:}#])+"

a regular expression used in the internal pager to determine quoted sections of text in the body of a message 🔍 quoted text may be filtered out using the <toggle-quoted> command, or colored according to the color quoted family of directives 🌈

higher levels of quoting may be colored differently (color quoted1, color quoted2, etc.) ✨ the quoting level is determined by removing the last character from the matched text and recursively reapplying the regular expression until it fails to produce a match. recursive queen behavior fr fr.

match detection may be overridden by the $smileys regular expression 😊

read_inc

Type: number
Default: 10

if set to a value greater than 0, NeoMutt will display which message it's currently on when reading a mailbox or when performing search actions such as search and limit 📊 the message is printed after this many messages have been read or searched (e.g., if set to 25, NeoMutt will print a message when it's at message 25, and then again when it gets to message 50). this variable is meant to indicate progress when reading or searching large mailboxes which may take some time ⏳ when set to 0, only a single message will appear before the reading the mailbox.

also see the $write_inc, $net_inc and $time_inc variables and the "tuning" section of the manual for performance considerations 💅

read_only

Type: boolean
Default: no

if set, all folders are opened in read-only mode 🔒 no edits, no chaos.

real_name

Type: string
Default: ""

this variable specifies what "real" or "personal" name should be used when sending messages 💌

if not specified, then the user's "real name" will be read from /etc/passwd 📁 this option will not be used, if "$from" is set.

recall

Type: quadoption
Default: ask-yes

controls whether or not NeoMutt recalls postponed messages when composing a new message 🔁

setting this variable to yes is not generally useful, and thus not recommended ⚠️ note that the <recall-message> function can be used to manually recall postponed messages.

also see $postponed variable ✨

record

Type: mailbox
Default: "~/sent"

this specifies the file into which your outgoing messages should be appended 📤 (this is meant as the primary method for saving a copy of your messages, but another way to do this is using the my_hdr command to create a "Bcc:" field with your email address in it.) 💌

...and like, to finish what we were saying about $record 👀 — the value of $record is overridden by the $force_name and $save_name variables, and the "fcc-hook" command. Also see $copy and $write_bcc. That's it, she's done, moving on 💅

🌸 `reflow_space_quotes`

Type: boolean — Default: yes

Okay so this one controls how quotes from format=flowed messages get displayed in the pager and when you're replying (that's when $text_flowed is unset, bestie). When it's set, it adds spaces after each level of quote marks, so >>>foo turns into > > > foo ✨

Note: if $reflow_text is unset, this option literally has no effect. Also, it doesn't affect replies when $text_flowed is set. Just so you know 🫶

🦋 `reflow_text`

Type: boolean — Default: yes

When set, NeoMutt will reformat paragraphs in text/plain parts marked format=flowed. If it's unset, NeoMutt displays paragraphs unaltered, exactly how they appear in the message body. See RFC3676 for the deets on the format=flowed format 📬

Also see $reflow_wrap, and $wrap.

🎀 `reflow_wrap`

Type: number — Default: 78

This variable controls the maximum paragraph width when reformatting text/plain parts when $reflow_text is set. Here's the vibe check:

When the value is 0, paragraphs get wrapped at the terminal's right margin.
A positive value sets the paragraph width relative to the left margin.
A negative value sets the paragraph width relative to the right margin.

Be aware that the reformatted lines of a paragraph are still subject to $wrap. So like, if $reflow_wrap is 40 and $wrap is 30, then the paragraph gets reformatted to 40 characters a line (due to $reflow_wrap) and afterwards each 40-character-line is split at 30 characters (due to $wrap) — resulting in alternating line lengths of 30 and 10 characters 😭 iconic behavior honestly.

Also see $wrap.

💜 `reply_regex`

Type: regular expression — Default: "^((re|aw|sv)(\[[0-9]+\])*:[ \t]*)*"

A regular expression used to recognize reply messages when threading and replying. The default value corresponds to the standard Latin Re: prefix 👑

This value may have been localized by the translator for your locale, adding other prefixes that are common in the locale. You can add your own prefixes by appending inside "^(re)". For example: "^(re|sv)" or "^(re|aw|sv)".

The second parenthesized expression matches zero or more bracketed numbers following the prefix, such as Re[1]: . The initial "\\[" means a literal left-bracket character. Note the backslash must be doubled when used inside a double quoted string in the neomuttrc. "[0-9]+" means one or more numbers. "\\]" means a literal right-bracket. Finally the whole parenthesized expression has a "*" suffix, meaning it can occur zero or more times.

The last part matches a colon followed by an optional space or tab. Note "\t" is converted to a literal tab inside a double quoted string. If you use a single quoted string, you would have to type an actual tab character, and would need to convert the double-backslashes to single backslashes 🫠

Note: the result of this regex match against the subject is stored in the header cache. Mutt isn't smart enough to invalidate a header cache entry based on changing $reply_regex, so if you aren't seeing correct values in the index, try temporarily turning off the header cache. If that fixes the problem, then once the variable is set to your liking, remove your stale header cache files and turn the header cache back on. Slay 🔥

🌈 `reply_self`

Type: boolean — Default: no

If unset and you're replying to a message sent by you, NeoMutt will assume you want to reply to the recipients of that message rather than to yourself. (Honestly, relatable — replying to yourself is a whole vibe 🙈)

Also see the "alternates" command.

⭐ `reply_to`

Type: quadoption — Default: ask-yes

If set, when replying to a message, NeoMutt will use the address listed in the Reply-to: header as the recipient of the reply. If unset, it will use the address in the From: header field instead. This option is useful for reading a mailing list that sets the Reply-To: header field to the list address and you want to send a private message to the author of a message 💌

🧚 `reply_with_xorig`

Type: boolean — Default: no

This variable provides a toggle. When active, the From: header will be extracted from the current mail's 'X-Original-To:' header. This setting does not have precedence over "reverse_real_name" ✨

Assuming 'fast_reply' is disabled, this option will prompt the user with a prefilled From: header.

🍓 `resolve`

Type: boolean — Default: yes

When set, the cursor in a list will be automatically advanced to the next (possibly undeleted) message/attachment/entry whenever a command that modifies the current message/attachment/entry is executed.

Examples of such commands are tagging a message, deleting an entry, or saving an attachment. It's giving "keep it moving" energy fr fr 💨

👑 `resume_draft_files`

Type: boolean — Default: no

If set, draft files (specified by -H on the command line) are processed similarly to when resuming a postponed message. Recipients are not prompted for; send-hooks are not evaluated; no alias expansion takes place; user-defined headers and signatures are not added to the message. Very much a "no thoughts, head empty, just send it" mode 😌

💖 `resume_edited_draft_files`

Type: boolean — Default: yes

If set, draft files previously edited (via -E -H on the command line) will have $resume_draft_files automatically set when they are used as a draft file again 🎀

The first time a draft file is saved, NeoMutt will add a header, X-Mutt-Resume-Draft to the saved file. The next time the draft file is read in, if NeoMutt sees the header, it will set $resume_draft_files.

This option is designed to prevent multiple signatures, user-defined headers, and other processing effects from being made multiple times to the draft file. She's just protecting your draft from getting the same signature stapled on like five times 💀

🌸 `reverse_alias`

Type: boolean — Default: no

This variable controls whether or not NeoMutt will display the "personal" name from your aliases in the index menu if it finds an alias that matches the message's sender. For example, if you have the following alias:

alias juser abd30425@somewhere.net (Joe User)

and then you receive mail which contains the following header:

From: abd30425@somewhere.net

It would be displayed in the index menu as "Joe User" instead of "abd30425@somewhere.net." This is useful when the person's e-mail address is not human friendly 🫶 honestly a public service.

🦋 `reverse_name`

Type: boolean — Default: no

It may sometimes arrive that you receive mail to a certain machine, move the messages to another machine, and reply to some the messages from there. If this variable is set, the default From: line of the reply messages is built using the address where you received the messages you are replying to if that address matches your "alternates". If the variable is unset, or the address that would be used doesn't match your "alternates", the From: line will use your address on the current machine ✨

Also see the "alternates" command and $reverse_real_name.

🎀 `reverse_real_name`

Type: boolean — Default: yes

This variable fine-tunes the behavior of the $reverse_name feature 💅

When it is unset, NeoMutt will remove the real name part of a matching address. This allows the use of the email address without having to also use what the sender put in the real name field.
When it is set, NeoMutt will use the matching address as-is.

In either case, a missing real name will be filled in afterwards using the value of $real_name.

🧚 `rfc2047_parameters`

Type: boolean — Default: yes

When this variable is set, NeoMutt will decode RFC2047-encoded MIME parameters. You want to set this variable when NeoMutt suggests you to save attachments to files named like:

=?iso-8859-1?Q?file=5F=E4=5F991116=2Ezip?=
=?utf-8?Q?z=C4=99ta.png?=

(like bestie what even IS that 😭)

When this variable is set interactively, the change won't be active until you change folders. Noted 🫡

Note that this use of RFC2047's encoding is explicitly prohibited by the standard, but nevertheless encountered in the wild and produced by, e.g., Outlook. (Outlook catching strays and honestly deserved 💀)

Also note that setting this parameter will not have the effect that NeoMutt generates this kind of encoding. Instead, NeoMutt will unconditionally use the encoding specified in RFC2231.

💜 `save_address`

Type: boolean — Default: no

If set, NeoMutt will take the sender's full address when choosing a default folder for saving a mail. If $save_name or $force_name is set too, the selection of the Fcc folder will be changed as well.

🌈 `save_empty`

Type: boolean — Default: yes

When unset, mailboxes which contain no saved messages will be removed when closed (the exception is $spool_file which is never removed). If set, mailboxes are never removed. Choose your fighter, babes ✨

Note: this only applies to mbox and MMDF folders. NeoMutt does not delete MH and Maildir directories.

⭐ `save_history`

Type: number — Default: 0

This variable controls the size of the history (per category) saved in the $history_file file 📜

Setting this to a value greater than $history is possible. However, there will never be more than $history entries to select from even if more are recorded in the history file. So like, don't get too excited 👀

🍓 `save_name`

Type: boolean — Default: no

This variable controls how copies of outgoing messages are saved. When set, a check is made to see if a mailbox specified by the recipient address exists (this is done by searching for a mailbox in the $folder directory with the username part of the recipient address). If the mailbox exists, the outgoing message will be saved to that mailbox, otherwise the message is saved to the $record mailbox 🫶

Also see the $force_name variable.

`save_unsubscribed`

Type: boolean — Default: no

Set this and NeoMutt will save the deets about unsubscribed newsgroups into the "newsrc" file and into cache. Like, it remembers the ones you ghosted 💅

`score`

Type: boolean — Default: yes

Unset this bad boy and scoring is fully turned off. Super handy when you wanna selectively kill scoring for certain folders while you're out here using $score_threshold_delete and friends 🎯

`score_threshold_delete`

Type: number — Default: -1

Any message that got assigned a score equal to or lower than this value gets automatically marked for deletion by NeoMutt. And since NeoMutt scores are always greater than or equal to zero, the default setting of this variable will never mark a message for deletion. No cap, it's a no-op at -1 💀

`score_threshold_flag`

Type: number — Default: 9999

Messages with a score greater than or equal to this value get automatically marked "flagged". Star 'em and slay ⭐

`score_threshold_read`

Type: number — Default: -1

Messages with a score equal to or lower than this value get automatically marked as read by NeoMutt. Again: NeoMutt scores are always ≥ zero, so at the default -1 this thing will never mark a message read 🙈

`search_context`

Type: number — Default: 0

For the pager, this tells NeoMutt how many lines to show before your search results. By default, search results are top-aligned 👑

`send_charset`

Type: string list — Default: "us-ascii:iso-8859-1:utf-8"

A colon-delimited list of character sets for outgoing messages. NeoMutt uses the first character set that the text can be converted into exactly. So if your $charset isn't "iso-8859-1" and your recipients might not understand "UTF-8", bestie, pls include a widely used standard character set in the list (something like "iso-8859-2", "koi8-r" or "iso-2022-jp") — either instead of or after "iso-8859-1" 💖

And if the text straight-up can't be converted into one of these exactly, NeoMutt falls back to $charset. Failsafe era 🧚

`sendmail`

Type: command — Default: "/usr/sbin/sendmail -oem -oi"

Specifies the program and arguments used to deliver mail that NeoMutt sends. NeoMutt expects that the program you name will interpret additional arguments as recipient addresses. NeoMutt appends all the recipients after adding a -- delimiter (if it's not already there). Other flags — think $use_8bit_mime, $use_envelope_from, $dsn_notify, $dsn_return — get added before that delimiter.

Note: this command is invoked differently from most other commands in NeoMutt. It's tokenized by space and invoked directly via execvp(3) with an array of arguments — so commands or arguments with spaces in them are not supported. The shell is not used to run the command, so shell quoting is also not supported. Periodt 🫶

See also: $write_bcc.

`sendmail_wait`

Type: number — Default: 0

How many seconds to wait for the $sendmail process to finish before giving up and yeeting delivery into the background ⏳

NeoMutt reads the value like this:

>0 — number of seconds to wait for sendmail to finish before continuing
0 — wait forever for sendmail to finish
<0 — always put sendmail in the background, no waiting at all

Heads up: if you specify anything other than 0, the output of the child process gets dropped in a temporary file. If something goes wrong, you'll be told where to find that output 🔍

`shell`

Type: command — Default: "/bin/sh"

The command used when spawning a subshell. If it's not specified, the user's login shell from /etc/passwd is used 🐚

`show_multipart_alternative`

Type: string — Default: ""

Set it to info and the multipart/alternative information gets shown.
Set it to inline and all of the alternatives are displayed.
Leave it unset and the default behavior is to show only the chosen alternative ✨

`show_new_news`

Type: boolean — Default: yes

Set this and the news server gets asked for new newsgroups when you enter the browser. Otherwise, that only happens once per news server. It also controls whether the number of new articles in subscribed newsgroups gets checked at that time 📰

`show_only_unread`

Type: boolean — Default: no

Set it and only subscribed newsgroups containing unread articles show up in the browser. Filtered, lowkey 🦋

`sidebar_component_depth`

Type: number — Default: 0

By default the sidebar shows the mailbox's path, relative to the $folder variable. This specifies how many parent directories to hide from the sidebar display. For example: if a maildir normally shows in the sidebar as dir1/dir2/dir3/maildir, setting sidebar_component_depth=2 will display it as dir3/maildir — the 2 highest directories got truncated bestie ✂️

See also: $sidebar_short_path.

`sidebar_delim_chars`

Type: string — Default: "/."

This is the list of characters you wanna treat as folder separators when displaying paths in the sidebar.

Local mail is often arranged in directories: 'dir1/dir2/mailbox'.

set sidebar_delim_chars='/'

IMAP mailboxes are often named: 'folder1.folder2.mailbox'.

set sidebar_delim_chars='.'

See also: $sidebar_short_path, $sidebar_folder_indent, $sidebar_indent_string.

`sidebar_divider_char`

Type: string — Default: "|"

The default is a Unicode vertical line 📏

This specifies the characters drawn between the sidebar (when it's visible) and the other NeoMutt panels. ASCII and Unicode line-drawing characters are supported.

You can set the divider char to an empty string for some extra space. And if it's empty, setting the sidebar_background color may help you tell the sidebar apart from the other panels 🎨

`sidebar_folder_indent`

Type: boolean — Default: no

Set this to indent mailboxes in the sidebar. Cute lil nesting moment 🎀

See also: $sidebar_short_path, $sidebar_indent_string, $sidebar_delim_chars.

`sidebar_format`

Type: string — Default: "%D%* %n"

This lets you customize the sidebar display. It's similar to $index_format, but it's got its own set of printf(3)-like sequences:

%a — Alert: 1 if user is notified of new mail
%B — Name of the mailbox
%d — * @ Number of deleted messages in the mailbox
%D — Descriptive name of the mailbox
%F — * Number of flagged messages in the mailbox
%L — * @ Number of messages after limiting
%n — "N" if mailbox has new mail, " " (space) otherwise
%N — * Number of unread messages in the mailbox (seen or unseen)
%o — * Number of old messages in the mailbox (unread, seen)
%p — Poll: 1 if Mailbox is checked for new mail
%r — * Number of read messages in the mailbox (read, seen)
%S — * Size of mailbox (total number of messages)
%t — * @ Number of tagged messages in the mailbox
%Z — * Number of new messages in the mailbox (unread, unseen)
%! — "!" : one flagged message; "!!" : two flagged messages; "n!" : n flagged messages (for n > 2). Otherwise prints nothing.
%>X — Right justify the rest of the string and pad with "X"
%|X — Pad to the end of the line with "X"
%*X — Soft-fill with character "X" as pad

* = Can be optionally printed if nonzero

@ = Only applicable to the current folder

In order to use %S, %N, %F, and %!, $mail_check_stats must be set. When it is, a suggested value for this option is "%B%<F? [%F]>%* %<N?%N/>%S" 👑

`sidebar_indent_string`

Type: string — Default: " "

This is the string used to indent mailboxes in the sidebar. Defaults to two spaces, iconic 🫶

See also: $sidebar_short_path, $sidebar_folder_indent, $sidebar_delim_chars.

`sidebar_new_mail_only`

Type: boolean — Default: no

When set, the sidebar will only display mailboxes that contain new, or flagged, mail. Keeping it curated ✨

See also: sidebar_pin, $sidebar_non_empty_mailbox_only.

`sidebar_next_new_wrap`

Type: boolean — Default: no

When set, the <sidebar-next-new> command will not stop at the end of the list of mailboxes — it wraps around to the beginning. The <sidebar-prev-new> command is similarly affected, wrapping around to the end of the list 🔁

`sidebar_non_empty_mailbox_only`

Type: boolean — Default: no

When set, the sidebar will only display mailboxes that contain one or more mails. No empty vibes allowed 🚫

See also: $sidebar_new_mail_only, sidebar_pin.

`sidebar_on_right`

Type: boolean — Default: no

When set, the sidebar appears on the right-hand side of the screen. Main character placement, honestly ➡️👑

`sidebar_short_path`

Type: boolean — Default: no

By default the sidebar shows the mailbox's path, relative to the $folder variable. Setting sidebar_shortpath=yes will shorten the names relative to the previous name. Here's the example, bestie:

shortpath=no   shortpath=yes   shortpath=yes, folderindent=yes, indentstr=".."
fruit          fruit           fruit
fruit.apple    apple           ..apple
fruit.banana   banana          ..banana
fruit.cherry   cherry          ..cherry

See also: $sidebar_delim_chars, $sidebar_folder_indent, $sidebar_indent_string, $sidebar_component_depth.

`sidebar_sort_method`

Type: sort order — Default: order

Type: string — Default: unsorted — wait no bestie, the original doesn't list a default line here, it just tells you the sort behavior 💅

Specifies how to sort mailbox entries in the sidebar. By default, the entries are unsorted. Valid values:

path — alphabetically
count — all message count
flagged — flagged message count
unread — unread message count
unsorted — literally just vibes, no order

You may optionally use the reverse- prefix to specify reverse sorting order, like:

set sidebar_sort_method=reverse-path

The alpha and name values are synonyms for path. The new value is a synonym for unread. Slay, synonyms 🦋

Type: boolean Default: no

This specifies whether or not to show sidebar. The sidebar shows a list of all your mailboxes. It's giving "table of contents but make it cute." ✨

See also: $sidebar_format, $sidebar_width

Type: number Default: 30

This controls the width of the sidebar. It is measured in screen columns. For example: sidebar_width=20 could display 20 ASCII characters, or 10 Chinese characters. Math is mathing, no cap 💀

`sig_dashes`

Type: boolean Default: yes

If set, a line containing -- (note the trailing space, bestie, that space is load-bearing) will be inserted before your $signature. It is strongly recommended that you not unset this variable unless your signature contains just your name. The reason for this is because many software packages use -- \n to detect your signature. For example, NeoMutt has the ability to highlight the signature in a different color in the built-in pager. So like… leave it alone, it's iconic for a reason 👑

`sig_on_top`

Type: boolean Default: no

If set, the signature will be included before any quoted or forwarded text.

It is strongly recommended that you do not set this variable unless you really know what you are doing, and are prepared to take some heat from netiquette guardians. 😭 They will come for you. Do not test them.

`signature`

Type: path Default: "~/.signature"

Specifies the filename of your signature, which is appended to all outgoing messages. If the filename ends with a pipe (|), it is assumed that filename is a shell command and input should be read from its standard output. Piping it in, we love a flexible queen 🫶

`simple_search`

Type: string Default: "~f %s | ~s %s"

Specifies how NeoMutt should expand a simple search into a real search pattern. A simple search is one that does not contain any of the ~ pattern operators. See "patterns" for more information on search patterns.

simple_search applies to several functions, e.g. <delete-pattern>, <limit>, searching in the index, and all of the index colors. It's everywhere, it's booked and busy 🌈

For example, if you simply type joe at a search or limit prompt, NeoMutt will automatically expand it to the value specified by this variable by replacing %s with the supplied string. For the default value, joe would be expanded to:

~f joe | ~s joe

`size_show_bytes`

Type: boolean Default: no

If set, message sizes will display bytes for values less than 1 kilobyte. See formatstrings-size.

`size_show_fractions`

Type: boolean Default: yes

If set, message sizes will be displayed with a single decimal value for sizes from 0 to 10 kilobytes and 1 to 10 megabytes. See formatstrings-size.

`size_show_mb`

Type: boolean Default: yes

If set, message sizes will display megabytes for values greater than or equal to 1 megabyte. See formatstrings-size.

`size_units_on_left`

Type: boolean Default: no

If set, message sizes units will be displayed to the left of the number. See formatstrings-size. Left-aligned units, a bold aesthetic choice 🎀

`sleep_time`

Type: number Default: 1

Specifies time, in seconds, to pause while displaying certain informational messages, while moving from folder to folder and after expunging messages from the current folder. The default is to pause one second, so a value of zero for this option suppresses the pause. Set it to 0 if you simply cannot wait, we get it ⭐

`smart_wrap`

Type: boolean Default: yes

Controls the display of lines longer than the screen width in the internal pager. If set, long lines are wrapped at a word boundary. If unset, lines are simply wrapped at the screen edge. Also see the $markers variable. Word boundaries are the moment, fr fr 💖

`smileys`

Type: regular expression Default: "(>From )|(:[-^]?[][)(><}{|/DP])"

The pager uses this variable to catch some common false positives of $quote_regex, most notably smileys, and not consider a line quoted text if it also matches $smileys. This mostly happens at the beginning of a line. Imagine getting marked as quote just for having a face :) — not on her watch 😭

`smime_ask_cert_label`

Type: boolean Default: yes

This flag controls whether you want to be asked to enter a label for a certificate about to be added to the database or not. It is set by default. (S/MIME only) 💅

`smime_ca_location`

Type: path Default: ""

This variable contains the name of either a directory, or a file which contains trusted certificates for use with OpenSSL. (S/MIME only)

`smime_certificates`

Type: path Default: ""

Since for S/MIME there is no pubring/secring as with PGP, NeoMutt has to handle storage and retrieval of keys by itself. This is very basic right now, and keys and certificates are stored in two different directories, both named as the hash-value retrieved from OpenSSL. There is an index file which contains mailbox-address keyid pairs, and which can be manually edited. This option points to the location of the certificates. (S/MIME only) 🗂️

`smime_decrypt_command`

Type: command Default: ""

This format string specifies a command which is used to decrypt application/pkcs7-mime attachments.

The OpenSSL command formats have their own set of printf(3)-like sequences similar to PGP's:

%a — The algorithm used for encryption.
%c — One or more certificate IDs.
%C — CA location: Depending on whether $smime_ca_location points to a directory or file, this expands to -CApath $smime_ca_location or -CAfile $smime_ca_location.
%d — The message digest algorithm specified with $smime_sign_digest_alg.
%f — Expands to the name of a file containing a message.
%i — Intermediate certificates
%k — The key-pair specified with $smime_default_key
%s — Expands to the name of a file containing the signature part of a multipart/signed attachment when verifying it.

For examples on how to configure these formats, see the smime.rc in the samples/ subdirectory which has been installed on your system alongside the documentation. (S/MIME only) 🧚

`smime_decrypt_use_default_key`

Type: boolean Default: yes

If set (default) this tells NeoMutt to use the default key for decryption. Otherwise, if managing multiple certificate-key-pairs, NeoMutt will try to use the mailbox-address to determine the key to use. It will ask you to supply a key, if it can't find one. (S/MIME only) 🔑

`smime_default_key`

Type: string Default: ""

This is the default key-pair to use for S/MIME operations, and must be set to the keyid (the hash-value that OpenSSL generates) to work properly.

It will be used for encryption (see $postpone_encrypt and $smime_self_encrypt). If GPGME is enabled, this is the key id displayed by gpgsm.

It will be used for decryption unless $smime_decrypt_use_default_key is unset.

It will also be used for signing unless $smime_sign_as is set.

The (now deprecated) smime_self_encrypt_as is an alias for this variable, and should no longer be used. (S/MIME only) ⚠️ Deprecated means stop using it, bestie, it's not a vibe anymore.

`smime_encrypt_command`

Type: command Default: ""

This command is used to create encrypted S/MIME messages.

This is a format string, see the $smime_decrypt_command command for possible printf(3)-like sequences. (S/MIME only)

Encrypt the message to $smime_default_key too. (S/MIME only)

`smime_encrypt_with`

Type: string Default: "aes256"

This sets the algorithm that should be used for encryption. Valid choices are aes128, aes192, aes256, des, des3, rc2-40, rc2-64, rc2-128. (S/MIME only) AES-256 serving main character energy, as she should 👑

`smime_get_cert_command`

Type: command Default: ""

This command is used to extract X509 certificates from a PKCS7 structure.

This is a format string, see the $smime_decrypt_command command for possible printf(3)-like sequences. (S/MIME only)

`smime_get_cert_email_command`

Type: command Default: ""

This command is used to extract the mail address(es) used for storing X509 certificates, and for verification purposes (to check whether the certificate was issued for the sender's mailbox).

This is a format string, see the $smime_decrypt_command command for possible printf(3)-like sequences. (S/MIME only) 📧

`smime_get_signer_cert_command`

Type: command Default: ""

This command is used to extract only the signers X509 certificate from a S/MIME signature, so that the certificate's owner may get compared to the email's From: field.

This is a format string, see the $smime_decrypt_command command for possible printf(3)-like sequences. (S/MIME only) 🕵️‍♀️

`smime_import_cert_command`

Type: command Default: ""

This command is used to import a certificate via smime_keys.

This is a format string, see the $smime_decrypt_command command for possible printf(3)-like sequences. NOTE: %c and %k will default to $smime_sign_as if set, otherwise $smime_default_key. (S/MIME only)

`smime_is_default`

Type: boolean Default: no

...and we're picking right back up mid-sentence, bestie — no new heading, we're still on the same variable from last time 💖

The default behavior of NeoMutt is to use PGP on all auto-sign/encryption operations. To override and to use OpenSSL instead this must be set. However, this has no effect while replying, since NeoMutt will automatically select the same application that was used to sign/encrypt the original message. (Note that this variable can be overridden by unsetting $crypt_auto_smime.) (S/MIME only)

`smime_keys`

Type: path
Default: ""

Okay so here's the tea: for S/MIME there's literally no pubring/secring like PGP has, so NeoMutt has to handle storage and retrieval of keys/certs all by itself 🎀 This is very basic right now, and stores keys and certificates in two different directories, both named as the hash-value retrieved from OpenSSL. There's an index file which contains a mailbox-address keyid pair, and which can be manually edited (yes, by you, with your own hands ✨).

This option points to the location of the private keys. (S/MIME only)

`smime_pk7out_command`

Type: command
Default: ""

This command is used to extract PKCS7 structures of S/MIME signatures, in order to extract the public X509 certificate(s) 👑

This is a format string, see the $smime_decrypt_command command for possible printf(3)-like sequences. (S/MIME only)

`smime_self_encrypt`

Type: boolean
Default: yes

When set, S/MIME encrypted messages will also be encrypted using the certificate in $smime_default_key. (S/MIME only) — yes, encrypting to yourself too, self-care era 💅

`smime_sign_as`

Type: string
Default: ""

If you have a separate key to use for signing, you should set this to the signing key. Most people will only need to set $smime_default_key. (S/MIME only)

`smime_sign_command`

Type: command
Default: ""

This command is used to created S/MIME signatures of type multipart/signed, which can be read by all mail clients 🦋 (yes, the original says "created", we're keeping it, character for character, no cap)

This is a format string, see the $smime_decrypt_command command for possible printf(3)-like sequences. (S/MIME only)

`smime_sign_digest_alg`

Type: string
Default: "sha256"

This sets the algorithm that should be used for the signature message digest. Valid choices are:

"md5"
"sha1"
"sha224"
"sha256"
"sha384"
"sha512"

(S/MIME only)

`smime_timeout`

Type: number
Default: 300

The number of seconds after which a cached passphrase will expire if not used. (S/MIME only) ⏳

`smime_verify_command`

Type: command
Default: ""

This command is used to verify S/MIME signatures of type multipart/signed.

This is a format string, see the $smime_decrypt_command command for possible printf(3)-like sequences. (S/MIME only)

`smime_verify_opaque_command`

Type: command
Default: ""

This command is used to verify S/MIME signatures of type application/pkcs7-mime.

This is a format string, see the $smime_decrypt_command command for possible printf(3)-like sequences. (S/MIME only)

`smtp_authenticators`

Type: string list
Default: ""

This is a colon-separated list of authentication methods NeoMutt may attempt to use to log in to an SMTP server, in the order NeoMutt should try them 🎯 Authentication methods are any SASL mechanism, e.g. "plain", "digest-md5", "gssapi" or "cram-md5". This option is case-insensitive. If it is "unset" (the default) NeoMutt will try all available methods, in order from most-secure to least-secure. Support for the "plain" mechanism is bundled; other mechanisms are provided by an external SASL library (look for '+sasl' in the output of neomutt -v).

Example:

set smtp_authenticators="digest-md5:cram-md5"

`smtp_oauth_refresh_command`

Type: command
Default: ""

The command to run to generate an OAUTH refresh token for authorizing your connection to your SMTP server. This command will be run on every connection attempt that uses the OAUTHBEARER or XOAUTH2 authentication mechanisms. See "oauth" for details. 🔑

`smtp_pass`

Type: string
Default: ""

Specifies the password for your SMTP account. If unset, NeoMutt will prompt you for your password when you first send mail via SMTP. See $smtp_url to configure NeoMutt to send mail via SMTP.

⚠️ Warning: you should only use this option when you are on a fairly secure machine, because the superuser can read your neomuttrc even if you are the only one who can read the file. Like, fr fr, everyone with root can see it 😭

`smtp_url`

Type: string
Default: ""

Defines the SMTP smarthost where sent messages should relayed for delivery. This should take the form of an SMTP URL, e.g.:

smtp[s]://[user[:pass]@]host[:port]

where "[...]" denotes an optional part. Setting this variable overrides the value of the $sendmail variable.

Also see $write_bcc. 💌

`smtp_user`

Type: string
Default: ""

The username for the SMTP server.

This variable defaults to your user name on the local machine. 🫶

`socket_timeout`

Type: number
Default: 30

Causes NeoMutt to timeout any socket connect/read/write operation (for IMAP, POP or SMTP) after this many seconds. A negative value causes NeoMutt to wait indefinitely — forever and ever, main character patience energy ⏱️

`sort`

Type: sort order
Default: date

Specifies how to sort messages in the "index" menu. Valid values are:

date
date-received
from
score
size
spam
subject
threads
to
unsorted

You may optionally use the "reverse-" prefix to specify reverse sorting order, or the "last-" prefix to sort threads based on the corresponding attribute of the last descendant rather than the thread root. If both prefixes are in use, "reverse-" must come before "last-". The "last-" prefix has no effect on a flat view.

Any ties in the primary sort are broken by $sort_aux. When $use_threads is "threads" or "reverse", $sort controls the sorting between threads, and $sort_aux controls the sorting within a thread.

The "date-sent" value is a synonym for "date". The "mailbox-order" value is a synonym for "unsorted".

The values of "threads" and "reverse-threads" are legacy options, which cause the value of $sort_aux to also control sorting between threads, and they may not be used with the "last-" prefix. The preferred way to enable a threaded view is via $use_threads. This variable can also be set via the <sort-mailbox> and <sort-reverse> functions.

Note: When $use_threads is "threads", the last thread sorts to the bottom; when it is "reversed", the last thread sorts to the top. The use of "reverse-" in $sort swaps which end the last thread will sort to. 🌀

See the "Use Threads Feature" section for further explanation and examples, https://neomutt.org/feature/use-threads

`sort_alias`

Type: sort order
Default: alias

Specifies how the entries in the "alias" menu are sorted. The following are legal values:

address (sort alphabetically by email address)
alias (sort alphabetically by alias name)
unsorted (leave in order specified in .neomuttrc)

Note: This also affects the entries of the address query menu, thus potentially overruling the order of entries as generated by $query_command. 👀

`sort_aux`

Type: sort order
Default: date

This provides a secondary sort for messages in the "index" menu, used when the $sort value is equal for two messages.

When sorting by threads, this variable controls how subthreads are sorted within a single thread (for the order between threads, see $sort). This can be set to any value that $sort can, including with the use of "reverse-" and "last-" prefixes, except for variations using "threads" (in that case, NeoMutt will just use "date"). For instance,

set sort_aux=last-date-received

would mean that if a new message is received in a thread, that subthread becomes the last one displayed (or the first, if you have "set use_threads=reverse".) When using $use_threads, it is more common to use "last-" with $sort and not with $sort_aux. ✨

See the "Use Threads Feature" section for further explanation and examples, https://neomutt.org/feature/use-threads

`sort_browser`

Type: sort order
Default: alpha

Specifies how to sort entries in the file browser. By default, the entries are sorted alphabetically. Valid values:

alpha (alphabetically)
count (all message count)
date
desc (description)
new (new message count)
size
unsorted

You may optionally use the "reverse-" prefix to specify reverse sorting order (example: "set sort_browser=reverse-date").

The "unread" value is a synonym for "new". 🗂️

`sort_re`

Type: boolean
Default: yes

This variable is only useful when sorting by threads with $strict_threads unset. In that case, it changes the heuristic neomutt uses to thread messages by subject. With $sort_re set, neomutt will only attach a message as the child of another message by subject if the subject of the child message starts with a substring matching the setting of $reply_regex. With $sort_re unset, neomutt will attach the message whether or not this is the case, as long as the non-$reply_regex parts of both messages are identical. 🧵

`spam_separator`

Type: string
Default: ","

This variable controls what happens when multiple spam headers are matched: if unset, each successive header will overwrite any previous matches value for the spam label. If set, each successive match will append to the previous, using this variable's value as a separator. 🍓

`spool_file`

Type: mailbox
Default: ""

(and that's where this part cuts off, bestie — the description is coming right up in the next chunk, don't go anywhere 💜)

spool_file — Type: path · Default: ""

Okay so if your spool mailbox lives somewhere non-default where NeoMutt just cannot find it (rude of it to hide, honestly), you tell it where with this variable. The description from named-mailboxes or virtual-mailboxes may be used for the spool_file. And if you don't specify anything? Then it goes and checks the environment variables $MAIL and $MAILDIR. Bestie, it's checking everywhere for you 🫶

ssl_ca_certificates_file — Type: path · Default: ""

This one specifies a file containing trusted CA certificates. Any server certificate signed with one of these CA certificates is automatically accepted too — no extra drama. (GnuTLS only) 💅

Example:

set ssl_ca_certificates_file=/etc/ssl/certs/ca-certificates.crt

ssl_ciphers — Type: string · Default: ""

Contains a colon-separated list of ciphers to use when using SSL. For OpenSSL, go see ciphers(1) for the syntax of the string — it's giving reference-required, no cap.

For GnuTLS, this option gets used in place of "NORMAL" at the start of the priority string. Peep gnutls_priority_init(3) for the syntax and more details. ⭐ (Note: GnuTLS version 2.1.7 or higher is required — so like, ancient versions, not invited.)

ssl_client_cert — Type: path · Default: ""

The file containing a client certificate and its associated private key. Both. Together. In one file. 🎀

ssl_force_tls — Type: boolean · Default: yes

If this variable is set, NeoMutt will require that all connections to remote servers be encrypted. Not some — all. Furthermore it'll attempt to negotiate TLS even if the server doesn't advertise the capability, since it would otherwise have to abort the connection anyway. This option supersedes $ssl_starttls. Iconic behavior honestly 👑

ssl_min_dh_prime_bits — Type: number · Default: 0

This variable specifies the minimum acceptable prime size (in bits) for use in any Diffie-Hellman key exchange. A value of 0 will use the default from the GNUTLS library. (GnuTLS only)

ssl_starttls — Type: quadoption · Default: yes

If set (the default!), NeoMutt will attempt to use STARTTLS on servers advertising the capability. When unset, NeoMutt will not attempt to use STARTTLS regardless of the server's capabilities — like, it's not even gonna try 🫥

Note that STARTTLS is subject to many kinds of attacks, including the ability of a machine-in-the-middle to suppress the advertising of support. Setting $ssl_force_tls is recommended if you rely on STARTTLS. Fr fr, please do this. 😭

ssl_use_sslv3 — Type: boolean · Default: no

If set, NeoMutt will use SSLv3 when communicating with servers that request it. But N.B. — as of 2015, SSLv3 is considered insecure, and using it is inadvisable. See https://tools.ietf.org/html/rfc7525. Like, this is the red-flag option, bestie 🚩

ssl_use_tlsv1 — Type: boolean · Default: no

If set, NeoMutt will use TLSv1.0 when communicating with servers that request it. N.B. as of 2015, TLSv1.0 is considered insecure, and using it is inadvisable. See https://tools.ietf.org/html/rfc7525. Same warning, different version 💀

ssl_use_tlsv1_1 — Type: boolean · Default: no

If set, NeoMutt will use TLSv1.1 when communicating with servers that request it. N.B. as of 2015, TLSv1.1 is considered insecure, and using it is inadvisable. See https://tools.ietf.org/html/rfc7525. The whole 2015 insecure crew, gathered together 🙈

ssl_use_tlsv1_2 — Type: boolean · Default: yes

If set, NeoMutt will use TLSv1.2 when communicating with servers that request it. Look at her, enabled by default, thriving ✨

ssl_use_tlsv1_3 — Type: boolean · Default: yes

If set, NeoMutt will use TLSv1.3 when communicating with servers that request it. The newest sibling and also default-yes. We love a modern queen 🌈

ssl_verify_dates — Type: boolean · Default: yes

If set (the default!), NeoMutt will not automatically accept a server certificate that is either not yet valid or already expired. Time is real, certificates expire, respect it. You should only unset this for particular known hosts, using the <account-hook> function — and like, only particular known hosts, okay? Not everyone. 🎀

ssl_verify_host — Type: boolean · Default: yes

If set (the default!), NeoMutt will not automatically accept a server certificate whose host name does not match the host used in your folder URL. Same energy: you should only unset this for particular known hosts, using the <account-hook> function. Don't just turn it off globally, that's not the vibe 💅

status_chars — Type: character string · Default: "-*%A"

Controls the characters used by the "%r" indicator in $status_format. Four little slots, four little jobs:

1 — - — Mailbox is unchanged
2 — * — Mailbox has been changed and needs to be resynchronized
3 — % — Mailbox is read-only, or will not be written when exiting. (You can toggle whether to write changes to a mailbox with the <toggle-write> operation, bound by default to "%")
4 — A — Folder opened in attach-message mode. (Certain operations like composing a new mail, replying, forwarding, etc. are not permitted in this mode)

status_format — Type: string · Default: "-%r-NeoMutt: %D [Msgs:%<M?%M/>%m%<n? New:%n>%<o? Old:%o>%<d? Del:%d>%<F? Flag:%F>%<t? Tag:%t>%<p? Post:%p>%<b? Inc:%b>%<l? %l>]---(%<T?%T/>%s/%S)-%>-(%P)---"

Controls the format of the status line displayed in the "index" menu. This string is similar to $index_format, but has its own set of printf(3)-like sequences. Obsessed with a customizable status line, honestly 🦋

%b — * Number of mailboxes with new mail
%d — * Number of deleted messages
%D — Description of the mailbox
%f — The full pathname of the current mailbox
%F — * Number of flagged messages
%h — Local hostname
%l — * Size (in bytes) of the current mailbox (see formatstrings-size)
%L — * Size (in bytes) of the messages shown (i.e., which match the current limit) (see formatstrings-size)
%m — * The number of messages in the mailbox
%M — * The number of messages shown (i.e., which match the current limit)
%n — * Number of new messages in the mailbox (unread, unseen)
%o — * Number of old messages in the mailbox (unread, seen)
%p — * Number of postponed messages
%P — Percentage of the way through the index
%r — Modified/read-only/won't-write/attach-message indicator, according to $status_chars
%R — * Number of read messages in the mailbox (read, seen)
%s — Current sorting mode ($sort)
%S — Current aux sorting method ($sort_aux)
%t — * Number of tagged messages in the mailbox
%T — * Current threading mode ($use_threads)
%u — * Number of unread messages in the mailbox (seen or unseen)
%v — NeoMutt version string
%V — * Currently active limit pattern, if any
%>X — Right justify the rest of the string and pad with "X"
%|X — Pad to the end of the line with "X"
%*X — Soft-fill with character "X" as pad

For an explanation of "soft-fill", see the $index_format documentation. It's a whole thing, iykyk 👀

* = can be optionally printed if nonzero

Some of the above sequences can be used to optionally print a string if their value is nonzero. For example, you may only want to see the number of flagged messages if such messages exist, since zero is not particularly meaningful. (Zero is giving nothing, honestly.) To optionally print a string based upon one of the above sequences, the following construct is used:

%<sequence_char?optional_string>

where sequence_char is a character from the table above, and optional_string is the string you would like printed if sequence_char is nonzero. optional_string may contain other sequences as well as normal text. So you can nest, go off ✨

Here is an example illustrating how to optionally print the number of new messages in a mailbox:

%<n?%n new messages>

You can also switch between two strings using the following construct:

%<sequence_char?if_string&else_string>

If the value of sequence_char is non-zero, if_string will be expanded, otherwise else_string will be expanded. A little if/else but make it aesthetic 💅

As another example, here is how to show either $sort and $sort_aux or $use_threads and $sort, based on whether threads are enabled with $use_threads:

%<T?%s/%S&%T/%s>

You can force the result of any printf(3)-like sequence to be lowercase by prefixing the sequence character with an underscore ("_") sign. For example, if you want to display the local hostname in lowercase, you would use: "%_h". Lowercase bestie hours 🎀

If you prefix the sequence character with a colon (":") character, NeoMutt will replace any dots in the expansion by underscores. This might be helpful with IMAP folders that don't like dots in folder names. Dots are, apparently, controversial. 🫠

status_on_top — Type: boolean · Default: no

Setting this variable causes the "status bar" to be displayed on the first line of the screen rather than near the bottom. Top of the class, main character energy 👑 If $help is set too, it'll be placed at the bottom. So they swap seats, basically.

strict_threads — Type: boolean · Default: no

If set, threading will only make use of the "In-Reply-To" and "References:" fields when you $sort by message threads. By default, messages with the same subject are grouped together in "pseudo threads." This may not always be desirable — like, in a personal mailbox where you might have several unrelated messages with subjects like "hi" which will get grouped together. Yeah, every "hi" in one pile, chaos 😭 See also $sort_re for a less drastic way of controlling this behavior.

suspend — Type: boolean · Default: yes

When unset, NeoMutt won't stop when the user presses the terminal's susp key, usually "^Z". This is useful if you run NeoMutt inside an xterm using a command like "xterm -e neomutt".

On startup NeoMutt tries to detect if it is the process session leader. If so, the default of suspend is "no" otherwise "yes". This default covers the above mentioned use case of "xterm -e neomutt". Smart default, no cap 🧚

text_flowed — Type: boolean · Default: no

When set, NeoMutt will generate format=flowed bodies with a content type of text/plain; format=flowed. This format is easier to handle for some mailing software, and honestly it just looks like ordinary text. To actually use the fancy features of this format, you'll need support for it in your editor, bestie 🫶.

The option only controls newly composed messages. Postponed messages, resent messages, and draft messages (via -H on the command line) will use the content-type of the source message. No take-backs, no glow-ups.

Note that $indent_string is straight-up ignored when this option is set. She said "not today" 💅.

🌸 `thorough_search`

Type: boolean Default: yes

Affects the ~b, ~B, and ~h search operations described in section "patterns". If set, the headers and body/attachments of messages to be searched are decoded before searching. If unset, messages are searched exactly as they appear in the folder (raw, unbothered, unedited 😌).

If you're searching attachments or looking for non-ASCII characters, you absolutely want to set this, because decoding also includes MIME parsing/decoding and possible character set conversions. Otherwise NeoMutt will try to match against the raw message it received (so, you know, quoted-printable encoded, or with encoded headers 🥴) which may lead to straight-up incorrect search results. Not the vibe.

⭐ `thread_received`

Type: boolean Default: no

If $strict_threads is unset, then messages may also be grouped by subject. Unlike threading by "In-Reply-To:" and "References:" header, grouping by subject does not imply a parent-child relation between two messages. They're just... standing next to each other in the group chat, iykyk.

To figure out the ancestry between messages grouped by subject, NeoMutt uses their date: only newer messages can be descendants of older ones. Chronology is the blueprint, fr fr.

When $thread_received is set, NeoMutt uses the date received rather than the date sent when comparing messages for the date.

See also $strict_threads, and $sort_re.

🎀 `tilde`

Type: boolean Default: no

When set, the internal-pager will pad blank lines to the bottom of the screen with a tilde ("~"). Yes, that little squiggle. It's giving classic vi energy and honestly? Iconic 👑.

🦋 `time_inc`

Type: number Default: 0

Along with $read_inc, $write_inc, and $net_inc, this variable controls the frequency with which progress updates are displayed. It suppresses updates less than $time_inc milliseconds apart. This can improve throughput on systems with slow terminals, or when you're running NeoMutt on a remote system 🐌➡️⚡.

Also see the "tuning" section of the manual for performance considerations.

💜 `timeout`

Type: number Default: 600

When NeoMutt is waiting for user input — either idling in menus or sitting in an interactive prompt — it would just block until input shows up 😴. Depending on the context, that would prevent certain operations from working, like checking for new mail or keeping an IMAP connection alive. Rude, honestly.

This variable controls how many seconds NeoMutt will at most wait until it aborts waiting for input, performs these operations and continues to wait for input.

A value of zero or less will cause NeoMutt to never time out. Zero chill, zero timeout, periodt.

🧚 `tmp_dir`

Type: path Default: "/tmp"

This variable lets you specify where NeoMutt will place its temporary files needed for displaying and composing messages 📁✨.

If this variable is not set, the environment variable $TMPDIR is used. Failing that, then "/tmp" is used. Fallback queen.

💖 `to_chars`

Type: character string Default: " +TCFLR"

Controls the character used to indicate mail addressed to you. The lineup, in order:

1 — <space> — The mail is not addressed to your address. Not about you, bestie 🙈
2 — + — You are the only recipient of the message. Main character energy 👑
3 — T — Your address appears in the "To:" header field, but you are not the only recipient of the message.
4 — C — Your address is specified in the "Cc:" header field, but you are not the only recipient.
5 — F — Indicates the mail that was sent by you.
6 — L — Indicates the mail was sent to a mailing-list you subscribe to.
7 — R — Your address appears in the "Reply-To:" header field but none of the above applies.

🌈 `toggle_quoted_show_levels`

Type: number Default: 0

Quoted text may be filtered out using the <toggle-quoted> command. If set to a number greater than 0, then the <toggle-quoted> command will only filter out quote levels above this number. So like, the deep-nested quote lore gets hidden but the top-level stuff stays visible 🫶.

🍓 `trash`

Type: mailbox Default: ""

If set, this variable specifies the path of the trash folder where the mails marked for deletion will be moved, instead of being irremediably purged. So dramatic. So true.

NOTE: When you delete a message in the trash folder, it is really deleted, so that you have a way to clean the trash. That's the whole point, babe — it's a trash can, not a museum 💀.

✨ `ts_enabled`

Type: boolean Default: no

Controls whether NeoMutt tries to set the terminal status line and icon name. Most terminal emulators emulate the status line in the window title, so it's lowkey just title-bar decoration 😌.

🎀 `ts_icon_format`

Type: string **Default: "M%<n?AIL&ail>"`

Controls the format of the icon title, as long as "$ts_enabled" is set. This string is identical in formatting to the one used by "$status_format". Same rules, different canvas 💅.

🔥 `ts_status_format`

Type: string Default: "NeoMutt with %<m?%m messages&no messages>%<n? [%n NEW]>"

Controls the format of the terminal status line (or window title), provided that "$ts_enabled" has been set. This string is identical in formatting to the one used by "$status_format".

💀 `tunnel`

Type: command Default: ""

Setting this variable will cause NeoMutt to open a pipe to a command instead of a raw socket. You may be able to use this to set up preauthenticated connections to your IMAP/POP3/SMTP server. Example:

set tunnel="ssh -q mailhost.net /usr/local/libexec/imapd"

Note: For this example to work you must be able to log in to the remote machine without having to enter a password. Like, no password prompt, or the whole thing just hangs there being awkward 😭.

When set, NeoMutt uses the tunnel for all remote connections. Please see "account-hook" in the manual for how to use different tunnel commands per connection.

🌸 `tunnel_is_secure`

Type: boolean Default: yes

When set, NeoMutt will assume the $tunnel connection does not need STARTTLS to be enabled. It will also allow IMAP PREAUTH server responses inside a tunnel to proceed. This is appropriate if $tunnel uses ssh or directly invokes the server locally 🫶.

When unset, NeoMutt will negotiate STARTTLS according to the ssl_starttls and ssl_force_tls variables. If ssl_force_tls is set, NeoMutt will abort connecting if an IMAP server responds with PREAUTH. This setting is appropriate if $tunnel does not provide security and could be tampered with by attackers 😬. Keep that in mind bestie, this one's not a vibe-flex, it's a security thing.

⭐ `uncollapse_jump`

Type: boolean Default: no

When set, NeoMutt will jump to the next unread message, if any, when the current thread is uncollapsed. Surprise! You're somewhere new 🦋.

🦋 `uncollapse_new`

Type: boolean Default: yes

When set, NeoMutt will automatically uncollapse any collapsed thread that receives a newly delivered message. When unset, collapsed threads will remain collapsed. The presence of the newly delivered message will still affect index sorting, though — the maths still counts it, it's just hiding 🙈.

💜 `use_8bit_mime`

Type: boolean Default: no

Warning: do not set this variable unless you are using a version of sendmail which supports the -B8BITMIME flag (such as sendmail 8.8.x) or you may not be able to send mail. That's a real "crying in the club" scenario, be careful 💀.

When set, NeoMutt will invoke $sendmail with the -B8BITMIME flag when sending 8-bit messages to enable ESMTP negotiation.

🌈 `use_domain`

Type: boolean Default: yes

When set, NeoMutt will qualify all local addresses (ones without the "@host" portion) with the value of $hostname. If unset, no addresses will be qualified. Bare addresses, raw and unfiltered ✨.

🔥 `use_envelope_from`

Type: boolean Default: no

When set, NeoMutt will set the envelope sender of the message. If $envelope_from_address is set, it will be used as the sender address. If unset, NeoMutt will attempt to derive the sender from the "From:" header. Detective mode 🔍.

Note that this information is passed to the sendmail command using the -f command line switch. Therefore setting this option is not useful if the $sendmail variable already contains -f or if the executable pointed to by $sendmail doesn't support the -f switch. No double-dipping, bestie.

🎀 `use_from`

Type: boolean Default: yes

When set, NeoMutt will generate the "From:" header field when sending messages. If unset, no "From:" header field will be generated unless you explicitly set one using the "my_hdr" command. Your mail, your rules 💅.

🍓 `use_ipv6`

Type: boolean Default: yes

When set, NeoMutt will look for IPv6 addresses of hosts it tries to contact. If this option is unset, NeoMutt will restrict itself to IPv4 addresses. Normally, the default should work — like, don't overthink it 🌸.

🧚 `use_threads`

Type: enumeration Default: unset

The style of threading used in the index. May be one of "flat" (no threading), "threads" (threaded, with subthreads below root message) or "reverse" (threaded, with subthreads above root message). For convenience, the value "yes" is a synonym for "threads", and "no" is a synonym for "flat". Slay, options.

If this variable is never set, then $sort controls whether threading is used, $sort_aux controls both the sorting of threads and subthreads, and using <sort-mailbox> to select threads affects only $sort. Once this variable is set: attempting to set $sort to a value using "threads" will warn, the value of $sort controls the sorting between threads while $sort_aux controls sorting within a thread, and <sort-mailbox> toggles $use_threads.

Example:

set use_threads=yes

See the "Use Threads Feature" section for further explanation and examples.

👑 `user_agent`

Type: boolean Default: no

When it’s set, NeoMutt will add a User-Agent: header to outgoing messages, showing which version of NeoMutt was used to compose them. 💌

`virtual_spool_file`

Type: boolean · Default: no

This command is now unnecessary. $spool_file has been extended to support mailbox descriptions as a value.

When set, NeoMutt will use the first defined virtual mailbox (see virtual-mailboxes) as a spool file.

`wait_key`

Type: boolean · Default: yes

Controls whether NeoMutt will ask you to press a key after an external command has been invoked by these functions: <shell-escape>, <pipe-message>, <pipe-entry>, <print-message>, and <print-entry> commands.

It is also used when viewing attachments with auto_view, provided that the corresponding mailcap entry has a needsterminal flag, and the external program is interactive.

When set, NeoMutt will always ask for a key. When unset, NeoMutt will wait for a key only if the external command returned a non-zero status.

`weed`

Type: boolean · Default: yes

When set, NeoMutt will weed headers when displaying, forwarding, or replying to messages.

Also see $copy_decode_weed, $pipe_decode_weed, $print_decode_weed.

`wrap`

Type: number · Default: 0

When set to a positive value, NeoMutt will wrap text at $wrap characters. When set to a negative value, NeoMutt will wrap text so that there are $wrap characters of empty space on the right side of the terminal. Setting it to zero makes NeoMutt wrap at the terminal width.

Also see $reflow_wrap.

`wrap_headers`

Type: number · Default: 78

This option specifies the number of characters to use for wrapping an outgoing message's headers. Allowed values are between 78 and 998 inclusive.

Note: This option usually shouldn't be changed. RFC5233 recommends a line length of 78 (the default), so please only change this setting when you know what you're doing. 🫣

`wrap_search`

Type: boolean · Default: yes

Controls whether searches wrap around the end.

When set, searches will wrap around the first (or last) item. When unset, incremental searches will not wrap.

`write_bcc`

Type: boolean · Default: no

Controls whether NeoMutt writes out the Bcc: header when preparing messages to be sent. Some MTAs, such as Exim and Courier, do not strip the Bcc: header; so it is advisable to leave this unset unless you have a particular need for the header to be in the sent message.

If NeoMutt is set to deliver directly via SMTP (see $smtp_url), this option does nothing: NeoMutt will never write out the Bcc: header in this case.

Note this option only affects the sending of messages. Fcc'ed copies of a message will always contain the Bcc: header if one exists.

`write_inc`

Type: number · Default: 10

When writing a mailbox, a message will be printed every $write_inc messages to indicate progress. If set to 0, only a single message will be displayed before writing a mailbox.

Also see the $read_inc, $net_inc and $time_inc variables and the "tuning" section of the manual for performance considerations.

`x_comment_to`

Type: boolean · Default: no

If set, NeoMutt will add an X-Comment-To: field (that contains the full name of the original article author) to the article that’s been followuped to a newsgroup.

For further NeoMutt information:

the full manual, /usr/share/doc/packages/neomutt/manual.{html,pdf,txt}
the home page, https://neomutt.org

💖 AUTHOR 💖

Richard Russon and friends. Use neomutt-devel@neomutt.org to contact the developers.

mwah 💋 — that’s the whole page, bestie. Source/version Unix, dated 2024-04-25, and it’s neomuttrc(5). 🫶✨

📦 where this page comes from

opensuse-leap 16.0: neomutt 20240425-bp160.1.16 · GPL-2.0-or-later
opensuse-leap 16.0: neomutt 20240425-bp160.1.16 · GPL-2.0-or-later
opensuse-leap 16.0: neomutt 20240425-bp160.1.16 · GPL-2.0-or-later
opensuse-leap 16.0: neomutt 20240425-bp160.1.16 · GPL-2.0-or-later
💖 girlified by deepseek-ai/DeepSeek-V4.1-Flash-1017 on 2026-11-04: a language model's rewrite of the original, under its terms

neomuttrc(5)

🌸 NAME 🌸

🦋 DESCRIPTION 🦋

🌈 COMMANDS 🌈

🛠️ Configuration Commands 🛠️

🪝 account-hook

🏷️ alias / unalias

🔁 alternates / unalternates

🎀 alternative_order / unalternative_order

📎 attachments / unattachments

👀 auto_view / unauto_view

⌨️ bind / unbind

🔤 charset-hook / iconv-hook

🎨 color / uncolor

message-hook ✨

mime_lookup / unmime_lookup 🦋

mono / unmono 🌈

my_hdr / unmy_hdr 🎀

open-hook / close-hook / append-hook 🗜️

push 💅

reply-hook / send-hook / send2-hook 🔥

score / unscore 🍓

set / unset / reset / toggle 🧚

setenv / unsetenv 🌸

sidebar_pin / sidebar_unpin 📌

source 📂

spam / nospam 🚫

subjectrx / unsubjectrx 🎀

🌸 PATTERNS 🌸

🎀 Pattern Modifier 🎀

🧚 Nesting and Boolean Operators 🧚

🎀 Searching by Date 🎀

🦋 Absolute Dates

🌸 Relative Dates

💖 CONFIGURATION VARIABLES 💖

🩷 abort_backspace

🩷 abort_key

🩷 abort_noattach

🩷 abort_noattach_regex

🩷 abort_nosubject

🩷 abort_unmodified

🩷 account_command

🩷 alias_file

alias_format

allow_8bit

allow_ansi

arrow_cursor

arrow_string

ascii_chars

ask_bcc

ask_cc

ask_followup_to

ask_x_comment_to

assumed_charset

attach_charset

attach_format

attach_save_dir

attach_save_without_prompting

attach_sep

attach_split

attribution_intro

attribution_locale

attribution_trailer

auto_edit

auto_subscribe

auto_tag

beep

beep_new

🌸 crypt_auto_sign

🦋 crypt_auto_smime

✨ crypt_chars

🧚 crypt_confirm_hook

💜 crypt_opportunistic_encrypt

🌈 crypt_opportunistic_encrypt_strong_keys

🎀 crypt_protected_headers_read

🌸 crypt_protected_headers_save

⭐ crypt_protected_headers_subject

🦋 crypt_protected_headers_write

💖 crypt_reply_encrypt

🌈 crypt_reply_sign

🪝 `account-hook`

🏷️ `alias` / `unalias`

🔁 `alternates` / `unalternates`

🎀 `alternative_order` / `unalternative_order`

📎 `attachments` / `unattachments`

👀 `auto_view` / `unauto_view`

⌨️ `bind` / `unbind`

🔤 `charset-hook` / `iconv-hook`

🎨 `color` / `uncolor`

`message-hook` ✨

`mime_lookup` / `unmime_lookup` 🦋

`mono` / `unmono` 🌈

`my_hdr` / `unmy_hdr` 🎀

`open-hook` / `close-hook` / `append-hook` 🗜️

`push` 💅

`reply-hook` / `send-hook` / `send2-hook` 🔥

`score` / `unscore` 🍓

`set` / `unset` / `reset` / `toggle` 🧚

`setenv` / `unsetenv` 🌸

`sidebar_pin` / `sidebar_unpin` 📌

`source` 📂

`spam` / `nospam` 🚫

`subjectrx` / `unsubjectrx` 🎀

🌸 `crypt_auto_sign`

🦋 `crypt_auto_smime`

✨ `crypt_chars`

🧚 `crypt_confirm_hook`

💜 `crypt_opportunistic_encrypt`

🌈 `crypt_opportunistic_encrypt_strong_keys`

🎀 `crypt_protected_headers_read`

🌸 `crypt_protected_headers_save`

⭐ `crypt_protected_headers_subject`

🦋 `crypt_protected_headers_write`

💖 `crypt_reply_encrypt`

🌈 `crypt_reply_sign`

🧚 `crypt_reply_sign_encrypted`

🔥 `crypt_timestamp`

👑 `crypt_use_gpgme`

🌟 `crypt_use_pka`

💜 `crypt_verify_sig`

🎀 `date_format`

🦋 `debug_file`

`fcc_clear` 🎀

`flag_chars` 🚩

`flag_safe` 🔒

`folder` 📁

`folder_format` 🌸

`followup_to` 💌

`followup_to_poster` 📰

`force_name` 🫡

`forward_attachments` 📎

`forward_attribution_intro` 🎬

`forward_attribution_trailer` 🎬

`forward_decode` 🔤

`forward_decrypt` 🔐

`forward_edit` 📝

`forward_format` 💬

`forward_quote` ❝

`forward_references` 🧵

`from` 📮

`from_chars` 🏷️

`gecos_mask` 🧐

`greeting` 💌

`group_index_format` 📰

`hdrs`

`header`

`header_cache`

`header_cache_backend`

`header_cache_compress_level`

`header_cache_compress_method`

`header_color_partial`

`help`

`hidden_host`

`hidden_tags`

`hide_limited`

`hide_missing`

`hide_thread_subject`

`hide_top_limited`

`hide_top_missing`

`history`