diff --git a/download.php b/download.php
index d0f5723..f095361 100755
--- a/download.php
+++ b/download.php
@@ -51,7 +51,19 @@
 		
 		<div class="homeitem">
 			<a name="updateSite"></a>
-			<h3>Get it from the update site</h3>
+			<h3>Get JWT 0.7 from the update site</h3>
+			<ul>
+				<li><b>1.</b> Start Eclipse 3.5 (Galileo). If your don't have it, get it <a href="http://www.eclipse.org/downloads/packages/">there</a>. It requires <a href="http://java.sun.com/javase/downloads/index.jsp">Java</a> (1.5 or later).</li> 
+				<li><b>2.</b> In the "Help" menu, click on "Software Update...". In the dialog, click on "Add Site..." and enter the URL of the <a href="http://download.eclipse.org/technology/jwt/update-site/">JWT update site</a> .</li>
+				<li><b>3.</b> Select JWT in the tree to automatically download JWT and its dependencies. Finally restart Eclipse.</li>
+			</ul>
+		</div>
+
+		<hr class="clearer" />
+
+		<div class="homeitem">
+			<a name="updateSite"></a>
+			<h3>Get JWT 0.6 from the update site</h3>
 			<ul>
 				<li><b>1.</b> Start Eclipse 3.5 (Galileo). 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>2.</b> In the "Help" menu, click on "Install New Software". Then select JWT in the <b>General Purpose Tools</b> category to automatically download JWT and its dependencies.</li>
@@ -59,24 +71,14 @@
 			</ul>
 		</div>
 		
-		<!-- div class="homeitem">
-			<a name="updateSite"></a>
-			<h3>OLDER RELEASES - Get it from the update site</h3>
-			<ul>
-				<li><b>1.</b> Start Eclipse 3.4 (Ganymede). If your don't have it, get it <a href="http://www.eclipse.org/downloads/packages/">there</a>. It requires <a href="http://java.sun.com/javase/downloads/index.jsp">Java</a> (1.5 or later).</li> 
-				<li><b>2.</b> In the "Help" menu, click on "Software Update...". In the dialog, click on "Add Site..." and enter the URL of the <a href="http://download.eclipse.org/technology/jwt/update-site/">JWT update site</a> .</li>
-				<li><b>3.</b> Select JWT in the tree to automatically download JWT and its dependencies. Finally restart Eclipse.</li>
-			</ul>
-		</div -->
-
 		<hr class="clearer" />
 		
 		<div class="homeitem">
 			<a name="integrator"></a>
 			<h3>Install an integrator's distribution</h3>
 			<ul>
-				<li><b>-</b> <a href="http://sourceforge.net/projects/agilpro">AgilPro</a> is an Eclipse JWT-based business process modeling suite providing a <b>Modeler</b>, a <b>Simulator</b> desktop application, and Adapters for standard applications ( <b>Firefox, OpenOffice</b> ).</li>
-				<li><b>-</b> <a href="http://scarbo.ow2.org">OW2 Scarbo</a> is an <b>SOA</b> BPM solution supporting <b>web services, RMI and SCA</b>, script, mail and semantics actions, and a server runtime based on <a href="http://www.ow2.org">OW2</a>'s <a href="http://bonita.ow2.org">Bonita</a> and <a href"http://frascati.ow2.org">FraSCAti</a> .</li> 
+				<li><b><a href="http://sourceforge.net/projects/agilpro">AgilPro</a></b> is an Eclipse JWT-based business process modeling suite providing a <b>Modeler</b>, a <b>Simulator</b> desktop application, and Adapters for standard applications ( <b>Firefox, OpenOffice</b>).</li>
+				<li><b><a href="http://scarbo.ow2.org">OW2 Scarbo</a></b> is an <b>SOA</b> BPM solution supporting <b>web services, RMI and SCA</b>, script, mail and semantics actions, and a server runtime based on <a href="http://www.ow2.org">OW2</a>'s <a href="http://bonita.ow2.org">Bonita</a> and <a href"http://frascati.ow2.org">FraSCAti</a> .</li> 
 			</ul>
 		</div>
 
@@ -108,17 +110,17 @@
  		</div>
 
  		<div class="sideitem">
- 			<h6>JWT 0.6.0 "Galileo" (Current)</h6>
-			Released on 2009-06-24 ( <a href="http://www.eclipse.org/downloads">get it in Galileo</a> , <a href="http://wiki.eclipse.org/Image:JWT_Release_Review_0_6.pdf"> slides</a> )
+ 			<h6>JWT 0.7.0 (Current)</h6>
+			Released on 2009-12-21 ( Get it from the <a href="http://download.eclipse.org/technology/jwt/update-site/">update site</a>, <a href="http://wiki.eclipse.org/Image:JWT_Release_Review_0_7.pdf">slides</a> )
 			<p/>
-			<i><a href="http://wiki.eclipse.org/JWT_NewNoteworthy_0_6">New</a> : templates, UML and EPC views, BPMN import, SOA, runtime</i>
+			<i>New: view layouts, new converter, improved transformations...</i>
  		</div>
 
  		<div class="sideitem">
