diff --git a/content/images/Papyrus-RT-0.8-screenshot.png b/content/images/Papyrus-RT-0.8-screenshot.png
new file mode 100644
index 0000000..ee9a50d
--- /dev/null
+++ b/content/images/Papyrus-RT-0.8-screenshot.png
Binary files differ
diff --git a/content/images/Papyrus-RT-logo-full.png b/content/images/Papyrus-RT-logo-full.png
new file mode 100644
index 0000000..7287e33
--- /dev/null
+++ b/content/images/Papyrus-RT-logo-full.png
Binary files differ
diff --git a/content/images/Papyrus-RT-logo-icon.png b/content/images/Papyrus-RT-logo-icon.png
new file mode 100644
index 0000000..4e96e80
--- /dev/null
+++ b/content/images/Papyrus-RT-logo-icon.png
Binary files differ
diff --git a/content/index.html b/content/index.html
index c95cc22..e167f9a 100644
--- a/content/index.html
+++ b/content/index.html
@@ -1,64 +1,103 @@
 <div id="midcolumn">
 
-<h1>Downloads</h1>
-<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>
+	<h1>Downloads</h1>
+	<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>
 
-<!-- ReleaseCheck -->
+	<!-- ReleaseCheck -->
 
+	There are alternative ways to install Papyrus-RT:
 
+	<ol>
+		<li>Install the Papyrus-RT RCP (a self-contained zip file, with
+			all included)
+		<li>Using the Papyrus-RT Installer (powered by Oomph, supporting bundle pooling, managed workspaces and automatic updates)
+ 		<li>Using p2 update sites
+	</ol>
 
-<h2>Release Builds</h2>
-<!-- TargetCheck -->
-<p>The Papyrus-RT releases (based on Mars) can be found here:</p>
-<ul>
+	<h2>Current release (Papyrus-RT 0.8.0 on Eclipse Neon)
+		(Recommended)</h2>
 
-	<li>Current release (0.7.2) Update site: <a href="http://download.eclipse.org/papyrus-rt/updates/releases/mars/0.7.2">http://download.eclipse.org/papyrus-rt/updates/releases/mars</a>
-	</li>
+	<h3>Papyrus-RT all-in-one RCP</h3>
 
+	<ul>
+		<li><a
+			href="http://download.eclipse.org/papyrus-rt/rcp/releases/neon/0.8.0/org.eclipse.papyrusrt.rcp.product-linux.gtk.x86_64.zip">
+				Linux</a> (Zip file; 288MB)
+		<li><a
+			href="http://download.eclipse.org/papyrus-rt/rcp/releases/neon/0.8.0/org.eclipse.papyrusrt.rcp.product-win32.win32.x86_64.zip">
+				Windows</a> (Zip file; 288MB)
+		<li><a
+			href="http://download.eclipse.org/papyrus-rt/rcp/releases/neon/0.8.0/org.eclipse.papyrusrt.rcp.product-macosx.cocoa.x86_64.tar.gz">
+				macOS</a> (Gzipped Tar file; 286MB)
+	</ul>
 
-	<li>Release 0.7.1 Update site: <a href="http://download.eclipse.org/papyrus-rt/updates/releases/mars/0.7.1">http://download.eclipse.org/papyrus-rt/updates/releases/mars/0.7.1</a>
-	</li>
+	<h3>Papyrus-RT Installer</h3>
 
-	<li>Release 0.7.0 Update site: <a href="http://download.eclipse.org/papyrus-rt/updates/releases/mars/0.7.0">http://download.eclipse.org/papyrus-rt/updates/releases/mars/0.7.0</a>
-	</li>
-
-</ul>
-<h2>Nightly Build</h2>
-<!-- TargetCheck -->
-<p>The Papyrus-RT nightly (dev) version (based on Mars) can be found here:</p>
-<ul>
-	
-	<li>Update site: <a href="http://download.eclipse.org/papyrus-rt/builds/nightly">http://download.eclipse.org/papyrus-rt/builds/nightly</a>
-	</li>
-	<li>ZIP file: <a href="http://download.eclipse.org/papyrus-rt/builds/archive.zip">http://download.eclipse.org/papyrus-rt/builds/archive.zip</a>
-	</li>
-</ul>
-
-<!-- 
-<p>Papyrus-RT nightly builds can be installed on top of any <a href="https://www.eclipse.org/downloads/packages/eclipse-modeling-tools/marsr">Eclipse Modeling tools Mars package</a>:</p>
-<ul>
-	<li>Download and extract one of the Mars packages which support the Papyrus Modeling tools</li>
-	<li>Start Eclipse</li>
-	<li>Help > Install New Software...</li>
-	<li>Enter the <a href="http://download.eclipse.org/papyrus-rt/builds/nightly">Papyrus-RT Nightly Build Update Site</a>
-	    into the 'Work with' field</li>
-	<li>Select all items of 'Uncategorized'</li>
-	<li>Accept the installation of unsigned content</li>
-	<li>Restart</li>
-	<li>Done!</li>
-</ul>
--->
-
-<p>Please keep in mind that this is the head development version! It
-might be unstable and contain any kind of errors.</p>
-
-
-</div>
-
-
-
-
-</div>
+	<ul>
+		<li><a
+			href="http://download.eclipse.org/papyrus-rt/installer/updates/Papyrus-RT-Installer-linux64.tar.gz">
+				Linux</a> (Gzipped Tar file; 45MB)
+		<li><a
+			href="http://download.eclipse.org/papyrus-rt/installer/updates/Papyrus-RT-Installer-win64.exe">
+				Windows</a> (Self-extracting exe file; 46MB)
+		<li><a
+			href="http://download.eclipse.org/papyrus-rt/installer/updates/Papyrus-RT-Installer-mac64.zip">
+				macOS</a> (Zip file; 46MB)
+	</ul>
  
