diff --git a/developers.php b/developers.php
index dea7684..823a45b 100644
--- a/developers.php
+++ b/developers.php
@@ -15,7 +15,7 @@
 	Getting started with Passage Licensing System</a>
 </li>
 <li>
-    <a href="https://git.eclipse.org/c/passage/passage.git/">Browse the Git repository</a><br>
+    <a href="https://github.com/eclipse/passage/">Browse the Git repository</a><br>
 </li>
 <li>
     <a href="https://dev.eclipse.org/mailman/listinfo/passage-dev">
diff --git a/index.php b/index.php
index 2730c85..59db8d2 100644
--- a/index.php
+++ b/index.php
@@ -40,7 +40,7 @@
 		<li>Licensing Runtime Interfaces</li>
 		<li>Licensing Operator Client</li>
 		<li>Licensing Back-end Server</li>
-		<li>Licensing Development Tools</li>
+		<li>Licensing Definition IDE Tools</li>
 		</p>
 		</p>
 		</div>
@@ -71,11 +71,8 @@
 <div id="rightcolumn">
 	<div id="headlines">
 		<p>
-			<a href="https://www.eclipse.org/projects/what-is-incubation.php">
-				<img class="project-image center-block margin-bottom-20 img-responsive" typeof="foaf:Image" src="https://projects.eclipse.org/sites/all/modules/custom/pmi/project_state/images/incubating.png" alt="Incubating - Eclipse Passage">
-			</a>
 			<a href="https://projects.eclipse.org/projects/technology.passage/releases/0.6.0">
-				<i>Eclipse Passage 0.6.0 (in progress)</i>
+				<i>Eclipse Passage 0.6.0 (available)</i>
 			</a>
 			<p/>
 			<a href="https://projects.eclipse.org/projects/technology.passage/releases/0.5.0">
