diff --git a/_projectCommon.php b/_projectCommon.php
index 56b1bde..ea998a3 100644
--- a/_projectCommon.php
+++ b/_projectCommon.php
@@ -1,6 +1,6 @@
 <?php
 /*******************************************************************************
- * Copyright (c) 2009, 2014 Eclipse Foundation and others.
+ * Copyright (c) 2009, 2016 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
@@ -34,6 +34,39 @@
 # Set the theme for your project's web pages.
 $theme = "solstice";
 
+# Initialize custom solstice $variables.
+$variables = array();
+
+# Add classes to <body>. (String)
+$variables['body_classes'] = '';
+
+# Insert custom HTML in the breadcrumb region. (String)
+$variables['breadcrumbs_html'] = "";
+
+# Hide the breadcrumbs. (Bool)
+$variables['hide_breadcrumbs'] = FALSE;
+
+# Insert HTML before the left nav. (String)
+$variables['leftnav_html'] = '';
+
+# Update the main container class (String)
+$variables['main_container_classes'] = 'container';
+
+# Insert HTML after opening the main content container, before the left sidebar. (String)
+$variables['main_container_html'] = '';
+
+// CFA Link - Big orange button in header
+$variables['btn_cfa'] = array(
+  'hide' => FALSE, // Optional - Hide the CFA button.
+  'html' => '', // Optional - Replace CFA html and insert custom HTML.
+  'class' => 'btn btn-huge btn-warning', // Optional - Replace class on CFA link.
+  'href' => '//www.eclipse.org/downloads/', // Optional - Replace href on CFA link.
+  'text' => '<i class="fa fa-download"></i> Download' // Optional - Replace text of CFA link.
+);
+
+# Set Solstice theme variables. (Array)
+$App->setThemeVariables($variables);
+
 # Define your project-wide Navigation here
 # This appears on the left of the page if you define a left nav
 # Format is Link text, link URL (can be http://www.someothersite.com/), target (_self, _blank), level (1, 2 or 3)
@@ -67,12 +100,7 @@
 $Menu->addMenuItem("About", "http://www.eclipse.org/projects/project_summary.php?projectid=modeling.gmp.gmf-runtime", "_self");
 $Menu->addMenuItem("Releases", "/gmf-runtime/releases.php", "_self");
 
-# To define additional CSS or other pre-body headers
-$App->AddExtraHtmlHeader('<link rel="stylesheet" type="text/css" href="/gmf-runtime/style.css"/>');
-
 # To enable occasional Eclipse Foundation Promotion banners on your pages (EclipseCon, etc)
 $App->Promotion = TRUE;
 
-# If you have Google Analytics code, use it here
-# $App->SetGoogleAnalyticsTrackingCode("YOUR_CODE");
 ?>
\ No newline at end of file
diff --git a/documentation.php b/documentation.php
index 5e3e623..efa5163 100644
--- a/documentation.php
+++ b/documentation.php
@@ -1,6 +1,6 @@
 <?php
 /*******************************************************************************
- * Copyright (c) 2009, 2013 Eclipse Foundation and others.
+ * Copyright (c) 2009, 2016 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
@@ -19,7 +19,6 @@
 include($App->getProjectCommon());
 
 $pageTitle 		= "GMF Runtime Documentation";
-$App->AddExtraHtmlHeader('<link rel="stylesheet" type="text/css" href="/gmf-runtime/style.css"/>');
 
 $html  = <<<EOHTML
 <div id="midcolumn">
diff --git a/downloads.php b/downloads.php
index 18ebcfc..734407a 100644
--- a/downloads.php
+++ b/downloads.php
@@ -1,6 +1,6 @@
 <?php  																														
 /*******************************************************************************
- * Copyright (c) 2009, 2014 Eclipse Foundation and others.
+ * Copyright (c) 2009, 2016 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
@@ -19,7 +19,6 @@
 include($App->getProjectCommon());
 
 $pageTitle = "GMF Runtime Downloads";
-$App->AddExtraHtmlHeader('<link rel="stylesheet" type="text/css" href="/gmf-runtime/style.css"/>');
 
 $html  = <<<EOHTML
 <div id="midcolumn">
diff --git a/getting_involved.php b/getting_involved.php
index 4cd3417..b1e8e9e 100644
--- a/getting_involved.php
+++ b/getting_involved.php
@@ -1,6 +1,6 @@
 <?php
 /*******************************************************************************
- * Copyright (c) 2009, 2013 Eclipse Foundation and others.
+ * Copyright (c) 2009, 2016 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
@@ -19,7 +19,6 @@
 include($App->getProjectCommon());
 
 $pageTitle 		= "GMF Runtime Getting Involved";
-$App->AddExtraHtmlHeader('<link rel="stylesheet" type="text/css" href="/gmf-runtime/style.css"/>');
 
 $html  = <<<EOHTML
 <div id="midcolumn">
diff --git a/images/backgroundMain.png b/images/backgroundMain.png
index 3136946..6d4a54e 100644
--- a/images/backgroundMain.png
+++ b/images/backgroundMain.png
Binary files differ
diff --git a/images/buttonDocumentation.png b/images/buttonDocumentation.png
deleted file mode 100644
index bbfdde0..0000000
--- a/images/buttonDocumentation.png
+++ /dev/null
Binary files differ
diff --git a/images/buttonDocumentation_sel.png b/images/buttonDocumentation_sel.png
deleted file mode 100644
index 8affb93..0000000
--- a/images/buttonDocumentation_sel.png
+++ /dev/null
Binary files differ
diff --git a/images/buttonDownload.png b/images/buttonDownload.png
deleted file mode 100644
index e620092..0000000
--- a/images/buttonDownload.png
+++ /dev/null
Binary files differ
diff --git a/images/buttonDownload_sel.png b/images/buttonDownload_sel.png
deleted file mode 100644
index d3a0330..0000000
--- a/images/buttonDownload_sel.png
+++ /dev/null
Binary files differ
diff --git a/images/buttonInvolved.png b/images/buttonInvolved.png
deleted file mode 100644
index b3e9a82..0000000
--- a/images/buttonInvolved.png
+++ /dev/null
Binary files differ
diff --git a/images/buttonInvolved_sel.png b/images/buttonInvolved_sel.png
deleted file mode 100644
index 346a452..0000000
--- a/images/buttonInvolved_sel.png
+++ /dev/null
Binary files differ
diff --git a/images/buttonSupport.png b/images/buttonSupport.png
deleted file mode 100644
index bd36086..0000000
--- a/images/buttonSupport.png
+++ /dev/null
Binary files differ
diff --git a/images/buttonSupport_sel.png b/images/buttonSupport_sel.png
deleted file mode 100644
index a535fe8..0000000
--- a/images/buttonSupport_sel.png
+++ /dev/null
Binary files differ
diff --git a/index.php b/index.php
index 240fa11..aedd559 100644
--- a/index.php
+++ b/index.php
@@ -1,6 +1,6 @@
 <?php
 /*******************************************************************************
- * Copyright (c) 2009, 2013 Eclipse Foundation and others.
+ * Copyright (c) 2009, 2016 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
@@ -16,28 +16,86 @@
 $App = new App();
 $Nav = new Nav();
 $Menu = new Menu();
-include($App->getProjectCommon());
+require_once('_projectCommon.php');
 
-$localVersion = false;
+$pageTitle = "Eclipse GMF Runtime";
+$pageKeywords = "Eclipse, Graphical, Modeling, Framework, GMF, Runtime, Project";
+$pageAuthor = "Anthony Hunter";
 
-$pageTitle 		= "Eclipse GMF Runtime";
+# Initialize custom solstice $variables.
+$variables = array();
+
+# Add classes to <body>. (String)
+$variables['body_classes'] = '';
+
+# Insert custom HTML in the breadcrumb region. (String)
+$variables['breadcrumbs_html'] = "";
+
+# Hide the breadcrumbs. (Bool)
+$variables['hide_breadcrumbs'] = FALSE;
+
+# Insert HTML before the left nav. (String)
+$variables['leftnav_html'] = '';
+
+# Update the main container class (String)
+$variables['main_container_classes'] = 'container';
+
+# Insert HTML after opening the main content container, before the left sidebar. (String)
+$variables['main_container_html'] = '';
+
+# Insert header navigation for project websites.
+$links = array();
+$links[] = array(
+  'icon' => 'fa-download', // Required
+  'url' => 'downloads.php', // Required
+  'title' => 'Download', // Required
+  'text' => 'Update Sites, P2 Repositories, SDK downloads, Nightly Builds, Translations' // Optional
+);
+
+$links[] = array(
+  'icon' => 'fa-users', // Required
+  'url' => 'getting_involved.php', // Required
+  'title' => 'Geting Involved', // Required
+  'text' => 'Git, Contributor Mailing List, Wiki, Committers' // Optional
+);
+
+$links[] = array(
+  'icon' => 'fa-book', // Required
+  'url' => 'documentation.php', // Required
+  'title' => 'Documentation', // Required
+  'text' => 'Online Reference, EMF Wiki' // Optional
+);
+
+$links[] = array(
+  'icon' => 'fa-support', // Required
+  'url' => 'support.php', // Required
+  'title' => 'Support', // Required
+  'text' => 'EMF Query FAQ, Forum, Newsgroup, Bugzilla' // Optional
+);
+
+$variables['header_nav'] = array(
+  'links' =>  $links, // Required
+  'logo' => array( // Required
+    'src' => 'images/backgroundMain.png', // Required
+    'alt' => 'EMF Query', // Optional
+    'url' => 'http://www.eclipse.org/emf-query', // Optional
+  ),
+);
+
+// CFA Link - Big orange button in header
+$variables['btn_cfa'] = array(
+  'hide' => FALSE, // Optional - Hide the CFA button.
+  'html' => '', // Optional - Replace CFA html and insert custom HTML.
+  'class' => 'btn btn-huge btn-warning', // Optional - Replace class on CFA link.
+  'href' => '//www.eclipse.org/downloads/', // Optional - Replace href on CFA link.
+  'text' => '<i class="fa fa-download"></i> Download' // Optional - Replace text of CFA link.
+);
+
+# Set Solstice theme variables. (Array)
+$App->setThemeVariables($variables);
 
 // 	# Paste your HTML content between the EOHTML markers!
 $html = <<<EOHTML
-<div id="bigbuttons">
-<h3>Primary Links</h3>
-<ul>
-<li><a id="buttonDownload" href="downloads.php" title="Download">
-	Downloads, Software Install Site</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">
-	Bug Tracker, Newsgroup</a></li>
-<li><a id="buttonInvolved" href="getting_involved.php" title="Getting Involved">
-	git, Workspace Setup, Wiki, Committers</a></li>
-</ul>
-</div>
-
 <div id="midcolumn">
 <h3>Eclipse Graphical Modeling Framework (GMF) Runtime</h3>
 
@@ -56,20 +114,20 @@
 
 <div id="rightcolumn">
 
-<div>
-<h3>Current Status</h3>
+<div class="sideitem">
+<h2>Current Status</h2>
 <p>Development is underway for the proposed GMF Runtime 1.10.0 release for Eclipse Neon, due June 2016.</p>
 </div>
 
-<div id="headlines">
-<h3>GMF Runtime 1.9.0 Now Available</h3>
-<p><i>June 24, 2015 -</i> GMF Runtime 1.9.0 for Eclipse Mars has been released. Check the <a href="/gmf-runtime/downloads.php">Downloads</a> page.</p
+<div class="sideitem">
+<h2>GMF Runtime 1.9.0 Now Available</h2>
+<p><i>June 24, 2015 -</i> GMF Runtime 1.9.0 for Eclipse Mars has been released. Check the <a href="downloads.php">Downloads</a> page.</p
 </div>
 
 </div>
 EOHTML;
 
 # Generate the web page
-$App->generatePage($theme, $Menu, null, $pageAuthor, $pageKeywords, $pageTitle, $html);
+$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
 
 ?>
diff --git a/releases.php b/releases.php
index d0fba54..0676a9f 100644
--- a/releases.php
+++ b/releases.php
@@ -1,6 +1,6 @@
 <?php
 /*******************************************************************************
- * Copyright (c) 2009, 2014 Eclipse Foundation and others.
+ * Copyright (c) 2009, 2016 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
@@ -19,7 +19,6 @@
 include($App->getProjectCommon());
 
 $pageTitle 		= "Eclipse GMF Runtime Project Releases";
-$App->AddExtraHtmlHeader('<link rel="stylesheet" type="text/css" href="/gmf-runtime/style.css"/>');
 
 $html  = <<<EOHTML
 <div id="midcolumn">
diff --git a/style.css b/style.css
deleted file mode 100644
index 75d277a..0000000
--- a/style.css
+++ /dev/null
@@ -1,181 +0,0 @@
-@CHARSET "UTF-8";
-#novaContent {
-	background: url("images/backgroundMain.png") no-repeat;
-	padding-top: 210px;
-}
-
-#midcolumn {
-	width: 640px;
-	padding: 0 10px 10px 10px;
-}
-
-#rightcolumn {
-	width: 260px;
-}
-
-
-h3 {
-	clear: both;
-}
-
-h7 {
-	font-weight: bold;
-	padding: 5px;
-}
-
-a strong {
-	text-decoration: underline;
-}
-
-img.displayed {
-	display: block;
-	margin-left: auto;
-	margin-right: auto;
-}
-
-#novaContent {
-	background: url("images/backgroundMain.png") no-repeat white;
-	padding-top: 170px;
-}
-
-#introText p.left {
-	width: 48%;
-	float: left;
-}
-
-#introText p.right {
-	width: 48%;
-	float: right;
-}
-
-#feature_1 {
-	float: left;
-	width: 30%;
-	margin-right: 3%;
-}
-
-#feature_2 {
-	float: left;
-	width: 30%;
-	margin-right: 3%
-}
-
-#feature_3 {
-	float: left;
-	width: 30%;
-}
-
-#feature_4 {
-	clear: both;
-	float: left;
-	width: 63%;
-	margin-right: 3%;	
-}
-
-#feature_more {
-	float: left;
-	width: 30%;
-}
-	
-#bigbuttons {
-	position: relative;
-	left: 420px;
-	top: -170px;
-}
-#bigbuttons h3{
-	visibility: hidden;
-}
-
-#bigbuttons a {
-}
-
-#bigbuttons ul li {
-   display:block;
-   list-style-type:none;
-   background-color: red;
-   padding: 0;
-   margin: 0;
-}
-
-#bigbuttons a:hover {
-	text-decoration: none;
-}
-
-#bigbuttons a {
-   display: block;
-   height:77px; width:250px;
-   padding: 0;
-   margin: 20px;
-   text-indent: -9000px;
-   position: absolute;
-}
-
-#buttonDownload {
-   background:transparent url("images/buttonDownload.png") no-repeat 0 0;
-   top: 0px;
-   left: 0px;
-}
-
-#buttonDownload:hover {
-   background:transparent url("images/buttonDownload_sel.png") no-repeat 0 0;
-}
-
-   
-#buttonDocumentation {
-   background:transparent url("images/buttonDocumentation.png") no-repeat 0 0;
-   top: 87px;
-   left: 0px;
-}
-
-#buttonDocumentation:hover {
-   background:transparent url("images/buttonDocumentation_sel.png") no-repeat 0 0;
-}
-
-#buttonSupport {
-   background:transparent url("images/buttonSupport.png") no-repeat 0 0;
-   top: 0px;
-   left: 280px;
-}
-
-#buttonSupport:hover {
-   background:transparent url("images/buttonSupport_sel.png") no-repeat 0 0;
-}
-
-#buttonInvolved {
-   background:transparent url("images/buttonInvolved.png") no-repeat 0 0;
-   top: 87px;
-   left: 280px;
-}
-
-#buttonInvolved:hover {
-   background:transparent url("images/buttonInvolved_sel.png") no-repeat 0 0;
-}
-
-#bigbuttons a * {
-	visibility: hidden;
-}
-
-#headlines {
-}
-
-#headlines ul li {
-	margin: 0 0;
-	list-style-type: none;
-	list-style-image: none;
-}
-
-	
-#headlines div.title {
-	display: inline;
-	margin-right: 0.5em;
-}
-
-#headlines div.meta {
-	display: inline;
-	color: #444444;
-	font-size: smaller;  
-}
-
-#headlines div.item {
-	display: block;
-}
\ No newline at end of file
diff --git a/support.php b/support.php
index dd969e8..d1021ba 100644
--- a/support.php
+++ b/support.php
@@ -1,6 +1,6 @@
 <?php
 /*******************************************************************************
- * Copyright (c) 2009, 2013 Eclipse Foundation and others.
+ * Copyright (c) 2009, 2016 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
@@ -19,7 +19,6 @@
 include($App->getProjectCommon());
 
 $pageTitle 		= "GMF Runtime Support";
-$App->AddExtraHtmlHeader('<link rel="stylesheet" type="text/css" href="/gmf-runtime/style.css"/>');
 
 $html  = <<<EOHTML
 <div id="midcolumn">
