<?xml version="1.0" encoding="UTF-8"?>
<!--
  Licensed to the Apache Software Foundation (ASF) under one
  or more contributor license agreements.  See the NOTICE file
  distributed with this work for additional information
  regarding copyright ownership.  The ASF licenses this file
  to you under the Apache License, Version 2.0 (the
  "License"); you may not use this file except in compliance
  with the License.  You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing,
  software distributed under the License is distributed on an
  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  KIND, either express or implied.  See the License for the
  specific language governing permissions and limitations
  under the License.    
-->
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<!-- Generated by Apache Maven Doxia at Jun 7, 2012 -->
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
  <head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
    <title>
    News Archive</title>
    <style type="text/css" media="all">
      @import url("./css/james.css");
      @import url("./css/maven-base.css");
      @import url("./css/maven-theme.css");
      @import url("./css/site.css");
      @import url("./js/jquery/css/custom-theme/jquery-ui-1.8.5.custom.css");
      @import url("./js/jquery/css/print.css");
      @import url("./js/fancybox/jquery.fancybox-1.3.4.css");
    </style>
    <script type="text/javascript" src="./js/jquery/js/jquery-1.4.2.min.js"></script>
    <script type="text/javascript" src="./js/jquery/js/jquery-ui-1.8.5.custom.min.js"></script>
    <script type="text/javascript" src="./js/fancybox/jquery.fancybox-1.3.4.js"></script>
    <link rel="stylesheet" href="./css/print.css" type="text/css" media="print" />
      <meta name="author" content="James Project Web Team" />
    <meta name="Date-Revision-yyyymmdd" content="20120607" />
    <meta http-equiv="Content-Language" content="en" />
                                                    