+	<h3>Update sites</h3>
+
+	<ul>
+
+		<li>Release 0.8.0 update site: <a
+			href="http://download.eclipse.org/papyrus-rt/updates/releases/neon/0.8.0/">http://download.eclipse.org/papyrus-rt/updates/releases/neon/0.8.0/</a>
+		</li>
+
+	</ul>
+
+	<h2>Older releases</h2>
+
+	<h3>Update sites</h3>
+
+	<ul>
+
+		<li>Release 0.7.2 (Mars) update site: <a
+			href="http://download.eclipse.org/papyrus-rt/updates/releases/mars/0.7.2">http://download.eclipse.org/papyrus-rt/updates/releases/mars</a>
+		</li>
+
+
+		<li>Release 0.7.1 (Mars) update site: <a
+			href="http://download.eclipse.org/papyrus-rt/updates/releases/mars/0.7.1">http://download.eclipse.org/papyrus-rt/updates/releases/mars/0.7.1</a>
+		</li>
+
+		<li>Release 0.7.0 (Mars) update site: <a
+			href="http://download.eclipse.org/papyrus-rt/updates/releases/mars/0.7.0">http://download.eclipse.org/papyrus-rt/updates/releases/mars/0.7.0</a>
+		</li>
+
+	</ul>
+
+
+	<h2>Nightly builds</h2>
+	<h3>Update sites</h3>
+	<ul>
+		<li>Update site: <a
+			href="http://download.eclipse.org/papyrus-rt/builds/nightly">http://download.eclipse.org/papyrus-rt/builds/nightly</a>
+		</li>
+	</ul>
+
+
+	<p>Please keep in mind that this is the head development version!
+		It might be unstable and contain any kind of errors.</p>
+
+
+</div>
+
+
+
+
+</div>
+
diff --git a/content/main.html b/content/main.html
index 586c4b1..e48c1da 100644
--- a/content/main.html
+++ b/content/main.html
@@ -1,106 +1,162 @@
-<div id="bigbuttons">
-<h3>Primary Links</h3>
-<ul>
-
-</ul>
-</div>
-
 <div id="midcolumn">
 
-<h3>Papyrus-RT - UML-RT Modeling and code generation Tools</h3>
+	<div id="title">
+		<img alt="Papyrus-RT-Logo"
+			src="/papyrus-rt/content/images/Papyrus-RT-logo-full.png">
+	</div>
+
+	<div id="screenshot">
+		<img alt="Papyrus-RT 0.8 screenshot"
+			src="/papyrus-rt/content/images/Papyrus-RT-0.8-screenshot.png"
+			width="800" height="620">
+	</div>
+
+	<h3>Papyrus-RT - UML-RT modelling and code generation environment</h3>
 
 
-<div id="introText">
-<p>Papyrus-RT provides an implementation of the UML-RT modeling language together with editors,
-code generator for C++ and a supporting runtime system. 
-	<p> For more details, see the  <a href="/papyrus-rt/content/overview.php"> Overview section. </a> <br> </p>
-</p>
-
- 
-</div>
+	<div id="introText">
+		<p>Papyrus-RT provides an implementation of the UML-RT modeling
+			language together with editors, code generator for C++ and a
+			supporting runtime system.</p>
+		<p>
+			For more details, see the <a href="/papyrus-rt/content/overview.php">
+				Overview section</a>.
+		</p>
+	</div>
 
 
+	<h3>Some highlights</h3>
 
