diff --git a/documentation.php b/documentation.php
index 8e041f1..1ab3779 100644
--- a/documentation.php
+++ b/documentation.php
@@ -21,6 +21,7 @@
 			SMILA's archived documentation is provided as read-only  
 			wiki export:
 			<ul>
+			    <li><a href="documentation/1.3/wiki.eclipse.org/SMILA.html" target="_blank">1.3</a> (<a href="documentation/wiki.eclipse.org_1.3_15.4.2015.zip">download</a>)</li>
 			    <li><a href="documentation/1.2/wiki.eclipse.org/SMILA.html" target="_blank">1.2</a> (<a href="documentation/wiki.eclipse.org_1.2_17.4.2013.zip">download</a>)</li>
 			    <li><a href="documentation/1.1/wiki.eclipse.org/SMILA.html" target="_blank">1.1</a> (<a href="documentation/wiki.eclipse.org_1.1_11.7.2012.zip">download</a>)</li>
 				<li><a href="documentation/1.0/wiki.eclipse.org/SMILA.html" target="_blank">1.0</a> (<a href="documentation/wiki.eclipse.org_1.0_2.2.2012.zip">download</a>)</li>				
@@ -33,6 +34,7 @@
 		<p>
 			Archived JavaDocs are also available:
 			<ul>								
+			    <li><a href="http://archive.eclipse.org/rt/smila/javadoc/1.3/" target="_blank">1.3</a> (<a href="http://archive.eclipse.org/rt/smila/javadoc/SMILA-javadoc-1.3.zip">download</a>)</li>
 			    <li><a href="http://archive.eclipse.org/rt/smila/javadoc/1.2/" target="_blank">1.2</a> (<a href="http://archive.eclipse.org/rt/smila/javadoc/SMILA-javadoc-1.2.zip">download</a>)</li>
 		    	<li><a href="http://archive.eclipse.org/rt/smila/javadoc/1.1/" target="_blank">1.1</a> (<a href="http://archive.eclipse.org/rt/smila/javadoc/SMILA-javadoc-1.1.zip">download</a>)</li>
 				<li><a href="http://archive.eclipse.org/rt/smila/javadoc/1.0/" target="_blank">1.0</a> (<a href="http://archive.eclipse.org/rt/smila/javadoc/SMILA-javadoc-1.0.zip">download</a>)</li>				
diff --git a/downloads.php b/downloads.php
index bceaba8..da9a9d1 100644
--- a/downloads.php
+++ b/downloads.php
@@ -9,32 +9,19 @@
 	<div id="midcolumn">
 		<h1>Downloads</h1>
 		
-		<h2>Releases</h2>
+		<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>
+		<h3>1.3</h3>
 		<p>
-			The release <b>1.2</b> is the latest stable version of SMILA.
+			The release <b>1.3</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>
+				<li>Linux 32 Bit: <a href="http://www.eclipse.org/downloads/download.php?file=/rt/smila/releases/1.3/SMILA-1.3-linux.gtk.x86.zip">SMILA-1.3-linux.gtk.x86.zip</a></li>
+				<li>Linux 64 Bit: <a href="http://www.eclipse.org/downloads/download.php?file=/rt/smila/releases/1.3/SMILA-1.3-linux.gtk.x86_64.zip">SMILA-1.3-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.3/SMILA-1.3-macosx.cocoa.x86_64.zip">SMILA-1.3-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.3/SMILA-1.3-win32.win32.x86.zip">SMILA-1.3-win32.win32.x86.zip</a></li>
+				<li>Windows 64 Bit: <a href="http://www.eclipse.org/downloads/download.php?file=/rt/smila/releases/1.3/SMILA-1.3-win32.win32.x86_64.zip">SMILA-1.3-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.3/SMILA-1.3-integrator-examples.zip">SMILA-1.3-integrator-examples.zip</a></li>
+				<li>SMILA source code: <a href="http://www.eclipse.org/downloads/download.php?file=/rt/smila/releases/1.3/SMILA-1.3-core-source.zip">SMILA-1.3-core-source.zip</a></li>
 			</ul>
 		</p>		
 		
