diff --git a/download.php b/download.php
index 80d6f7a..2f74aa9 100755
--- a/download.php
+++ b/download.php
@@ -46,9 +46,9 @@
 		<hr class="clearer" />
 
 		<div class="homeitem">
-			<h3>Get JWT with the latest Eclipse (JWT 1.1 with Eclipse 3.7 "Indigo")</h3>
+			<h3>Get JWT with the latest Eclipse (JWT 1.3 with Eclipse 4.2 "Kepler")</h3>
 			<ul>
-				<li><b>1.</b> Start the latest Eclipse. If your don't have it, get it <a href="http://www.eclipse.org/downloads">there</a>. It requires <a href="http://java.sun.com/javase/downloads/index.jsp">Java</a> (1.5 or later).</li> 
+				<li><b>1.</b> Start the latest Eclipse. If your don't have it, get it <a href="http://www.eclipse.org/downloads">there</a>. It requires <a href="http://www.oracle.com/technetwork/java/javase/downloads/‎">Java</a> (1.6 or later recommended).</li> 
 				<li><b>2.</b> In the "Help" menu, click on "Install New Software". Then select JWT in the <b>SOA Development</b> category to automatically download JWT and its dependencies.</li>
 				<li><b>3.</b> Finally restart Eclipse.</li>
 			</ul>
diff --git a/index.php b/index.php
index 1b1c617..90598fb 100644
--- a/index.php
+++ b/index.php
@@ -151,26 +151,19 @@
  		<div class="sideitem">
 			<h6>What's new</h6>
 			<ul>
+				<li><strong>June, 26th 2013:</strong>
+				JWT 1.3 has been released, along with the latest <a href="http://www.eclipse.org/kepler/">Eclipse Kepler</a> yearly release. One good news following the other, it provides <a href="http://wiki.eclipse.org/JWT_NewNoteworthy_1_3">the most expected BPMN view</a>!
+				</li>
+				<li><strong>October, 23rd 2012:</strong>
+				At Eclipse Con Europe 2012 in Ludwigsburg, we furthered our <a href="http://fr.slideshare.net/mdutoo/eclipseconeurope2012-soa-models-as-operational-documentation">Models as Operational Documentations</a> showcase, and demonstrated integration of <a href="http://fr.slideshare.net/mdutoo/eclipseconeurope2012-soa-talend-with-easysoa">Talend with EasySOA</a> and at a wider level of SOA design-time and runtime registries.
+				</li>
+				<li><strong>June, 13th 2012:</strong>
+        			Workflow models can have a life after design time: as published documentation. The <a href="http://www.easysoa.org/2012/06/publishing-models-documentation-at-eclipse-juno-democamp-grenoble/">EasySOA</a> team <a href="http://www.slideshare.net/mdutoo/eclipse-democamp-2012ecmv05pub">illustrated as much</a> for JWT at the <a href="http://wiki.eclipse.org/Eclipse_DemoCamps_Juno_2012/Grenoble">Eclipse DemoCamp Grenoble 2012</a> using a prototype EMF to <a href="https://www.oasis-open.org/committees/cmis/">CMIS export</a>.
+				</li>
 				<li><strong>June, 3rd 2012:</strong>
 				You couldn't miss it: Juno is finally out! And as usual, JWT is part of the release. Version 1.2 include a brand-new SVG export feature, Eclipse 4 support <a href="http://wiki.eclipse.org/JWT_NewNoteworthy_1_2">and more</a>!
 				As always, to install, just navigate to the "SOA Development" category in the <a href="http://download.eclipse.org/releases/juno/">Juno update site</a> and select JWT.
