I keep having to reinvent this every few years, and I always stitch it together from assorted sources, mostly because Google sort of shifts around now and then. So:

• Given a Gmail account with IMAP access turned on
• Given a Fastmail account using IMAP
• Given mutt, with your configuration in ~/.mutt and with muttrc and macros files.
• Given a working gpg config you can use to encrypt/decrypt

There are all sorts of ways to handle mutt config for assorted providers. The examples here are working right now, in early 2024. They probably have bits of cruft and lint because my config has been a work in progress since some time in the late 20th century.

Overview

You’re making profiles to do this: One for each of your accounts that will hold account specific config information. If you currently have a monolith config in mutt, you can lift a lot of stuff out of it and move it into a profile, then source the profile in your main muttrc.

You’re also going to make and encrypt a credential file for each account. Some people do this all in one file and use account hooks to make sure imap_user, imap_password and smtp_password are set correcctly depending on the account you’re operating in. I chose to make a file for each account.

You’re going to make macros that source the profiles when you want to switch between them.

0. Pre-config with Gmail and Fastmail

I’m not going to go into a ton of detail here:

• Gmail needs to have less secure app access turned on. Find it in your account settings. If you’re doing this for a work account, it may be your admin hasn’t enabled this. Have fun fighting city hall, in that case.
• If you have a GSuite admin, they need to have enabled all IMAP clients, not just OAuth ones.
• If you have 2FA turned on with Google, you will need to enable an application password.

For Fastmail:

• You need to have an app password set up for mutt. Settings -> Privacy and Security -> Integrations -> App passwords

1. The profile files

Make profile files for each of your accounts. I name them workplace.profile, fastmail.profile, etc. It doesn’t matter there’s no required convention. It’s a good idea to use the first one as the template for the second one.

This is an example of my Fastmail profile. Note line 6:

source "gpg -d ~/.mutt/passwords.gpg |"

That’s where your credentials will come from. I’ll show that file next.

# -*- muttrc -*-
# Mutt sender profile : personal/default

unset folder
set smtp_authenticators = 'gssapi:login' # fastmail needs this
set imap_authenticators = ''
source "gpg -d ~/.mutt/passwords.gpg |" 
set spoolfile = "imaps://imap.fastmail.com"
set folder = "imaps://imap.fastmail.com/INBOX"
set postponed="+Drafts"
set hostname="yourdomain.com"
set signature= "~/.mutt/personal.sig"
set from= "Bob Jones <bob@yourdomain.com>"
set realname = "Bob Jones"
set smtp_url = "smtps://bobjones@fastmail.com@smtp.fastmail.com:465" # use your fastmail username, not your email address
set imap_user = "bobjones@fastmail.com" # use your fastmail username here, too

# set the status to show which profile I'm using
set status_format= "-%r-Fastmail: %f [Msgs:%?M?%M/?%m%?n? New:%n?%?o? Old:%o?%?d? Del:%d?%?F? Flag:%F?%?t? Tag:%t?%?p? Post:%p?%?b? Inc:%b?%?l? %l?]---(%s/%S)-%>-(%P)---\n"

unmy_hdr *

my_hdr From: Bob Jones <bob@yourdomain.com>
my_hdr Organization: yourdomain.com
my_hdr Sender: Bob Jones <bob@yourdomain.com>
my_hdr Return-Path: <bob@yourdomain.com>

# clear the existing mailboxes list
unmailboxes *

# load up mailboxes appropriate to this profile
mailboxes + "=Spam"
mailboxes + "=disposable"
mailboxes + "=Newsletters"
mailboxes + "=Sent"
mailboxes + "=Archive"

2. Make credentials files

For each account, you need to make a file for your credentials.

set imap_user=bob@bobjones.com
set imap_pass="klatu barada nikto"
set smtp_pass="klatu barada nikto"

Name it whatever. passwords-accountname works.

Once you’ve created the file, encrypt it with gpg:

