NeoMutt compatibility

0.2.1 stable

This matrix covers all 472 options in NeoMutt 2026-06-16 docs/config.c at commit dd0ba096. By design, each account uses one IMAP server and user, and a native Mutt Desktop sidebar replaces NeoMutt's built-in sidebar, which Mutt Desktop will not support. Mutt Desktop will not support OpenPGP, S/MIME, or Autocrypt signing, encryption, decryption, signature verification, or key management. A version beside ✓ marks first full support.

GitHub tracks bugs and feature requests. For help, email support@muttdesktop.com.

Supported 106

Supported NeoMutt options
OptionStatusDifference
abort_nosubject 0.1.0
allow_8bit 0.2.1
ask_bcc 0.2.1
ask_cc 0.2.1
browser_abbreviate_mailboxes 0.2.0
browser_sort 0.2.0
browser_sort_dirs_first 0.2.0
change_folder_next 0.2.1
check_mbox_size 0.2.1
collapse_all 0.2.1
collapse_flagged 0.2.1
collapse_unread 0.2.1
color_directcolor 0.2.1
count_alternatives 0.2.1
delete_untag 0.2.0
digest_collapse 0.2.1
fast_reply 0.2.1
fcc_attach 0.2.1
flag_safe 0.2.0
followup_to 0.2.1
forward_attribution_intro 0.2.0
forward_attribution_trailer 0.2.0
forward_edit 0.2.0
forward_format 0.2.0
forward_quote 0.2.0
from 0.1.0
from_chars 0.1.0
gecos_mask 0.2.1
hdrs 0.2.1
help 0.2.1
hidden_host 0.2.1
history_remove_dups 0.1.0
honor_disposition 0.2.1
honor_followup_to 0.1.0
imap_authenticators 0.2.1
imap_check_subscribed 0.2.1
imap_deflate 0.2.1
imap_headers 0.2.0
imap_keep_alive 0.2.1
imap_login 0.2.1
imap_oauth_refresh_command 0.2.1
imap_pipeline_depth 0.2.1
imap_poll_timeout 0.2.1
imap_send_id 0.2.1
imap_user 0.1.0
include_only_first 0.2.1
indent_string 0.2.0
local_date_header 0.2.1
mail_check_recent 0.2.1
mail_check_stats 0.2.1
mail_check_stats_interval 0.2.1
maildir_check_cur 0.2.1
maildir_field_delimiter 0.2.1
maildir_trash 0.2.0
mark_old 0.2.0
mask 0.2.1
me_too 0.2.1
message_cache_clean 0.2.0
net_inc 0.2.0
pop_auth_try_all 0.2.0
pop_authenticators 0.2.0
pop_check_interval 0.2.0
pop_delete 0.2.0
pop_last 0.2.0
pop_oauth_refresh_command 0.2.0
pop_pass 0.2.0
pop_reconnect 0.2.0
pop_user 0.2.0
postpone 0.1.0
read_only 0.1.0
real_name 0.1.0
reply_self 0.2.1
reply_to 0.1.0
resolve 0.2.1
reverse_alias 0.1.0
reverse_name 0.2.1
reverse_real_name 0.2.1
rfc2047_parameters 0.2.1
score_threshold_delete 0.2.1
score_threshold_flag 0.2.1
score_threshold_read 0.2.1
sidebar_component_depth 0.2.1
sidebar_delim_chars 0.2.1
sidebar_folder_indent 0.2.1
sidebar_indent_string 0.2.1
sidebar_new_mail_only 0.2.1
sidebar_non_empty_mailbox_only 0.2.1
sidebar_short_path 0.2.1
sidebar_sort 0.2.1
sidebar_visible 0.1.0
sig_dashes 0.1.0
sig_on_top 0.1.0
smtp_user 0.1.0
socket_timeout 0.2.1
sort_re 0.2.1
status_on_top 0.1.0
strict_threads 0.2.1
thread_received 0.2.1
uncollapse_jump 0.2.1
uncollapse_new 0.2.1
use_domain 0.2.1
use_from 0.2.1
wrap_headers 0.2.1
write_bcc 0.2.1
write_inc 0.2.0

Partial support 105

Partial support NeoMutt options
OptionStatusDifference
abort_unmodified Partial supportAlso checks edited bytes to avoid losing a draft
alias_file Partial supportUsed when creating an alias from a query result
alias_format Partial supportFormats the alias completion menu
alias_sort Partial supportSorts nested alias and query menus
attach_save_dir Partial supportRelative paths start at home
attach_save_without_prompting Partial supportDecline ends save
auto_edit Partial supportNeovim only; native review remains
auto_tag Partial supportApplies in alias, query, and browser menus
beep Partial supportOnly set-flag and clear-flag ring the bell
beep_new Partial supportMac alert sound; bell untested
certificate_file Partial supportSMTP only
confirm_append Partial supportExplicit copy and save only
confirm_create Partial supportAutomatic spool moves skip prompt
copy Partial supportSupported mailboxes only; no Fcc hooks
date_format Partial supportLocal time for %d; safe overflow
default_hook Partial supportApplied to hooks; message hooks run
delete Partial supportLocal marks drop on close if purge declined
duplicate_threads Partial supportThreaded indexes only
edit_headers Partial supportNo pseudoheaders for existing attachments
editor Partial supportRaw edits need Neovim; drafts use native fallback; safe -c
empty_subject Partial supportConfigured replacement ignored
external_search_command Partial supportRuns while compiling an alias or message ~I pattern
fcc_before_send Partial supportSupported mailboxes; no fcc_clear
flag_chars Partial supportNo thread or attachment status
folder Partial supportSupported mailbox URLs and local paths
folder_format Partial supportMailbox browser; no padding
forward_attachments Partial supportOnly parts the message lists as attachments
forward_decode Partial supportNo Bcc; LF line breaks; ISO-8859-1 fallback
forward_references Partial supportMalformed source IDs omitted
header_cache Partial supportPOP and IMAP: NeoMutt LMDB path plus .muttdesktop
header_cache_backend Partial supportPOP and IMAP; lmdb only
header_cache_compress_level Partial supportPOP and IMAP; zlib only
header_cache_compress_method Partial supportPOP and IMAP; zlib only
history Partial supportNo native review field history
history_format Partial supportFormats the editor history menu
hostname Partial supportEHLO sends [127.0.0.1], not the host name
idn_decode Partial supportDecoded with Foundation, not libidn2
idn_encode Partial supportEncoded with Foundation, not libidn2
ignore_list_reply_to Partial supportNo address groups
imap_condstore Partial supportCached keywords kept
imap_delim_chars Partial supportCompletion and URL normalization
imap_idle Partial supportMYRIGHTS reply timing differs
imap_list_subscribed Partial supportLSUB only
imap_pass Partial supportURL password until first login
imap_peek Partial supportBody fetched by part
imap_qresync Partial supportVANISHED, empty UIDSEQSET, and login fixes
imap_rfc5161 Partial supportUTF-8 names when enabled; modified UTF-7 otherwise
implicit_auto_view Partial supportAutoviews only text/html, without a command
index_format Partial supportExpando subset; pending %X dot; limits
keep_flagged Partial supportNo mbox-hook
mail_check Partial supportNo check during load or sync
mailbox_folder_format Partial supportNo padding
mailcap_path Partial supportDirect macOS open or qlmanage only
mbox Partial supportSupported backends; no mbox-hook
mbox_type Partial supportmbox and Maildir only
menu_context Partial supportIndex and mailbox browser movement only
menu_move_off Partial supportIndex and mailbox browser movement only
menu_scroll Partial supportIndex and mailbox browser movement only
message_cache_dir Partial supportIMAP viewing fills it; POP hash names
message_format Partial supportAttachment descriptions only; no attach_format
message_id_format Partial supportNo | filter
mime_forward Partial supportBcc is never forwarded; NeoMutt keeps it
mime_forward_decode Partial supportAutoview is text/html only
move Partial supportSupported backends; no mbox-hook; IMAP 4 GiB limit
new_mail_command Partial supportRuns the command at index and pager notices
pager_read_delay Partial supportPreview timer updates while idle
pattern_format Partial supportFormats the pattern completion menu
pop_host Partial supportPassword in the text is removed
postponed Partial supportSupported backends; fixed list layout
query_command Partial supportRuns from editor complete-query
query_format Partial supportFormats the nested query menu
quit Partial supportCmd-Q skips prompt
read_inc Partial supportMost bars keep their last text
recall Partial supportSupported postponed mailbox only
record Partial supportSupported backends only
reply_regex Partial supportEnglish default; no localized pattern
save_address Partial supportIndex expandos only
save_empty Partial supportmbox only; no MMDF
score Partial supportScoring; body and header terms refused as in NeoMutt
send_charset Partial supportA text attachment with a charset label keeps it
shell Partial supportEmpty nested shell prompt uses this command
show_multipart_alternative Partial supportAutoview shows only text/html
signature Partial supportLocal UTF-8 file; no command signatures
size_show_bytes Partial supportAll size displays except the compose %l total
size_show_fractions Partial supportAll size displays except the compose %l total
size_show_mb Partial supportAll size displays except the compose %l total
size_units_on_left Partial supportAll size displays except the compose %l total
sleep_time Partial supportNo pause in 8 mutt_sleep calls
smtp_pass Partial supportNo OAuth helpers
smtp_url Partial supportSMTP STARTTLS and SMTPS only
sort Partial supportNo spam or label sorts
sort_aux Partial supportDate, last-date-received, and score sorts
spam_separator Partial supportSeparates %H and ~H tags; tags stop at 64 KiB
spool_file Partial supportSupported backends only
status_chars Partial supportNative status bar states only
status_format Partial supportSome message sizes unknown
timeout Partial supportNo timeout hooks
to_chars Partial supportConfigured identities and lists only
trash Partial supportAccount's IMAP login or local; loaded rows only
use_threads Partial supportNative index rendering
user_agent Partial supportNames Mutt Desktop and its version
wait_key Partial supportWaits for a key after nested shell output
weed Partial supportPager wraps long headers natively

Not supported yet 172

Not supported yet NeoMutt options
OptionStatusDifference
abort_backspace Not supported yet
abort_key Not supported yet
abort_noattach Not supported yet
abort_noattach_regex Not supported yet
account_command Not supported yet
allow_ansi Not supported yet
arrow_cursor Not supported yet
arrow_string Not supported yet
ascii_chars Not supported yet
ask_followup_to Not supported yet
ask_x_comment_to Not supported yet
assumed_charset Not supported yet
attach_charset Not supported yet
attach_format Not supported yet
attach_sep Not supported yet
attach_split Not supported yet
attribution_intro Not supported yet
attribution_locale Not supported yet
attribution_trailer Not supported yet
auto_subscribe Not supported yet
bounce Not supported yet
bounce_delivered Not supported yet
braille_friendly Not supported yet
catchup_newsgroup Not supported yet
charset Not supported yet
check_new Not supported yet
compose_confirm_detach_first Not supported yet
compose_format Not supported yet
compose_preview_above_attachments Not supported yet
compose_preview_min_rows Not supported yet
compose_show_preview Not supported yet
compose_show_user_headers Not supported yet
config_charset Not supported yet
confirm_empty_to Not supported yet
content_type Not supported yet
copy_decode_weed Not supported yet
debug_file Not supported yet
debug_level Not supported yet
devel_security Not supported yet
display_filter Not supported yet
dsn_notify Not supported yet
dsn_return Not supported yet
encode_from Not supported yet
envelope_from_address Not supported yet
followup_to_poster Not supported yet
force_name Not supported yet
greeting Not supported yet
group_index_format Not supported yet
header Not supported yet
header_color_partial Not supported yet
hidden_tags Not supported yet
hide_limited Not supported yet
hide_missing Not supported yet
hide_thread_subject Not supported yet
hide_top_limited Not supported yet
hide_top_missing Not supported yet
history_file Not supported yet
imap_fetch_chunk_size Not supported yet
imap_passive Not supported yet
imap_server_noise Not supported yet
include Not supported yet
inews Not supported yet
ispell Not supported yet
mailcap_sanitize Not supported yet
maildir_header_cache_verify Not supported yet
mark_macro_prefix Not supported yet
markers Not supported yet
meta_key Not supported yet
mh_purge Not supported yet
mh_seq_flagged Not supported yet
mh_seq_replied Not supported yet
mh_seq_unseen Not supported yet
mime_forward_rest Not supported yet
mime_type_query_command Not supported yet
mime_type_query_first Not supported yet
narrow_tree Not supported yet
news_cache_dir Not supported yet
news_server Not supported yet
newsgroups_charset Not supported yet
newsrc Not supported yet
nm_config_file Not supported yet
nm_config_profile Not supported yet
nm_db_limit Not supported yet
nm_default_url Not supported yet
nm_exclude_tags Not supported yet
nm_flagged_tag Not supported yet
nm_open_timeout Not supported yet
nm_query_type Not supported yet
nm_query_window_current_position Not supported yet
nm_query_window_duration Not supported yet
nm_query_window_enable Not supported yet
nm_query_window_or_terms Not supported yet
nm_query_window_timebase Not supported yet
nm_record Not supported yet
nm_record_tags Not supported yet
nm_replied_tag Not supported yet
nm_unread_tag Not supported yet
nntp_authenticators Not supported yet
nntp_context Not supported yet
nntp_listgroup Not supported yet
nntp_load_description Not supported yet
nntp_pass Not supported yet
nntp_poll Not supported yet
nntp_user Not supported yet
pager Not supported yet
pager_context Not supported yet
pager_format Not supported yet
pager_index_lines Not supported yet
pager_skip_quoted_context Not supported yet
pager_stop Not supported yet
pipe_decode Not supported yet
pipe_decode_weed Not supported yet
pipe_sep Not supported yet
pipe_split Not supported yet
post_moderated Not supported yet
preconnect Not supported yet
preferred_languages Not supported yet
print Not supported yet
print_command Not supported yet
print_decode Not supported yet
print_decode_weed Not supported yet
print_split Not supported yet
prompt_after Not supported yet
quote_regex Not supported yet
reflow_space_quotes Not supported yet
reflow_text Not supported yet
reflow_wrap Not supported yet
reply_with_xorig Not supported yet
resume_draft_files Not supported yet
resume_edited_draft_files Not supported yet
save_history Not supported yet
save_name Not supported yet
save_unsubscribed Not supported yet
search_context Not supported yet
sendmail Not supported yet
sendmail_wait Not supported yet
show_new_news Not supported yet
show_only_unread Not supported yet
sidebar_next_new_wrap Not supported yet
smart_wrap Not supported yet
smileys Not supported yet
smtp_authenticators Not supported yet
smtp_oauth_refresh_command Not supported yet
ssl_ca_certificates_file Not supported yet
ssl_ciphers Not supported yet
ssl_client_cert Not supported yet
ssl_force_tls Not supported yet
ssl_min_dh_prime_bits Not supported yet
ssl_starttls Not supported yet
ssl_use_system_certs Not supported yet
ssl_use_tlsv1_2 Not supported yet
ssl_use_tlsv1_3 Not supported yet
ssl_verify_dates Not supported yet
ssl_verify_host Not supported yet
ssl_verify_partial_chains Not supported yet
suspend Not supported yet
text_flowed Not supported yet
tilde Not supported yet
time_inc Not supported yet
tmp_dir Not supported yet
toggle_quoted_show_levels Not supported yet
ts_enabled Not supported yet
ts_icon_format Not supported yet
ts_status_format Not supported yet
tunnel Not supported yet
tunnel_is_secure Not supported yet
use_8bit_mime Not supported yet
use_envelope_from Not supported yet
use_ipv6 Not supported yet
wrap Not supported yet
x_comment_to Not supported yet

Won't support 89

Won't support NeoMutt options
OptionStatusDifference
autocrypt Won't support
autocrypt_acct_format Won't support
autocrypt_dir Won't support
autocrypt_reply Won't support
crypt_auto_encrypt Won't support
crypt_auto_pgp Won't support
crypt_auto_sign Won't support
crypt_auto_smime Won't support
crypt_chars Won't support
crypt_confirm_hook Won't support
crypt_encryption_info Won't support
crypt_opportunistic_encrypt Won't support
crypt_opportunistic_encrypt_strong_keys Won't support
crypt_protected_headers_read Won't support
crypt_protected_headers_save Won't support
crypt_protected_headers_subject Won't support
crypt_protected_headers_weed Won't support
crypt_protected_headers_write Won't support
crypt_reply_encrypt Won't support
crypt_reply_sign Won't support
crypt_reply_sign_encrypted Won't support
crypt_timestamp Won't support
crypt_use_gpgme Won't support
crypt_use_pka Won't support
crypt_verify_sig Won't support
entropy_file Won't support
fcc_clear Won't support
forward_decrypt Won't support
include_encrypted Won't support
pgp_auto_decode Won't support
pgp_auto_inline Won't support
pgp_check_exit Won't support
pgp_check_gpg_decrypt_status_fd Won't support
pgp_clear_sign_command Won't support
pgp_decode_command Won't support
pgp_decrypt_command Won't support
pgp_decryption_okay Won't support
pgp_default_key Won't support
pgp_encrypt_only_command Won't support
pgp_encrypt_sign_command Won't support
pgp_entry_format Won't support
pgp_export_command Won't support
pgp_get_keys_command Won't support
pgp_good_sign Won't support
pgp_ignore_subkeys Won't support
pgp_import_command Won't support
pgp_key_sort Won't support
pgp_list_pubring_command Won't support
pgp_list_secring_command Won't support
pgp_long_ids Won't support
pgp_mime_auto Won't support
pgp_reply_inline Won't support
pgp_retainable_sigs Won't support
pgp_self_encrypt Won't support
pgp_show_unusable Won't support
pgp_sign_as Won't support
pgp_sign_command Won't support
pgp_strict_enc Won't support
pgp_timeout Won't support
pgp_use_gpg_agent Won't support
pgp_verify_command Won't support
pgp_verify_key_command Won't support
postpone_encrypt Won't support
sidebar_divider_char Won't supportMutt Desktop has a native sidebar; this option is ignored.
sidebar_format Won't supportMutt Desktop has a native sidebar; this option is ignored.
sidebar_on_right Won't supportMutt Desktop has a native sidebar; this option is ignored.
sidebar_width Won't supportMutt Desktop has a native sidebar; this option is ignored.
smime_ask_cert_label Won't support
smime_ca_location Won't support
smime_certificates Won't support
smime_decrypt_command Won't support
smime_decrypt_use_default_key Won't support
smime_default_key Won't support
smime_encrypt_command Won't support
smime_encrypt_with Won't support
smime_get_cert_command Won't support
smime_get_cert_email_command Won't support
smime_get_signer_cert_command Won't support
smime_import_cert_command Won't support
smime_is_default Won't support
smime_keys Won't support
smime_pk7out_command Won't support
smime_self_encrypt Won't support
smime_sign_as Won't support
smime_sign_command Won't support
smime_sign_digest_alg Won't support
smime_timeout Won't support
smime_verify_command Won't support
smime_verify_opaque_command Won't support

Mutt Desktop-only functions

Mutt Desktop-only functions
FunctionMenusBehavior
my-muttdesktop-clear-flag-stayIndex, pager0.2.1 Asks for a flag and clears it on the selected message. Unlike clear-flag, it stays on that message after the answer. Use N to clear New by marking an unread message read.
my-muttdesktop-equalize-message-panesIndex, pager0.2.1 Gives the message list and pager equal widths. Default key: Ctrl-W then =.
my-muttdesktop-move-message-divider-leftIndex, pager0.2.1 Moves the divider between the message list and pager 80 points left. Default key: Ctrl-W then -.
my-muttdesktop-move-message-divider-rightIndex, pager0.2.1 Moves the divider between the message list and pager 80 points right. Default key: Ctrl-W then +.
my-muttdesktop-load-content-imagesIndex, pager0.2.0 Loads remote images except suspected trackers for the selected message.
my-muttdesktop-load-remote-contentIndex, pager0.2.0 Loads all remote images for the selected message.
my-muttdesktop-toggle-html-appearanceIndex, pager0.2.1 Switches the selected HTML message's appearance until pressed again or another message is selected. No default key.
my-muttdesktop-toggle-hiddenBrowser0.2.0 Switches between the browser mask and all files.

Mutt Desktop-only options

Mutt Desktop-only options
OptionDefaultBehavior
my_muttdesktop_index_fontunset0.2.0 Sets the message index font by family, such as SF Mono, or by font name. Unset uses the system monospaced font.
my_muttdesktop_index_font_sizeunset0.2.0 Sets the message index font size, from 6 to 72 points. Unset uses the system body size.
my_muttdesktop_index_alternating_rowsno0.2.0 yes gives index and attachment-browser rows alternating backgrounds.
my_muttdesktop_status_baryes0.2.0 no hides the mailbox status bar, which NeoMutt always shows.
my_muttdesktop_autopreviewno0.2.0 yes shows the selected message beside the index and marks it read once its body loads while selected. With imap_peek=yes, preview loads do not hold later navigation keys; with imap_peek=no, BODY[] and FLAGS finish before the next key.
my_muttdesktop_switch_accountyes0.2.0 Controls whether Command-1 through Command-9 switch to the corresponding saved account or ask first; the large pending view names the target while switching, then shows Logging in… during IMAP login and Opening with the selected mailbox name during mailbox open. The status bar and lower information line show the same phase text; the window title keeps the account name. Old rows stay hidden, navigation keys wait for the target, and a failed open reopens the previous account with its normal opening phase and queued keys. A failed return shows the previous mailbox's own error. The returned account's open error stays on the mail line until the next index action and does not stay in Settings when that account is configured.
my_muttdesktop_start_accountfirst0.2.1 The first saved account's muttrc chooses the account opened at launch: first opens Command-1; last opens the last successfully switched account. The first muttrc is read before this choice.
my_muttdesktop_remote_contentask-no0.2.0 A quadoption for remote images in HTML mail: no blocks them, yes loads them automatically, and the ask values allow loading them for one message.
my_muttdesktop_html_appearancelight0.2.1 Sets the HTML viewer's canvas to light, dark, or the macOS system appearance.
my_muttmailbox_dock_badgeno0.2.1 yes shows the active account's new Inbox count on the Dock icon.
my_muttdesktop_menu_bar_badgeno0.2.1 yes shows that count beside the macOS envelope symbol in the menu bar. Clicking the envelope opens the Inbox at its first new message.
my_muttdesktop_delete_clears_newno0.2.1 yes marks a message read when a delete command marks it deleted, so its Trash copy is not new.

Macro execution

Menus that execute configured macros
MenuInputLimit
Index, pager, attachment, postponed listLiteral keys, named keys, multi-key bindings, and implemented functions run in read order.The pager reads only pager bindings.
Compose and browsersMacros can continue from the index into compose, a prompt, or a browser. Keys typed during an asynchronous operation wait behind macro events.Unsupported functions remain unavailable.
Text promptsThe focused field runs editor macros and configured editing functions with its cursor, history, and completion state. history-search, complete-query, help, and redraw-screen follow the same path for typed keys and macros.Address completion can enter the alias or query menu; history search and help enter their own menus before the editor resumes.
History, alias, query, and help menusNested menus read their own bindings and macros, then return to the suspended text prompt. Query and alias menus can read more prompts for search, limit, sort, and alias creation.The current menu handles each key before the outer editor reads again.
Certificate and password promptsKeys typed after the prompt appears can answer it. Earlier terminal keys are discarded; macro events wait until it closes.NeoMutt's certificate prompt may read an earlier ungotten key.

Tab completion

Prompts where Tab completes, as in NeoMutt
PromptTab completesSince
To:, Cc:, Bcc:, compose address fieldsAn alias: a unique match expands to its address, several extend their common prefix, otherwise the alias menu opens. Ctrl-T runs query_command and opens the query menu.0.2.1
change-folder, copy-message, save-messageA local or IMAP mailbox path, with =, +, and ! expanded. Tab on an empty line opens the folder browser.0.2.0
Attach file:, Save to file:A file path.0.2.0
limit, tag-pattern, delete-pattern, and other pattern promptsAfter ~, the pattern menu opens and the chosen pattern replaces the ~. After ~y, an X-Label value from the open mailbox; later Tabs cycle through the matches.0.2.1
: and ! in the alias, query, history, and help menusCommand names, option names and values, and file paths.0.2.1

Not yet supported: completion at : and ! in the folder browser.

Commands, behavior, and differences

Open an item for its behavior and NeoMutt comparison. Difference marks changed behavior; addition marks a Mutt Desktop feature; mixed covers several states.

Account setup 6

addition To use Neovim for composing or edit raw message source, install it with brew install neovim.

To use Neovim for composing or edit raw message source, install it with brew install neovim. Mutt Desktop finds nvim in your login shell's PATH or in Homebrew's /opt/homebrew/bin or /usr/local/bin, or runs the nvim path set editor= gives. Otherwise composition uses the built-in editor, which opens each draft at its first line with the caret ready for typing.

addition Mutt Desktop reads NeoMutt config files.

Mutt Desktop reads NeoMutt config files. It opens the first saved account (Command-1) on each launch. Set my_muttdesktop_start_account=last in that account's muttrc to open the last successfully switched account instead. With no saved account, it searches NeoMutt's default muttrc locations. Account setup opens when no config is found or a required account variable is missing. Mutt Desktop → Settings… adds config files, names accounts, sets optional variables, and orders the File menu. Settings saves an edit on Return, when its field loses focus, when another account is selected, and when Settings closes (Esc drops edits not yet saved); selecting an account there does not switch to it. Closing Settings reopens the open account, without the switch question, only when Settings changed its config file or variables or the account was left offline; NeoMutt's mailbox close questions still apply. Edits made in the muttrc file itself apply when the account next opens: at launch, after such a reopen, or after switching to another account and back. Accounts can share a muttrc. Each account uses one IMAP server and user; see One IMAP server and user per account for splitting a muttrc that combines several. Variable values stay in Keychain and override the launch environment for that account. Removing an account keeps its config file. Finder launches need no terminal command.

addition Every valid NeoMutt 2026-06-16 option name is accepted.

Every valid NeoMutt 2026-06-16 option name is accepted. An option Mutt Desktop does not support has no effect. After an account opens, one warning lists the names it ignored, with no values. Continue has focus, and Return dismisses the warning. “Don't show this again” suppresses later warnings for that account only. Unknown names and invalid config syntax still report errors.

difference Owner-approved difference: Esc at an IMAP or POP password question declines later questions for that protocol in the open account, including queued startup logins.

Owner-approved difference: Esc at an IMAP or POP password question declines later questions for that protocol in the open account, including queued startup logins. IMAP and POP cancellations are independent. The declined password is not sent; the login fails. Command-digit can then switch accounts. To try the declined account again, switch to another account and back, or restart the app. NeoMutt may ask again at the next login. SMTP cancellation ends the explicit send; a later explicit send may ask again.

addition Removing the open account closes it when Settings closes, after NeoMutt's mailbox close questions.

Removing the open account closes it when Settings closes, after NeoMutt's mailbox close questions. Mutt Desktop then opens the account it would open at launch. When no saved account remains, it shows account setup and does not search NeoMutt's default locations until the next launch. If mail access is blocked when Settings closes, the removed account stays open and offline until access returns, then closes the same way. Canceling a close question keeps it open; close Settings again or choose an account in File → Switch Account.

addition Errors shown by the app are also written to standard error.

Errors shown by the app are also written to standard error. SMTP submission failures include the underlying connection, login, or server error there, with the username, the configured or typed password, and their SMTP authentication encodings redacted. Run "/Applications/Mutt Desktop.app/Contents/MacOS/MuttDesktop" in Terminal to see them.

Mailbox safety 23

toggle-new and delete-message queue source changes until sync-mailbox or mailbox exit.

toggle-new and delete-message queue source changes until sync-mailbox or mailbox exit. copy-message, the copy step of save-message, and the append step of edit-raw-message run immediately; between IMAP mailboxes, copy-message and save-message send one UID COPY for all the targets, with Copying N messages to MAILBOX...; a [TRYCREATE] answer asks Create MAILBOX?, and the source mailbox is not listed again. A refused UID COPY (or a declined or failed Create MAILBOX?) makes copy-message and save-message append the messages one by one, as imap_copy_messages returning 1 does, after a STATUS of the destination; a failure after that shows Error copying message (or tagged, or saving). Before that append, a refused UID COPY shows imap_copy_messages [REPLY], where REPLY is the server's tagged reply, or the CREATE's when the Create MAILBOX? that followed [TRYCREATE] failed (imap/message.c:1857, 1863-1866; imap/util.c:660-663); a declined Create MAILBOX? shows nothing (imap/message.c:1851-1855). The move of read messages on leaving an IMAP spool shows the same text before its append, and a sync's refused UID COPY to an IMAP Trash shows imap_fast_trash [REPLY] before the messages are appended to Trash (imap/imap.c:1540-1543; mx.c:541-571). The sync queues its UID STORE and UID COPY commands in a ring of imap_pipeline_depth plus one and writes the queue in one piece before any command that is not queued, reading the replies by their tags, and judges a flush by its last reply alone: an earlier refusal only shows IMAP command failed: LINE, and a refused last reply of a full ring ends the connection. A message that an EXPUNGE reply removed, during the sync or before it, is left out of the later sets, as select_email_uids leaves it out. Without configured trash, sync permanently deletes IMAP and mbox messages and Maildir messages when maildir_trash=no. With maildir_trash=yes, Maildir keeps the file marked T. An edited original bypasses configured trash but follows the same Maildir rule.

difference Mail safety difference: an append into the open mailbox, such as a copy-message or save-message into it, a Sent copy, or a postponed draft, leaves a read-only mailbox read-only.

Mail safety difference: an append into the open mailbox, such as a copy-message or save-message into it, a Sent copy, or a postponed draft, leaves a read-only mailbox read-only. NeoMutt's mx_mbox_open of the open mailbox for the append resets its read-only state from the append's flags (mx.c:309), so the append makes a mailbox opened read-only writable.

difference Difference the owner chose not to port (2026-10-21), since no user benefits from it:

Difference the owner chose not to port (2026-10-21), since no user benefits from it:

  • The open mailbox's progress and sync messages always show. NeoMutt keeps an m->verbose flag on the open mailbox and clears it whenever it opens that mailbox quietly to add mail to it: edit-message or edit-raw-message, a save or copy of several tagged messages into it, or a Sent copy or postponed draft filed into it (mx.c:308, 1655-1657; editmsg.c:196; external.c:915-922; send/sendlib.c:1035-1037). Until a save of one message into it or, for an mbox, a reopen (mbox/mbox.c:715), NeoMutt then shows no Reading, Writing, Mailbox is unchanged, N kept, N deleted, or IMAP header and sync progress for it.
difference Mail safety difference: if an APPEND for a linked or broken thread fails, sync stops and keeps its unsaved header edits queued.

Mail safety difference: if an APPEND for a linked or broken thread fails, sync stops and keeps its unsaved header edits queued. NeoMutt clears the edit even after a failed APPEND. A confirmed APPEND is not repeated after a later failure, and an uncertain APPEND result is not retried automatically.

difference Owner-requested progress difference: an IMAP sync, including one started by leaving the mailbox, immediately shows Syncing mailbox...

Owner-requested progress difference: an IMAP sync, including one started by leaving the mailbox, immediately shows Syncing mailbox... in the status bar while saving flags. Adapter messages replace it as the sync proceeds. An EXPUNGE that takes more than five seconds updates its elapsed time every five seconds until the server answers. NeoMutt shows no message while saving ordinary flags and shows Expunging messages from server... for EXPUNGE; the IMAP commands and their order are unchanged.

difference An IMAP thread rewrite reads the message from the server even when the message cache holds it.

Mail safety difference: a sync that rewrites a message's thread headers appends the edited copy and then deletes the original, so it reads the original with BODY.PEEK[] (or BODY[] with imap_peek unset) instead of the message_cache_dir entry NeoMutt's imap_msg_open would use (imap/message.c:2025-2031). A damaged cache entry cannot replace a message. A UID that vanished, or that an EXPUNGE removed during the fetch, is skipped.

difference A due mailbox check still running after 150 ms shows Checking mailboxes… while other index keys wait.

Owner-approved responsiveness difference: a due mailbox check still running after 150 ms shows Checking mailboxes… in the status bar until its index pass finishes; a quicker check leaves the status bar unchanged. Prompts, account switches, folder transitions, and sync progress take priority. Other index keys wait for the check as in NeoMutt dlg_index (index/dlg_index.c:1180-1304); a direct quit question is the exception below.

difference The index quit question appears during a hook-free startup login, first-mailbox opening, or a mailbox check.

Owner-requested responsiveness difference (2026-10-26, extended 2026-10-27): when quit is directly bound in the index and $quit asks, its question appears during a hook-free startup config login, while the first startup mailbox opens after its hooks, or while an index mailbox-check pass runs. A config login with account or folder hooks or pending hook input effects keeps keys queued until its hooks finish. A no leaves the login, open, or check running; a yes waits for startup completion before the mailbox's move, purge, and write path. A second q at the question beeps and leaves it open. Earlier queued keys, macros, other mailbox work, account switches, and nonasking quit values keep their normal order. NeoMutt logs in to configured IMAP mailboxes while reading config (main.c:1197; commands.c:661-717), opens the startup mailbox before entering the index (main.c:1713-1736; mx.c:298-389), checks it before reading q (index/dlg_index.c:1180-1304), then asks before mx_mbox_close (index/functions.c:2108-2144).

While a mailbox opens or is written, or a forward reads the messages it forwards, NeoMutt reads no command.

While a mailbox opens or is written, or a forward reads the messages it forwards, NeoMutt reads no command. Keys typed meanwhile wait and run afterward, in order with the account switch and the quit that follow them. A Command-digit account switch waits the same way, and the keys typed during it go to the new account's mailbox. The owner-approved quit-question exception during a hook-free startup config login, the first startup open after its hooks, or an index check is recorded above.

difference Ctrl-C belongs to the wait the user is in, so the held-key rule does not apply to it.

