I've haven't written too much here lately. This is because I have spent most
of my emacs hacking time on
mu4e, an emacs e-mail client. It's only
slightly over six months old since its first release, but it has progressed
rather quickly! So, I think it is time to give it an introduction to a wider
audience. In future posts, I'll go into more detail.
E-mail is a very important means of communication for me; and for purposes of
integration, it prefer to do my e-mail with emacs. For a long time, I used
mutt with emacs as the editor; a few years back I switched to Wanderlust,
and wrote a few articles about it.
There's a lot to like about Wanderlust: it's very featureful, and allows for a lot of customization. Still, there were a few things I was not fully happy with; the most important one was the speed of some operations; another annoyance was the fact that I got rather frequent cache-corruptions when using newer emacs versions.
So, what was I to do? Well, a few years back, I had written an e-mail
indexer/searcher, called mu. It takes the messages in a maildir-folder, and
allows you to query them. I wondered if I could use
mu as the backend for
an emacs-based e-mail client. So, I fired up emacs, started writing some code
and some later I had a first version of…
how does it work?
mu4e is an emacs front-end for
mu; when you start it,
mu4e connects to a
mu server process (started on-demand). It accepts simple commands, and
responds with emacs s-expressions, in asynchronous fashion. In practice, all
the heavy work is done in this server process, and emacs shows the results
when it is ready (usually almost instantly). Emacs does not need to wait for
the backend, and things stay snappy, even with tens of thousands (or more)
e-mail messages. The only operation that may still require some waiting is
sending mail, since that uses the emacs built-in
smtpmail, which blocks
during its operation.
mu expects your e-mail messages to be stored in a maildir (a
one-file-per-message system); you can get these mails there through tools
like offlineimap or fetchmail.
mu periodically indexes the messages, and
stores the results in a Xapian database. A lot of what
mu4e does is
querying this database – so for example, what you see as 'my inbox folder'
mu4e-frontend, is in fact just the result of a query of all
message that happen to live in that folder. You can query for many things –
message sender, subject, date, words in the body and more.
mu4e does not just query messages; it can also move messages between
folders, delete them, modify their flags and so on (and afterwards update the
database). All 'state' is in the file system, and the database is just a quick
way to get to it; if you delete the database and then re-index, nothing is
lost, and changes made with other tools (e.g.
mutt) are picked up by
Some Linux distributions ship
mu4e, but not necessarily a very recent
version; and because
mu4e is developing quickly, you may want to use the
latest official release, or (if you are more adventurous) check out the git repository. You'll need GNU/Emacs 23 or 24, GLib, GMime >= 2.4 and Xapian.
mu4e, you can check the mu4e manual, which should be
fairly complete. In fact, one of the goals of
mu4e is to make it easy to
set up; for that reason, the documentation includes complete examples of how
to set things up. The Getting started chapter should get you up to speed
So, give it a try if you're interested; the
mu=/=mu4e project is very open
to suggestions (and even bugs reports!), so feel free to put them here or
subscribe to the mu mailing list.
a small tour
I'll end this with a number of screenshots, to give you a rough idea of how things look.
The main screen
The headers / view split-screen
The results of your queries are shown as a list of headers; if you click one
of the headers,
mu4e splits the screen horizontally (optionally, you can
split the screen vertically, or only show the message view). You can
customize the headers shown, re-order them and so on.
The message view supports html message, inline images, and has a mechanism to associate user-functions with messages and attachments (such as 'view in browser' or 'pipe through command'); see the manual for some examples.
The message composition view
Obviously, you can reply to messages, forward them, or compose a new
message. For writing and sending messages,
mu4e reuses emacs' built-in
message-mode. There's support for auto-completing addresses (based on the
e-mails you've sent/received before).
There's even (experimental) support for writing you're messages using
org-mode, and then sending them as rich-text (html) messages.
So, this was a short introduction to
mu4e, barely scratching the surface,
but hopefully conveying the main ideas. The manual discusses things in much
more detail, and I'll write more about it in the future.
mu4e is still a young project, but, for what's it worth, I've been using it
full-time for over six months, and a growing number of people are doing the
same. So, if you're interested, give it try and let us know you think!