diff --git a/download.html b/download.html
index 7ed700e..30f1c81 100644
--- a/download.html
+++ b/download.html
@@ -128,7 +128,7 @@
 				</p>
 				<p>
 				
-					<strong><a href="releasenotes.html">Xtend 2.14.0 Release Notes</a></strong>
+					<strong><a href="releasenotes.html">Xtend 2.15.0 Release Notes</a></strong>
 				
 				</p>
 			</div>
diff --git a/feed.xml b/feed.xml
index 758d773..9a361f7 100644
--- a/feed.xml
+++ b/feed.xml
@@ -6,11 +6,75 @@
 </description>
     <link>http://xtend-lang.org/xtend/</link>
     <atom:link href="http://xtend-lang.org/xtend/feed.xml" rel="self" type="application/rss+xml"/>
-    <pubDate>Wed, 19 Sep 2018 15:39:29 -0400</pubDate>
-    <lastBuildDate>Wed, 19 Sep 2018 15:39:29 -0400</lastBuildDate>
+    <pubDate>Wed, 19 Sep 2018 16:16:45 -0400</pubDate>
+    <lastBuildDate>Wed, 19 Sep 2018 16:16:45 -0400</lastBuildDate>
     <generator>Jekyll v2.5.3</generator>
     
       <item>