- 			<h6>JWT 0.7.0 (Upcoming)</h6>
-			Upcoming on 2009-09-24 ( Test it in the <a href="http://download.eclipse.org/technology/jwt/integration-update-site/">nightly builds update site</a> )
+ 			<h6>JWT 1.0.0 (Upcoming)</h6>
+			Upcoming on 2010-06-20 ( Test it in the <a href="http://download.eclipse.org/technology/jwt/integration-update-site/">nightly builds update site</a> )
 			<p/>
-			<i>In the works : view layouts, jPDL export, BPMN2...</i>
+			<i>In the works : jPDL export, BPMN2 view, desktop application...</i>
  		</div>
 
  		<!-- div class="sideitem">
diff --git a/index.php b/index.php
index 1bbb727..f772288 100644
--- a/index.php
+++ b/index.php
@@ -117,7 +117,7 @@
 			<h3>Community and Development</h3>
 			<img align="right" src="/jwt/images/item_community.gif" alt="community" />
 			<ul>
-				<li><a href="http://wiki.eclipse.org/JWT_Downloads#Overview">Roadmap</a></li> 
+				<li><a href="http://www.eclipse.org/projects/project-plan.php?projectid=technology.jwt">Roadmap</a></li> 
 				<li><a href="https://dev.eclipse.org/mailman/listinfo/jwt-dev">Mailing List</a> (<a href="http://dev.eclipse.org/mhonarc/lists/jwt-dev/maillist.html">Archive</a>) and <a href="news://news.eclipse.org/eclipse.technology.jwt">Newsgroup</a> ( <a href="http://www.eclipse.org/newsportal/thread.php?group=eclipse.technology.jwt">browse</a> )</li>
 				<li><a href="http://dev.eclipse.org/bugs/buglist.cgi?bug_status=NEW&bug_status=ASSIGNED&bug_status=REOPENED&email1=&emailtype1=substring&emailassigned_to1=1&email2=&emailtype2=substring&emailreporter2=1&bugidtype=include&bug_id=&changedin=&votes=&chfieldfrom=&chfieldto=Now&chfieldvalue=&product=JWT&short_desc=&short_desc_type=allwordssubstr&long_desc=&long_desc_type=allwordssubstr&keywords=&keywords_type=anywords&field0-0-0=noop&type0-0-0=noop&value0-0-0=&cmdtype=doit&order=Reuse+same+sort+as+last+time">Open Bugs and Requests</a> (<a href="https://bugs.eclipse.org/bugs/enter_bug.cgi?product=JWT">Ask for a Feature or Report Bug</a>)</li> 
 				<li><a href="http://wiki.eclipse.org/JWT_CVS">Get the Source Code</a> ( <a href="http://dev.eclipse.org/viewcvs/index.cgi/org.eclipse.jwt/?root=Technology_Project">browse</a> )</li> 
@@ -157,10 +157,11 @@
  		<div class="sideitem">
 			<h6>What's new</h6>
 			<ul>
+				<li><strong>December, 21st 2009:</strong>
+				JWT 0.7 has now been released. It is available from the update site and will also be integrated into SR2 of <a href="http://www.eclipse.org/galileo/">Eclipse Galileo</a>. <a href="download.php">Download it now !</a>
+				</li>		
 				<li><strong>October, 20th 2009:</strong>
 				JWT Configuration profiles will be featured at the <a href="http://www.eclipsecon.org/summiteurope2009/">Eclipse Summit Europe 2009</a> in the <a href="http://www.eclipsecon.org/summiteurope2009/sessions?id=935">Aspect-Oriented Modeling</a> talk (<a href="http://following-flo.blogspot.com/2009/10/aspect-oriented-modeling.html">more</a>) on October 28th in Ludwigsburg. Meet us there !
-				<li><strong>June, 24th 2009:</strong>
-				JWT 0.6 has been released. It is available in <a href="http://www.eclipse.org/galileo/">Eclipse 3.5 (Galileo)</a>, the new yearly Eclipse distribution, out this very day. <a href="download.php">Download it now !</a>
 				</li>
 			    <li><a href="/jwt/newsarchive.php">News archive</a>
 			    </li>
diff --git a/newsarchive.php b/newsarchive.php
index 7f9f13e..441fd8b 100644
--- a/newsarchive.php
+++ b/newsarchive.php
@@ -33,6 +33,9 @@
 		<div class="homeitem3col">
 			<h3>News archive</h3>
 					<p>
+					<li><strong>June, 24th 2009:</strong>
+						JWT 0.6 has been released. It is available in <a href="http://www.eclipse.org/galileo/">Eclipse 3.5 (Galileo)</a>, the new yearly Eclipse distribution, out this very day. <a href="download.php">Download it now !</a>
+					</li>					
 					<li><strong>April, 23rd 2009:</strong> JWT was presented at Eclipse Forum Europe 2009 in Mainz, Germany. 
 					Please find the <a href="/jwt/press/efe09/ExecuteYourProcesses_EFE09_final.pdf">presentation</a> and the shown screencasts (
 					<a href="/jwt/press/efe09/01_FromBPMN2JWT.swf">1</a>,
