diff --git a/download/index.php b/download/index.php
index 39b5c67..c61937a 100755
--- a/download/index.php
+++ b/download/index.php
@@ -23,6 +23,8 @@
 	$pageKeywords	= "Eclipse, EclipseRT, Gemini, OSGi, Management, Documentation";
 	$pageAuthor		= "Christopher Frost";
 
+	$geminiManagementVersions = array("1.0.3.RELEASE", "1.0.2.RELEASE", "1.0.1.RELEASE", "1.0.0.RELEASE");
+
 	ob_start();
 ?>
 
@@ -39,52 +41,38 @@
 			unless otherwise specified.
 		</p>
 	
-		<h4 class='toggle'>1.0.2.RELEASE</h4>
-		<div class='accordion'>
-			<ul>
-				<li><a href='http://www.eclipse.org/gemini/management/download/release-notes/1.0.2.RELEASE.php' target='_self'>View Release Notes. </a></li>
-				<li>Update Site 'http://download.eclipse.org/gemini/updates/management/1.0.2.RELEASE'</li>
-				<li><strong>Gemini Management</strong> -  <a href='http://www.eclipse.org/downloads/download.php?file=/gemini/management/release-zips/1.0.2.RELEASE/org.eclipse.gemini.management_1.0.2.RELEASE.jar' target='_self'>Download</a></li>
-			</ul>
-		</div>
-		<h4 class='toggle'>1.0.1.RELEASE</h4>
-		<div class='accordion'>
-			<ul>
-				<li><a href='http://www.eclipse.org/gemini/management/download/release-notes/1.0.1.RELEASE.php' target='_self'>View Release Notes. </a></li>
-				<li>Update Site 'http://download.eclipse.org/gemini/updates/management/1.0.1.RELEASE'</li>
-				<li><strong>Gemini Management</strong> -  <a href='http://www.eclipse.org/downloads/download.php?file=/gemini/management/release-zips/1.0.1.RELEASE/org.eclipse.gemini.mgmt_1.0.1.RELEASE.jar' target='_self'>Download</a></li>
-			</ul>
-		</div>
-		<h4 class='toggle'>1.0.0.RELEASE</h4>
-		<div class='accordion'>
-			<ul>
-				<li><a href='http://www.eclipse.org/gemini/management/download/release-notes/1.0.0.RELEASE.php' target='_self'>View Release Notes. </a> (<a href='https://bugs.eclipse.org/bugs/attachment.cgi?id=209305' target='_self'>Download Approved IP Log</a>)</li>
-				<li>Update Site 'http://download.eclipse.org/gemini/updates/management/1.0.0.RELEASE'</li>
-				<li><strong>Gemini Management</strong> -  <a href='http://www.eclipse.org/downloads/download.php?file=/gemini/management/release-zips/1.0.0.RELEASE/org.eclipse.gemini.mgmt_1.0.0.RELEASE.jar' target='_self'>Download</a></li>
-			</ul>
-		</div>
+	<?
+	$first = true;
+	foreach ($geminiManagementVersions as $version){
+		echo "<h4 class='toggle'>$version";
+		if ($first) {
+			echo " - Latest</h4>";
+		} else {
+			echo "</h4>";
+		}
+		echo "<div class='accordion'>";
+		echo "	<ul>";
+		echo "		<li><a href='http://www.eclipse.org/gemini/management/download/release-notes/$version.php' target='_self'>View Release Notes</a></li>";
+		echo "		<li>Update Site 'http://download.eclipse.org/gemini/updates/management/$version'</li>";
+		if($version == '1.0.0.RELEASE' | $version == '1.0.1.RELEASE') {
+			echo "		<li><strong>Gemini Management</strong> -  <a href='http://www.eclipse.org/downloads/download.php?file=/gemini/management/release-zips/$version/org.eclipse.gemini.mgmt_$version.jar' target='_self'>Download</a>";
+		}else {
+			echo "		<li><strong>Gemini Management</strong> -  <a href='http://www.eclipse.org/downloads/download.php?file=/gemini/management/release-zips/$version/org.eclipse.gemini.management-$version.jar' target='_self'>Download</a> - ";
+			echo "			<a href='http://www.eclipse.org/downloads/download.php?file=/gemini/management/release-zips/$version/org.eclipse.gemini.management-$version-sources.jar' target='_self'>(Source)</a></li>";
+		}
+		echo "	</ul>";
+		echo "</div>";
+		$first = false;
+	}
+	?>
 
-
-		<h2>Development Milestones</h2>
+<!--		<h2>Development Milestones</h2>
 		<p>
 			Development milestones are available for <a href="/gemini/management/download/milestones.php">download</a>. 
-		</p>
+		</p>-->
 	
 	</div>
 
-<!--	<div id="rightcolumn">
-		<div class="sideitem">
-		   <h6>Incubation</h6>
-		   <div id="incubation"><a href="/projects/what-is-incubation.php"><img src="/images/egg-incubation.png" border="0" alt="Incubation" /></a></div>
-		</div>
-
-		<div class="sideitem">
-			<h6>&lt;h6&gt; tag</h6>
-				<div class="modal">
-					Wrapping your content using a div.modal tag here will add the gradient background
-				</div>
-		</div>
-	</div>-->
 
 <?
 	$html = ob_get_clean();
diff --git a/download/milestones.php b/download/milestones.php
index 78dd1bb..55fc42b 100755
--- a/download/milestones.php
+++ b/download/milestones.php
@@ -23,7 +23,7 @@
 	$pageKeywords	= "Eclipse, EclipseRT, Gemini, OSGi, Downloads";
 	$pageAuthor		= "Christopher Frost";
 	
-	$geminiWebVersions = array("1.0.0.RC1-incubation", "1.0.0.M01-incubation");
+	$geminiManagementVersions = array("1.0.0.RC1-incubation", "1.0.0.M01-incubation");
 	
 	ob_start();
 ?>
@@ -46,7 +46,7 @@
 		</p>
 	<?
 	$first = true;
-	foreach ($geminiWebVersions as $version){
+	foreach ($geminiManagementVersions as $version){
 		echo "<h4 class='toggle'>$version";
 		if ($first) {
 			echo " - Latest</h4>";
diff --git a/download/release-notes/1.0.3.RELEASE.php b/download/release-notes/1.0.3.RELEASE.php
new file mode 100755
index 0000000..5f0e7c8
--- /dev/null
+++ b/download/release-notes/1.0.3.RELEASE.php
@@ -0,0 +1,46 @@
+<?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());
+	
+/*******************************************************************************
+ * Copyright (c) 2009 Eclipse Foundation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors: Christopher Frost
+ *    
+ *******************************************************************************/
+
+	# Begin: page-specific settings.  Change these. 
+	$pageTitle 		= "Gemini Web - Release Notes";
+	$pageKeywords	= "Eclipse, EclipseRT, Gemini, Management, OSGi, Downloads";
+	$pageAuthor		= "Christopher Frost";
+		
+	ob_start();
+?>
+
+<div id="midcolumn">
+
+	<h3>1.0.3.RELEASE - Release Notes</h3>
+	
+	<p>
+		This is a minor bug fix of Gemini Management. It includes some changes to work with Eclipse 3.8 (Juno) 
+		and better handling of queries against bundles that haven't been resolved. For a full list of bugs please see 
+		<a href="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced;classification=RT;product=Gemini.Management;target_milestone=1.0.3.RELEASE" target="_self">here</a>.
+	</p>
+
+
+</div>
+
+<?
+	$html = ob_get_clean();
+	# Generate the web page
+	$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
+?>
\ No newline at end of file