+        <title>Xtend 2.15.0 Release Notes</title>
+        <description>&lt;p&gt;This release focuses on stability, performance and the integration in Eclipse 2018-09.&lt;/p&gt;
+
+&lt;h2 id=&quot;minimal-required-target-platform&quot;&gt;Minimal Required Target Platform&lt;/h2&gt;
+
+&lt;p&gt;Xtext and Xtend 2.15 are built and tested against Eclipse Oxygen.3a and newer. Thus we recommend to use at least Eclipse Oxygen.3a or even better Eclipse 2018-09. For older versions of the Eclipse Platform we cannot guarantee backwards compatibility even though we carefully assess any changes that are made.&lt;/p&gt;
+
+&lt;h2 id=&quot;smarter-organize-imports&quot;&gt;Smarter Organize Imports&lt;/h2&gt;
+
+&lt;p&gt;In the past there were a couple of corner cases where organize imports did not yield the optimal result. It could even lead to broken code under certain conditions. We fixed these scenarios and organize imports now works nicely, even when multicatch or static extensions are involved.&lt;/p&gt;
+
+&lt;h2 id=&quot;improved-performance-of-the-gradle-build&quot;&gt;Improved Performance of the Gradle Build&lt;/h2&gt;
+
+&lt;p&gt;The Gradle build performance was greatly improved. Tasks that consumed lots of memory and even more CPU cycles could be fixed such that it’s now way faster to build Xtend with Gradle.&lt;/p&gt;
+
+&lt;p&gt;2.14:&lt;/p&gt;
+
+&lt;p&gt;&lt;img src=&quot;/xtend/images/releasenotes/2_15_xtext_core.png&quot; alt=&quot;&quot; height=&quot;50%&quot; width=&quot;50%&quot; /&gt;&lt;/p&gt;
+
+&lt;p&gt;2.15:&lt;/p&gt;
+
+&lt;p&gt;&lt;img src=&quot;/xtend/images/releasenotes/2_15_xtext_core_fast.png&quot; alt=&quot;&quot; height=&quot;50%&quot; width=&quot;50%&quot; /&gt;&lt;/p&gt;
+
+&lt;h2 id=&quot;fixed-quickfixes&quot;&gt;Fixed QuickFixes&lt;/h2&gt;
+
+&lt;p&gt;In some cases, quick fixes broke existing code, this no longer happens.&lt;/p&gt;
+
+&lt;h2 id=&quot;improved-junit-support&quot;&gt;Improved JUnit Support&lt;/h2&gt;
+
+&lt;p&gt;Test methods must return void to be valid test cases. This is now statically checked by the Xtend validation.&lt;/p&gt;
+
+&lt;p&gt;&lt;img src=&quot;/xtend/images/releasenotes/2_15_junit_quickfix.png&quot; alt=&quot;&quot; height=&quot;50%&quot; width=&quot;50%&quot; /&gt;&lt;/p&gt;
+
+&lt;h2 id=&quot;new-api-iterableextensionsrejectclass&quot;&gt;New API IterableExtensions.reject(Class)&lt;/h2&gt;
+
+&lt;p&gt;An overloaded variant of &lt;code&gt;reject()&lt;/code&gt; was added for convience, this allows type based rejection of elements from an iterable.&lt;/p&gt;
+
+&lt;h2 id=&quot;fixed-issues&quot;&gt;Fixed Issues&lt;/h2&gt;
+
+&lt;p&gt;As in every release cycle we were eagerly hunting down bugs, and reviewed and integrated plenty of contributions. More than a 100 issues and almost 300 pull requests have made it into this release. For further details please refer to the following lists:&lt;/p&gt;
+
+&lt;ul&gt;
+  &lt;li&gt;
+    &lt;p&gt;&lt;a href=&quot;https://github.com/search?utf8=%E2%9C%93&amp;amp;q=is%3Aissue+milestone%3ARelease_2.15+is%3Aclosed+repo%3Aeclipse%2Fxtext+repo%3Aeclipse%2Fxtext-core+repo%3Aeclipse%2Fxtext-lib+repo%3Aeclipse%2Fxtext-extras+repo%3Aeclipse%2Fxtext-eclipse+repo%3Aeclipse%2Fxtext-idea+repo%3Aeclipse%2Fxtext-web+repo%3Aeclipse%2Fxtext-maven+repo%3Aeclipse%2Fxtext-xtend&amp;amp;type=Issues&amp;amp;ref=searchresults&quot;&gt;Fixed GitHub issues&lt;/a&gt;&lt;/p&gt;
+  &lt;/li&gt;
+  &lt;li&gt;
+    &lt;p&gt;&lt;a href=&quot;https://github.com/search?utf8=%E2%9C%93&amp;amp;q=is%3Apr+milestone%3ARelease_2.15+is%3Aclosed+repo%3Aeclipse%2Fxtext+repo%3Aeclipse%2Fxtext-core+repo%3Aeclipse%2Fxtext-lib+repo%3Aeclipse%2Fxtext-extras+repo%3Aeclipse%2Fxtext-eclipse+repo%3Aeclipse%2Fxtext-idea+repo%3Aeclipse%2Fxtext-web+repo%3Aeclipse%2Fxtext-maven+repo%3Aeclipse%2Fxtext-xtend&amp;amp;type=Issues&amp;amp;ref=searchresults&quot;&gt;Closed Pull Requests&lt;/a&gt;&lt;/p&gt;
+  &lt;/li&gt;
+  &lt;li&gt;
+    &lt;p&gt;&lt;a href=&quot;https://bugs.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;amp;bug_status=VERIFIED&amp;amp;bug_status=CLOSED&amp;amp;classification=Modeling&amp;amp;classification=Tools&amp;amp;columnlist=product%2Ccomponent%2Cassigned_to%2Cbug_status%2Cresolution%2Cshort_desc%2Cchangeddate%2Ckeywords&amp;amp;f0=OP&amp;amp;f1=OP&amp;amp;f3=CP&amp;amp;f4=CP&amp;amp;known_name=Xtext%202.15&amp;amp;list_id=16618269&amp;amp;product=TMF&amp;amp;product=Xtend&amp;amp;query_based_on=Xtext%202.15&amp;amp;query_format=advanced&amp;amp;status_whiteboard=v2.15&amp;amp;status_whiteboard_type=allwordssubstr&quot;&gt;Fixed Eclipse Bugzilla tickets&lt;/a&gt;&lt;/p&gt;
+  &lt;/li&gt;
+&lt;/ul&gt;
+
+</description>
+        <pubDate>Tue, 04 Sep 2018 00:00:00 -0400</pubDate>
+        <link>http://xtend-lang.org/xtend/releasenotes/2018/09/04/version-2-15-0.html</link>
+        <guid isPermaLink="true">http://xtend-lang.org/xtend/releasenotes/2018/09/04/version-2-15-0.html</guid>
+        
+        
+        <category>releasenotes</category>
+        
+      </item>
+    
+      <item>
         <title>Xtend 2.14.0 Release Notes</title>
         <description>&lt;h2 id=&quot;java-9-and-10-support&quot;&gt;Java 9 and 10 Support&lt;/h2&gt;
 
