diff --git a/content/index.html b/content/index.html
index fc800ed..1cf1948 100644
--- a/content/index.html
+++ b/content/index.html
@@ -7,7 +7,7 @@
 			Agreement</a> unless otherwise specified.
 	</p>
 
-	<h2>There are three ways to install Eclipse Papyrus for Real Time
+	<h2>There are four ways to install Eclipse Papyrus for Real Time
 		(Papyrus-RT):</h2>
 
 	<ol>
@@ -15,35 +15,107 @@
 			The RCP is an all-inclusive self-contained archive (zip) of
 			Papyrus-RT<br />
 			<ul>
-				<li>Pros: simple three-step: download, extract, start working
-					with Papyrus-RT!</li>
-				<li>Cons: larger file to download</li>
+				<li>Pros: Simple three-step installation: download, extract, start working
+					with Papyrus-RT! All dependencies are included.</li>
+				<li>Cons: Larger file to download. No bundle sharing.</li>
 			</ul></li>
-		<li><em>Using the <a href="#Installer">Papyrus-RT
+		<li><em>Using the <a href="#PapyrusRTInstaller">Papyrus-RT
 					Installer</a></em><br /> The Papyrus-RT installer is powered by Oomph, the
 			same technology used by the Eclipse Installer.
 			<ul>
-				<li>Pros: support for bundle pooling, managed workspaces, and
-					automatic updates</li>
-				<li>Cons: You have to answers a few simple questions</li>
+				<li>Pros: All dependencies are automatically installed. Support for bundle pooling 
+					(saves disk space), managed workspaces, and automatic updates.</li>
+				<li>Cons: You have to answers a few simple questions.</li>
 			</ul></li>
-		<li><em>Using <a href="#UpdateSites">update sites</a></em><br />
-			This approach is for the Eclipse veterans who are not afraid of the
-			Eclipse Installer, understand what we mean by "p2", and need to
-			install Papyrus-RT with other Eclipse projects!
+		<li><em>Using the <a href="#EclipseInstaller">Eclipse Installer</a></em><br />
+					This approach is similar to the Papyrus-RT installer above but it is based on the base
+			Eclipse Installer.
 			<ul>
-				<li>Pros: Complete control of what will be part of the
-					installation, including other Eclipse projects!</li>
+				<li>Pros: Increased control of what will be part of the
+					installation, including other Eclipse projects.</li>
 				<li>Cons: Increased complexity in the installation process with
 					boxes to check and more questions to answer.</li>
 			</ul></li>
+		<li><em>Manual installation using <a href="#UpdateSites">update sites</a></em><br />
+			This approach is for the Eclipse veterans who are familiar with installing features and
+			plugins in Eclipse, understand what we mean by "p2", and need to install Papyrus-RT with 
+			other Eclipse projects.
+			<ul>
+				<li>Pros: Full control of what will be part of the
+					installation, including other projects.</li>
+				<li>Cons: Increased complexity in the installation process. 
+					Dependencies must be installed separately.</li>
+			</ul></li>
+			
 	</ol>
 
-	<h2>Current release: Papyrus-RT 0.9.0 on Eclipse Neon.3
+	<h2>Current release: Papyrus-RT 1.0.0 on Eclipse Oxygen
 		(Recommended)</h2>
 
 	<h3 id="RCP">Papyrus-RT all-in-one RCP</h3>
 