@@ -51,12 +38,14 @@
 				<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 
diff --git a/downloads_archive.php b/downloads_archive.php
index 5f5ec31..e79904d 100644
--- a/downloads_archive.php
+++ b/downloads_archive.php
@@ -1,101 +1,114 @@
-<?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 archive";
-	$pageKeywords	= "SMILA, Unified Information Access Architecture, unstructured information management, information logistics, semantic web, framework, platform, eclipse, big data, bigdata";
-	$pageAuthor		= "Igor Novakovic";
-
-	# Paste your HTML content between the EOHTML markers!
-	$html = <<<EOHTML
-
-	<div id="midcolumn">
-		<h1>Downloads archive</h1>
-		<h2>Releases</h2>
-		
-		<h3>1.1</h3>
-		<p>			
-			<ul>
-				<li>Linux 32 Bit: <a href="http://www.eclipse.org/downloads/download.php?file=/rt/smila/releases/1.1/SMILA-1.1-linux.gtk.x86.zip">SMILA-1.1-linux.gtk.x86.zip</a></li>
-				<li>Linux 64 Bit: <a href="http://www.eclipse.org/downloads/download.php?file=/rt/smila/releases/1.1/SMILA-1.1-linux.gtk.x86_64.zip">SMILA-1.1-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.1/SMILA-1.1-macosx.cocoa.x86_64.zip">SMILA-1.1-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.1/SMILA-1.1-win32.win32.x86.zip">SMILA-1.1-win32.win32.x86.zip</a></li>
-				<li>Windows 64 Bit: <a href="http://www.eclipse.org/downloads/download.php?file=/rt/smila/releases/1.1/SMILA-1.1-win32.win32.x86_64.zip">SMILA-1.1-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.1/SMILA-1.1-integrator-examples.zip">SMILA-1.1-integrator-examples.zip</a></li>
-				<li>SMILA source code: <a href="http://www.eclipse.org/downloads/download.php?file=/rt/smila/releases/1.1/SMILA-1.1-core-source.zip">SMILA-1.1-core-source.zip</a></li>
-			</ul>
-		</p>
-		
-		<h3>1.0</h3>
-		<p>			
-			<ul>
-				<li>Linux 32 Bit: <a href="http://www.eclipse.org/downloads/download.php?file=/rt/smila/releases/1.0/SMILA-1.0-linux.gtk.x86.zip">SMILA-1.0-linux.gtk.x86.zip</a></li>
-				<li>Linux 64 Bit: <a href="http://www.eclipse.org/downloads/download.php?file=/rt/smila/releases/1.0/SMILA-1.0-linux.gtk.x86_64.zip">SMILA-1.0-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.0/SMILA-1.0-macosx.cocoa.x86_64.zip">SMILA-1.0-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.0/SMILA-1.0-win32.win32.x86.zip">SMILA-1.0-win32.win32.x86.zip</a></li>
-				<li>Windows 64 Bit: <a href="http://www.eclipse.org/downloads/download.php?file=/rt/smila/releases/1.0/SMILA-1.0-win32.win32.x86_64.zip">SMILA-1.0-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.0/SMILA-1.0-integrator-examples.zip">SMILA-1.0-integrator-examples.zip</a></li>
-				<li>SMILA source code: <a href="http://www.eclipse.org/downloads/download.php?file=/rt/smila/releases/1.0/SMILA-1.0-core-source.zip">SMILA-1.0-core-source.zip</a></li>
-			</ul>
-		</p>
-				 
-		
-		<h3>0.9</h3>
-		<p>
-			<ul>
-				<li>Linux 32 Bit: <a href="http://archive.eclipse.org/rt/smila/releases/0.9/SMILA-incubation-0.9-linux.gtk.x86.zip">SMILA-incubation-0.9-linux.gtk.x86.zip</a></li>				                          				
-				<li>Linux 64 Bit: <a href="http://archive.eclipse.org/rt/smila/releases/0.9/SMILA-incubation-0.9-linux.gtk.x86_64.zip">SMILA-incubation-0.9-linux.gtk.x86_64.zip</a></li>
-				<li>Mac OS X 64 Bit (Cocoa): <a href="http://archive.eclipse.org/rt/smila/releases/0.9/SMILA-incubation-0.9-macosx.cocoa.x86_64.zip">SMILA-incubation-0.9-macosx.cocoa.x86_64.zip</a></li>
-				<li>Windows 32 Bit: <a href="http://archive.eclipse.org/rt/smila/releases/0.9/SMILA-incubation-0.9-win32.win32.x86.zip">SMILA-incubation-0.9-win32.win32.x86.zip</a></li>
-				<li>Windows 64 Bit: <a href="http://archive.eclipse.org/rt/smila/releases/0.9/SMILA-incubation-0.9-win32.win32.x86_64.zip">SMILA-incubation-0.9-win32.win32.x86_64.zip</a></li>
-				<li>SDK Examples (platform independent): <a href="http://archive.eclipse.org/rt/smila/releases/0.9/SMILA-0.9-integrator-examples.zip">SMILA-0.9-integrator-examples.zip</a></li>
-			</ul>
-		</p>
-
-		<h3>0.8</h3>
-		<p>
-			<ul>
-				<li>Linux 32 Bit: <a href="http://archive.eclipse.org/rt/smila/releases/0.8/SMILA-incubation-0.8-linux.gtk.x86.zip">SMILA-incubation-0.8-linux.gtk.x86.zip</a></li>
-				<li>Linux 64 Bit: <a href="http://archive.eclipse.org/rt/smila/releases/0.8/SMILA-incubation-0.8-linux.gtk.x86_64.zip">SMILA-incubation-0.8-linux.gtk.x86_64.zip</a></li>
-				<li>Mac OS X 64 Bit (Cocoa): <a href="http://archive.eclipse.org/rt/smila/releases/0.8/SMILA-incubation-0.8-macosx.cocoa.x86_64.zip">SMILA-incubation-0.8-macosx.cocoa.x86_64.zip</a></li>
-				<li>Windows 32 Bit: <a href="http://archive.eclipse.org/rt/smila/releases/0.8/SMILA-incubation-0.8-win32.win32.x86.zip">SMILA-incubation-0.8-win32.win32.x86.zip</a></li>
-				<li>Windows 64 Bit: <a href="http://archive.eclipse.org/rt/smila/releases/0.8/SMILA-incubation-0.8-win32.win32.x86_64.zip">SMILA-incubation-0.8-win32.win32.x86_64.zip</a></li>
-			</ul>
-		</p>
-
-		<h3>0.7</h3>
-		<p>
-			<ul>
-				<li>Linux binaries: <a href="http://archive.eclipse.org/rt/smila/releases/0.7/SMILA-incubation-0.7-linux.gtk.x86.zip">SMILA-incubation-0.7-linux.gtk.x86.zip</a></li>
-				<li>Win32 binaries: <a href="http://archive.eclipse.org/rt/smila/releases/0.7/SMILA-incubation-0.7-win32.win32.x86.zip">SMILA-incubation-0.7-win32.win32.x86.zip</a></li>
-			</ul>
-		</p>
-		<h2>Milestones</h2>
-		<h3>0.5 M3</h3>
-		<p>
-			<ul>
-				<li>Linux binaries: <a href="http://archive.eclipse.org/rt/smila/milestones/0.5-M3/SMILA-incubation-0.5-M3-linux.gtk.x86.zip">SMILA-incubation-0.5-M3-linux.gtk.x86.zip</a></li>
-				<li>Win32 binaries: <a href="http://archive.eclipse.org/rt/smila/milestones/0.5-M3/SMILA-incubation-0.5-M3-win32.win32.x86.zip">SMILA-incubation-0.5-M3-win32.win32.x86.zip</a></li>
-			</ul>
-		</p>
-		<h3>0.5 M2</h3>
-		<p>
-			<ul>
-				<li>Linux binaries: <a href="http://archive.eclipse.org/rt/smila/milestones/0.5-M2/SMILA-incubation-0.5-M2-linux.gtk.x86.zip">SMILA-incubation-0.5-M2-linux.gtk.x86.zip</a></li>
-				<li>Win32 binaries: <a href="http://archive.eclipse.org/rt/smila/milestones/0.5-M2/SMILA-incubation-0.5-M2-win32.win32.x86.zip">SMILA-incubation-0.5-M2-win32.win32.x86.zip</a></li>
-			</ul>
-		</p>
-		<h3>0.5 M1</h3>
-		<p>
-			<ul>
-				<li>Linux binaries: <a href="http://archive.eclipse.org/rt/smila/milestones/0.5-M1/SMILA-incubation-0.5-M1-linux.gtk.x86.zip">SMILA-incubation-0.5-M1-linux.gtk.x86.zip</a></li>
-				<li>Win32 binaries: <a href="http://archive.eclipse.org/rt/smila/milestones/0.5-M1/SMILA-incubation-0.5-M1-win32.win32.x86.zip">SMILA-incubation-0.5-M1-win32.win32.x86.zip</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 archive";
+	$pageKeywords	= "SMILA, Unified Information Access Architecture, unstructured information management, information logistics, semantic web, framework, platform, eclipse, big data, bigdata";
+	$pageAuthor		= "Igor Novakovic";
+
+	# Paste your HTML content between the EOHTML markers!
+	$html = <<<EOHTML
+
+	<div id="midcolumn">
+		<h1>Downloads archive</h1>
+		<h2>Releases</h2>
+		
+		<h3>1.2</h3>
+		<p>			
+			<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>
+		
+		<h3>1.1</h3>
+		<p>			
+			<ul>
+				<li>Linux 32 Bit: <a href="http://www.eclipse.org/downloads/download.php?file=/rt/smila/releases/1.1/SMILA-1.1-linux.gtk.x86.zip">SMILA-1.1-linux.gtk.x86.zip</a></li>
+				<li>Linux 64 Bit: <a href="http://www.eclipse.org/downloads/download.php?file=/rt/smila/releases/1.1/SMILA-1.1-linux.gtk.x86_64.zip">SMILA-1.1-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.1/SMILA-1.1-macosx.cocoa.x86_64.zip">SMILA-1.1-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.1/SMILA-1.1-win32.win32.x86.zip">SMILA-1.1-win32.win32.x86.zip</a></li>
+				<li>Windows 64 Bit: <a href="http://www.eclipse.org/downloads/download.php?file=/rt/smila/releases/1.1/SMILA-1.1-win32.win32.x86_64.zip">SMILA-1.1-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.1/SMILA-1.1-integrator-examples.zip">SMILA-1.1-integrator-examples.zip</a></li>
+				<li>SMILA source code: <a href="http://www.eclipse.org/downloads/download.php?file=/rt/smila/releases/1.1/SMILA-1.1-core-source.zip">SMILA-1.1-core-source.zip</a></li>
+			</ul>
+		</p>
+		
+		<h3>1.0</h3>
+		<p>			
+			<ul>
+				<li>Linux 32 Bit: <a href="http://www.eclipse.org/downloads/download.php?file=/rt/smila/releases/1.0/SMILA-1.0-linux.gtk.x86.zip">SMILA-1.0-linux.gtk.x86.zip</a></li>
+				<li>Linux 64 Bit: <a href="http://www.eclipse.org/downloads/download.php?file=/rt/smila/releases/1.0/SMILA-1.0-linux.gtk.x86_64.zip">SMILA-1.0-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.0/SMILA-1.0-macosx.cocoa.x86_64.zip">SMILA-1.0-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.0/SMILA-1.0-win32.win32.x86.zip">SMILA-1.0-win32.win32.x86.zip</a></li>
+				<li>Windows 64 Bit: <a href="http://www.eclipse.org/downloads/download.php?file=/rt/smila/releases/1.0/SMILA-1.0-win32.win32.x86_64.zip">SMILA-1.0-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.0/SMILA-1.0-integrator-examples.zip">SMILA-1.0-integrator-examples.zip</a></li>
+				<li>SMILA source code: <a href="http://www.eclipse.org/downloads/download.php?file=/rt/smila/releases/1.0/SMILA-1.0-core-source.zip">SMILA-1.0-core-source.zip</a></li>
+			</ul>
+		</p>
+				 
+		
+		<h3>0.9</h3>
+		<p>
+			<ul>
+				<li>Linux 32 Bit: <a href="http://archive.eclipse.org/rt/smila/releases/0.9/SMILA-incubation-0.9-linux.gtk.x86.zip">SMILA-incubation-0.9-linux.gtk.x86.zip</a></li>				                          				
+				<li>Linux 64 Bit: <a href="http://archive.eclipse.org/rt/smila/releases/0.9/SMILA-incubation-0.9-linux.gtk.x86_64.zip">SMILA-incubation-0.9-linux.gtk.x86_64.zip</a></li>
+				<li>Mac OS X 64 Bit (Cocoa): <a href="http://archive.eclipse.org/rt/smila/releases/0.9/SMILA-incubation-0.9-macosx.cocoa.x86_64.zip">SMILA-incubation-0.9-macosx.cocoa.x86_64.zip</a></li>
+				<li>Windows 32 Bit: <a href="http://archive.eclipse.org/rt/smila/releases/0.9/SMILA-incubation-0.9-win32.win32.x86.zip">SMILA-incubation-0.9-win32.win32.x86.zip</a></li>
+				<li>Windows 64 Bit: <a href="http://archive.eclipse.org/rt/smila/releases/0.9/SMILA-incubation-0.9-win32.win32.x86_64.zip">SMILA-incubation-0.9-win32.win32.x86_64.zip</a></li>
+				<li>SDK Examples (platform independent): <a href="http://archive.eclipse.org/rt/smila/releases/0.9/SMILA-0.9-integrator-examples.zip">SMILA-0.9-integrator-examples.zip</a></li>
+			</ul>
+		</p>
+
+		<h3>0.8</h3>
+		<p>
+			<ul>
+				<li>Linux 32 Bit: <a href="http://archive.eclipse.org/rt/smila/releases/0.8/SMILA-incubation-0.8-linux.gtk.x86.zip">SMILA-incubation-0.8-linux.gtk.x86.zip</a></li>
+				<li>Linux 64 Bit: <a href="http://archive.eclipse.org/rt/smila/releases/0.8/SMILA-incubation-0.8-linux.gtk.x86_64.zip">SMILA-incubation-0.8-linux.gtk.x86_64.zip</a></li>
+				<li>Mac OS X 64 Bit (Cocoa): <a href="http://archive.eclipse.org/rt/smila/releases/0.8/SMILA-incubation-0.8-macosx.cocoa.x86_64.zip">SMILA-incubation-0.8-macosx.cocoa.x86_64.zip</a></li>
+				<li>Windows 32 Bit: <a href="http://archive.eclipse.org/rt/smila/releases/0.8/SMILA-incubation-0.8-win32.win32.x86.zip">SMILA-incubation-0.8-win32.win32.x86.zip</a></li>
+				<li>Windows 64 Bit: <a href="http://archive.eclipse.org/rt/smila/releases/0.8/SMILA-incubation-0.8-win32.win32.x86_64.zip">SMILA-incubation-0.8-win32.win32.x86_64.zip</a></li>
+			</ul>
+		</p>
+
+		<h3>0.7</h3>
+		<p>
+			<ul>
+				<li>Linux binaries: <a href="http://archive.eclipse.org/rt/smila/releases/0.7/SMILA-incubation-0.7-linux.gtk.x86.zip">SMILA-incubation-0.7-linux.gtk.x86.zip</a></li>
+				<li>Win32 binaries: <a href="http://archive.eclipse.org/rt/smila/releases/0.7/SMILA-incubation-0.7-win32.win32.x86.zip">SMILA-incubation-0.7-win32.win32.x86.zip</a></li>
+			</ul>
+		</p>
+		<h2>Milestones</h2>
+		<h3>0.5 M3</h3>
+		<p>
+			<ul>
+				<li>Linux binaries: <a href="http://archive.eclipse.org/rt/smila/milestones/0.5-M3/SMILA-incubation-0.5-M3-linux.gtk.x86.zip">SMILA-incubation-0.5-M3-linux.gtk.x86.zip</a></li>
+				<li>Win32 binaries: <a href="http://archive.eclipse.org/rt/smila/milestones/0.5-M3/SMILA-incubation-0.5-M3-win32.win32.x86.zip">SMILA-incubation-0.5-M3-win32.win32.x86.zip</a></li>
+			</ul>
+		</p>
+		<h3>0.5 M2</h3>
+		<p>
+			<ul>
+				<li>Linux binaries: <a href="http://archive.eclipse.org/rt/smila/milestones/0.5-M2/SMILA-incubation-0.5-M2-linux.gtk.x86.zip">SMILA-incubation-0.5-M2-linux.gtk.x86.zip</a></li>
+				<li>Win32 binaries: <a href="http://archive.eclipse.org/rt/smila/milestones/0.5-M2/SMILA-incubation-0.5-M2-win32.win32.x86.zip">SMILA-incubation-0.5-M2-win32.win32.x86.zip</a></li>
+			</ul>
+		</p>
+		<h3>0.5 M1</h3>
+		<p>
+			<ul>
+				<li>Linux binaries: <a href="http://archive.eclipse.org/rt/smila/milestones/0.5-M1/SMILA-incubation-0.5-M1-linux.gtk.x86.zip">SMILA-incubation-0.5-M1-linux.gtk.x86.zip</a></li>
+				<li>Win32 binaries: <a href="http://archive.eclipse.org/rt/smila/milestones/0.5-M1/SMILA-incubation-0.5-M1-win32.win32.x86.zip">SMILA-incubation-0.5-M1-win32.win32.x86.zip</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 917025a..ca327c5 100755
--- a/index.php
+++ b/index.php
@@ -41,7 +41,13 @@
 		<div class="homeitem3col">
 			<h3>News</h3>
 			