@@ -386,22 +450,5 @@
         
       </item>
     
-      <item>
-        <title>Xtend 2.7.0 Available</title>
-        <description>&lt;p&gt;We are proud to announce the general availability of Xtend 2.7.0. The release contains again tons of improvements, new features, and bugfixes. Check out the &lt;a href=&quot;/xtend/releasenotes.html#/releasenotes/2014/09/02/version-2-7-0&quot;&gt;release notes&lt;/a&gt; for details.&lt;/p&gt;
-
-&lt;p&gt;Special thanks go to all those who contributed to this release: Anton Kosyakov, Dennis Huebner, Holger Schill, Jan Köhnlein, Jan Rosczak, Jörg Reichert, Knut Wannheden, Michael Vorburger, Moritz Eysholdt, Ralf Kretzschmar-Auer, Sebastian Zarnekow, Stefan Oehme, Stéphane Galland, Sven Efftinge, Thomas Fritsch, and Vladimir Piskarev.&lt;/p&gt;
-
-&lt;p&gt;We’re also very grateful for the feedback that we get everyday. It helped us to get where we are now.&lt;/p&gt;
-</description>
-        <pubDate>Wed, 03 Sep 2014 00:00:00 -0400</pubDate>
-        <link>http://xtend-lang.org/xtend/news/2014/09/03/Xtend-2-7-0.html</link>
-        <guid isPermaLink="true">http://xtend-lang.org/xtend/news/2014/09/03/Xtend-2-7-0.html</guid>
-        
-        
-        <category>news</category>
-        
-      </item>
-    
   </channel>
 </rss>
diff --git a/releasenotes.html b/releasenotes.html
index 04304eb..1cf94ba 100644
--- a/releasenotes.html
+++ b/releasenotes.html
@@ -123,6 +123,8 @@
 					<h3>Table of Contents</h3>
 					<ul>
 						
+							<li><p><a href="#/releasenotes/2018/09/04/version-2-15-0">Xtend 2.15.0 Release Notes &mdash; Sep 4, 2018</a></p>
+						
 							<li><p><a href="#/releasenotes/2018/05/23/version-2-14-0">Xtend 2.14.0 Release Notes &mdash; May 23, 2018</a></p>
 						
 							<li><p><a href="#/releasenotes/2017/10/20/version-2-13-0">Xtext 2.13.0 Release Notes &mdash; Oct 20, 2017</a></p>
@@ -145,6 +147,65 @@
 				</div>
 				
 				  <hr/>
