diff --git a/_projectCommon.php b/_projectCommon.php
index 22e55dc..d5cdc3a 100755
--- a/_projectCommon.php
+++ b/_projectCommon.php
@@ -25,16 +25,16 @@
 	# $Nav->setLinkList(array());
 	
 	# Break the navigation into sections
-	$Nav->addNavSeparator("MyProject", 	"/default");
-	$Nav->addCustomNav("Download", "/project/download.php", "_self", 3);
-	$Nav->addCustomNav("Documentation", "/project/documentation.php", "_blank", 3);
-	$Nav->addCustomNav("Support", "/project/support.php", "_blank", 3);
-	$Nav->addCustomNav("Getting Involved", "/project/developers", "_blank", 3);
+	$Nav->addNavSeparator("Gemini JPA", 	"/jpa");
+	$Nav->addCustomNav("Download", "/jpa/download.php", "_self", 3);
+	$Nav->addCustomNav("Documentation", "/jpa/documentation.php", "_blank", 3);
+	$Nav->addCustomNav("Support", "/jpa/support.php", "_blank", 3);
+	$Nav->addCustomNav("Getting Involved", "/jpa/getting_involved.php", "_blank", 3);
 
 	# Define keywords, author and title here, or in each PHP page specifically
-	$pageKeywords	= "xtext, dsl, modeling, domain specific language, textual";
-	$pageAuthor		= "Your name";
-	# $pageTitle 		= "Xtext";
+	$pageKeywords	= "javaee, osgi, enterprise, module, gemini";
+	$pageAuthor		= "Mike Keith";
+	$pageTitle 		= "Gemini JPA";
 
 
 	# top navigation bar
diff --git a/documentation.php b/documentation.php
new file mode 100644
index 0000000..d88ddf1
--- /dev/null
+++ b/documentation.php
@@ -0,0 +1,26 @@
+<?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'
+/*******************************************************************************
+ * Copyright (c) 2009 
+ * 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:
+ *    
+ *******************************************************************************/
+
+	$pageTitle 		= "Gemini JPA Documentation";
+	$App->AddExtraHtmlHeader('<link rel="stylesheet" type="text/css" href="/default/style.css"/>');
+
+	$html  = <<<EOHTML
+<div id="midcolumn">
+<h2>$pageTitle</h2>
+</p>
+<p>Documentation is in the process of being written for Gemini JPA.</p>
+
+</div>
+EOHTML;
+	# Generate the web page
+	$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
+?>
\ No newline at end of file
diff --git a/download.php b/download.php
index a4c9eb1..7e656aa 100644
--- a/download.php
+++ b/download.php
@@ -10,22 +10,15 @@
  *    
  *******************************************************************************/
 
-	$pageTitle 		= "MyProject - Download";
-	$App->AddExtraHtmlHeader('<link rel="stylesheet" type="text/css" href="/default/style.css"/>');
+	$pageTitle 		= "Gemini JPA Downloads";
+	$App->AddExtraHtmlHeader('<link rel="stylesheet" type="text/css" href="/jpa/style.css"/>');
 
 	$html  = <<<EOHTML
 <div id="midcolumn">
 <h2>$pageTitle</h2>
 <p>All downloads are provided under the terms and conditions of the <a href="/legal/epl/notice.php">Eclipse Foundation Software User Agreement</a> unless otherwise specified.</p>
 
-<h3>Galileo - Eclipse 3.5</h3>
-<p><b>Update site:</b> http://download.eclipse.org/myproject/<br />
-<b>ZIP file: </b><a href="/downloads/download.php?file=/myproject/file.zip">file.zip</a> (10 MiB)</p>
-
-<h3>Helios - Eclipse 3.6 (unreleased)</h3>
-<p><b>Update site:</b> http://download.eclipse.org/myproject/<br />
-<b>ZIP file: </b><a href="/downloads/download.php?file=/myproject/file.zip">file.zip</a> (10 MiB)</p>
-
+<h2>No downloads are currently available.</h2>
 
 </div>
 EOHTML;
