diff --git a/download/index.php b/download/index.php
index 31e5ca6..b7dc1ff 100644
--- a/download/index.php
+++ b/download/index.php
@@ -45,33 +45,18 @@
 			<table style="width: 95%;" border="1" cellpadding="2" cellspacing="5" align="">			
 				<tr>
 					<th align="left">ATL version</th>
-					<td>ATL dev 2_1_0 <br/><a href ="http://wiki.eclipse.org/ATL/How_Install_ATL_%28Dev%29_From_CVS">
-						http://wiki.eclipse.org/ATL/How_Install_ATL_(Dev)_From_CVS </a>
+					<td><a href ="http://www.eclipse.org/atl/developers/repositoryDetails.php">
+						ATL 3.x </a><br/>
 					</td>
 				</tr>
 				<tr>
-					<th align="left">Eclipse version</th>
-					<td>3.4.2</td>
-				</tr>
-				<tr>
-					<th align="left">EMF version</th>
-					<td>2.4.0</td>
-				</tr>
-				<tr>
 					<th align="left">SVN repository</th>
 					<td>
-						https://dev.eclipse.org/svnroot/modeling/org.eclipse.gmt.amw
+						<a href ="http://dev.eclipse.org/viewsvn/viewvc.cgi/?root=Modeling_AMW">
+						http://dev.eclipse.org/viewsvn/viewvc.cgi/?root=Modeling_AMW
 						</a>
 					</td>
 				</tr>				
-				<tr>
-					<th align="left">AM3 version</th>
-					<td> 
-						AM3 dev <br/>
-						<a href ="http://wiki.eclipse.org/AM3/How_Install_AM3_From_SVN">
-						http://wiki.eclipse.org/AM3/How_Install_AM3_From_SVN </a>
-					</td>
-				</tr>	
 				</table>				
 			<p/>					
 			</div>
@@ -87,6 +72,47 @@
 			<table style="width: 95%;" border="1" cellpadding="2" cellspacing="5" align="">
 				<tr>
 					<th width="25%" align="left">Build date</th>
+					<td>November, 25th 2010</td>
+				</tr>
+				<tr>
+					<th align="left">ATL version</th>
+					<td><a href ="http://www.eclipse.org/atl/download/">
+						3.x </a></td>
+				</tr>
+				<tr>
+					<th align="left">Eclipse version</th>
+					<td>Helios</td>
+				</tr>
+				<tr>
+					<th align="left">EMF version</th>
+					<td>Any Helios-compatible version</td>
+				</tr>
+				<tr>
+					<th align="left">Zip file</th>
+					<td>
+						<a href="http://www.eclipse.org/downloads/download.php?file=/modeling/gmt/amw/binaries/AMW-stable/mwplugins-stable.zip">
+						mwplugins-stable.zip</a></td>
+				</tr>					
+				<tr>
+					<th align="left">More info</th>
+					<td>
+						This bundle has been tested using the Eclipse Modeling bundle.<br/>						
+					</td>
+				</tr>					
+				</table>				
+			
+			<p/>					
+			</div>
+		</div>
+		
+		<div class="homeitem3col">
+			<h3>Stable builds</h3>
+
+			<div align="center">
+			
+			<table style="width: 95%;" border="1" cellpadding="2" cellspacing="5" align="">
+				<tr>
+					<th width="25%" align="left">Build date</th>
 					<td>October 15th, 2007</td>
 				</tr>
 				<tr>
@@ -105,32 +131,18 @@
 				<tr>
 					<th align="left">Zip file</th>
 					<td>
-						<a href="http://www.eclipse.org/downloads/download.php?file=/modeling/gmt/amw/binaries/AMW-stable/mwplugins-stable.zip">
-						mwplugins-stable.zip</a></td>
-				</tr>				
+						<a href="http://www.eclipse.org/downloads/download.php?file=/modeling/gmt/amw/binaries/AMW-20071015/mwplugins-20071015.zip">
+						mwplugins-20071015.zip</a></td>
+				</tr>					
 				<tr>
-					<th align="left">More info</th>
-					<td> 
-						This build is regularly updated with the <b>newest features</b> of AMW. It allows having the latest functionalities (some still
-						under testing)	without the need to install AMW from the sources.
-					</td>
-				</tr>	
-					<tr>
 					<th align="left">AMW, AM3 and ATL compatibility</th>
 					<td>
