diff --git a/usecases/modelgen/index.php b/usecases/modelgen/index.php
new file mode 100644
index 0000000..1c50e95
--- /dev/null
+++ b/usecases/modelgen/index.php
@@ -0,0 +1,214 @@
+<?php  																														require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/nav.class.php"); 	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/menu.class.php"); 	$App 	= new App();	$Nav	= new Nav();	$Menu 	= new Menu();		include($App->getProjectCommon());    # All on the same line to unclutter the user's desktop'
+
+	#*****************************************************************************
+	#
+	# template.php
+	#
+	# Author: 		Freddy Allilaire
+	# Date:			2005-12-07
+	#
+	# Description: Type your page comments here - these are not sent to the browser
+	#
+	#
+	#****************************************************************************
+	
+	#
+	# Begin: page-specific settings.  Change these. 
+	$pageTitle 		= "AMW Use Case - Bridge between SQL-DDL and KM3";
+	$pageKeywords	= "ModelGen, SQL, KM3, model weaving, transformations";
+	$pageAuthor		= "Marcos Didonet Del Fabro";
+	
+	# End: page-specific settings
+	#
+		
+	# Paste your HTML content between the EOHTML markers!	
+	$html = <<<EOHTML
+
+	<!-- Main part -->
+	<div id="midcolumn">
+		<h1><font color='#280882'>AMW</font> Use Case - Bridge between SQL-DDL and KM3</h1>
+
+		<a name="goals"></a>
+		<img align="right" src="../../resources/amwLogoSmall.png" valign="top" style="padding-left: 10px;" alt="AMW Logo" />
+		<blockquote>
+			<ul>
+				<li><a href="#overview"><b>Overview</b></a></li>
+				<li><a href="#download"><b>Download and examples</b></a></li>
+				<li><a href="#related"><b>Related use cases</b></a></li>
+			</ul>
+		</blockquote>
+    		    	
+		<hr class="clearer" />
+
+		<div id="container>
+		<table>
+			<COLGROUP>
+				<COL width="2%">
+				<COL width="98%">
+		<tr>
+			<td>
+			</td>
+			
+			This use case shows how weaving models and model transformations are used to translate SQL-DDL (Data Definition Language) into KM3 (a 
+			modeling technical space) and to translate KM3 into SQL.
+			In model management platforms, this use case is considered an application of <a href="#modelgen">ModelGen</a> operations.
+			
+			<p/>
+			
+		<h4 STYLE="font-size: 10pt; padding: 0; border-bottom: 2px solid #49457C; background-position: top left; background-repeat; repeat-x;">
+		
+		<a name="overview">Overview</a></h4>
+		
+		<p align="justify">
+		    The development of bridges between different technical spaces is a complex process divided in several phases. This use case illustrates
+		    a bridge between an SQL-DDL file into a KM3 file. The SQL-DDL file conforms to a SQL grammar, for example with standard CREATE 
+		    TABLE statements. KM3 is a standard language for defining  metamodels for the modeling world. 
+		    <p/>		    		    
+		    The first step of the briding process is to inject the SQL-DDL file into the EMF technical space (Ecore is the metametamodel). 
+		    The injection creates an SQL-DDL model that conforms to an SQL-DDL metamodel (see Figure 1.a). This metamodel is created manually by a developer. 
+		    <p/>
+		    Then a weaving model (<i>Mw</i>) is created between the SQL-DDL and KM3 metamodels. <i>Mw</i> conforms to <i>MMw</i>, which is an extension to the 
+		    <a href="http://www.eclipse.org/gmt/amw/zoo/#AMW%20core">core weaving metamodel</a>. This extension contains different kinds of links that
+		    define the equivalences between the elements of SQL-DDL and the elements of KM3. However, these two metamodels have different expressivenes. This means 
+		    it is not always possible  to link all the elements of SQL and KM3. For instance, a KM3 <i>Class</i> does not have a "default value" 
+		    property; a SQL-DDL <i>Table</i> does not have references. 
+			<p/>
+			
+		  	<p align="center">
+		  		 <img src="../resources/modelgen_overview.png"/>
+	  			<br /><br />
+				<b>1. Injection and weaving</b>
+			</p>					
+			
+			The weaving model is used as specification to produce model transformations (in ATL). We implement a 
+			higher-order transformation (HOT) based on a generic transformation pattern. This HOT takes the weaving model as input 
+			and produces a transformation model as output (Figure 2.a). This output transformation is used to transform a SQL-DDL model into a 
+			KM3 model (Figure 2.b).
+			
+			<p align="center">
+		  		<img src="../resources/modelgen_hot.png"/>
+	  			<br /><br />
+				<b>2. Transforming KM3 model into KM3 file</b>
+			</p>	
+			
+			The last step of the bridging process is the extraction of the KM3 model (with KM3 concepts such as Class, Attribute, Reference) into the 
+			textual concrete syntax of KM3 (see Figure 3).
+			
+			<p align="center">
+		  		<img src="../resources/modelgen_extract.png"/>
+	  			<br /><br />
+				<b>3. Extraction of KM3 model into KM3 file</b>
+			</p>				
+			
+	    </p>
+		
+		
+		
+		<h4 STYLE="font-size: 10pt; padding: 0; border-bottom: 2px solid #49457C; 
+							background-position: top left; background-repeat; repeat-x;">
+		<a name="download">Download and examples</a></h4>
+
+		<table>
+			<COLGROUP>
+				<COL width="25%">
+				<COL width="75%">
+		<tr>
+
+		<td align="center">
+			<a href="../../examples/AMW_SQL2KM3/AMW_SQL2KM3.zip"><h3>SQL-DDL to KM3</h3></a>
+		</td>
+		<td>
+			This example implements a complete chain of operations that enables to bridge between SQL-DDL and KM3 (injection, weavings, 
+			transformations and extraction). It uses an SQL file extracted from the <a href="http://www.mantisbt.org/">Mantis bug tracker</a> tool.
+			<p/>
+		</td>				
+		</tr>
+		<td align="center">
+			<a href="../../examples/AMW_SQL2KM3/AMW_SQL2KM3_doc.php"><h3>SQL-DDL to KM3 HowTo</h3></a>
+		</td>
+		<td>
+			This document contains step-by-step instructions explaining how to execute the SQL-DDL to KM3 example.
+			<p/>
+		</td>		
+		</tr>
+			
+		<tr>
+
+		<td align="center">
+			<a href="../../examples/AMW_KM32SQL/AMW_KM32SQL.zip"><h3>KM3 to SQL-DDL</h3></a>
+		</td>
+		<td>
+			This example implements a bridge between KM3 and SQL-DDL, i.e., it is the opposite scenario of the example above. 
+			It also provides the complete chain of operations. 
+			<p/>
+		</td>				
+		</tr>
+		<td align="center">
+			<a href="../../examples/AMW_KM32SQL/AMW_KM32SQL_doc.php"><h3>KM3 to SQL HowTo</h3></a>
+		</td>
+		<td>
+			This document contains step-by-step instructions explaining how to execute the KM3 to SQL-DDL example.
+			<p/>
+		</td>		
+		</tr>			
+			
+		</table>
+		
+		<h4 STYLE="font-size: 10pt; padding: 0; border-bottom: 2px solid #49457C; 
+							background-position: top left; background-repeat; repeat-x;">
+		
+		<a name="related">Related use cases</a></h4>
+		
+		<table>
+			<COLGROUP>
+				<COL width="25%">
+				<COL width="68%">
+		<tr>
+				
+		<td align="center">
+			<a href="../matching/"><h3>Matching</h3></a>
+		</td>
+		<td>
+			Matching is the generic process that creates weaving models.
+			This use case gives a general overview of the matching process, and how it is handled by AMW and ATL.			
+		</td>		
+		</tr>		
+	    <tr>
+		<td align="center">
+			<a href="../interoperability/"><h3>Tool interoperability</h3></a>
+		</td>
+		<td>
+			This use case shows how weaving models are used to capture the semantic heterogeneities between different tools' 
+			metamodels. We use two well known bug tracking tools, Mantis and Bugzilla.
+		</td>		
+		</tr>
+		
+		<tr>		
+		<td align="center">
+			<a href="../compare/"><h3>Metamodel comparison</h3></a>
+		</td>
+		<td>
+			This use case demonstrates how weaving models are used to compare different
+			metamodels and to produce executable model transformations (we use two metamodels used to define embedded 
+			softwer in the avionics industry).
+		</td>		
+		</tr>		
+		
+
+		
+		</table>		
+		
+		
+		<p/>
+		<b><a name="modelgen">Reference</a>:</b><br/>
+		Atzeni, P, Cappellari, P, Bernstein, P A. ModelGen: Model-Independent Schema and Data Translation. EDBT 2006, pp. 368-385			
+		</div>
+	</div><p/>
+
+	
+EOHTML;
+
+
+	# Generate the web page
+	$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
+?>
\ No newline at end of file