-				</li>		
-				<li><strong>June, 22th 2012:</strong>
-        Workflow models can have a life after design time: as published documentation. The <a href="http://www.easysoa.org/2012/06/publishing-models-documentation-at-eclipse-juno-democamp-grenoble/">EasySOA</a> team <a href="http://www.slideshare.net/mdutoo/eclipse-democamp-2012ecmv05pub">illustrated as much</a> for JWT at the <a href="http://wiki.eclipse.org/Eclipse_DemoCamps_Juno_2012/Grenoble">Eclipse DemoCamp Grenoble 2012</a> using a prototype EMF to <a href="https://www.oasis-open.org/committees/cmis/">CMIS export</a>.
-				</li>		
-				<li><strong>June, 28th 2011:</strong>
-				At the <a href="http://wiki.eclipse.org/Eclipse_DemoCamps_Indigo_2011/Grenoble">Eclipse DemoCamp Grenoble 2011</a>, we gave a glimpse of our ongoing work with the <a href="http://www.github.com/easysoa">EasySOA</a> community to allow for <a href="http://www.slideshare.net/mdutoo/eclipse-democamp-eclipse-to-easysoa-core">Collaborative SOA from Eclipse to EasySOA Core</a>.
-				</li>		
-				<li><strong>June, 22nd 2011:</strong>
-				Indigo is here! And with it, the brand new Java Workflow Tooling 1.1 with lots of bugfixes to improve your JWT experience.
-				To install, just navigate to the "SOA Development" category in the Indigo update site and select JWT.   
-				</li>		
-				<li><strong>November, 24th 2010:</strong>
-				JWT-integrating <a href="http://wiki.scarbo.ow2.org/xwiki/bin/view/OW2+Scarbo+1/2+Release+notes">OW2 Scarbo 1.2</a> is out ! Presented at the <a href="http://www.ow2.org/view/Events2010AnnualConference/">OW2 Conference 2010</a>, it gathers improvements garnered in production environments, and builds on the newly enriched <a href="http://wiki.eclipse.org/JWT_Monitoring#Workflow_State_Model">JWT WorkflowService query API</a>.
-				</li>	
-				<li><strong>July, 1st 2010:</strong>
-				Java Workflow Tooling has graduated to version 1.0! The new version is available from the official update site.  
-				</li>		
+				</li>
 			    <li><a href="/jwt/newsarchive.php">News archive</a>
 			    </li>
 			</ul>
diff --git a/newsarchive.php b/newsarchive.php
index 3f006e4..a65416f 100644
--- a/newsarchive.php
+++ b/newsarchive.php
@@ -33,6 +33,20 @@
 		<div class="homeitem3col">
 			<h3>News archive</h3>
 					<p>
+				<li><strong>June, 28th 2011:</strong>
+				At the <a href="http://wiki.eclipse.org/Eclipse_DemoCamps_Indigo_2011/Grenoble">Eclipse DemoCamp Grenoble 2011</a>, we gave a glimpse of our ongoing work with the <a href="http://www.github.com/easysoa">EasySOA</a> community to allow for <a href="http://www.slideshare.net/mdutoo/eclipse-democamp-eclipse-to-easysoa-core">Collaborative SOA from Eclipse to EasySOA Core</a>.
+				</li>
+				<li><strong>June, 22nd 2011:</strong>
+				Indigo is here! And with it, the brand new Java Workflow Tooling 1.1 with lots of bugfixes to improve your JWT experience.
+				To install, just navigate to the "SOA Development" category in the Indigo update site and select JWT.   
+				</li>
+				<li><strong>November, 24th 2010:</strong>
+				JWT-integrating <a href="http://wiki.scarbo.ow2.org/xwiki/bin/view/OW2+Scarbo+1/2+Release+notes">OW2 Scarbo 1.2</a> is out ! Presented at the <a href="http://www.ow2.org/view/Events2010AnnualConference/">OW2 Conference 2010</a>, it gathers improvements garnered in production environments, and builds on the newly enriched <a href="http://wiki.eclipse.org/JWT_Monitoring#Workflow_State_Model">JWT WorkflowService query API</a>.
+				</li>
+				<li><strong>July, 1st 2010:</strong>
+				Java Workflow Tooling has graduated to version 1.0! The new version is available from the official update site.  
+				</li>	
+
 				  <li><strong>June, 24th 2010:</strong>
 				  HELIOS! It's out and JWT is again included in the Helios repositories (can be found in the SOA category).
 				  Also, the JWT project will graduate to 1.0 in the next days!  