-						This version was tested using ATL and AM3 from the update site (version 2.0RC2).<br/>
+						This is the last version of AMW that is compatible with ATL2.x and AM3 plug-ins.<br/>
 					</td>
 				</tr>					
 				</table>				
-			<p/>					
-			</div>
-		</div>
-		
-		<div class="homeitem3col">
-			<h3>Release builds</h3>
-
-			<div align="center">
 			
+			<p/>			
 			<table style="width: 95%;" border="1" cellpadding="2" cellspacing="5" align="">
 				<tr>
 					<th width="25%" align="left">Build date</th>
diff --git a/index.php b/index.php
index 735ebde..8a7e9db 100644
--- a/index.php
+++ b/index.php
@@ -82,19 +82,6 @@
 						</tr>
 					</table>
 				</li>
-				<li>
-					<table width="100%">
-						<tr>
-							<td width="80%" valign="bottom">
-								<b><a href="publication.php">Publications</a></b><b> (new)</b>, 
-								<a href="references.php"> external references</a>
-		  					</td>
-							<td align="right">
-								<a href="publication.php"><img align="right" src="../resources/images/reference.gif" valign="top"/></a>
-							</td>
-						</tr>
-					</table>
-				</li>
 
 				<li>
 					<table width="100%">
diff --git a/news/amwNewsArchive.rss b/news/amwNewsArchive.rss
index a40ff19..469c316 100644
--- a/news/amwNewsArchive.rss
+++ b/news/amwNewsArchive.rss
@@ -7,6 +7,30 @@
 
 
 <item>
+		<title>A new version of AMW compatible with ATL 3 is now available!</title>
+		<description>
+			A new version of AMW that is compatible with the latest versions of Eclipse, EMF and ATL3 is available. <p/>
+			The plug-ins are available for download in the 
+			<a href="http://www.eclipse.org/gmt/amw/download/">download section</a>. <p/>
+			
+			The sources can be checked-out in the  	
+			<a href="http://dev.eclipse.org/viewsvn/index.cgi/plugins/trunk/?root=Modeling_AMW">AMW SVN</a>.
+			The plug-ins have been tested using Eclipse Mdeling bundle, to simplify the installation.
+			<p/>
+			This version has different modifications: <br/>
+			<ul>
+			<li>The model manager has been updated to be compatible with ATL 3. </li>
+			<li>The AMW model handler plug-in has been removed. Now AMW uses the ATL <i>org.eclipse.m2m.atl.engine.emfvm.libextension</i> extension point for registering new operations. New operations can be easily added.</li>
+			<li>The ATL transformation model generated after the execution of the matching transformations is automatically extracted into the corresponding .atl file</li>
+			<li>The KM3 import feature is temporarily disabled.</li>
+			</ul>
+			
+										
+		</description>
+		<pubDate>Thu, 25 Nov 2010 18:00:00 CET</pubDate>
+	</item>
+
+<item>
 		<title>The new sources of AMW have been committed</title>
 		<description>
 			The sources of AMW have just been committed under 	
@@ -106,596 +130,6 @@
 		<pubDate>Tue, 21 Aug 2007 11:00:00 CET</pubDate>
 	</item>
 
-    <item>
-    
-    
-    
-		<title>July 13th, 2007 - Free tutorial - "Practice of model transformation and model weaving with ATL, AMW, and TCS"</title>
-		<description>
-			<p align="justify">
-				The INRIA ATLAS team organizes in Nantes (France) a day essentially dedicated to the practice of model transformation (ATL) and model weaving (AMW) tools. This day is intended for 
-				ATL and AMW beginners who want to improve their knowledge in the domain. The tools are available in open source under Eclipse and a previous minimal experience with ATL is 
-				recommended.
-			</p>
-			<p align="justify">
-				The participation to this day is free of charge but the inscription is mandatory. The number of available places being limited (~15), the inscription's requests will be 
-				treated depending on their arrival order.
-			</p>
 
