---
layout: default
title: Announcements 2008
---

<h1>Announcements - 2008</h1>

<p class="pull-right">
  Skip to: <a href="announce-2007.html">Announcements - 2007</a>
</p>

<h4 id="a20081204">04 December 2008 - Struts 1.3.10 General Availability Release</h4>
<p>
  The Apache Struts group is pleased to announce that Struts 1.3.10
  is available as a "General Availability" release. The GA designation is
  our highest quality grade.
</p>
<p>
  Struts 1.3.10 is available in a full distribution, or as separate
  library, source, example and documentation distributions.
</p>
<p>
  <a href="http://struts.apache.org/download.cgi#struts1310">
    http://struts.apache.org/download.cgi#struts1310</a>
</p>
<p>
  It is also available in the central Maven repository under Group ID
  "org.apache.struts".
</p>

<h4 id="a20081124">24 November 2008 - Struts 2.0.14 General Availability Release</h4>
<p>
  The Apache Struts group is pleased to announce that Struts 2.0.14 is
  available as a "General Availability" release. The GA designation is
  our highest quality grade.
</p>
<p>
  Apache Struts 2 is an elegant, extensible framework for creating
  enterprise-ready Java web applications. The framework is designed to
  streamline the full development cycle, from building, to deploying, to
  maintaining applications over time.
</p>
<p>
  This release is a bugfix release for version 2.0.12, which provided important
  security fixes.
  Struts 2.0.14 addresses two major bugs introduced with these security fixes,
  keeping the FilterDispatcher from serving built in static resources,
  and keeping conversion error messages from being displayed.
</p>
<p>
  All developers are strongly encouraged to update existing Struts 2 applications
  to Struts 2.0.14.
</p>
<p>
  Struts 2.0.14 is available in a full distribution,
  or as separate library, source, example and documentation
  distributions, from the
  <a href="http://struts.apache.org/download.cgi#struts2014">releases page</a>.
  The release is also available through the central Maven repository under Group ID
  "org.apache.struts". The
  <a href="http://struts.apache.org/2.0.14/docs/release-notes-2014.html">release notes</a>
  are available online.
</p>
<p>
  The 2.0.x series of the Apache Struts framework has a minimum
  requirement of the following specification versions: Servlet API 2.4,
  JSP API 2.0, Java 5, Backported Java 4 JARs are also available.
</p>
<p>
  Should any issues arise with your use of any version of the Struts
  framework, please post your comments to the user list, and, if
  appropriate, file a
  <a href="https://issues.apache.org/struts/secure/Dashboard.jspa">tracking ticket</a>.
</p>


<h4 id="a20081020">20 October 2008 - Struts 2.0.12 General Availability Release</h4>
<p>
  The Apache Struts group is pleased to announce that Struts 2.0.12 is
  available as a "General Availability" release. The GA designation is
  our highest quality grade.
</p>
<p>
  Apache Struts 2 is an elegant, extensible framework for creating
  enterprise-ready Java web applications. The framework is designed to
  streamline the full development cycle, from building, to deploying, to
  maintaining applications over time.
</p>
<p>
  This release includes a number of bug fixes since the
  2.0.11.2 GA release, including important security fixes regarding remote
  server context manipulation by injecting OGNL expressions in request parameters
  and possible server filesystem resources read access in certain application
  server environments. For more information about the exploits, see the corresponding
  security bulletins <a href="http://struts.apache.org/2.0.12/docs/s2-003.html">S2-003</a>
  and <a href="http://struts.apache.org/2.0.12/docs/s2-004.html">S2-004</a>.
</p>
<p>
  All developers are strongly advised to update existing Struts 2 applications
  to Struts 2.0.12.
</p>
<p>
  Struts 2.0.12 is available in a full distribution,
  or as separate library, source, example and documentation
  distributions, from the
  <a href="http://struts.apache.org/download.cgi#struts2012">releases page</a>.
  The release is also available through the central Maven repository under Group ID
  "org.apache.struts". The
  <a href="http://struts.apache.org/2.0.12/docs/release-notes-2012.html">release notes</a>
  are available online.
</p>
<p>
  The 2.0.x series of the Apache Struts framework has a minimum
  requirement of the following specification versions: Servlet API 2.4,
  JSP API 2.0, Java 5, Backported Java 4 JARs are also available.
</p>
<p>
  Should any issues arise with your use of any version of the Struts
  framework, please post your comments to the user list, and, if
  appropriate, file a
  <a href="https://issues.apache.org/struts/secure/Dashboard.jspa">tracking ticket</a>.
</p>


<h4 id="a20080204-1">4 February 2008 - New Struts Committer Jeromy Evans</h4>
<p>
  Please join us in welcoming Jeromy Evans as a new Struts committer.
</p>
<p>
  Jeromy has been posting to the user list since May 2007, and to dev@
  since July 2007, and has submitted two issues to JIRA, both with
  patches.
</p>
<p>
  Welcome, jeromy@ ... WW-2398 is all yours now!
</p>
<p>
  PMC vote: 5 +1s
</p>

<h4 id="a20080204-2">4 February 2008 - New Struts Committer Wes Wannemacher</h4>
<p>
  Please join us in welcoming Wes Wannemacher as a new Struts committer.
</p>
<p>
  Wes has been posting to the user list and to dev@ since September
  2007, and, to date, he has reported a dozen JIRA issues, often with
  patches. Wes has also been helping with the documentation.
</p>
<p>
  Welcome, wesw@ ... now you tweak your own POMs!
</p>
<p>
  PMC vote: 6 +1s
</p>
<hr/>

<p class="pull-right">
  Skip to: <a href="announce-2007.html">Announcements - 2007</a>
</p>

<p class="pull-left">
  <strong>Next:</strong>
  <a href="kickstart.html">Kickstart FAQ</a>
</p>