-			<h4>2014-12-01 - 1.3-M1 available</h4>
+			<h4>2015-04-15 - SMILA 1.3 released!</h4>
+			<p>
+				Today we released <a href="downloads.php">SMILA 1.3</a>! 
+				The main new features of this release are 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 
+				and the <a href="http://wiki.eclipse.org/SMILA/Documentation/Solr_4.x">Solr-4 integration</a> including Cloud-, Http- and EmbeddedSolrServer implementations and support of all available Solr-4 search/indexing features.				
+			</p>
+			<h4>December 2014 - 1.3-M1 available</h4>
 			<p>
 				Today we <a href="downloads.php">published the milestone M1</a> 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.  
diff --git a/plan.php b/plan.php
index fb3583a..dd31a8d 100644
--- a/plan.php
+++ b/plan.php
@@ -15,7 +15,7 @@
 					
 			<h3>SMILA Version 1.3</h3>
 			<p>
-			This release is planned for April 15th 2015.
+			SMILA 1.3 was released on April 15th 2015. The main new features were:
 			</p>
 			<ul>			    							
 				<li>Solr 4 integration/clustering</li>
diff --git a/plan_archive.php b/plan_archive.php
index 1f47e47..6b9d3f7 100644
--- a/plan_archive.php
+++ b/plan_archive.php
@@ -1,115 +1,124 @@
-<?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 - Project Plan";
-	$pageKeywords	= "SMILA, Unified Information Access Architecture, unstructured information management, information logistics, semantic web, framework, platform, eclipse, big data, bigdata";
-	$pageAuthor		= "Igor Novakovic";
-
-	# Paste your HTML content between the EOHTML markers!	
-	$html = <<<EOHTML
-
-	<div id="midcolumn">
-		<h1>Project Plan - Archive</h1>
-		<div class="homeitem3col">
-		
-			<h3>SMILA Version 1.2</h3>
-			<p>
-			This release was published on April, 17th 2013.
-			</p>
-			<ul>
-				<li>Apache Tika integration - extracting text from binary content</li>								
-				<li>JDBC-Crawler: Splitting functionality for scaling</li>
-				<li>Web-Crawling enhancements (robots.txt, boilerpipe integration)</li>
-				<li>Remote-Crawling</li>
-				<li>Cluster setup tutorial</li>
-			</ul>
-		
-		    <h3>SMILA Version 1.1</h3>
-			<p>
-			This release was published on July, 11th 2012.
-			</p>
-			<ul>
-				<li>Migration of web, file, JDBC and feed crawler implementations to self-scaling ETL</li>
-				<li>Solr 3.5 integration</li>
-			</ul>
-		
-			<h3>SMILA Version 1.0</h3>
-			<p>
-			This release was published on February, 2nd 2012.
-			</p>
-			<ul>
-				<li>Self-scaling ETL</li>
-			</ul>
-
-			<h3>SMILA Version 0.9</h3>
-			<p>
-			This release was published on October, 27th 2011.
-			</p>
-			<ul>
-				<li>Cluster readiness (RESTful APIs)</li>
-				<li>New asynchronous workflows</li>
-				<li>BPEL Designer on RAP (proof of concept)</li>
-			</ul>
-			<h3>SMILA Version 0.8</h3>
-			<p>
-			This release was published on May, 2nd 2011.
-			</p>
-			<ul>
-				<li>BPEL editor extensions</li>
-				<li>Simplification of data model</li>
-			</ul>
-		</div>
-		<div class="homeitem3col">
-			<h3>SMILA Version 0.7</h3>
-			<p>
-			This release was published on March 17th 2010.
-			</p>
-			<ul>
-				<li>Web Service API support</li>
-				<li>Solr integration (access to Apache Solr' REST API)</li>
-			</ul>
-		</div>
-		<div class="homeitem3col">
-			<h3>SMILA Version 0.5 M3</h3>
-			<p>
-			This milestone was published on July 31st 2009.
-			</p>
-			<ul>
-				<li>Bulk operations (increasing the data throughput)</li>
-				<li>More connectors (XML, Job file)</li>
-				<li>Alternative binary storage implementation (based on JPA)</li>
-			</ul>
-		</div>
-		<div class="homeitem3col">
-			<h3>SMILA Version 0.5 M2</h3>
-			<p>
-			This milestone was published on May 29th 2009.
-			</p>
-			<ul>
-				<li>Simple compound management</li>
-				<li>More connectors (RSS & Atom)</li>
-			</ul>
-		</div>
-		<div class="homeitem3col">
-			<h3>SMILA Version 0.5 M1</h3>
-			<p>
-			This milestone was published on March 23rd 2009.
-			</p>
-			<ul>
-				<li>Basic architecture settled and implemented</li>
-				<li>Simple search application available</li>
-				<li>Diverse connectors (File System, Web, DB)</li>
-				<li>Incremental update</li>
-				<li>Conception and implementation of search APIs</li>
-				<li>Implementation of the security concept</li>
-				<li>Ontology Service (introduction of semantic layer)</li>
-			</ul>
-		</div>
-	</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 - Project Plan";
+	$pageKeywords	= "SMILA, Unified Information Access Architecture, unstructured information management, information logistics, semantic web, framework, platform, eclipse, big data, bigdata";
+	$pageAuthor		= "Igor Novakovic";
+
+	# Paste your HTML content between the EOHTML markers!	
+	$html = <<<EOHTML
+
+	<div id="midcolumn">
+		<h1>Project Plan - Archive</h1>
+		<div class="homeitem3col">
+		
+			<h3>SMILA Version 1.3</h3>
+			<p>
+			This release was published on April, 15th 2015.
+			</p>
+			<ul>
+				<li>Scripting Engine for using JavaScript scripts for synchronous data processing.</li>												
+				<li>Solr-4 integration including Cloud-, Http- and EmbeddedSolrServer implementations and support of all available Solr-4 search/indexing features</li>
+			</ul>
+		
+			<h3>SMILA Version 1.2</h3>
+			<p>
+			This release was published on April, 17th 2013.
+			</p>
+			<ul>
+				<li>Apache Tika integration - extracting text from binary content</li>								
+				<li>JDBC-Crawler: Splitting functionality for scaling</li>
+				<li>Web-Crawling enhancements (robots.txt, boilerpipe integration)</li>
+				<li>Remote-Crawling</li>
+				<li>Cluster setup tutorial</li>
+			</ul>
+		
+		    <h3>SMILA Version 1.1</h3>
+			<p>
+			This release was published on July, 11th 2012.
+			</p>
+			<ul>
+				<li>Migration of web, file, JDBC and feed crawler implementations to self-scaling ETL</li>
+				<li>Solr 3.5 integration</li>
+			</ul>
+		
+			<h3>SMILA Version 1.0</h3>
+			<p>
+			This release was published on February, 2nd 2012.
+			</p>
+			<ul>
+				<li>Self-scaling ETL</li>
+			</ul>
+
+			<h3>SMILA Version 0.9</h3>
+			<p>
+			This release was published on October, 27th 2011.
+			</p>
+			<ul>
+				<li>Cluster readiness (RESTful APIs)</li>
+				<li>New asynchronous workflows</li>
+				<li>BPEL Designer on RAP (proof of concept)</li>
+			</ul>
+			<h3>SMILA Version 0.8</h3>
+			<p>
+			This release was published on May, 2nd 2011.
+			</p>
+			<ul>
+				<li>BPEL editor extensions</li>
+				<li>Simplification of data model</li>
+			</ul>
+		</div>
+		<div class="homeitem3col">
+			<h3>SMILA Version 0.7</h3>
+			<p>
+			This release was published on March 17th 2010.
+			</p>
+			<ul>
+				<li>Web Service API support</li>
+				<li>Solr integration (access to Apache Solr' REST API)</li>
+			</ul>
+		</div>
+		<div class="homeitem3col">
+			<h3>SMILA Version 0.5 M3</h3>
+			<p>
+			This milestone was published on July 31st 2009.
+			</p>
+			<ul>
+				<li>Bulk operations (increasing the data throughput)</li>
+				<li>More connectors (XML, Job file)</li>
+				<li>Alternative binary storage implementation (based on JPA)</li>
+			</ul>
+		</div>
+		<div class="homeitem3col">
+			<h3>SMILA Version 0.5 M2</h3>
+			<p>
+			This milestone was published on May 29th 2009.
+			</p>
+			<ul>
+				<li>Simple compound management</li>
+				<li>More connectors (RSS & Atom)</li>
+			</ul>
+		</div>
+		<div class="homeitem3col">
+			<h3>SMILA Version 0.5 M1</h3>
+			<p>
+			This milestone was published on March 23rd 2009.
+			</p>
+			<ul>
+				<li>Basic architecture settled and implemented</li>
+				<li>Simple search application available</li>
+				<li>Diverse connectors (File System, Web, DB)</li>
+				<li>Incremental update</li>
+				<li>Conception and implementation of search APIs</li>
+				<li>Implementation of the security concept</li>
+				<li>Ontology Service (introduction of semantic layer)</li>
+			</ul>
+		</div>
+	</div>
+	  
+EOHTML;
+
+	include('rightColumn.php');
+	$html .= $rightColumn;
+
+	# Generate the web page
+	$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
+?>