+	<div id="highlights">
+		<table>
+			<tr>
+				<th width="45%">
+					<h4>Graphical structure editor</h4>
+				</th>
+				<th width="10%"></th>
+				<th width="45%">
+					<h4>Graphical behavior editor</h4>
+				</th>
+			</tr>
+			<tr>
+				<td width="45%" valign="top">
+					<p align="justify">The structure editor allows the user to edit
+						capsule structure in a convenient way. It is possible to create
+						and arrange capsule references and ports and to create bindings
+						and layer connections.</p>
+				</td>
+				<td width="10%"></td>
+				<td width="45%" valign="top">
+					<p align="justify">The behavior editor allows the user to
+						describe capsule behavior by means of a hierarchical finite state
+						machine. It is possible to create and arrange states, choice
+						points, junction points and transitions using the state machine
+						editor.</p>
+				</td>
+			</tr>
+		</table>
+	</div>
 
-  
-<h3>Some Highlights of Papyrus-RT</h3>
+	<br>
 
-<div id="feature_description">
-<h4>Graphical Model Structure Editor</h4>
-<p>
-The Structure Editor allows the user to edit the Capsule Structure in a convenient way.
-It is possible to create and arrange capsule references and ports and to create bindings and layer connections. 
-</p>
-</div>
-
-
-
-<div id="feature_description">
-<h4>Graphical behavior Editor</h4>
-<p>The behavior Editor allows the user to describe the Capsule behavior by means of a hierarchical finite state machine.
-It is possible to create and arrange states, choice points, junction points and transitions using the state machine editor.
-</p>
-
-</div>
-
-<div id="feature_description">
-<h4>Code Generator</h4>
-<p>A code generator will translate the UML-RT model into C++ code. This code generator 
-will translate all structural (e.g., capsules, protocols, and classes) and 
-behavioral (i.e., state machines) elements  into C++ code, based on their 
-properties, stereotypes, stereotype properties (including those from a profile 
-with properties specific to C++), and runtime services elements. For the generation of 
-the behavioral C++ code from the state machines, the code generator will first translate 
-the behavior provided by each capsule's (or passive class') state machine into an intermediate 
-model that will then be translated to optimized code. Based on user-provided thread allocation 
-information, the code generator will also allocate capsules, or groups of capsules,  to threads.</p>
-</div>
-
-<div id="feature_description">
-<h4>C++ Runtime services support</h4>
-<p>The C++ Runtime Services Library provides support for the execution of the C++ code generated from a UML-RT model. Capsule lifecycle 
-functions (incarnate, destroy, import, deport), message delivery and timing services are provided by the services libary and are used by both the 
-generated code as well as the used specifed action code which is part of the capsule behavior. 
-
-The runtime system code is distributed in source form and is an installable feature of Eclipse. A makefile in the RTS folder can be used to compile and link the RTS into
-a library, which is then linked with the compiled UML-RT model. 
-  </p>
-</div>
-
+	<div id="highlights">
+		<table>
+			<tr>
+				<th width="45%"><h4>Code generator</h4></th>
+				<th width="10%"></th>
+				<th width="45%"><h4>C++ runtime services support</h4></th>
+			</tr>
+			<tr>
+				<td width="45%" valign="top">
+					<p align="justify">A code generator will translate the UML-RT
+						model into C++ code. This code generator will translate all
+						structural (e.g., capsules, protocols, and classes) and behavioral
+						(i.e., state machines) elements into C++ code, based on their
+						properties, stereotypes, stereotype properties (including those
+						from a profile with properties specific to C++), and runtime
+						services elements. For the generation of the behavioral C++ code
+						from the state machines, the code generator will first translate
+						the behavior provided by each capsule's (or passive class') state
+						machine into an intermediate model that will then be translated to
+						optimized code. Based on user-provided thread allocation
+						information, the code generator will also allocate capsules, or
+						groups of capsules, to threads.</p>
+				</td>
+				<td width="10%"></td>
+				<td width="45%" valign="top">
+					<p align="justify">The C++ Runtime Services Library provides
+						support for the execution of the C++ code generated from a UML-RT
+						model. Capsule lifecycle functions (incarnate, destroy, import,
+						deport), message delivery and timing services are provided by the
+						services library and are used by both the generated code as well
+						as the user specifed action code which is part of the capsule
+						behaviour. The runtime system code is distributed in source form
+						as an installable Eclipse feature. The code generator produces
+						both standard makefiles as well as CMakeList files to build the
+						generated code.</p>
+				</td>
+			</tr>
+		</table>
+	</div>
 </div>
 
 <div id="rightcolumn">
- 
-<div class="sideitem">
-   <h6>Incubation</h6>
-<a href="/projects/what-is-incubation.php">
-<img align="middle" src="/images/egg-incubation.png" border="0" alt="Incubation" />
-</a>
-        <p>This project is in the <a href="/projects/dev_process/incubation-phase.php">Incubation Phase</a>.</p>
-</div>
 
