<!DOCTYPE html><html><head><meta charset="utf-8"><title>Apache Pony Mail (Incubating)</title>
<link rel="stylesheet" type="text/css" href="/css/default.css"/>
<link rel="stylesheet" type="text/css" href="/css/fa/fa.css"/>
<link rel="apple-touch-icon" sizes="57x57" href="/icons/apple-icon-57x57.png">
<link rel="apple-touch-icon" sizes="60x60" href="/icons/apple-icon-60x60.png">
<link rel="apple-touch-icon" sizes="72x72" href="/icons/apple-icon-72x72.png">
<link rel="apple-touch-icon" sizes="76x76" href="/icons/apple-icon-76x76.png">
<link rel="apple-touch-icon" sizes="114x114" href="/icons/apple-icon-114x114.png">
<link rel="apple-touch-icon" sizes="120x120" href="/icons/apple-icon-120x120.png">
<link rel="apple-touch-icon" sizes="144x144" href="/icons/apple-icon-144x144.png">
<link rel="apple-touch-icon" sizes="152x152" href="/icons/apple-icon-152x152.png">
<link rel="apple-touch-icon" sizes="180x180" href="/icons/apple-icon-180x180.png">
<link rel="icon" type="image/png" sizes="192x192"  href="/android-icon-192x192.png">
<link rel="icon" type="image/png" sizes="32x32" href="/icons/favicon-32x32.png">
<link rel="icon" type="image/png" sizes="96x96" href="/icons/favicon-96x96.png">
<link rel="icon" type="image/png" sizes="16x16" href="/icons/favicon-16x16.png">
<link rel="manifest" href="/icons/manifest.json">
<meta name="msapplication-TileColor" content="#ffffff">
<meta name="msapplication-TileImage" content="/icons/ms-icon-144x144.png">
<meta name="theme-color" content="#ffffff">
</head><body>
<div id="titlebar">
    <a href="/contribute.html"><img align='left' style="width: 130px; height: 125px; position: relative; left: -6px; top: -6px; border: 0;" src="/images/devme.png" alt="Fork/Hack on Pony Mail"></a>
    <a href='/'><img src="/images/ponymail.svg" style="width: 110px; margin-left: -10px; margin-right: 20px; height: auto;" align="left"/></a>
    <h1><a id="title" href="/" style="color: #FFF !important;">Apache Pony Mail&trade; (Incubating)</a></h1>
    <div id="menubar">
        <ul>
            <li><a href="/docs.html"><i class="fa fa-book"></i><span>Documentation</span></a></li>
            <li><a href="/source.html"><i class="fa fa-git-square"></i><span>Source</span></a></li>
            <li><a href="/downloads.html"><i class="fa fa-cloud-download"></i><span>Download</span></a></li>
            <li><a href="/support.html"><i class="fa fa-question-circle"></i><span>Get support</span></a></li>
            <li><a href="/contribute.html"><i class="fa fa-share-alt"></i><span>Contribute</span></a></li>
            <li><a href="/about.html"><i class="fa fa-users"></i><span>About</span></a></li>
        </ul>
    </div>