Ctrl-C belongs to the wait the user is in, so the held-key rule does not apply to it. Inside an IMAP command (a write, a copy, the login, the SELECT, a mailbox check, or the STATUS and CREATE that check or create the mailbox a save, a copy, a Trash move, or the move of read messages writes to), an encrypted connection drops at once, as ssl_socket_read does, and shows no text of its own. An APPEND is not such a command: the APPEND of a save, a copy, a Trash move, the move of read messages, a sync with an IMAP Trash, an Fcc, a postpone, and edit-raw-message completes on an encrypted connection, and the interrupt stays set, as imap_append_message reads outside imap_exec and SSL_read restarts (imap/message.c:1618-1654; mutt/signal.c:202-208; conn/openssl.c:1344); only the STATUS, CREATE, and UID COPY drop (imap/command.c:1468-1477). Owner-delegated difference (agent judgment, 2026-10-21): after a lost APPEND reply for a save, copy, Trash move, read-message move, IMAP Trash sync, Fcc, or postpone, Mutt Desktop reconnects on the next command; NeoMutt's imap_cmd_step logs in and reopens at once (imap/command.c:1260-1276). The immediate reopen can discard unsynced flags, tags, and purge marks (imap_reopen_mailbox, imap/imap.c:2159-2190). The uncertain APPEND is never retried automatically. A plaintext connection (the greeting and STARTTLS exchange) drops when the next data arrives and shows Connection to HOST has been aborted. A plaintext socket_timeout that expires first clears the interrupt and shows Error talking to HOST (Resource temporarily unavailable). An encrypted connection never times out once TLS is active, because ssl_socket_read retries a read that fails with EAGAIN; the connect and the TLS handshake keep the limit (IMAP and SMTP also limit the greeting of an implicit-TLS connection; POP does not). A Ctrl-C during the connect ends it, clears the interrupt, and shows Could not connect to HOST (Interrupted system call) (raw_socket_open), whether the connect opens a mailbox, logs in again inside another command, or reconnects after a lost connection. Where an encrypted connection dropped on a Ctrl-C shows no text, an attachment open or save, a forward, and the message panel show no reason either. The sync then reports Error saving flags and keeps every change queued, or asks Error saving flags. Close anyway? when leaving. A Ctrl-C during the STATUS that save-message or copy-message sends to check an IMAP destination ends that STATUS, not the copy. imap_access still counts the mailbox as present, so confirm_append asks Append messages to MAILBOX? and the copy then runs (muttlib.c:756-769, imap/imap.c:470-475). A plaintext read clears the interrupt; after an encrypted drop it stays set, which the encrypted copy ignores (conn/openssl.c:1344). When a Ctrl-C ends the UID COPY that moves read messages on leaving an IMAP spool, Mutt Desktop logs in again and reopens the mailbox (Reconnected to HOST, Reopened mailbox on HOST), then shows imap_copy_messages [] (imap/message.c:1863-1866; imap/command.c:181-247). NeoMutt-bug difference (agent judgment): after the reconnect NeoMutt's brackets hold the reopen's last reply, not the COPY's, which imap_error is meant to show (imap/imap.c:930-942, 2182-2188; imap/message.c:1845-1846; imap/util.c:660-663); the lost COPY has no reply, so Mutt Desktop's brackets are empty. imap_sync_message: STORE failed [...] after a reconnect follows the same rule. A flag store before the COPY that loses the connection logs in again and reopens the mailbox first, then shows imap_sync_message: STORE failed [] and asks Continue?; yes sends the COPY on the new connection (imap/command.c:181-247; imap/imap.c:1093-1098). If that login failed, the yes still queues the COPY, whose final imap_exec fails: for several messages Copying %d messages to %s... shows first (imap/message.c:1828-1832), then Mutt Desktop shows imap_copy_messages [] and appends the messages, for one message or several, as imap_copy_messages returns 2 (imap/imap.c:940; imap/message.c:1837, 1863-1866, 1887; mx.c:761; external.c:886-913). No COPY was sent, so the append cannot leave two copies. A flag store that fails with Continue? declined sends no COPY and ends the close with no more text (imap/message.c:1772-1776, 1804-1808; mx.c:757-759). So does a failure while several messages' COPY sets are queued, except that a set queued before it may have been copied (imap/message.c:1824-1827); for a single message, whose COPY cannot be queued on a connection whose login failed, the read message is appended instead, as imap_copy_messages returns 2 (imap/message.c:1779-1784, 1887; mx.c:761). On such a connection a message with a flag to store sends the STORE first, which logs in again and fails, so imap_sync_message: STORE failed [] and Continue? come before the COPY (imap/imap.c:1092-1095; imap/command.c:270-274). A single message's Copying message %d to %s... shows before that login (imap/message.c:1767). fetch-mail's close of a spool not open in the index ends the same way, after logging in again and reopening the spool when the connection was lost. Difference not yet resolved (origin: agent judgment; pending chunk 6p-9): when the connection fails while the sets are queued, NeoMutt logs in twice, once in cmd_queue's read and again when imap_exec sees the failed cmd_start (imap/command.c:154-161, 1449-1453); Mutt Desktop logs in once. Mutt Desktop-only refusals before the COPY, such as a mailbox whose server flags were never read or a message with no UIDVALIDITY, show their own text. A CREATE after [TRYCREATE] that loses the connection logs in again, shows CREATE failed: and imap_copy_messages [], and appends the read messages to mbox, since the server refused the COPY (imap/imap.c:443-458; imap/message.c:1857, 1863-1866; mx.c:761-781); the trailer is empty by the same NeoMutt-bug rule as the brackets. A failed append shows only the backend's error (mx.c:777-786), and an mbox that cannot be opened for appending shows PATH: REASON (errno = N) (mbox_mbox_open_append, mbox/mbox.c:898-903). Mutt Desktop-only (Mail safety, agent judgment): a source mailbox whose UIDVALIDITY changed shows The mailbox changed; reload it before continuing.; NeoMutt has no such check. NeoMutt-bug difference (agent judgment): the reopen after a lost flag store frees every message (imap/imap.c:2159-2166) while imap_copy_messages and mx_mbox_close still read and mark the ones they hold (imap/message.c:1792-1814, 1870-1878; mx.c:738-746); Mutt Desktop copies the same UIDs, checked against UIDVALIDITY, and marks the messages with those UIDs deleted. After a reconnect, as after a lost CREATE, the append takes the messages the reopened mailbox lists as read, so a message read only in Mutt Desktop, whose change the reopen dropped, is not moved (mx.c:769-787; imap/imap.c:2159-2190). If that reopen fails during its header download, the append takes the read messages its download added before the failure (imap/message.c:1271-1273, 1338-1345; mx.c:769-787). Owner-delegated difference (agent judgment, 2026-10-21): a failed spool write adds Destination may contain copies.; NeoMutt ends the close without that warning (mx.c:777-786). It tells the user that repeating the fetch could make duplicate copies. Mail safety difference (agent judgment): after a lost COPY, NeoMutt appends the read messages to mbox (mx.c:757-781), which can leave two copies if the COPY was made; Mutt Desktop appends nothing and keeps the mailbox open. Mail safety difference (agent judgment): after a fast Trash STORE or CREATE reconnect, a refused COPY fallback appends every reopened deleted message. NeoMutt starts at the pre-reconnect first_del index (mx.c:502-518, 555-571), which can skip a newly listed deleted message; the following EXPUNGE can then remove it without a Trash copy (imap/imap.c:1759-1778). Mutt Desktop opens Trash for appending before it appends messages there, as trash_append does. This covers the sync or close of a mailbox that is not IMAP, the fetch-mail that stops the close of an open mbox spool on new mail, an IMAP mailbox whose Trash is local, and an IMAP Trash that refuses the UID COPY. A missing IMAP Trash is created after Create MAILBOX? at that open. A missing local Trash is created at that open, after Create PATH? under confirm_create. A Trash that cannot be opened or created shows Can't open trash folder and nothing is removed from the mailbox (mx.c:546-552; imap/imap.c:2291-2318; mbox/mbox.c:877-920; maildir/mailbox.c:752-800); a local one first shows the system error, such as PATH: Permission denied (errno = 13) for an mbox without write permission (mbox/mbox.c:890-902). A failed append to Trash then shows Unable to append to trash folder (mx.c:569). Every deleted message is appended to Trash, in the index's sort order (including messages a limit hides), before the sync removes any, whether the mailbox and Trash are local or IMAP, so a failed append removes nothing (mx.c:555-572, 984-991; email/sort.c:406-431). An mbox that changed since it was read gets its Trash copies first, then is read again with its deletions still queued, so the next sync appends them to Trash again, as in NeoMutt (mx.c:984; mbox/mbox.c:1110-1117). An mbox Trash is locked when it is opened and stays locked through every append of the batch. While another program holds the lock, Mutt Desktop shows Waiting for fcntl lock... N once a second and, after five tries, Timeout exceeded while attempting fcntl lock, as at every mbox lock NeoMutt takes: an open, a new-mail check, a sync, and an append (mutt/file.c:1095-1135); then Couldn't lock PATH and Can't open trash folder, and nothing is appended or removed (mbox/mbox.c:905-910; mx.c:549-553). Reading, copying, or flagging one message waits without these texts, as NeoMutt's mbox_msg_open takes no lock (mbox/mbox.c:1473-1484); removing a recalled postponed message shows them, as the sync does (mbox/mbox.c:1103). The move of read messages to a local mbox on leaving a mailbox locks it the same way, and a lock it cannot take shows Couldn't lock PATH and ends the close (mx.c:764-768). Difference (origin: agent judgment): a read of that Trash by Mutt Desktop itself during the batch takes a shared lock on the same file, which turns the held exclusive lock into a shared one until the next append locks it again; NeoMutt reads nothing during trash_append (mx.c:556-577). Differences not yet resolved (origin: agent judgment; chunk 6s-8): NeoMutt does not count a try while the locked file grows, so it waits for as long as another program writes it (mutt/file.c:1120-1121), where Mutt Desktop stops after five tries; and an mbox whose shared lock NeoMutt cannot take at an open is opened read-only (mbox/mbox.c:150-154), where Mutt Desktop fails the open. When a sync's UID COPY to an IMAP Trash loses the connection, Mutt Desktop logs in again and reopens the mailbox, then shows imap_fast_trash [], with the same empty brackets (imap/imap.c:1515, 1540-1543). When fetch-mail closes an IMAP spool that is not open in the index and the UID COPY that moves its read messages loses the connection, Mutt Desktop logs in again, reopens the spool, shows imap_copy_messages [], and ends the close (pop/pop.c:671; mx.c:737). Mail safety difference (agent judgment): after either lost COPY, NeoMutt appends the messages (trash_append, mx.c:541-571; mx_mbox_close, mx.c:757-781), which can leave two copies if the COPY was made; Mutt Desktop appends nothing.

difference Ctrl-C stops a stalled IMAP, POP, or SMTP TLS handshake during connection setup.

Owner-approved difference (2026-10-25): Ctrl-C stops implicit TLS and STARTTLS or STLS handshakes for IMAP, POP, and an explicit SMTP send. It closes that connection before login, POP commands after STLS, or SMTP envelope commands; a stopped SMTP send keeps its draft, and none of these operations retries automatically. An interrupted POP login retry stops its authenticator list before any later credentials are sent. The key does not later ask to quit. NeoMutt retries an interrupted SSL_connect and can remain in the handshake (conn/openssl.c:1167-1173, 1211-1298; imap/imap.c:822-879; pop/lib.c:281-290, 330-380; send/smtp.c:1017-1070). Certificate questions still own their keys. See .architecture/history/2026-10-connection-open-interrupt.md.

difference An interrupted IMAP authentication server-response wait closes before another method runs.

Ctrl-C during an IMAP authentication server-response wait closes the connection before another method can send credentials. If a command reaches the unfinished exchange, Mutt Desktop rejects it instead of crashing. Password and SASL interaction prompts still handle their own keys. NeoMutt stops trying methods when the connection is unusable (imap/auth.c:150-157, 178-191); an interrupted socket read ends the exchange (conn/raw.c:299-317; conn/openssl.c:1333-1358).

difference Every pass of an IMAP header download (the cache pass, the flag updates, and the header fetch) asks Abort download and close mailbox? at the next response, from inside the heade...

Every pass of an IMAP header download (the cache pass, the flag updates, and the header fetch) asks Abort download and close mailbox? at the next response, from inside the header loop, on every open and reopen of a mailbox: the index's, the postponed list's, fetch-mail's spool, a quiet reload, and the reopen after a reconnect, of the index's mailbox or of postponed. The socket is read no further while the question is open. Yes ends an open with Error opening mailbox; on the reopen after a reconnect it shows no text of its own before Reconnected to HOST but failed to reopen mailbox. A mailbox check's new-mail fetch does not ask. A message body download stops with Download interrupted on an encrypted connection; on a plaintext one it shows Connection to HOST has been aborted, as raw_socket_read aborts the read that a Ctrl-C reaches (conn/raw.c:299-317). Owner-approved difference (2026-10-21): Ctrl-C ends a stalled encrypted message open even when its body FETCH has no reply; NeoMutt reads it outside imap_exec, so SSL_read restarts and can wait forever (imap/message.c:2057-2070; imap/command.c:1467-1477; conn/openssl.c:1335-1359). On a plaintext connection, when that abort comes before the message text, on a line of the server's reply, the connection is lost at once and, after that text, logs in again, as imap_cmd_step runs cmd_handle_fatal (imap/command.c:1269-1276), and the next open reads as usual. A Ctrl-C that comes before the body download starts, while Mutt Desktop checks which message it reads or waits for the connection, counts as one on a line of the reply: on an encrypted connection SSL_read restarts (mutt/signal.c:315-325) and the download stops at its first byte with Download interrupted, and on a plaintext one the read aborts with Connection to HOST has been aborted and logs in again at once. A pager whose message was opening returns to the index (pager/message.c:458-460, 490); a reply whose message download stops then ends with Could not include all requested messages, as generate_body does (send/send.c:1176-1179). A forward's message download stops the same way, and only that text shows: with mime_forward or without forward_decode, or with forward_attachments set to no, the forward goes on without that message (send/send.c:1200-1213, 1234). NeoMutt bug difference (origin: agent judgment): with mime_forward, NeoMutt's failed mutt_make_message_attach returns NULL (send/sendlib.c:493-499) and sets last to NULL, so the next message attached replaces e->body and drops the text part (send/send.c:2156-2157) and every message attached before it (send/send.c:1200-1212); Mutt Desktop keeps them. Without mime_forward and with forward_decode set and forward_attachments not set to no, Mutt Desktop instead logs in again and reopens the mailbox at once, as inline_forward_attachments opens the message again and that open's cmd_start runs cmd_handle_fatal (send/send.c:1237, 574; imap/command.c:270-274), and the forward ends with no draft. NeoMutt bug difference (origin: agent judgment): that reconnect's imap_reopen_mailbox frees every Email (imap/imap.c:2160-2167), and the open goes on with the freed one (the use-after-free described below), where generate_body intends to end the forward when the open fails (send/send.c:1237-1238); Mutt Desktop ends it after the reconnect. An edit-raw-message read stops the same way, then the run ends with could not write temporary mail folder: Interrupted system call, as ev_message does (editmsg.c:89-97). Apart from that reply-line case, the stopped download leaves the connection lost (IMAP_FATAL, imap/imap.c:642, 667). The index's or pager's next mailbox check, which runs without a key once mail_check seconds have passed since the last one, logs in again and reopens the mailbox (Reconnected to HOST, Reopened mailbox on HOST), which lists each message with the server's flags, as NeoMutt's mx_mbox_check does (mx.c:1117-1123, index/dlg_index.c:1180, imap/imap.c:1170, imap/command.c:1509-1514). Before that check is due, a key does not log in again by itself; any IMAP command logs in again and reopens the mailbox first, as cmd_start runs cmd_handle_fatal (imap/command.c:270-274), which drops the queued changes. Moving the cursor sends nothing. A message open, such as a forward's next message, then fails and shows nothing of its own, so the forward leaves the message out. sync-mailbox, a mailbox close, and a quit go on over the reopened mailbox and show its counts, as imap_sync_mailbox's first check reopens it and returns success (imap/imap.c:1166-1183, 1589); when that check sends IDLE (imap_idle) or a NOOP due after timeout, they fail after the reconnect with nothing more, the close leaving the mailbox open (imap/imap.c:1138-1166; mx.c:816-821, 989-992); a save, the STATUS of a mailboxes entry, and an Fcc go on over the new login, as NeoMutt takes the STATUS's IMAP_EXEC_FATAL as found (imap/imap.c:470-475, 2303-2305). Opening a mailbox clears the lost state and logs in as part of the open (imap/imap.c:2223-2224); a quiet reload does not, and its first command logs in again first. While a local mailbox is open, nothing logs in again: each IMAP command fails with nothing shown (imap/command.c:191-192). Difference not yet resolved (origin: agent judgment, chunk 6p-3): when the reopen leaves no change to write, the sync sends no EXPUNGE and shows no Expunging messages from server..., where NeoMutt sends one (imap/imap.c:1759-1772). NeoMutt bug difference (origin: agent judgment): imap_msg_open calls imap_cmd_start(adata, buf); and ignores its result (imap/message.c:2063), where cmd_start documents @retval <0 Failure (imap/command.c:264) and fails the command unsent under IMAP_FATAL (imap/command.c:270-274). The open then waits for the reply to the fetch it never sent (imap/message.c:2064-2066), until socket_timeout ends the wait with a second reconnect on a plaintext connection, or without end on an encrypted one, where ssl_socket_read retries the timed-out read (conn/openssl.c:1344-1353). The reconnect's imap_reopen_mailbox has freed every email (imap/imap.c:2159-2165), so the open then writes e->active = true to freed memory (imap/message.c:2128, 2187), a use-after-free. Mutt Desktop fails that open after the one reconnect. On a plaintext connection, a Ctrl-C after the editor closes, while edit-raw-message appends the edited copy, aborts that APPEND at its next read, as imap_append_message reads its replies through raw_socket_read (imap/message.c:1618-1654, conn/raw.c:312-316). Mutt Desktop shows Connection to HOST has been aborted, logs in again, and reopens the mailbox, then Error. Preserving temporary file: PATH ends the run and the original is not marked deleted (editmsg.c:242-267). On an encrypted connection the APPEND completes and the interrupt stays set, as ssl_socket_read ignores it (conn/openssl.c:1344). When a read of an edited copy's APPEND loses the connection another way, the socket's text shows first, such as Error talking to HOST (Resource temporarily unavailable) after a timeout (conn/raw.c:305-308) or Connection to HOST closed (conn/socket.c:216); then Mutt Desktop logs in again and reopens the mailbox, the APPEND shows nothing of its own (imap/command.c:1269-1276; imap/message.c:1664-1672), and Error. Preserving temporary file: PATH follows. When a write of the message fails, the socket's text is followed by Error. Preserving temporary file: PATH at once, and Mutt Desktop logs in again at the next IMAP command, such as the mailbox check that follows the edit (imap/message.c:1630-1645; imap/command.c:284-293). Between a forward's reads, or during its read of a local message, Ctrl-C only sets the interrupt for the next read, as NeoMutt's handler does (mutt_signal.c:84-85). A Ctrl-C typed after the download finishes, while the message is still opening, does not stop that open; it stays set until the next key read clears it (key/get.c:231). A message open, a forward's read, or an edit-raw-message read that starts while the interrupt is set fails at its body read; a message read from message_cache_dir does not check it, and the commands before the body read do not see it. A Ctrl-C during the open of a message in message_cache_dir only sets the interrupt, and the open succeeds, as NeoMutt reads no socket (imap/message.c:2025-2031). On an encrypted connection the open sends its fetch and stops at the reply with Download interrupted, as imap_read_literal checks before the first byte (imap/imap.c:636-644) and ssl_socket_read ignores the interrupt (conn/openssl.c:1344); with imap_peek unset the server has then marked the message read, and the connection is lost as above. On a plaintext connection the body fetch's first reply ends the read with Connection to HOST has been aborted and the connection is lost, as raw_socket_read does (conn/raw.c:312-317). For example, a Ctrl-C during the wait after an error, before a reply runs, stops the reply's read, and the reply ends with Could not include all requested messages. During the wait after an error (sleep_time), the sleep_time wait after an echo or the sort threads warning, and the wait before a reconnect (Connection lost. Retrying in N seconds...), Ctrl-C ends the wait and asks nothing, as SIGINT ends NeoMutt's nanosleep and sleep (mutt/date.c:982-989, muttlib.c:841-848, imap/command.c:215). The interrupt stays set for the next step, as NeoMutt's SigInt does, until the next key read clears it: after the wait that follows a folder-hook error, the Maildir open stops and fails with no text of its own. While IDLE runs (imap_idle), the index's next check of the IMAP mailbox, and the check a sync or a close starts with (imap/imap.c:1589), ask Exit Mutt Desktop without saving? at their poll when nothing waits to be read, as raw_socket_poll calls mutt_query_exit (imap/imap.c:1144-1150, conn/raw.c:380-381): Yes exits at once, also during a sync or a close, whose queued changes stay unwritten; No clears the interrupt and the check goes on. Over a plaintext connection, a check that enters IDLE, or that finds data the server sent during IDLE, reads IDLE's answer or that data first, and the read fails with Connection to HOST has been aborted and clears the interrupt (conn/raw.c:312-316): the check fails, and the connection logs in again (Reconnected to HOST, Reopened mailbox on HOST). Over an encrypted connection the read ignores the interrupt (conn/openssl.c:1344), and the question follows. A plaintext connection the server closes aborts the same way: during IDLE at the next check, and during any command, including IDLE before its answer, at once, as the read of the end of the stream still shows Connection to HOST has been aborted and clears the interrupt (conn/raw.c:304-316). When a read of IDLE's answer fails, IDLE command failed for HOST follows the reconnect messages (imap/command.c:1269-1276, 1622-1628); when IDLE cannot be sent, it does not (1588-1593). Before the reconnect, a check shows the socket's own text: Connection to HOST closed when the server closed the connection, during IDLE too, and Error talking to HOST (REASON) when a plaintext read or write failed (conn/socket.c:214-217, conn/raw.c:305-307, 338-341); a failed TLS read or write shows no text of its own (conn/openssl.c:239-301, 1333-1360). When IDLE's answer does not come within imap_poll_timeout and the interrupt is set, the poll asks Exit Mutt Desktop without saving? first; after No, Connection to HOST timed out waiting for IDLE response follows (conn/raw.c:377-381, imap/command.c:1598-1605). The check that starts the close of fetch-mail's IMAP spool_file (mx_mbox_close, pop/pop.c:671; imap/imap.c:1589) reads the interrupt as a sync's does, and Yes at its question exits during the fetch. A command of that close that loses the connection logs in again and reopens the spool (imap/command.c:181-247), with the texts an index check shows around the reconnect, such as Connection to HOST closed before it and IDLE command failed for HOST after it; a lost check then ends the close with no text of its own (mx.c:816-821), and a lost flag store asks Error saving flags. Close anyway? (imap/imap.c:1717-1727). When nothing waits, or at a question, prompt, or menu that reads a key, Ctrl-C asks Exit Mutt Desktop without saving? first (mutt_getch calls mutt_query_exit, key/get.c:241-244): Yes exits, No cancels the question or prompt it interrupted, and the keys typed before are dropped. A Ctrl-C typed into a prompt field or a password prompt reaches the window's owner the same way. In the pager, a key the pager does not bind drops the keys typed behind it, and the next key shows Key is not bound, as NeoMutt's retry_generic does. During a local write or close, Ctrl-C does not stop the write: NeoMutt blocks signals in mbox_mbox_sync, and a Maildir write does not check the interrupt. The interrupt then stays set until a key read clears it, so a folder change whose close write it reached fails the Maildir open with no text of its own. If a draft is open while a mail-window prompt asks for a save path, Ctrl-C cancels that prompt and reports that the draft must be finished before quitting.

difference During the read of an mbox, Ctrl-C is ignored too, as NeoMutt blocks signals in mbox_mbox_open: the index's open, the postponed list's open, the fetch-mail spool's open, and a c...

During the read of an mbox, Ctrl-C is ignored too, as NeoMutt blocks signals in mbox_mbox_open: the index's open, the postponed list's open, the fetch-mail spool's open, and a check's read of the mail appended to the mailbox all finish. An open of an mbox that starts while the interrupt is still set, as after a Ctrl-C at a wait or during a local write, reads no message, as mbox_parse_mailbox stops before its first message (mbox/mbox.c:397, 529-533): the mailbox opens with an empty index and shows Reading from PATH interrupted... (mx.c:375-389), the postponed list then shows No postponed messages, and fetch-mail goes on with no spool messages listed. The quiet reads of an mbox stop the same way and show the same text: the %p and Recall postponed message? count of $postponed, which then counts 0 and does not ask, and a mail_check_stats count of a mailbox in mailboxes (postpone/postpone.c:156-158; mbox/mbox.c:1697; mx.c:384-388). Those counts stay 0 until the file changes again or $postponed is opened, as in NeoMutt; recall-message still lists every postponed message. The file is not changed, and sync-mailbox says Mailbox is unchanged. Mail safety difference (origin: agent judgment): a check of an mbox that shrank ignores Ctrl-C and reads the whole mailbox. NeoMutt's reopen_mailbox reads with signals unblocked (mbox/mbox.c:1030-1038), keeps a partial list after Ctrl-C (397, 529-532, 630-640), and records the full file size (377). A later flag sync can then overwrite the listed records and truncate unlisted mail (1110-1121, 1140-1209, 1290-1303). Mutt Desktop finishes the reread before it permits a sync. For the same reason, a check's read of an mbox, whether of appended mail or of one that shrank, ignores an interrupt set before it starts and reads every message; NeoMutt's mbox_parse_mailbox stops there before its first message (397), so the appended messages are never listed, and since the recorded size covers them (377), a later mbox_mbox_sync truncates them (1290-1303). A Ctrl-C during the scan of a Maildir's new or cur stops that scan, and one during the read of new stops the scan of cur. Either way the open fails with no text of its own, as in maildir_parse_dir: the index is left empty, the postponed list shows No postponed messages, and fetch-mail ends; a Ctrl-C while cur is read is ignored. A Maildir $postponed that changed is counted for %p and Recall postponed message? with the same scan, so an interrupt still set stops it, shows nothing, and counts 0 (postpone/postpone.c:156-163). A forced count of an IMAP $postponed sends its STATUS as a wait: on a plaintext connection an interrupt still set ends the read with Connection to HOST has been aborted (conn/raw.c:312-316), and the count keeps its last value; then Mutt Desktop logs in again, as after any lost connection. An encrypted read leaves the interrupt set. Mail safety difference (origin: agent judgment): a Ctrl-C during a Maildir check's reload fails the reload with no text and keeps the listed messages. NeoMutt's maildir_check ignores the stopped scan (maildir_parse_dir(m, &mda, "new", NULL);, maildir/mailbox.c:607-610) and marks each listed message the scan did not reach e->deleted = true; e->purge = true; under the comment "We know it disappeared because we just scanned the subdirectory it used to reside in" (667-675). NeoMutt's mx_mbox_check then sends NT_MAILBOX_INVALID (mx.c:1124-1126), the marked messages count as deleted (mview.c:214-215), and the sync asks Purge %d deleted messages? under $delete (mx.c:944-952) and unlinks their files, or with $maildir_trash set gives them the T flag (maildir/message.c:316-325: unlink at 322, T flag at 324-325). A Ctrl-C during the open of a POP mailbox ends the open with no text and an empty index. NeoMutt ends a plaintext read with Connection to HOST has been aborted (raw_socket_read, conn/raw.c:312-316), and an encrypted read through ssl_socket_read and ssl_err (conn/openssl.c:1333-1359). Difference not yet resolved (origin: owner, postponed 2026-10-18, TODO pop-interrupt).

difference During an established SMTP send over TLS, Ctrl-C has no effect, as in NeoMutt.

During an established SMTP send over TLS, Ctrl-C has no effect, as in NeoMutt. A Ctrl-C during SMTP socket connect ends it before the greeting and shows Could not connect to HOST (Interrupted system call) (conn/raw.c:104-142, 282-286; send/smtp.c:1017-1028). A plaintext SMTP connection drops with the next data and shows SMTP session failed: read error. A reply that is not a success shows SMTP session failed: REPLY, a timeout while writing shows SMTP session failed: write error, and a line that does not start with a three-digit reply code shows Invalid server response (send/smtp.c:148-187, 1195-1200). Difference: SMTP lines may be up to 8 KiB, where NeoMutt reads 1,024 bytes. The draft stays sendable unless the transport reports the send as accepted-unknown, which means after the final dot. Difference (origin: agent judgment, under the owner's NeoMutt-bug exception): a Ctrl-C during the sleep_time wait after an error, before Sending message... shows, ends the send when no copy is filed before SMTP. Nothing is sent, filed, or postponed, Sending message... stays on the line, and the draft stays open and sendable. NeoMutt intends this: mutt_write_mime_body ends with if (SigInt) { SigInt = false; return -1; } (send/body.c:373-376), and mutt_send_message then returns to the compose menu (send/send.c:2784-2817). But encode_8bit and encode_base64 clear SigInt and stop before the first character (send/body.c:109-112, 134-137), so that check finds it clear. When the first part written is a base64 part or a text part that is neither quoted-printable nor base64 (7bit or 8bit, through encode_8bit, send/body.c:364-365), NeoMutt sends the message with that part empty and the later parts whole, which differs from the message composed and from the copy it files after SMTP (Mail safety); a quoted-printable or raw first part fails the write, as intended, and stops it before any later part (send/body.c:324-325). Difference (origin: agent judgment, under the owner's NeoMutt-bug exception): with fcc_before_send set and an Fcc mailbox, the same Ctrl-C fails the Fcc write before it files anything, and NeoMutt's Fcc failed. (r)etry, alternate (m)ailbox, or (s)kip? follows; after any answer the message is sent whole, as NeoMutt sends after save_fcc whatever it returns (send/send.c:2780-2783). NeoMutt's Fcc write reaches the interrupt first (send/sendlib.c:1155, 1201) and meets the same encoders: such a first part is filed empty with no question, and the send then goes out whole, so the filed copy differs from the message sent (Mail safety). A quoted-printable or raw first part fails the write after that part, before any later part or the closing boundary (send/body.c:324-325), so a message with more than one part is cut off after its first. mutt_write_fcc still commits that copy to a Maildir, MH, or IMAP Fcc (send/sendlib.c:1201-1204) before asking, so r files a second copy; to an mbox Fcc it ignores the write's result (1155), files the cut copy, and asks nothing.

difference After a lost connection Mutt Desktop logs in again at once, as cmd_handle_fatal does, and shows Reconnected to HOST.

After a lost connection Mutt Desktop logs in again at once, as cmd_handle_fatal does, and shows Reconnected to HOST. A message read that lost the connection shows its error, such as Connection to HOST closed, before that; a forward shows both before it clears the message line and opens the draft, and edit-raw-message then ends with could not write temporary mail folder: REASON, as it does after any failed read (editmsg.c:89-97), where REASON is the failure's system error, Interrupted system call after a Ctrl-C. NeoMutt's text names whatever system error was last set, which the reconnect may have changed. A forward of several messages reads them one at a time, in NeoMutt's order: the reconnect after a read that lost the connection ends before the next message is read (send/send.c:1200-1213, 1232-1234; imap/command.c:1269-1276). NeoMutt bug difference (origin: agent judgment): that reconnect's imap_reopen_mailbox frees every Email (imap/imap.c:2159-2165), and NeoMutt's next include_forward (send/send.c:1232-1234) or mutt_make_message_attach (send/send.c:1200-1203) opens a freed one; Mutt Desktop reads the next message from the reopened mailbox. It then reads the selected mailbox again (imap_reopen_mailbox), with SELECT or EXAMINE and the header download only, and shows Reopened mailbox on HOST, or Reconnected to HOST but failed to reopen mailbox. Reading the mailbox again discards the queued changes, the tags, and the purge marks, and the write that was lost is never sent again. A reopen that fails leaves the index with only the messages its header download read before the failure, as imap_reopen_mailbox drops the others before it selects the mailbox again. Difference (NeoMutt bug): the index shows those messages at once; NeoMutt's view keeps no visible rows until its next update (imap/imap.c:2173), contrary to the function's comment that the reopen is there "so the index is repopulated" and to avoid "an empty screen" (2142-2145). A failed login shows its connect or login error, such as Could not connect to HOST (Connection refused), then at once Reconnection to HOST failed. Will retry automatically.; the next command logs in again after 1, 2, 4, or 8 seconds, and the fifth failed attempt shows Failed to reconnect to HOST after 5 attempts.

difference Mail safety difference: if the server refuses a command with session is not selected, Mutt Desktop closes that IMAP connection.

Mail safety difference: if the server refuses a command with session is not selected, Mutt Desktop closes that IMAP connection. The failed command is not retried; the next operation logs in and selects its mailbox again. NeoMutt keeps the connection after this tagged refusal.

difference NeoMutt bug difference: after a failed open of a temporary postponed or fetch-mail spool mailbox, Mutt Desktop selects the previous mailbox again before using it.

NeoMutt bug difference: after a failed open of a temporary postponed or fetch-mail spool mailbox, Mutt Desktop selects the previous mailbox again before using it. NeoMutt restores its mailbox pointer without selecting it (imap_mbox_open, imap/imap.c:2279-2285), although its close path selects the previous mailbox (2369-2375). Its next sync then refuses to write because no mailbox is selected (1578-1582).

difference IMAP replies update the open mailbox and its message list.