gpg -r your-gpg-key@yourdomain.com -e passwords-fastmail

Test it:

gpg -d passwords-fastmail.gpg

Then shred the plaintext original:

shred -u passwords-fastmail

Make sure that your profile (from the previous step) is sourcing the gpg file in line 6 of my example, e.g.

source "gpg -d ~/.mutt/passwords-fastmail.gpg |"

3. Do a quick mid-config check

Might as well test it now. You can do that by sourcing one of your profiles in your muttrc:

source ~/.mutt/fastmail.profile

When you run mutt the first time in this login session, you should get a gpg prompt for your credentials so mutt can decrypt your password file and use it to log in.

If it’s working, now’s the time to make your second profile and credentials files using the above steps since it’ll be good to know what they’re all called for the next step, which is making macros.

4. Make macros

I keep my macros in their own file under ~/.mutt just to keep things modular. You can put these in your main muttrc. Whatever you prefer. If you have a separate file, make sure to source it in muttrc:

source ~/.mutt/macros

Now add something like this for each account:

macro index .cf '<sync-mailbox><enter-command>source ~/.mutt/fastmail.profile<enter><change-folder>!<enter>'
macro index .cg '<sync-mailbox><enter-command>source ~/.mutt/google.profile<enter><change-folder>!<enter>'

That just does one last sync, then sources your profile, then changes folders to the inbox of that profile.

Restart mutt. From the index, if all is working correctly, the macro .cf will source your fastmail.profile and the macro .cg will source your google.profile file (both of which also source/decrypt their respective credential files).

5. In conclusion

Once it’s all wired up and running, you should be able to switch back and forth between accounts with just a few seconds of latency as the inbox syncs on exit and the new inbox syncs on login.

The pleasures of mutt

I went on a mutt revival kick early last year. It remains a land of contrasts. I never end up sticking to it 100 percent of the time but instead prefer to use it as a quick triage tool: It’s easy to make macros and keybindings that speed up inbox processing. Sometimes it’s easier to just bail out to the web mail interface, but during the day it’s helpful to just burn through the inbox never taking my hands off the keyboard.

mutt scoring and color treatments

One last thing, I guess, since I’m documenting stuff. One of the reasons I like mutt for triage so much is my ability to add a little visual treatment to messages based on their scores. That makes it easy to see what in my inbox has more priority.

I’ve got this little script in my ~/.mutt:

#!/usr/bin/env ruby

require 'mail'
require 'tempfile'

# Wants a +/- integer, e.g. +20
score = ARGV.first

score_file = "#{Dir.home}/.mutt/scored"

msg = Tempfile.new('msg')

msg.write($stdin.read)

mail = Mail.read(msg)

from = mail.from.first

File.open(score_file, "a") { |f| f.write "score ~f#{from} #{score}\n"}

msg.close

msg.unlink

And I’ve got these macros in my ~/.mutt/macros file:

# Score messages
macro index,browser .sp "<pipe-entry>~/.mutt/mailscore.rb +5\n<enter-command>source ~/.mutt/scored<enter>" # score sender +5
macro index,browser .sP "<pipe-entry>~/.mutt/mailscore.rb +20\n<enter-command>source ~/.mutt/scored<enter>" # score sender +20
macro index,browser .sm "<pipe-entry>~/.mutt/mailscore.rb -5\n<enter-command>source ~/.mutt/scored<enter>" # score sender -5
macro index,browser .sM "<pipe-entry>~/.mutt/mailscore.rb -20\n<enter-command>source ~/.mutt/scored<enter>" # score sender -20

And I’ve got a few lines in my ~/.mutt/colors file:

color index cyan default "~n 0-2 !~p"
color index magenta default "~n <5"
color index brightyellow default "~n >15"
color index brightred default "~n >19"
#

