\input texinfo.tex    @c -*-texinfo-*-
@c %**start of header
@setfilename mu4e.info
@settitle mu4e user manual
@documentencoding utf-8
@c %**end of header

@dircategory Emacs
@direntry
* mu4e: (mu4e).        An email client for emacs based on mu.
@end direntry

@copying
Copyright @copyright{} 2011 Dirk-Jan C. Binnema

@quotation
Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU Free Documentation License, Version 1.2 or
any later version published by the Free Software Foundation; with no
Invariant Sections, with no Front-Cover Texts, and with no Back-Cover
Texts.
@end quotation
@end copying

@node Top
@top mu4e Manual

@emph{Mu-For-Emacs} (or for short, @samp{mu4e}), is an @samp{emacs} based
e-mail client, based on the @samp{mu} e-mail search engine. @samp{mu4e}
supports GNU Emacs 23 and later.

@menu
* Introduction::
* Getting started::
* Running mu4e::
* Searching mail::
* Example configuration::
* FAQ - Frequently Anticipated Questions::
* Known issues / missing features::
@end menu

@node Introduction
@chapter Introduction

@samp{mu4e} is an e-mail program for GNU Emacs; it uses the @samp{mu}
e-mail search engine as its backend, making @samp{mu} fully
search-based.


@menu
* Background::
* Acknowledgments::
@end menu

@node Background
@section Background

@samp{mu4e} (and @samp{mu}) does @emph{not} deal with getting your
e-mail messages from some e-mail server; instead, this task is delegated to
other tools, such as @samp{offlineimap}. As long as the messages end up in
a Maildir, @samp{mu4e}/@samp{mu} are happy to deal with them.

@samp{mu4e} does @emph{not} implement sending messages either; instead, it
depends on the true-and-tested @emph{smtpmail} which is part of emacs. In
fact, @samp{mu4e} piggybacks on Gnu's message editor; @inforef{Top,Gnus
message editor,message}.

Thus, many of the traditional things an e-mail client needs to do, are
subcontracted to other tools. This leaves @samp{mu4e} to concentrate on
what it does best: quick message searching, reading mails, replying them,
moving messages around and so on.

It's important to note the @samp{mu4e} requires your mail to be in
Maildir-format, typically stored in @file{~/Maildir}.

@node Acknowledgments
@section Acknowledgments

@samp{mu} has been helped tremendously by users who helped to isolate and fix
bugs, and (maybe even more so) by providing suggestions. Thanks to all!

@samp{mu4e} has taken inspiration from many places. First, there are @samp{sup}
and @samp{notmuch} which showed that one can write a search-based e-mail
client. Aspects of the Wanderlust e-mail client can be seen in the UI, as well
as the @samp{dired} interaction model.

@node Getting started
@chapter Getting started

In this chapter, we will see how you can install @samp{mu4e} and how you can
set it up. After we have succeeded in @xref{Getting mail}, and @xref{Indexing
your messages}, we discuss @xref{Basic configuration}. After going through
these steps, @samp{mu4e} should be ready for use.

@menu
* Installation::
* Getting mail::
* Indexing your messages::
* Sending mail::
* Queuing mail::
* Basic configuration::
@end menu

@node Installation
@section Installation

@samp{mu4e} is part of @samp{mu} - by installing the latter, the former will
be installed as well.

At the time of writing, there are no distribution packages for @samp{mu4e}
yet, so we are assuming installation from source packages.

Installation follows the normal sequence of:
@example
$ tar xvfz mu-<version>.tar.gz  # use the specific version
$ cd mu-<version>
$./configure && make
$ sudo make install
@end example

After this, @samp{mu} and @samp{mu4e} should be installed @footnote{there's a
hard dependency between versions of @samp{mu4e} and @samp{mu} - you cannot
combine different versions.}, a be available from the command line and emacs
(respectively). For emacs, you may to restart it so it can pick up
@samp{mu4e}.

There is experimental support for using the @samp{emacs} customization
system in @samp{mu4e}, but for now we recommend setting the values by
manually. Please @ref{Example configuration} for a working example of this.

@node Getting mail
@section Getting mail

In order for @samp{mu} (and by extension, @samp{mu4e}) to work, we need
to have our e-mail stored in a Maildir. If you were already using Maildirs,
your lucky, otherwise you will need to get your mail there in some other way.

