diff --git a/downloads.php b/downloads.php
index dfcd807..bceaba8 100644
--- a/downloads.php
+++ b/downloads.php
@@ -1,88 +1,102 @@
-<?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'
-	$pageTitle 		= "SMILA - Downloads";
-	$pageKeywords	= "SMILA, Unified Information Access Architecture, unstructured information management, information logistics, semantic web, framework, platform, eclipse, big data, bigdata";
-	$pageAuthor		= "Andreas Weber";
-
-	# Paste your HTML content between the EOHTML markers!
-	$html = <<<EOHTML
-
-	<div id="midcolumn">
-		<h1>Downloads</h1>
-		
-		<h2>Releases</h2>
-		<h3>1.2</h3>
-		<p>
-			The release <b>1.2</b> is the latest stable version of SMILA.
-			<ul>
-				<li>Linux 32 Bit: <a href="http://www.eclipse.org/downloads/download.php?file=/rt/smila/releases/1.2/SMILA-1.2-linux.gtk.x86.zip">SMILA-1.2-linux.gtk.x86.zip</a></li>
-				<li>Linux 64 Bit: <a href="http://www.eclipse.org/downloads/download.php?file=/rt/smila/releases/1.2/SMILA-1.2-linux.gtk.x86_64.zip">SMILA-1.2-linux.gtk.x86_64.zip</a></li>
-				<li>Mac OS X 64 Bit: <a href="http://www.eclipse.org/downloads/download.php?file=/rt/smila/releases/1.2/SMILA-1.2-macosx.cocoa.x86_64.zip">SMILA-1.2-macosx.cocoa.x86_64.zip</a></li>
-				<li>Windows 32 Bit: <a href="http://www.eclipse.org/downloads/download.php?file=/rt/smila/releases/1.2/SMILA-1.2-win32.win32.x86.zip">SMILA-1.2-win32.win32.x86.zip</a></li>
-				<li>Windows 64 Bit: <a href="http://www.eclipse.org/downloads/download.php?file=/rt/smila/releases/1.2/SMILA-1.2-win32.win32.x86_64.zip">SMILA-1.2-win32.win32.x86_64.zip</a></li>
-				<li>SDK example code: <a href="http://www.eclipse.org/downloads/download.php?file=/rt/smila/releases/1.2/SMILA-1.2-integrator-examples.zip">SMILA-1.2-integrator-examples.zip</a></li>
-				<li>SMILA source code: <a href="http://www.eclipse.org/downloads/download.php?file=/rt/smila/releases/1.2/SMILA-1.2-core-source.zip">SMILA-1.2-core-source.zip</a></li>
-			</ul>
-		</p>		
-		
-		<h2>Archived releases and milestones</h2>
-		<p>
-			You can find older SMILA releases and milestones in our 
-			<a href="downloads_archive.php">download archive</a>.
-		</p>
-		<h2>Nightly builds</h2>
-		<p>
-			The nightly builds are provided for now only for Linux and Windows. Please note that these builds
-			have not been tested and that they actually reflect the status of the current development branch.
-			<ul>
-				<li><a href="http://build.eclipse.org/rt/smila/nightly/">SMILA nightly builds</a></li>
-			</ul>
-		</p>
-		<h2>SMILA extensions for BPEL designer</h2>
-		<p>
-			Starting from release 0.8 we offer BPEL designer extensions for management of SMILA's workflows. 
-			Detailed instructions on how to obtain the BPEL designer and install deploy our extensions int can be found 
-			<a href="http://wiki.eclipse.org/SMILA/BPEL_Designer">here</a>.
-		</p>
-		<h2>Resources</h2>
-		<p>
-			If you would like to incorporate SMILA logo (e.g. "powered by SMILA") into your application or your website, here 
-			are some graphics you can freely use:
-			<table border="1" frame="border" >
-				<tr>
-					<td><img src="logo/SMILA_Icon.jpg" alt="SMILA icon" align="left" width="124" height="124"></td>
-				</tr>
-				<tr>
-					<td><img src="logo/SMILA.gross.png" alt="SMILA with name - large" align="left" width="434" height="96"></td>
-				</tr>
-				<tr>
-					<td><img src="logo/SMILA.Icon.tagline.jpg" alt="SMILA with tagline" align="left" width="124" height="163"></td>
-				</tr>
-				<tr>
-					<td><img src="logo/SMILA_Tagline_Large.jpg" alt="SMILA with tagline - large" align="left" width="420" height="119"></td>
-				</tr>
-				<tr>
-					<td><img src="logo/SMILA.powered.gross.jpg" alt="powered by SMILA - large" align="left" width="320" height="103"></td>
-				</tr>
-				<tr>
-					<td><img src="logo/SMILA_powered_klein.jpg" alt="powered by SMILA" align="left" width="125" height="191"></td>
-				</tr>
-			</table>
-		</p>
-		<h2>SMILA Distributions</h2>
-		<p>
-			Free and Commercial Distributions of SMILA:
-			<ul>
-				<li>eccenca: <a href="http://www.eccenca.com">Find out more about the different editions of eccenca</a></li>
-				<li>eccenca Marketplace: <a href="http://market.eccenca.com">Components to extend the capabilities of your SMILA and eccenca installation</a></li>
-			</ul>
-		</p>
-	</div>
-
-EOHTML;
-
-	include('rightColumn.php');
-	$html .= $rightColumn;
-
-	# Generate the web page
-	$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
-?>
+<?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'
+	$pageTitle 		= "SMILA - Downloads";
+	$pageKeywords	= "SMILA, Unified Information Access Architecture, unstructured information management, information logistics, semantic web, framework, platform, eclipse, big data, bigdata";
+	$pageAuthor		= "Andreas Weber";
+
+	# Paste your HTML content between the EOHTML markers!
+	$html = <<<EOHTML
+
+	<div id="midcolumn">
+		<h1>Downloads</h1>
+		
+		<h2>Releases</h2>
+		
+		<h3>1.3-M1</h3>
+		<p>			
+			<ul>
+				<li>Linux 32 Bit: <a href="http://www.eclipse.org/downloads/download.php?file=/rt/smila/milestones/1.3-M1/SMILA-1.3-M1-linux.gtk.x86.zip">SMILA-1.3-M1-linux.gtk.x86.zip</a></li>
+				<li>Linux 64 Bit: <a href="http://www.eclipse.org/downloads/download.php?file=/rt/smila/milestones/1.3-M1/SMILA-1.3-M1-linux.gtk.x86_64.zip">SMILA-1.3-M1-linux.gtk.x86_64.zip</a></li>
+				<li>Mac OS X 64 Bit: <a href="http://www.eclipse.org/downloads/download.php?file=/rt/smila/milestones/1.3-M1/SMILA-1.3-M1-macosx.cocoa.x86_64.zip">SMILA-1.3-M1-macosx.cocoa.x86_64.zip</a></li>
+				<li>Windows 32 Bit: <a href="http://www.eclipse.org/downloads/download.php?file=/rt/smila/milestones/1.3-M1/SMILA-1.3-M1-win32.win32.x86.zip">SMILA-1.3-M1-win32.win32.x86.zip</a></li>
+				<li>Windows 64 Bit: <a href="http://www.eclipse.org/downloads/download.php?file=/rt/smila/milestones/1.3-M1/SMILA-1.3-M1-win32.win32.x86_64.zip">SMILA-1.3-M1-win32.win32.x86_64.zip</a></li>
+				<li>SDK example code: <a href="http://www.eclipse.org/downloads/download.php?file=/rt/smila/milestones/1.3-M1/SMILA-1.3-M1-integrator-examples.zip">SMILA-1.3-M1-integrator-examples.zip</a></li>
+				<li>SMILA source code: <a href="http://www.eclipse.org/downloads/download.php?file=/rt/smila/milestones/1.3-M1/SMILA-1.3-M1-core-source.zip">SMILA-1.3-M1-core-source.zip</a></li>
+			</ul>
+		</p>
+		
+		<h3>1.2</h3>
+		<p>
+			The release <b>1.2</b> is the latest stable version of SMILA.
+			<ul>
+				<li>Linux 32 Bit: <a href="http://www.eclipse.org/downloads/download.php?file=/rt/smila/releases/1.2/SMILA-1.2-linux.gtk.x86.zip">SMILA-1.2-linux.gtk.x86.zip</a></li>
+				<li>Linux 64 Bit: <a href="http://www.eclipse.org/downloads/download.php?file=/rt/smila/releases/1.2/SMILA-1.2-linux.gtk.x86_64.zip">SMILA-1.2-linux.gtk.x86_64.zip</a></li>
+				<li>Mac OS X 64 Bit: <a href="http://www.eclipse.org/downloads/download.php?file=/rt/smila/releases/1.2/SMILA-1.2-macosx.cocoa.x86_64.zip">SMILA-1.2-macosx.cocoa.x86_64.zip</a></li>
+				<li>Windows 32 Bit: <a href="http://www.eclipse.org/downloads/download.php?file=/rt/smila/releases/1.2/SMILA-1.2-win32.win32.x86.zip">SMILA-1.2-win32.win32.x86.zip</a></li>
+				<li>Windows 64 Bit: <a href="http://www.eclipse.org/downloads/download.php?file=/rt/smila/releases/1.2/SMILA-1.2-win32.win32.x86_64.zip">SMILA-1.2-win32.win32.x86_64.zip</a></li>
+				<li>SDK example code: <a href="http://www.eclipse.org/downloads/download.php?file=/rt/smila/releases/1.2/SMILA-1.2-integrator-examples.zip">SMILA-1.2-integrator-examples.zip</a></li>
+				<li>SMILA source code: <a href="http://www.eclipse.org/downloads/download.php?file=/rt/smila/releases/1.2/SMILA-1.2-core-source.zip">SMILA-1.2-core-source.zip</a></li>
+			</ul>
+		</p>		
+		
+		<h2>Archived releases and milestones</h2>
+		<p>
+			You can find older SMILA releases and milestones in our 
+			<a href="downloads_archive.php">download archive</a>.
+		</p>
+		<h2>Nightly builds</h2>
+		<p>
+			The nightly builds are provided for now only for Linux and Windows. Please note that these builds
+			have not been tested and that they actually reflect the status of the current development branch.
+			<ul>
+				<li><a href="http://build.eclipse.org/rt/smila/nightly/">SMILA nightly builds</a></li>
+			</ul>
+		</p>
+		<h2>SMILA extensions for BPEL designer</h2>
+		<p>
+			Starting from release 0.8 we offer BPEL designer extensions for management of SMILA's workflows. 
+			Detailed instructions on how to obtain the BPEL designer and install deploy our extensions int can be found 
+			<a href="http://wiki.eclipse.org/SMILA/BPEL_Designer">here</a>.
+		</p>
+		<h2>Resources</h2>
+		<p>
+			If you would like to incorporate SMILA logo (e.g. "powered by SMILA") into your application or your website, here 
+			are some graphics you can freely use:
+			<table border="1" frame="border" >
+				<tr>
+					<td><img src="logo/SMILA_Icon.jpg" alt="SMILA icon" align="left" width="124" height="124"></td>
+				</tr>
+				<tr>
+					<td><img src="logo/SMILA.gross.png" alt="SMILA with name - large" align="left" width="434" height="96"></td>
+				</tr>
+				<tr>
+					<td><img src="logo/SMILA.Icon.tagline.jpg" alt="SMILA with tagline" align="left" width="124" height="163"></td>
+				</tr>
+				<tr>
+					<td><img src="logo/SMILA_Tagline_Large.jpg" alt="SMILA with tagline - large" align="left" width="420" height="119"></td>
+				</tr>
+				<tr>
+					<td><img src="logo/SMILA.powered.gross.jpg" alt="powered by SMILA - large" align="left" width="320" height="103"></td>
+				</tr>
+				<tr>
+					<td><img src="logo/SMILA_powered_klein.jpg" alt="powered by SMILA" align="left" width="125" height="191"></td>
+				</tr>
+			</table>
+		</p>
+		<h2>SMILA Distributions</h2>
+		<p>
+			Free and Commercial Distributions of SMILA:
+			<ul>
+				<li>eccenca: <a href="http://www.eccenca.com">Find out more about the different editions of eccenca</a></li>
+				<li>eccenca Marketplace: <a href="http://market.eccenca.com">Components to extend the capabilities of your SMILA and eccenca installation</a></li>
+			</ul>
+		</p>
+	</div>
+
+EOHTML;
+
+	include('rightColumn.php');
+	$html .= $rightColumn;
+
+	# Generate the web page
+	$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
+?>
diff --git a/index.php b/index.php
index 8bc62f1..701f032 100755
--- a/index.php
+++ b/index.php
@@ -41,7 +41,15 @@
 		<div class="homeitem3col">
 			<h3>News</h3>
 			
-			<h4>2013-07-04 - Announcement for SMILA presentation in Berlin</h4>
+			<h4>2014-12-01 - 1.3-M1 available</h4>
+			<p>
+				Today we published the milestone M1 of the upcoming <a href="plan.php">release 1.3</a>. 
+				The milestone contains the new <a href="http://wiki.eclipse.org/SMILA/Documentation/Scripting">scripting engine</a> based on JavaScript, which can be used for all kinds of synchronous processing.  
+				It can also be seen as a (recommended) alternative for BPEL, while being faster, more flexible and easier to use. 
+				The milestone M1 doesn't contain the Solr 4 integration yet, this will be finished in the next weeks. 
+				As always, please try it out and give us your feedback.
+			</p>
+			<h4>July 2013 - Announcement for SMILA presentation in Berlin</h4>
 			<p>
 			    On 20th of August there will be a SMILA presentation at the Fraunhofer Heinrich-Hertz-Institut in Berlin: 
 			    <a href="http://www.ebusiness-lotse-berlin.de/termine/termin/d/2013/08/20/a/informationsgewinnung-mit-semantischen-technologien-die-anwendung-smila/">Informationsgewinnung mit semantischen Technologien - die Anwendung SMILA</a>. 