+				  <section id="/releasenotes/2018/09/04/version-2-15-0">
+				  	<h1>Xtend 2.15.0 Release Notes<small>&nbsp;&nbsp;Sep 4, 2018</small></h1>
+				    <br/>
+				    <p>This release focuses on stability, performance and the integration in Eclipse 2018-09.</p>
+
+<h2 id="minimal-required-target-platform">Minimal Required Target Platform</h2>
+
+<p>Xtext and Xtend 2.15 are built and tested against Eclipse Oxygen.3a and newer. Thus we recommend to use at least Eclipse Oxygen.3a or even better Eclipse 2018-09. For older versions of the Eclipse Platform we cannot guarantee backwards compatibility even though we carefully assess any changes that are made.</p>
+
+<h2 id="smarter-organize-imports">Smarter Organize Imports</h2>
+
+<p>In the past there were a couple of corner cases where organize imports did not yield the optimal result. It could even lead to broken code under certain conditions. We fixed these scenarios and organize imports now works nicely, even when multicatch or static extensions are involved.</p>
+
+<h2 id="improved-performance-of-the-gradle-build">Improved Performance of the Gradle Build</h2>
+
+<p>The Gradle build performance was greatly improved. Tasks that consumed lots of memory and even more CPU cycles could be fixed such that it’s now way faster to build Xtend with Gradle.</p>
+
+<p>2.14:</p>
+
+<p><img src="/xtend/images/releasenotes/2_15_xtext_core.png" alt="" height="50%" width="50%" /></p>
+
+<p>2.15:</p>
+
+<p><img src="/xtend/images/releasenotes/2_15_xtext_core_fast.png" alt="" height="50%" width="50%" /></p>
+
+<h2 id="fixed-quickfixes">Fixed QuickFixes</h2>
+
+<p>In some cases, quick fixes broke existing code, this no longer happens.</p>
+
+<h2 id="improved-junit-support">Improved JUnit Support</h2>
+
+<p>Test methods must return void to be valid test cases. This is now statically checked by the Xtend validation.</p>
+
+<p><img src="/xtend/images/releasenotes/2_15_junit_quickfix.png" alt="" height="50%" width="50%" /></p>
+
+<h2 id="new-api-iterableextensionsrejectclass">New API IterableExtensions.reject(Class)</h2>
+
+<p>An overloaded variant of <code>reject()</code> was added for convience, this allows type based rejection of elements from an iterable.</p>
+
+<h2 id="fixed-issues">Fixed Issues</h2>
+
+<p>As in every release cycle we were eagerly hunting down bugs, and reviewed and integrated plenty of contributions. More than a 100 issues and almost 300 pull requests have made it into this release. For further details please refer to the following lists:</p>
+
+<ul>
+  <li>
+    <p><a href="https://github.com/search?utf8=%E2%9C%93&amp;q=is%3Aissue+milestone%3ARelease_2.15+is%3Aclosed+repo%3Aeclipse%2Fxtext+repo%3Aeclipse%2Fxtext-core+repo%3Aeclipse%2Fxtext-lib+repo%3Aeclipse%2Fxtext-extras+repo%3Aeclipse%2Fxtext-eclipse+repo%3Aeclipse%2Fxtext-idea+repo%3Aeclipse%2Fxtext-web+repo%3Aeclipse%2Fxtext-maven+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues&amp;ref=searchresults">Fixed GitHub issues</a></p>
+  </li>
+  <li>
+    <p><a href="https://github.com/search?utf8=%E2%9C%93&amp;q=is%3Apr+milestone%3ARelease_2.15+is%3Aclosed+repo%3Aeclipse%2Fxtext+repo%3Aeclipse%2Fxtext-core+repo%3Aeclipse%2Fxtext-lib+repo%3Aeclipse%2Fxtext-extras+repo%3Aeclipse%2Fxtext-eclipse+repo%3Aeclipse%2Fxtext-idea+repo%3Aeclipse%2Fxtext-web+repo%3Aeclipse%2Fxtext-maven+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues&amp;ref=searchresults">Closed Pull Requests</a></p>
+  </li>
+  <li>
+    <p><a href="https://bugs.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=VERIFIED&amp;bug_status=CLOSED&amp;classification=Modeling&amp;classification=Tools&amp;columnlist=product%2Ccomponent%2Cassigned_to%2Cbug_status%2Cresolution%2Cshort_desc%2Cchangeddate%2Ckeywords&amp;f0=OP&amp;f1=OP&amp;f3=CP&amp;f4=CP&amp;known_name=Xtext%202.15&amp;list_id=16618269&amp;product=TMF&amp;product=Xtend&amp;query_based_on=Xtext%202.15&amp;query_format=advanced&amp;status_whiteboard=v2.15&amp;status_whiteboard_type=allwordssubstr">Fixed Eclipse Bugzilla tickets</a></p>
+  </li>
+</ul>
+
+
+				  </section>
+				
+				  <hr/>
 				  <section id="/releasenotes/2018/05/23/version-2-14-0">
 				  	<h1>Xtend 2.14.0 Release Notes<small>&nbsp;&nbsp;May 23, 2018</small></h1>
 				    <br/>