-<div>
-<h3>Current Status</h3>
-<!-- ReleaseCheck -->
+	<div class="sideitem">
+		<h6>Incubation</h6>
+		<a href="/projects/what-is-incubation.php"> <img align="middle"
+			src="/images/egg-incubation.png" border="0" alt="Incubation" />
+		</a>
+		<p>
+			This project is in the <a
+				href="/projects/dev_process/incubation-phase.php">Incubation
+				Phase</a>.
+		</p>
+	</div>
 
-<p><b>Papyrus-RT 0.8.0</b> planned release October 24th, 2016.</p>
-<p><b>Papyrus-RT 0.7.2</b> released December 15th, 2015. See the <a href="/papyrus-rt/content/download.php">download section</a> for details.</p>
-<p><b>Papyrus-RT 0.7.1</b> released October 12th, 2015.</p>
+	<div>
+		<h3>
+			<a href="/papyrus-rt/content/download.php">Downloads</a>
+		</h3>
 
-<p>See also our
-<a href="https://projects.eclipse.org/projects/modeling.papyrus-rt/releases/0.7.2/plan">project plan</a> 
-for  details of the 0.7.2 release.</p>
+		<h3>
+			<a href="https://wiki.eclipse.org/Papyrus-RT">Wiki</a>
+		</h3>
 
-</div>
+		<h3>News</h3>
+
+		<p>
+			Oct. 24, 2016: <b>Papyrus-RT 0.8.0</b> released. Get it in the <a
+				href="/papyrus-rt/content/download.php">downloads</a> section. See
+			also the <a
+				href="https://wiki.eclipse.org/Papyrus-RT/Releases/Neon_v0.8_Release_Notes">Release
+				notes</a>.
+		
+		<h3>History</h3>
+
+		<p>
+			<b>Papyrus-RT 0.8.0</b> released October 24th, 2016.
+		</p>
+		<p>
+			<b>Papyrus-RT 0.7.2</b> released December 15th, 2015.
+		</p>
+		<p>
+			<b>Papyrus-RT 0.7.1</b> released October 12th, 2015.
+		</p>
+
+	</div>
 
 
 
-<div>
-<h3>More...</h3>
-<ul>
-	<li>Read the <a href="https://projects.eclipse.org/projects/modeling.papyrus-rt"> project proposal</a></li>
-	<li>Join the discussions at the <a href="http://www.eclipse.org/forums/eclipse.Papyrus-RT">forum</a></li>
-</ul>
-</div>
+	<div>
+		<h3>More...</h3>
+		<ul>
+			<li>Read the <a
+				href="https://projects.eclipse.org/projects/modeling.papyrus-rt">
+					project proposal</a></li>
+			<li>Join the discussions at the <a
+				href="http://www.eclipse.org/forums/eclipse.Papyrus-RT">forum</a></li>
+		</ul>
+	</div>
 
 </div>
diff --git a/content/setup/papyrus-rt-developer.setup b/content/setup/papyrus-rt-developer.setup
index ae670db..17cff5e 100644
--- a/content/setup/papyrus-rt-developer.setup
+++ b/content/setup/papyrus-rt-developer.setup
@@ -220,8 +220,6 @@
       <requirement
           name="org.eclipse.papyrus.junit.framework"/>
       <requirement
-          name="org.eclipse.papyrus.designer.languages.cpp.cdt.texteditor"/>
-      <requirement
           name="org.eclipse.egit.feature.group"/>
       <requirement
           name="org.eclipse.emf.compare.diagram.papyrus.feature.group"/>
@@ -674,12 +672,6 @@
             activeRepositoryList="${eclipse.target.platform}">
           <requirement
               name="org.eclipse.cdt.sdk.feature.group"/>
-          <requirement
-              name="org.eclipse.papyrus.designer.languages.common.base"/>
-          <requirement
-              name="org.eclipse.papyrus.designer.languages.common.extensionpoints"/>
-          <requirement
-              name="org.eclipse.papyrus.designer.languages.cpp.library"/>
         </targlet>
       </setupTask>
     </stream>
diff --git a/content/setup/papyrus-rt-tester.setup b/content/setup/papyrus-rt-tester.setup
index c8ce014..4dbffd1 100644
--- a/content/setup/papyrus-rt-tester.setup
+++ b/content/setup/papyrus-rt-tester.setup
@@ -126,14 +126,6 @@
           name="org.eclipse.papyrus.sdk.feature.feature.group"
           versionRange="[2.0.0,3.0.0)"/>
       <requirement
-          name="org.eclipse.papyrus.designer.languages.cpp.cdt.texteditor"/>
-      <requirement
-          name="org.eclipse.papyrus.designer.languages.common.extensionpoints"/>
-      <requirement
-          name="org.eclipse.papyrus.designer.languages.common.base"/>
-      <requirement
-          name="org.eclipse.papyrus.designer.languages.cpp.library"/>
-      <requirement
           name="org.eclipse.egit.feature.group"/>
       <requirement
           name="org.eclipse.emf.compare.diagram.papyrus.feature.group"/>
