Text based email workflow on macOS

But why though?

macOS has arguably the best looking, most succinct and most user friendly GUI in all the OS commonly used on personal computers.

With this comes a bunch of fantastic GUI based tools for everything – including a lot for emailing.

The following list is but a selection of some.

Just with this selection, I am quite sure a lot of people would find their match. Personally I happily used the default macOS Mail.app. It did everything, that I needed. It is well integrated into the OS and iCloud of course. Together with Calendar.app and Contacts.app this quite a potent and well oiled machinery.

Then why did I switch to a text based workflow?

A few articles ago I wrote about my obsession with Emacs. Since I started using Emacs, I have been down the rabbit hole of migrating most of my workflows into it. Emacs is a fantastic text based – for lack of a better word – environment.

Breaking things to their basic nature takes away the distraction and it does not get any more basic than plain text.

Granted, I noticed that the appeal is not just the text based nature of the application, but also the focus on fuzzy searching/finding. In Emacs one can do this on any imaginable type of list.

Most of my navigation is initiated by a fuzzy completion interface. I accomplish this with a whole host of applications, programs and add-ons.

So I handle emails in plain text. But how?

The Toolchain

First things first. Let’s take a look at the tools and programs that I user to achieve that.

Emacs & mu4e

As mentioned before I already wrote up my setup to handle emails with Emacs. This is extensively illustrated in this article.


For the rare cases I don’t have Emacs running and I just want a glance into my mailboxes I can quickly launch NeoMutt on the command line. This also has the added benefit of having a backup client for my email.

Both Mu4e and NeoMutt use mbsync and the same email directory structure located in ~/.maildir. Again demonstrated in the aforementioned article.

NeoMutt, which to my knowledge is based Mutt, is a wonderful email client for the command line. It is quite customizable, both in behaviour (keybindings, email handling) and look & feel.

It is however quite intense to configure. Luckily the guide online is detailed enough.

In this post I will not go through the details on how to configure NeoMutt. I will rather layout some of the special custom settings that might not be documented in the guide.

In my case the configuration files are in the ~/.mutt directory as documented here.

├── accounts           # configuration for every account in a separate file
│   ├── aimebertrand
│   ├── icloud
│   ├── mocarchive
│   └── moclub
├── bindings           # file containing the keybindings
├── colors             # theming
├── muttrc             # main configuration
└── signatures         # signature are kept separate as well
    ├── aimebertrand-sign
    ├── icloud-sign
    ├── mocarchive-sign
    └── moclub-sign

Once configured, the result looks like this:

Some of the custom settings, that you will not find in the guide include a mailbox switcher/selector using fzf. I use a script which is then bound to a key in the binding file.

bash script muttfzf.sh:


match_folder() {
    find $HOME/.maildir -name '*' -type d \
-mindepth 2 -maxdepth 2 |\
grep -v '.git' | grep -v '\/mu' |\
        fzf --reverse


echo "push 'c$folder<enter>'"


macro index,pager J ":source ~/.dotfiles/bin/muttfzf.sh|<enter>"


Notmuch is an email indexing and search tool – just like mu/mu4e – based on Xapian. This provides a way to index my emails from the ~/.maildir. However separate to the mu xapian database.

This is useful because I can use the terminal to quickly fuzzy search for an email and display it quite fast on the command line. To achieve I use a custom function, that chains notmuch, fzf, mu & nvim.

function nmail() {
    set -o pipefail
    mail=$(notmuch show --format=text \
                   $(notmuch search date:1970..2021 | \
                         fzf --reverse --preview \
                             "echo {} | cut -d' ' -f1 | cut -d':' -f2 | \
xargs notmuch show --format=text | \
grep 'message{' | head -n 1 | cut -d':' -f6,7 | \
sed 's/\ /\\\ /g' | xargs mu view" | \
                         cut -d' ' -f1 | cut -d':' -f2) | \
               grep 'message{' | head -n 1 | cut -d':' -f6,7 | \
               sed 's/\ /\\\ /g' | xargs mu view) && \
        echo $mail | nvim -c 'set ft=mail' -c 'nmap q :q!<CR>'

This is beautifully convenient and fast, when I just want to quickly fuzzy match a subject in all of my emails and take a peak of the content. And I don’t need to open a fully fledged client and search.


Looking at this from a purely sober perspective it looks like a lot of hoops to go through. And granted the overhead is quite challenging. But the result speaks for itself. the convenience of finding emails at the speed of thought is a great one. Plus I have the added benefit of having all my email archive stored in a format that is readable by almost any sort of digital device.