+	<p>Download one of the packages below for your operating system, and follow the following instructions:
+	<a href="https://wiki.eclipse.org/Papyrus-RT/User/User_Guide/Papyrus-RT_RCP">Installing the Papyrus-RT RCP</a>.
+
+	<ul>
+		<li><a
+			href="https://www.eclipse.org/downloads/download.php?file=/papyrus-rt/rcp/releases/oxygen/1.0.0/org.eclipse.papyrusrt.rcp.product-linux.gtk.x86_64.zip">
+				Linux</a> (Zip file; 353MB)</li>
+		<li><a
+			href="https://www.eclipse.org/downloads/download.php?file=/papyrus-rt/rcp/releases/oxygen/1.0.0/org.eclipse.papyrusrt.rcp.product-win32.win32.x86_64.zip">
+				Windows</a> (Zip file; 355MB)</li>
+		<li><a
+			href="https://www.eclipse.org/downloads/download.php?file=/papyrus-rt/rcp/releases/oxygen/1.0.0/org.eclipse.papyrusrt.rcp.product-macosx.cocoa.x86_64.zip">
+				macOS</a> (Zip file; 355MB)</li>
+	</ul>
+
+	<h3 id="#PapyrusRTInstaller">Papyrus-RT Installer</h3>
+
+	<p>Download one of the packages below for your operating system, and follow the following instructions:
+	<a href="https://wiki.eclipse.org/Papyrus-RT/User/User_Guide/Papyrus-RT_Installer">Installing Papyrus-RT using the Papyrus-RT Installer</a>.
+
+	<ul>
+		<li><a
+			href="https://www.eclipse.org/downloads/download.php?file=/papyrus-rt/installer/updates/Papyrus-RT-Installer-linux64.tar.gz">
+				Linux</a> (Gzipped Tar file; 48MB)</li>
+		<li><a
+			href="https://www.eclipse.org/downloads/download.php?file=/papyrus-rt/installer/updates/Papyrus-RT-Installer-win64.exe">
+				Windows</a> (Self-extracting exe file; 49MB)</li>
+		<li><a
+			href="https://www.eclipse.org/downloads/download.php?file=/papyrus-rt/installer/updates/Papyrus-RT-Installer-mac64.zip">
+				macOS</a> (Zip file; 49MB)</li>
+	</ul>
+
+	<h3 id="#EclipseInstaller">Eclipse Installer</h3>
+	
+	<p>Download the Eclipse installer from the <a href="https://wiki.eclipse.org/Eclipse_Installer">Eclipse Installer Wiki</a>
+	or from the <a href="https://www.eclipse.org/downloads/eclipse-packages/">Eclipse downloads page</a> and follow the following 
+	instructions: <a href="https://wiki.eclipse.org/Papyrus-RT/User/User_Guide/Eclipse_Installer">Installing Papyrus for Real Time using the Eclipse Installer</a>.
+
+	<h3 id="#UpdateSites">Update sites</h3>
+
+	<p style="font-weight: bold; color: red;">Note: 
+		If you follow this approach, you will have to manually install dependencies.
+	</p>
+
+	Install some Eclipse platform from the <a href="https://www.eclipse.org/downloads/eclipse-packages/">Eclipse downloads page</a>, 
+	and, using the update site link below, follow the following instructions: 
+	<a href="https://help.eclipse.org/oxygen/index.jsp?topic=%2Forg.eclipse.platform.doc.user%2Ftasks%2Ftasks-124.htm">Installing new software</a>.
+	
+	<ul>
+		<li>Release 1.0.0 update site: <a
+			href="http://download.eclipse.org/papyrus-rt/updates/releases/oxygen/1.0.0/">http://download.eclipse.org/papyrus-rt/updates/releases/oxygen/1.0.0/</a>
+		</li>
+	</ul>
+	
+	
+
+	<h2>Older releases</h2>
+
+	<h3>Papyrus-RT 0.9.0</h3>
+
+	<h4 id="RCP">Papyrus-RT all-in-one RCP</h4>
+
 	<ul>
 		<li><a
 			href="https://www.eclipse.org/downloads/download.php?file=/papyrus-rt/rcp/releases/neon/0.9.0/org.eclipse.papyrusrt.rcp.product-linux.gtk.x86_64.zip">
@@ -56,7 +128,7 @@
 				macOS</a> (Gzipped Tar file; 303MB)</li>
 	</ul>
 