The macros pipe a given message into the script, the script extracts the sender, and the script writes a line into my ~/.mutt/scored file. Then the ~/.mutt/colors file (which you need to source in muttrc) assigns colors to certain scores. I have a few other rules in ~/.mutt/scores, as well:

# Date-based scoring penalties -- older things fall down
score ~d>3d -1
score ~d>7d -3
score ~d>14d -10

score "~O" +10 # old = +10 so I don't miss it
score "~F" +20 # flagged = +20 so it stays in the interesting view for a while, even if old
score "!~p ~d>7d" -10 # not for me directly, getting old, let it fade away
score "!~l" +2 # to a known list, give it a bump

I was scrolling through /r/emacs today and came across someone asking for help configuring GNUS and IMAP. It has been a very long time since I did that, so I had nothing useful to contribute – that config predated me using version control – but I did notice a link to https://useplaintext.email, which intrigued me.

The last time I allowed myself to have a strong opinion about email I was writing a “how we work” for Puppet’s engineering department. The boss and I believed that this was our big shot at putting a lot of email evil to rest – the scourge of top-posting, the blight of replies too widely scoped to too many groups, the simple, everyday harm done by needless reply-alls that add nothing.

It turns out the top-posters won and we just have to live with that.

But there was https://useplaintext.email reminding me of a more innocent time, using the word “harmful” in conjunction with HTML mail, taking one more swing at putting paid to top-posting once and for all.

It also had a list of plaintext email clients that I gave a quick scan, and one jumped out because I’d heard of it but never really gave it a spin: MailMate. It’s a Mac email client, it defaults to plain text but will read and send HTML email (via Markdown formatting on the sending side). It’s also super keyboard-centric. And it has a “bundles” feature that lets you write your own plugins. It comes with a bunch, including one that saves a link to a message in an org-mode file.

I’ve been fiddling around with it today and like it a lot. Besides its plaintext-centricity, keyboard-centricity, and extensibility, I love that you can open up a font picker, select a piece of the interface, and define a font for it. I went through and set everything to Fira Code Retina.

So, what about mu4e? Or mutt? Still on the docket.

mu4e has been bugging me a little because it has a very strange and possessive set of keymappings that collide with Doom Emacs. It hijacks the space key, so my muscle memory around the spacebar as the leader key is all messed up.

mutt remains mutt. I have a lot of affection for it, but its main advantage over anything at all is its customizable keyboard-centric nature, and MailMate has that, too, with less fussing.

And there is something a little weird about running isync on two machines in the house. I mean, theoretically it is no weirder than running two IMAP clients of any kind on two machines in the house. It’s just an IMAP client. But it’s a busy one.

Atomic Chrome/GhostText

There have been a few “use your favorite editor for text areas in your browser” things over the years. Atomic Chrome seems to work very well with GhostText, an extension that works with any of Firefox, Safari, or Chrome. You just install the package in Emacs, and invoke the listener with (atomic-chrome-start-server) somewhere in your init. It listens for the browser extension, which can be invoked with CMD SHIFT k, and opens a buffer for editing.

As I said, this kind of thing has been around for years. The Atomic Chrome/GhostText combination just seems to be reliable in a way I haven’t come across in the past.

org-recur

Scheduling recurrence in org isn’t that bad, but org-recur makes it really simple. It just extends org-mode’s syntax and allows you to add recurrence rules in a heading using notation like |+1|, |Wkdy|, or |1,15|, for “every day,” “every weekday,” and “1st and 15th of every month,” respectively.

Captee

org-capture, like assorted “use your favorite editor everywhere” plugins, is one of those things I know people have had working for a while. I remember having it set up and working a very long time ago, then I lost that config and just forgot how to do it. Captee is a little macOS app that worked pretty much out of the box once I had an emacsclient app set up.

It sits in your Mac share menu and grabs URLs from browsers and browser-adjacent apps then does … stuff … to them. If you want a simple Markdown link, it’ll do that. If you want an org-mode link, it’ll do that, copying both to the clipboard for you. It’ll also work with your org-capture template of choice and send a link + title + selected text to org-mode.

