diff --git a/_index.html b/_index.html
index 2b401e3..226e4ee 100644
--- a/_index.html
+++ b/_index.html
@@ -1,97 +1,89 @@
-
-<div id="primaryLinks">
-	<h3>Primary Links</h3>
-	<ul>
-		<li>
-			<a id="buttonDownload" href="downloads" title="Download">
-				<strong>Download</strong> Eclipse Distribution, Update Site, Dropins
-			</a>
-		</li>
-		<li>
-			<a id="buttonDocumentation" href="documentation" title="Documentation">
-				<strong>Documentation</strong> Tutorials, Examples, Videos, Reference Documentation
-			</a>
-		</li>
-		<li>
-			<a id="buttonSupport" href="support" title="Support">
-				<strong>Support</strong> Bug Tracker, Newsgroup, Support
-			</a>
-		</li>
-		<li>
-			<a id="buttonInvolved" href="developers" title="Getting Involved">
-				<strong>Getting Involved</strong> Git, Workspace Setup, Wiki, Committers
-			</a>
-		</li>
-	</ul>
-</div>
-
-<div id="midcolumnhome">
-	<br />
-	<h3>ATL - a model transformation technology</h3>
-	<div id="introText">
-	<p class="left">
-		<a href="http://wiki.eclipse.org/MMT/Atlas_Transformation_Language_%28ATL%29">ATL</a> (ATL Transformation Language) is a model transformation language and toolkit. In the field of Model-Driven Engineering (MDE), ATL provides ways to produce a set of target models from a set of source models. 
- 	</p>
-	<p class="right">
-		Developed on top of the Eclipse platform, the ATL Integrated Environnement (IDE) provides a number of standard development tools (syntax highlighting, debugger, etc.) that aims to ease development of ATL transformations.
-	 </p>
-	</div>
-
-	<div id="screencast">
-		<a href="videos/ATL_features.htm" title="ATL editor features overview" rel="nofollow">
-		<img src="images/ATL.png" alt="ATL" width="640" height="480" /></a>
-	</div>
-
-	<h3>What can you do with ATL? </h3>
-	<div id="introText">
-ATL provides a way to produce a number of target models from a set of source models.
-An ATL transformation program is composed of rules that define how source model elements are matched and navigated to create and initialize the elements of the target models.
-You can find more details about the model to model transformation concepts <a href="http://wiki.eclipse.org/ATL/Concepts">here</a>.
-
-	 <br /> <br />    
- 	<div id="screencast">
-	<a href="images/atl_presentation.png"><img src="images/atl_presentation.png" alt="ATL" width="400" height="129" /></a>
-		</div>
-	</div>
-	
-	<div id="feature">
-		<h4>ATL Examples</h4>
-There is a lot of ATL transformations which can be used as reference to develop your own transformations. Families to Persons (<a href="http://www.eclipse.org/atl/documentation/old/ATLUseCase_Families2Persons.pdf">PDF version</a>, <a href="http://www.eclipse.org/atl/documentation/old/ATLUseCase_Families2Persons.ppt">Powerpoint version</a>) is a kind of ATL "Hello World". The <a href="http://www.eclipse.org/atl/documentation/basicExamples_Patterns/">ATL Basic Examples</a> section provides a set of basic examples and patterns.<br/> <br/>
-Advanced examples of ATL use are available as <a href="http://www.eclipse.org/atl/usecases/">use cases</a> and inside of the <a href="http://www.eclipse.org/atl/atlTransformations/">ATL Transformations Zoo</a>.
-	</div>
-	
-	<div id="feature_discovery">
-		<h4>Discovering features...</h4>
-		<p>
-			Read the <a href="documentation">documentation</a>, join the discussion at the
-			<a href="http://www.eclipse.org/forums/index.php?t=thread&frm_id=23&">newsgroup</a>.
-		</p>
-	</div>
-</div>
-
-<div id="rightcolumn">
-	<div class="sideitem" id="obeo">
-		<a href="http://www.obeo.fr" title="Main Obeo website" rel="nofollow"><img src="images/logo/logo_obeo.png"/></a>
-	</div>
-	
-	<div class="sideitem">
-		<h6>Project Summary</h6>
-		<p>
-			Read more <a href="http://www.eclipse.org/projects/project_summary.php?projectid=modeling.mmt.atl">about
-			this project</a> and get all useful information and links about it in a nutshell.
-		</p>
-	</div>
-	
-	<div class="sideitem" id="newAndNoteworthy">
-		<a href="http://wiki.eclipse.org/ATL_3.3.0_New_and_Noteworthy">New and Noteworthy</a>
-	</div>
-	
-	<div class="sideitem">
-%%NEWS%%
-	</div>
-
-<div class="sideitem">
-%%HEADLINES%%
-	</div>
-
-</div>
+
+<div id="primaryLinks">
+	<h3>Primary Links</h3>
+	<ul>
+		<li>
+			<a id="buttonDownload" href="downloads" title="Download">
+				<strong>Download</strong> Eclipse Distribution, Update Site, Dropins
+			</a>
+		</li>
+		<li>
+			<a id="buttonDocumentation" href="documentation" title="Documentation">
+				<strong>Documentation</strong> Tutorials, Examples, Videos, Reference Documentation
+			</a>
+		</li>
+		<li>
+			<a id="buttonSupport" href="support" title="Support">
+				<strong>Support</strong> Bug Tracker, Newsgroup, Support
+			</a>
+		</li>
+		<li>
+			<a id="buttonInvolved" href="developers" title="Getting Involved">
+				<strong>Getting Involved</strong> Git, Workspace Setup, Wiki, Committers
+			</a>
+		</li>
+	</ul>
+</div>
+
+<div id="midcolumnhome">
+	<br />
+	<h3>ATL - a model transformation technology</h3>
+	<div id="introText">
+	<p class="left">
+		<a href="http://wiki.eclipse.org/MMT/Atlas_Transformation_Language_%28ATL%29">ATL</a> (ATL Transformation Language) is a model transformation language and toolkit. In the field of Model-Driven Engineering (MDE), ATL provides ways to produce a set of target models from a set of source models. 
+ 	</p>
+	<p class="right">
+		Developed on top of the Eclipse platform, the ATL Integrated Environnement (IDE) provides a number of standard development tools (syntax highlighting, debugger, etc.) that aims to ease development of ATL transformations.
+	 </p>
+	</div>
+
+	<div id="screencast">
+		<a href="videos/ATL_features.htm" title="ATL editor features overview" rel="nofollow">
+		<img src="images/ATL.png" alt="ATL" width="640" height="480" /></a>
+	</div>
+
+	<h3>What can you do with ATL? </h3>
+	<div id="introText">
+ATL provides a way to produce a number of target models from a set of source models.
+An ATL transformation program is composed of rules that define how source model elements are matched and navigated to create and initialize the elements of the target models.
+You can find more details about the model to model transformation concepts <a href="http://wiki.eclipse.org/ATL/Concepts">here</a>.
+
+	 <br /> <br />    
+ 	<div id="screencast">
+	<a href="images/atl_presentation.png"><img src="images/atl_presentation.png" alt="ATL" width="400" height="129" /></a>
+		</div>
+	</div>
+	
+	<div id="feature">
+		<h4>ATL Examples</h4>
+There is a lot of ATL transformations which can be used as reference to develop your own transformations. Families to Persons (<a href="http://www.eclipse.org/atl/documentation/old/ATLUseCase_Families2Persons.pdf">PDF version</a>, <a href="http://www.eclipse.org/atl/documentation/old/ATLUseCase_Families2Persons.ppt">Powerpoint version</a>) is a kind of ATL "Hello World". The <a href="http://www.eclipse.org/atl/documentation/basicExamples_Patterns/">ATL Basic Examples</a> section provides a set of basic examples and patterns.<br/> <br/>
+Advanced examples of ATL use are available as <a href="http://www.eclipse.org/atl/usecases/">use cases</a> and inside of the <a href="http://www.eclipse.org/atl/atlTransformations/">ATL Transformations Zoo</a>.
+	</div>
+	
+	<div id="feature_discovery">
+		<h4>Discovering features...</h4>
+		<p>
+			Read the <a href="documentation">documentation</a>, join the discussion at the
+			<a href="http://www.eclipse.org/forums/index.php?t=thread&frm_id=23&">newsgroup</a>.
+		</p>
+	</div>
+</div>
+
+<div id="rightcolumn">
+	<div class="sideitem" id="obeo">
+		<a href="http://www.obeo.fr" title="Main Obeo website" rel="nofollow"><img src="images/logo/logo_obeo.png"/></a>
+	</div>
+	
+	<div class="sideitem">
+		<h6>Project Summary</h6>
+		<p>
+			Read more <a href="http://www.eclipse.org/projects/project_summary.php?projectid=modeling.mmt.atl">about
+			this project</a> and get all useful information and links about it in a nutshell.
+		</p>
+	</div>
+	
+	<div class="sideitem" id="newAndNoteworthy">
+		<a href="https://projects.eclipse.org/projects/modeling.mmt.atl/releases/4.0">New and Noteworthy</a>
+	</div>
+	
+</div>
diff --git a/index.php b/index.php
index 65537fd..7c9d8c0 100644
--- a/index.php
+++ b/index.php
@@ -9,14 +9,6 @@
 	
 	$html = file_get_contents('_index.html');
 
-	$atlNewsConverter = new RSS2HTML();
-	$atlnews = $atlNewsConverter->convert("news/atlNewsArchive.rss", "/atl/news/index.php");
-	$html = str_replace("%%NEWS%%", $atlnews, $html);
-
-	$newsConverter = new RSS2HTML_Blog();
-	$headlines = $newsConverter->convert();
-	$html = str_replace("%%HEADLINES%%", $headlines, $html);
-
 	# Generate the web page
 	$App->generatePage($theme, $Menu, null, $pageAuthor, $pageKeywords, $pageTitle, $html);
 ?>