-	<h3 id="Installer">Papyrus-RT Installer</h3>
+	<h4 id="Installer">Papyrus-RT Installer</h4>
 
 	<ul>
 		<li><a
@@ -70,7 +142,7 @@
 				macOS</a> (Zip file; 48MB)</li>
 	</ul>
 
-	<h3 id="UpdateSites">Update sites</h3>
+	<h4 id="UpdateSites">Update sites</h4>
 
 	<ul>
 		<li>Release 0.9.0 update site: <a
@@ -79,59 +151,6 @@
 
 	</ul>
 
-	<h2>Older releases</h2>
-
-	<h3>Papyrus-RT 0.8.0</h3>
-
-	<h4 id="RCP">Papyrus-RT all-in-one RCP</h4>
-
-	<ul>
-		<li><a
-			href="https://www.eclipse.org/downloads/download.php?file=/papyrus-rt/rcp/releases/neon/0.8.0/org.eclipse.papyrusrt.rcp.product-linux.gtk.x86_64.zip">
-				Linux</a> (Zip file; 288MB)</li>
-		<li><a
-			href="https://www.eclipse.org/downloads/download.php?file=/papyrus-rt/rcp/releases/neon/0.8.0/org.eclipse.papyrusrt.rcp.product-win32.win32.x86_64.zip">
-				Windows</a> (Zip file; 288MB)</li>
-		<li><a
-			href="https://www.eclipse.org/downloads/download.php?file=/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)</li>
-	</ul>
-
-	<h4 id="Installer">Papyrus-RT Installer</h4>
-
-	<ul>
-		<li><a
-			href="https://www.eclipse.org/downloads/download.php?file=/papyrus-rt/installer/updates/Papyrus-RT-Installer-linux64.tar.gz">
-				Linux</a> (Gzipped Tar file; 45MB)</li>
-		<li><a
-			href="https://www.eclipse.org/downloads/download.php?file=/papyrus-rt/installer/updates/Papyrus-RT-Installer-win64.exe">
-				Windows</a> (Self-extracting exe file; 45MB)</li>
-		<li><a
-			href="https://www.eclipse.org/downloads/download.php?file=/papyrus-rt/installer/updates/Papyrus-RT-Installer-mac64.zip">
-				macOS</a> (Zip file; 46MB)</li>
-	</ul>
-
-	<h4 id="UpdateSites">Update sites</h4>
-
-	<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>
-
-<!-- 	<h3>Papyrus-RT 0.7.X</h3>
-
-	<h4>Update sites</h4>
-
-	<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/0.7.2</a>
-		</li>
-	</ul>
- -->
-
 	<h2>Nightly builds</h2>
 
 	<p style="font-weight: bold; color: red; background-color: yellow;">
@@ -139,10 +158,10 @@
 		It might be unstable and contain any kind of errors.
 	</p>
 
-	<h3>Update sites</h3>
+	<h3>Nightly update site</h3>
 	<ul>
-		<li>Update site: <a
-			href="http://download.eclipse.org/papyrus-rt/updates/nightly/neon/">http://download.eclipse.org/papyrus-rt/updates/nightly/neon/</a>
+		<li><a
+			href="http://download.eclipse.org/papyrus-rt/updates/nightly/oxygen/">http://download.eclipse.org/papyrus-rt/updates/nightly/oxygen/</a>
 		</li>
 	</ul>
 
diff --git a/content/main.html b/content/main.html
index acc137b..413b115 100644
--- a/content/main.html
+++ b/content/main.html
@@ -19,7 +19,7 @@
 		<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>
+						supporting runtime system and model-compare (diff/merge) capabilities.</p>
 				<p>
 						For more details, see the <a
 								href="/papyrus-rt/content/overview.php"
@@ -27,6 +27,23 @@
 				</p>
 		</div>
 