The thing I really like about it is that it works well with my RSS reader, Reeder. I’ve just bound it to C in the share actions list and it saves links/titles to my org-mode inbox.

More on my org PRM

I guess the thing I’ve been calling a plaintext CRM belongs to the “PRM” category (for “personal,” not “customers.”) So, it’s my org PRM now. I’ve been getting real use out of it.

Building it has followed a familiar pattern of feeling a gap, thinking surely someone has filled it, realizing that is not true, then going through the same loop of “maybe this general purpose tool?” and a halting attempt to use it, then a realization that it doesn’t matter how many rounded corners and AJAX transition effects the roach motel has – it’s still a roach motel.

It’s just a bad category I can only assume is as bad as it is because nobody wants to pay for it at the consumer level, and I think nobody wants to pay for it because social media has ushered in an era where we’re all sort of performing the family holiday letter on Facebook every day of the year. And also our “contacts” are all over the place. Every attempt to consolidate them and de-dup them is a minor catastrophe, with your sister-in-law manifesting nine times in the same address book and Siri forgetting where “home” is because something has pulled in your address-free doppelganger.

Anyhow, the thing I built a few weeks ago? I am using it daily:

• Agenda reports that tell me who I haven’t been in touch with, but want to.
• Reminders to schedule time with people or follow up on plans.
• Easy,fast access to past messages from contacts.
• Quick notes about conversations.
• Reminders to ping recruiters.

There are a lot of contact management apps. There are a few apps that will issue general-purpose “AI-driven” reminders to contact people. There’s nothing that feels as easy to use. I tried one that featured a lot of nice automation, but it was iOS only and there was no way to mass-select and tag contacts. Even with my relatively modest list I would have been an hour pecking in tags. With a contacts.org file, it was very fast and simple. There’s not even a smirky “only free if your time is worth nothing” rejoinder, because most of these products are harder to use and take more time to deliver less, or cost astronomical amounts for what they do.

Being plaintext and org-mode/elisp driven, it’s also super easy to extend and modify. If I don’t like a decision I made about how something works, it’s an easy change. With org-mode capture templates, the input is all uniform and structured, so I don’t worry about backing out or moving the content elsewhere. Basically, it’s as calming for me as text ever has been.

Anyhow, I use it daily, I like it a lot, and it feels good to use.

I went into giving mu a shot giving myself a giant side-eye for doing anything that involved running some MDA on a laptop, which is the minimum to use something like mu.

The intensity of the irritation with myself just deepened when my first pick for delivery – offlineimap – didn’t pan out and I found myself configuring isync to see if that would do any better. But isync (dba mbsync) works pretty well. It was easy to configure, I figured out how to gpg-encrypt my credentials, and I got it all set up in mackup such that I only have to configure/reconfigure in one place.

Most of my aversion to fiddling around with mail comes down to the MDA part, either because of the fragility of the component itself, or the flakiness of running these things on a laptop and how they’ll cope with being daemonized in an environment that’s not awake all the time. isync itself seems fine after several days, and it seems to be okay running as a homebrew service (with one minor caveat).

So that’s getting mail down to the machine.

mu itself – the indexing/search service for the maildir that isync creates – is pretty good. I’ve got ~231,000 messages indexed in it, and it’s super fast. As I’ve been working on cleaning up my contacts list it’s been great for just mu find "someone" from the command line. In some ways it’s almost too helpful given the volume of messages, because you get stuff like multiple reply-to’s in headers from Google+ email notifications or whatever, so one name can return 20 or 30 results in an address search.

So that brings us to mu4e.

Most of my aversion to running anything to do with ’net activity on Emacs comes down to blocking the whole app on a slow operation. I used to use GNUS for both IMAP and Usenet, and remember sometimes just having to get up and walk away during a sync until something finally got around to downloading. It was no way to live and I swore off anything to do with mail on Emacs unless I was willing to do it with an MDA of some kind in place (with all the attendant reasons I did not want to do that applying).

