diff --git a/acceleo/plan-3_2_0.xml b/acceleo/plan-3_2_0.xml
new file mode 100644
index 0000000..ab4b6d2
--- /dev/null
+++ b/acceleo/plan-3_2_0.xml
@@ -0,0 +1,111 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
+<?xml-stylesheet type="text/xsl" href="http://www.eclipse.org/projects/project-plan.xsl"?>
+<plan plan-format="1.0" xmlns="http://www.eclipse.org/project/plan" xmlns:html="http://www.w3.org/1999/xhtml"
+      name="Project Name">
+   <release projectid="modeling.m2t.acceleo" version="3.2.0"/>
+   <introduction>
+     <html:div>
+     This document lays out the feature and API set for the 3.2.0 release of the M2T Acceleo project.  
+     The Acceleo component is an open source component under the Eclipse Modeling / Model-To-Text (M2T) project.
+     Its primary goal is to provide an implementation of the MOF Model-To-Text OMG standard.
+     
+	 The new release of Acceleo introduces no API or feature breakage, and is thus labeled 3.2.0.
+     </html:div>
+   </introduction>
+   <release_deliverables>
+	<html:p>
+    The release deliverables have the same form as is found in most Eclipse projects, namely:
+	<html:ul>
+		<html:li>Acceleo SDK (includes runtime and tooling components, with sources, examples, and documentation) (downloadable and update site).</html:li>
+		<html:li>Acceleo runtime binary distribution (downloadable and update site).</html:li>
+		<html:li>Acceleo examples (downloadable and update site)</html:li>
+		<html:li>Acceleo tests (downloadable and update site)</html:li>
+	</html:ul>
+	</html:p>
+    </release_deliverables>
+   <release_milestones>
+      <preamble>
+         <html:div>
+         The implementation will be compliant with the advanced feature compliance level of the MOF Model-To-Text OMG language (No Macro and alternative syntax).
+         The milestones for this release of Acceleo will be synchronized with the Indigo release schedule.
+         </html:div>
+      </preamble>
+      <milestone date="10/10/2011" milestone="RC1"><html:div></html:div></milestone>
+      <milestone date="10/11/2011" milestone="RC2"><html:div></html:div></milestone>
+      <milestone date="10/12/2011" milestone="RC3"><html:div></html:div></milestone>
+      <milestone date="10/13/2011" milestone="RC4"><html:div></html:div></milestone>
+      <milestone date="10/14/2010" milestone="3.1 Final"><html:div></html:div></milestone>
+      <postamble><html:div></html:div></postamble>
+   </release_milestones>
+   <target_environments>
+     <html:div>
+     The acceleo project depends upon the Platform and other projects, which are mostly "pure" Java.
+     Acceleo 3.2.0 will be compatible with Eclipse Ganymede, Galileo, Helios and Indigo. 
+     EMF is used throughout Acceleo both for its inner mechanics and accessing the target models.
+     The MDT-OCL component is reused to edit, parse, and interpret OCL as a sub-language of Acceleo. 
+     Acceleo will target the same Java version as EMF, which currently requires Java 5.
+     Acceleo will be tested and validated against Eclipse SDK 3.4.2, 3.5.2, 3.6.2 and 3.7.0.
+     </html:div>
+          <internationalization>
+          <html:div>
+          <html:p>
+	The Eclipse Platform is designed as the basis for internationalized products. The user interface
+	elements provided by the Eclipse SDK components, including dialogs and error messages, are
+	externalized. The English strings are provided as the default resource bundles. Likewise, the
+	Acceleo project will provide English strings in its default bundles and be localized to a subset
+	of those locales offered by the Platform. This plan will be updated to indicate which locales
+	will be provided and the time frame for availability.
+          </html:p>
+          </html:div>
+     </internationalization>
+   </target_environments>
+   <compatibility_with_previous_releases>
+       <html:div>
+       The acceleo 3.2 version will be compatible with the 3.1, 3.0 and 0.8 versions.
+       </html:div>
+   </compatibility_with_previous_releases>
+   <themes_and_priorities>
+     <preamble>
+         <html:div></html:div>
+     </preamble>
+     <theme name="Advanced feature compliance">
+        <description>
+        	<html:ul>
+        <html:li>Standalone Component.</html:li>
+        <html:li>Advanced feature compliance level of the MOF Model-To-Text language.</html:li>
+		<html:li>Keep the user code you typed manually : User tags and JMerge support.</html:li>
+		<html:li>Complete Acceleo Runtime library.</html:li>
+		<html:li>Java developer facilities : Java extensions and Properties files.</html:li>
+		<html:li>Files encoding.</html:li>
+		<html:li>MTL Syntax Documentation.</html:li>
+			</html:ul>
+        </description>
+     </theme>
+     <theme name="Eclipse IDE components">
+        <description>
+        	<html:ul>
+        <html:li>2 modes for the Eclipse Builder : The fully OMG-compliant standard mode and the EMF addict mode.</html:li>
+        <html:li>Advanced code completion and quick fixes to create a template from an example.</html:li>
+        <html:li>Overrides View : Show the workspace and the plugin generators to make it possible to easily override the behavior of the code generation.</html:li>
+        <html:li>Traceability information : The Result view shows the synchronization between the code and the model.</html:li>
+        <html:li>Export a generator as a plugin and build a generator on the Eclipse build server.</html:li>
+        <html:li>Debug and Profile a code generation.</html:li>
+        <html:li>Real time syntax error detection.</html:li>
+        <html:li>IDE Documentation.</html:li>
+        	</html:ul>
+        </description>
+     </theme>
+	 <theme name="Integration with other tools">
+	    <description>
+	    	<html:ul>
+	    <html:li>Workflow facilities for acceleo.</html:li>
+	    <html:li>Compatibility with other Eclipse modeling projects like QVTo, ATL, JET, and Xpand.</html:li>
+	    <html:li>A wizard to migrate an Acceleo template from the 2.x versions to the 3.x versions.</html:li>
+	    	</html:ul>
+	    </description>
+     </theme>
+     <theme name="Examples">
+        <description>Examples for end-users : Python, Java</description>
+     </theme>
+   </themes_and_priorities>
+ </plan>