diff --git a/releasenotes/2018/09/04/version-2-15-0.html b/releasenotes/2018/09/04/version-2-15-0.html
new file mode 100644
index 0000000..7b0c051
--- /dev/null
+++ b/releasenotes/2018/09/04/version-2-15-0.html
@@ -0,0 +1,252 @@
+<!DOCTYPE html>
+<html>
+
+  <head>
+	<meta charset="UTF-8">
+	<title>Xtend - Xtend 2.15.0 Release Notes</title>
+	<meta name="viewport" content="width=device-width, initial-scale=1.0">
+	<meta name="description"
+		content="Xtend is a statically typed programming language sitting on top of Java.">
+	<meta name="author" content="Sven Efftinge">
+	<meta name="author" content="Miro Spoenemann">
+	<!--  styles -->
+	<!-- Le HTML5 shim, for IE6-8 support of HTML5 elements -->
+	<!--[if lt IE 9]>
+	  <script src="http://html5shim.googlecode.com/svn/trunk/html5.js"></script>
+	<![endif]-->
+	
+	<!-- Le fav and touch icons -->
+	
+	<link rel="shortcut icon" href="/xtend/images/favicon.png">
+	
+	<link href="/xtend/css/bootstrap.css" rel="stylesheet" type='text/css'>
+	<link href="/xtend/css/bootstrap-responsive.css" rel="stylesheet" type='text/css'>
+	<link href="/xtend/css/shield-responsive.css" rel="stylesheet" type='text/css'>
+	<link href='/xtend/css/fonts.css' rel='stylesheet' type='text/css'>
+	<link href="/xtend/css/prettyPhoto.css" rel="stylesheet" media="screen" type='text/css'>
+	<link href="/xtend/css/prettify.css" type="text/css" rel="stylesheet"/>
+	<link href="/xtend/css/style.css" rel="stylesheet" type='text/css'>
+	
+	<!--[if lt IE 9]>
+	<link href="css/iebugs.css" rel="stylesheet" type='text/css'>
+	<![endif]-->
+
+	<!-- BEGIN Cookie Consent
+	<link rel="stylesheet" type="text/css" href="//cdnjs.cloudflare.com/ajax/libs/cookieconsent2/3.0.3/cookieconsent.min.css" />
+	<script src="//cdnjs.cloudflare.com/ajax/libs/cookieconsent2/3.0.3/cookieconsent.min.js"></script>
+	<script>
+	window.addEventListener("load", function(){
+	window.cookieconsent.initialise({
+		"palette": {
+		"popup": {
+		  "background": "#000"
+		},
+		"button": {
+		  "background": "#f1d600"
+		}
+		},
+		"theme": "edgeless",
+		"type": "opt-in",
+		onInitialise: function (status) {
+		  var type = this.options.type;
+		  var didConsent = this.hasConsented();
+		  if (type == 'opt-in' && didConsent) {
+		    // TODO: enable cookies
+		  }
+		  if (type == 'opt-out' && !didConsent) {
+		    // TODO: disable cookies
+		  }
+		},
+		onStatusChange: function(status, chosenBefore) {
+		  var type = this.options.type;
+		  var didConsent = this.hasConsented();
+		  if (type == 'opt-in' && didConsent) {
+		    // TODO: enable cookies
+		  }
+		  if (type == 'opt-out' && !didConsent) {
+		    // TODO: disable cookies
+		  }
+		}, 
+		onRevokeChoice: function() {
+		  var type = this.options.type;
+		  if (type == 'opt-in') {
+		    // TODO: disable cookies
+		  }
+		  if (type == 'opt-out') {
+		    // TODO: enable cookies
+		  }
+		},
+		"content": {
+		"href": "http://www.eclipse.org/legal/privacy.php"
+		}
+	})});
+	</script>
+	END Cookie Consent -->
+</head>
+
+
+  <body>
+
+    <!-- Navbar -->
+  <div class="navbar navbar-fixed-top"
+    style="border-bottom: 1px solid #000;">
+    <div class="navbar-inner">
+      <div class="container">
+        <a class="btn btn-navbar" data-toggle="collapse"
+          data-target=".nav-collapse"> <span class="icon-bar"></span> <span
+          class="icon-bar"></span> <span class="icon-bar"></span>
+        </a> <a class="brand" href="/xtend/index.html"></a>
+        <div class="nav-collapse collapse" style="height: 0px;">
+          <ul class="nav">
+            <li ><a href="/xtend/download.html">Download</a></li>
+            <li ><a href="/xtend/documentation/index.html">Documentation</a></li>
+            <li ><a href="/xtend/community.html">Community</a></li>
+            <li ><a href="http://xtext.org">Xtext</a></li>
+            <li ><a href="http://www.eclipse.org">Eclipse.org</a></li>
+          </ul>
+              <!--div class="btn-group pull-right">
+                <div class="g-plusone" data-href="http://www.xtend-lang.org"></div>
+              </div-->
+        </div>
+        <!--/.nav-collapse -->
+      </div>
+    </div>
+  </div>
+  <!-- Navbar End -->
+
+
+    <div class="post">
+
+  <header class="post-header">
+    <h1 class="post-title">Xtend 2.15.0 Release Notes</h1>
+    <p class="post-meta">Sep 4, 2018</p>
+  </header>
+
+  <article class="post-content">
+    <p>This release focuses on stability, performance and the integration in Eclipse 2018-09.</p>
+
+<h2 id="minimal-required-target-platform">Minimal Required Target Platform</h2>
+
+<p>Xtext and Xtend 2.15 are built and tested against Eclipse Oxygen.3a and newer. Thus we recommend to use at least Eclipse Oxygen.3a or even better Eclipse 2018-09. For older versions of the Eclipse Platform we cannot guarantee backwards compatibility even though we carefully assess any changes that are made.</p>
+
+<h2 id="smarter-organize-imports">Smarter Organize Imports</h2>
+
+<p>In the past there were a couple of corner cases where organize imports did not yield the optimal result. It could even lead to broken code under certain conditions. We fixed these scenarios and organize imports now works nicely, even when multicatch or static extensions are involved.</p>
+
+<h2 id="improved-performance-of-the-gradle-build">Improved Performance of the Gradle Build</h2>
+
+<p>The Gradle build performance was greatly improved. Tasks that consumed lots of memory and even more CPU cycles could be fixed such that it’s now way faster to build Xtend with Gradle.</p>
+
+<p>2.14:</p>
+
+<p><img src="/xtend/images/releasenotes/2_15_xtext_core.png" alt="" height="50%" width="50%" /></p>
+
+<p>2.15:</p>
+
+<p><img src="/xtend/images/releasenotes/2_15_xtext_core_fast.png" alt="" height="50%" width="50%" /></p>
+
+<h2 id="fixed-quickfixes">Fixed QuickFixes</h2>
+
+<p>In some cases, quick fixes broke existing code, this no longer happens.</p>
+
+<h2 id="improved-junit-support">Improved JUnit Support</h2>
+
+<p>Test methods must return void to be valid test cases. This is now statically checked by the Xtend validation.</p>
+
+<p><img src="/xtend/images/releasenotes/2_15_junit_quickfix.png" alt="" height="50%" width="50%" /></p>
+
+<h2 id="new-api-iterableextensionsrejectclass">New API IterableExtensions.reject(Class)</h2>
+
+<p>An overloaded variant of <code>reject()</code> was added for convience, this allows type based rejection of elements from an iterable.</p>
+
+<h2 id="fixed-issues">Fixed Issues</h2>
+
+<p>As in every release cycle we were eagerly hunting down bugs, and reviewed and integrated plenty of contributions. More than a 100 issues and almost 300 pull requests have made it into this release. For further details please refer to the following lists:</p>
+
+<ul>
+  <li>
+    <p><a href="https://github.com/search?utf8=%E2%9C%93&amp;q=is%3Aissue+milestone%3ARelease_2.15+is%3Aclosed+repo%3Aeclipse%2Fxtext+repo%3Aeclipse%2Fxtext-core+repo%3Aeclipse%2Fxtext-lib+repo%3Aeclipse%2Fxtext-extras+repo%3Aeclipse%2Fxtext-eclipse+repo%3Aeclipse%2Fxtext-idea+repo%3Aeclipse%2Fxtext-web+repo%3Aeclipse%2Fxtext-maven+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues&amp;ref=searchresults">Fixed GitHub issues</a></p>
+  </li>
+  <li>
+    <p><a href="https://github.com/search?utf8=%E2%9C%93&amp;q=is%3Apr+milestone%3ARelease_2.15+is%3Aclosed+repo%3Aeclipse%2Fxtext+repo%3Aeclipse%2Fxtext-core+repo%3Aeclipse%2Fxtext-lib+repo%3Aeclipse%2Fxtext-extras+repo%3Aeclipse%2Fxtext-eclipse+repo%3Aeclipse%2Fxtext-idea+repo%3Aeclipse%2Fxtext-web+repo%3Aeclipse%2Fxtext-maven+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues&amp;ref=searchresults">Closed Pull Requests</a></p>
+  </li>
+  <li>
+    <p><a href="https://bugs.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=VERIFIED&amp;bug_status=CLOSED&amp;classification=Modeling&amp;classification=Tools&amp;columnlist=product%2Ccomponent%2Cassigned_to%2Cbug_status%2Cresolution%2Cshort_desc%2Cchangeddate%2Ckeywords&amp;f0=OP&amp;f1=OP&amp;f3=CP&amp;f4=CP&amp;known_name=Xtext%202.15&amp;list_id=16618269&amp;product=TMF&amp;product=Xtend&amp;query_based_on=Xtext%202.15&amp;query_format=advanced&amp;status_whiteboard=v2.15&amp;status_whiteboard_type=allwordssubstr">Fixed Eclipse Bugzilla tickets</a></p>
+  </li>
+</ul>
+
+
+  </article>
+
+</div>
+
+    
+    <footer class="site-footer">
+  <div id="extra">
+    <div class="container inner-footer">
+      <div class="row">
+        <div class="span6">
+          <h3 class="footer-links-header">Quick Links</h3>
+          <ul class="footer-links clearfix">
+            <li><a href="http://www.eclipse.org/legal/privacy.php">Privacy Policy</a></li>
+            <li><a href="http://www.eclipse.org/legal/termsofuse.php">Terms of Use</a></li>
+            <li><a href="http://www.eclipse.org/legal/copyright.php">Copyright Agent</a></li>
+            <li><a href="http://www.eclipse.org/legal/">Legal</a></li>
+          </ul>
+          <ul class="footer-links clearfix">
+            <li><a href="http://www.eclipse.org">Eclipse Home</a></li>
+            <li><a href="http://marketplace.eclipse.org/">Market Place</a></li>
+            <li><a href="http://live.eclipse.org/">Eclipse Live</a></li>
+            <li><a href="http://www.planeteclipse.org/">Eclipse Planet</a></li>
+          </ul>
+        </div>
+        <div class="span6">
+            <!-- Social Media Links -->
+            <h3 class="footer-links-header"">Social Media</h3>
+            <ul class="footer-links clearfix">
+              <li>
+                <a href="https://twitter.com/xtendlang"><img src="/xtend/images/Twitter-bird-darkgray.png" class="img-responsive" style="margin-right: 5px;height: 1em;" alt="Twitter icon">@xtendlang on Twitter</a>
+              </li>
+            </ul>
+          </div>
+
+      </div>
+    </div>
+  </div>
+  <a href="#" class="scrollup fadeOutRight animated" style="display: none;">ScrollUp</a>
+  <a href="http://dryicons.com/">Icons by http://dryicons.com</a>
+  <!-- Le javascript
+      ================================================== -->
+  <!-- Placed at the end of the document so the pages load faster -->
+  <script src="/xtend/js/jquery-1.7.1.min.js" type="text/javascript"></script>
+  <script src="/xtend/js/bootstrap.min.js" type="text/javascript"></script>
+  
+  <!-- include pretty-print files -->
+  <script src="/xtend/js/prettify.js" type="text/javascript" ></script>
+  <script src="/xtend/js/lang-xtend.js" type="text/javascript"></script>
+  
+  <!-- Include the plug-in -->
+  <script src="/xtend/js/jquery.prettyPhoto.js" type="text/javascript"></script>
+  <script src="/xtend/js/jquery.easing.1.3.js" type="text/javascript"></script>
+  <script src="/xtend/js/custom.js" type="text/javascript"></script>
+  <!--script src="https://apis.google.com/js/platform.js" async defer></script-->
+  <!--script type="text/javascript">
+    var _gaq = _gaq || [];  
+      _gaq.push([ '_setAccount', 'UA-2429174-4' ]);
+    _gaq.push([ '_trackPageview' ]);
+    (function() {
+      var ga = document.createElement('script');
+      ga.type = 'text/javascript';
+      ga.async = true;
+      ga.src = ('https:' == document.location.protocol ? 'https://ssl'
+          : 'http://www')
+          + '.google-analytics.com/ga.js';
+      var s = document.getElementsByTagName('script')[0];
+      s.parentNode.insertBefore(ga, s);
+    })();
+  </script-->
+</footer>
+
+  </body>
+
+</html>