+		<h3>UML-RT in a nutshell</h3>
+
+
+		<div id="introText">
+				<p>UML-RT is a modelling language intended for real-time and embedded systems.</p>
+				<p>It considerably simplifies the UML language while introducing a few new concepts.
+				The main concepts of UML-RT are <em>capsules</em> and <em>protocols</em>.</p> 
+				<p>A <em>capsule</em> is an active class that defines concurrent behaviour (similar to a thread).
+				It's behaviour may be specified with a (hierarchical) state machine. A capsule has an interface consisting of 
+				one or more <em>ports</em> that are typed by a <em>protocol</em>. A <em>protocol</em> defines the set of
+				messages that may be sent and received by the port and processed by its state machine.
+				A capsule may also have internal structure consisting of static or dynamic <em>parts</em> that contain instances of other
+				capsules. <em>Connectors</em> are used to link their ports.</p>
+				<p>UML-RT also supports the notion of <em>service ports</em> and includes a built-in <em>services library</em>
+				that provides communication, timing, logging and dynamic structure services.</p>
+		</div>
+
 
 		<h3>Some highlights</h3>
 
@@ -103,22 +120,33 @@
 						</tr>
 				</table>
 		</div>
+
+		<br>
+
+		<div id="highlights">
+				<table>
+						<tr>
+								<th width="22.5%"></th>
+								<th width="50%"><h4>Model compare</h4></th>
+								<th width="22.5%"></th>
+						</tr>
+						<tr>
+								<th width="22.5%"></th>
+								<td width="55%" valign="top">
+										<p align="justify">
+										The model-compare capability allows you to compare and merge different versions
+										of a model at the same abstraction level as the modelling experience, providing
+										integration with source control, specially EGit.</p>
+								</td>
+								<th width="22.5%"></th>
+						</tr>
+				</table>
+		</div>
+
 </div>
 
 <div id="rightcolumn">
 
-		<div id="incubation" class="sideitem">
-				<h3>Incubation</h3>
-				<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 id="quicklinks" class="sideitem">
 				<h3>Quick Links</h3>
 				<ul>
@@ -135,40 +163,28 @@
 
 				<h3>News</h3>
 				<p>
+						<b>2017-07-20</b>: <b><em>Papyrus-RT 1.0.0</em> released.</b> 
+						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/Oxygen_v1.0_Release_Notes"
+						>Release notes</a>.
+				</p>
+				<p>
 						<b>2017-03-23</b>: <em>Papyrus-RT 0.9.0</em> 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.9_Release_Notes"
 						>Release notes</a>.
 				</p>
-				<p>
-						<b>2016-03-01</b>: Altough Papyrus-RT is not part of the Eclipse
-						Release train, we will endeavour to align with it for the next two
-						releases (as seen in the <a
-								href="https://wiki.eclipse.org/Papyrus-RT/Roadmap"
-						>Papyrus-RT Roadmap</a>):</p>
-				<ul>
-						<li><a
-								href="https://wiki.eclipse.org/Papyrus-RT/Releases#Papyrus-RT_MVP2_.28v0.9.29_-_Better_behave.21"
-						>Papyrus-RT v0.9</a> is planned to be released with Neon.3 (+4)</li>
-						<li><a
-								href="https://wiki.eclipse.org/Papyrus-RT/Releases#Papyrus-RT_MVP2.1_.28v1.0.29_-_Better_behave_with_Oxygen.21"
-						>Papyrus-RT v1.0</a> is planned to be released with Oxygen (+4)</li>
-				</ul>
-
-				<p>
-						<b>2016-10-24</b>: <em>Papyrus-RT 0.8.0</em> 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>.
-				</p>
 		</div>
 
 		<div id="history>" class="sideitem">
 				<h3>History</h3>
 
 				<p>
+						<b>Papyrus-RT 1.0.0</b> released July 20th, 2017.
+				</p>
+				<p>
 						<b>Papyrus-RT 0.9.0</b> released March 23rd, 2017.
 				</p>
 				<p>