The EXISTS, EXPUNGE, and flag changes in IMAP replies reach the open mailbox, as cmd_handle_untagged sends them there. After each command run while a reopen is allowed, the messages an EXPUNGE named leave the index and the new mail is fetched, as NeoMutt's imap_cmd_finish does. A reopen is allowed (IMAP_REOPEN_ALLOW) from the end of the open's header download and of a sync's flag writes, for every later command, until a mailbox check ends; the check allows it while it runs (imap/message.c:1532, imap/imap.c:1756, 2330-2334). The index shows the removals and flag changes at once, and the new mail at the next mailbox check, except mail fetched before an EXPUNGE, which joins with the removals as NeoMutt's update_tables puts it in the view. So a Sent copy appended to the open mailbox appears without the mailbox being read again. The same happens when some servers (Proton Bridge) send an EXPUNGE after a UID COPY: the source message leaves the index. Difference: a second mailbox of the account is selected for a copy or through the postponed chooser and load, and the open mailbox is selected again afterward without NeoMutt's CLOSE, which would expunge messages another client marked deleted there.

difference Difference (a NeoMutt defect not copied): cmd_handle_fatal tests if (imap_login(adata)) as the success of the reconnect (imap/command.c:221), but imap_login returns 0 on success...

Difference (a NeoMutt defect not copied): cmd_handle_fatal tests if (imap_login(adata)) as the success of the reconnect (imap/command.c:221), but imap_login returns 0 on success and -1 on failure (imap/imap.c:1899). A literal copy would report every successful login as Reconnection to HOST failed and count it as a failed attempt. Mutt Desktop treats a successful login as success, as NeoMutt intends.

difference Local Maildir and mbox mailboxes use the same commands but update files differently.

Local Maildir and mbox mailboxes use the same commands but update files differently. Copies between local and IMAP mailboxes stream without a fixed app size limit; the IMAP server may enforce APPENDLIMIT. A Maildir's new/, cur/, and tmp/ entries must be directories, not symbolic links; the mailbox path itself may be a symbolic link. A save or copy to a symbolic link appends to the mailbox the link leads to, so a link to the open mailbox names the open mailbox, as mutt_save_message resolves it (external.c:915). A Maildir change renames or removes the message's file when the mailbox is synced. A new Maildir message gets its name by a hard link, as in NeoMutt's mutt_file_safe_rename; a link that reports failure but made the name counts as done, a failed removal of the temporary name afterward is ignored, and on a file system without hard links (link fails with EXDEV, ENOSYS, EPERM, ENOTSUP, or EOPNOTSUPP) the file is renamed instead. Mail safety difference (agent judgment): that rename never replaces an existing file, where NeoMutt's rename would and so could lose a message (mutt/file.c:350-366); on a file system with neither hard links nor an exclusive rename the delivery therefore fails, where NeoMutt's succeeds. Mail safety difference (agent judgment): the received time is set on the open temporary file before it gets its name, where NeoMutt runs utime on the final path after the rename (maildir/message.c:394-416) without checking that the file at that path is still the one it wrote, which this project's rule to revalidate local file identity before each local change forbids. Queued source changes in an mbox are staged and written in one locked rewrite of the file at sync-mailbox or when leaving the mailbox.

If the rewrite fails before it starts overwriting the file, none of the staged changes is written, the rows return to their listed state, and the failure is reported.

If the rewrite fails before it starts overwriting the file, none of the staged changes is written, the rows return to their listed state, and the failure is reported. If it fails while overwriting, the mailbox may be damaged, and a copy of the mailbox from the first changed message to the end is saved to a file. The message line shows Unable to write PATH, as NeoMutt's does, and the log names the file. Sync removes the source mbox record or, when maildir_trash=no, the source Maildir file; configured Trash may hold a copy. Keep backups.

Commands act on the selected message, or on every visible tagged message after ;.

Commands act on the selected message, or on every visible tagged message after ;. Tagged operations validate every loaded target, then run in display order. An IMAP write runs on the selected mailbox, requires its UIDVALIDITY unchanged, and sends the whole batch; a local write rechecks each file's identity. Nothing is retried automatically. SMTP sending and Sent-copy filing are independent of these operations.

Commands 3

addition G checks an open IMAP mailbox immediately and keeps queued changes pending.

Mutt Desktop-only (owner 2026-10-23; first version 0.2.1): G (fetch-mail) in an open IMAP message list sends a forced NOOP, fetches mail the server announces, and leaves queued flags and deletions pending. NeoMutt uses the separate imap-fetch-mail command for that check (index/functions.c:2523-2531); its G always runs POP fetch-mail (index/functions.c:3056-3062). Mutt Desktop keeps POP G behavior when a non-IMAP mailbox is open. $ writes queued changes.

Security exception for ~user paths: NeoMutt truncates usernames over 127 bytes before lookup, which can select another user's home directory.

Security exception for ~user paths: NeoMutt truncates usernames over 127 bytes before lookup, which can select another user's home directory. Mutt Desktop looks up the full name and leaves an unknown name unchanged.

addition Preview builds show their UTC build time with the version.

Owner addition (0.2.1): show-version and About Mutt Desktop show the app version and the preview's UTC build time. Stable builds show the version alone. The time identifies a specific preview even when several builds share a version number.

Supported 1

mixed Supported reference table
NeoMutt command Status Mutt Desktop behavior
ignore, unignore ✅ Parsed for message-header display. Matching is a prefix match that ignores ASCII case. For received headers, including the mbox From line, it matches the whole original line as mutt_copy_hdr does. When the original header is unavailable, it matches the line reconstructed from the stored name and value. ignore * hides all headers except unignore matches.
spam, nospam ✅ Case-insensitive POSIX regex rules match each unfolded header line when a mailbox reads it. The first spam PATTERN TEMPLATE rule supplies a tag; %N in its template inserts capture N. nospam PATTERN removes that spam rule or suppresses matching lines, nospam * clears both lists, and spam PATTERN removes a suppression rule. The tag is available to ~H. Difference (origin: agent judgment for security): the combined tag stops at 64 KiB, where NeoMutt keeps appending matches from headers.

Partial support 3

mixed Partial support reference table
NeoMutt command Status Mutt Desktop behavior
score, unscore ⚠️ Ordered score rules run when a mailbox opens and after an entered command; ~n matches their result. Exact and ±9999 values stop evaluation, and thresholds set delete, read, then flag without clearing earlier flags. Score rules compile the supported tag-pattern operators. As in NeoMutt, a score pattern refuses body, whole-message, header, and MIME-type terms with ~: not supported in this mode. NeoMutt passes no mailbox when scoring: server-search terms do not match, and ~X counts zero parts. NeoMutt bug difference (origin: agent judgment): an invalid value for a new rule is rejected before it can leave a dangling rule pointer.
$name and ${name} option references ⚠️ $name and ${name} read a supported option or a my_ variable set earlier, else a nonempty variable of the environment the app started with, else stay as written; no shell runs. A NeoMutt option that Mutt Desktop does not retain has no value here, so its $name falls to the environment or stays as written, where NeoMutt gives its default. A value that includes a secret option's value is refused for a non-secret option, a my_muttdesktop_ option that has a validator, a folder-hook pattern, a source path, and a notice; secret options and other my_ variables keep it. Where such a value or a backtick's output is read as further words (set imap_pass=cmd`` with output foo bar), NeoMutt names the trailing word in its error; Mutt Desktop shows (secret) instead, a deliberate difference for passwords.
alias, reverse_alias ⚠️ Aliases are parsed with NeoMutt's whitespace-splitting address parser, expanded recursively to at most 32 nested aliases, 1,024 addresses, and 128 KiB of address text, and used in compose addresses. As in NeoMutt, an alias repeated in one address field is skipped and later duplicate mailboxes are removed, while the first address is kept. A quoted personal name keeps its quotes, so a comma inside it does not split the address. An address group, label: a, b;, expands to its members, and the label is not sent. reverse_alias=yes shows the personal name of the matching alias address. Editor completion can open the alias menu; its tagging, sorting, search, and deletion run before the editor resumes. Query results can create an alias in memory and append it to alias_file. Security differences: new alias files use mode 0600 rather than the process umask, and alias lines with embedded line breaks or NUL are rejected before appending. unalias is not supported.
group, ungroup ⚠️ Named address and regular-expression groups are retained for alias and query menu patterns. -group on an alias, alternates, or list command adds its addresses or pattern to the named group. Named groups also match message-pattern fields through % operators.
alternates, unalternates ⚠️ Parsed for reply identity matching and the index_format fields that depend on the user's identity. Patterns use NeoMutt's case-insensitive POSIX extended regular expressions. They match any parsed mailbox, such as me@localhost, and never an address longer than 254 bytes. -group also retains the pattern for alias and query menu group matches.
attachments, unattachments ⚠️ Fill and empty NeoMutt's four lists (+A, -A, +I, -I, each a prefix of attachment or inline), with any, none, a type without a subtype (read as TYPE/unknown), and a case-insensitive minor-type regular expression, as parse_attach_list reads them; unattachments * empties all four. %X and ~X count with them and count_alternatives, 0 while every list is empty. Differences: attachments ? prints nothing, because there is no terminal to print the lists to; after a failed %X message open, Mutt Desktop keeps the displayed zero for this mailbox session, while NeoMutt retries on each redraw; a failed ~X open stays a nonmatch for the session, while NeoMutt retries on each pattern evaluation (security, decided with /principal:decide).
color index, uncolor index ⚠️ color index [ATTRIBUTE...] FOREGROUND BACKGROUND [PATTERN] colors index rows that match the pattern, as NeoMutt does: each matching line, in config order, sets the colors it does not leave default, and attributes add up. A missing pattern matches every message, a pattern already listed takes the new colors in its place, and uncolor index PATTERN..., uncolor index, uncolor index *, and uncolor * remove lines. Colors are default, the eight named colors, colorNNN, and #RRGGBB, which needs color_directcolor; as in NeoMutt, a malformed #RRGGBB or colorNNN reports color not supported by term and any other unknown word no such color. As in NeoMutt, a bright foreground draws bold, an alert color draws bold and blinking, and light or a bright background chooses the lighter color. The color pairs follow NeoMutt, including the xterm cube and gray ramp for colorNNN above 15. Owner visual difference (2026-10-15): named colors draw with macOS system colors, and every colored row background uses an 18% tint to keep the selected-row highlight visible. Explicit colorNNN and #RRGGBB retain their RGB values; default keeps the index's own text and background colors. While the index is the active menu, the selected row keeps the system highlight and text color instead of color index colors; color index attributes still apply. Difference: NeoMutt draws its cursor row as the row's colors overlaid with indicator, reverse video by default, so a colored row keeps its colors there, reversed. bold, italic, and underline are drawn, and reverse and standout swap the foreground and background, a default side included. Patterns are those tag-pattern supports, compiled once when the line is read; as in NeoMutt, startup ~m fails with No mailbox is open. A runtime color index command compiles ~m against the open index view, as NeoMutt does; startup config and folder hooks have no index view. A line with a pattern that does not compile, an unknown color, or extra words is reported and skipped. For large messages, body-based index colors resolve without pausing message-list keys.
auto_view, unauto_view, alternative_order, unalternative_order ⚠️ Parsed into NeoMutt's AutoViewList and AlternativeOrderList, with parse_stailq and parse_unstailq (a repeated word is not added twice, * clears). is_autoview matches a type exactly or as type/*, and alternative_handler prefers the types of alternative_order in order. Mutt Desktop runs no mailcap command, which AGENTS.md forbids for security, so only text/html is autoviewed, by the app's own renderer; without auto_view text/html (or implicit_auto_view) an HTML part is unsupported, as in NeoMutt without a mailcap entry.
bind and unbind ⚠️ index, generic, pager, compose, browser, attach, postpone, editor, alias, query, and dialog are parsed for supported functions. Mail and compose prompts use configured editor bindings in the focused text field; their nested menus read their own maps. A function NeoMutt does not offer in that menu leaves the previous binding intact; a notice follows when that menu is last in a comma-separated list. As in NeoMutt, a function the menu offers but Mutt Desktop does not run still replaces the key's binding, and the key then reports Key is not bound. The pager reads only pager bindings, as NeoMutt does. Other menus are retained but have no effect.
folder-hook ⚠️ Ordered folder hooks use POSIX extended regular expressions with case-sensitive matching, as in NeoMutt; invalid patterns report the platform POSIX error. A hook matches the path NeoMutt's mailbox_path gives the mailbox being entered. For a local mailbox, that is its local path. For an IMAP mailbox the account holds (a mailboxes entry, or the open mailbox), it is the account's URL with the mailbox's name, without a password, as imap_ac_add writes it. For an IMAP mailbox typed at change-folder that the account does not hold, it is the expanded answer. For a POP mailbox, it is the POP URL as written. ^ and - name the same paths. As in NeoMutt, ! negates a pattern, -noregex matches it literally, and a leading mailbox shortcut expands with its regex characters escaped; a pattern that starts with ^ is refused with current mailbox shortcut '^' is unset while the config is read, and names the entered mailbox inside a hook. An @alias pattern expands, as in NeoMutt, to the save mailbox of an alias defined earlier; an unknown alias expands to nothing and the pattern is refused. A hook stores its command text, and each time a matching mailbox opens the command runs as a config line on the current configuration, so a backtick left inside single quotes runs then, as in NeoMutt. As in NeoMutt, the change stays: nothing restores it when another folder opens, and sort-mailbox changes the same configuration (sort, or use_threads when it is set). The store and the adapters read each option they use from the current configuration when they use it; the open mailbox keeps the read_only it was opened with, and change-folder reads read_only before the hooks of the mailbox it enters run. At startup the startup mailbox's hooks run before read_only is read and before the IMAP login, as in NeoMutt; when a mailboxes entry on the account's login logged in while the config was read (see the mailboxes row), the hooks run after that login and the startup open does not log in again. As in NeoMutt, an IMAP pattern read after that login is fixed with the server's hierarchy delimiter, so on a server whose delimiter is . the pattern imaps://host/INBOX/Sent matches INBOX.Sent. The IMAP adapter reads imap_peek, mark_old, message_cache_dir, and message_cache_clean; each IMAP login reads imap_rfc5161, imap_qresync, and, when no password is held, imap_pass, as imap_login does; a failed login drops the password, so the next login reads imap_pass or asks again. The account keeps the imap_pipeline_depth its first successful login read, as NeoMutt's account data does; the local and POP adapters read their options when used. Each send reads smtp_url, smtp_user, smtp_pass, certificate_file, and allow_8bit, as mutt_smtp_send does, so a hook that changes them changes the server and login of the next send. Progress and size options, IMAP and POP socket_timeout, POP login options, and IMAP postponed use the current configuration at NeoMutt’s read points. Remaining differences: a hook that changes imap_user, folder, or spool_file does not change the IMAP account's server and user, which stay the ones read at launch (see "One IMAP server and user per account"); and 8 NeoMutt mutt_sleep calls outside folder entry do not pause for sleep_time (see the sleep_time row). After change-folder or a sidebar choice opens a mailbox, the message line is cleared after sleep_time seconds have passed since an error, as change_folder_mailbox does; the startup open does not clear it. When the path does not match, the pattern is tried on the mailbox's named-mailboxes or -label label, as in NeoMutt; a mailbox without a label matches no pattern by label, ! patterns included. At startup only a local mailbox's label is found, because NeoMutt's mailbox_find compares files. A hook that a hook adds runs later in the same walk. In a hook's mailboxes, unmailboxes, and folder-hook, ^, -, !!, and @alias name the entered mailbox, the previous mailbox, and the alias's save mailbox. As in NeoMutt, the events of a hook's push and exec are read at the first index key after the mailbox opens and the message line is cleared, a later command's events first, then the rest of a running macro, then typed keys. exec looks names up in the pager's functions when change-folder ran from the pager, else in the index's, at startup too. An unknown exec name empties every queued event and typed key before its error shows. echo shows its text, then holds keys for sleep_time seconds. A hook's mailboxes and unmailboxes change the sidebar's local and POP rows, and the entered mailbox still opens after unmailboxes ^ removed it. Difference (NeoMutt bug): exec with an unknown function in a hook shows NAME: no such function as the hook error, where NeoMutt replaces that message with an empty error (hook.c:658-661); in a config file the same exec reports a notice that names the function. A hook that fails ends the hooks after it, as in NeoMutt, and a relative source in a hook is read from the file that declared the hook. The hooks of a mailbox run once, when it opens, off the main thread; the error message of the command that failed appears on the message line as mutt_error shows it (hook.c:658-661), then the next mailbox status waits for sleep_time before replacing it. A command warning shows nothing. Keys typed while the hooks run wait until they have finished, as NeoMutt reads none during mutt_folder_hook (index/dlg_index.c:674).
account-hook ⚠️ As in NeoMutt, account-hook [!]PATTERN COMMAND stores a POSIX extended regular expression, matched case-sensitively against the account's URL as written (no mailbox shortcuts and no -noregex), and the command text. Before an account connects, the hooks whose pattern matches run in order as config lines on the current configuration, and their changes stay. They run before the IMAP account's login, with the path of the mailbox that login is for: a mailboxes entry while the config is read, else the startup mailbox, or, after a failed login, the next IMAP mailbox opened; the account keeps the imap_pipeline_depth read before the hooks ran. A local startup mailbox's sidebar login uses the configured IMAP path, and a save or copy destination can create the account. After a failed login, completion and the browser find no account. They run before each send's SMTP connection, with smtp:// or smtps://, the smtp_url user, the host, the smtp_url port, and /, and before a POP mailbox connects and before fetch-mail, with the POP account's URL; the Inbox indicators' count of a closed POP inbox runs none. No URL holds a password. The login or connection then reads the options the hooks set, such as imap_pass, smtp_user, smtp_pass, pop_user, and pop_pass. A command that fails shows its error and ends the hooks after it; a warning shows nothing. While the config is read, a hook's echo and error wait and show after the config, in order with the logins' messages. unhook account-hook removes the hooks, except from inside an account hook. A hook for the first eligible mailboxes entry changes the live muttrc: later lines see its options, and its own mailboxes commands run before the outer entry is added. Mutt Desktop defers the network login until parsing ends to enforce one IMAP server and user per account; if the account identity was unset at that entry, it also defers the hook, so later lines do not see that hook's changes. NeoMutt runs both inline while parsing. If that deferred login fails, a later entry's hook can supply credentials for its login, but its changes do not reach lines already parsed or the final configuration, and its nested mailboxes commands do not remain. Difference: a hook that changes imap_user, folder, or spool_file does not change the IMAP account (see "One IMAP server and user per account").
message-hook, unhook ⚠️ message-hook runs when display-message opens a message, the pager's message changes, the message panel is clicked, the attachment list opens, or a copy or save mailbox prompt opens: the hooks whose pattern matches run in order before that view or prompt opens, each pattern tested on the options the commands before it left, the first failing command's error shows and ends the run, and the changed options stay. For tagged copy or save, each target runs its hook before an individual append; a successful same-account IMAP copy runs only the first target hook. Reply inclusion runs the source hook after its body opens and before quoting, so settings such as indent_string affect the reply. It does not run yet at pipe, print, or forward, and never for the my_muttdesktop_autopreview panel, which NeoMutt lacks. On IMAP, =b, =B, =h, and =/ test the stored matches from the last index pattern search; a fresh mailbox has none, and a hook does not fetch message text for these terms. A message-hook command is one word, so quote a command with spaces. Simple patterns use default_hook; different commands with the same pattern run in order, and an equal command is skipped. unhook TYPE removes only that type, and unhook * removes every hook. Known inactive types remain valid names for unhook and remove nothing; charset-hook and iconv-hook are unknown hook types for unhook, as in NeoMutt.
mbox-hook, send-hook, send2-hook, reply-hook, save-hook, fcc-hook, fcc-save-hook, startup-hook, shutdown-hook, timeout-hook, append-hook, close-hook, open-hook, charset-hook, iconv-hook, index-format-hook ❌ Owner-approved temporary difference for 0.2.1 (2026-10-22): config parsing reports NAME: unsupported hook and stores nothing. Only folder-hook, account-hook, and message-hook are accepted. NeoMutt accepts these inactive types (hook.c:123-164, 166-387, 441-555, 1029-1052; compmbox/compress.c:62-66). For reverse_name, the app chooses a reply From before its recipient prompts; NeoMutt then tests that From in reply-hook and send-hook (send/send.c:2200-2216, 2290-2300). Those hooks remain rejected here, so their changes to the reply configuration cannot run.
hdr_order, unhdr_order ⚠️ Parsed for message-header display. Ordered prefix matches move before unmatched headers; the longest matching prefix wins. Standard envelope headers start in Mutt Desktop's fixed Date, From, To, Cc, Bcc, Reply-To, Subject order; unmatched custom headers retain their fetched wire order. NeoMutt can retain raw relative wire order across both groups.
lists, unlists, subscribe, unsubscribe ⚠️ lists marks known lists for list replies. subscribe marks an address as both known and subscribed; the index fields %B, %F, %K, %L, %O, %t, and %T use subscribed lists only. unsubscribe removes only the subscription, and unlists removes both. Patterns use NeoMutt's case-insensitive POSIX extended regular expressions. Index fields match any parsed mailbox, such as list@localhost, and never an address longer than 254 bytes; list-reply recognizes only deliverable list addresses. -group also retains the pattern for alias and query menu group matches. ~l and ~u match known and subscribed recipients in To and Cc. Automatic subscription inference is not implemented.
macro ⚠️ Index, pager, attachment, postponed-list, compose, browser, and editor macros execute literal keys, named keys, multi-key bindings, and implemented functions through one input queue. An index macro can continue in compose, its prompts, and a browser; queued typed keys wait behind macro input. Generic macros apply where NeoMutt retries the generic map, except in the pager. The focused editor field handles cursor movement, history search, word edits, alias and query completion, help, and redraw for typed and macro input. History, alias, query, pattern, help, and file-browser menus read their own bindings before the editor resumes. Functions the app does not implement remain unavailable. An unknown <name> following an operation stays literal. NeoMutt repeats the preceding operation in this case (key/get.c:353,388-405). Security difference: certificate and password prompts accept only terminal keys entered while visible; earlier terminal keys are discarded, and macro events wait until the prompt closes. NeoMutt's certificate reader also accepts earlier ungotten keys.
difference Nested history, alias, query, pattern, help, and file-browser menus dispatch enter-command, shell-escape, and show-version after their own bindings.

Nested history, alias, query, pattern, help, and file-browser menus dispatch enter-command, shell-escape, and show-version after their own bindings. : parses the command against the current configuration; ! opens an interactive terminal with the configured environment. A nonzero shell exit or wait_key=yes holds the terminal until a physical key is pressed, while macro input waits. show-version reports the Mutt Desktop version.

difference Security differences: ~I passes its query to external_search_command as one quoted shell argument.

Security differences: ~I passes its query to external_search_command as one quoted shell argument. NeoMutt appends it as shell text, which lets metacharacters run another command. A message ~I query omits a password from the mailbox URL passed to the command. The running notice and a command launch error omit the command text. NeoMutt can expose those secrets in process arguments or on screen (pattern/compile.c:172-195). | mailboxes, named-mailboxes, unmailboxes | ⚠️ | mailboxes retains the ordered list of local Maildir, MH, and mbox paths, mailboxes on the account's IMAP login, and pop:// and pops:// servers, each once, with any URL password kept for that server's login and never shown, resolved like the other mailbox options with + and = read against the folder set when the command runs. As in NeoMutt, a local path where no Maildir, MH, or mbox mailbox exists is refused with Unknown Mailbox: PATH, which ends the command, as is a shortcut such as ^ or - with no value; a listed local path is absolute and tidied. As in NeoMutt, a URL whose scheme no backend claims, such as foo://x, is a local path, and is refused the same way when no mailbox exists there. Unlike NeoMutt, a refused path that can hold a password shows (redacted) in place of the path: a malformed IMAP URL, a URL with a password or query, or text where a : that does not start :// comes before an @. unmailboxes removes the named mailboxes, or all of them with *; its paths expand as NeoMutt's buf_expand_path expands them, so a leading shortcut expands whatever follows it. As in NeoMutt, a local or POP path must then equal the listed text, so a relative path or an added / removes nothing. -notify, -nonotify, -poll, and -nopoll set whether the next path's new mail is announced and whether it is checked at all, as mailbox_add does; -label and the named-mailboxes label set the next mailbox's label, replacing an earlier one, and -nolabel removes it, as mailbox_add does. Folder hooks match labels (see the folder-hook row). As in NeoMutt, change-folder opens the mailbox whose label is the answer when no mailbox is at that path, a spool_file that is a label opens that mailbox at startup, status %D shows the open mailbox's label, and the browser's mailbox list describes each mailbox by its label. Unlike NeoMutt, a label that includes a password from another option is refused with its mailbox, as such a path is. Inside a folder hook, ^, -, and !! name the entered and the previous mailbox. As in NeoMutt's sidebar, the sidebar lists the mailboxes entries in command order, IMAP, local, and POP mixed; a folder imap_check_subscribed adds becomes an entry after the others, which unmailboxes removes until the next open's LSUB adds it again, as in NeoMutt; a later mailboxes or unmailboxes, typed or in a folder hook, changes the rows. As in NeoMutt, a mailbox opened without an entry, such as spool_file or a change-folder answer, has no row. As in NeoMutt, the first entry on the account's IMAP login logs in while the config is read, before the startup folder hook, with the values that the lines before it set for imap_pass, imap_pipeline_depth, imap_rfc5161, and imap_qresync; a failed login's line adds nothing, so a later line that names the same mailbox adds it with only that line's label and flags, and the next such entry, or else the startup open, logs in again. Owner-approved difference: after Esc at an IMAP password question, later logins in that account store receive no password without asking again; switching away and back permits another question. As NeoMutt queues messages while it reads the config, the logins show Connecting to and their errors only once the config is read, before the startup folder hook, and a message after an error then waits out sleep_time. As in NeoMutt, an entry read after the successful login is fixed with the server's hierarchy delimiter, so on a server whose delimiter is /, =a..b names a..b. Owner-approved difference (2026-10-20): Mutt Desktop sends LIST "" "*" after the IMAP login, before Reading, only to choose each listed IMAP row's icon (see "Native sidebar"); a refused LIST leaves plain icons, and the startup mailbox still opens. After a local startup mailbox opens, that login and LIST run only when mailboxes names an IMAP mailbox. Unlike NeoMutt, Mutt Desktop drops news://, snews://, and notmuch:// mailboxes and mailboxes on other IMAP logins (see "One IMAP server and user per account"). virtual-mailboxes is ignored. | | reset, queries, set &name, +=, and -= | ⚠️ | reset name restores every supported option type to its NeoMutt default; reset all restores all supported option values without removing mailbox declarations or key bindings. A query (set name?, or the bare name of a number or string option) prints nothing and, as in NeoMutt, ends that set command; the rest of the line is then read as another command, which is usually an unknown one. += and -= are read; for a supported option they report a notice and change nothing. | | set name=value, set name = value, unset name, toggle name | ⚠️ | Parsed. Outside single quotes, NeoMutt's \c, \e, \f, \n, \r, \t, and three-digit octal escapes produce what they name; \c and octal escapes produce bytes, read as UTF-8, and invalid UTF-8 becomes U+FFFD. A backslash at the end of a value is dropped, as NeoMutt's set drops it. A line ending in a backslash continues on the next line, and a continued line that the file ends is dropped, as in NeoMutt. The first option that fails ends the command, and an option NeoMutt does not know is an error, as in NeoMutt. Strings reject toggle, set no..., and set inv...; nullable strings become empty on unset, while nonempty and sort options reject it and keep the old value. Supported booleans and quadoptions accept NeoMutt's set, unset, toggle, set no..., and set inv... forms, and booleans accept NeoMutt's yes, no, y, n, true, false, on, off, 1, and 0 in any case. Supported number options take a whole number from 0 to 32767 after any leading spaces; score_threshold_delete, score_threshold_flag, score_threshold_read, sidebar_component_depth, and socket_timeout also take negative numbers down to -32768, as in NeoMutt. An empty value is 0. unset and set no… set 0, and toggle and set inv… switch between 0 and the last other value, as in NeoMutt. set name =value assigns, as in NeoMutt. Only the options marked ✅ or ⚠️ in the option tables above affect the app. | | setenv, unsetenv | ⚠️ | Values, including backtick output, change the environment that backtick commands and POP token commands receive. As in NeoMutt they do not change what $NAME reads. Queries print nothing. setenv NAME $imap_pass is allowed, as in NeoMutt: the value reaches only the programs the config starts and is never shown. A Finder or Dock launch starts from the login shell's environment ($SHELL -l -c 'env -0', read once), so commands such as pass are found. | | Backticks | ⚠️ | Outside single quotes, `COMMAND` runs /bin/sh -c COMMAND with the environment the config's setenv and unsetenv leave, and the first line it prints, without its line ending, takes its place, as NeoMutt's parse_extract_token does. Inside double quotes the line joins the word as it is; outside quotes it is read again as config text, so it can hold several words, a ;, a #, or more backticks. In set and source, $name inside the backticks becomes that option's value first. A backslash or single quotes keep a backtick literal. An unmatched backtick, or a command that cannot start, ends the word, and the text after it is read as the next words; the exit status is ignored. A backtick or $name that expands a secret option cannot reach a non-secret option, a source path, or a notice. Backtick commands receive saved account variables. Their output can set supported options and setenv values, as in NeoMutt. Mutt Desktop redacts it in error messages and sourced-file paths. Direct $name expansion keeps NeoMutt behavior. Difference (owner, 2026-10-19): a backtick command stops after 30 seconds, its first line stops after 1 MiB, and one config or pattern input runs at most 32 backticks. NeoMutt sets none of these limits. | | ifdef, ifndef, finish | ✅ | As in NeoMutt, ifdef SYMBOL COMMAND runs the command when the symbol is defined and ifndef when it is not; finish stops reading the current file. A symbol is defined when NeoMutt 2026-06-16 knows it as a variable, function, command, or color object, when it names an environment variable or a set my_ variable, or for the hcache feature. Mutt Desktop's own options and my-muttdesktop-* functions are defined too, which lets one muttrc serve both programs: ifdef my-muttdesktop-load-remote-content "source ~/.config/mutt/muttdesktop.rc" reads Mutt Desktop-only lines that NeoMutt skips, and ifndef my-muttdesktop-load-remote-content finish at the top of such a file stops NeoMutt there. | | source <file> | ⚠️ | Each path in the command is read in turn, and a file that fails or reports a problem ends the command. Relative paths, mailbox shortcuts such as = and ~ (expanded as buf_expand_path expands them), $NAME, ${NAME}, later repeat sources, and source-cycle notices are handled. Variables come from the options and the app environment. Source input is limited to 32 nested files, 256 loads, 1 MiB per file, and 4 MiB total. Security difference: when the expansion holds a URL password or a saved account value, a failed source reports Could not read sourced config file. without the path NeoMutt prints. |

Not supported yet 1

unsupported Not supported yet reference table
NeoMutt command Status Mutt Desktop behavior
conditionals, color and uncolor for objects other than index, mono, mailboxes, and other commands ❌ Ignored.
Pipe sources ❌ Ignored. Mutt Desktop does not execute config commands.

Index bindings 4

