Mozilla Labs recently pulled
the covers off of Raindrop, a new project that
attempts to rethink how messaging software presents information to users.
In one sense, Raindrop is designed to function as a "grand unified inbox"
aggregating email, instant messaging, and a wide range of site-specific
message channels. These channels otherwise exist in complete isolation,
users to check multiple applications and web services to collect their
incoming communication. But Raindrop also strives to better present the
aggregated dispatches and notices, automatically sorting individual
conversations from group discussions, and personal messages from automated
announcements and updates.
Messages, messages everywhere....
Raindrop's web page says its mission is making it "enjoyable to
participate in conversations from people you care about, whether the
conversations are in email, on twitter, a friend's blog or as part of a
social networking site." To that end, the application abstracts
the user the work of retrieving messages, notifications, and replies from
the various web and email accounts, and presents them together as a unified
whole. On top of that, Raindrop attempts to figure out which messages and
conversations are most likely to be important to the user, and filters them
up to the top of the stack. One of the introduction videos gives the
example of sorting personal email to the top of the stack, while putting
automatically-generated alerts to the bottom.
Clearly, there are more than just two categories of message (personal
and automatic); Raindrop filters list email as well, but pays more
attention to threads in which the user is participating. On the
microblogging front, Raindrop classifies direct messages and "@" replies
above general status notices, and can thread back-and-forth exchanges just
Raindrop's interface is undergoing constant study and redesign, but at
present it features a "home" screen with a combined list of all messages,
plus links to specialized views for content, including "Direct Messages."
"Group Conversations," "Mail Folders," and "Mailing Lists." Raindrop's
home screen sorts the newest conversations at the top, and all messages
appear as conversation "bubbles" with a preview of their contents.
Raindrop threads related messages together, and it flags each conversation
with an icon to distinguish between what it believes are person-to-person
conversations, group discussions, and announcements or other impersonal
messages. At the bottom of the home screen is a summary block for content
in which the user is not a direct participant — general Twitter
updates, mailing list threads between other people, and so on.
The Raindrop team is making considerable efforts to solicit input and
feedback from real-world users in order to adapt its design. The project's
"guiding principles" emphasize its user-centric and participatory process.
The project has not yet made a pre-packaged release, but has tagged a 0.1
milestone in its source code repository. In keeping with the participatory
goal, the designers have issued two previews of interface changes, although
neither is yet available to run.
Those interested can install and run the current code on Linux, Mac, and
Windows machines, however. Raindrop is a web application, written
its own web server, so it can run on a normal desktop machine. Users can
check out the Mercurial tree and install either the 0.1 milestone from
October 22, or the less stable trunk. Installation
instructions are provided on the Mozilla wiki; the notable dependencies
include CouchDB version 0.10 or newer and Python 2.5 or 2.6.
After checking out the code, the included script check-raindrop.py will
check for specific Python packages (including Twisted, Paisley, and several support
packages for dealing with specific services such as Twitter and RSS feeds)
and check that CouchDB is configured and running. Once the script reports
that everything is satisfied, users must manually create a
and populate it with account information for the services they wish to
monitor. The current release includes IMAP email accounts, generic RSS
feeds, and the popular commercial services Gmail, Twitter, and Skype.
Once Raindrop is configured, users start the service with the included
run-raindrop.py script. The first time through, according to the
installation guide, this script should be executed as:
run-raindrop.py sync-messages --max-age=Ndays
will fetch the previous N days' worth of incoming messages from each
can take several minutes to process each
so it is best to choose a small value for N. When the import finishes,
users can access the Raindrop application from a browser at:
Functionality and ongoing development
At first glance, Raindrop's home screen shows what one would expect from
any email client: message threads. More subtle than this automatic
threading is Raindrop's attempt to combine all message sources into one
"inflow" (as the project calls it). Each conversation category Raindrop
presents combines threads from all of the configured accounts; "Group
Conversations" contains email and @replies, "Sent" contains outgoing tweets
and mail, and so on.
Lead designer Bryan Clark describes this
automated sifting of content by message type as one of the key goals of the
project. The first iteration of the user interface looks much like a
webmail client, but the prototypes posted
by the developers indicate that they plan to push the separation of
different content types even further, perhaps clustering announcements and
other non-personal messages into separate areas of the screen, giving more
room to the "important" conversations with a "dashboard"-style layout.
As of today, it is difficult to get a solid feel for how this
intelligent processing of messages will work in practice, because there are
so few supported services. It is certainly handy to access all of the
assorted account inboxes in a single location, but the actual value of
merging message sources increases the more sources there are to consider.
Users who interact with the same contacts via Twitter, Skype, and email can
test the combined-message-threading more rigorously, but for many users,
additional services may have to be added to make the user experience
diverge significantly from a traditional, single-source web application
— perhaps even a service from outside the web itself, such as an SMS
The Raindrop team solicits input from outside users and developers
through user and developer mailing lists, and
has posted documentation on the front- and back-end architecture.
In addition, the design team working on the user interface and user
experience maintains a blog
chronicling its work, and posts its design ideas
and mock-ups to Flickr. Users and developers are encouraged to send
feedback and ideas to both groups.
One interesting feature of Raindrop that should help encourage its open
development is that it has Mozilla Bespin's code-editing
functionality built-in. At the bottom of each page is a link labeled
"Extend" that opens a "Raindrop Extender" code editor window in a new tab.
Raindrop is structured to permit easy addition of extensions written in
Raindrop Extender includes two extensions that the user can activate and
begin using on his or her local Raindrop installation immediately. One
parses each message for URLs and appends a list of the URLs found in each
message to the message's preview bubble for easy access. The second
performs a similar task for Flickr URLs, but rather than providing a link,
it fetches and displays a thumbnail image of the file in the preview.
Several early blog reactions to Raindrop compared it to Google's Wave, but beyond the aggregation of
multiple content sources, the two projects have little in common. Wave
centers around real-time and collaborative content editing, while Raindrop
focuses on filtering messages in a user-centric way. Other projects have
attempted to "rethink the inbox" over the years — much of the Getting
Things Done (GTD) craze took aim at message processing, for example, and,
although it has never attracted critical mass, a big part of the Chandler project's goal was to merge
calendar, email, and to-do into a unified stream. A horde of Firefox and
Thunderbird extensions exist to try and combine the multitude of
single-site message streams into a single application.
Raindrop has certainly found a problem in need of a solution; even with
open standards and open protocols, online communication today has
splintered into more and more messaging services that are blindly ignorant
of each other — consider how many ostensibly "VoIP services" also
provide instant messaging functionality as if users were in need of another
IM account. But above all else, the Raindrop design team seems to
understand that to a user, an incoming message is important or unimportant
based on who sent it and what it says — it does not matter which from
which site or protocol the message originated. Its "grand unified inbox"
does not stop at un-splintering all of the incoming content, it actually
tries to make useful sense out of it.
The current 0.1 milestone of Raindrop is clearly just the first drop in
the bucket, but it deserves kudos for tackling this complicated issue
— and for doing it in a completely open way. Clark and the other
Raindrop developers at Mozilla
Messaging are the team that developed Thunderbird; whether Raindrop's
concepts remain limited to a web application, become integrated into
Thunderbird and other stand-alone clients, or some combination of both
remains to be seen. Wherever it goes, though, Raindrop will be an
interesting experiment to watch.
to post comments)