mu4e doesn’t even really interact with whatever we could consider a “physical” mail message, though. I mean, yes … when you write a message with it, it is creating a tmp of something that is eventually handed off to an MTA, but for reading and processing it is not touching Maildir messages in the filesystem – it is instead interacting with the mu database as a set of queries. It’s super fast. Fast the way Spotlight can be in Apple Mail, or search can be in Gmail, but consistently so.

UI-wise, mu4e is initially puzzling.

It starts from a place of “every list of mail is just a database query, not a list of files in a Maildir directory.” That’s fine. Lots of things in computing exist as vectorized representations of an object in filesystem. The difference between mu4e and some of these other styles of digital information is that not a ton of work has been done to re-translate these vectorized abstractions back into their old metaphor. So the menus, etc. talk in terms of “lists of headers” and not “folders of messages.”

Broadly, you can tell mu4e started from mu – “let’s make a mail search engine” – and then found expression as an Emacs MUA. While other MUAs include the idea of marking and operating but tend to start from a place of direct operation on a message (mutt’s an exception), mu4e starts from the assumption you’re going to mark and operate. So you don’t “delete a message,” you mark it for deletion (or moving, or whatever) then either execute your marks with the x keystroke, or sign off on executing them when you leave a given header list (i.e. what everyone else calls a folder).

It’s … I hate to even make it sound like this is a thing. If you have room in your life for setting up an MDA, a search engine for mail, and an Emacs MUA, you have whatever it is one needs to interact with a thin layer of abstraction over that whole pile of other abstractions. In some ways, mu4e feels to me like what might have happened if we chucked every innovation in mail interfaces that occurred after mh and went straight to “nah, dawg, your mail is still there on disk, but it also lives in The Matrix.” There’s just a little ramp for your muscle memory, is all.

So, what do you get in exchange, I guess?

First, it overcomes the core objection to running an MUA on Emacs at all: Everything except composing a message is a database operation, so everything is pretty fast.

People report being slowed down when trying to send messages with large attachments, and the proposed workaround (an async method you can configure) reportedly flakes out now and then. A dedicated MUA like Apple Mail might just step over that by backgrounding the send operation and letting you go on your way. Some webmail apps will give you the AJAX-y spinner until they’re done receiving the attachment, but not otherwise lock you out of using your browser. Conceivably, a big attachment with mu4e will still cost you the use of your text editor for the duration of the attachment. People who refuse to use their text editors for things besides just editing text will find that unacceptable and weird, but also know it’s a problem they’ll never have. People who think it’s right and proper to use their text editors to catch up on Mastodon, read RSS, send mail, do their calendaring, track their todos, browse the web … aaaaaaand sometimes edit a text file may be more put off.

By default, at least in Doom, it also hooks its update function into firing off your MDA so it can make sure the database has the latest messages. So when you check your mail with it, it wants to kick off an mbsync run. That doesn’t block it. I think it’s possible to configure it to just prompt a reindexing of your Maildir instead of a whole MDA run. I need to do a little more in-depth investigation of how well isync is working for me because right now I think mu4e and the Homebrew daemonization fight with each other, but the net effect is that one process gets isync to download my mail instead of the other.

Otherwise it is very, very fast, and its keyboard-centric UI is built toward getting at stuff quickly with a bunch of terse keystrokes to navigate to bookmarked mailboxes and canned search queries. Once you get the hang of marking/operating on a list of headers (with equally efficient keystrokes you can also customize) it’s a mail processing machine.

No, sorry, excuse me – it is a mail database processing machine.

I’ve previously named a few of these, but besides speed and efficiency, it offers a few other benefits:

First, I love composing mail in org mode markup. I sent myself a few test mails and loved, for instance, that an org mode src block was correctly colorized. org markup is a little more verbose than Markdown in some places. For instance, a blockquote isn’t done with a leading > but with a +begin_quote and +end_quote block.

Second, it’s easily hooked into org-capture. Here’s a capture template for putting a message in your inbox, marked for action within two days:

'("M" "process-soon" entry (file+headline "inbox.org" "Messages")
        "* TODO %:fromname: %a %?\nDEADLINE: %(org-insert-time-stamp (org-read-date nil t \"+2d\"))")

In Doom Emacs, you get at that with SPC X M. When it’s time to deal with the message, just tap enter on the heading and mu4e opens the message. Excuse me, no, it retrieves the header from the database.

In terms of drawbacks, setup time and learning curve aside, it has a few downsides:

At least one keymapping doesn’t play well with Doom Emacs. In mu4e, the SPC key is mapped to scroll-up-command to serve as a pager, whereas that’s the leader key for Doom everywhere else. The workaround is to use OPT SPC to get to Doom’s menu, but I’m still baking that into my muscle memory.

While orgmail-mode is cool and all, it interacts weirdly with the rest of the package sometimes, and I wish I could toggle its HTML mail features on and off now and then.

Its HTML mail presentation is as woeful as any mail client that starts from plaintext land, and the remedy is the same as it is in mutt: Learn the shortcut for opening HTML mail of any complexity straight into your browser.

Finally, it doesn’t interact as well with winner mode as I’d like, leaving frames in a weird state after some operations. I did convince ChatGPT to write a hook for me to get mail composer frames to close instead of leaving the view split:

(after! mu4e
(defun my-mu4e-close-frame-after-send ()
  "Close the frame after sending a message in mu4e."
  (when (and (eq major-mode 'mu4e-compose-mode)
             (not (mu4e~message-autopgp-p)))
    (delete-frame)))

(add-hook 'message-sent-hook #'my-mu4e-close-frame-after-send))

org-mail also seems to leave behind spare buffers it uses to put together the plaintext part of its multipart messages.

Net, though, it’s so fast and efficient that I can see past most of that. I’m sort of curious about connecting mutt to notmuch to see how that works, mostly because I know mutt very, very well and feel a little more fluent when it comes to customizing it. Some of the stuff I’ve got set up in mu4e could be done with a little utility scripting in mutt.

In the past, when I’ve gone through a plaintext or Emacs kick of some kind, I’ve blown past what I’ve come to think of as a common sense limit: Eventually I’m looking at Wanderlust, GNUS, or mu4e and thinking about the whole email in Emacs thing. Inevitably, then, you’re looking at some sort of way to sync your IMAP account down to your local machine, and a whole layer goes in to make that work.

I walked up to the line this time around, asked myself what problem I’m trying to solve, and remembered that part of what is making Doom Emacs work for me right now is how much I’ve been keeping things limited to stuff that has to do with writing and stuff that has to do with personal organization. Those are things that don’t stress Emacs’ single-threaded nature the way I do them, and that don’t take me into the murky space between Emacs and the OS.

The problem I am trying to solve whenever I go on these kicks, is the pain of getting parts of the macOS experience into a more keyboard-centric place. Mail always sticks out because I don’t like doing Mac Mail from the keyboard. There’s Mail Act-On, but at $45 a renewal it’s just more than I can see paying, and it doesn’t really do much for visualization – it just makes it easy to move things into folders.

So my mind always goes to mutt. It’s not perfect – search is a challenge without something external augmenting it – but I’m not sure it matters in the end: I use Fastmail for IMAP, and I don’t mind punting to its web interface if I need to go dig for something.

I thought about mutt this time because my long-standing config has always sort of felt similar to the way Spacemacs and Doom put a modal UI over Emacs. My mutt macros – here’s a sample – use . as a leader and are written mnemonically:

macro index .sn "l ^a^k~N\n" # Show unread/new only
macro index .sa "l ^a^kall\n" # show all
macro index .C "<esc>V" # toggle threads
macro index .si "l (~n5-100|~N)\n" # show interesting 
macro index .rs "<enter-command>source ~/.mutt/scores<enter>" # reprocess scores
macro index .sf "l ~F\n" # show flagged
macro index .hl "l ^a^k!~l\n" # hide lists
macro index .to "T ~d>7d\n" # "tag old" -- messages older than 7 days
macro index .ab    "<pipe-entry>/opt/homebrew/bin/lbdb-fetchaddr\n"                # Store address details in lbdb.

The value of mutt is less as my everything email client – I still keep up with mail from my phone or tablet – and more because over the years I’ve tuned it to visualize and process mail from the keyboard. I still read mail with my phone or tablet every day, but don’t like to do anything more than flag messages when I’m out.

HTML mail and mutt

mutt is sometimes hard to stick with because we lost the plaintext email battle. I know one designer who formats his email with monotype faces in what I’d describe as a sort of problematic aesthetic revolt, but otherwise … we lost and we’ll never be able to unsee Calibri.

Sticking elinks, lynx or w3m in your ~/.mailcap to show HTML was best practice for a long while, provided you didn’t mind also using urlview to display the links in a message once you’d read it. I was involved in email marketing during the era when that approach worked, partially because to do HTML mail “right” back then meant you had someone doing it painstakingly by hand, then reviewing across a multitude of clients and platforms – you were heavily incentivized to keep it simple. I bear the scars from a spat with a division of Siemens that was still using an old Lotus Notes and Win2000 in its marketing department. They were the customer, and the mail didn’t look good to them, so it didn’t look good. That was all, and we were forced to buy the next tier of service from our mail provider so we could add Lotus Notes on Win 2000 to our testing.

Anyhow, “elinks in your mailcap and call it a day” doesn’t work anymore: image text, dozens of links, complex positional markup, etc. etc. etc. and it makes a lot of HTML mail a hash in a plaintext browser. There are a few ways to solve this on a Mac: One is punting to an actual browser, and the other is using the Mac Quicklook service:

text/html;  open -a firefox %s; nametemplate=%s.html text/html; open -a firefox %s; nametemplate=%s.html; copiousoutput
text/html; qlmanage -p %s; nametemplate=%s.html

The former does about what you’d expect from looking at it: It uses Firefox (or whatever browser you’d care to invoke) to open the HTML part of the message, at which point you can click links, etc.

The latter is a little more obscure, but basically recreates what happens when you select a file and tap the spacebar to preview it on a Mac, popping up a modal window with the contents. This often works well for other kinds of attachments. With HTML mail it is enough to let you read the mail but not really interact with it (e.g. follow a link). The [DEBUG] label at the front of the modal’s title suggests that nobody at Apple really took the “plain text zealots using this to browse HTML email” use case into account when they wrote qlmanage, and the man page makes clear it’s just a debugging tool. It’ll do if you never intend to interact with a mail.

I’m sticking to the Firefox approach. It’s super fast if Firefox is already running (it always is), and you can follow links.

These things leave in waves, too

At some point mutt is going to do something to annoy me. I don’t know what it’s going to be this time. For now, I’m just enjoying the periodic dustoff of my config and pleasures of zipping through my inbox. If I had to guess, it’ll have something to do with getting email messages into org-mode or calendaring, somehow. There are a few shell-based CalDav clients out there, but they’re very sync-and-cache oriented and I just don’t like adding services. Had mutt never added IMAP caching and built-in SMTP support, I would have a harder time justifying it.

But I feel more protective of my Emacs and org-mode experience than anything. This run with Doom has yielded the most stable Emacs experience I’ve had since switching to Macs mooostly full-time ca. 2004. No mystery segfaults. No hard-locking the UI because I have IMAP, RSS, IRC, and Twitter clients running in my text editor.