diff --git a/pages/team.php b/pages/team.php
index e52bf11..412b55e 100644
--- a/pages/team.php
+++ b/pages/team.php
@@ -47,7 +47,7 @@
 </ul>
 <h3>JWT Release Engineer</h3>
 <ul>
-	<li><span>Christian Saad<br><a href="http://www.informatik.uni-augsburg.de/ds/">University of Augsburg</a></span></li>
+	<li><span>Ahmed Samir Wafa<br><a href="http://www.informatik.uni-augsburg.de/ds/">University of Augsburg</a></span></li>
 </ul>
 <h3>JWT Board Members</h3>
 <ul>
@@ -75,13 +75,12 @@
 	<li><span>Mickael Istria<br><a href="http://www.openwide.fr">Open Wide SA</a></span></li>
 	<li><span>Rodrigue Le-Gall<br><a href="http://www.bonitasoft.com/">bonitasoft SA</a></span></li>
 	<li><span>Emmanuel Rias<br><a href="http://www.bull.com/fr/index.php">Bull SA</a></span></li>
+	<li><span>Yoann Rodière<br><a href="http://www.openwide.fr">Open Wide SA</a></span></li>
 	<li><span>Christian Seitz<br><a href="http://www.informatik.uni-augsburg.de/ds/">University of Augsburg</a></span></li>
+	<li><span>Pierre Vigneras<br><a href="http://www.bull.com/fr/index.php">Bull SA</a></span></li>
 </ul>
 	</div>
 
-	<li><span>Pierre Vigneras<br><a href="http://www.bull.com/fr/index.php">Bull SA</a></span></li>
-	eMundo GmbH
-
 
 <table border="0" cellspacing="0" cellpadding="0" width="100%">
  <tr>
diff --git a/press/index.php b/press/index.php
index 4a116d8..efcac70 100644
--- a/press/index.php
+++ b/press/index.php
@@ -38,7 +38,17 @@
 		<h1>Java Workflow Tooling (JWT)</h1>
 
 		<div class="homeitem3col">
-			<h3> Eclipse Con 2010</h3>
+			<h3> Eclipse Con Europe 2012</h3>
+			At Eclipse Con Europe 2012 in Ludwigsburg, we presented in the SOA Symposium track <a href="http://fr.slideshare.net/mdutoo/eclipseconeurope2012-soa-models-as-operational-documentation">Models as Operational Documentations</a>, or how design-time JWT workflow models can get a new life at operation time thanks to EMF to CMIS export, and how we can combine<a href="http://fr.slideshare.net/mdutoo/eclipseconeurope2012-soa-talend-with-easysoa">Talend with EasySOA</a> and at a wider level SOA architecture repositories with middleware runtime registries.
+		</div>
+
+		<div class="homeitem3col">
+			<h3> Eclipse DemoCamp Grenoble 2012</h3>
+			Workflow models can have a life after design time: as published documentation. The <a href="http://www.easysoa.org/2012/06/publishing-models-documentation-at-eclipse-juno-democamp-grenoble/">EasySOA</a> team <a href="http://www.slideshare.net/mdutoo/eclipse-democamp-2012ecmv05pub">illustrated as much</a> for JWT at the <a href="http://wiki.eclipse.org/Eclipse_DemoCamps_Juno_2012/Grenoble">Eclipse DemoCamp Grenoble 2012</a> using a prototype EMF to <a href="https://www.oasis-open.org/committees/cmis/">CMIS export</a>. We also told the educative technical & IP tale of bringing SVG export to JWT (<a href="GEF SVG export in JWT, a newcomer’s rocky ride to Eclipse ">slides</a>).
+		</div>
+
+		<div class="homeitem3col">
+			<h3> Eclipse DemoCamp Grenoble 2011</h3>
 			At the <a href="http://wiki.eclipse.org/Eclipse_DemoCamps_Indigo_2011/Grenoble">Eclipse DemoCamp Grenoble 2011</a>, we gave a glimpse of our ongoing work with the <a href="http://www.github.com/easysoa">EasySOA</a> community to allow for <a href="http://www.slideshare.net/mdutoo/eclipse-democamp-eclipse-to-easysoa-core">Collaborative SOA from Eclipse to EasySOA Core</a>.
 		</div>
 