diff --git a/getting_involved.php b/getting_involved.php
new file mode 100644
index 0000000..07a428b
--- /dev/null
+++ b/getting_involved.php
@@ -0,0 +1,26 @@
+<?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'
+/*******************************************************************************
+ * Copyright (c) 2009 
+ * 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:
+ *    
+ *******************************************************************************/
+
+	$pageTitle 		= "Getting Involved in Gemini JPA";
+	$App->AddExtraHtmlHeader('<link rel="stylesheet" type="text/css" href="/default/style.css"/>');
+
+	$html  = <<<EOHTML
+<div id="midcolumn">
+<h2>$pageTitle</h2>
+<p/>
+<p>Post a message to the <a href="http://www.eclipse.org/forums/index.php?t=thread&frm_id=153">Gemini forum</a> to indicate that you would like to get involved, and how/what you would like to contribute.
+
+</div>
+EOHTML;
+	# Generate the web page
+	$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
+?>
\ No newline at end of file
diff --git a/index.php b/index.php
index ab12bd1..4b0eb06 100755
--- a/index.php
+++ b/index.php
@@ -11,14 +11,14 @@
  *******************************************************************************/
 
 	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());
-	$App->AddExtraHtmlHeader('<link rel="stylesheet" type="text/css" href="/default/style.css"/>');
+	$App->AddExtraHtmlHeader('<link rel="stylesheet" type="text/css" href="/jpa/style.css"/>');
 	
 	$localVersion = false;
 	
 	# Define these here, or in _projectCommon.php for site-wide values
-	$pageKeywords	= "eclipse, project";
-	$pageAuthor		= "Your name";
-	$pageTitle 		= "My project home";
+	$pageKeywords	= "eclipse, project, osgi, jpa, gemini";
+	$pageAuthor		= "Mike Keith";
+	$pageTitle 		= "Gemini JPA";
 	
 	
 	// 	# Paste your HTML content between the EOHTML markers!
diff --git a/pages/_index.html b/pages/_index.html
index 01da877..5a81f92 100644
--- a/pages/_index.html
+++ b/pages/_index.html
@@ -1,68 +1,55 @@
 <div id="bigbuttons">
 <h3>Primary Links</h3>
 <ul>
-	<li><a id="buttonDownload" href="download.php" title="Download">Eclipse
-	Distribution, Update Site, Dropins</a></li>
-	<li><a id="buttonDocumentation" href="midcolumn_example.php"
-		title="Documentation">Tutorials, Examples, Videos, Reference Documentation</a></li>
-	<li><a id="buttonSupport" href="midcolumn_example.php" title="Download">Bug
-	Tracker, Newsgroup, Professional Support</a></li>
-	<li><a id="buttonInvolved" href="midcolumn_example.php" title="Getting Involved">CVS,
-	Workspace Setup, Wiki, Committers</a></li>
+    <li><a id="buttonDownload" href="download.php" title="Download">Module Downloads</a></li>
+    <li><a id="buttonDocumentation" href="documentation.php"
+        title="Documentation">Tutorials, Examples, Reference Documentation</a></li>
+    <li><a id="buttonSupport" href="support.php" title="Support">Forum</a></li>
+    <li><a id="buttonInvolved" href="getting_involved.php" title="Getting Involved">SVN,
+    Workspace Setup, Wiki, Committers</a></li>
 </ul>
 </div>
 
 <div id="midcolumn">
-<h3>MyProject - use this header describe what it does</h3>
+<h3>Gemini JPA</h3>
+<h4>Modular JPA Support</h4>
 <div id="introText">
 
-<p class="left">MyProject is a framework for development of cool stuff and
-more cool stuff. Just describe your project here very briefly. Use the center 
-section below for a screenshot, a screenshot collage or a screencast.</p>
+<p class="left">The Gemini JPA project is about modular implementations 
+of Java Persistence API technology. This project provides a JPA provider that follows the
+OSGi JPA specification approach and that clients can use to get JPA support in OSGi.</p>
 
-<p class="right"> This project was just provisioned.  You can see the proposal 
-<a href="/proposals/gemini">here</a>
-
-</p>
+<p class="right">The modules run on the Equinox OSGi framework and leverage the OSGi bundle model
+of packaging and lifecycle activation.</p>
 
 </div>
 
- 
-
 <div id="screencast">
 <object width="640" height="480"><param name="allowfullscreen" value="true" /><param name="allowscriptaccess" value="always" /><param name="movie" value="http://vimeo.com/moogaloop.swf?clip_id=8260921&amp;server=vimeo.com&amp;show_title=0&amp;show_byline=0&amp;show_portrait=0&amp;color=DBD7EF&amp;fullscreen=1" /><embed src="http://vimeo.com/moogaloop.swf?clip_id=8260921&amp;server=vimeo.com&amp;show_title=0&amp;show_byline=0&amp;show_portrait=0&amp;color=DBD7EF&amp;fullscreen=1" type="application/x-shockwave-flash" allowfullscreen="true" allowscriptaccess="always" width="640" height="480"></embed></object>
 </div>
 