If you are using some external @acronym{IMAP} or @acronym{POP} server, you can
use tools like @samp{getmail} and @samp{offlineimap} to download your
message into a Maildir-directory (@file{~/Maildir}, usually). If you are using
a local mailserver (such as Postfix or @samp{qmail}), you can teach them to
deliver into a Maildir as well, maybe in combination with @samp{qmail}.

@node Indexing your messages
@section Indexing your messages

After you have succeeded in @ref{Getting mail}, we need to @emph{index}
it. That is - we need to scan the Maildir and store the information about the
mails into a special database. We can do that from @code{mu4e} -- @xref{Main
view}, but for now it's better to do it from the command line, because it's
easier to spot any problems then.

Assuming that your Maildir is at @file{~/Maildir}, you should give the
following command:
@example
  $ mu index --maildir=~/Maildir
@end example

This should scan your @file{~/Maildir} and fill the database, and give
progress information while doing so. The first time you index your mail might
take a few minutes (for thousands of e-mails), afterwards it is much faster
since it only has to scan the differences.

Note that indexing is discussed at length in the @samp{mu-index} man page.

After the indexing is finished, you can quickly test if everything worked, by
trying some command line searches, for example
@example
  $ mu find hello
@end example
which should list all messages that match "hello". The @samp{mu-find} man
page describes the various things you can do with @samp{mu find}.

If all of this worked well, we are almost ready to start @samp{mu4e}.

@node Sending mail
@section Sending mail
@samp{mu4e} re-uses Gnu's @samp{message mode} -- @xref{(message)} for writing
mail and inherits the setup for @emph{sending} mail from that.

For sending mail using @abbr{SMTP}, @samp{mu4e} uses Emacs's built-in
@samp{smtpmail} package -- @inforef{smtpmail}. This package support many
different ways to send mail, please refer to its documentation. Here we
provide some simple examples.

A very minimal setup could look something like:

@verbatim
;; tell message-mode how to send mail
(setq message-send-mail-function 'smtpmail-send-it)
;; if our mail server lives at smtp.example.org; if you have a local
;; mailserver, simply use 'localhost' here.
(setq smtpmail-smtp-server "smtp.example.org")
@end verbatim

Note, since @samp{mu4e} uses the same @samp{message mode} and @samp{smtpmail}
that Gnus uses, any setting for those will also work for @samp{mu4e}.


@node Queuing mail
@section Queing mail

If you cannot send mail directly, for example because you are currently
offline, you can queue the mail, and send it when you have restored your
internet connection. To allow for queueing, you need to tell @samp{smtpmail}
where you want to do this. For example:

@verbatim
(setq
    smtpmail-queue-mail  nil  ;; start in non-queing mode
    smtpmail-queue-dir   "~/Maildir/queue/cur")
@end verbatim

For convenience, we locate the queue directory somewhere in our normal
Maildir. If you want to use queued mail, you should create this directory
before starting @samp{mu4e}. The @command{mu mkdir} command can be handy here,
so for example:

@verbatim
$ mu mkdir ~/Maildir/queue
$ touch ~/Maildir/queue/.noindex
@end verbatim

The @command{touch} command tells @samp{mu} to ignore this directory for
indexing, which makes sense since it does not just consist of 'normal'
messages but also some of the @samp{smtpmail} metadata.

Also see @samp{mu-mkdir} and @samp{mu-index} man pages.

@node Basic configuration
@section Basic configuration

The last thing to do before running @samp{mu4e} is setting up some basic
configuration. A good place to put this would be in your @file{~/.emacs} file.

First, we need to load @samp{mu4e}:

@example
(require 'mu4e)
@end example

Then, we need to tell @samp{mu4e} where it can find your Maildir, and some
special folders. So for example:
@example
  (setq
    mu4e-maildir       "~/Maildir"
    mu4e-inbox-folder  "/inbox"      ;; where do i receive mail?
    mu4e-sent-folder   "/sent"       ;; where do i keep sent mail?
    mu4e-drafts-folder "/drafts"     ;; where do i keep half-written mail?
    mu4e-trash-folder  "/trash"      ;; where do i move deleted mail?
@end example
The folder names are all relative to @code{mu4e-maildir}.

Without going into too much technical detail, here we describe the elements in
a @samp{mu4e}-setup, and how they work together. Using some ascii-art:

@example
              +---------+
              | emacs   |
              |    +------+
              +----| mu4e | --> send mail (smtpmail)
                   +------+
                    |  A
                    V  |
              +---------+
              |   mu    |
              +---------+
                |    A
                V    |
              +---------+
              | Maildir |  <--- receive mail (fetchmail,
              +---------+                     offlineimap, ...)
@end example

So:
@itemize

 @item Your e-mail messages are stored in a Maildir-directory (typically,
 @file{~/Maildir}), and new mail comes in using tools like @samp{fetchmail},
 @samp{offlineimap} etc., or through a local mail servers (such as
 @samp{qmail} or @samp{Postfix}).

 @item @samp{mu} indexes these messages periodically, so you can quickly
 search for them. @samp{mu} can run in a special @samp{server}-mode, where it
 provides services to client software.

 @item @samp{mu4e}, which runs inside @samp{emacs} is such a client; it
 communicates with @samp{mu} to search for messages, and manipulate them.

 @item @samp{mu4e} uses the facilities offered by @samp{emacs} (the
 @samp{Gnus} message editor and @samp{smtpmail}) to send messages.

@end itemize


@node Running mu4e
@chapter Running mu4e

After the following the steps in @xref{Getting started}, we should now have a
working @samp{mu4e} setup. In this chapter, we'll give a tour of the
@samp{mu4e} programming, and show its use.

@samp{mu4e} consists of a number of views; the diagram shows how they relate
to eachother, and the default keybindings to from one view to the next. In the
next sections we will describe what these keys actually @emph{do}.

@menu
* Main view::
* Headers view::
* Message view::
* Editor view::
@end menu


@example
        [C]     +--------+   [RFCE]
      --------> | editor | <--------
     /          +--------+          \
    /         [RFCE]^                \
   /                |                 \
+-------+ [sjb] +---------+  [RET] +---------+
| main  | <---> | headers | <----> | message |
+-------+  [q]  +---------+ [qbjs] +---------+
                  [sbj]                 ^
                                    [.] | [q]
                                        V
                                      +-----+
                                      | raw |
                                      +-----+

Default bindings
----------------
R: Reply      s: search            .: raw view
F: Forward    j: jump-to-maildir
C: Compose    b: bookmark-search
E: Edit       q: quit
@end example

@node Main view
@section Main view

After you've installed @samp{mu4e} (@pxref{Getting started}), you can start it
with @code{M-x mu4e}. This will do some checks to ensure everything is set up
correctly, and then show the @samp{mu4e} main view.

This looks something like the following:

--
@verbatim
* mu4e - mu for emacs version x.x

  Basics

	* [j]ump to some maildir
	* enter a [s]earch query
	* [C]ompose a new message

  Bookmarks

	* [bu] Unread messages
	* [bt] Today's messages
	* [bw] Last 7 days
	* [bp] Messages with images
  Misc

	* [U]pdate email & database
	* toggle [m]ail sending mode (direct)
	* [f]lush queued mail

        * [H]elp
	* [q]uit mu4e
@end verbatim
--

First, the @emph{Basics}:
@itemize
@item @samp{[j]ump to some maildir} means that after pressing @key{j},
@samp{mu4e} will ask you for a maildir to jump to. These are the maildirs you
set in @xref{Basic configuration}.
@item @samp{enter a [s]earch query} means that after pressing @key{s} you will
be asked for a search query, and after entering one, the results will be shown.
@item @samp{[C]ompose a new message} means that after pressing @key{C}, you
will be thrown you in a message-editing buffer, where you can write a new message.
@end itemize

Next come the @emph{Bookmarks}.These are set in @code{mu4e-bookmarks}; what
you see in the above example are the @emph{default}, but you can add your own
and/or replace the default ones. See @xref{Bookmarks}.

Finally, there are some @emph{Misc} actions:
@itemize
@item @samp{[U]pdate email & database} will execute whatever is in
@code{mu4e-get-mail-command}, and afterwards update the @samp{mu} database;
@xref{Indexing your messages}. This is a synchronous command.
@item @samp{toggle [m]ail sending mode (direct)} will toggle between sending
mail directly, and queuing it first (for example, when you are offline), and
@samp{[f]lush queued mail} will flush any queued mail.
@item @samp{[H]elp} will show help information for this view.
@item Finally, @samp{[q]uit mu4e} will quit @samp{mu4e}.
@end itemize

@node Headers view
@section Headers view

The headers view shows the results of search queries. There's one line for
each matching message, and each line shows a number of fields describing this
message.

--
@verbatim
* Date              Flags  From/To                Subject
  2011-12-16 18:38  uN     To Edmund Dantès       + Re: Extension security?
  2011-12-16 21:44  uN     Abbé Busoni                + Re: Extension security?
  2011-12-17 03:14  uN     Pierre Morrel              + Re: Extension security?
  2011-12-17 04:04  uN     Jacopo                       + Re: Extension security?
  2011-12-17 14:36  uN     Mercédès                       + Re: Extension security?
  2011-12-18 06:05  uN     Beachamp                         \ Re: Extension security?
  2011-12-16 18:23  uN     Eric Schulte           + Re: [O] A presentation tool for org-mode
  2011-12-17 01:53  usaN   Gaspard Caderousse       \ Re: [O] A presentation tool for org-mode
  2011-12-16 16:31  uN     Baron Danglars         | [O] imaxima?
End of search results
@end verbatim
--

It should be fairly obvious what this means, but some notes:
@itemize
@item The fields shown in the headers view can be influenced by customizing
@samp{mu4e-headers-fields}
@item You can change the date format by customizing
@samp{mu4e-headers-date-format}
@item The letters in the 'Flags' field correspond to the following: D=draft,
F=flagged, N=new, P=passed (i.e.., forwarded), R=replied, S=seen, T=trashed,
a=has-attachment, x=encrypted, s=signed, u=unread.
@item The From/To field shows the sender of the message unless the sender
matches the regular expression in @samp{mu4e-user-mail-address-regexp}, in
which the header will show @samp{To} followed by the recipient.
@item The subject field displays the discussion threads according to the @emph{JWZ mail
threading algorithm}.
@end itemize

Using the default key bindings, you can do various things with these messages;
note that these actions are also listed in the @samp{Headers} menu in the
Emacs menu bar.


@verbatim
key          description
---          -----------
d            mark for moving to the trash folder
DEL,D        mark for immediate deletion
m            mark for moving to another maildir folder
u            unmark message at point
U            unmark *all* messages
x            execute actions for the marked messages
RET          open the message at point in the message view
R,F,C        reply/forward/compose
E            edit (only allowed for draft messages)
H            get help
q            leave the headers buffer
@end verbatim

Note, all the mark/unmark commands support the current @emph{region} (i.e.,
selection) -- so, for example, if you the select a number of message and then
press @key{DEL}, all selected message will be marked for deletion.

Tne two-step mark-execute sequence is similar to what for example @samp{Dired}
does, and tries to be as fast as possible while still trying to protect the
user against accidents.


@node Message view
@section Message view

After selecting a message in the Headers view (@ref{Headers view}), the
message will be show in the message view. This might look something like the
following:

--
@verbatim
From: info@galatians.net
To: "Paul" paul@hotmail.com
Subject: Re: some thoughts
Flags: (seen attach)
Date: Mon 19 Jan 2004 09:39:42 AM EET
Maildir: /inbox
Attachments(2): [1]DSCN4961.JPG(1.3M), [2]DSCN4962.JPG(1.4M)

Hi Paul,

How are you? Sorry we didn't get back to you sooner and sorry for the
top-quoting. We're still debating your last message; anyway, here are some
recent pics. And here's a link: http://example.com[1]

All the best!

On Sun 21 Dec 2003 09:06:34 PM EET, Paul wrote:

[....]
@end verbatim
--

Some notes:
@itemize
@item You can customize which header fields are shown using
@samp{mu4e-view-fields}.
@end itemize

You can find most things you can do with this message in the @emph{View} menu,
or use the keyboard -- the default bindings are:

@verbatim
key          description
---          -----------
n,p          go to next, previous message
d            mark for moving to the trash folder
DEL,D        mark for immediate deletion
m            mark for moving to another maildir folder
u            unmark message at point
R,F,C        reply/forward/compose
E            edit (only allowed for draft messages)

.            show the raw message view. '.'/'q' take you back
|            pipe the message through a shell command

g            go to (visit) numbered URL (using `browse-url')
e,o          extract, open numbered attachment

w            toggle line wrapping
h            toggle showing cited parts

H            get help
q            leave the headers buffer
@end verbatim

Note that @key{x}, which means 'execute actions on marked messages' is not
available in this view, to reduce the risk of accidents. You have to go back
to the headers view to effectuate the actions.

Also note that opening of an attachment uses the @samp{xdg-open} programming
to determine the right program to use for a certain attachment.

For displaying messages, @samp{mu4e} normally prefers the plain text version
if the message consists of both a textversion and an html version of its
contents. If there is only an html-version, or if the text part is too short
in comparison with the html part, @samp{mu4e} tries to convert the html into
plain text for display. The default way to do that is to use the Emacs
built-in @code{html2text} function, but if you set
@code{mu4e-html2text-command} to some external program, that will be
used. This is expected to take html from standard input and write plain text
on standard output.

@node Editor view
@section Editor view

Currently, @samp{mu4e} uses Gnu's message editor, so for documentation
@inforef{Message}.

@node Searching mail
@chapter Searching mail

@samp{mu4e} is fully search-based; this means that all the lists of messages
you see, are the result of some query. Even if you 'jump to a folder', in fact
you are executing a search query for messages that have the property of being
in a certain folder.

Note, all queries normally return only up to @code{mu4e-search-results-limit}
results; if you need more than that, prefix your search command with
@kbd{C-u}.

@menu
* Queries::
* Bookmarks::
* Maildir searches::
@end menu

@node Queries
@section Queries

The queries you can execute are the same that @code{mu find}
understands. Please refer to the @code{mu-find} man-page for details. Here, we
just provide a few examples.

@verbatim
# get all messages about bananas
bananas

# get all messages about bananas from john with an attachment
from:john flag:attach bananas

# get all messages with subject wombat in June 2009
subject:wombat date:20090601..20090630

# get all messages with PDF attachments in the /projects folder
maildir:/projects mime:application/pdf
@end verbatim

@node Bookmarks
@section Bookmarks

If you have queries that you use often, you may want to store them as
@emph{bookmarks}. These bookmarks then show up in the main view.  By default,
bookmark searches are available in the main view @ref{Main view}, header
view @xref{Headers view}, and message view @xref{Message view}, with the key
@kbd{b} for @code{mu4e-search-bookmark}.

@code{mu4e} provides some default bookmarks which you of course can
override. The definition of the default bookmarks is instructive here:

@example
(defvar mu4e-bookmarks
  '( ("flag:unread AND NOT flag:trashed" "Unread messages"      ?u)
     ("date:today..now"                  "Today's messages"     ?t)
     ("date:7d..now"                     "Last 7 days"          ?w)
     ("mime:image/*"                     "Messages with images" ?p))
  "A list of pre-defined queries; these will show up in the main
screen. Each of the list elements is a three-element list of the
form (QUERY DESCRIPTION KEY), where QUERY is a string with a mu
query, DESCRIPTION is a short description of the query (this will
show up in the UI), and KEY is a shortcut key for the query.")
@end example

Thus, you can replaces this or add your own items, by putting in your
configuration (@file{~/.emacs}) something like:
@example
(add-to-list 'mu4e-bookmarks
  '("size:5M..500M"       "Big messages"     ?b))
@end example

This prepend your bookmark to the list, and assign the key @key{b} to it. If
you want to @emph{append} your bookmark, you can use @code{t} as the third
argument to @code{add-to-list}.

In the various @samp{mu4e} views, pressing @key{b} will list all the bookmarks
defined in the echo area, with the shortcut key highlight. So, to invoke your
bookmark (get the list of "Big Message", all you need to type is @kbd{bb}.


@node Maildir searches
@section Maildir searches

Maildir searches are quite similar to bookmark searches (see @ref{Bookmarks}),
with the difference being that the target is always a maildir -- maildir
queries provide a 'traditional' folder-like interface to a search-based e-mail
client. By default, maildir searches are available in the main view
@ref{Main view}, header view @ref{Headers view}, and message view
@ref{Message view}, with the key @kbd{j} for @code{mu4e-jump-to-maildir}.

You can do Maildir searches manually (e.g. with a query like
@code{maildir:/myfolder}, but since it is so common, @samp{mu4e} allows for
shortcuts for this.

To enable this, you need to define a list of maildirs you'd like to have quick
access to, for example:

@example
   (setq mu4e-maildir-shortcuts
    '( ("/inbox"     . ?i)
       ("/archive"   . ?a)
       ("/lists"     . ?l)
       ("/work"      . ?w)
       ("/sent"      . ?s))
@end example

This would set @key{i} as a shortcut for the @t{/inbox} folder; so effectively
a query @t{maildir:/inbox}. There's one 'built-in' shortcut @key{o} for
'other' (so don't use that one for your own shortcuts!), which allows you to
choose from @emph{all} maildirs.

Each of the folder name is relative to your top-level maildir directory; so if
you keep your maildir in @file{~/Maildir}, @file{/inbox} would refer to
@file{~/Maildir/inbox}.

Having these shortcuts allows you to jump around your folder very quickly -
for example, getting to the @t{/lists} folder only requires you to type
@kbd{jt}. Note that the same shortcuts are use by @code{mu4e-mark-for-move}.


@node Example configuration
@chapter Example configuration

@example
@verbatim
;; example configuration for mu-for-emacs (mu4e)

(require 'mu4e)
(load-library "smtpmail")

(setq
  ;; a regular expression that matches all email address uses by the user;
  ;; this allows us to correctly determine if user is the sender of some message
  mu4e-user-mail-address-regexp
      "foo@bar\.com\\|cuux@example\.com"

  mu4e-maildir       "/home/user/Maildir"
  ;; the next are relative to `mu4e-maildir'
  mu4e-outbox-folder "/outbox"
  mu4e-sent-folder   "/sent"
  mu4e-drafts-folder "/drafts"
  mu4e-trash-folder  "/trash"

   ;; the maildirs you use frequently; access them with 'j' ('jump')
  mu4e-maildir-shortcuts
    '( ("/archive"     . ?a)
       ("/inbox"       . ?i)
       ("/work"        . ?w)
       ("/sent"        . ?s))

    ;; program to get mail
   mu4e-get-mail-command "fetchmail"

   ;; general emacs mail settings
   mail-reply-to "foo@bar.com"
   user-mail-address "foo@bar.com"
   user-full-name  "Foo X. Bar"

   ;; include in message with C-c C-w
   message-signature
    (concat
      "Foo X. Bar\n"
      "http://www.example.com\n")

   ;; smtp mail setting
    message-send-mail-function 'smtpmail-send-it
    smtpmail-default-smtp-server "smtpa.example.com"
    smtpmail-smtp-server ""smtpa.example.com"
    smtpmail-local-domain "example.com"

    ;; for offline mode
    smtpmail-queue-mail  nil
    smtpmail-queue-dir   "/home/user/Maildir/queue/cur")
@end verbatim
@end example


@node FAQ - Frequently Anticipated Questions
@chapter FAQ - Frequently Anticipated Questions

In this chapter we list a number of anticipated questions and their answers.

@itemize
@item @emph{How can I quickly delete/move/trash a lot of messages?} You can
select ('mark' in emacs-speak) the messages, and then press one of the keys to
mark them for some actions; by default @key{DEL} for delete, @key{m} for move
and @key{t} for trash.
@item @emph{mu4e only seems to return a subset of all matches - how can I get
all?}. Yes, for speed reasons (and because, if you are like the author, you
usually don't need thousands of matches), mu4e returns only up to
@code{m4ue-search-result-limit} matches. You can customize that variable, or
simply press the emacs prefix @samp{C-u} to get all matches. In other words,
when you press @samp{C-u s hello} you will get all matches, while @samp{s
hello} only gets you up-to-a-limited-number matches. Same for the other search
based commands, @code{mu4e-jump-to-maildir} (default: @key{j}) and
@code{mu4e-search-bookmark} (default: @key{b}).
@end itemize


@node Known issues / missing features
@chapter Known issues / missing features

In this chapter we list a number of known issue and/or missing features in
@samp{mu4e}. Thus, users won't have to search in vain for things that are not
there (yet), and the author can use it as a todo-list.

@itemize
@item @emph{Thread handling is incomplete.} While threads are calculated and are
visible in the headers buffer, there is no functionality to manipulate them
(e.g., collapse the thread, or delete a whole thread at once). But note that
you can manipulate a number of consequetive messages at once by selecting
them, and then using one of the manipulation commands, such as
@code{mu4e-mark-for-move} or @code{mu4e-mark-for-delete}.
@item @emph{Forwarding messaging does not forward attachments.} This is a
missing features, which will be added in some future version. Of course, you
can save attachments, and then re-attach them by hand.
@item @emph{No support for crypto when reading mail}. Currently, you cannot
conveniently read encrypted mail or check signatures (it should be possible
with e.g. EPA though, @inforef{Top, EasyPG Assistant, epa}.) For outgoing
messages, it should work though, using the built-in mechanisms.
@item @emph{Difficulties with attachments in messages with complex
MIME-hierarchy.} While dealing with attachments usually works fine, we have
found some problems with specific mails. This is an issue in @samp{mu}, and it
is under investigation.
@item @emph{mu4e is very much keyboard-driven}. It would be nice to add
support for mousing as well.
@end itemize

@bye