<link title="DOAP" rel="meta" type="application/rdf+xml" href="http://james.apache.org//doap_james-project.rdf"/>
                      
          <!-- Google Analytics -->
    <script type="text/javascript">
    
      var _gaq = _gaq || [];
      _gaq.push(['_setAccount', 'UA-1384591-1']);
      _gaq.push(['_trackPageview']);

      (function() {
        var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
        ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
        var s = document.getElementsByTagName('script').item(0); s.parentNode.insertBefore(ga, s);
      })();

    </script>
    </head>
  <body class="composite">
    <div id="banner">
                                      <a href="index.html" id="bannerLeft" title="james-project-logo.gif">
              
                                                                            
        <img src="images/logos/james-project-logo.gif" alt="James Project" />
                </a>
                              <a href="http://www.apache.org/index.html" id="bannerRight">
              
                                        
        <img src="images/logos/asf-logo-reduced.gif" alt="The Apache Software Foundation" />
                </a>
            <div class="clear">
        <hr/>
      </div>
    </div>
    <div id="breadcrumbs">
            
                
                <div class="xleft">
        <span id="publishDate">Last Published: 2012-06-07</span>
                      </div>
            <div class="xright">                    <a href="index.html" title="Home">Home</a>
            |
                        <a href="server/index.html" title="Server">Server</a>
            |
                        <a href="hupa/index.html" title="Hupa">Hupa</a>
            |
                        <a href="protocols/index.html" title="Protocols">Protocols</a>
            |
                        <a href="mailet/index.html" title="Mailets">Mailets</a>
            |
                        <a href="mailbox/index.html" title="Mailbox">Mailbox</a>
            |
                        <a href="mime4j/index.html" title="Mime4J">Mime4J</a>
            |
                        <a href="jsieve/index.html" title="jSieve">jSieve</a>
            |
                        <a href="jspf/index.html" title="jSPF">jSPF</a>
            |
                        <a href="jdkim/index.html" title="jDKIM">jDKIM</a>
            |
                        <a href="mpt/index.html" title="MPT">MPT</a>
            |
                        <a href="postage/index.html" title="Postage">Postage</a>
              
                
      </div>
      <div class="clear">
        <hr/>
      </div>
    </div>
    <div id="leftColumn">
      <div id="navcolumn">
             
                
                                <h5>About James</h5>
                  <ul>
                  <li class="none">
                          <a href="index.html" title="Overview">Overview</a>
            </li>
                  <li class="none">
            <strong>News</strong>
          </li>
                  <li class="none">
                          <a href="mail.html" title="Mailing Lists">Mailing Lists</a>
            </li>
                  <li class="none">
                          <a href="contribute.html" title="Contributing">Contributing</a>
            </li>
                  <li class="none">
                          <a href="guidelines.html" title="Guidelines">Guidelines</a>
            </li>
                  <li class="none">
                          <a href="http://wiki.apache.org/james" title="Wiki">Wiki</a>
            </li>
                  <li class="none">
                          <a href="team-list.html" title="Who We Are">Who We Are</a>
            </li>
                  <li class="none">
                          <a href="license.html" title="License">License</a>
            </li>
          </ul>
                       <h5>Download</h5>
                  <ul>
                  <li class="none">
                          <a href="download.cgi" title="Releases">Releases</a>
            </li>
                  <li class="none">
                          <a href="https://repository.apache.org/content/repositories/snapshots/org/apache/james/" title=""></a>
            </li>
          </ul>
        <h5>Apache Software Foundation</h5>
  <ul>
    <li>
      <strong>
        <a title="ASF" href="http://www.apache.org/">ASF</a>
      </strong>
    </li>
    <li>
      <a title="Get Involved" href="http://www.apache.org/foundation/getinvolved.html">Get Involved</a>
    </li>
    <li>
      <a title="FAQ" href="http://www.apache.org/foundation/faq.html">FAQ</a>
    </li>
    <li>
      <a title="License" href="http://www.apache.org/licenses/" >License</a>
    </li>
    <li>
      <a title="Sponsorship" href="http://www.apache.org/foundation/sponsorship.html">Sponsorship</a>
    </li>
    <li>
      <a title="Thanks" href="http://www.apache.org/foundation/thanks.html">Thanks</a>
    </li>
    <li>
      <a title="Security" href="http://www.apache.org/security/">Security</a>
    </li>
  </ul>
                       <a href="http://maven.apache.org/" title="Built by Maven" class="poweredBy">
        <img class="poweredBy" alt="Built by Maven" src="./images/logos/maven-feather.png" />
      </a>
                   
                
            </div>
    </div>
    <div id="bodyColumn">
      <div id="contentBox">
        <!-- Licensed to the Apache Software Foundation (ASF) under one
  or more contributor license agreements.  See the NOTICE file
  distributed with this work for additional information
  regarding copyright ownership.  The ASF licenses this file
  to you under the Apache License, Version 2.0 (the
  "License"); you may not use this file except in compliance
  with the License.  You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing,
  software distributed under the License is distributed on an
  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  KIND, either express or implied.  See the License for the
  specific language governing permissions and limitations
  under the License. -->

  

    <div class="section"><h2>News<a name="News"></a></h2>

      <div id="apacheconspacer">
        <div id="apacheconbox">
          <iframe src="http://www.apache.org/ads/bannerbar.html" style="border-width:0;" frameborder="0" scrolling="no" width="250" height="150"></iframe>
        </div>
      </div>

    <div class="section"><h3>2012<a name="a2012"></a></h3>

      <a name="a120607"><div class="section"><h4>Jun 2012 - Apache Hupa 0.0.2 released<a name="Jun_2012_-_Apache_Hupa_0.0.2_released"></a></h4></a>
        <p>The Java Apache Mail Enterprise Server Project is happy to announce 
           the release of version 0.0.2 of Apache Hupa, the James rich webmail client.</p>

      <a name="a120417"></div><div class="section"><h4>April 2012 - Apache James Server 3.0-beta4 released<a name="April_2012_-_Apache_James_Server_3.0-beta4_released"></a></h4></a>
        <p>The Apache James project is happy to announce the release 
           of version 3.0-beta4 of its modular mail server.</p>
        <p>We thank all Users for their feedback and tests and we encourage anyone to 
           <a class="externalLink" href="http://james.apache.org/download.cgi#Apache_James_Server">download</a>
           and discover this Milestone 3 release.</p>
        <p>If you're interested in contributing to the James project, please subscribe to the James 
           <a class="externalLink" href="http://james.apache.org/mail.html">mailing lists</a>.</p>

      <a name="a120123"></div><div class="section"><h4>January 2012 - Apache James Protocols 1.6.1 released<a name="January_2012_-_Apache_James_Protocols_1.6.1_released"></a></h4></a>
        <p>The Java Apache Mail Enterprise Server (a.k.a. Apache James) Project is happy to announce 
           the release of version 1.6.1 of Apache James Protocols library.</p>

      <a name="a120118"></div><div class="section"><h4>January 2012 - Apache James Protocols 1.6.0 released<a name="January_2012_-_Apache_James_Protocols_1.6.0_released"></a></h4></a>
        <p>The Java Apache Mail Enterprise Server (a.k.a. Apache James) Project is happy to announce 
           the release of version 1.6.0 of Apache James Protocols library.</p>

      <a name="a120104"></div><div class="section"><h4>January 2012 - Apache James Mime4j 0.7.2 released<a name="January_2012_-_Apache_James_Mime4j_0.7.2_released"></a></h4></a>
        <p>The Java Apache Mail Enterprise Server (a.k.a. Apache James) Project is happy to announce 
           the release of version 0.7.2 of Apache James Mime4j library.</p>
    </div></div>
    <div class="section"><h3>2011<a name="a2011"></a></h3>
      <a name="a111230"><div class="section"><h4>December 2011 - Apache James Protocols 1.6.0-RC1 released<a name="December_2011_-_Apache_James_Protocols_1.6.0-RC1_released"></a></h4></a>
        <p>The Java Apache Mail Enterprise Server (a.k.a. Apache James) Project is happy to announce 
           the release of version 1.6.0-RC1 of Apache James Protocols library.</p>

      <a name="a111101"></div><div class="section"><h4>November 2011 - Apache James jSPF 1.0.0 released<a name="November_2011_-_Apache_James_jSPF_1.0.0_released"></a></h4></a>
        <p>The Java Apache Mail Enterprise Server (a.k.a. Apache James) Project is happy to announce 
           the release of version 1.0.0 of Apache James jSPF (Sender Policy Framework) library.</p>

      <a name="a111711"></div><div class="section"><h4>October 2011 - Apache James Mime4j 0.7.1 released<a name="October_2011_-_Apache_James_Mime4j_0.7.1_released"></a></h4></a>
        <p>The Java Apache Mail Enterprise Server (a.k.a. Apache James) Project is happy to announce 
           the release of version 0.7.1 of Apache James Mime4j library.</p>

      <a name="a111611"></div><div class="section"><h4>October 2011 - Apache James Protocols 1.6-beta1 released<a name="October_2011_-_Apache_James_Protocols_1.6-beta1_released"></a></h4></a>
        <p>The Java Apache Mail Enterprise Server (a.k.a. Apache James) Project is happy to announce 
           the release of version 1.6-beta1 of Apache James Protocols library.</p>

      <a name="a082011"></div><div class="section"><h4>Augustus 2011 - Apache James Server 3.0-beta3 released<a name="Augustus_2011_-_Apache_James_Server_3.0-beta3_released"></a></h4></a>
        <p>The Apache James project is happy to announce the release 
           of version 3.0-beta3 of its modular mail server.</p>
        <p>We thank all Users for their feedback and tests and we encourage anyone to 
           <a class="externalLink" href="http://james.apache.org/download.cgi#Apache_James_Server">download</a>
           and discover this Milestone 3 release.</p>
        <p>If you're interested in contributing to the James project, please subscribe to the James 
           <a class="externalLink" href="http://james.apache.org/mail.html">mailing lists</a>.</p>
        <div><pre>
        * What's new in 3.0-beta3 for end users
          - Numerous IMAP bug fixes (better client support, memory improvement, NIO and IO support...)
          - Support for IMAP IDLE (RFC 2177, server transmit updates to the client in real time)
          - Support for IMAP User Flags
          - Support for IMAP WITHIN Extensions (RFC 5032)
          - Mailbox Tooling to copy from a persistence implementation to another implementation
          - Telnet Management has been removed in favor of JMX with client shell
          - More metrics counters available via JMX
          - Better debug logging on protocols
          - JPA validated against more databases (among others Oracle)
          - Multiple address and port configurations per protocol
          - POP3 is now operational (was buggy in 3.0-M2)
          - Upgrade tool from James 2.3 is available
          - Better logging on protocols with adjustable level
          - Full mailet package must be specified
          - Composite Matchers
          - Better debug logging on protocols
          - Mailing list functionality has been removed
          - More documentation on web site for configuration,...
          - Java 1.6 mandatory
          - ... and much more, see details on https://issues.apache.org/jira/secure/ReleaseNote.jspa?in&amp;version=12316850&amp;styleName=Html&amp;projectId=10411
        * What's new in 3.0-beta3 for developers
          - Less maven modules
          - Maven 3.0.2 required to build
          - Upgrade to latest frameworks versions (netty, activemq, jackrabbit...)
          - Code reports generation via 'mvn site -P site-reports' maven profile
          - Corrections further to findbugs,... reports
          - Code formatting
          - ... and much more, see details on https://issues.apache.org/jira/secure/ReleaseNote.jspa?in&amp;version=12316850&amp;styleName=Html&amp;projectId=10411
      
        * Quick Start  http://james.apache.org/server/3/quick-start.html
        </pre></div>

        <a name="a30072011"></div><div class="section"><h4>Apache James jDKIM 0.2<a name="Apache_James_jDKIM_0.2"></a></h4></a>
        <p>The Apache James Project is happy to announce
           the release of version 0.2 of the Apache James jDKIM library.</p>
        <p>jDKIM is a DKIM implementation library written in Java. It provides
           both verification and signing and also provides Mailets for the
           Apache JAMES project.</p>
        <p>This is the first official release of the library, but the code has
           been in production almost unchanged since two years.</p>
        <p><a class="externalLink" href="https://issues.apache.org/jira/secure/ReleaseNote.jspa?projectId=12310990&amp;version=12314300">Read the release notes</a>.</p>
    
        <a name="a25072011"></div><div class="section"><h4>Apache James Mime4J 0.7<a name="Apache_James_Mime4J_0.7"></a></h4></a>
        <p>The Apache James Project is happy to announce 
           the release of version 0.7 of the Apache James Mime4J.</p>
        <p>Mime4J is a flexible MIME parsing library written in Java. SAX, DOM and pull parsing styles are 
            supported.</p>
        <p>The 0.7 release brings another round of API enhancements, bug fixes and performance optimizations. 
            A major effort has been put in code reorganization, separating parsing code from DOM manipulation
            code. Mime4J has been restructured into three separate modules: 'core', 'dom' and 'storage'. 
            The 'core' package provides an event-driven SAX style parser that relies on a callback mechanism 
            to report parsing events such as the start of an entity header the start of a body, etc. 
            The 'dom' package contains base/abstract classes and interfaces for MIME-DOM manipulation aiming 
            to provide the base for a full featured traversable DOM. Per default the Mime4J DOM builder stores 
            content of individual body parts in memory. The 'storage' package provides support for more
            complex storage backends such on-disk storage systems, overflow on max limit, or encrypted storage 
            through JSSE API.</p>
          <p>Mime4J 0.7 improves support for headless messages, malformed separation between headers and body
            and adds support for &quot;obsolete&quot; rfc822 syntax (e.g: &quot;Header&lt;somespace&gt;: &quot; style). Parsing 
            performance for quoted printable streams have been considerably improved. A &quot;DecodeMonitor&quot; object 
            has been introduced in most code to define how to deal with malformed input (Lenient vs Strict 
            behaviours). Mime4J 0.7 also provides LenientFieldParser as an alternative to DefaultFieldParser
            when a higher degree of tolerance to non-severe MIME field format violations is desired.</p>
        <p><a class="externalLink" href="https://issues.apache.org/jira/secure/ReleaseNote.jspa?projectId=12310521&amp;version=12313592">Read the release notes</a>.</p>

        <a name="a10072011"></div><div class="section"><h4>Apache James jSPF 0.9.9<a name="Apache_James_jSPF_0.9.9"></a></h4></a>
        <p>The Apache James Project is happy to announce 
           the release of version 0.9.9 of the Apache James jSPF which includes fixes related to OSGI.</p>
        <p><a class="externalLink" href="https://issues.apache.org/jira/secure/IssueNavigator.jspa?reset=true&amp;jqlQuery=project+%3D+JSPF+AND+fixVersion+%3D+%220.9.9%22+AND+status+%3D+Resolved+ORDER+BY+priority+DESC&amp;mode=hide">Read the release notes</a>.</p>

        <a name="a29062011"></div><div class="section"><h4>Apache James Protocols 1.5<a name="Apache_James_Protocols_1.5"></a></h4></a>
        <p>The Apache James Project is happy to announce 
           the release of version 1.5 of the Apache James Protocols.</p>
        <p><a class="externalLink" href="https://issues.apache.org/jira/secure/ReleaseNote.jspa?projectId=12311060&amp;version=12316655">Read the release notes</a>.</p>

        <a name="a15052011"></div><div class="section"><h4>Apache James IMAP 0.2 and Mailbox 0.2<a name="Apache_James_IMAP_0.2_and_Mailbox_0.2"></a></h4></a>
        <p>The Apache James Project is happy to announce 
           the release of version 0.2 of the Apache James IMAP and Mailbox components with following features:</p>
        <p>- Numerous IMAP bug fixes (better client support, memory improvement, NIO and IO support...).</p>
        <p>- Support for IMAP IDLE (RFC 2177, server transmit updates to the client in real time).</p>
        <p>- Support for IMAP User Flags.</p>
        <p>- Support for IMAP WITHIN Extensions (RFC 5032).</p>
        <p>- Mailbox Tooling to copy from a persistence implementation to another implementation.</p>
        <p>- ... See also the complete release notes for <a class="externalLink" href="http://s.apache.org/n8">IMAP 0.2</a>
           and <a class="externalLink" href="http://s.apache.org/SNu">Mailbox 0.2</a>.</p>

    </div></div>

    <div class="section"><h3>2010<a name="a2010"></a></h3>

        <a name="a06122010_1"><div class="section"><h4>Dec/2010 - Apache James Protocols 1.2 released<a name="Dec2010_-_Apache_James_Protocols_1.2_released"></a></h4></a>
        <p>The Java Apache Mail Enterprise Server (a.k.a. Apache James) Project is happy to announce 
           the release of version 1.2 of the Apache James Protocols.</p>

        <a name="a06112010_1"></div><div class="section"><h4>Nov/2010 - Apache James Server 3.0-M2 released<a name="Nov2010_-_Apache_James_Server_3.0-M2_released"></a></h4></a>
        <p>The Java Apache Mail Enterprise Server (a.k.a. Apache James) Project is happy to announce 
           the release of version 3.0-M2 (Milestone 2) of the Apache James server.</p>
        <p>M2 is not only a fast corrective release on M1 (issues related to JMX 
           security configuration on Windows platforms,...), but also contains an important number
           of enhancement and JIRA fixes.</p>
        <p>For example, memory usage has been reduced thanks to optimizations on 
           the ActiveMQ component usage (responsible for the mail spooling).</p>
        <p>We thank all Users for their feedback and tests and we encourage 
           anyone to discover this Milestone 2 release.</p>
        <p>If you're interested in contributing to the James project, please subscribe to the James 
          <a class="externalLink" href="http://james.apache.org/mail.html">mailing lists</a>.</p>

        <a name="a01112010_1"></div><div class="section"><h4>Nov/2010 - Apache James Server 3.0-M1 released<a name="Nov2010_-_Apache_James_Server_3.0-M1_released"></a></h4></a>
        <p>The Java Apache Mail Enterprise Server (a.k.a. Apache James) Project is happy to announce 
           the release of version 3.0-M1 (Milestone 1) of the Apache James server.</p>
        <p>The Apache James Server is a 100% pure Java enterprise mail server based on open protocols. 
           Currently supported are SMTP/LMTP, POP3, IMAP4 protocols together with several different 
           storage solutions (relational database via JPA and JDBC, File system with MailDir, JCR Content Repsitory).</p>
        <p>The James server also serves as a mail application platform. It hosts the Apache Mailet API,
           and acts has a Mailet container. This feature makes it easy to design, write, and deploy custom applications for mail processing. This modularity and ease of customization is one of James' strengths, and can allow administrators to produce powerful applications surprisingly easily.</p>
        <p>Features for that version include enhancements to nearly every area of functionality, 
           including full IMAP support, improved mailing list capabilities, fastfail support, SMTP API 
           for developing own fastfail filters and the next revision of the Mailet API.</p>
        <p>This was an exciting time in James development and we thank all contributors.</p>
        <p>We are still actively looking for eager, capable developers to contribute to James. 
          If you're interesting in contributing to the James project, please subscribe to the James 
          <a class="externalLink" href="http://james.apache.org/mail.html">mailing lists</a>.</p>
        <p>Information about James can be found at the James web site
           at <a class="externalLink" href="http://james.apache.org/">http://james.apache.org/</a>.</p>
         
        <a name="a20092010_1"></div><div class="section"><h4>Sep/2010 - Apache IMAP 0.2-M1 released<a name="Sep2010_-_Apache_IMAP_0.2-M1_released"></a></h4></a>
        <p>The Apache James Project is pleased to announce a new  
        <a class="externalLink" href="http://james.apache.org/imap">Apache IMAP</a> release in preparation of 
        the upcoming 3.0-M1 <a class="externalLink" href="http://james.apache.org/imap">Apache Mail server</a>.
        </p>

        <a name="a18092010_1"></div><div class="section"><h4>Sep/2010 - Apache protocols 1.2-M1 released<a name="Sep2010_-_Apache_protocols_1.2-M1_released"></a></h4></a>
        <p>The Apache James Project is pleased to announce a new  
        Apache protocols release in preparation of the upcoming 3.0-M1 <a class="externalLink" href="http://james.apache.org/imap">Apache Mail server</a>.
        </p>

        <a name="a21062010_1"></div><div class="section"><h4>Jun/2010 - Apache jSPF 0.9.8 released<a name="Jun2010_-_Apache_jSPF_0.9.8_released"></a></h4></a>
        <p>The Apache James Project is pleased to announce a new  
        <a class="externalLink" href="http://james.apache.org/jspf">Apache jSPF</a> release which includes fixed to TXT record escaping and pass the rfc4408-tests-2009.10 testsuite.
        </p>
        
        <a name="a21062010"></div><div class="section"><h4>Jun/2010 - Apache Mailet Base 1.1 released<a name="Jun2010_-_Apache_Mailet_Base_1.1_released"></a></h4></a>
        <p>The Apache James Project is pleased to announce a new  
        <a class="externalLink" href="http://james.apache.org/mailet/api">Apache Mailet Base</a> release which fixes a NullPointerException when using MatcherInverter.
        </p>
        
        <a name="a14052010_1"></div><div class="section"><h4>May/2010 - Apache JSieve 0.4 released<a name="May2010_-_Apache_JSieve_0.4_released"></a></h4></a>
        <p>The Apache James Project is pleased to announce that the forth release of
        <a class="externalLink" href="http://james.apache.org/jsieve">Apache JSieve</a> - an implementation of the
        <a class="externalLink" href="http://www.ietf.org/rfc/rfc3028.txt">Sieve</a> mail filtering language - 
        is now available for <a href="download.cgi#Apache_JSieve">download</a>.
        </p>
        
        <a name="a14052010"></div><div class="section"><h4>May/2010 - Apache Mailet Standard 1.0 released<a name="May2010_-_Apache_Mailet_Standard_1.0_released"></a></h4></a>
        <p>The Apache James Project is pleased to announce that the first independent release of
        <a class="externalLink" href="http://james.apache.org/mailet/standard/">Apache Mailet Standard</a> - was bundled with James Server 2.3 before - 
        is now available for <a href="download.cgi#Apache_JSieve">download</a>.
        </p> 
        
    </div></div>
    
    <div class="section"><h3>2009<a name="a2009"></a></h3>
    
        <a name="a15102009"><div class="section"><h4>Oct/2009 - jDKIM joins Apache James as sub-project<a name="Oct2009_-_jDKIM_joins_Apache_James_as_sub-project"></a></h4></a>
        <p>
        The Apache James project is pleased to announce the inclusion of a new sub-project called
        <a class="externalLink" href="http://james.apache.org/jdkim/">jDKIM</a>.
        jDKIM is a DomainKeys Identified Mail (DKIM) implementation library written in Java. It provides both verification and signing and also provides Mailets for the Apache James project.
        </p> 
        
        <a name="a25092009"></div><div class="section"><h4>Sep/2009 - Hupa joins Apache James as sub-project<a name="Sep2009_-_Hupa_joins_Apache_James_as_sub-project"></a></h4></a>
        <p>
        The Apache James project is pleased to announce the inclusion of a new sub-project called
        <a class="externalLink" href="http://james.apache.org/hupa/">Hupa</a>.
        Hupa is a GWT based webmail which use IMAP to connect to the backend mailserver.
        </p> 
        
        <a name="a31082009"></div><div class="section"><h4>Aug/2009 - Apache James 2.3.2 Released<a name="Aug2009_-_Apache_James_2.3.2_Released"></a></h4></a>
        <p>
        The Apache James project is pleased to announce that Apache James 2.3.2 
        is now 
        <a href="download.cgi#Apache_James_2.3.2_is_the_stable_version">available</a>.
        This is a minor bug fix release.
        See the 
        <a class="externalLink" href="http://james.apache.org/server/2.3.2/release-notes.html">Release Notes</a> 
        for more details. Upgrading is recommended for users of previous 2.x releases.
        </p> 
        <a name="a02072009"></div><div class="section"><h4>Jul/2009 - Apache MPT 0.1 released<a name="Jul2009_-_Apache_MPT_0.1_released"></a></h4></a>
        <p>The Apache James project is pleased to announced that the first release of
        <a class="externalLink" href="http://james.apache.org/mpt">Apache MPT</a> - a functional testing
        library particularly suitable for line protocols based on ASCII - is now
        <a href="download.cgi#Apache_MPT">available</a>. These
        protocols are common in mail but the library may be useful more widely.
        See the <a class="externalLink" href="http://james.apache.org/mpt/0.1/release-notes.html">release notes</a>
        for more details.
        </p>
        
        <a name="a25062009"></div><div class="section"><h4>Jun/2009 - Apache jSPF 0.9.7 released<a name="Jun2009_-_Apache_jSPF_0.9.7_released"></a></h4></a>
        <p>The Apache James Project is pleased to announce a new  
        <a class="externalLink" href="http://james.apache.org/jspf">Apache jSPF</a> release which included some critical bug fixes.
        </p> 
        
        <a name="a18062009"></div><div class="section"><h4>Jun/2009 - Apache JSieve 0.3 released<a name="Jun2009_-_Apache_JSieve_0.3_released"></a></h4></a>
        <p>The Apache James Project is pleased to announce that the third release of
        <a class="externalLink" href="http://james.apache.org/jsieve">Apache JSieve</a> - an implementation of the
        <a class="externalLink" href="http://www.ietf.org/rfc/rfc3028.txt">Sieve</a> mail filtering language - 
        is now available for <a href="download.cgi#Apache_JSieve">download</a>. This is the first
        modular release and includes a filtering <a class="externalLink" href="http://james.apache.org/mailet">mailet</a>.
        See the <a class="externalLink" href="http://james.apache.org/jsieve/0.3/release-notes.html">release notes</a>
        for more details.
        </p> 
        
        <a name="a14052009"></div><div class="section"><h4>May/2009 - Apache Crypto Mailets 1.0 released<a name="May2009_-_Apache_Crypto_Mailets_1.0_released"></a></h4></a>
        <p>The Apache James Project is pleased to announce the first independent release of
        <a class="externalLink" href="http://james.apache.org/mailet/crypto">Apache Cryptographic Mailets</a> (previous versions 
        were released as part of the 
        <a class="externalLink" href="http://james.apache.org/server">Apache James Server</a>). 
        This package contains mailets which encode, decode, sign and verify mail plus cryptology utilities.
        </p> 
        
        <a name="a01042009"></div><div class="section"><h4>Apr/2009 - Apache Mailet Base 1.0 released<a name="Apr2009_-_Apache_Mailet_Base_1.0_released"></a></h4></a>
        <p>The Apache James Project is pleased to announce the first independent release of
        <a class="externalLink" href="http://james.apache.org/mailet/base">Apache Mailet Base</a> (previous versions 
        were released as part of the 
        <a class="externalLink" href="http://james.apache.org/server">Apache James Server</a>). The Basic Mailet Toolkit
        contains lightweight frameworks and utilities likely to be of interest to 
        <a class="externalLink" href="http://james.apache.org/mailet/api">Mailet</a> developers.
        </p>   
        
        <a name="a08032009"></div><div class="section"><h4>Mar/2009 - Mime4j 0.6 released<a name="Mar2009_-_Mime4j_0.6_released"></a></h4></a>
        <p>We are proud to announce the <a href="../download.cgi">availability</a> of Apache 
        Mime4j-0.6. This release brings another round of API enhancements and performance 
        optimizations. There has been a number of notable improvements in the DOM support. MIME 
        stream parser is expected to be 50% faster when line counting is disabled. Please also note 
        that as of this release Mime4j requires a Java 1.5 compatible runtime</p>
        
        <a name="a21022009"></div><div class="section"><h4>Feb/2009 - MailetDocs Maven Plugin 0.1 released<a name="Feb2009_-_MailetDocs_Maven_Plugin_0.1_released"></a></h4></a>
        <p>The Apache James Project is pleased to announce the first release of the
        <a class="externalLink" href="http://james.apache.org/mailet/maven-mailetdocs-plugin/" rel="tag">MailetDocs</a> 
        plugin for <a class="externalLink" href="http://maven.apache.org" rel="tag">Maven</a>. The plugin catalogs mailet
        (for <a class="externalLink" href="http://james.apache.org/mailet/standard/mailet-report.html">example</a>). 
        For more information, see the 
        <a class="externalLink" href="http://james.apache.org/mailet/maven-mailetdocs-plugin/release-notes.html">release notes</a>.
        </p>  
        
        <a name="a01052009"></div><div class="section"><h4>Jan/2009 - Apache Mailet 2.4 released<a name="Jan2009_-_Apache_Mailet_2.4_released"></a></h4></a>
        <p>The Apache James Project is pleased to announce the first independent release of
        <a class="externalLink" href="http://james.apache.org/mailet/api">Apache Mailet</a> (previous versions 
        were released as part of the 
        <a class="externalLink" href="http://james.apache.org/server">Apache James Server</a>). The Mailet API
        defines a standard approach to enterprise mail processing.
        </p>   
        
    </div></div>
    
    <div class="section"><h3>2008<a name="a2008"></a></h3>
    
        <a name="a10162008"><div class="section"><h4>October/2008 - Mime4j 0.5 released<a name="October2008_-_Mime4j_0.5_released"></a></h4></a>
        <p>We are proud to announce the <a href="../download.cgi">availability</a> of APACHE Mime4j-0.5. This release addresses a number of important issues discovered since 0.4. In particular, it improves Mime4j ability to deal with malformed data streams including those intentionally crafted to cause excessive CPU and memory utilization that can lead to DoS condition</p>
        <p>This release also fixes a serious bug that can prevent Mime4j from correctly processing binary content</p>
        <a name="a08262008"></div><div class="section"><h4>Aug/2008 - Apache JSieve 0.2 released<a name="Aug2008_-_Apache_JSieve_0.2_released"></a></h4></a>
        <p>The Apache James Project is pleased to announce the first public release of 
        <a class="externalLink" href="http://james.apache.org/jsieve">Apache JSieve</a> an implementation
        of <a class="externalLink" href="http://www.faqs.org/rfcs/rfc3028.html">RFC3028 - Sieve: A Mail Filtering Language</a>
        for Java.
        </p>
        
        <a name="a08222008"></div><div class="section"><h4>Aug/2008 - Mime4j 0.4 released<a name="Aug2008_-_Mime4j_0.4_released"></a></h4></a>
        <p>We are proud to announce the <a href="../download.cgi">availability</a> of APACHE Mime4j-0.4. This release brings a number of significant improvements in terms of supported capabilities, flexibility and performance:</p>
        <ul>
          <li>Revised and improved public API with support for pull parsing</li>
          <li>Support for parsing of 'headless' messages transmitted using non SMTP transports such as HTTP</li>
          <li>Reduced external dependencies. Mime4j is no longer directly dependent on log4j and commons-io</li>
          <li>Improved parsing performance (up to 10x for large messages)</li>
          <li>More comprehensive header parsing including support for RFC1864, RFC2045, RFC2183, RFC2557 and RFC3066</li>
          <li>Revised packaging and exception hierarchy. MimeException now extends IOException</li>
        </ul>
        
        <a name="a04082008"></div><div class="section"><h4>Apr/2008 - jSPF-0.9.6 released<a name="Apr2008_-_jSPF-0.9.6_released"></a></h4></a>
        <p>We are proud to announce the <a href="../download.cgi">availability</a> release of APACHE jSPF-0.9.6. This release fix two possible NullPointerExceptions and handle the &quot;exp=&quot; modifier correctly.</p>
    
        <a name="a03192008"></div><div class="section"><h4>Mar/2008 - James publishes project ideas for Google Summer of Code '08<a name="Mar2008_-_James_publishes_project_ideas_for_Google_Summer_of_Code_08"></a></h4></a>
        <p>The James Team are delighted to announce that we're proposing two project ideas for <a class="externalLink" href="http://code.google.com/soc/2008/">Google Summer of Code (GSOC) 2008</a>. The project Ideas are set out on the Apache GSOC wiki <a class="externalLink" href="http://wiki.apache.org/general/SummerOfCode2008#james">here</a>.</p>
        <p>In brief they are:<br />
        1) Develop a VERP Mailet to allow James to write VERP modified return addresses on outbound messages, and an inbound mailet/matcher to identify VERP bounces and invoke configurable &quot;do something&quot; code.
        <br />
        And <br />
        2) James' provided mailing list manager is fine for small closed groups, but lacks the functionality of a more robust MLM, the project is to add some all or more of the following features subscriber and message moderation, double opt-in and bounce handling.</p>

    </div></div>
    
    <div class="section"><h3>2007<a name="a2007"></a></h3>

        <a name="a09252007"><div class="section"><h4>Sept/2007 - jSPF-0.9.5 released<a name="Sept2007_-_jSPF-0.9.5_released"></a></h4></a>
        <p>We are proud to announce the <a href="download.cgi">availability</a> of APACHE jSPF-0.9.5. This release brings initial support for asynchronous processing and is fully RFC4408 compliant.</p> 

        <a name="a05302007"></div><div class="section"><h4>May/2007 - Apache Mime4J 0.3 Final Released<a name="May2007_-_Apache_Mime4J_0.3_Final_Released"></a></h4></a>
        <p>After almost 2 years the Apache James team is proud to announce the <a href="download.cgi">availability</a> of Apache Mime4J 0.3. This is the first release under the ASF umbrella.</p>

        <a name="a05052007"></div><div class="section"><h4>May/2007 - Mailet API sub-project lives<a name="May2007_-_Mailet_API_sub-project_lives"></a></h4></a>
        <p>Following a decision taken by the James PMC a few months ago, the Apache Mailet API project is now independent of James Server and has its own <a href="mailet/index.html">webpage</a> and its own source repository.</p>

        <a name="a04029007"></a></div><div class="section"><h4>Apr/2007 - James Server 2.3.1 Final Released<a name="Apr2007_-_James_Server_2.3.1_Final_Released"></a></h4>
        <p>James PMC is proud to announce the <a href="download.cgi">availability</a> of the final release of James Server 2.3.1. More informations on what has been fixed since the 2.3.0 release can be found in the <a href="/server/2.3.1/changelog.html">changelog</a>.</p>

        <a name="a04192007"></div><div class="section"><h4>Apr/2007 - James Server 2.3.1 RC1 released<a name="Apr2007_-_James_Server_2.3.1_RC1_released"></a></h4></a>
        <p>James PMC is proud to announce the <a class="externalLink" href="http://www.apache.org/dist/james/server/rc">availability</a> of the first release candidate of James Server 2.3.1. This release is maintenance release. See the <a class="externalLink" href="http://issues.apache.org/jira/browse/James?report=com.atlassian.jira.plugin.system.project:changelog-panel"> changelog </a> for more detail.</p>

        <a name="a04162007"></div><div class="section"><h4>Apr/2007 - Apache James Project Guidelines published<a name="Apr2007_-_Apache_James_Project_Guidelines_published"></a></h4></a>
        <p>The James PMC has approved - for the first time - a set of <a href="guidelines.html">guidelines</a> for the project. These guidelines are intended to reflect and summarize well-known practices in our community. They include &quot;... definitions of how conflict is resolved by voting, who is able to vote, and the procedures to follow for proposing and making changes to the Apache James products.&quot; </p>

        <a name="a02092007"></div><div class="section"><h4>Feb/2007 - jSPF-0.9b4 released<a name="Feb2007_-_jSPF-0.9b4_released"></a></h4></a>
        <p>James PMC is proud to announce the <a class="externalLink" href="http://www.apache.org/dist/james/jspf/beta">availability</a> of the fourth beta of jspf 0.9. This version pass all tests in the last official release of the <a class="externalLink" href="http://www.openspf.org/svn/project/test-suite/rfc4408-tests-2007.01.yml">spf testsuite</a>.</p>

        <a name="a02012007"></div><div class="section"><h4>Feb/2007 - Feathercast features James<a name="Feb2007_-_Feathercast_features_James"></a></h4></a>
        <p>James PMC member and commiter <a class="externalLink" href="http://people.apache.org/list_A.html">Danny Angus</a> was interviewed about James by David Reid for Feathercast episode 24. You can download the podcast from <a class="externalLink" href="http://feathercast.org/?p=39">here</a>.</p>

        <a name="a01012007"></div><div class="section"><h4>Jan/2007 - Mailet API to become a sub-project<a name="Jan2007_-_Mailet_API_to_become_a_sub-project"></a></h4></a>
        <p>The James commiters have voted to promote the Mailet API to its own James sub-project.<br />
        This move will provide a clearer division between development of the API and development of James server, and we hope this will encourage more participation from external projects.</p>
        <p>The effort will start small, by releasing the current version, and move on to look at the enhancements we've been discussing over on <a class="externalLink" href="http://james.apache.org/mail.html">the mailet api list</a> where we will extend a warm welcome to anyone who has something to contribute.</p>
        <p>Eventually we hope to extend the scope of the sub-project to include things like a Reference Implementation independent of James Server and suitable for embedding, an SDK, and possibly a TCK.
        </p>

    </div></div>

    <div class="section"><h3>2006<a name="a2006"></a></h3>

     <a name="a00102006"></a><div class="section"><h4>Oct/2006 - James Server 2.3.0 Final Released<a name="Oct2006_-_James_Server_2.3.0_Final_Released"></a></h4>
     <p>James PMC is proud to announce the <a href="download.cgi">availability</a> of the long awaited final release of James Server 2.3.0. More informations on what's new can be found in the <a href="/server/2.3.0/changelog.html">changelog</a>.</p>

     <a name="a00092006"></a></div><div class="section"><h4>Sep/2006 - jSPF 0.9 b3 Released<a name="Sep2006_-_jSPF_0.9_b3_Released"></a></h4>
     <p>James PMC is proud to announce the <a class="externalLink" href="http://people.apache.org/dist/james/jspf/">availability</a> of the third beta of jspf 0.9. This version has start to use the official spf testsuite to fix all rfc issues.</p>

     <a name="a01082006"></a></div><div class="section"><h4>Aug/2006 - James Server 2.3.0 RC3 Released<a name="Aug2006_-_James_Server_2.3.0_RC3_Released"></a></h4>
     <p>James PMC is proud to announce the <a class="externalLink" href="http://people.apache.org/dist/james/server/">availability</a> of the third, and hopefully last, release candidate of James Server 2.3.0. More informations on what's new can be found in the <a href="/server/2.3.0/changelog.html">changelog</a>.</p>
     <p>New development roadmaps are being discussed right now, so stay tuned for 2.3.0 final and for the following news. - Sep/2006</p>

     <a name="a00082006"></a></div><div class="section"><h4>Aug/2006 - James Products website revamped<a name="Aug2006_-_James_Products_website_revamped"></a></h4>
     <p>We just finished a major update of james products to be able to publish each product specific site under this new website structure</p>

     <a name="a01072006"></a></div><div class="section"><h4>Jul/2006 - James Server 2.3.0 on the way<a name="Jul2006_-_James_Server_2.3.0_on_the_way"></a></h4>
     <p>After a long time of development we have released the first <a class="externalLink" href="http://people.apache.org/dist/james/server/">release candidate</a> of James Server 2.3.0. After a period of user testing version 2.3.0 will be released.</p>

     <a name="a00072006"></a></div><div class="section"><h4>Jul/2006 - New project James jSPF<a name="Jul2006_-_New_project_James_jSPF"></a></h4>
     <p>James PMC is happy to announce that we are working on a Java implementation of the SPF specification. The first <a class="externalLink" href="http://people.apache.org/dist/james/jspf/">betas</a> are already available for download.</p>

    </div></div>

    <div class="section"><h3>2005<a name="a2005"></a></h3>

      <div class="section"><h4>James PMC react to the closure of Apache Avalon.<a name="James_PMC_react_to_the_closure_of_Apache_Avalon."></a></h4>
      <p>James PMC would like to reassure all of our users that James Server is alive and well. All of the James team have kept abreast of the Avalon developments culminating in the closure of the Avalon project and dispersal of its codebase. We are are keen to stress that this has little impact on our ability to support and develop Server in both the short and long terms.<br />Over the coming months we will be finalising and publishing a road map for James Server which will address all of the specific concerns raised by Avalon's closure, but rest assured James Server' future is safe, and we have enthusiasm and plans aplenty.<br /> In the meantime we would like to extend our best wishes to all our friends from Avalon, here's luck with your future projects guys!<br /> If you are at all concerned please subscribe to the server-user mailing list and raise your points there. - 05/Jan/2005</p>

      </div><div class="section"><h4>James product sources have moved to &quot;Subversion&quot;<a name="James_product_sources_have_moved_to_Subversion"></a></h4>
      <p>Subversion is a version control system like CVS, but it has advantages over CVS for Apache Software Foundation (ASF) projects.<br /> In common with all other ASF projects we have reviewed our use of CVS and migrated our code to Subversion.<br />
         Have a look at this <a href="server/FAQ.html#a17">FAQ</a> for further details. - 05/Jan/2005</p>
      <p></p>

    </div></div>

    </div>

  


      </div>
    </div>
    <div class="clear">
      <hr/>
    </div>
    <div id="footer">
      <div class="xright">Copyright &#169;                    2006-2012
                        <a href="http://www.apache.org/">The Apache Software Foundation</a>.
            All Rights Reserved.      
                
      </div>
      <div class="clear">
        <hr/>
      </div>
    </div>
  </body>
</html>