-<!-- 
-<h3>...and yet powerful</h3>
- -->
-<div id="feature_1">
-
-<h4>Some cool feature</h4>
-<p>MyProject has this really cool feature that you describe here in few words, just as a teaser.</p>
+<div id="modularity">
+<h4>Modularity</h4>
+<p>The Gemini JPA project is packaged as a small number of separate and standalone module.</p>
 </div>
 
-<div id="feature_2">
-<h4>Another Feature</h4>
-<p>When working with MyProject, great things happen, and one of them is described here.</p>
+<div id="independence">
+<h4>Independence</h4>
+<p>The Gemini JPA subproject is downloadable and executable independently from the others Gemini subprojects.</p>
 </div>
 
-<div id="feature_3">
-<h4>Another Feature</h4>
-<p>When working with MyProject, great things happen, and one of them is described here.</p>
-</div>
-
-<div id="feature_4">
-<h4>User Experience</h4>
-<p>
-Experiment with style.css to create columns for text, just the way you want it. This section 
-is a bit wider and can contain more words, even small logos or graphics to describe a neat feature in more detail.</p>
+<div id="free">
+<h4>Free and Easy</h4>
+<p>Like everything else at Eclipse, getting started is as easy as downloading and trying it out!</p>
 </div>
 
 <div id="feature_more">
 <h4>and much more...</h4>
-<p>Read the MyProject <a href="/project/documentation.php">documentation</a> and join the discussion at the <a href="http://www.eclipse.org/forums/eclipse.newsgroup.name">forum</a> to understand how powerful MyProject is.</p>
-<p> Want to know more? <a href="/projects/project_summary.php?projectid=my.project">About This Project</a>
+<p>The Gemini documentation (coming soon) will give more details about the project.</p>
+<p>Join the discussion at the <a href="http://www.eclipse.org/forums/index.php?t=thread&frm_id=153&">forum</a> to ask questions or find out answers from questions that others have asked.</p>
+<p>Want to know more?
+<br><a href="/projects/project_summary.php?projectid=rt.gemini">About Gemini</a></br>
+</p>
 </div>
 
 </div>
@@ -71,17 +58,12 @@
 
 <div>
 <h3>Current Status</h3>
-<p>Update this section occasionally to let your community know what's new and exciting with your project....</p>
+<p>The source code is in the process of legal approval for acceptance into Eclipse.</p>
 </div>
 
 <div id="headlines">
 <h3>New and Noteworthy</h3>
-<p>... or a link to your new and noteworthy.</p>
-</div>
-
-<div id="headlines">
-<h3>Headlines on the web</h3>
-<p>Project headlines...</p>
+<p>Stay tuned for Gemini JPA announcements coming soon!</p>
 </div>
 
 <div id="headlines">
diff --git a/placeHolder.html b/placeHolder.html
new file mode 100644
index 0000000..3014a68
--- /dev/null
+++ b/placeHolder.html
@@ -0,0 +1 @@
+Coming soon!
\ No newline at end of file
diff --git a/project_plan.html b/project_plan.html
new file mode 100644
index 0000000..cc5298c
--- /dev/null
+++ b/project_plan.html
@@ -0,0 +1 @@
+The Project Plan for Gemini JPA is coming soon.
\ No newline at end of file
diff --git a/support.php b/support.php
new file mode 100644
index 0000000..b0be45a
--- /dev/null
+++ b/support.php
@@ -0,0 +1,26 @@
+<?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'
+/*******************************************************************************
+ * Copyright (c) 2009 
+ * 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:
+ *    
+ *******************************************************************************/
+
+	$pageTitle 		= "Gemini JPA Support";
+	$App->AddExtraHtmlHeader('<link rel="stylesheet" type="text/css" href="/default/style.css"/>');
+
+	$html  = <<<EOHTML
+<div id="midcolumn">
+<h2>$pageTitle</h2>
+<p/>
+<p>You can get support for Gemini JPA by posting to the <a href="http://www.eclipse.org/forums/index.php?t=thread&frm_id=153">Gemini forum</a>. Please be sure to indicate the exact nature of your question or problem, including any stack traces or additional information.
+
+</div>
+EOHTML;
+	# Generate the web page
+	$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
+?>
\ No newline at end of file