-			<p align="justify">
-				The tutorial takes place the 13th of July 2007, from 9h to 12h and from 14h to 18h. The inscription's requests have to be sent as soon as possible to Hugo Bruneliere
-				(Hugo DOT Bruneliere AT univ-nantes DOT fr).
-			</p>
-
-			<p align="justify">
-				Please provide us in your request the basic information such as your name, company, phone number, etc. According to the number of available places, an answer will be sent 
-				to you including more details concerning the course of the day.
-			</p>
-
-			<p align="justify">
-				The tutorials will be either in French or in English, depending on the audience. All the slides will be in English and will be provided to the participants at the 
-				beginning of the day (slides non-available outside of the tutorial).
-			</p>
-
-			<p align="justify">
-				The goal of this day is to provide a practical point of view on Model-Driven Engineering (MDE). By following numerous examples and use cases, you will discover how to:
-				<ul>
-					<li>Refine models in order to target a specific execution platform;</li>
-					<li>Make tools and norms interoperable;</li>
-					<li>Build, at low cost, domain-specific languages (DSLs);</li>
-					<li>Define chains of transformations and integrate them in a workflow.</li>
-				</ul>
-			</p>
-
-			<p align="justify">
-				Each of these points will use on or several tools of the Atlas Model Management Architecture (AMMA) tool suite, with in particular:
-				<ul>
-					<li>Atlas Transformation Language (ATL): a model transformation language and engine;</li>
-					<li>Kernel MetaMetaModel (KM3): a metamodel definition language;</li>
-					<li>Atlas Model Weaver (AMW): a model weaving prototype for interoperability and traceability;</li>
-					<li>Textual Concrete Syntax (TCS): a model textual syntaxes definition language;</li>
-					<li>Atlas MegaModel Management (AM3): a modeling artifact management prototype in order to facilitate the model-driven development (collaboration, distribution, etc).</li>
-				</ul>
-			</p>
-
-			<p align="justify">
-				All these tools are available from the Eclipse foundation website (http://www.eclipse.org ). ATL is a component of the model-to-model transformation project (M2M).The others 
-				are available as components of the GMT project. GMT has the goal to provide an incubation area for innovative projects related to model engineering. M2M and GMT are parts of 
-				the top-level modeling project gathering the model engineering activities of the Eclipse foundation.
-			</p>
-
-			<p align="justify">
-				Reference: 
-				<ul>
-					<li><a href="http://www.eclipse.org/m2m/atl/">http://www.eclipse.org/m2m/atl/</a></li>
-					<li><a href="http://www.eclipse.org/gmt/amw/">http://www.eclipse.org/gmt/amw/</a></li>
-					<li><a href="http://www.eclipse.org/gmt/am3/">http://www.eclipse.org/gmt/am3/</a></li>
-					<li><a href="http://www.eclipse.org/gmt/tcs/">http://www.eclipse.org/gmt/tcs/</a></li>
-				</ul>
-			</p>
-		</description>
-		<pubDate>Thu, 5 July 2007 12:00:00 CET</pubDate>
-	</item>
-
- 	<item>
-		<title>New use case available : inverting metamodel mappings</title>
-      	<link>http://www.eclipse.org/gmt/amw/usecases/inverse/</link>
-		<description>
-			The objective of this use case is to show that AMW can easily support the process of inverse mapping generation. 
-			Inversing of mappings is on of the most important model management operators. 
-			Informally speaking, the operator puts back a given mapping of metamodels. 
-			The operator has multiple practical applications. 
-			This use case describes an application of inverses using a Sales Force Automation Systems.
-		</description>
-		<pubDate>Fri, 15 Jun 2007 12:00:00 CET</pubDate>
-	</item>
-
-
- 	<item>
-		<title>Major updates on the AMW sources</title>
-      	<link>http://www.eclipse.org/gmt/amw/download/</link>
-		<description>
-			The <a href="http://dev.eclipse.org/viewcvs/indextech.cgi/org.eclipse.gmt/AMW/">sources of AMW</a> were updated to 
-			be compatible with the migration of the ATL CVS from GMT into M2M. A binary release with these sources will be provided soon.
-			<p/>
-			The code was also refactored to completely separate the core plug-in (org.eclipse.weaver) from the extensions 
-			that execute transformations.
-			<p/>
-			The latest version before the updates was tagged as <b>build_20070327[ATLRefactoring_Migration]</b>
-		</description>
-		<pubDate>Thu, 12 Apr 2007 14:00:00 CET</pubDate>
-	</item>
-
- 	<item>
-		<title>New use case available : Metamodel Annotation for Ontology Design</title>
-      	<link>http://www.eclipse.org/gmt/amw/usecases/oamusecase/</link>
-		<description>
-			This use case presents a Model Driven solution for annotating models in order to obtain ontologies. Ontology design can 
-			be seen as a difficult task for people who are not aware of ontology concepts. By annotating already made models 
-			we expect to reduce the time for producing ontologies. 
-			<p/>
-			This use case is part of a work for a complete ontology development 
-			environment based on Model Driven Engineering made by <a href="mailto:g.hillairet@gmail.com">Guillaume Hillairet</a> from the 
-			<a href="http://www.univ-lr.fr/labo/l3i/site_statique/Index.html">L3I</a> Lab in La Rochelle (France).
-		</description>
-		<pubDate>Wed, 11 Apr 2007 11:00:00 CET</pubDate>
-	</item>
-
-
- 	<item>
-		<title>New use case available : Software product line engineering</title>
-      	<link>http://www.eclipse.org/gmt/amw/usecases/softwareproductline/</link>
-		<description>
-		Mapping features to models is a necessary step when developing software product lines of
-		models. In such product lines, we need to relate objects from feature models (i.e. features) to
-		objects from model templates. In this use case we show an extension to the AMW platform to
-		specify those relations through weaving models. 
-		<p/>
-		This use case was developed by <a href="http://www.opencanarias.com">OpenCanarias</a> company.
-		</description>
-		<pubDate>Mon, 09 Apr 2007 16:00:00 CET</pubDate>
-	</item>
-	
-	 <item>
-		<title>New extension to the AMW plug-in: graphical interface to develop simple ATL transformations</title>
-      	<link>http://www.eclipse.org/gmt/amw/download/</link>
-		<description>
-			 We developed an extension to the AMW plug-in that provides a graphical interface to develop simple ATL transformations. 
-			 The extension contains a metamodel extension with only the essential elements of ATL transformations: (modules, rules, input and 
-			 output elements, bindings).
-			 <p/>
-			 This extension has two main goals: <br/>
-			 - to demonstrate that AMW can be easily extended with new facilities;<br/>
-			 - to provide a simple graphical interface to develop ATL transformations.
-			 <p/>
-			 The plug-in name is <i>org.eclipse.gmt.weaver.qatl</i>. It is available in the 
-			 <a href="http://dev.eclipse.org/viewcvs/indextech.cgi/org.eclipse.gmt/AMW">AMW CVS</a>.			 
-			 
-			 
-		</description>
-		<pubDate>Wed, 07 Mar 2007 14:00:00 CET</pubDate>
-	</item>
-
-	
-	 <item>
-		<title>New use case - calculating the difference between two models</title>
-      	<link>http://www.eclipse.org/gmt/amw/usecases/diff/</link>
-		<description>
-			 This use case calculates the differences between two models.
-			 The difference between two models is an essential process to control the changes and evolutions of models. 
-			 The result of the difference is used to apply a patch in the the models.
-		</description>
-		<pubDate>Tue, 20 Feb 2007 19:00:00 CET</pubDate>
-	</item>
-
-
-	 <item>
-		<title>New use case - System Architecture management</title>
-      	<link>http://www.eclipse.org/gmt/amw/usecases/sys_of_sys/</link>
-		<description>
-			This use case shows how to map the overlapping concepts of different views of a complex system. It uses a System Architecture (SA) 
-			framework called DoDAF  (Department of Defense Architecture Framework).
-		</description>
-		<pubDate>Mon, 12 Feb 2007 17:00:00 CET</pubDate>
-	</item>
-
-	 <item>
-		<title>Improvements on the integration of AMW and ATL (AMW Model Handler)</title>
-      	<link>http://wiki.eclipse.org/index.php/AMW_Model_Handler</link>
-		<description>
-			The integration of AMW and ATL was improved. We created a model handler for weaving models and woven models
-			(AMWModelHandler). 
-			
-			This model handler provides a set of primitives that are often needed when developing ATL transformations that 
-			use weaving models.						
-		</description>
-		<pubDate>Fri, 09 Feb 2007 15:00:00 CET</pubDate>
-	</item>
-
-	 <item>
-		<title>New AMW use case - Bridge between Domain Specific Languages (DSLs) and UML profiles</title>
-      	<link>http://www.eclipse.org/gmt/amw/usecases/umlprofiles/</link>
-		<description>
-				The DSL approach aims at representing every domain with a specific metamodel. The UML approach uses profiles to create 
-				domain specific concepts. This use case shows how AMW and ATL are used to produce a bridge between these two modeling 
-				approaches.
-		</description>
-		<pubDate>Mon, 05 Feb 2007 18:30:00 CET</pubDate>
-	</item>
-
-	 <item>
-		<title>New AMW use case - Merge of geographical information (GML) and statistical data into SVG</title>
-      	<link>http://www.eclipse.org/gmt/amw/usecases/mergeSVG/</link>
-		<description>
-			This use case presents a weaving model used to define a merge operation between a metamodel with geographical information 
-			(an extension of GML) and a metamodel with data about the results of elections into a graphical representation (SVG).								
-		</description>
-		<pubDate>Thu, 01 Feb 2007 10:30:00 CET</pubDate>
-	</item>
-
-	 <item>
-		<title>New AMW use case - Data mapping between relational DB and XML</title>
-      	<link>http://www.eclipse.org/gmt/amw/usecases/RDBMSXML/ </link>
-		<description>
-			The data mapping between relational databases and XML is a typical problem in many organizations. This use case shows how weaving 
-			models capture the relationships between a metamodel with flat structures and foreign keys relationshps (representing a relational 
-			database) and a metamodel that contains nested structures (representing an XML base).
-		</description>
-		<pubDate>Wed, 31 Jan 2007 10:30:00 CET</pubDate>
-	</item>
-
-
- <item>
-		<title>New AMW use case - Bridge between SQL and KM3</title>
-      	<link>http://www.eclipse.org/gmt/amw/usecases/modelgen/ </link>
-		<description>
-			This use case shows how weaving models and model transformations are used to translate SQL-DDL (Data Definition Language) into KM3 
-			(modeling technical space). The use case presents the complete bridging process: the injection of the SQL file, the weaving model, 
-			the transformations, and finally the extraction into a KM3 file.
-		</description>
-		<pubDate>Mon, 29 Jan 2007 15:30:00 CET</pubDate>
-	</item>
-
-
- <item>
-		<title>New AMW use case - model annotation</title>
-      	<link>http://www.eclipse.org/gmt/amw/usecases/annotation/ </link>
-		<description>
-			 Models are annotated to add extra information that are not defined in the metamodel. 
-			 For instance, a model can be annotated with preprocessing informations, comments, etc. <br/>
-			 
-			 This use case presents a generic annotation framework built using AMW. 
-		</description>
-		<pubDate>Wed, 24 Jan 2007 11:00:00 CET</pubDate>
-	</item>
-
-
- <item>
-		<title>New AMW use case - tool interoperability</title>
-      	<link>http://www.eclipse.org/gmt/amw/usecases/interoperability/ </link>
-		<description>
-			Nowadays, there are a large number of tools that can be used to solve similar problems. 
-			However, the tools have different data format and semantics. To support interoperability between 
-			different tools, it is necessary to identify the 
-			heterogeneities between them.
-			<p/> 
-			This use case shows how weaving models are used to capture the heterogeneities
-			between different tools' metamodels. It uses two bug tracking tools as example.			
-		</description>
-		<pubDate>Mon, 22 Jan 2007 18:00:00 CET</pubDate>
-	</item>
-
-
-   <item>
-		<title>New AMW use case - model matching</title>
-      	<link>http://www.eclipse.org/gmt/amw/usecases/matching/ </link>
-		<description>
-			Matching is the process of creating weaving models. It is very important to provide methods 
-			to easily create weaving models, because this is the starting point for 
-			several other use cases. <p/>
-			
-			This use case presents a general overview of the matching process. It shows how AMW is integrated with 
-			ATL to be able to execute different matching transformations. <p/>
-			
-			This use case also provides a step-by-step 'HowTo' that explains how to execute these transformations, 
-			and a guide that explains how to develop user-defined methods. 		
-			
-		</description>
-		<pubDate>Sun, 21 Jan 2007 17:00:00 CET</pubDate>
-	</item>
-
-
-   <item>
-		<title>New AMW use case - aspect oriented modeling</title>
-      	<link>http://www.eclipse.org/gmt/amw/usecases/AOM/</link>
-		<description>
-			Aspect oriented modeling aims at weaving business models and cross cutting models in a single model. A weaving can be applied 
-			in any model (e.g., weavings in the cross cutting concern AND/OR in the business model), 
-			because there is no preferential model. This use case shows how AMW is used on an aspect oriented modeling appplication. 
-			The weaving model is interpreted by ATL transformations to weave the models. 
-		</description>
-		<pubDate>Fri, 19 Jan 2007 15:00:00 CET</pubDate>
-	</item>
-
-   <item>
-		<title>New AMW use case - traceability</title>
-      	<link>http://www.eclipse.org/gmt/amw/usecases/traceability/</link>
-		<description>
-			A new AMW use case is available: traceability of model transformations.
-			This use case considers traceability of model transformations. After executing a model transformation, it is often necessary 
-			to know the set of elements of the source model that were used to produce the target elements. 
-			A weaving model is used to save this traceability information.
-		</description>
-		<pubDate>Thu, 18 Jan 2007 14:00:00 CET</pubDate>
-	</item>
-
-   <item>
-		<title>New AMW use case - metamodel comparison</title>
-      	<link>http://www.eclipse.org/gmt/amw/usecases/compare/</link>
-		<description>
-			A new use case of AMW is available: metamodel comparison.
-			The objective of this use case is to demonstrate how weaving models created with the AMW plug-in are 
-			used to compare different versions of a metamodel and to produce executable model transformations. <p/>
-			We use two different versions of a 
-			Scade metamodel (from the <a href="http://www.eclipse.org/gmt/am3/zoos/atlanticZoo/#SCADE">Atlantic zoo</a>). 
-			Scade is a standard for development of embedded software for the Avionics Industry. 
-		</description>
-		<pubDate>Thu, 18 Jan 2007 10:50:00 CET</pubDate>
-	</item>
-
-   <item>
-		<title>AMW use cases available</title>
-      	<link>http://www.eclipse.org/gmt/amw/usecases/</link>
-		<description>
-			A new page with a set of use cases of AMW was created. 
-			It contains simple and documented use cases of weaving models and AMW.
-		</description>
-		<pubDate>Fri, 08 Dec 2006 18:00:00 CET</pubDate>
-	</item>
-
-
-   <item>
-		<title>New release of AMW</title>
-      	<link>http://www.eclipse.org/gmt/amw/download/</link>
-		<description>
-			There is a new release of AMW plugin. This release is compatible with the latest releases of ATL and AM3.
-		</description>
-		<pubDate>Fri, 08 Dec 2006 18:00:00 CET</pubDate>
-	</item>
-
-   <item>
-		<title>Improvements on the integration of AMW and matching transformations</title>
-      	<link>http://dev.eclipse.org/viewcvs/indextech.cgi/org.eclipse.gmt/AMW</link>
-		<description>
-			The integration of the AMW plugin with the execution of matching transformations was improved. 
-			The plugin uses the new <a href="http://wiki.eclipse.org/index.php/ATL_2006">ATL 2006 compiler</a> . 
-			<p/>
-			There is a new project "org.eclipse.weaver.transformation". 
-			This project is an extension to the weaving core. It contains a set of matching and higher-order transformations 
-			that can be called directly from the Weaving panel.
-			<p/>
-			For the moment these transformations are available in the context menu of the weaving panel (right click). 
-			They are executed one-by-one. We plan to gradually add new transformations and also to combine them, 
-			as well as to provide documentation.								
-		</description>
-		<pubDate>Wed, 29 Nov 2006 18:00:00 CET</pubDate>
-	</item>
-
-
-   <item>
-		<title>AMW newsgroup migration</title>
-      	<link>http://www.eclipse.org/gmt/</link>
-		<description>
-			As part of the changes related to the new Eclipse Modeling project, the AMW newsgroup has moved.
-			Please use the new AMW newsgroup: eclipse.modeling.gmt.amw<br />
-			The old one "eclipse.technology.gmt.amw" will be archived.
-		</description>
-		<pubDate>Fri, 20 Oct 2006 16:00:00 CET</pubDate>
-	</item>
-
-	<item>
-		<title>Creation of a library of matching transformations</title>
-		<link>http://www.eclipse.org/gmt/amw/examples/</link>
-		<description>	
-			Creation of a new category of examples with a set of matching transformations. 
-			The matching transformations are used to automatically create weaving models.
-		</description>
-		<pubDate>Wed, 18 Oct 2006 17:00:00 CET</pubDate>
-	</item>
-
-	<item>
-		<title>Creation of the AMW FAQ</title>
-		<link>http://wiki.eclipse.org/index.php/AMW_FAQ</link>
-		<description>
-			Creation of a Wiki FAQ with questions about AMW.
-			It will improve gradually. Everybody is welcome to contribute.
-		</description>
-		<pubDate>Tue, 10 Oct 2006 16:00:00 CET</pubDate>
-	</item>
-
-	<item>
-		<title>New example - System Architecture (SA) Management</title>
-		<link>http://www.eclipse.org/gmt/amw/examples/</link>
-		<description>	
-				This is a complex scenario of management of "systems of systems". 
-				It uses many features of AMMA (ATLAS Model Management Architecture) to interoperate between
-				different views of the same system. 
-				It uses different types of matching transformations to produce weaving models that capture the 
-				overlapping concepts of the different views. 				
-		</description>
-		<pubDate>Wed, 27 September 2006 11:40:00 CET</pubDate>
-	</item>
-
-	<item>
-		<title>Creation of the AMW Wiki</title>
-		<link>http://wiki.eclipse.org/index.php/AMW</link>
-		<description>	
-			The AMW Wiki was created. It contains general information about the AMW project, metamodel extensions, 
-			information about the examples, wish list, etc.
-		</description>
-		<pubDate>Tue, 22 August 2006 15:30:00 CET</pubDate>
-	</item>
-
-	<item>
-		<title>New example: using ATL to semi-automatically create weaving models</title>
-		<link>http://www.eclipse.org/gmt/amw/examples/</link>
-		<description>	
-			This example contains a set of matching transformations (implemented in ATL) that produce a weaving
-			model. The ATL transformations are executed sequentially using AM3 Ant tasks.<br/>
-			The example is an adapted implementation of the Similarity Flooding algorithm 
-			<font size="-1">(the reference to it is available on the example description)</font>. 
-		</description>
-		<pubDate>Mon, 24 July 2006 17:30:00 CET</pubDate>
-	</item>
-
-	<item>
-		<title>New relase / commit with several improvements</title>
-		<link>http://www.eclipse.org/gmt/amw/download/</link>
-		<description>New release/commit with many changes in the Model Weaver. <p/>			
-			Most part of changes are related to the metadata file
-			 (that is not hidden from the users anymore), and the 
-			 possibility to directly load .ecore weaving metamodels.
-			<p/>
-			The new release is available for download at the 
-			<a href="../download/">
-						download page.</a>
-			More information
-			<a href="../download/20060717/">
-						here.</a>
-				
-		</description>
-		<pubDate>Thu, 17 July 2006 11:00:00 CET</pubDate>
-	</item>
-
-
-	<item>
-		<title>Weaving Mantis and Bugzilla bug trackers</title>
-		<link>http://www.eclipse.org/gmt/amw/examples/</link>
-		<description>
-				This example contains an extension to the core weaving metamodel to support interoperability between different tools.
-				A weaving model conforming to this extension captures links between the metamodels of two bug tracking tools 
-				(<a href="http://www.mantisbt.org/">Mantis</a>
-				and <a href="http://www.bugzilla.org/">Bugzilla</a>). The metamodels are extracted from the <a href ="http://www.eclipse.org/gmt/am3/zoos/">Atlantic Zoo</a>.
-		</description>
-		<pubDate>Mon, 26 June 2006 15:30:00 CET</pubDate>
-	</item>
-
-
-
-	<item>
-		<title>New example: translating KM3 into SQL using AMW and ATL</title>
-		<link>http://www.eclipse.org/gmt/amw/examples/</link>
-		<description>
-				This example contains a weaving model between a KM3 metamodel and a SQL DDL metamodel.
-				The weaving model is used to produce an ATL transformation that translates KM3 models
-				into SQL DDL models. It is similar to the example "Translating SQL into KM3", but the bridge
-				is executed in the opposite direction. 							
-		</description>
-		<pubDate>Mon, 26 June 2006 15:30:00 CET</pubDate>
-	</item>
-
-
-	<item>
-		<title>New example: translating SQL into KM3 using AMW and ATL</title>
-		<link>http://www.eclipse.org/gmt/amw/examples/</link>
-		<description>
-				This example uses a weaving model between a SQL DDL metamodel and a KM3 metamodel.
-				The weaving model is used to produce an ATL transformation that translates SQL DDL models
-				into KM3 models. We used an SQL extracted from <a href="http://www.mantisbt.org/">Mantis</a> bug tracker.
-		</description>
-		<pubDate>Mon, 20 June 2006 11:30:00 CET</pubDate>
-	</item>
-
-	<item>
-		<title>New example: production of ATL and XSLT from the same weaving model</title>
-		<link>http://www.eclipse.org/gmt/amw/examples/</link>
-		<description>
-				This example generates XSLT and ATL transformations from the same weaving model.
-				It contains two ATL HOTs (higher-order transformations). 
-		</description>
-		<pubDate>Mon, 19 June 2006 16:00:00 CET</pubDate>
-	</item>
-
-	<item>
-		<title>The AMW Zoo is available</title>
-		<link>http://www.eclipse.org/gmt/amw/zoo/</link>
-		<description>
-				The AMW Zoo is a zoo containing weaving metamodels and extensions of weaving metamodels expressed in KM3. 
-		</description>
-		<pubDate>Fri, 19 May 2006 15:00:00 CET</pubDate>
-	</item>
-
-	<item>
-		<title>New ATL-AMW traceability example</title>
-		<link>http://www.eclipse.org/gmt/amw/examples/</link>
-		<description>
-				This example generates an ATL execution trace in a weaving model. 
-				An ATL transformation produces a traceability weaving model. 
-		</description>
-		<pubDate>Fri, 19 May 2006 13:00:00 CET</pubDate>
-	</item>
-    
-	<item>
-		<title>New HOT that transforms an AMW model into an ATL model</title>
-		<link>http://www.eclipse.org/gmt/amw/examples/</link>
-		<description>
-			This example is an complement that uses the metamodel extension between 
-			foreign keys and nested structures. <br/>
-			It provides a HOT (higher-order transformation) that transforms a weaving model into
-			an ATL model. 
-		</description>
-		<pubDate>Fri, 28 Apr 2006 17:00:00 CET</pubDate>
-	</item>
-
-	<item>
-		<title>New AMW merge example</title>
-		<link>http://www.eclipse.org/gmt/amw/examples/</link>
-		<description>
-			There is a new example of an extension to the weaving core metamodel.<br />
-			This extension enables to create a merge weaving model a subset of GML metamodel 
-			and an election metamodel into a SVG metamodel.			
-		</description>
-		<pubDate>Fri, 14 Apr 2006 16:00:00 CET</pubDate>
-	</item>
-
-
-	<item>
-		<title>New AMW example</title>
-		<link>http://www.eclipse.org/gmt/amw/examples/</link>
-		<description>
-			There is a new example of an extension to the weaving core metamodel.<br />
-			This extension enables to create weavings between a metamodel with foreign key structure
-			and a metamodel with nested structures.			
-		</description>
-		<pubDate>Fri, 14 Apr 2006 11:00:00 CET</pubDate>
-	</item>
-
-
-	<item>
-		<title>New logo for AMW (Thank you Xavier and Romain)</title>
-		<link>http://www.eclipse.org/gmt/amw/</link>
-		<description>
-			AMW has now a new logo, more sexy.<br />
-			
-			ATLAS team wants to thank Xavier Mehaut and Romain Larcher for their pretty work.
-		</description>
-		<pubDate>Mon, 06 Mar 2006 11:00:00 CET</pubDate>
-	</item>
-
-	<item>
-		<title>New release available</title>
-		<link>http://www.eclipse.org/gmt/amw/download/</link>
-		<description>
-			A new release of AMW is available. It is compatible with the latest release of ATL.
-		</description>
-		<pubDate>Thu, 26 Jan 2006 18:00:00 CET</pubDate>
-	</item>
-
-	<item>
-		<title>Creation of AMW newsgroup</title>
-		<link>news://news.eclipse.org/eclipse.tools.gmt.amw</link>
-		<description>
-			A newsgroup for discussing &lt;a href="news://news.eclipse.org/eclipse.tools.gmt.amw"&gt;AMW&lt;/a&gt; technical issues, bugs,
-			suggestions, use cases is now available.
-		</description>
-		<pubDate>14 Jun 2005</pubDate>
-	</item>
-	<item>
-		<title>AMW binaries are available</title>
-		<link>http://www.eclipse.org/gmt/amw/download/</link>
-		<description>
-			The AMW binaries are now available in the &lt;a href="http://www.eclipse.org/gmt/amw/download/"&gt;download section&lt;/a&gt;.
-			The sources are available under CVS.
-		</description>
-		<pubDate>10 Jun 2005</pubDate>
-	</item>
-	<item>
-		<title>Start of AMW subproject</title>
-		<link>http://www.eclipse.org/gmt/amw/</link>
-		<description>
-			Creation of &lt;a href="http://www.eclipse.org/gmt/amw/"&gt;AMW&lt;/a&gt; subproject. AMW will be available for download soon.
-		</description>
-		<pubDate>07 Jun 2005</pubDate>
-	</item>
   </channel>
 </rss>
\ No newline at end of file