mixed Index bindings reference table
NeoMutt function Mutt Desktop action
next-entry Select the next message. The default key in the index and pager is J. At the last message, Mutt Desktop reports You are on the last message, as NeoMutt does.
next-line, previous-line In the index and the postponed list, the generic keys > and < scroll the list one line and keep the selection on screen, as NeoMutt's menu does; at the end they report You can't scroll down farther or You can't scroll up farther. The pager does not bind > or <; there Return runs next-line and Backspace runs previous-line, which scroll the message.
next-undeleted Selects the next message not marked deleted. The default keys are j and Down, and in the pager also Right. At the last message it reports You are on the last message; when every later message is marked deleted, it reports No undeleted messages and stays, as NeoMutt does.
previous-entry Select the previous message. The default key in the index and pager is K. At the first message, Mutt Desktop reports You are on the first message.
previous-undeleted Selects the previous message not marked deleted. The default keys are k and Up, and in the pager also Left. At the first message it reports You are on the first message; when every earlier message is marked deleted, it reports No undeleted messages and stays.
sidebar-toggle-visible Shows or hides the native sidebar in the index and pager. Ctrl-F is the Mutt Desktop default (owner decision, 2026-10-19); NeoMutt uses Ctrl-F for forget-passphrase.
display-message Open the selected message in the pager. The default keys are Return, KeypadEnter, and Space. As in NeoMutt, a message is shown only in the pager: in the index the message panel is blank apart from a dim hint for this key, such as [<Enter>] to open the selected message, unless my_muttdesktop_autopreview=yes. With pager_read_delay=0, the pager marks a message read once its body loads; a positive value waits that many seconds while the message remains displayed. The same delay applies to the optional index preview. Read changes queue like toggle-new; a read-only mailbox stays unread, and a body loaded during a mailbox write is marked read after the write if it is still displayed.
view-attachments Opens the selected message, then shows its full MIME tree in preorder: containers, body parts, and named inline CID images. The default key is v. The menu opens without another part fetch; keys typed during the message open go to the menu afterward. Selecting another message closes it.
mail Open composer.
compose-to-sender Supported in index and pager when configured. Starts a new message to every mailbox in the source From, ignores Reply-To, and leaves subject and reply-thread headers empty, then asks To:, Cc: and Bcc: per ask_cc and ask_bcc, and Subject:, as NeoMutt's edit_envelope does, unless auto_edit and edit_headers are both set; under fast_reply, a To: that the source From already filled is not asked. It skips postponed-draft recall. With tag-prefix, it collects visible tagged messages in display order and deduplicates mailboxes case-insensitively.
reply The default key is r. Replies to Reply-To or From, subject to reply_to, reply_self, me_too, and alternates. Then asks To:, Cc: and Bcc: per ask_cc and ask_bcc, and Subject: (starting from Re: …) as NeoMutt's edit_envelope does, unless fast_reply is set or auto_edit and edit_headers both are.
group-reply The default key is g. Keeps the primary reply target in To and adds the original To and Cc recipients to Cc, subject to honor_followup_to and identity removal.
list-reply The default key is L. Uses standard List-Post: <mailto:…> recipients plus addresses recognized by lists or subscribe. A message without a recognized list reports No mailing lists found. Full mailto templates and NeoMutt address groups are not supported.
forward-message The default key is f in the index and pager. Forwards the current message, or every tagged message that the limit shows, in display order, after ;; a target outside the open mailbox refuses the command before any prompt. Mutt Desktop builds the subject from forward_format for the first message, and asks To, Cc, and Bcc per ask_cc and ask_bcc, then Subject with the forward subject filled in, unless auto_edit and edit_headers are both set. It then asks Forward as attachment? per mime_forward: yes attaches each message as an inline message/rfc822 part; otherwise the body is, for each message, forward_attribution_intro, the original header lines (weeded and reordered under weed), the decoded text, and forward_attribution_trailer, and forward_attachments can add the parts that cannot be decoded, asking once and reading and copying each message before the next. The signature follows; forward_quote prefixes the copied lines with indent_string. forward_edit asks Edit forwarded message? before the editor opens, and an answer other than yes opens the compose review directly. abort_unmodified does not apply, and the original is not marked replied. With forward_references the forward carries In-Reply-To and References, and several tagged messages drop References. Mutt Desktop reads a message only after the prompts and the mime_forward answer, as NeoMutt does, and a message it cannot read is left out after the error shows, except that a message inline_forward_attachments cannot open ends the forward. Difference, recorded under the project's exception for an obvious NeoMutt bug (origin: agent judgment): with mime_forward, when a message that cannot be read comes before one that can, NeoMutt's attach loop sets the later message as the whole body and drops the text the user writes (send/send.c:1203-1212), against its own walk to the end of the body and its comment "don't kill command-line attachments" (send/send.c:1196-1197, 2156); Mutt Desktop keeps the text and attaches the later message. Differs for security: Bcc and Resent-Bcc are never forwarded; NeoMutt keeps them. Differs for security: a carriage return that no line feed follows, or a line over 998 bytes, converts a forwarded message, or an attached message/* or multipart/* file, to 7-bit, parts nested past 50 levels, counting nested messages and multiparts together, stay as they are, a multipart with an unusable boundary is converted as an attachment encoded as base64, long header lines are cut, a converted result that is still unsafe is sent as base64 leaves or fails, and SMTP refuses a lone carriage return. Differs for security: the plain text of the forwarded headers loses controls and bidi characters. Differences: see forward_decode, mime_forward, and forward_attachments.
copy-message The default key is C. Prompts for a mailbox, shows Copying to PATH..., and copies immediately: IMAP COPY within the account, or streamed source bytes and APPEND across backends, keeping flags and received date. A missing mailbox asks under confirm_create; Return on an empty line copies nothing. After ;, tagged visible rows are validated, then copied in display order; a local mbox destination stays locked through the batch. Mail safety difference: NeoMutt closes a second descriptor when reading a source from that same mbox (mbox/mbox.c:1473-1484, 1519-1525), releasing its process-wide fcntl lock; Mutt Desktop keeps the lock so another writer cannot interleave or damage records. Within the IMAP account they go in one UID COPY for each set of sorted UIDs, split at 8192 bytes. Queued read and flag changes go with the copy: for each changed message a same-account IMAP copy first stores its whole flag list (UID STORE UID FLAGS.SILENT), as NeoMutt's imap_sync_message_for_copy does, and a refused store asks Continue?. Differences: NeoMutt joins its system flags and keywords without a space, so it sends an invalid flag and the flag sync of that copy fails; Mutt Desktop sends a valid list. NeoMutt's pre-copy STORE leaves its core server flag record stale despite its comment that the server flags are updated; a later reverse toggle can therefore send no clearing STORE. Mutt Desktop updates that record so the later toggle is stored (NeoMutt bug; .architecture/history/2026-10-imap-peek.md). After an IMAP copy the source mailbox is not listed again, as in NeoMutt, so a server that removes the source after COPY shows the message until the next mailbox check. A failed copy shows Error copying message (or the tagged or saving form), and a failed IMAP sync shows Error saving flags; the server's reason goes to the log. Tab completes the mailbox as in change-folder. The answer is read as NeoMutt's mutt_save_message reads it, after the prompt ends, so a refused answer such as a POP mailbox ends the prompt and shows its error on the message line. . repeats the last answer. A leading shortcut expands whatever follows it, as buf_expand_path does, so -x names the path of the mailbox open before, followed by x. @alias names = and the alias's first address, as mutt_default_save gives it when no save hook applies; Mutt Desktop does not support save hooks.
delete-message Queues source changes until sync-mailbox or leaving the mailbox. With a supported trash option it copies IMAP messages before marking sources \Deleted; local and cross-backend moves also copy before removing the source. Deleting within Trash purges the message. Mail safety difference (origin: agent judgment): when the open mailbox path is a link to Trash, NeoMutt appends the deleted messages to that file, as trash_append checks the open mailbox with lstat (mx.c:535-539); Mutt Desktop deletes them in place. With or without trash, IMAP deletion marks the target \Deleted and uses one ordinary mailbox EXPUNGE at sync, without requiring UIDPLUS. That can also remove other messages already marked \Deleted on the server, as in NeoMutt. A local message is removed by the Maildir or mbox adapter at sync, or flagged T under maildir_trash. After ;, it applies to every tagged visible row. Deletions queue alongside other changes, and deleting a message already marked D changes nothing. A mailbox whose MYRIGHTS lack DELETE refuses it with Can't delete message: Operation not permitted by ACL.
purge-message Unsupported because NeoMutt's bypass-Trash behavior must remain distinct from delete-message. As in NeoMutt, bind accepts it in the index and pager; the key then reports Key is not bound.
undelete-message The default key is u in the index and pager. Clears a queued deletion or queues removal of a loaded D, Maildir T, or IMAP \Deleted mark, then moves to the next message; at the last message it stays. The loaded mark is cleared on sync or mailbox close. After resolve advances past a deletion, select the deleted message before using it. It does not revert toggle-new. A mailbox whose MYRIGHTS lack DELETE refuses it with Can't undelete message: Operation not permitted by ACL.
save-message The default key is s. Return on an empty line closes the prompt and saves nothing. It copies as copy-message does before marking the source D for deletion at sync, including queued read and flag changes. A missing destination is created after confirm_create, when enabled; local creation uses mbox_type. Tagged visible rows are copied as copy-message copies them: within the IMAP account, one UID COPY for each set of UIDs. A queued trash move for the saved message becomes a deletion. A mailbox whose MYRIGHTS lack DELETE keeps the source unmarked, as mutt_set_flag leaves it.
sort-mailbox, sort-reverse The default keys are o and O in the index and pager. They open NeoMutt's one-key sort chooser; Return or a typed Ctrl-G cancels it, and Escape does nothing. As in NeoMutt, a macro's Ctrl-G leaves it open, and a macro's <function> sorts by date. In the mailbox browser's sort question, a macro's Ctrl-G also leaves it open, and a macro's <function> keeps the sort and selects the default entry. Supported choices sort by date, received date, alias-aware From and To, reply-prefix-normalized Subject, score, threads, and mailbox order in normal or reverse order. date-sent and mailbox-order config aliases are accepted. Size, spam, and label choices report that they are not supported. Empty subjects and subjects containing only reply prefixes compare by sent date before sort_aux. The choice is written to sort, preserving an existing last- modifier for a non-thread choice, or to use_threads when threads are chosen while it is set, as mutt_select_sort (external.c:476-572) does, and it stays until a folder-hook or another sort-mailbox changes it.
quit The default key is q in the index and Q in the pager. Asks Quit Mutt Desktop? under quit, then leaves the mailbox as change-folder does, writing its queued changes, and quits. Cmd-Q does the same without the quit question; it cancels an open text prompt, and while another question is open it reports Answer the open question before quitting. While a draft is open, or once one starts during the write, Mutt Desktop reports Finish the current draft before quitting and stays; NeoMutt's composer owns the screen until it is done.
exit In the index, the default key is x. Asks Exit Mutt Desktop without saving? under quit, then quits without writing queued changes. In the pager, exit returns to the index.
sync-mailbox Asks Purge N deleted messages? under delete while messages are marked deleted; Ctrl-G there writes nothing. Then writes the queue as NeoMutt does. An IMAP mailbox gets UID COPY of the messages to trash, UID STORE +FLAGS.SILENT (\Deleted) for the deletions (Marking N messages deleted...), +FLAGS.SILENT and -FLAGS.SILENT stores for \Deleted, \Flagged, Old, \Seen, and \Answered in that order, and EXPUNGE (Expunging messages from server...), each over sorted UID sets split at 8192 bytes, then shows Mailbox checkpointed or N kept, N deleted and does not list the mailbox again. Of the flags, only \Flagged, Old, and \Answered are skipped when the mailbox's PERMANENTFLAGS omit them. A failure shows Error saving flags and keeps every change queued. Other mailboxes apply the changes in turn and an mbox's staged changes become permanent in one rewrite. A Maildir or mbox is not read again afterward, as in NeoMutt (the rows are updated; a POP mailbox still lists again), and a failed write shows Unable to write PATH. An mbox that grew or changed since it was read is not written: after Writing PATH... the sync reads only the appended messages, or the whole mailbox when it changed otherwise, keeps the changes queued, and shows N kept, N deleted, as mbox_mbox_sync does. NeoMutt then unlinks the mbox when every listed message is marked deleted, unless it is the spool or save_empty is set (mx.c:1007-1014). After the check, that happens when the appended bytes parse to no message or every reread message is marked deleted, and the unlink also removes those appended bytes; Mutt Desktop leaves the file (Mail safety, agent judgment). NeoMutt also copies the messages queued for Trash before that check (trash_append, mx.c:980-985) and marks nothing, so the next sync copies them again and Trash holds two copies of each; Mutt Desktop copies none until the write, which finishes every Trash copy before it marks the sources deleted (Mail safety, agent judgment). NeoMutt holds one exclusive lock across the check and the write (mbox/mbox.c:966, 1103); Mutt Desktop's check takes a shared lock and its write takes its own exclusive lock, under which it checks each record again (agent judgment). When the check fails to read the mailbox, NeoMutt shows Mailbox was corrupted, closes the mailbox, and ends with Unable to write PATH (mbox/mbox.c:1050-1057, 1118-1121); Mutt Desktop shows the read's error and keeps the mailbox (agent judgment). No result is retried automatically. The default key is $. Keys typed while it runs wait and run afterward. During an IMAP write, Ctrl-C drops the connection at once over TLS. A plaintext connection drops with the next data and shows Connection to HOST has been aborted. A local write finishes despite Ctrl-C: NeoMutt blocks signals in mbox_mbox_sync, and a Maildir write does not check the interrupt. The interrupt then stops the next Maildir scan or plaintext IMAP read unless a key is read first. Mailbox checks continue while changes are queued. With ACL, MYRIGHTS is asked before the SELECT and gates each flag store, the \Deleted pass and EXPUNGE; a mailbox without the DELETE right marks and expunges nothing, so its deleted rows stay listed, marked deleted, and one that grants none of DELETE, SEEN, WRITE, and INSERT opens read-only. For each changed IMAP message, sync compares all five local flags with the latest server report and stores each difference the mailbox's PERMANENTFLAGS (else FLAGS) can store. Toggling an IMAP flag back removes its STORE but keeps the message changed until a successful sync, so the sync still checks the selected mailbox. FLAGS in a body-fetch reply are accepted according to that changed state when each FLAGS item is parsed; a later local flag change does not erase the accepted server flags or lose the local change. A failed EXPUNGE shows imap_sync_mailbox: EXPUNGE failed with the server's reply, and rows are removed only after the server answers it OK, namely those its EXPUNGE replies name. A UID COPY to trash that the server refuses is appended message by message, as trash_append does. After a lost connection Mutt Desktop logs in again at once, reads the mailbox again, and discards the queued changes, as described under Mailbox safety; the write that was lost is not sent again. A local write that may have written shows only Unable to write PATH, as NeoMutt does; the adapter's words, such as the file holding unwritten mbox messages, go to the log.
fetch-mail The default key is G in the index; NeoMutt's pager has no fetch-mail. In an open IMAP message list, it forces a check (extension). Otherwise, as NeoMutt's pop_fetch_mail does, it retrieves the messages on the pop_host server, or under pop_last those after the number LAST returns, into spool_file. It shows Checking for new messages..., then opens the spool as mx_mbox_open does: Reading PATH..., then the read's progress as on an index open, PATH is not a mailbox for a missing path or a file that is not a mailbox, and no message for an empty spool_file; a failed IMAP spool open shows only imap_mbox_open's text, such as Error opening mailbox after a failed header download. In these messages and in Writing PATH..., PATH is the spool's full mailbox path, as NeoMutt's mailbox_path gives it. It then asks Delete messages from server? under pop_delete and shows Reading new messages (N bytes)... with a count after each message. An empty server reports No new mail in POP mailbox. A write failure reports Error while writing mailbox and sends RSET so the server deletes nothing; a spool that cannot take a new message, such as a POP spool, reports it before any RETR and sends no RSET. A lost connection reports Server closed connection. A refused QUIT after DELE reports that server deletion was not confirmed, so saved messages may be fetched again. A STAT count above 500,000 or a LAST number outside the message list is rejected before the spool opens. Login and TLS follow the pop_* rows: a pop:// server must accept STLS. Last, it closes the spool as mx_mbox_close does, before RSET and QUIT: with move set and read messages in the spool, it asks Move N read messages to MBOX?; it asks Purge N deleted messages? under delete when the spool has messages marked deleted, marks new messages old under mark_old, moves (one UID COPY from an IMAP spool to an IMAP mbox), and writes, then shows Mailbox is unchanged or N kept, N moved, N deleted. A spool open in the index is closed the same way, with its queued changes, and stays open; NeoMutt's reopen of it also ends a read-only open. An mbox spool grew during the fetch, so, as NeoMutt's sync stops on new mail there, the moves and Trash copies are made, their deletions and the old marks stay queued, and Writing PATH... is the last message. New messages in a spool that is not open show at the next mailbox check, as in NeoMutt. While it runs, Mutt Desktop does not quit, and keys pressed go to its next question or prompt, then to the index after it ends, as NeoMutt reads them from the terminal. As NeoMutt keeps an mbox spool open for the whole fetch, a different file at that path before a write is an error. An mbox spool receives NeoMutt's record: a From_ line naming $USER, the retrieved lines, and a blank line; a $USER with whitespace is written as MAILER-DAEMON so the line reads back. A failed flag store in the close of an IMAP spool asks Error saving flags. Close anyway?. Difference, recorded under the project's exception for an obvious NeoMutt bug (origin: agent judgment): when the close of an IMAP spool that is not open in the index fails, Mutt Desktop selects the index's mailbox again without CLOSE, where NeoMutt leaves the spool selected while the index shows another mailbox (mx.c:598-880; imap/imap.c:2346-2378). Differences: each message is written whole after its RETR ends, so a lost connection or a refused RETR leaves no partial message, where NeoMutt leaves a From_ line and the partial bytes in an mbox spool; a body line that would start another mbox message, or a first line that is a From_ line, makes Mutt Desktop add Content-Length and Lines so the message reads back whole, where NeoMutt writes it unchanged.
edit-or-view-raw-message, edit-raw-message, edit, view-raw-message The default key for edit-or-view-raw-message is e in the index and pager; edit is a synonym of edit-raw-message, which with view-raw-message has no default key, as in NeoMutt. On IMAP, Mutt Desktop shows Fetching message... for a message not in message_cache_dir, as imap_msg_open does (a local read shows nothing), reads the whole message with BODY.PEEK[] on IMAP, without marking it read (BODY[] with imap_peek unset, which marks it read), or from the local file, and opens it in embedded Neovim in a separate window that closes when Neovim exits. When Neovim cannot run or exits with an error, it shows Error running "COMMAND", where COMMAND is editor (nvim when unset or not a Neovim form) followed by the file's quoted path, and goes on to check the file, as NeoMutt's mutt_edit_file does. A file whose modification time cannot be read or set before the editor opens is kept, with the system error and Error. Preserving temporary file: PATH. edit-or-view-raw-message edits where Mutt Desktop can write and views a read-only mailbox. A viewed source is read-only, and a change to it reports Message of read-only mailbox modified! Ignoring changes. An edited source whose file was not written reports Message not modified, and an emptied one Message file is empty. Otherwise Mutt Desktop appends it to the same mailbox at once, with the original's flagged and replied state and received date, after checking that the original is still there; it then marks the original read and marks it deleted for purge unless flag_safe blocks deletion. It untags the original only when delete_untag=yes. The new copy joins the index when the mailbox check receives it. With ;, each tagged message opens in turn. A failed append shows the reason as an error, then Error. Preserving temporary file: PATH, keeps the file, and stops; Mutt Desktop removes the file after a day. An IMAP APPEND the server refuses shows IMAP command failed: LINE, then a NO's text as the error, or nothing for a BAD, as NeoMutt's imap_append_message does. A local copy that fails to write shows NeoMutt's text for the format: Can't write message: … for mbox, or Could not flush message to disk: …, maildir_commit_message(): unable to set time on file: …, or the mailbox path with the system error for Maildir. After a failed write that shows one of these texts, or a copy that may have reached the mailbox, the mailbox is checked at once, as in NeoMutt. The editor source is a temporary mbox message with a From_ line and current status headers. The edited copy drops stale Content-Length and Lines fields. It retains edited Status and X-Status fields in mbox, including the read state, and drops them outside mbox, where the new copy arrives unread. It preserves body bytes; IMAP APPEND converts LF to CRLF on the wire. When deletion is allowed, sync purges the original without copying it to Trash. A viewed source that is emptied reports Message file is empty, as NeoMutt checks that first. While a source is open, sync-mailbox, changing mailboxes, and quitting report Finish editing the message first. A source whose declared size exceeds 32 MiB is refused before it downloads. On IMAP, SwiftMail fetches the whole message in one command, which fails only after socket_timeout seconds (default 30) pass without a byte read or written. An empty answer from the server opens nothing.
change-folder, change-folder-readonly The default keys are c and Esc then c (NeoMutt's Alt-c) in the index and pager. Opens the mailbox command line; Return on an empty line closes it, as in NeoMutt. change-folder-readonly marks only the mailbox opened by that command read-only. As in NeoMutt, from the start of a change-folder or a sidebar choice until the index draws the entered mailbox, the index, the status bar, and the sidebar keep the screen of the mailbox being left as it was last drawn, so a message the close purges stays in the index. The folder browser opened with ? stays in the message panel when the mailbox is picked there. Owner difference (2026-10-21): a pager shown before the change clears at once. A question while the mailbox closes redraws the window as it is at that moment. After the close, a prompt or question draws the index with no rows until the entered mailbox has opened, and with its rows after that; the message panel stays blank unless the folder browser is open. Differences (origin: agent judgment): a window resize during the change leaves the rows drawn, where NeoMutt clears them at its next progress update; at a prompt before the entered mailbox has opened, the status bar keeps its last line, where NeoMutt recalculates status_format with the mailbox being left closed and no view. Mutt Desktop-only (owner-approved 2026-10-20): the held rows are dimmed, and the window title and the sidebar's selection move to the entered mailbox at once, so the sidebar shows no selected row when its held list does not include the entered mailbox. Mailbox shortcuts expand as NeoMutt's mx_path_canon expands them: + and = under folder, and, before a / or the end, ! for spool_file, !! and - for the mailbox open before, ^ for the open mailbox, < for record, > for mbox, and ~ for the home directory; ~user is probed as written, as in NeoMutt. Tab completes the text before the cursor as NeoMutt's mutt_complete does: a local path from its directory (= and + under folder, ! under spool_file, other directories expanded as buf_expand_path expands them, with -, ^, !!, ~user, and @alias), adding / after a unique directory and stopping at the common prefix of several matches; an IMAP path from LIST "" "NAME%" on the account, written with + under an IMAP folder; an IMAP URL for another server from the mailboxes list. A Tab on an empty or unchanged line opens the folder browser (see Mailbox-browser bindings), and ? as the line's first key opens it on the mailbox list; the prompt reads Open mailbox ('?' for list): until the first key, as NeoMutt's mw_enter_fname does. Choosing a mailbox there opens it; leaving the browser after a Tab returns to the line, and after ? ends the prompt. A Tab that matches nothing leaves the line unchanged without NeoMutt's beep. Return opens a listed mailbox, or a local path where NeoMutt's mx_path_probe finds a Maildir or mbox mailbox; the probe runs before the open mailbox closes. Any other local path opens the mailbox whose label is the answer after shortcut expansion; without one the prompt ends and the line reports PATH is not a mailbox, where PATH is that answer, and the open mailbox stays open, as NeoMutt's change_folder_string does. An IMAP name that matches no listed folder is opened too, as imap_path_probe claims every IMAP path; a SELECT or EXAMINE the server refuses shows IMAP command failed: LINE; a NO then shows the server's answer as an error, even when it is empty, and a BAD shows no error of its own, as in NeoMutt's imap_select_and_poll. Leaving the open mailbox first writes its queued changes, as NeoMutt's mx_mbox_close does, after Purge N deleted messages? under delete; Ctrl-G at that question or a failed change keeps the mailbox open. Choosing a folder in the sidebar leaves the mailbox the same way. Difference, recorded under the project's exception for an obvious NeoMutt bug: the sidebar open honors read_only when it enters the mailbox, where NeoMutt's sidebar open (index/dlg_index.c:1485) and next-unread-mailbox (index/functions.c:1682) pass false although the manual says read_only opens all folders read-only. Entering a mailbox selects the first new message not marked for deletion, then the first old-unread message, else the last row, or the first under a reverse- sort, as NeoMutt's find_first_message does.
jump Opens Jump to message:. Return selects the message with the entered number; an empty answer closes it with Nothing to do, as in NeoMutt, and so does Ctrl-G. Numbers are positions in the sorted mailbox and include messages that limit hides; the prompt closes, and a hidden message, a number outside the mailbox, or text that is not a number shows the warning That message is not visible, Invalid message number, or Argument must be a message number, as NeoMutt's op_jump does. A message in a collapsed thread can be the answer: its thread opens and the message is selected, unless it is the thread's first message, as op_jump does. Default keys are 1 through 9; the first digit is prefilled.
mailbox-list Shows New mail in NAME, NAME for the mailboxes with new mail, as mutt_mailbox_list does, and nothing when none has it. The default key is . in the index, the pager, and the mailbox browser.
limit Opens Limit to messages matching: with the current limit pattern; as in NeoMutt, a typed first character replaces it, any editing key keeps it, and Return on an empty line closes it. The default key is l. As at NeoMutt's other pattern prompts (tag-pattern, untag-pattern, delete-pattern, undelete-pattern, and search on a browser's help screen), Tab after ~ opens the pattern menu, and the chosen row replaces the ~. Tab after ~y completes an X-Label value from the open mailbox, and later Tabs cycle through the matching values. It filters the current index with the patterns tag-pattern supports. As in NeoMutt, a pattern that is ~A after the simple-search words are expanded (all, ., ^, ~A) clears the limit; * is a simple search like any other word. Ctrl-C during the scan keeps the matches reached so far and reports Search interrupted; an interrupted ~A scan clears the saved limit while keeping those rows visible. The limit keeps the answer as typed and compiles it a second time, as NeoMutt does, so a backtick in it runs twice. Difference (origin: agent judgment, under the owner's NeoMutt-bug exception): NeoMutt compiles that second pattern after the loop rebuilt the view and before the cursor moves, so ., relative ranges (N,M), and a bare 0 can resolve against the new view and the stored limit_pattern can differ from the pattern that chose the rows; Mutt Desktop compiles it with the first compile's view, so the stored limit is the one just applied. Difference (origin: agent judgment, under the owner's NeoMutt-bug exception): when that second compile fails, NeoMutt leaves limit_pattern NULL and update_index dereferences it (index/dlg_index.c:443, 512); Mutt Desktop stores no pattern, so a refresh adds no message to the limit. Limits preserve tags. The command shows Compiling search pattern..., clears the message line after the scan, and reports No messages matched criteria for an empty result. If a limit was already set, it then shows To view all messages, limit to "all" after any sleep_time error pause, including when the prompt is canceled or compilation fails. As NeoMutt's update_index does, a shown message stays shown when its tag, read, flag, or deletion state changes, until the next limit; a refresh adds messages that now match.
first-entry Selects the first displayed message. NeoMutt's default keys = and <Home> work.
next-page, previous-page Move the index view by one page and fit the cursor into it, as NeoMutt's menu_move_view_relative does. If the view cannot move at an end, move the cursor within the view; an unchanged position reports nothing. The default keys are Page Down, Right, and z, and Page Up, Left, and Z.
last-entry Selects the last displayed message. NeoMutt's default keys * and <End> work. $ selects the last message only when the config explicitly rebinds it from its default sync-mailbox action.
tag-entry Toggles the selected message's in-memory tag and advances one row. The default key is t. Tags are cleared when the mailbox changes and never alter message flags. Same-mailbox refreshes remap tags by message identity: folder, UIDVALIDITY, and UID for IMAP, unique name and file identity for Maildir, or file identity and position for mbox.
tag-pattern Opens NeoMutt's Tag messages matching: prompt, filled with the limit pattern as limit is, and tags every displayed match. Like untag-pattern, delete-pattern, and undelete-pattern, it shows Compiling search pattern... and clears the message line when done. It changes each tag before testing the next row, so a thread relation can match a tag set earlier in the command. The default key is T. The pattern is compiled once, as NeoMutt's mutt_pattern_comp compiles it: terms written one after another must all match, `
mixed Index bindings reference table

| untag-pattern | Opens Untag messages matching:, filled with the limit pattern as limit is, and removes tags from every displayed match. It clears each tag before testing the next row. The default key is Ctrl-T. | | delete-pattern, undelete-pattern | The default keys are D and U in the index, as in NeoMutt. In a read-only mailbox they report Mailbox is read-only; in one whose rights lack DELETE they report Can't delete messages: Operation not permitted by ACL or Can't undelete messages: Operation not permitted by ACL and ask nothing, as check_acl does. Otherwise they open Delete messages matching: or Undelete messages matching:, filled with the limit pattern, and read the pattern as tag-pattern does. They test displayed rows in order; an earlier deletion change can affect a later thread relation match. They mark each displayed match deleted, or clear its deletion and purge mark, as mutt_set_flag does; flag_safe keeps flagged messages from deletion. The cursor and tags stay where they were. The changes are queued like delete-message until sync-mailbox or leaving the mailbox. Difference (origin: agent judgment for mail safety): a sync, save, copy, or mailbox close in progress reports Wait for mailbox operation to finish and changes nothing. For identified messages, validation also refuses a mailbox that became read-only (Mailbox is read-only), lacks a mutation service (This mailbox cannot be changed), or no longer holds a target (Message is not in the current mailbox). The mailbox can change while a ~X pattern waits for attachment counts. Trash is resolved at sync; an unusable destination leaves the deletion marks in place and stops the write. | | delete-thread, delete-subthread, purge-thread, undelete-thread, undelete-subthread, read-thread, read-subthread | NeoMutt's index and pager keys change every message in the selected thread or subthread, including messages hidden by a limit. purge-thread has no default key and skips Trash at sync. DELETE or SEEN ACL rights are checked before any change; flat threading reports Threading is not enabled. The cursor follows resolve. Difference (origin: agent judgment for mail safety): a mailbox operation in progress or a stale identified target refuses the whole change before any member is marked. | | collapse-thread, collapse-all | The default index keys are Alt-v and Alt-V. A collapsed thread shows one representative row while ~v matches every member when more than one message was visible. collapse-thread reports Thread contains unread or flagged messages when the matching option is unset and the thread has such a visible message. collapse-all toggles all eligible threads. Flat threading reports Threading is not enabled. | | break-thread, link-threads | The default index and pager keys are # and &. WRITE ACL is checked first. Breaking clears the selected message's threading headers and obsolete descendant References. Linking attaches tagged visible threads to the selected message and clears their tags. IMAP sync appends changed copies and deletes their originals when allowed; local sync rewrites the messages. POP sync stores changed headers in header_cache when set; POP never rewrites the server message. | | tag-prefix | The default key is ;. It sets a one-shot tagged-operation state, or reports No tagged messages when the mailbox has none; tagged messages a limit hides count, as NeoMutt's msg_tagged does, but the command that follows skips them. ;t mass-untags visible tagged messages. ;C, ;d, ;N, ;s, and ;u validate loaded tagged rows, then run in display order; an IMAP mailbox receives the batch in one sync, and a local mailbox receives each change in turn. Tagged reply is refused; Mutt Desktop does not compose a multi-message reply. | | toggle-write | The default key is % in the index and pager. It toggles whether the open mailbox writes queued changes. While writing is off, %r shows the read-only status character, $ reports Mailbox is marked unwritable and writes nothing, and leaving the mailbox discards queued changes without a move or purge question. Press % again to restore writes. A mailbox opened read-only refuses the toggle. The setting survives folder switches and reopens within one account, including unlisted mailboxes, and clears on account switch or app restart. Retention for unlisted mailboxes is an owner-approved difference (2026-10-21): NeoMutt frees them after leaving (core/mailbox.c:89-112). | | toggle-new | The default key is N. It queues exact \Seen changes until sync-mailbox or leaving the mailbox, updates rows provisionally, and advances. Pressing it again on a message with a queued change cancels that change. ;N applies to every tagged visible row. Old-unread becomes new-unread when toggled; new-unread becomes read. A mailbox whose MYRIGHTS lack SEEN refuses it with Can't toggle new: Operation not permitted by ACL. | | flag-message | The default key is F in the index and pager. It toggles the message's \Flagged state, which %Z shows as ! and ~F (or flag) matches, so l then ~F limits the index to flagged messages. It queues the change like toggle-new until sync-mailbox or leaving the mailbox, and pressing it again before then cancels it. It then moves to the next undeleted message, as NeoMutt does. ;F applies to every tagged visible row. A mailbox whose MYRIGHTS lack WRITE refuses it with Can't flag message: Operation not permitted by ACL. | | set-flag, clear-flag | The default keys are w and W in the index and pager. They ask NeoMutt's Set flag? (D/N/O/r/*/!): or Clear flag? (D/N/O/r/*/!): and read one key, upper or lower case: D marks or unmarks the message deleted (clearing also clears a save-message purge mark), N new, O old (setting it also marks the message unread, clearing it marks it read), r replied (setting it also marks an unread message read), * tagged, and ! flagged. Ctrl-G ends the question with nothing changed; any other key does too, after ringing the bell under beep. Changes queue like toggle-new and flag-message, and changing a state back cancels its queued change. flag_safe keeps a flagged message from being marked deleted. As in NeoMutt there is no check_acl: a flag the mailbox's MYRIGHTS do not cover changes nothing and nothing is reported, and a read-only mailbox refuses the function before it asks. The cursor then moves to the next undeleted message under resolve; after ; every tagged visible message changes and the cursor stays. Tagged set-flag D marks the messages before Trash is checked at sync, as NeoMutt does. | | noop | Mutt Desktop accepts noop in any case. As in NeoMutt, it removes the binding in the named menu, so a generic binding for the key applies again; otherwise the key reports Key is not bound. |

After a mailbox check removes the selected message, the index selects the message now at the old row position.

After a mailbox check, the selected message stays selected if it remains in the index. If it was removed, the message now at its old row position is selected. If that position is past the end, the first new message is selected, then the first unread one, or an end row if neither exists. When a sync removes the selected deleted message and its check found no new mail, reopen, or flag change, the cursor selects the next undeleted message, or the previous one if none follows.

After mailbox headers arrive, account entry, next-page, previous-page, and last-entry show the destination rows and selection immediately.

After mailbox headers arrive, account entry, next-page, previous-page, and last-entry show the destination rows and selection immediately. An uncached %X field shows · until its attachment count arrives; the count worker updates that row without holding the viewport or the next key. Leaving a mailbox cancels its background %X work before close-time flag writes and IMAP CLOSE; a refused close resumes counts for the open view. A due mailbox check and idle keepalive wait while background counts use the IMAP connection; the next idle or key pass runs the due check. With an empty message list, a connection lasting over 300 ms shows “Connecting to HOST...”; after login, a message-list load lasting over 300 ms shows its spinner. Neither spinner appears during a password prompt or over populated rows. An explicit ~X pattern still waits for the counts it needs. On IMAP with imap_peek=yes, the app requests BODYSTRUCTURE for the visible page in one UID FETCH, then checks the rows' actual root MIME headers in one bounded UID FETCH. It queues known, bounded child MIME-header requests across the page in the account's command pipeline. Headers discovered after that batch use bounded section fetches. A missing header or unsafe structure falls back to a whole-message read for that row. If BODYSTRUCTURE omits multipart children, bounded numbered MIME-header probes recover the parts before counting. With imap_peek=no, counts still use whole-message BODY[] reads, which can mark messages read. Local and POP counts retain their raw-message path. NeoMutt opens each message in display order during synchronous redraw; background count display and metadata batching are owner-approved message-list performance differences.

Binding resolution 19

Mutt Desktop parses the single-character and named keys used by supported menus.
  • Mutt Desktop parses the single-character and named keys used by supported menus. A control key uses NeoMutt's \Cx or \cx syntax, so bind pager \Cb previous-page binds Ctrl-B. As in NeoMutt, ^x and <c-x> in a key are not control keys. NeoMutt reads each as a sequence of literal keys, and Mutt Desktop does not bind key sequences.
Index bindings override generic bindings regardless of declaration order.
  • Index bindings override generic bindings regardless of declaration order.
A binding to a function NeoMutt does not offer in that menu leaves the previous binding intact.
  • A binding to a function NeoMutt does not offer in that menu leaves the previous binding intact. A binding to one NeoMutt offers there but Mutt Desktop does not run replaces the key, as in NeoMutt, except in the browser. noop and unbind MENU KEY remove that menu's binding, so the generic binding applies where NeoMutt retries the generic menu.
difference Mutt Desktop difference: a bind removes the first existing binding its keys overlap, as NeoMutt's km_bind does, and keeps one entry per key sequence.
  • Mutt Desktop difference: a bind removes the first existing binding its keys overlap, as NeoMutt's km_bind does, and keeps one entry per key sequence. NeoMutt's binding list can keep an older entry with the same keys, which a later noop on the newer one exposes; Mutt Desktop treats that as a NeoMutt bug and does not copy it.
difference Mutt Desktop difference: when a key unbound in a menu runs a generic macro, the keys the macro sends are read in that menu.
  • Mutt Desktop difference: when a key unbound in a menu runs a generic macro, the keys the macro sends are read in that menu. NeoMutt reads them in the generic menu (retry_generic, key/get.c:321-339), so a key only the menu binds is reported unbound; Mutt Desktop treats that as a NeoMutt bug.
Help screens, help bars, and messages built from the key map name a bound key as NeoMutt's km_expand_key does, such as ^G, <Return>, <F5>, or <Esc>b.
  • Help screens, help bars, and messages built from the key map name a bound key as NeoMutt's km_expand_key does, such as ^G, <Return>, <F5>, or <Esc>b.
difference Owner difference (2026-10-22): editor and browser help screens keep a Close button above their scrolling text.
  • Owner difference (2026-10-22): editor and browser help screens keep a Close button above their scrolling text. It shows the bound exit key (q by default); a click runs the same close action as that key and returns to the prompt or browser without moving keyboard focus. The button works when exit has no binding.
difference Help bars are NeoMutt's (compile_help): key:label entries, each followed by two spaces, from the menu's NeoMutt help table: FolderHelp in the browsers, AttachmentHelp in the att...
  • Help bars are NeoMutt's (compile_help): key:label entries, each followed by two spaces, from the menu's NeoMutt help table: FolderHelp in the browsers, AttachmentHelp in the attachment list, PostponedHelp in the postponed list, ComposeHelp in compose, and EditorHelp on the prompt line of every prompt, such as <Esc>?:Help <Tab>:Complete ^P:Hist Up. A rebound key shows in the bar. Mutt Desktop difference: an entry whose function the menu does not run yet, such as attachment pipe-entry or compose edit-description, is left out, where NeoMutt would name its key. Mutt Desktop difference: when the editor binds no help key, NeoMutt's prompt bar names generic ? (helpbar/helpbar.c:92, as km_error_key does, key/get.c:296-298), which the editor types as text; Mutt Desktop treats that as a NeoMutt bug and leaves the entry out. Above the message list is IndexHelp, such as q:Quit d:Del u:Undel s:Save m:Mail r:Reply g:Group, and above the message pager is PagerNormalHelp, such as i:Exit -:PrevPg <Space>:NextPg v:View Attachm. d:Del r:Reply j:Next. set nohelp hides every NeoMutt help bar, including the prompt line's, as it hides NeoMutt's help bar window; a folder hook that changes help applies when the folder opens. Other Mutt Desktop-only hints, such as compose's e:Edit body, stay. Mutt Desktop difference: the pager bar names only pager keys. NeoMutt's make_help falls back to a generic key (helpbar/helpbar.c:91-92), but the pager reads no generic keys (key/get.c:329, 447), and NeoMutt's own km_error_key skips generic for the pager and the editor (key/get.c:296-298); Mutt Desktop treats the fallback as a NeoMutt bug.
addition The pager help bar shows the bound previous-message key after the next-message key.

Owner addition (2026-10-22): the pager help bar shows k:Previous by default, after j:Next. Both labels follow pager key remaps and disappear when their functions are unbound. NeoMutt's PagerNormalHelp has only Next (pager/dlg_pager.c:94-106).

difference Mutt Desktop difference: help screens pad columns by display width, and every key name shows a non-ASCII key as its character.
  • Mutt Desktop difference: help screens pad columns by display width, and every key name shows a non-ASCII key as its character. NeoMutt measures columns by display width but pads by bytes (help.c:210), and shows each UTF-8 byte of a key as an octal escape (km_keyname, key/lib.c:421-428); Mutt Desktop treats both as NeoMutt bugs.
difference Owner difference (2026-10-21): the help lists in the browsers and prompts are menus with a selected row that the movement keys move, and a search selects the matching line.
  • Owner difference (2026-10-21): the help lists in the browsers and prompts are menus with a selected row that the movement keys move, and a search selects the matching line. NeoMutt shows help in its pager (help.c:262-269): it scrolls from a top line, reads only pager keys, so j and k do nothing, and highlights search matches (pager/functions.c:377-815).
unbind MENU removes the menu's bindings but keeps its macros, so generic bindings apply again, then binds Return, ? (to help), and q again, as NeoMutt does; in the index q becom...
  • unbind MENU removes the menu's bindings but keeps its macros, so generic bindings apply again, then binds Return, ? (to help), and q again, as NeoMutt does; in the index q becomes exit. The index, attachment list, postponed list, and compose window have no help screen yet, so ? there reports Key is not bound.
Yes/no questions read as NeoMutt's do, default answer first: ([yes]/no): or ([no]/yes):.
  • Yes/no questions read as NeoMutt's do, default answer first: ([yes]/no): or ([no]/yes):. y and n answer in either case, Return takes the default, Ctrl-G cancels, and Escape does nothing, as in NeoMutt's mw_yesorno. NeoMutt adds /? to a quadoption's question to show the option's help; Mutt Desktop has no help screen and omits it.
Every key goes to the active menu: the postponed list, the attachment list, the pager, or the index.
  • Every key goes to the active menu: the postponed list, the attachment list, the pager, or the index. This includes Control and Option keys; Command keys go to the menu bar. A key that menu does not bind reports Key is not bound, and never reaches another panel. NeoMutt names the bound help key in this message; Mutt Desktop has no help screen for these menus. Tab in the index and pager selects the next new message, or the next older unread message when none are new, wrapping at the end. In the index and pager, Esc starts a key sequence, as in NeoMutt, where Alt-x is Esc then x: Esc then c runs change-folder-readonly. In the index, Esc then a key that continues no binding reports Key is not bound for the Esc, and the key is read again. In the pager, that sequence counts as an unbound key: both keys are dropped, and the next key, read alone even when it is Esc, shows Key is not bound; with no key within one second, the error shows then. A key or key sequence that the index or pager binds to a function Mutt Desktop does not run, such as the pager's Esc then e (resend-message), reports Key is not bound at once and reads no further key, as NeoMutt returns the bound function without another read. Option keys do not send Esc; type Esc, then the key. A key sequence that gets no next key within one second is dropped, as NeoMutt's key read ends after one second; a pending tag prefix stays. Ctrl-G, or Ctrl-C answered no at the exit question, drops a pending key sequence and a pending tag prefix. The mailbox browser, the compose window and its file browser, and every prompt drop a pending key sequence after one second too; a prompt then reads on, so Esc, a pause, and b inserts b, where Esc then b at once runs backward-word. In the attachment and postponed lists a lone Esc is dropped after one second too. Esc then a key that continues no binding reports Key is not bound for the Esc and reads the key again, as in NeoMutt. Mutt Desktop does not run check-traditional-pgp or resend-message in these lists, or search-reverse in the postponed list. In the attachment list Esc then / runs search-reverse; in the postponed list it is read as one key sequence and reports Key is not bound once, as is any key sequence bound to a function the menu does not run yet. In the attachment list Esc then P or e reports the Esc, and the key is read again on its own; NeoMutt binds both sequences, to check-traditional-pgp and resend-message, and Mutt Desktop leaves out these defaults. Editable fields and the embedded terminal receive their own keys.
At a text prompt, Esc starts a key sequence, as in NeoMutt: a lone Esc is dropped after one second, Esc then a key that completes no binding inserts both keys, and Ctrl-G cancel...
  • At a text prompt, Esc starts a key sequence, as in NeoMutt: a lone Esc is dropped after one second, Esc then a key that completes no binding inserts both keys, and Ctrl-G cancels the prompt. Mutt Desktop shows ^G:Abort beside active text prompts and one-key questions that Ctrl-G cancels. set nohelp hides the hint. It stays visible before other prompt help in narrow windows.
Option is not mapped to Alt: type NeoMutt's Alt-x as Esc then x.
  • Option is not mapped to Alt: type NeoMutt's Alt-x as Esc then x. To use Option as Alt, map Option+x to Esc then x with Karabiner-Elements.
Links in the pager can be clicked: a web or mailto link opens with the Mac's default browser or mail app, as the project owner approved; NeoMutt has no mouse support.
  • Links in the pager can be clicked: a web or mailto link opens with the Mac's default browser or mail app, as the project owner approved; NeoMutt has no mouse support. In HTML mail the message view itself never navigates. In plain-text mail Mutt Desktop marks web and mailto addresses as links. Other link schemes, such as file:, do nothing. On a line longer than 16,384 UTF-16 units, a link crossing a scan boundary remains plain text; bounded scanning keeps large messages responsive (owner, 2026-10-21).
Large plain-text mail shows its first lines while the rest of the body finishes formatting, then shows the complete message (owner, 2026-10-21).
  • Large plain-text mail shows its first lines while the rest of the body finishes formatting, then shows the complete message (owner, 2026-10-21).
An accent-colored outline marks the panel keys go to: the index, or the message panel for the pager, attachment list, or postponed list.
  • An accent-colored outline marks the panel keys go to: the index, or the message panel for the pager, attachment list, or postponed list. The index selection takes the accent color when the index has the outline and the window is in front, and is grey otherwise. The message panel's attachment or postponed list then shows the accent-colored selection. Return, Space, i, q, x, and v move the outline as they change the menu. A click in the index makes the index active, leaving the pager or attachment list. A click in the message panel opens the selected message in the pager, so its text can be selected and copied; as with Return, the pager marks the message read, but the click loads no remote content. Clicks on scroll bars, on the divider between panels, and in the sidebar change nothing.

Pager bindings 12

The pager reads only pager bindings, as NeoMutt's pager does.
  • The pager reads only pager bindings, as NeoMutt's pager does. Supported functions are top, bottom, next-line, previous-line, next-page, previous-page, next-entry, previous-entry, next-undeleted, previous-undeleted, exit, quit, jump, view-attachments, mail, reply, group-reply, list-reply, forward-message, compose-to-sender, copy-message, delete-message, delete-thread, delete-subthread, purge-thread, undelete-message, undelete-thread, undelete-subthread, read-thread, read-subthread, save-message, sync-mailbox, change-folder, change-folder-readonly, tag-message, mark-as-new, flag-message, set-flag, clear-flag, edit-or-view-raw-message, edit-raw-message, edit, view-raw-message, mailbox-list, sidebar-toggle-visible, sort-mailbox, and sort-reverse. NeoMutt's pager has no first-entry, last-entry, or tag-prefix; binding them reports a notice.
difference Mutt Desktop difference: if a key is unbound in the pager but bound in the still-visible index, it reports Key is not bound in pager.
  • Mutt Desktop difference: if a key is unbound in the pager but bound in the still-visible index, it reports Key is not bound in pager. Press i for index. with the first configured pager exit key by NeoMutt keycode order. NeoMutt reports only Key is not bound. The pager never runs the index command.
The default keys are NeoMutt's: j, Down, and Right show the next message not marked deleted, and k, Up, and Left the previous one; J and K move one message whatever its state.
  • The default keys are NeoMutt's: j, Down, and Right show the next message not marked deleted, and k, Up, and Left the previous one; J and K move one message whatever its state. Return scrolls down a line and Backspace up a line; Space and Page Down page down, and - and Page Up page up; Home and ^ go to the top, and End to the bottom. i, q, and x return to the index, and Q quits. m, r, g, L, C, d, Ctrl-D, Alt-d, u, Ctrl-U, Alt-u, Ctrl-R, Alt-r, s, $, c, t, N, F, v, o, O, and 1 through 9 run the same functions as in the index.
One pager key moves an HTML message once, even if the same message renders again.
  • One pager key moves an HTML message once, even if the same message renders again.
difference Rapid pager navigation can skip an intermediate message's full rendering.
  • After an IMAP message open applies its FLAGS, Mutt Desktop reads the next pager key while the body finishes rendering. A message passed quickly may show only its headers or a short preview; the message where navigation stops shows its full body. NeoMutt renders each message before reading the next pager key (pager/message.c:456-489; pager/dlg_pager.c:374-489). Owner-approved responsiveness difference (2026-10-25; .architecture/history/2026-10-message-list-selection-stutter.md).
display-message (Return or Space in the index) enters the pager.
  • display-message (Return or Space in the index) enters the pager. Moving to another message, by key or by a command such as delete-message, shows it in the pager, as in NeoMutt. A click on an index row selects that message in the index, except while a prompt or question is open. Clicking a fully visible row does not scroll the message list, even after you scroll it manually. A double-click on the selected index row acts as Return when the index is ready to read a key; if the click starts a due mailbox check, it does not queue Return. When selection moves to another message, the old page and its in-memory rendering clear immediately. The panel shows the new message's headers and loading state until its body loads or fails; I applies to that selected message. A folder or account switch clears the old page too, while the folder browser remains visible during its change. view-attachments opens the selected message before showing its MIME menu.
Mutt Desktop does not report Top of message is shown or Bottom of message is shown, because it cannot tell where an HTML message ends without running scripts.
  • Mutt Desktop does not report Top of message is shown or Bottom of message is shown, because it cannot tell where an HTML message ends without running scripts.
addition my-muttdesktop-load-remote-content, a Mutt Desktop-only function, loads every remote image once.
  • my-muttdesktop-load-remote-content, a Mutt Desktop-only function, loads every remote image once. Its default key is uppercase I, a lower-priority Mutt Desktop fallback in the index and pager; bind moves it and noop removes it, as for any function. It reports Remote content loaded, or Remote content will load with the message while the message is still loading. The hint above the message names each bound key with how many images it loads and how many look like trackers, for example Load content images (23) [i], all images (24) [I]; suspected trackers: 1; the counts cover <img> elements and appear once the body has loaded.
addition my-muttdesktop-load-content-images is a Mutt Desktop-only function with no default key; bind it in the index or pager, for example bind index i my-muttdesktop-load-content-image...
  • my-muttdesktop-load-content-images is a Mutt Desktop-only function with no default key; bind it in the index or pager, for example bind index i my-muttdesktop-load-content-images, since NeoMutt's pager uses i to return to the index. It loads the message's remote images except tracker images and reports Content images loaded; N tracker images blocked. An image is a tracker when its host is on the bundled EasyPrivacy list, when it is declared 1×1 or smaller, or when it or an element around it is hidden. Requests to listed hosts, such as CSS backgrounds, are also blocked. I afterwards loads everything. The checks are not complete: a sender can still track an ordinary image with a unique address. It obeys my_muttdesktop_remote_content as I does, and the hint shows its key when bound.
addition my-muttdesktop-clear-flag-stay is a Mutt Desktop-only index and pager function with no default key.
  • my-muttdesktop-clear-flag-stay is a Mutt Desktop-only index and pager function with no default key. It asks the same Clear flag? question as NeoMutt's clear-flag, but keeps the selected message after a valid answer. N clears New by marking an unread message read. Normal clear-flag advances when resolve is set and a later undeleted message exists. This command is an owner-approved addition; NeoMutt does not have it.
addition my-muttdesktop-toggle-html-appearance is a Mutt Desktop-only index and pager function with no default key.
  • my-muttdesktop-toggle-html-appearance is a Mutt Desktop-only index and pager function with no default key. Bind it to a key to switch the selected HTML message to the opposite of its configured appearance; press it again to restore the configured appearance. The temporary choice clears when another message is selected. It does not change plain-text mail.
An index or pager binding for I suppresses that menu's fallback.
  • An index or pager binding for I suppresses that menu's fallback. A generic binding suppresses both fallbacks.

Compose bindings 5

Supported functions are attach-file, detach-file, view-attach, edit-message, edit-bcc, edit-cc, edit-fcc, edit-reply-to, edit-subject, edit-to, send-message, postpone-message, exit, end-cond, and noop.
  • Supported functions are attach-file, detach-file, view-attach, edit-message, edit-bcc, edit-cc, edit-fcc, edit-reply-to, edit-subject, edit-to, send-message, postpone-message, exit, end-cond, and noop.
Their default keys are a, D, Return, e, b, c, f, r, s, t, y, P, and q.
  • Their default keys are a, D, Return, e, b, c, f, r, s, t, y, P, and q.
Files dragged from Finder onto the Attachments block attach in the order dropped.
  • Files dragged from Finder onto the Attachments block attach in the order dropped. NeoMutt has no drop target; the project owner approved this one. A drop does nothing while the editor owns the draft, while a header edit, prompt, or question is open, while the draft is sending or importing, or while a postponement's result is unknown. Only file URLs attach.
Review starts in command mode, where Esc starts a key sequence, as generic search-reverse is Esc then /; a lone Esc is dropped after one second.
  • Review starts in command mode, where Esc starts a key sequence, as generic search-reverse is Esc then /; a lone Esc is dropped after one second. Field-edit commands and field clicks enter text mode until Return or Ctrl-G.
Neovim receives its own input.
  • Neovim receives its own input.

Attachment-menu bindings 8

difference Supported functions are next-entry, previous-entry, next-line, previous-line, first-entry, last-entry, next-page, previous-page, top-page, middle-page, bottom-page, half-down, h...
  • Supported functions are next-entry, previous-entry, next-line, previous-line, first-entry, last-entry, next-page, previous-page, top-page, middle-page, bottom-page, half-down, half-up, search, search-reverse, search-next, search-opposite, collapse-parts, view-attach, view-mailcap, save-entry, and exit. Return runs view-attach, as in NeoMutt. A key bound to select-entry clears the message line and does nothing, as in NeoMutt, whose attachment menu does not run it. bind attach accepts every attachment-menu and generic function; one the menu does not run yet, such as reply, jump, or tag-entry, reports Key is not bound. / asks Search for:, Esc then / asks Reverse search for:, and n repeats the last search; each search matches a regular expression against the row's description, media type, and size, ignoring case when the pattern has no uppercase letter, and reports Search wrapped to top or Not found. The search text lasts across attachment lists, and each list starts searching down. Difference: Mutt Desktop has no attach_format, so a search matches the row as shown. NeoMutt's default keys include j and Down, k and Up, > and < for lines, Home and =, End and *, Page Down and z, Page Up and Z, H, M, and L for positions within the page, ] and [ for half pages, v, Return, m, s, and q. The menu starts on the top-level MIME node. With digest_collapse=yes, digest subparts start collapsed; v toggles the selected container and reports There are no subparts to show on a leaf. Moving past either end reports You are on the first entry or You are on the last entry.
Return on a multipart opens its first descendant leaf.
  • Return on a multipart opens its first descendant leaf. A selected plain-text or attached-message leaf opens in the internal pager; selected HTML opens in isolated WebKit with bounded referenced CID images. q returns to the MIME menu. An explicit open reads only the selected part. The app blocks XHTML, SVG, and filenames with HTML, XHTML, or SVG extensions from external viewers. HTML parts use the isolated viewer; the app has no viewer for XHTML or SVG. NeoMutt's other default attachment commands, including d/u part deletion, T text view, h header display, and generic t tagging, remain unimplemented; their keys report Key is not bound. Piping, printing, reply/forward from a selected part, and attached-message navigation remain unimplemented too.
m forces a mailcap lookup for the selected row.
  • m forces a mailcap lookup for the selected row. A missing safe entry reports an error before any part fetch. Regular Return also checks mailcap before fetching an externally viewed part, then uses macOS open if no safe entry matches. Mailcap lookup uses the first safe matching entry in file and line order, including type/* and bare type wildcards. Shell commands are skipped.
difference save-entry asks Save to file:, prefilled from attach_save_dir and the attachment's file name; a typed first character replaces the suggestion, as in NeoMutt.
  • save-entry asks Save to file:, prefilled from attach_save_dir and the attachment's file name; a typed first character replaces the suggestion, as in NeoMutt. The answer, and the suggestion under attach_save_without_prompting, expand ~, =, +, !, !!, <, >, -, ^, and @alias as NeoMutt's buf_expand_path does; a relative result starts at the home directory. Save to file: asked again shows the expanded answer, as in NeoMutt. A directory asks File is a directory, save under it: (y)es, (n)o, (a)ll?; y or a asks File under directory:, and n asks Save to file: again. An existing file asks PATH - File exists, (o)verwrite, (a)ppend, or (c)ancel?, where PATH is the expanded answer as written, as in NeoMutt, also for a relative answer; c asks Save to file: again. Security difference: Save to file: asked again and the File exists question show the typed answer when the expansion holds a URL password or a saved account value. As in NeoMutt, a choice's number also answers these questions, Return or Ctrl-G ends the save, and Escape does nothing; an empty Save to file: answer also ends the save. After the last answer, Mutt Desktop shows Saving..., fetches only that part within the 32 MiB attachment limit, writes it, and reports Attachment saved. A failed fetch or write reports the error and ends the save, where NeoMutt asks Save to file: again. A file that appears at a new path during the fetch asks the existing-file question rather than being overwritten.
difference The file name loses any directory part.
  • The file name loses any directory part. Unlike NeoMutt, Mutt Desktop replaces control characters, format characters such as U+202E, which reverses the text after it, and a leading . with _, so a saved file is never hidden and its name shows as it is. SwiftMail removes :/\?%*|"<> from names. An unnamed MIME-tree row leaves Save to file: empty, as NeoMutt does. Saved parts use NeoMutt's transfer decoding, including uuencode and text line endings. Saving a multipart row writes its raw body, including boundaries and child headers.
Saved files carry macOS quarantine metadata, so Gatekeeper checks them before they run; NeoMutt does not add it.
  • Saved files carry macOS quarantine metadata, so Gatekeeper checks them before they run; NeoMutt does not add it. A file system that refuses the metadata gets the file anyway, and Mutt Desktop says so.
addition The attachment bar below the message headers is Mutt Desktop-only; NeoMutt lists attachments only in the v menu.
  • The attachment bar below the message headers is Mutt Desktop-only; NeoMutt lists attachments only in the v menu. It lists the message's own leaf parts that have an attachment disposition (for a local, POP, or IMAP message, a disposition that starts with neither inline nor form-data counts as attachment, as in NeoMutt); a file name and no inline disposition, including a part without Content-Disposition; an inline disposition, a file name, and a type other than image; the type text/calendar; the type message/rfc822, message/news, or message/global, which includes each message of a digest; or a Content-ID and either a file name or a type other than text/plain and text/html. Parts inside an attached message are not listed.
Double-clicking an attachment below the message headers opens it, unless a prompt, question, or decision is open.
  • Double-clicking an attachment below the message headers opens it, unless a prompt, question, or decision is open. Text, HTML, and attached messages use the internal viewer; other files use the private external viewer. Save from the v attachment list. Double-clicking a row in that list opens it.

Postponed-draft bindings 3

mixed Supported functions are delete-entry, undelete-entry, exit, which closes the list, and inherited generic movement and selection functions.
  • Supported functions are delete-entry, undelete-entry, exit, which closes the list, and inherited generic movement and selection functions. As in NeoMutt, the list has no tagging: t (tag-entry) shows Tagging is not supported, ; (tag-prefix) shows No tagged entries, and the next function applies to the current entry only. As in NeoMutt, q is the list's own exit binding; the generic menu has no q, and neither menu has quit. Page movement is not implemented, and other keys report Key is not bound. Moving past either end reports You are on the first entry or You are on the last entry, as in NeoMutt.
Delete marks are committed on quit or before another draft is recalled.
  • Delete marks are committed on quit or before another draft is recalled. With the postponed mailbox open in the index, the list shows and changes the index's own deletion marks, and nothing is written until the index is synced.
Several entries can be marked deleted, one at a time.
  • Several entries can be marked deleted, one at a time.

Attachment-browser bindings 11

The browser implements every default browser and inherited generic binding in NeoMutt commit 1154e466.

The browser implements every default browser and inherited generic binding in NeoMutt commit 1154e466. The generic digits 1-9 run jump: Jump to: opens with the digit typed, Return selects that row, and a number outside the list reports Invalid index number; in an empty list jump reports No entries.

mixed Attachment-browser bindings reference table
Key Action
Return Enter a directory or attach a file.
Space View a file through supported mailcap rules or macOS open.
t Tag a file and advance. Directories cannot be tagged.
Return with files tagged Attach the tagged files in display order, as NeoMutt's op_exit does. After ;, Return attaches them even on a directory.
q Leave the browser.
Esc Starts a key sequence, such as Esc then / for search-reverse; a lone Esc is dropped after one second.
h, Backspace Unbound.
Click Select the entry, keeping a pending ;. NeoMutt has no mouse input. Clicks do nothing while the browser asks for a pattern, a directory, or a sort, or while a chosen file imports.
Double-click Same as Return.
While a chosen file imports Escape and the exit key cancel the import; every other key and click does nothing.
my-muttdesktop-toggle-hidden Mutt Desktop-only, with no default key, in every browser. It switches between the mask and showing every file. When mask is empty or ., it switches between showing every file and NeoMutt's default mask, !^\.[^.]. Bind it with, for example, bind browser , my-muttdesktop-toggle-hidden.
difference Each entry is one line in the index font, with the index's column lines and, under my_muttdesktop_index_alternating_rows, its alternating backgrounds.
  • Each entry is one line in the index font, with the index's column lines and, under my_muttdesktop_index_alternating_rows, its alternating backgrounds. The columns are date modified, date added (the Finder's Date Added), and the name, with / after a directory; mailbox-list and IMAP rows use the same columns, with blank dates. Difference: NeoMutt formats these lines with folder_format, and the mailbox list with mailbox_folder_format, as the mail window's browser does; it has no date-added field.
The help bar is NeoMutt's FolderHelp: q:Exit c:Chdir =:Goto m:Mask ?:Help.
  • The help bar is NeoMutt's FolderHelp: q:Exit c:Chdir =:Goto m:Mask ?:Help.
It is the mail window's browser opened with MUTT_SEL_MULTI: every function in Mailbox-browser bindings works, including the mailbox list, IMAP functions, enter-command, shell-es...
  • It is the mail window's browser opened with MUTT_SEL_MULTI: every function in Mailbox-browser bindings works, including the mailbox list, IMAP functions, enter-command, shell-escape, and show-version. A new listing drops the tags.
exit after a Tab returns to Attach file: with its text; after ? it ends the prompt.
  • exit after a Tab returns to Attach file: with its text; after ? it ends the prompt. select-new closes the browser and attaches nothing, as in NeoMutt.
Browser bindings override generic bindings.
  • Browser bindings override generic bindings. Browser = remains goto-folder, not first-entry.
difference Difference (AGENTS.md Interface rule: a compose window never closes while a prompt uses its draft): Ctrl-C at the browser's sort question cancels it without asking, where NeoMut...
  • Difference (AGENTS.md Interface rule: a compose window never closes while a prompt uses its draft): Ctrl-C at the browser's sort question cancels it without asking, where NeoMutt first asks whether to exit (key/get.c:241-244).
..
  • .. stays first under every sort and is selectable. The initial selection skips it when another entry exists.
Browser macros and pushed operations use the same input queue as the compose window and its prompts.
  • Browser macros and pushed operations use the same input queue as the compose window and its prompts.
difference Tab in Attach file: completes as in change-folder.
  • Tab in Attach file: completes as in change-folder. A Tab on an unchanged typed path opens this browser in that path's directory, listing only the names that begin with the rest of the path, as NeoMutt's dlg_browser does; entering a directory drops that filter. ? opens the browser only as the prompt's first key, as in NeoMutt. On an empty prompt, the attachment browser first opens in the home directory and later reopens in the last local directory visited during this app session. NeoMutt opens an empty file browser in process cwd every time (browser/dlg_browser.c:1008-1010); this is an owner-approved difference (2026-10-22). Typed paths still choose their own directory. This remembered attachment directory does not change mailbox or Settings browsers, Tab completion, or relative attachment paths. Save to file: and File under directory: complete the word after the last shell character, as NeoMutt's complete_file_simple does, reading a relative path from the home directory as the save does; a repeated Tab there opens the mail window's file browser, whose choice replaces that word.

Mailbox-browser bindings 13

The mail window's browser is NeoMutt's dlg_browser: the mailbox prompts (change-folder, copy-message, save-message) open it from a Tab or ?, and the attachment-save prompts from...

The mail window's browser is NeoMutt's dlg_browser: the mailbox prompts (change-folder, copy-message, save-message) open it from a Tab or ?, and the attachment-save prompts from a repeated Tab. It shows the directory, IMAP folder, or mailbox list in the message panel; while it is open, every key goes to it.

Every default browser and generic binding works:
  • Every default browser and generic binding works:
    • select-entry enters a directory or chooses a mailbox (a directory with cur or new, or MH marks, is a mailbox).
    • 1-9 (jump) open Jump to: with the digit typed; Return selects that row, and a number outside the list reports Invalid index number.
    • descend-directory (no default key) enters even a mailbox.
    • change-dir, goto-parent, goto-folder, and toggle-mailboxes. A change-dir answer, the path the browser opens at, a chosen mailbox-list entry, a tagged file, and a subscribed folder expand as NeoMutt's buf_expand_path expands them, including -, ^, !!, and @alias.
    • check-new (no default key).
    • enter-mask.
    • sort and sort-reverse, with NeoMutt's dazecwn question.
    • display-filename, view-file, and select-new (New file name:).
    • mailbox-list.
    • subscribe, unsubscribe, and toggle-subscribed.
    • create-mailbox.
    • delete-mailbox (Really delete mailbox "…"?).
    • rename-mailbox.
    • search (/), search-reverse (Esc then /), search-next (n), and search-opposite (no default key), help, and the menu movement functions, with NeoMutt's end-of-list messages. As in NeoMutt, search-opposite with no earlier search asks Reverse search for: and searches down.
Esc starts a key sequence, as in NeoMutt; with no next key within one second, the Esc is dropped.
  • Esc starts a key sequence, as in NeoMutt; with no next key within one second, the Esc is dropped.
subscribe, delete-mailbox, and rename-mailbox send the folder's name exactly as the server's LIST gave it.
  • subscribe, delete-mailbox, and rename-mailbox send the folder's name exactly as the server's LIST gave it. NeoMutt percent-decodes the URL it builds from that name and trims its slashes, so Old%20Work addresses Old Work; Mutt Desktop does not.
view-file runs a mailcap entry, or opens the file in the default text editor (open -t) when none matches, and never runs it.
  • view-file runs a mailcap entry, or opens the file in the default text editor (open -t) when none matches, and never runs it. NeoMutt shows such a file as text in its pager.
A key the browser does not bind reports Key is not bound.
  • A key the browser does not bind reports Key is not bound. Press '?' for help., naming the key bound to help. Mutt Desktop's index, pager, attachment, and postponed-draft menus have no working help screen, so they say only Key is not bound; NeoMutt names ? for its generic help binding outside the pager.
A file name that is not valid UTF-8 is listed and entered, and shows U+FFFD for each invalid byte.
  • A file name that is not valid UTF-8 is listed and entered, and shows U+FFFD for each invalid byte. Choosing it passes the name on with those bytes escaped, which Mutt Desktop cannot open.
Lines follow folder_format, and the mailbox list mailbox_folder_format.
  • Lines follow folder_format, and the mailbox list mailbox_folder_format. The title reads Directory [PATH], File mask: MASK, Subscribed […] under imap_list_subscribed, or Mailboxes [N].
mask, browser_sort, and imap_list_subscribed changes last across browser visits for the session, the attachment browser's included.
  • mask, browser_sort, and imap_list_subscribed changes last across browser visits for the session, the attachment browser's included. The mailbox browser reopens where it was (LastDir), with the cursor on the mailbox last opened. The compose attachment browser keeps its own directory as described above.
An IMAP browser URL uses the open account's connection.
  • An IMAP browser URL uses the open account's connection. A URL for an unrelated account does not start a new connection, as in NeoMutt's imap_browse.
A click selects a row; NeoMutt has no mouse support.
  • A click selects a row; NeoMutt has no mouse support. Double-click does nothing here.
mixed enter-command (:) and shell-escape (!) read their line without Tab completion; NeoMutt completes commands and file names there.
  • enter-command (:) and shell-escape (!) read their line without Tab completion; NeoMutt completes commands and file names there. Tagging reports Tagging is not supported, as a folder browser does in NeoMutt.
difference %N, %n, and %m show the last check's counts; other IMAP folders' totals update after background STATUS replies; unknown totals show ·.
  • %N, %n, and %m show what the last new-mail check of each mailbox found (see New mail in other mailboxes); the open mailbox's counts are its own. The browser runs mutt_mailbox_check when it lists mailboxes, under mail_check. Difference (owner, 2026-10-24): after the browser appears, the isolated metadata connection reads STATUS totals for other configured, polled IMAP folders and updates their %m values together. Unknown IMAP totals show ·; an empty message line shows Fetching folder counts… until the read completes or fails. A known empty folder shows 0. Older replies do not replace newer totals; results from an earlier browser, configuration, or access session are discarded. Keys and explicit opens proceed while those replies wait. NeoMutt shows the saved count until its queued STATUS replies are read (browser/dlg_browser.c:391-485, imap/imap.c:1196-1253).

Tab completion 4

Tab runs NeoMutt's complete function, and Ctrl-T runs complete-query.

Tab runs NeoMutt's complete function, and Ctrl-T runs complete-query. They complete at these prompts, as in NeoMutt:

mixed Tab completion reference table
Prompt What Tab completes
To:, Cc:, Bcc:, and the compose address fields An alias, as NeoMutt's alias_complete does: a unique match expands to its address, several extend their common prefix, and otherwise the alias menu opens. Ctrl-T runs query_command on the address before the cursor and opens the query menu for several results.
change-folder, change-folder-readonly, copy-message, save-message A local or IMAP mailbox path, with =, +, and ! expanded (see change-folder in Index bindings). A Tab on an empty or unchanged line opens the folder browser.
Attach file:, Save to file:, File under directory: A file path (see Attachment-browser bindings).
limit, tag-pattern, untag-pattern, delete-pattern, undelete-pattern, the alias and query menu pattern prompts, and a browser's help search After ~, Tab opens the pattern menu (pattern_format) and the chosen row replaces the ~. After ~y, Tab completes an X-Label value from the open mailbox, and later Tabs cycle through the matches.
: and ! in the alias, query, history, and help menus : completes command names, option names, function names after exec, and an option's value after =, as NeoMutt's mutt_command_complete does; ! completes a file path.
Not yet supported: completion at : and ! in the folder browser, which NeoMutt completes.

Not yet supported: completion at : and ! in the folder browser, which NeoMutt completes.

At a prompt with no completion, such as Jump to message:, Tab inserts a Tab character, as in NeoMutt.

At a prompt with no completion, such as Jump to message:, Tab inserts a Tab character, as in NeoMutt. With complete unbound, Tab inserts a Tab character at every prompt.

New mail in other mailboxes 12

Mutt Desktop checks the mailboxes entries other than the open one for new mail (mutt_mailbox_check), as NeoMutt's index and pager loops do.

Mutt Desktop checks the mailboxes entries other than the open one for new mail (mutt_mailbox_check), as NeoMutt's index and pager loops do. It checks before each command and every second while no key comes, but no more often than every mail_check seconds; opening a mailbox checks them at once, and one check runs at a time. The index reads the next key only after the open-mailbox check, the other-mailbox check, notification, and visible-row redraw finish. A mailbox that got new mail since the user last saw it is announced once: New mail in =INBOX, =lists, with each name as buf_pretty_mailbox writes it (+lists for an IMAP mailbox under an IMAP folder). The index skips the notice on its first pass and right after the open mailbox's own check found new mail, changed flags, or had to reopen the mailbox; the pager always shows it. Mail that arrives while a mailbox is open is not announced after the user leaves it: leaving records the visit, as mx_fastclose_mailbox does. mailbox-list (.) repeats it on demand.

difference beep_new defaults to no, as in NeoMutt.

beep_new defaults to no, as in NeoMutt. Setting it to yes rings the Mac alert sound for a new-mail notice even with beep=no. The enabled bell path is intentionally untested in automated tests at the owner's request. new_mail_command runs its configured shell command once for that notice, after expanding NeoMutt's status fields; a nonzero exit shows Error running "COMMAND". %D shows the mailbox's label, else %f. The pager combines an open-mailbox and other-mailbox notice into one set of effects. These effects finish before the next mailbox key. The command keeps the IMAP connection alive while it runs. Security difference: when a reached %D or %f mailbox value contains shell syntax, the app reports Unsafe mailbox name in new_mail_command and does not run the command. The native app does not change process-wide SIGINT or SIGQUIT handlers as terminal NeoMutt does.

mixed New mail in other mailboxes reference table
Mailbox Check
IMAP STATUS NAME (UIDNEXT UIDVALIDITY UNSEEN RECENT MESSAGES) on the account's connection, queued as imap_status queues it: it goes out with the next command, such as the open mailbox's NOOP, and its reply is read then. Under mail_check_recent, a mailbox has new mail when UIDNEXT rose and messages are unseen; at its first STATUS of the session, when messages are recent; and after its UIDVALIDITY changed, when messages are unseen. With mail_check_recent unset, a mailbox has new mail when messages are unseen. The open mailbox gets no STATUS. Opening a mailbox also queues the postponed mailbox's STATUS when it is a mailboxes entry, and, under imap_check_subscribed, LSUB "" "*", whose mailboxes join the list. Security differences: at most 1,000 subscribed mailboxes join from one LSUB, and a LIST or LSUB keeps at most 100,000 names; control and bidi characters in a mailbox name show as the message line shows them elsewhere.
Maildir A message in new/ (and cur/ under maildir_check_cur) without the S flag; under mail_check_recent, only one that changed after the mailbox was last left.
mbox The file was written after it was last read (or grew, under check_mbox_size); under mail_check_recent, only after the mailbox was last left. While the last check found no file, an empty one is not a mailbox yet.
POP Not checked, as in NeoMutt.
Under mail_check_stats, every mail_check_stats_interval seconds the check also counts the messages of each local mailbox (an mbox is read for its counts when it changed).

Under mail_check_stats, every mail_check_stats_interval seconds the check also counts the messages of each local mailbox (an mbox is read for its counts when it changed). The sidebar, %N, %n, and %m of the mailbox list show these counts.

change-folder checks before its prompt and offers the next mailbox with new mail in configured order.

change-folder checks before its prompt and offers the next mailbox with new mail in configured order. The index renders status_format; reached %b and %p fields check mailboxes and postponed mail in render order.

IMAP STATUS asks for UIDNEXT UIDVALIDITY UNSEEN RECENT MESSAGES with IMAP4rev1, or UID-VALIDITY in place of UIDVALIDITY with only the STATUS capability.

IMAP STATUS asks for UIDNEXT UIDVALIDITY UNSEEN RECENT MESSAGES with IMAP4rev1, or UID-VALIDITY in place of UIDVALIDITY with only the STATUS capability. With neither capability it sends nothing. The selected mailbox gets no STATUS, and another mailbox is skipped while the selected mailbox does not poll.

After a reconnect during a mailbox close's copy or sync, the outcome and cached unread count use the reopened mailbox; the moved count remains the number in the move question.

After a reconnect during a mailbox close's copy or sync, the outcome and cached unread count use the reopened mailbox; the moved count remains the number in the move question. A fetch-mail spool close also uses the reopened rows for purge, sync flags, and header cache after its move reconnects, keeping the earlier move and purge answers. The reopen discards the earlier mark-old changes.

A refused STATUS counts as a missing mailbox during copy, save, Trash, Sent filing, and postponing.

A refused STATUS counts as a missing mailbox during copy, save, Trash, Sent filing, and postponing. The creation question follows the append-open STATUS, or a COPY response with [TRYCREATE]. A tagged APPEND refusal before the literal leaves the connection open. A NO reports its trailer; a BAD uses the generic failure text. A lost read-only Trash STATUS reconnects and revalidates the source once before any write; no uncertain write is retried.

Differences:

Differences:

NeoMutt's positive error result incorrectly counts a refused STATUS as an existing mailbox.
  • NeoMutt's positive error result incorrectly counts a refused STATUS as an existing mailbox. Mutt Desktop treats it as missing, following NeoMutt's intended creation branch.
The same positive result becomes NeoMutt's postponed count when the STATUS of an IMAP $postponed fails (postpone/postpone.c:109-113), so %p shows 1 or 2, where imap_mailbox_stat...
  • The same positive result becomes NeoMutt's postponed count when the STATUS of an IMAP $postponed fails (postpone/postpone.c:109-113), so %p shows 1 or 2, where imap_mailbox_status documents @retval -1 Error (imap/imap.c:1294). Mutt Desktop keeps the last count, as the using old IMAP postponed count branch intends (115-118).
Status size fields use loaded header sizes, which can be incomplete.
  • Status size fields use loaded header sizes, which can be incomplete.

Message text 23

The pager, a reply, an inline forward, and mime_forward_decode all take the message text from mutt_body_handler (MuttBodyHandler), over the MIME tree of the message, with the St...

The pager, a reply, an inline forward, and mime_forward_decode all take the message text from mutt_body_handler (MuttBodyHandler), over the MIME tree of the message, with the State flags that NeoMutt's mutt_display_message, include_reply, include_forward, and mutt_make_message_attach set. The pager prints NeoMutt's [-- Attachment #N: name --], [-- Type: ..., Encoding: ..., Size: ... --], and [-- text/foo is unsupported (use 'v' to view this part) --] lines, honors honor_disposition, show_multipart_alternative, and weed, and copies the headers of an embedded message with ignore, unignore, and hdr_order. As in mutt_copy_hdr, those lists match each whole header line, so they also weed and order the mbox From line. Reply and forward text carry none of those lines, except the print_part_line lines that show_multipart_alternative=info prints. Differences from NeoMutt:

A JSON-style Unicode escape in an IMAP BODYSTRUCTURE filename no longer hides a multipart's text and attachment rows.
  • A JSON-style Unicode escape in an IMAP BODYSTRUCTURE filename no longer hides a multipart's text and attachment rows. Mutt Desktop decodes that parameter before its bounded section reads; NeoMutt parses the fetched whole message. The attachment body is still fetched only when opened or saved.
When a send follows an error, the Date header is set before the sleep_time pause instead of after it (send/send.c:2775-2777); it can be up to sleep_time seconds early.
  • When a send follows an error, the Date header is set before the sleep_time pause instead of after it (send/send.c:2775-2777); it can be up to sleep_time seconds early.
auto_view, unauto_view, alternative_order, unalternative_order, and implicit_auto_view work as in NeoMutt, except that the app runs no mailcap command (a security rule), so text...
  • auto_view, unauto_view, alternative_order, unalternative_order, and implicit_auto_view work as in NeoMutt, except that the app runs no mailcap command (a security rule), so text/html is the one autoview type: its own renderer, an isolated web view, stands in for the command, and the pager shows it as one document with the text around it, each part in a shadow root of its own. No [-- Autoview using ... --] line is printed, since no command runs.
There is no crypto backend, so multipart/signed, multipart/encrypted, and PGP or S/MIME parts are handled as ordinary parts.
  • There is no crypto backend, so multipart/signed, multipart/encrypted, and PGP or S/MIME parts are handled as ordinary parts. Detached signatures follow ordinary attachment rules when forwarded, and PGP key parts follow ordinary transfer-encoding rules. Crypto-only options, including include_encrypted and forward_decrypt, are ignored, and crypto patterns are absent from completion.
mixed Header text outside RFC 2047 words is read as NeoMutt keeps it: valid UTF-8 is text, and each byte that is not UTF-8 shows as U+FFFD, as the index shows it (expando/format.c:121...
  • Header text outside RFC 2047 words is read as NeoMutt keeps it: valid UTF-8 is text, and each byte that is not UTF-8 shows as U+FFFD, as the index shows it (expando/format.c:121-129). assumed_charset is not supported. Differences: the pager's header lines show such a byte as U+FFFD, where NeoMutt's pager shows \ooo (pager/display.c:893-905); a reply, a forward, or a recalled draft carries U+FFFD, where NeoMutt copies the byte. In a listed message, Subject words, address names, and group phrases decode from their original bytes, as NeoMutt does. In recalled drafts and other decoded headers, such a byte is first replaced with U+FFFD, so =?iso-8859-1?Q?caf\xE9?= shows caf� there instead of café (email/rfc2047.c:365-385).
mixed reflow_text, text_flowed, assumed_charset, charset_hook, and preferred_languages are not supported.
  • reflow_text, text_flowed, assumed_charset, charset_hook, and preferred_languages are not supported. Text converts with the C library's iconv as convert_to_state does: a part with a charset parameter that iconv knows becomes UTF-8, each invalid byte becomes ?, and an incomplete sequence at the end is dropped. A text part from a Content-Type header without a charset is us-ascii; without a header it is copied as it is. Other bytes are read as UTF-8.
mixed text/enriched wraps at 72 columns.
  • text/enriched wraps at 72 columns. The pager shows its overstrike as bold and underline and skips ANSI color sequences, as NeoMutt's pager does with allow_ansi unset; allow_ansi itself is not supported. Other control characters show as ^X, and a byte that is not UTF-8 as \ooo.
The pager shows state_mark_attach markers as nothing, since the app has no pager colors.
  • The pager shows state_mark_attach markers as nothing, since the app has no pager colors.
The sizes in [-- Type: ...
  • The sizes in [-- Type: ... --] lines count the CR-stripped body, as NeoMutt's IMAP cache does. On IMAP the bytes of a part that is not loaded are not known: its size is BODYSTRUCTURE's octets less its line count for text and message parts. For any other part, such as a base64 attachment, it is the octets, which NeoMutt would count without the CR of each line, because the index counts from BODYSTRUCTURE before it has parsed a cached whole message. A multipart's size on IMAP is the sum of its parts, where NeoMutt's includes the delimiters, preamble, and epilogue, which are not fetched either. A local, POP, or cached message is measured as NeoMutt measures it.
difference For an IMAP message with unknown RFC822.SIZE or larger than 32 MiB, the bounded section reader checks each multipart's actual header before using BODYSTRUCTURE boundaries: the root header has a 1 MiB cap, and nested MIME headers have a 16 KiB cap.
  • For an IMAP message with unknown RFC822.SIZE or larger than 32 MiB, the bounded section reader checks each multipart's actual header before using BODYSTRUCTURE boundaries: the root header has a 1 MiB cap, and nested MIME headers have a 16 KiB cap. It batches sibling header requests after checking their parent. If BODYSTRUCTURE omits a multipart’s children, it probes bounded numbered MIME headers for stable part sections. A rejected batch is retried one section at a time; a refusal for the first absent child ends the list. A one-byte check separates a missing section from an oversized header. If the server exposes none, returns a gap, or exceeds the header cap, the message cannot be shown without fetching possible attachment bytes, so the read fails. Recovered file parts appear in the attachment list with unknown size; opening one rechecks its numbered identity before a bounded body fetch. A recovered inline CID image is fetched only when the displayed HTML references it, under the same 8 MiB per-image and 16 MiB total limits. An embedded message body that becomes text uses BODY[N.TEXT] so its header is not repeated. Then mutt_body_handler finds the parts it decodes, and UID FETCH of BODY.PEEK items (BODY items with imap_peek unset) reads them. A multipart that became text uses the remaining shared 32 MiB budget for its body request. A command stops taking items as imap_make_msg_set ends a set at ImapMaxCmdlen (8,192 bytes). The commands use the account's imap_pipeline_depth ring: a full ring is sent and read before the next set is queued. Every tagged refusal except an expected missing MIME section probe shows IMAP command failed: <tagged reply> in reply order. An earlier refused reply leaves that set missing; a refused last reply of a full ring closes the connection before the next set, and the read reconnects, as cmd_handle_fatal does after a lost connection. One fetch takes at most 1,100 items; a round of the handler that needs more makes several fetches. On this fallback path, a part that NeoMutt only names as an attachment is fetched only after an approved open or save; normal known-size in-limit viewing fetches the whole message, including attachments, and caches it when message_cache_dir is set. With honor_disposition unset NeoMutt shows a text part marked attachment inline, so it is body text, and it is fetched and shown. Loading is bounded: bodies and headers beyond 32 MiB in all, a block longer than its limit, and a part that cannot be fetched are left out. Fallback difference: NeoMutt fetches the whole message and fails the open when the fetch fails (imap_msg_open); the bounded section reader reads parts separately, so a failed part is left out and the open fails only when no body loads. Every HTML part is sanitized, a lone HTML part (the usual HTML mail) as well as one in a mixed document: no svg, math, script, noscript, noembed, noframes, xmp, iframe, plaintext, template, object, embed, frame, frameset, applet, link, meta, base, or dialog elements; no popover, popovertarget, popovertargetaction, command, commandfor, or interestfor attribute; and no attribute value with < or >. A part in a mixed document is shown in a shadow root of its own; if its sanitized markup still holds </template in any case, it is shown as pager text instead, with control characters as ^X and bidi characters removed. These are security differences, since NeoMutt renders HTML to text with a command.
A multipart without a boundary parameter, or with an empty one, becomes text/plain with no parts and shows NeoMutt's multipart message has no boundary parameter when the message...
  • A multipart without a boundary parameter, or with an empty one, becomes text/plain with no parts and shows NeoMutt's multipart message has no boundary parameter when the message is first parsed for display.
If BODYSTRUCTURE omits a multipart boundary, the pager reads that part's MIME header.
  • If BODYSTRUCTURE omits a multipart boundary, the pager reads that part's MIME header. A real boundary keeps the section fetch path. With no boundary, the part is text with no children; the pager reads its body within the 32 MiB viewing limit. For a root multipart this is a bounded raw message read.
For security, the MIME parser reads at most 1,000 parameters from one header and joins at most 1,000 RFC 2231 pieces for one attribute.
  • For security, the MIME parser reads at most 1,000 parameters from one header and joins at most 1,000 RFC 2231 pieces for one attribute. NeoMutt has no such bounds; a message with more entries loses the excess parameters or pieces. This limits work on untrusted mail.
difference Security difference: mutt_body_handler stops writing message text after 32 MiB, because hostile text/enriched mail can multiply its input (<indent> and <excerpt> repeat).
  • Security difference: mutt_body_handler stops writing message text after 32 MiB, because hostile text/enriched mail can multiply its input (<indent> and <excerpt> repeat). NeoMutt has no such bound.
difference Security difference: threading ignores a Message-ID, In-Reply-To, or References ID over 998 bytes and follows at most a message's last 100 parent IDs, to bound the work hostile...
  • Security difference: threading ignores a Message-ID, In-Reply-To, or References ID over 998 bytes and follows at most a message's last 100 parent IDs, to bound the work hostile mail can cause. NeoMutt has no such bound.
difference Difference (NeoMutt bug and security): In-Reply-To and References are RFC 2047-decoded once and scanned left to right for IDs.
  • Difference (NeoMutt bug and security): In-Reply-To and References are RFC 2047-decoded once and scanned left to right for IDs. NeoMutt's parse_references (email/parse.c:328-331) decodes the rest of the header again for each ID but advances through the undecoded text by the length of the decoded match (email/parse.c:413-419), so an encoded word before the IDs makes it read an ID twice (=?utf-8?q?x?= <a@b> <c@d> gives <a@b>, <a@b>, <c@d>), and its work grows with the square of the header length.
difference Difference (NeoMutt bug): when an RFC 2047 B word in a header does not decode, the whole header stays as written.
  • Difference (NeoMutt bug): when an RFC 2047 B word in a header does not decode, the whole header stays as written. NeoMutt's rfc2047_decode ends that word's text with a NUL in the header itself before decoding it (email/rfc2047.c:722) and on failure leaves the header cut at that word's closing ? (:721-727), where its comment says the input is left untouched (:658-659).
difference Before parsing an IMAP BODYSTRUCTURE or BODY structure, the app rejects more than 4,096 parenthesized groups, 65,536 tokens total, 2,000 tokens in one group, 96 nested groups, o...
  • Before parsing an IMAP BODYSTRUCTURE or BODY structure, the app rejects more than 4,096 parenthesized groups, 65,536 tokens total, 2,000 tokens in one group, 96 nested groups, or 1 MiB of structure data, and closes the connection. This bounds NIOIMAPCore's allocations. Parsed MIME and flat part trees keep NeoMutt's first 500 parts and stop at depth 50. NeoMutt does not reject an oversized structure on these limits; this is a security difference.
The Pager finds CID images in the MIME tree for the displayed HTML, across its rendered parts.
  • The Pager finds CID images in the MIME tree for the displayed HTML, across its rendered parts. It fetches only inline images named by exact cid: image URLs or CSS url(...) values, up to 8 MiB per part and 16 MiB total. A failed fetch, missing section, or response that fills the size probe aborts the open. Before serving a CID image to WebKit, ImageIO checks every frame's metadata: one image may have at most 256 frames and 32 million decoded pixels across them, and all images together at most 64 million pixels. Invalid or larger images are not served. A referenced CID image with an explicit Content-Disposition other than inline stays in v but is not fetched for the Pager. Opening or saving that part fetches its bytes. This includes form-data, which Mutt Desktop treats as an attachment for this safety rule. NeoMutt reads the whole message before displaying it; its HTML attachment viewer searches the nearest multipart/related group.
The Pager limits HTML <img> width to its content area and preserves image proportions as the window resizes, including HTML parts in a mixed message.
  • The Pager limits HTML <img> width to its content area and preserves image proportions as the window resizes, including HTML parts in a mixed message. Numeric HTML width hints below the limit stay small. It replaces sender inline image styles so malformed CSS cannot disable the limit; this can change sender image styling. CSS-generated images outside <img> are not resized, and a transform on an ancestor can still scale an image. This is a WebKit presentation rule; NeoMutt's terminal pager has no inline bitmap layout.
The headers of an embedded message in a reply or forward lose Bcc: and Resent-Bcc:, and show C0 controls, DEL, C1 controls, and bidi characters as forward_decode does.
  • The headers of an embedded message in a reply or forward lose Bcc: and Resent-Bcc:, and show C0 controls, DEL, C1 controls, and bidi characters as forward_decode does.
addition Mutt Desktop-only feature (owner, 2026-10-21): an attachment preview converts every text part to the display charset; see Text attachment charsets.
  • Mutt Desktop-only feature (owner, 2026-10-21): an attachment preview converts every text part to the display charset; see Text attachment charsets.

Locale 1

difference Platform difference (agent judgment): NeoMutt sets the process locale from the environment once at startup (init_locale).

Platform difference (agent judgment): NeoMutt sets the process locale from the environment once at startup (init_locale). Mutt Desktop reads the environment's character-type and collation locale once, and selects it only on the thread that compiles or matches a regular expression, compares names for sorting, or measures character width. Darwin's setlocale replaces the collation table inside the shared global locale, so another thread sorting or compiling a regular expression at that moment would read a freed table; a locale made once and never changed avoids that. Matching, sorting, and widths follow the locale the environment names, as in NeoMutt. Owner difference: when LC_ALL, LC_CTYPE, LC_COLLATE, and LANG are all unset or empty, as in an app opened from the Finder or the Dock, Mutt Desktop uses en_US.UTF-8. NeoMutt would use the C locale, where smart case and . in a regular expression see bytes rather than characters, names sort by byte value, and wide characters have no width. If any of these variables is set, Mutt Desktop reads the environment as NeoMutt does.

Local mailbox formats 2

The mbox_type row explains how Mutt Desktop chooses a local mailbox's format.

The mbox_type row explains how Mutt Desktop chooses a local mailbox's format. Local writes follow the rules in Mailbox safety. Local mailbox behavior and differences from NeoMutt's maildir/ and mbox/ code:

mixed Local mailbox formats reference table
Behavior Mutt Desktop
Detecting an mbox An empty regular file is an mbox. Otherwise, after leading CR/LF bytes, a From prefix identifies it, as in NeoMutt; MMDF is not supported.
Times after detecting an mbox Mail safety difference: after reading the first line, Mutt Desktop puts back only the file's access time. NeoMutt also writes back the modification time, but mbox_path_probe reads both times from &st where it means st (mbox/mbox.c:1589-1590, against its comment at 1584-1586). The read does not change the modification time, and resetting it could hide a message that another task of the app appends between the read and the reset.
Times after an mbox sync Mail safety difference: Mutt Desktop puts back the mailbox's times while it still holds the lock. NeoMutt unlocks and closes the file first (mbox/mbox.c:1311-1313) and then calls utime (1334), so a message delivered in between can lose its new modification time and go unnoticed.
Content-Length in an mbox NeoMutt checks the offset one byte past the declared body without validating that intervening byte. It trusts Content-Length if that offset is EOF or begins From , even midline or with an invalid date. An invalid From_ line is not listed as a message.
Locking Mbox writes use fcntl, matching NeoMutt's default build. Other writers must use the same lock; a writer that ignores it can corrupt a concurrent rewrite.
Appending to an mbox A preflight scan refuses an append that would change how earlier messages read. The append uses O_APPEND writes on the locked file descriptor, in chunks of at most 1 MiB. If the file changes during the write or verification fails, Mutt Desktop does not roll back the write. It reports that the message may have been added and tells you to check the mailbox before retrying; it never truncates another writer's data.
Final byte without a newline Mutt Desktop preserves the final byte of an mbox message when it is not followed by a newline; NeoMutt drops that byte while parsing.
From line sender As NeoMutt's mx_msg_open_new does, the sender is the first address of Return-Path, then Sender, then From. Mutt Desktop writes MAILER-DAEMON for an empty sender, one holding whitespace, or one over 256 bytes, which NeoMutt writes as they are; whitespace would split the separator line and a long sender would not read back. Return-Path: <> gives From @ DATE (the <> fix), where NeoMutt writes From DATE.
Checking a mailbox A mailbox check reads only the file's status, not its contents. As in NeoMutt, an mtime-only change at the same size does not reload an mbox. Mutt Desktop also reloads when the file's identity changes at the same size, so it does not keep rows tied to a replaced file. An mbox that grew in place, with From at its old end, is read only from there, so the earlier messages keep their flags in memory, as mbox_mbox_check does; if another program holds the lock, the check ends silently and the next one tries again. Difference (agent judgment, ARCHITECTURE.md message-window-has-one-owner): an error on the message line stays while a later progress bar runs, so after Mailbox was externally modified. Flags may be wrong. the next check's Reading PATH... bar shows only once a key has cleared the error; NeoMutt's bar opens its own window over the error (progress/progress.c:152). Difference (origin: agent judgment): when that read fails with an I/O error, Mutt Desktop shows the error and keeps the index; NeoMutt shows Mailbox was corrupted and closes the mailbox after a failed seek (mbox/mbox.c:985-998, 1050-1057), and keeps the messages read before a failed read (397, 1005-1017).

POP mailboxes 2

A pop:// or pops:// URL in spool_file, mailboxes, or change-folder opens the server's mailbox, as NeoMutt's pop/ code does.

A pop:// or pops:// URL in spool_file, mailboxes, or change-folder opens the server's mailbox, as NeoMutt's pop/ code does. The sidebar lists the POP servers mailboxes and spool_file name. Login and TLS follow the pop_* rows.

mixed POP mailboxes reference table
Behavior Mutt Desktop
Opening Fetching list of messages...: UIDL, then LIST and TOP n 0 for every message the header cache does not know. A message starts read when its body is in message_cache_dir, old under mark_old when the header cache knows it, else new, as pop_fetch_headers decides. Login follows the pop_* rows: SASL through the macOS Cyrus SASL library, then APOP, then USER/PASS, as a NeoMutt build with Cyrus SASL tries them. A mailbox mailboxes lists keeps its account's capabilities after it closes, so reopening it sends no CAPA, as in NeoMutt.
Reading A message in message_cache_dir opens without RETR. Otherwise RETR, with Fetching message..., writes it there, or, without message_cache_dir, into a private temporary file. Ten slots chosen by message number modulo ten keep read messages until the mailbox closes, a sync, or renumbering clears them. POP cache directories and filenames use SHA-256 of the full endpoint and UIDL ID, so distinct names that NeoMutt's sanitizing would merge cannot substitute each other's bodies. Existing NeoMutt POP body cache files are not reused. Non-ASCII UIDL bytes are mapped one-to-one before hashing and keying the header cache; host or user values that lose bytes in NeoMutt's account URL add a hash to the header cache folder name. A message over 4 GiB fails. As pop_msg_open does, the index row then takes the header and size of the whole message.
Rights As a NeoMutt build with a header cache grants a POP mailbox the SEEN, DELETE, and WRITE rights: toggle-new, flag-message, and a sent reply change the open mailbox, the server keeps no flags, and header_cache keeps flagged and replied states across sessions; edit-raw-message reports Can't edit message: Operation not permitted by ACL, and edit-or-view-raw-message views.
Deleting sync-mailbox and leaving the mailbox send DELE for each deleted message, then QUIT, which makes the deletions permanent. A confirmed QUIT removes accepted deletions from both caches. If a later DELE is refused, the connection closes without QUIT, so earlier accepted deletions cannot be committed by mailbox close. The mailbox is not listed again after the sync: pop_mbox_sync sets its check time to 0, so the next mailbox check logs in and lists it, as NeoMutt does. A message UIDL no longer lists is marked deleted, with N messages have been lost. Try reopening the mailbox. As in NeoMutt, a lost message counts among the deleted ones for the Purge question only once a check also adds messages.
Checking At most every pop_check_interval seconds: log out, log in, and read UIDL for new messages. A read-only mailbox sends RSET before each QUIT, as pop_logout does.
Badge count A Dock or menu bar badge count keeps its POP session for later counts and names its caches with the logged-in user. The first user open runs account-hook and logs in with its result; the badge session supplies neither a password nor capabilities to that open.
Lost connection Logs in again at once and maps UIDL to the new message numbers; asks under pop_reconnect only when that fails.
Closing Leaving the mailbox sends QUIT, after RSET when it was opened read-only.
Copying in A POP mailbox cannot receive messages: copy-message and save-message report Can't save message to POP mailbox, as NeoMutt's mutt_save_confirm does. Copying out of one requires the whole source message to fit the 32 MiB POP read limit. A Sent copy into one asks Fcc failed. (r)etry, alternate (m)ailbox, or (s)kip?, and postponing into one fails without a message, leaving the composer open, as mutt_write_fcc cannot open a POP mailbox for appending.
Safety As in NeoMutt, a user or password containing CR or LF is sent as given, a user or password ends at its first NUL, and a POP URL whose user or password decodes to a NUL is invalid. Differences: bytes a server sends after its STLS answer are discarded before TLS starts, where NeoMutt can wait for them without end; and the capabilities the server listed before STLS are discarded, so CAPA (or AUTH) is asked again over TLS, where NeoMutt keeps the plaintext answer and asks again only if CAPA worked (RFC 2595 section 4).
UIDL lines Read as NeoMutt's fetch_uidl and check_uidl read them: a number as strtol or strtoul reads it, spaces, then the unique ID; only an overflowing number fails the listing, and a line such as garbage is message 0. NeoMutt indexes its message cache with a message number of 0 or below outside the array; Mutt Desktop keeps that slot in range.
Accounts A POP URL belongs to the first account with the same host and current user, compared without case and whatever the scheme or port, as NeoMutt's pop_ac_owns_path decides; the account connects with the settings of the URL that created it, and a URL without a user matches it only until its login resolves the user. fetch-mail never uses these accounts.
Sizes and dates As in NeoMutt: %c shows the body length pop_read_header computes, the LIST size less the TOP header and one byte for each header line, and %cr shows that length plus the header; once the message is read, both come from the retrieved message. A negative length, from a LIST size smaller than the header, is shown as the size_t NeoMutt converts it to. A message the header cache knows keeps the sizes stored with it. Header parsing sets received from a valid internal From line or a Received header with a semicolon while the value is zero. An invalid Received blocks later sources, then resets to the epoch. A missing or invalid Date takes received.
Names As in NeoMutt, a POP mailbox is named by its path as written, which pop_path_canon leaves unchanged: two texts for one account are two mailboxes that share the account's login and caches, and unmailboxes removes only the same text. Once a mailbox opens, the sidebar and status bar show the path pop_mbox_open gives it: pop:// or pops://, the URL user, the host as written, a port only when the URL named one, and no path. Two texts that differ only in their URL password are two mailboxes, as in NeoMutt, and both log in with the password of the account's first URL; Mutt Desktop never shows a password, so their sidebar rows look alike. A folder-hook matches the path NeoMutt's mutt_folder_hook gets: the text as written, password included, until the mailbox first opens, and the opened path when a listed mailbox is entered again. Differences: before a mailbox opens, NeoMutt's sidebar and status bar can show its URL password (abbrev_url keeps it when no / follows the host), and NeoMutt shows a URL query; Mutt Desktop shows neither. NeoMutt also matches a later change-folder against the rewritten path; Mutt Desktop keeps matching the listed text, because that text identifies the mailbox's queued changes, tags, and POP session.
Limits Difference: Mutt Desktop reads at most 1 MiB of CAPA or AUTH listing, 500,000 UIDL lines or 40 MiB of UIDL text, and a 32 MiB TOP header. Every POP read that returns a whole message as Data, including a cache read, selected part, or transfer, is capped at 32 MiB. A larger message reports The message is too large to read. even when the selected part is small. NeoMutt keeps the message in a file and can open that part. The cap prevents a server or cache file from making the app allocate the whole large message.
Messages As in NeoMutt, a check shows Fetching message headers... progress paced by read_inc, a connection shows Looking up HOST... and Connecting to HOST..., and The message index is incorrect. Try reopening the mailbox. leaves the next check to mail_check.
Security difference: password in Reading Opening a mailbox shows Reading PATH... without a password written in a POP or IMAP URL. NeoMutt shows a POP path as written, password included.

HTML message appearance 2

addition HTML messages use a light canvas by default, including when macOS uses Dark Mode.

HTML messages use a light canvas by default, including when macOS uses Dark Mode. This keeps ordinary black email text readable. Set my_muttdesktop_html_appearance=dark for a dark canvas or my_muttdesktop_html_appearance=system to follow macOS. The option changes the HTML viewer, including attached HTML and compose previews; plain-text messages keep the app's system colors. Sender-specified text and background colors remain in effect, so some messages can still have poor contrast.

difference Bind my-muttdesktop-toggle-html-appearance in index and pager, for example with bind index,pager <f12> my-muttdesktop-toggle-html-appearance.

Bind my-muttdesktop-toggle-html-appearance in index and pager, for example with bind index,pager <f12> my-muttdesktop-toggle-html-appearance. The first press chooses the opposite of the selected HTML message's configured appearance, and the second restores the setting. A new selection clears the temporary choice. The function has no default key; it does not reload the message or grant remote-image access. If remote images are already allowed, sender CSS can request different images in each appearance.

Message line 4

As in NeoMutt, a message shows at most its first 1,023 bytes (ErrorBuf), at a prompt too; a character the cut splits is dropped, as the terminal draws nothing for it.

As in NeoMutt, a message shows at most its first 1,023 bytes (ErrorBuf), at a prompt too; a character the cut splits is dropped, as the terminal draws nothing for it. The terminal log keeps the whole text.

difference Owner difference (2026-10-20): NeoMutt's message window grows to three rows for a long message.

Owner difference (2026-10-20): NeoMutt's message window grows to three rows for a long message. Mutt Desktop keeps one row. A message wider than the line stays still for 1.5 seconds, scrolls left until its end shows, stays still for 1.5 seconds again, and starts over; one that fits does not move. With Reduce Motion on in macOS, the line does not scroll and the end of a long message is cut.

addition Drag to select text in the mailbox status line or message line, then press Command-C to copy it.

Owner-approved Mutt Desktop addition (2026-10-22): drag to select text in the mailbox status line or bottom message line, including the version shown by V, then press Command-C to copy it. Selection leaves the active NeoMutt key menu and message timing unchanged.

difference Esc or Ctrl-G clears a visible V version message.

Owner-approved difference (2026-10-25; first version 0.2.1): in the message list or pager, a physical Esc or Ctrl-G clears the visible short version message without changing the mailbox status line. Esc still starts a key sequence. Other messages keep their usual timing. NeoMutt leaves this message visible after an abort key (index/dlg_index.c:1316-1320, pager/dlg_pager.c:508-515); Esc also stays in km_dokey_event until a following key or timeout (key/get.c:419-523).

Keyboard divider resize 2

addition In the index or pager, Ctrl-W opens divider controls; Left and Right, with or without Control held, keep moving the divider until Esc.

In the index or pager, Ctrl-W then = gives the message list and pager equal widths. Ctrl-W then - moves their divider 80 points left; Ctrl-W then + moves it 80 points right. Ctrl-W then Left or Right enters resize mode and moves the divider 80 points per keypress. Ctrl-Left and Ctrl-Right work there too, so Control can stay held after Ctrl-W. The message line keeps the Left/Right and Esc hint visible during resize mode. Esc or Ctrl-G exits it and clears the hint; another key exits the mode and runs normally. Before an arrow starts resize mode, Esc or Ctrl-G cancels the Ctrl-W sequence, and a one-second key timeout clears its hint. The width is saved for the next launch and stays fixed across account switches.

addition These three functions can be rebound in the index or pager menu: my-muttdesktop-equalize-message-panes, my-muttdesktop-move-message-divider-left, and my-muttdesktop-move-message...

These three functions can be rebound in the index or pager menu: my-muttdesktop-equalize-message-panes, my-muttdesktop-move-message-divider-left, and my-muttdesktop-move-message-divider-right. NeoMutt has no message-list/pager divider or matching functions. Its bind command names a function in the chosen menu; it does not define a new function.

Text attachment charsets 1

difference Opening a text attachment converts it from its declared charset, such as iso-8859-1 or shift_jis, so its text reads correctly.

Opening a text attachment converts it from its declared charset, such as iso-8859-1 or shift_jis, so its text reads correctly. NeoMutt converts only a text part shown inline (mutt_decode_attachment, handler.c:1908); a text file sent as an attachment in a charset other than the terminal's shows its raw bytes there (owner, 2026-10-21).

Mail window reopening 1

addition Command-W or the red close control hides the mail window while Mutt Desktop stays open.

Command-W or the red close control hides the mail window while Mutt Desktop stays open. Choose Window → Message List or click the Dock icon to show the same window again, at its saved size and divider position. This is a Mutt Desktop-only window action; NeoMutt has no macOS window. While a draft is open, the mail window still reads messages and accepts its own keys. The compose window receives only its own keys. Window → Return to Draft or Command-Shift-C returns to the open draft. Starting another draft reports A compose window is already open. in the mail window. An account switch reports Can't switch account with the compose window open. Send, postpone, or abandon the draft before switching.

Native sidebar 1

mixed Mutt Desktop has a native sidebar instead of NeoMutt's built-in sidebar, which it does not support and will not (owner decision, 2026-10-18).

Mutt Desktop has a native sidebar instead of NeoMutt's built-in sidebar, which it does not support and will not (owner decision, 2026-10-18). A clicked mailbox stays selected while the previous mailbox closes; if that close is refused, selection returns to the previous mailbox (owner decision, 2026-10-21). As in NeoMutt, where sidebar-open runs only from the index and pager, a sidebar or menu-bar Inbox click does nothing while a folder change holds the window or while the folder browser, the attachment list, an attachment's view, or the postponed list shows. A sidebar click during other work, such as a mailbox check, waits for that work to end, as a key does; it then does nothing if one of those four views shows or a prompt or question is open. During fetch-mail or an error pause, a sidebar click does nothing. Mutt Desktop-only (owner-approved 2026-10-21): a sidebar or menu-bar Inbox click also does nothing while an account switch is leaving the old account. Owner-approved difference (2026-10-21): an open compose window does not block a sidebar click, because compose has its own window; NeoMutt's composer replaces the index on screen (compose/dlg_compose.c:454-462). The native sidebar shows one row per mailboxes entry, in command order, with its unread count (see the mailboxes row). After the filters below, sidebar_sort orders the rows by message, unread, or flagged count, path, label, or command order, as in NeoMutt; like NeoMutt, it takes no reverse- form. A row is bold while its mailbox has new mail, where NeoMutt's default sidebar_format shows %n and color sidebar_new colors the row (has_new); opening the mailbox clears it. The sidebar color objects (sidebar_new, sidebar_unread, sidebar_flagged, sidebar_highlight, sidebar_indicator, sidebar_ordinary, sidebar_spool_file, sidebar_divider, sidebar_background) are ignored and will not be supported (owner decision, 2026-10-20), and so is sidebar_format, whose fixed-width padding native rows cannot follow; each row shows its default %D text. The sidebar functions (sidebar-next, sidebar-prev, sidebar-next-new, sidebar-prev-new, sidebar-first, sidebar-last, sidebar-page-up, sidebar-page-down, sidebar-open) and sidebar_next_new_wrap are not implemented yet (planned for 0.3.1); choose a mailbox with change-folder or a click. sidebar_width, sidebar_on_right, sidebar_divider_char, and sidebar-toggle-virtual will not be supported (owner decision, 2026-10-20): the split view sets and saves the width, keeps the sidebar on the leading side, and draws its own divider, and Mutt Desktop has no notmuch mailboxes. sidebar_new_mail_only hides a mailbox with no unread or flagged messages and no new mail, and sidebar_non_empty_mailbox_only hides an empty one; neither hides the open mailbox or one that sidebar_pin names (by path, expanded as buf_expand_path expands it, or by label), as in NeoMutt. sidebar_unpin removes a name, and sidebar_unpin * all of them; sidebar_whitelist and unsidebar_whitelist are the older names. Security difference: a sidebar_pin or sidebar_unpin word that holds a password (from a password option such as $imap_pass) is refused, as other commands refuse one; NeoMutt stores the word, an IMAP URL without its password. Owner-approved difference (2026-10-20): an IMAP row's icon comes from the special-use attributes (\Sent, \Drafts, \Trash, \Junk, \Archive, \Flagged) of a LIST "" "*" sent after the startup mailbox and index open; a local startup requests it only when mailboxes names an IMAP mailbox; NeoMutt sends only LIST "" "" at login. sidebar_visible sets visibility at launch, and sidebar-toggle-visible changes it. Command-1 through Command-9 keep the current visibility and dragged width across account switches; the width remains saved on this Mac. As in NeoMutt's default sidebar_format, each row shows %D: the mailbox's label, else its path under folder, or, for a path outside folder, an IMAP or POP URL after the first / from its eleventh byte on (after the host, unless the host is very short) and the whole path of a local mailbox. A POP row is shortened from its path without the password, so a folder that holds a POP password does not shorten it. sidebar_short_path, sidebar_delim_chars, sidebar_folder_indent, sidebar_indent_string, and sidebar_component_depth change that text and its indent as in NeoMutt; the indent is drawn in the sidebar's proportional font. Difference (NeoMutt bug): without sidebar_short_path, sidebar_component_depth also removes that many leading parts from a path under folder, as NeoMutt's documentation of the option describes (docs/config.c:4379-4384), where NeoMutt's code (sidebar/window.c:589-595) only lowers the indent. sidebar_format and every other sidebar_* option are ignored. Ctrl-F toggles it in the index and pager (owner decision, 2026-10-19). NeoMutt binds Ctrl-F to forget-passphrase, which Mutt Desktop does not support. Configured bindings and unbinds override this default; the editor keeps Ctrl-F for forward-char. In 0.2.1, icons may appear after the startup mailbox opens. A failed IMAP startup open skips the icon listing and keeps the mailbox error visible.

One IMAP server and user per account 4

difference Each Mutt Desktop account uses one IMAP login identity, a deliberate difference from NeoMutt (owner decision, 2026-10-18).

Each Mutt Desktop account uses one IMAP login identity (server and user), a deliberate difference from NeoMutt (owner decision, 2026-10-18).

NeoMutt can use mailboxes on several IMAP logins in one session.

NeoMutt can use mailboxes on several IMAP logins in one session. A mailboxes, change-folder, record, postponed, trash, or mbox path on another server, or for another user on the same server, opens a second connection and logs in, and folder hooks switch from, smtp_url, and other settings when you enter that login's folders.

The login is the server and user of the account's spool_file, or of folder when spool_file is not an IMAP URL.

The login is the server and user of the account's spool_file, or of folder when spool_file is not an IMAP URL. Every folder on that login works. A path on any other IMAP login is never opened and never sent to the account's server: mailboxes drops it, record, postponed, and trash refuse it when they are used, change-folder reports that the answer is not a mailbox, and closing the spool_file moves no read messages to an mbox on it. The login stays the one read when the account opens: after a folder hook sets folder or spool_file to another login, + and = paths name that login and are refused the same way.

To read mail on another login, add it as its own account in Mutt Desktop → Settings… and switch with File → Switch Account or ⌘1–⌘9.

To read mail on another login, add it as its own account in Mutt Desktop → Settings… and switch with File → Switch Account or ⌘1–⌘9.

Splitting a multi-login muttrc 5

Keep the shared settings in one muttrc and move each login into a small file that an account variable selects:

Keep the shared settings in one muttrc and move each login into a small file that an account variable selects:

muttrc
# ~/.mutt/muttrc: shared by every account
set sort = threads
set editor = nvim
source ~/.mutt/$LOCAL_CONFIG
muttrc
# ~/.mutt/personal
set folder = "imaps://you@mail.example.com/"
set spool_file = "+INBOX"
set from = "You <you@example.com>"
set smtp_url = "smtps://you@mail.example.com"
muttrc
# ~/.mutt/work
set folder = "imaps://you@mail.example.org/"
set spool_file = "+INBOX"
set from = "You <you@example.org>"
set smtp_url = "smtps://you@mail.example.org"
In Settings, both accounts read ~/.mutt/muttrc; one sets LOCAL_CONFIG to personal, the other to work.

In Settings, both accounts read ~/.mutt/muttrc; one sets LOCAL_CONFIG to personal, the other to work.

IMAP mailboxes 2

Opening an IMAP mailbox follows NeoMutt's imap_read_headers (read_headers_normal_eval_cache, read_headers_fetch_new, imap_fetch_msn_seqset).

Opening an IMAP mailbox follows NeoMutt's imap_read_headers (read_headers_normal_eval_cache, read_headers_fetch_new, imap_fetch_msn_seqset).

mixed IMAP mailboxes reference table
Behavior Mutt Desktop
Download With a header cache for the mailbox's UIDVALIDITY, UID FETCH 1:UIDNEXT-1 (UID FLAGS), then FETCH by message number for the messages with no cached header, in sets that end once their text passes 500 characters. Without one, one FETCH 1:N. Headers come as BODY.PEEK[HEADER.FIELDS (...)], never ENVELOPE. A failed FETCH ends the load, with no retry. Progress follows each response, as progress_update does.
Skipped responses As in NeoMutt, a response without a UID, with a message number out of range, repeating a message number, or without header data is skipped. An EXPUNGE moves the message numbers as cmd_parse_expunge does, and an EXISTS above the current count raises the bound before the next FETCH. The mailbox is not selected again after the download.
Header cache With header_cache set, each mailbox creation, header download, expunge, and sync opens Mutt Desktop's LMDB file and closes it at that operation's end. Difference (owner, 2026-10-25): the file is NeoMutt's name plus .muttdesktop, with a leading dot in a directory so NeoMutt's message_cache_clean skips it; NeoMutt's file is never read or written and alternating clients keep both caches warm; the first Mutt Desktop open downloads headers once. A directory holds a file per mailbox; one file can hold POP and IMAP entries. The cache keeps UIDVALIDITY and UIDNEXT (max(UIDNEXT, highest UID + 1)) with the headers. A new IMAP mailbox reads those values when it opens after the folder hook; the header download opens the cache chosen for that operation. The cache pass runs only when both values exist, covering UIDs 1 through the cached UIDNEXT minus 1. Each UID FETCH reply reads that UID's cached header. New headers are written as they arrive; EXPUNGE and sync delete their named UIDs. An initial download stores the SELECT's HIGHESTMODSEQ as MODSEQ when the server has CONDSTORE and imap_condstore is set or the login enabled QRESYNC, else deletes MODSEQ; when the login enabled QRESYNC it also stores the UIDs by message number as UIDSEQSET (imap_msn_index_to_uid_seqset's text, an empty number as 0, with its NUL), else deletes UIDSEQSET. Under imap_condstore, a cache that holds a MODSEQ keeps each cached message's flags and fetches only the flags changed since that MODSEQ; such a message keeps its cached keywords, where NeoMutt's read_headers_normal_eval_cache clears them (imap/message.c:803-805) against its comment that the cached flags are kept (719-721) (NeoMutt bug). Under QRESYNC, a cache that holds a MODSEQ and a UIDSEQSET numbers the cached messages from the UIDSEQSET with Evaluating cache... and no command, then fetches the changed flags with (CHANGEDSINCE MODSEQ VANISHED); a UID that then appears twice, or a message that an EXPUNGE or VANISHED removes after those flag updates, shows QRESYNC failed. Reopening mailbox., deletes MODSEQ and UIDSEQSET, and reads the mailbox again. Difference: a message that VANISHED removes during those flag updates leaves the message list, so the open goes on; NeoMutt's imap_expunge_mailbox frees its IMAP data but leaves it in the list, since at an open no index view exists to run update_tables (index/dlg_index.c:695-697, mview.c:342), and imap_verify_qresync then fails every such open on it (imap/message.c:1054-1055), against the intent of its VANISHED handling (1002-1010) (NeoMutt bug). Difference: an empty stored UIDSEQSET, which a download that lists no message stores, opens with no cached message; NeoMutt cannot read it (imap/util.c:1129-1130) and fails that open and every later one of the mailbox (imap/message.c:1440) (NeoMutt bug). A UIDSEQSET that does not parse fails the open with Error opening mailbox, as in NeoMutt. Evaluating cache... and QRESYNC failed. Reopening mailbox. show where the open's progress shows, as NeoMutt shows them only on a verbose open: on an index open, the postponed list's open, an IMAP spool_file open by fetch-mail, and the reopen after a reconnect, not on another quiet reload. A header download that fails, including a FETCH refused before its first reply, shows Error opening mailbox on any open or quiet reload; when it lost the connection, the socket error comes first, then, for the index's or the postponed list's open, the reconnect's messages. A failed header read in the reopen after a reconnect, of the open mailbox or of postponed, shows nothing of its own before Reconnected to HOST but failed to reopen mailbox, as NeoMutt's imap_reopen_mailbox does. A fetch-mail spool open that loses the connection logs in again and reopens the spool before it stops without fetching a POP message. A failed first open keeps fetched headers and the prior raw metadata. Unset header_cache leaves no IMAP header cache. Each build's HCACHEVER makes another build's entry a miss. When NeoMutt's account URL truncates a user or host, an IMAP cache key adds the full endpoint digest to prevent account collisions. The database and lock file are private, and symlinks and hard links are refused; NeoMutt leaves their modes to the umask. A creating open unlinks a confirmed incompatible file and retries once, as NeoMutt does. Read-only or transient open errors preserve the file, while NeoMutt unlinks it. Overlong LMDB keys are skipped without aborting other staged writes, and values above 33 MiB are rejected before allocation; NeoMutt aborts the current write transaction for an overlong key and has no value cap.
Reply fields The download asks for NeoMutt's want_headers only, so Bcc and Mail-Followup-To come when a message is opened, as imap_msg_open reads the header again. imap_headers adds its fields to NeoMutt's list.
Security difference: unique UID Message identity is the folder, UIDVALIDITY, and UID, so a row needs a nonzero UID that no other row of the listing has, where NeoMutt dedupes by message number only.
Security difference: header block size A header block above 1 MiB is cut to its first 1 MiB and logged at debug level by UID; the message still lists. NeoMutt keeps any size.
Security difference: response caps More FETCH responses than twice the expected number plus 100 (102 for a one-message fetch), more EXPUNGE or EXISTS responses than that, or a part fetch with more than 100 unrelated responses close the connection. The selected mailbox also retains at most 4,096 pending FLAGS replies; another one drops the connection. NeoMutt accepts any number.
Security difference: announced count A server that announces more than 10,000,000 messages, by SELECT or EXISTS, fails the listing; after the open, its connection is dropped and nothing is fetched.
Security difference: selecting the open mailbox again After a second mailbox of the account is used, the SELECT that returns to the open mailbox must report the UIDVALIDITY, the message count its message-number table holds, and the UIDNEXT it had, and must bring no EXPUNGE or FETCH, which is not expected in a SELECT response and is taken as a sign the mailbox changed, nor an EXISTS above that count. Until it passes, no change reaches the index; if it fails, no mailbox counts as selected, the changes held for the index are discarded, and the next check reopens the mailbox. NeoMutt keeps the table without comparing, so later replies could name the wrong messages. As NeoMutt's imap_mbox_select does, the SELECT goes out without a stale-connection NOOP first. Decided with /principal:decide.
Security difference: NOOP replies A NOOP keeps at most 1,024 untagged replies for itself; every reply still reaches the open mailbox.
Security difference: idle responses More than 1,024 unsolicited responses or 256 KiB of them while no command runs, a BYE, or a fatal response closes the connection; the next command fails and Mutt Desktop logs in again.
Security difference: lost connection A command on a lost connection fails and is never sent again. Mutt Desktop logs in again at once, as cmd_handle_fatal does, where SwiftMail's own silent reconnect is off.
URLs Every mailbox, account, smtp_url, and mailto: URL is read as NeoMutt's url_parse reads it, with PREX_URL's characters, and an IMAP URL is written back as imap_path_canon writes it, without its password. Difference (a NeoMutt defect not copied): a combining mark (a decomposed accent, as macOS file names hold) is accepted in a user name, host, or path; NeoMutt's PREX_URL refuses it, so NeoMutt cannot name such a mailbox by URL. Security difference: an IMAP URL's query, which imap_parse_path ignores and which can carry a credential, is left out of every mailbox path Mutt Desktop keeps or writes, including the Mutt-Fcc header; NeoMutt writes it back. Security difference: an imap:// or imaps:// text that url_parse reads only as a path, such as one whose password holds a /, is kept as written, where NeoMutt's imap_path_canon collapses its // and so hides its password from redaction.
Login imap_open_connection and imap_login: a greeting without capabilities gets CAPABILITY, and a server that then advertises neither IMAP4 nor IMAP4rev1 is refused with This IMAP server is ancient. Mutt Desktop does not work with it. A PREAUTH greeting logs in without LOGIN or a password question; on a connection that is not yet encrypted it is refused with Encrypted connection unavailable, as NeoMutt refuses it under its default ssl_force_tls. Any other greeting, such as BYE, shows imap_open_connection() [LINE]. With no imap_authenticators list, a TLS connection with SASL-IR and an advertised OAuth mechanism tries OAUTHBEARER, XOAUTH2, PLAIN, Cyrus SASL, then LOGIN. A configured colon-separated list selects and orders those methods, including Cyrus mechanisms. imap_oauth_refresh_command supplies the token from its first output line, and imap_login supplies the OAuth identity. AUTHENTICATE PLAIN runs even when not advertised: with SASL-IR its credentials are inline; otherwise they follow the server continuation. A tagged refusal falls through to one LOGIN unless the server advertises LOGINDISABLED. The password is read only when PLAIN, Cyrus SASL, or LOGIN needs it and is shared by those methods. A successful method is followed by CAPABILITY; then ENABLE UTF8=ACCEPT (under imap_rfc5161, when the server advertises ENABLE) and LIST "" "" go out in one write, and LIST sets the delimiter used for mailbox names until the connection closes. A refusal of the CAPABILITY, ENABLE, or LIST that follows LOGIN does not stop the login. Under imap_rfc5161 and imap_qresync, a server that advertises QRESYNC also gets ENABLE QRESYNC in that write, and an ENABLED QRESYNC reply turns QRESYNC on. No NAMESPACE is sent. Difference (NeoMutt bug): QRESYNC and UTF-8 names are on only for a login whose ENABLED named them; NeoMutt's cmd_parse_enabled sets adata->qresync and adata->unicode (imap/command.c:1058-1061) and nothing clears them, so after a reconnect whose server did not enable them they stay on, against the comment on adata->qresync, "true, if QRESYNC is successfully ENABLE'd" (imap/adata.h:66). Difference (NeoMutt bug, agent judgment): a password in the IMAP URL of folder, spool_file, or a mailboxes entry is used for the account's login until a login succeeds. NeoMutt never uses it: mx_path_canon2 replaces the mailbox path with the form url_tobuffer writes, which has no password (mx.c:1484-1496; email/url.c:360-391), so imap_ac_add parses a path without one. NeoMutt's manual documents the URL as "proto[s]://[username[:password]@]server[:port][/path]" (docs/manual.xml.head:12504) and says "Since all protocols supported by NeoMutt support/require authentication, login credentials may be specified in the URL." (docs/manual.xml.head:12513-12515). Difference (a NeoMutt defect not copied): a NIL root delimiter leaves /; NeoMutt stores 0, and imap_fix_path_with_delim then writes a NUL for each /, which cuts a/b to a.
Mailbox names imap_munge_mbox_name sends UTF-8 after UTF8=ACCEPT is enabled; otherwise it sends modified UTF-7. Both forms are quoted and escaped on the wire, including long names. imap_unmunge_mbox_name decodes LIST, LSUB, and STATUS names using the same login state. This applies to mailbox selection, listing patterns, copy, append, status, and mailbox management. Difference (a NeoMutt tokenizer bug): a literal LIST, LSUB, or STATUS name is decoded like a quoted name. NeoMutt skips decoding literals (imap/command.c:712-743, 907-934), despite noting that literal LIST replies need a real tokenizer. Security differences: invalid or noncanonical names in a server reply are omitted from listings and STATUS updates; outgoing and decoded names are capped at 4,096 wire bytes. NeoMutt keeps the invalid raw bytes and does not apply this cap. A lossy UTF-8 conversion can turn invalid bytes into the name of another mailbox.
Opening mx_mbox_open shows Reading URL... with the mailbox's account URL, and imap_mbox_open shows Selecting MAILBOX...; the line clears when the open succeeds. MYRIGHTS (when the server has ACL) and SELECT go out in one write; a mailbox opened read-only is opened with EXAMINE; one whose rights grant none of delete, seen, write, and insert is selected and then treated as read-only. The rights are read only at the open; delete-message, undelete-message, delete-pattern, undelete-pattern, toggle-new, flag-message, edit-raw-message, and edit-or-view-raw-message check them when pressed, as check_acl does.
Reading a message NeoMutt imap_msg_open first looks in message_cache_dir, before any IMAP command (imap/message.c:2025-2037). Mutt Desktop also reads a canonical cached body without an IMAP command, including on the first open after a restart; on a miss it shows Fetching message... before the open's first command, after the wait that follows an error. A cache that cannot be used shows its error first. An empty entry counts as cached; Mutt Desktop then reads the message from the server, as the empty-body difference in the message_cache_dir option entry describes, and shows the text before that read. Once the message is read, the line clears, whatever it shows then (imap/message.c:2172): after every open that fetched the message, and after the first open of a cached message, which shows no text. A later open of a cached message that an earlier open read shows and clears nothing. This holds for every open: the pager's, the attachment menu's, a reply's and a forward's read of each message, edit-raw-message's, a postponed draft's recall (postpone/postpone.c:497), the %X count and an index color or pattern scan whose pattern needs the message, as pattern_needs_msg decides, when they read the message (index/expando_index.c:388, index/dlg_index.c:1409-1435, pattern/exec.c:798-828), and every save or copy that reads the message through mutt_append_message (copy.c:991, external.c:749), such as the append that follows a refused UID COPY or a Trash move's append; a save's read clears the line before its append and counts as an open, so a later open of that message clears nothing. Difference not yet resolved (origin: agent judgment, chunk 6p-12): a limit that update_index applies again after a check opens no message, where NeoMutt opens each message it tests, with m->verbose off so no text shows (index/dlg_index.c:438-445, 512-513, 1234-1237), so a ~b or ~B limit applied again cannot add a new message by its body. Differences (origin: agent judgment): an unreadable cache entry is read from the server, so its open shows the text after its first command. When RFC822.SIZE is absent or greater than 32 MiB, Mutt Desktop reads bounded displayed sections without filling the cache; NeoMutt reads the whole message, and an oversized cache entry is never loaded into the viewer. Difference not yet resolved (origin: agent judgment, chunk 6p-12): a postponed draft's recall always reads the draft from the server and shows the text, also when message_cache_dir holds it, where mutt_prepare_template's open reads the cache (postpone/postpone.c:497, imap/message.c:2025). A failed open leaves its error on the line, as imap_msg_open clears only after a read that worked (imap/message.c:2172). Difference (origin: agent judgment): a background %X count or index color read runs after the key that drew its row, so it clears only its own text, shows nothing while the pager shows, and shows nothing and waits out no error_pause while an error shows or the line is held, so the error stays; NeoMutt opens these while it draws the index, where mutt_message waits out error_pause, shows the text, and mutt_clear_error empties the line (index/dlg_index.c:1302-1303; mutt_logging.c:74-83, 127-128; imap/message.c:2035, 2154). Message-list optimization difference (owner 2026-10-16): with imap_peek set, the %X count and a ~X pattern read a page of messages' structure in one FETCH, which opens no message, so no Fetching message... shows, where NeoMutt opens each message.
Checking imap_check_mailbox: before a command once mail_check seconds passed, and every second while no key comes under the same rule. With imap_idle set and advertised, the check sends IDLE, reads pending replies, and sends no timeout NOOP while idling. The next command sends the held DONE with its own command. A forced keep-alive sends DONE with NOOP. Without IDLE, NOOP is sent only once timeout seconds passed since the server's last response, or imap_keep_alive seconds while idle; a server silent for imap_poll_timeout seconds shows Connection to HOST timed out, the connection closes, and Mutt Desktop logs in again, as cmd_handle_fatal does. A command after 300 seconds without one sends NOOP first. While a check, or any command run while a reopen is allowed, fetches new mail, the message line shows Fetching message headers... N/M as read_inc paces it, counting from the first new message to the mailbox's new size; when the fetch ends, the message the bar covered shows again (with read_inc 0, the plain Fetching message headers... clears), as NeoMutt's progress_free does. The check then applies what every reply since brought and shows New mail in this mailbox, Mailbox was externally modified, or Mailbox was externally modified. Flags may be wrong. where NeoMutt does. A VANISHED reply removes the messages it names, moving the later message numbers down as EXPUNGE does. Differences: VANISHED (EARLIER) moves them down too, where NeoMutt's cmd_parse_vanished leaves them against its own comment that leaving them is wrong (imap/command.c:396-400), as Mutt does; left in place, a message expunged since the stored UIDSEQSET leaves a hole that the header FETCH fills with a message already listed, so most QRESYNC reopens fail (NeoMutt bug); a server that ends IDLE without DONE does not leave a stale DONE queued (NeoMutt bug); IDLE replies are bounded to prevent unbounded memory use (security); when an EXPUNGE reply removes messages, NeoMutt's update_tables also drops every message the user marked deleted and has not synced (mview.c:258-259), contrary to imap_expunge_mailbox's own comment that it must not remove messages no EXPUNGE named (imap/imap.c:785-799), and clears the queued changes of every message it keeps (mview.c:250, 275-276); Mutt Desktop removes only the messages the server expunged and keeps the other queued changes (NeoMutt bug); a flag change another client makes to a message with a queued change is compared with the flags the server last reported, where NeoMutt's imap_set_flags compares with an empty record (imap/message.c:1955).
Pattern search IMAP string patterns =b, =B, =h, and =/ run one UID SEARCH before the local pattern action. A search term containing CR or LF fails with IMAP search term contains a line break before a command is sent. Security difference (origin: agent judgment): NeoMutt's imap_quote_string allows those bytes, which could inject an IMAP command.
Refused commands As NeoMutt's imap_cmd_step does, every tagged NO or BAD shows IMAP command failed: LINE with the whole tagged line, and server text is never cut before the message line's own limit. A refused message read (the pager, a reply, a forward, an attachment) shows only that line; a reply then ends with Could not include all requested messages, and a forward goes on without that message. A refused APPEND then shows the NO text, if any, as an error, as imap_append_message does. For a Sent copy, the error shows, then waits out sleep_time, and the line clears before Fcc failed. For a postpone, the compose line shows the error, or the IMAP command failed line when the NO has no text or the reply is BAD. A fast Trash flag STORE that loses the connection reconnects and reopens before Continue?; Yes copies only messages the reopened mailbox marks deleted and drops local deletion changes. After a failed recovery login, Yes reaches a COPY that fails unsent on the closed connection, logs in and reselects without reading headers again, then appends the retained deleted messages. Mail safety difference (agent judgment): Mutt Desktop models that closed-socket COPY failure without calling the writer again. NeoMutt queues COPY and its socket rejects the send before any bytes leave (conn/socket.c:148-151); the app's writer would recover first and could repeat the uncertain flag STORE or send COPY after reconnect. Modeling the unsent failure preserves the error and append order without retrying the uncertain STORE. After a refused Trash COPY with [TRYCREATE], a CREATE whose read loses the connection reconnects and reopens before CREATE failed: and imap_fast_trash []; Trash then receives APPENDs of only reopened deleted messages, without repeating COPY. A copy or save ends on Error copying message, Error saving message, or their tagged forms, which in NeoMutt replace the NO text at once. When the server refuses the new copy that sync uploads for a message whose thread was linked or broken, the connection stays open.
Other imap_fetch_chunk_size is not read, as with NeoMutt's default: without a cache a download is one FETCH, and with one the missing numbers go in sets of about 500 characters.

Mutt Desktop-only options 1

addition Mutt Desktop-only options reference table
Option Type Default Mutt Desktop behavior
my_muttdesktop_index_font NeoMutt my_ user variable interpreted by Mutt Desktop unset The message index font: a family such as SF Mono or a font name such as Menlo-Regular. Unset uses the system monospaced font. A font that is not installed is reported at startup when no config notice comes first, and the index uses the system monospaced font.
my_muttdesktop_index_alternating_rows NeoMutt my_ user variable interpreted by Mutt Desktop no yes gives index rows and attachment-browser rows the system's alternating backgrounds, white and a very light gray in light mode. Other values are reported and the previous value kept.
my_muttdesktop_status_bar NeoMutt my_ user variable interpreted by Mutt Desktop yes no hides the mailbox status bar, which NeoMutt always shows. Other values are reported and the previous value kept.
my_muttdesktop_autopreview NeoMutt my_ user variable interpreted by Mutt Desktop no yes shows the selected message in the message panel while in the index and marks it read once its body loads, as the pager does, so moving the cursor reads each message it stops on. no keeps NeoMutt's behavior: the panel shows a message only in the pager. The preview runs no message-hook; the pager does. Other values are reported and the previous value kept.
my_muttdesktop_switch_account NeoMutt my_ user variable interpreted by Mutt Desktop as a quadoption yes Controls Command-1 through Command-9, which switch to the saved account at that position. The open account's config supplies it. yes switches without asking, no does not switch, and ask-yes or ask-no asks Switch accounts? with that default, except before any mailbox has loaded, when there is nothing to close. File → Switch Account never asks. Switching ignores $quit. Once a switch goes ahead, the open mailbox closes as NeoMutt's mx_mbox_close does, with its move and purge questions. The question offers no ? help, since NeoMutt has no such option. During the switch, the mail window shows the chosen account and hides old rows; navigation keys wait for the target mailbox, close questions still read their answers, and a failed switch returns queued keys to the previous mailbox.
my_muttdesktop_start_account NeoMutt my_ user variable interpreted by Mutt Desktop first In the first saved account's muttrc, first opens that account on launch; last opens the last successfully switched account. The first muttrc is read before this choice.
my_muttdesktop_index_font_size NeoMutt my_ user variable interpreted by Mutt Desktop unset The message index font size in points, from 6 to 72. Unset uses the system body size. An invalid value is reported and the previous value kept. Cmd-+ or Cmd-= increases the message list and preview text by one point; Cmd-- decreases them. Cmd-0 restores the current account's configured list size and the preview's normal body size. The keyboard-selected size is one global setting, saved across launches; neither list nor preview size changes when accounts switch. The shortcuts do not edit the config. These shortcuts are an owner-approved Mutt Desktop addition (2026-10-19); the global scope is an owner correction (2026-10-21).
my_muttmailbox_dock_badge NeoMutt my_ user variable interpreted by Mutt Desktop no yes shows the number of new messages in the active account's Inbox on the macOS Dock icon, including while another folder is open. New means unread, not old, and not deleted. Zero clears the badge. An IMAP Inbox outside the open folder is checked with a read-only EXAMINE and an exact search on the isolated metadata connection; the open folder keeps its selected identity. A closed POP Inbox refreshes its count from UIDL on the kept login. Either Inbox indicator requests that count after mailbox checks. A pending IMAP count is shared by later checks and never holds navigation keys; the previous count remains visible until completion. The option name is an owner-approved exception to the app-key prefix rule.
my_muttdesktop_menu_bar_badge NeoMutt my_ user variable interpreted by Mutt Desktop no yes shows the macOS envelope symbol and the same active-account Inbox new-message count in the menu bar. At zero, the envelope remains without a number. Clicking it brings the mail window forward, opens the Inbox, and selects its first new message. It does nothing while a prompt, the folder browser, the postponed list, an attachment list or view, a folder change, an account switch, a sync, fetch-mail, or an error pause is active; during other work, such as a mailbox check, the Inbox opens when that work ends, as a sidebar click does. The Window menu's Open Inbox command provides keyboard access. The menu bar and Dock settings work independently.
my_muttdesktop_delete_clears_new NeoMutt my_ user variable interpreted by Mutt Desktop no yes marks a message read when delete-message, delete-thread, delete-subthread, purge-thread, delete-pattern, set-flag D, or score_threshold_delete marks it deleted, as clear-flag N does, so a Trash copy is not new. undelete-message does not make it unread again. The option does not apply to save-message or edit-raw-message; delete-message on a message save-message marked sends it to Trash and marks it read. A mailbox whose MYRIGHTS lack SEEN keeps it unread. Other values are reported and the previous value kept.
my_muttdesktop_remote_content NeoMutt my_ user variable interpreted by Mutt Desktop as a quadoption ask-no Controls remote images in HTML mail. no blocks automatic and manual loading. yes loads automatically. Both ask values allow uppercase I, and my-muttdesktop-load-content-images for images other than trackers, in index or pager mode to load once for the selected message; ask-yes also lets display-message, Return or Space by default, load once while entering the pager. A refused request reports why. There is no mouse action. Scripts, forms, frames, plug-ins, navigation, cleartext HTTP, and other remote resource types remain blocked for every value. Loading remote images makes sender-chosen HTTPS requests, which can disclose that the message was opened and may contact any HTTPS host reachable from the Mac.
my_muttdesktop_html_appearance NeoMutt my_ user variable interpreted by Mutt Desktop light Sets the HTML viewer's canvas to light, dark, or system (the macOS appearance). Other values are reported and the previous value kept. It does not change plain-text mail or override sender colors.

Starting a draft 9

New composition checks the configured postponed mailbox according to recall.
  • New composition checks the configured postponed mailbox according to recall. One recalled draft opens directly, with no message; multiple drafts use a keyboard list. With the postponed mailbox open in the index, recall checks it as the index does, without a message, and lists its messages in the index's sort order, including those a limit hides and those marked deleted. An empty postponed mailbox, or one that fails to open, shows No postponed messages and ends the composition, as NeoMutt does; a failed open first shows its own error, such as Error opening mailbox after a failed header download, and a reopen that fails after the check reconnected shows Reconnected to HOST but failed to reopen mailbox, then lists the drafts its header read added before the failure, if any. With the postponed mailbox open in the index, such a failed reopen leaves the index with only the drafts its header download read, which recall lists, or with none, so recall shows No postponed messages. An open that loses the connection logs in again and reopens the postponed mailbox, as cmd_handle_fatal does, before Error opening mailbox. The open shows the read's progress as an index open does. A draft that fails to load shows only the read's error.
A recalled draft may keep its saved Fcc for an IMAP destination.
  • A recalled draft may keep its saved Fcc for an IMAP destination. An unconfigured local Fcc in draft metadata is ignored; Sent filing uses the current record setting so a draft cannot create an arbitrary local file.
difference Difference (NeoMutt bug): a recalled draft with an empty Mutt-Fcc: or X-Mutt-Fcc: field makes no Sent copy, as NeoMutt intends (postpone/postpone.c:755-758), where NeoMutt's hea...
  • Difference (NeoMutt bug): a recalled draft with an empty Mutt-Fcc: or X-Mutt-Fcc: field makes no Sent copy, as NeoMutt intends (postpone/postpone.c:755-758), where NeoMutt's header reader drops the empty field (email/parse.c:1316-1317) and the default record copy comes back.
Without a recalled draft, Mutt Desktop prompts for To:, optional Cc: and Bcc:, then Subject:.
  • Without a recalled draft, Mutt Desktop prompts for To:, optional Cc: and Bcc:, then Subject:. The ask_cc and ask_bcc options control the optional prompts. An empty answer moves on to the next prompt; when To, Cc, and Bcc are all empty, Mutt Desktop reports No recipients specified and ends the composition, as NeoMutt does. Ctrl-G or Ctrl-C at To, Cc, or Bcc ends the composition silently, and at Subject reports No subject, aborting, as NeoMutt does.
New mail, forwards, replies (unless fast_reply is set), and compose-to-sender run these prompts as NeoMutt's edit_envelope does; a reply's To and Cc are first cleaned of the use...
  • New mail, forwards, replies (unless fast_reply is set), and compose-to-sender run these prompts as NeoMutt's edit_envelope does; a reply's To and Cc are first cleaned of the user's own addresses (mutt_fix_reply_recipients, unless me_too), after the my_hdr recipients are added. An address prompt starts from the field's addresses (my_hdr To: included) followed by , . With fast_reply, a To, Cc, or Bcc that is already set is not asked for, and a forward keeps its forward_format subject without the Subject prompt. The last my_hdr Subject: line fills the Subject prompt.
auto_edit=yes with edit_headers=yes skips those prompts and opens the editor.
  • auto_edit=yes with edit_headers=yes skips those prompts and opens the editor.
An empty initial Subject: answer follows abort_nosubject before the editor opens.
  • An empty initial Subject: answer follows abort_nosubject before the editor opens. Spaces in a subject are kept.
A reply quotes what NeoMutt's include_reply quotes: the text mutt_body_handler writes for the message, each line starting with indent_string, with no [-- Attachment --] lines, b...
  • A reply quotes what NeoMutt's include_reply quotes: the text mutt_body_handler writes for the message, each line starting with indent_string, with no [-- Attachment --] lines, because only the pager prints them. A text/html part is the one autoview type, and Mutt Desktop quotes text derived from its HTML that keeps its paragraphs, line breaks, list items, table rows, and preformatted text, where NeoMutt quotes what an auto_view mailcap command produces. With auto_view text/html, a multipart/alternative therefore quotes the HTML rather than the plain-text part, as NeoMutt does; without it HTML is an unsupported part and the plain-text part is quoted. include_only_first stops the quote after the first part. A lone carriage return in the text becomes a line break in the draft.
difference Difference (owner, 2026-10-20): replies and forwards with forward_references omit source Message-IDs and References that the SMTP writer cannot accept, including IDs with intern...
  • Difference (owner, 2026-10-20): replies and forwards with forward_references omit source Message-IDs and References that the SMTP writer cannot accept, including IDs with internal whitespace. NeoMutt copies those IDs into the draft unchanged.

Editing and review 7

Mutt Desktop opens embedded Neovim when installed.
  • Mutt Desktop opens embedded Neovim when installed. Without it, a plain macOS text editor handles composition: Command-S saves the draft, Command-Return saves and opens review, and Escape exits without saving changes since the last save. It starts at the first body line, after one blank line when edit_headers shows headers, and keeps the caret and scroll position if the view reattaches. An initial unsaved exit follows abort_unmodified; after a save, Escape opens review. Raw message editing still needs Neovim to preserve message bytes. After editing, review shows From, To, Cc, Bcc, Fcc, Subject, body information, and attachments. With edit_headers, it also shows Reply-To.
A supported editor value adds direct Neovim -c commands when Neovim is installed.
  • A supported editor value adds direct Neovim -c commands when Neovim is installed.
difference Security difference (agent judgment): NeoMutt runs the editor with its whole environment (system.c:84).
  • Security difference (agent judgment): NeoMutt runs the editor with its whole environment (system.c:84). Mutt Desktop gives embedded Neovim only HOME, USER, LOGNAME, SHELL, TMPDIR, LANG, LC_*, XDG_CONFIG_HOME, XDG_DATA_HOME, XDG_STATE_HOME, and XDG_CACHE_HOME from its environment, plus its own PATH, TERM=xterm-256color, and COLORTERM=truecolor (Sources/MuttDesktopApp/EmbeddedNeovimView.swift:324-339), so tokens and other secrets in the environment do not reach Neovim plugins.
Aliases expand as NeoMutt's mutt_expand_aliases_env and mutt_edit_address expand them: once when a new message, reply, forward, or compose-to-sender draft is created; in the one...
  • Aliases expand as NeoMutt's mutt_expand_aliases_env and mutt_edit_address expand them: once when a new message, reply, forward, or compose-to-sender draft is created; in the one address prompt or review field being edited; and after an edit_headers editor closes. They do not expand at send or postpone, or in a recalled draft.
An unchanged initial editor exit follows abort_unmodified, except for a forward or a recalled draft.
  • An unchanged initial editor exit follows abort_unmodified, except for a forward or a recalled postponed draft, which return to review, as in Mutt. After review, an unchanged e edit returns to review.
Safety exception: NeoMutt checks only the draft file's modification time; Mutt Desktop also checks its bytes so an edited draft with a restored timestamp is not discarded.
  • Safety exception: NeoMutt checks only the draft file's modification time; Mutt Desktop also checks its bytes so an edited draft with a restored timestamp is not discarded.
mixed Editing and review reference table
Key Compose action
a Attach a file. ? opens the keyboard file browser. While the typed file imports, the prompt ignores edits and ?. A typed path expands as NeoMutt's buf_expand_path expands it; a relative result resolves from the process working directory, where each file browser opens. Security difference: Unable to attach names the path without a URL password that !, -, or ^ expanded into it; NeoMutt shows the expanded text.
D Detach the selected part. A recalled draft's groups are listed with their parts indented below them, and a group goes with its parts. As in Mutt, D refuses to leave a group with one part (Can't leave group with only one attachment) or to remove a draft's only part (You may not delete the only attachment). The message body, and a group that holds it, cannot be detached.
Return View the selected attachment; a multipart group shows its first part, as in Mutt. Double-clicking its row does the same. Text, HTML, and attached messages use the internal viewer; other files open through the reader's private viewer from the draft's snapshot. In the pager, j/J and k/K view adjacent attachments; a boundary returns to review.
e Reopen the editor.
b, c, r, s, t Edit Bcc, Cc, Reply-To, Subject, or To. Return commits; Ctrl-G restores the prior value.
f Edit this message's Fcc. Return commits; Ctrl-G keeps the prior value. Each Fcc mailbox expands when the message is sent, as NeoMutt's save_fcc expands it with buf_expand_path, so ^, -, !!, and @alias name the open mailbox, the previous one, and the alias's save mailbox.
y Send.
P Postpone.
q, Cmd-W, close control Follow postpone. Closing is blocked while another compose operation owns the draft.

Attachments 9

The file browser supports NeoMutt's default browser and generic keys, including the digits 1-9 (jump).
  • The file browser supports NeoMutt's default browser and generic keys, including the digits 1-9 (jump). Return attaches, Space views, t tags, ; plus Return attaches tagged files, and q leaves the browser. As in NeoMutt, Esc starts a key sequence, such as Esc then / for search-reverse, and a lone Esc is dropped after one second.
..
  • .. is selectable. h and Backspace are unbound.
An open POP attachment list keeps its original message for viewing and saving attachments.

An open POP attachment list keeps its original message for viewing and saving attachments, even after other messages are read. The list parses and extracts from those same bytes. A view or save that has started finishes before the list reads a queued close key; an index click during the action does nothing. Closing the list then releases the source. NeoMutt keeps the message open until the attachment menu returns (index/functions.c:2490-2499; attach/dlg_attach.c:216-229; attach/recvattach.c:973-987, 1053-1057, 1162-1167).

Mutt Desktop reads and snapshots each attachment off the main thread.
  • Mutt Desktop reads and snapshots each attachment off the main thread. Later disk changes do not alter the draft.
Canceling an import blocks another import until the current read finishes.
  • Canceling an import blocks another import until the current read finishes. There is no app-defined attachment size limit.
difference Attach:, Mutt-Attach:, and X-Mutt-Attach: work in an edit_headers document.
  • Attach:, Mutt-Attach:, and X-Mutt-Attach: work in an edit_headers document. Each path expands as NeoMutt's buf_expand_path expands it, such as = under folder and ~ for the home directory; a relative result uses the process working directory. Security difference: an attach error names the file without a URL password that !, -, or ^ expanded into its path; NeoMutt shows the expanded text.
A nonempty Fcc:, Mutt-Fcc:, or X-Mutt-Fcc: line in an edit_headers document changes this message's Sent-copy destination.
  • A nonempty Fcc:, Mutt-Fcc:, or X-Mutt-Fcc: line in an edit_headers document changes this message's Sent-copy destination. The last nonempty line wins.
Successful attachment pseudoheaders are removed.
  • Successful attachment pseudoheaders are removed. Invalid ones remain editable and block sending. NeoMutt consumes a failed Attach: directive and can send without that attachment; Mutt Desktop keeps it for correction. Attachment bytes never enter the editor file.
addition Mutt Desktop-only addition: a text/calendar attachment that is valid UTF-8 is sent with Content-Disposition: inline and its file name, so mail clients offer the invitation; NeoM...
  • Mutt Desktop-only addition: a text/calendar attachment that is valid UTF-8 is sent with Content-Disposition: inline and its file name, so mail clients offer the invitation; NeoMutt marks it attachment.

Sending and Sent copies 14

Empty subjects follow abort_nosubject before Fcc preparation or network access.
  • Empty subjects follow abort_nosubject before Fcc preparation or network access.
Mutt Desktop sends plain text and optional attachments through SMTP after send-message.
  • Mutt Desktop sends plain text and optional attachments through SMTP after send-message.
To, Cc, and Bcc remain separate recipient groups.
  • To, Cc, and Bcc remain separate recipient groups. Bcc appears in the SMTP envelope and filed copy, but not in transport headers.
For mail safety, Resent-Bcc: is removed from custom headers during sending and postponed-draft recall.
  • For mail safety, Resent-Bcc: is removed from custom headers during sending and postponed-draft recall. NeoMutt retains it and can expose a hidden recipient in the transmitted message.
One prepared message supplies Bcc-free transport bytes and Bcc-preserving filing bytes.
  • One prepared message supplies Bcc-free transport bytes and Bcc-preserving filing bytes. Message-ID, date, body, and MIME parts are shared.
fcc_before_send controls filing order.
  • fcc_before_send controls filing order. After a safe SMTP failure, the next explicit send prepares the message again and skips completed pre-SMTP filing targets.
fcc_attach chooses the filed MIME part after sending.
  • For a multipart message, fcc_attach=no files only the first part; ask values show Save attachments in Fcc? after SMTP. After no or Ctrl-G, NeoMutt asks again and a yes on that second question files all parts. The SMTP message keeps every part. fcc_before_send files all parts without this question (send/send.c:1709-1769, 2780-2821).
A failed Sent copy asks Fcc failed.
  • A failed Sent copy asks Fcc failed. (r)etry, alternate (m)ailbox, or (s)kip?, before or after SMTP as fcc_before_send places filing, as NeoMutt's save_fcc does. r files again; m asks Fcc mailbox:, starting from the Fcc, and files there at once; s, 3, Return, Ctrl-G, an empty mailbox, or a canceled prompt skip the copy, and sending goes on. A Fcc into a POP mailbox fails this way, as NeoMutt cannot open one for appending. A retry writes every Fcc mailbox again, as NeoMutt does, so a copy that was filed, or an unknown IMAP APPEND result, can leave a second copy.
difference Security difference: the compose and failed-copy Fcc prompts remove URL passwords and queries and redact saved secrets in the shared mailbox history.
  • Security difference: the compose and failed-copy Fcc prompts remove URL passwords and queries and redact saved secrets in the shared mailbox history. NeoMutt stores the raw accepted mailbox text, so a later history recall can show its credentials.
A permanent SMTP failure blocks the unchanged draft.
  • A permanent SMTP failure blocks the unchanged draft. Editing or discarding it clears the failure.
A refused SMTP send shows the server reply in compose.
  • A refused SMTP send shows the server reply in compose and keeps the draft. An uncertain result shows the warning to check Sent before another send.
SMTP acceptance or an unknown SMTP result blocks resubmission.
  • SMTP acceptance or an unknown SMTP result blocks resubmission.
After a reply is sent, the answered message is marked replied, and read, while the sent message still names it in In-Reply-To or References, and marked not replied otherwise, as...
  • After a reply is sent, the answered message is marked replied, and read, while the sent message still names it in In-Reply-To or References, and marked not replied otherwise, as NeoMutt's mutt_set_flag(MUTT_REPLIED) does. The change is queued like other flag changes: \Answered on IMAP, R in Maildir, X-Status: A in mbox, and the header cache on POP.
A crash between SMTP acceptance and filing can leave no Sent copy.
  • A crash between SMTP acceptance and filing can leave no Sent copy.

Postponed drafts 11

Postponement supports the account's IMAP login and local Maildir or mbox paths, not other IMAP logins (see "One IMAP server and user per account"), and messages up to 32 MiB.
  • Postponement supports the account's IMAP login and local Maildir or mbox paths, not other IMAP logins (see "One IMAP server and user per account"), and messages up to 32 MiB. It appends MIME with \Draft on IMAP. For IMAP recall, a forced STATUS counts postponed messages before the recall question. A Yes answer opens the configured mailbox, reads its headers, runs the due check, and uses the messages in mailbox order, including those marked \Deleted or lacking \Draft. Drafts stays selected through the chooser and message load. Recall sends no postponed-only SEARCH command.
A postponed draft has the header NeoMutt's mutt_rfc822_write_header writes for a postponed message: Date (under local_date_header), From only when set, To, Cc, Bcc, Subject, the...
  • A postponed draft has the header NeoMutt's mutt_rfc822_write_header writes for a postponed message: Date (under local_date_header), From only when set, To, Cc, Bcc, Subject, the draft's Message-ID, Reply-To, custom headers, References, the MIME headers, and In-Reply-To, then Mutt-References: and Mutt-Fcc:. No Mail-Followup-To, User-Agent, or undisclosed-recipients is added, as NeoMutt adds them only at send. Recall keeps the Message-ID and an empty From. Mutt Desktop's own X-MuttDesktop- resume headers follow the Mutt- ones.
Re-postponing saves the replacement before deleting the recalled copy.
  • Re-postponing saves the replacement before deleting the recalled copy.
An unknown APPEND result blocks another attempt.
  • An unknown APPEND result blocks another attempt. After checking the mailbox, r retries when the draft is absent; q closes the local draft when it is present.
NeoMutt marks a recalled draft deleted on recall.
  • NeoMutt marks a recalled draft deleted on recall. When the recall opened the postponed mailbox, or the index changed folder while the list was open, Mutt Desktop keeps that copy until the draft is sent, discarded, or safely replaced, so an editor or app failure does not lose it. Removal uses \Deleted and ordinary EXPUNGE on IMAP, file removal on Maildir, or a mailbox rewrite on mbox. A failure may leave the copy in place. The list recalls a draft whatever its deletion mark, as NeoMutt does.
difference Difference (NeoMutt bug): sending a recalled reply marks the original replied when it is in the open mailbox, as NeoMutt's comment intends (send/sendlib.c:1083-1087); NeoMutt's...
  • Difference (NeoMutt bug): sending a recalled reply marks the original replied when it is in the open mailbox, as NeoMutt's comment intends (send/sendlib.c:1083-1087); NeoMutt's mutt_send_message skips the mark for a recalled message (send/send.c:2850-2852).
Postponed messages preserve attachment bytes.
  • Postponed messages preserve attachment bytes. Active unpostponed drafts have no crash recovery.
difference Recall keeps a draft's MIME tree, as NeoMutt does (postpone/postpone.c:358-487, 590-592); the text is its first part when that part is text.
  • Recall keeps a draft's MIME tree, as NeoMutt does (postpone/postpone.c:358-487, 590-592): only a top multipart/mixed is dropped, and a multipart/alternative or nested multipart/mixed is postponed and sent again with its parts and boundary, so the HTML part of a draft from another mail program stays its alternative. The text is the first part, through the first part of each multipart, as NeoMutt's editor finds it (send/send.c:2418-2420), when that part is text of any type, such as text/html or an attached text/plain file: it opens in the editor, as NeoMutt opens a text part without a mailcap edit command (attach/mutt_attach.c:310-315), and keeps its type, parameters, filename, disposition, and description, with its charset set again when it is written. Every part keeps its Content-ID and Content-Language, so an inline image keeps the id its HTML refers to. With edit_headers, the first editor on a text other than text/plain opens without the header block, as NeoMutt's mutt_edit_attachment does; e from compose adds it. A flowed text that is not inside a kept multipart (any multipart but the dropped top multipart/mixed) is stuffed again when written, as NeoMutt does (rfc3676.c:418-492). As in NeoMutt, a recalled text loses its first charset parameter and, unless it is inside a kept multipart, the next one too, and is converted to the one left (send/send.c:2399, 2626). Mail safety difference: a first part that is a message is not edited, as the editor holds UTF-8 text and a message's bytes need not be. Such a draft, or one whose first part is of another type, has no text part and opens at compose review without the editor, and postponing or sending writes no text part unless text is added; NeoMutt edits a message part in the editor and another type with a mailcap edit command, and, without one, ends the recall after marking the draft deleted (send/send.c:2418-2424). Difference (NeoMutt bug): a kept multipart is labeled binary or 8bit when a part inside it is, else 7bit, as NeoMutt labels the top multipart (send/multipart.c:43-56), where NeoMutt keeps the label the multipart was read with, even base64, which RFC 2045 forbids for a multipart. The text is converted to UTF-8 from its charset, each byte the charset cannot convert becoming ?, as in NeoMutt. A text marked x-mutt-noconv, or in a charset Mutt Desktop cannot convert, is read whole in its charset, else as UTF-8, Windows-1252, or ISO-8859-1, as the draft has no charset label to keep it under. An attachment keeps its stored charset label, which NeoMutt changes when it sends.
addition Before the editor opens on a recalled HTML draft, or on a draft whose text has an HTML copy, a question asks whether to edit it.
  • Before the editor opens on a recalled draft whose text is HTML, This draft is HTML. Edit its HTML source? asks first; for a text inside a multipart/alternative with an HTML copy, at any depth, Edits change only the plain-text copy, not the HTML copy. Edit anyway?. Yes, the default, opens the editor; no or Ctrl-G opens compose review, where e still opens the editor. NeoMutt asks neither question (owner addition, 2026-10-25).
difference Security difference: recall refuses a draft whose address field, Message-ID, In-Reply-To, or References is over 128 KiB or holds a raw control character (a tab is allowed in the...
  • Security difference: recall refuses a draft whose address field, Message-ID, In-Reply-To, or References is over 128 KiB or holds a raw control character (a tab is allowed in the last three); NeoMutt reads it. An encoded word that decodes to a control character shows ? instead, as NeoMutt filters it. Recall also drops a part's Content-Description, Content-ID, or Content-Language over 128 KiB or holding a control character, which NeoMutt keeps.
Canceling Recall postponed message? ends the composition silently.
  • Canceling Recall postponed message? ends the composition silently. Leaving the postponed list without a choice reports Mailbox is unchanged, or N kept, M deleted after deleting drafts, as NeoMutt does when it closes the postponed mailbox. When the postponed mailbox is the open mailbox, NeoMutt does not close it and reports nothing, and neither does Mutt Desktop: the list and the index share their deletion marks, so a message marked deleted in the index shows as deleted in the list, and a recall marks the draft deleted and purged in the index. Nothing is removed until the index is synced: sending, discarding, or postponing the recalled draft again leaves it marked deleted in the index, as in NeoMutt.

Address and transport limits 21

Every outgoing address field (To, Cc, Bcc, Reply-To, From, postponed drafts, edit_headers, List-Post mailto:) is read with NeoMutt's mutt_addrlist_parse, so groups, comments, an...
  • Every outgoing address field (To, Cc, Bcc, Reply-To, From, postponed drafts, edit_headers, List-Post mailto:) is read with NeoMutt's mutt_addrlist_parse, so groups, comments, and quoted names work. Aliases expand as mutt_expand_aliases expands them; text that does not parse leaves the field empty, as in NeoMutt.
In a received header, Mail-Reply-To replaces earlier Reply-To addresses; a later Reply-To appends.
  • In a received header, Mail-Reply-To replaces earlier Reply-To addresses; a later Reply-To appends. IMAP's default header fetch omits Mail-Reply-To; add it to imap_headers to use it from the message list.
difference Alias expansion works as NeoMutt's expand_aliases_r does for a word without @ that names no alias: when it names a local user, that user's GECOS name (gecos_mask) becomes its na...
  • Alias expansion works as NeoMutt's expand_aliases_r does for a word without @ that names no alias: when it names a local user, that user's GECOS name (gecos_mask) becomes its name, and under use_domain it gets @ and hostname. NeoMutt bug difference (agent judgment): NeoMutt writes an empty name as <mailbox>; Mutt Desktop writes no name, as NeoMutt's own code treats an empty name elsewhere (hcache/serialize.c:282-285 frees it; address/address.c:625 counts it as unset).
difference With from unset, a new message's From is the username at hostname under use_domain, else the bare username, as NeoMutt's mutt_default_from gives it; NeoMutt has no check for a m...
  • With from unset, a new message's From is the username at hostname under use_domain, else the bare username, as NeoMutt's mutt_default_from gives it; NeoMutt has no check for a missing from. real_name names a From address that has no name; it starts as the current user's GECOS name.
SMTP sends each mailbox as it was parsed: MAIL FROM, then one RCPT TO per To, Cc, then Bcc mailbox, skipping group names, as mutt_smtp_send and smtp_rcpt_to do.
  • SMTP sends each mailbox as it was parsed: MAIL FROM, then one RCPT TO per To, Cc, then Bcc mailbox, skipping group names, as mutt_smtp_send and smtp_rcpt_to do. Addresses such as o'brien@example.com, postmaster, and user@localhost reach the server, which decides whether to accept them. When the server offers SMTPUTF8 and the sender or a recipient has a non-ASCII character, MAIL FROM ends with SMTPUTF8.
Send runs NeoMutt's mutt_send_message checks before the abort_nosubject question and before any Fcc or SMTP step.
  • Send runs NeoMutt's mutt_send_message checks before the abort_nosubject question and before any Fcc or SMTP step. When To, Cc, and Bcc hold no recipient (a group name alone counts as none), it warns No recipients specified. It then encodes the domains under idn_encode (mutt_env_to_intl); a domain that cannot be encoded gives Bad IDN in 'FIELD': 'MAILBOX'. Either one returns to the compose screen. Postpone encodes the same way and ignores a failure. With idn_encode unset, a Unicode domain stays as typed, and SwiftMail then refuses it at send (see below).
my_hdr works as NeoMutt's hdrs handling does: To, Cc, and Bcc lines are added before alias expansion and the envelope prompts; From and Reply-To lines replace those fields after...
  • my_hdr works as NeoMutt's hdrs handling does: To, Cc, and Bcc lines are added before alias expansion and the envelope prompts; From and Reply-To lines replace those fields after the prompts, without alias expansion; a valid Message-ID line sets the message's id; To, Cc, Bcc, Subject, Newsgroups, Followup-To, X-Comment-To, Supersedes, and Return-Path lines never become custom headers; other lines become custom headers of the sent and postponed message. my_hdr Subject: only fills the Subject prompt. The edit_headers editor shows the custom headers, and the edited ones replace them. A Supersedes: line written in the edit_headers editor or recalled from a postponed draft is sent, as in NeoMutt.
difference Under idn_decode, xn-- domains are shown decoded where NeoMutt decodes them: index expandos and sort names (mutt_addr_for_display, mutt_get_name), and the address headers of the...
  • Under idn_decode, xn-- domains are shown decoded where NeoMutt decodes them: index expandos and sort names (mutt_addr_for_display, mutt_get_name), and the address headers of the pager, a forwarded message, and an attached message (address_header_decode). Address prompts and review fields store domains encoded under idn_encode (mutt_addrlist_to_intl), start editing from the decoded text, and show the review fields decoded under idn_decode. The edit_headers editor gets the decoded text (mutt_env_to_local), and its result is encoded again. A domain that cannot be encoded gives Bad IDN: 'MAILBOX': an envelope prompt asks again, and a review field keeps the text and shows the error. Difference, recorded under the project's exception for an obvious NeoMutt bug (origin: agent judgment): the repeated envelope prompt shows the error, where NeoMutt's new prompt hides the message window, which clears it at once (send/send.c:217-221, gui/msgcont.c:99-100, gui/msgwin.c:340-342).
difference Security difference: a mailbox holding a line break or other control character is refused before SMTP, since it would end the SMTP command.
  • Security difference: a mailbox holding a line break or other control character is refused before SMTP, since it would end the SMTP command.
difference An smtp_url that is not an smtp:// or smtps:// URL with a host fails when a message is sent, with Invalid SMTP URL: URL, as smtp_fill_account reports it.
  • An smtp_url that is not an smtp:// or smtps:// URL with a host fails when a message is sent, with Invalid SMTP URL: URL, as smtp_fill_account reports it. Security difference: the URL is shown without its password; NeoMutt shows the password.
difference NeoMutt bug difference (owner): NeoMutt parses <> to an empty mailbox and writes it as nothing, so From: <> reads back as no address.
  • NeoMutt bug difference (owner): NeoMutt parses <> to an empty mailbox and writes it as nothing, so From: <> reads back as no address. Mutt Desktop keeps <>, as NeoMutt's own parse_route_addr and mutt_addr_write intend.
difference Library difference (owner): domains are converted with Foundation's host conversion, which refuses some ASCII text that NeoMutt's libidn2 accepts (lowercased), such as a group n...
  • Library difference (owner): domains are converted with Foundation's host conversion, which refuses some ASCII text that NeoMutt's libidn2 accepts (lowercased), such as a group name holding @ and ,; such a send stops with Bad IDN. Foundation also keeps a domain's letter case, which libidn2 lowercases. Domains are decoded for display with Foundation too.
difference Library difference (agent judgment): a domain holding a % escape is shown undecoded.
  • Library difference (agent judgment): a domain holding a % escape is shown undecoded. Foundation's decoding would also decode the escape; NeoMutt's libidn2 converts only xn-- labels.
difference Security difference: a group name or a local part that holds address punctuation is written in quotes, so the written text reads back as the same list.
  • Security difference: a group name or a local part that holds address punctuation is written in quotes, so the written text reads back as the same list. NeoMutt writes both bare, and that text can read as extra recipients.
difference The sent message and its Fcc copy have the header NeoMutt's mutt_rfc822_write_header writes: Date, From, To, Cc, Bcc in the Fcc copy only, Subject, Message-ID, Reply-To, Mail-Fo...
  • The sent message and its Fcc copy have the header NeoMutt's mutt_rfc822_write_header writes: Date, From, To, Cc, Bcc in the Fcc copy only, Subject, Message-ID, Reply-To, Mail-Followup-To (under followup_to), custom headers, References one ID per line, the MIME headers, In-Reply-To, and User-Agent (under user_agent). Address lines keep groups and fold at 74 columns; Subject and custom headers fold at wrap_headers. A message with only Bcc recipients gets To: undisclosed-recipients: ;. The MIME headers and the body are written as NeoMutt's mutt_write_mime_header and mutt_write_mime_body write them: the text is text/plain, converted to a send_charset entry: the first that converts it with no inexact conversion, a utf-8 entry as soon as it is reached, else the one with the fewest inexact conversions (iso-8859-1 for café under the default us-ascii:iso-8859-1:utf-8), 7bit, or with 8-bit bytes 8bit under allow_8bit, else quoted-printable, with Content-Disposition: inline; a text attachment without a charset label is converted and encoded the same way, one that is not UTF-8 is labelled us-ascii or utf-8 with its bytes as they are, and one with a label other than us-ascii keeps the label and its bytes; a message or multipart attachment is 7bit or 8bit, or converted to 7-bit; any other attachment is base64 or quoted-printable, whichever is smaller; and a description is sent as Content-Description. With attachments the body is a multipart/mixed with a random 16-letter boundary and no preamble. Names, group names, Subject, and custom headers are encoded as NeoMutt's rfc2047_encode encodes them, in the sent message, its Fcc copy, and a postponed draft: only the span from the first to the last 8-bit word (widened over the address specials in a name), Q or B per word, words sized to the header column and joined with a line break and a tab, in a charset from send_charset. A MIME parameter with 8-bit or control bytes, such as an attachment file name, is written as NeoMutt's rfc2231_encode_string writes it, converted to the first send_charset entry that holds it: filename*=iso-8859-1''caf%E9%2Etxt for café.txt under the default, where NeoMutt picks utf-8 (the mutt_ch_choose difference below). Postponed drafts keep address groups.
difference NeoMutt bug difference (agent judgment): for header words and MIME parameters, NeoMutt's mutt_ch_choose takes the send_charset entry with the shortest name that holds the text (...
  • NeoMutt bug difference (agent judgment): for header words and MIME parameters, NeoMutt's mutt_ch_choose takes the send_charset entry with the shortest name that holds the text (for a parameter, any entry iconv can open, as characters it cannot convert become ?), so café goes out in utf-8 under the default us-ascii:iso-8859-1:utf-8; its documentation says "NeoMutt will use the first character set into which the text can be converted exactly" (docs/config.c:4295-4296), which Mutt Desktop takes (iso-8859-1 there). For message text and text attachments NeoMutt's mutt_convert_file_to takes the first entry that converts exactly, or a utf-8 entry when it comes first, else the one with the fewest inexact conversions (convert/convert.c:161-185), as Mutt Desktop does.
difference Security difference: a header word holding a control character other than a tab is encoded, so it cannot start another header line; NeoMutt's rfc2047_encode encodes only 8-bit b...
  • Security difference: a header word holding a control character other than a tab is encoded, so it cannot start another header line; NeoMutt's rfc2047_encode encodes only 8-bit bytes and =?.
difference Owner difference (2026-10-18): the User-Agent value is MuttDesktop/ and the app version, where NeoMutt writes NeoMutt/ and its own version.
  • Owner difference (2026-10-18): the User-Agent value is MuttDesktop/ and the app version, where NeoMutt writes NeoMutt/ and its own version.
difference NeoMutt bug difference (agent judgment): NeoMutt's encode_headers writes a custom header's value two bytes after its colon, so my_hdr X-Name:value is sent as X-Name: vvalue: it...
  • NeoMutt bug difference (agent judgment): NeoMutt's encode_headers writes a custom header's value two bytes after its colon, so my_hdr X-Name:value is sent as X-Name: vvalue: it skips any white space after the colon, none included (send/sendlib.c:683), then writes the value at a fixed i + 2 (689-692). Mutt Desktop sends X-Name: value.
Replies preserve validated In-Reply-To and References headers.
  • Replies preserve validated In-Reply-To and References headers. References keep NeoMutt's newest ten message IDs, including repeats.
Mutt Desktop does not use sendmail, sign, encrypt, or retry network commands automatically.
  • Mutt Desktop does not use sendmail, sign, encrypt, or retry network commands automatically.