</div>
<p>Apache Pony Mail (Incubating) is a web-based mail archive browser
built to scale to millions of archived messages with hundreds of requests
per second.  It allows you to browse, search, and interact with mailing lists
including creating replies to mailing list threads.</p>
<p>Apache Pony Mail uses OAuth2 (Google, GitHub,
Facebook etc) for authentication to allow viewing private lists, and uses
ElasticSearch for storage and searching.  Licensed under the Apache License 2.0
and undergoing Incubation at the Apache Software Foundation (ASF).</p>
<h3 id='samplescreenshot'>Sample Screenshot<a href='#samplescreenshot' style='color: rgba(0,0,0,0);'>&para;</a></h3>
<p><img alt="Ponies" src="images/demo.png" /></p>
<h3 id='ponymailincludesrichvisualizations'>Pony Mail includes rich visualizations<a href='#ponymailincludesrichvisualizations' style='color: rgba(0,0,0,0);'>&para;</a></h3>
<p><img alt="Trends" src="images/demo_trends.png" /></p>
<h3 id='youcanalsorunsimplengramanalysesoflistcontent'>You can also run simple n-gram analyses of list content<a href='#youcanalsorunsimplengramanalysesoflistcontent' style='color: rgba(0,0,0,0);'>&para;</a></h3>
<p><img alt="N-grams" src="images/demo_ngrams.png" /></p>
<p>See <a href="https://lists.apache.org">https://lists.apache.org.org</a> for a live demo;
Pony Mail is currently running on the full mail archives of all Apache projects.</p>
<p>Pony Mail works in both public, private and mixed-mode, allowing you
to have one unified place for all your communication, both public and
private.</p>
<h3 id='featuresinclude'>Features include:<a href='#featuresinclude' style='color: rgba(0,0,0,0);'>&para;</a></h3>
<ul>
<li>Importing from standard mbox files, maildir directory, Pipermail or an mod_mbox-driven site</li>
<li>Public and private list viewing based on auth</li>
<li>Cross-list threading</li>
<li>OpenSearch support for browsers (can add as search engine)</li>
<li>In-browser reply to mailing lists</li>
<li>Fast and intuitive searching</li>
<li>Threaded, flat and tree view modes</li>
<li>Notifications of replies to emails sent via Pony Mail</li>
<li>Email and list statistics</li>
<li>Multi-site, multi-list handling</li>
<li>Word clouds</li>
<li>Fuzzy-logic email grouping/threading (based in part on JWZ's ideas)</li>
<li>Supports both custom OAuth, Google Auth and more.</li>
<li>Atom feeds for all lists (including private ones!)</li>
<li>Source view and custom range mbox export</li>
<li>Customized trend analysis and n-grams</li>
</ul>
<h3 id='requirements'>Requirements:<a href='#requirements' style='color: rgba(0,0,0,0);'>&para;</a></h3>
<ul>
<li>Linux operating system (tested on Ubuntu, Debian, Fedora and CentOS - Windows or OS/X may work)</li>
<li>ElasticSearch backend</li>
<li>Apache HTTP Server frontend with mod_lua loaded OR<ul>
<li>Nginx with nginx-extras (ng-lua module) AND lua-apr installed</li>
</ul>
</li>
<li>Python 3.x for importing (with elasticsearch and formatflowed via pip)</li>
<li>A mailing list system:<ul>
<li>MailMan3 if you fancy that (we have a python3 archive plugin)</li>
<li>OR any mailing list system of your choice (use archiver plugin with stdin)</li>
</ul>
</li>
<li>Lua &gt;=5.1 + lua-cjson, luasec and luasocket</li>
</ul>
<h3 id='developmentbenchmarking'>Development Benchmarking<a href='#developmentbenchmarking' style='color: rgba(0,0,0,0);'>&para;</a></h3>
<p>Pony Mail has been built for and tested with the mail archives of the Apache
Software Foundation, which span more than 15 million emails sent across more
than 20 years. To put things into perspective, importing all this on a modern
machine (2xSSD with 64GB RAM) took around 12 hours and resulted in a performance
at around 100 archive search requests per second per ES node, depending on mailing
list size and available bandwidth.</p>
<h3 id='todo'>TODO:<a href='#todo' style='color: rgba(0,0,0,0);'>&para;</a></h3>
<p>This is a list of what we would love to get done:</p>
<ul>
<li>Start on the <a href="https://github.com/apache/incubator-ponymail-site">project's documentation</a> (WIP)</li>
<li>Rework JS, turn those ugly innerHTML hacks into proper DOM handling</li>
<li>Set up notification system (depends on reply system) (works, but still <em>WIP!</em>)</li>
<li>Have it work with ES with auth mode or via HTTPS</li>
</ul>
<div style="display: inline-block; background: #BBB; margin: -10px; padding: 10px;">
    <h4><a id="disclaimer"></a>Disclaimer</h4>
<div style="width: 65%; float: left;">
<p style="line-height: 12pt;">
    Apache Pony Mail (Incubating) is an effort undergoing incubation at
    The Apache Software Foundation (ASF), sponsored by the <a href="https://incubator.apache.org">
    Apache Incubator</a>. Incubation is required of all newly accepted projects
    until a further review indicates that the infrastructure,
    communications, and decision making process have stabilized in a
    manner consistent with other successful ASF projects. While
    incubation status is not necessarily a reflection of the
    completeness or stability of the code, it does indicate that the
    project has yet to be fully endorsed by the ASF.
</p>
</div>
<div style="width: 20%; float: left; padding-top: 16px; margin-left: -8px;">
<a href="https://incubator.apache.org"><img src="https://incubator.apache.org/images/incubator_feather_egg_logo_sm.png"/></a>
</div>
<div style="width: 15%; float: left; line-height: 15px; padding-left: 22px;">
    <a class="item" target="_blank" href="https://incubator.apache.org/">Apache Incubator</a><br/>
            <a class="item" target="_blank" href="https://www.apache.org/">About the ASF<span></span></a><br/>
            <a class="item" target="_blank" href="https://www.apache.org/foundation/policies/conduct.html">Code of Conduct<span></span></a><br/>
            <a class="item" target="_blank" href="https://www.apache.org/foundation/thanks.html">Thanks<span></span></a><br/>
            <a class="item" target="_blank" href="https://www.apache.org/foundation/sponsorship.html">Become a Sponsor<span></span></a><br/>
            <a class="item" target="_blank" href="https://www.apache.org/security/">Security<span></span></a><br/>
            <a class="item" target="_blank" href="https://www.apache.org/licenses/LICENSE-2.0">License<span></span></a><br/>
</div>
</div>
</body></html>
