diff --git a/documentation/350_continuous_integration.html b/documentation/350_continuous_integration.html
index 0d73cac..7e748a3 100644
--- a/documentation/350_continuous_integration.html
+++ b/documentation/350_continuous_integration.html
@@ -472,12 +472,20 @@
   </thead>
   <tbody>
     <tr>
+      <td><a href="http://download.eclipse.org/modeling/tmf/xtext/updates/releases/2.28.0/">2.28.0</a></td>
+      <td><a href="http://download.eclipse.org/modeling/emf/emf/builds/release/2.31">2.31.0</a> (2.20.0)</td>
+      <td><a href="http://download.eclipse.org/modeling/emft/mwe/updates/releases/2.13.0/">2.13.0</a> (2.9.1)</td>
+      <td><a href="http://download.eclipse.org/modeling/m2t/xpand/updates/releases/R201605260315">2.2.0</a> (1.4)</td>
+      <td><a href="http://download.eclipse.org/releases/2022-09">4.24.0</a> (4.7.3)</td>
+      <td><a href="http://download.eclipse.org/releases/2022-09">2022-09</a></td>
+    </tr>
+    <tr>
       <td><a href="http://download.eclipse.org/modeling/tmf/xtext/updates/releases/2.27.0/">2.27.0</a></td>
       <td><a href="http://download.eclipse.org/modeling/emf/emf/builds/release/2.30">2.30.0</a> (2.20.0)</td>
       <td><a href="http://download.eclipse.org/modeling/emft/mwe/updates/releases/2.13.0/">2.13.0</a> (2.9.1)</td>
       <td><a href="http://download.eclipse.org/modeling/m2t/xpand/updates/releases/R201605260315">2.2.0</a> (1.4)</td>
       <td><a href="http://download.eclipse.org/releases/2022-06">4.24.0</a> (4.7.3)</td>
-      <td><a href="http://download.eclipse.org/releases/2021-06">2022-06</a></td>
+      <td><a href="http://download.eclipse.org/releases/2022-06">2022-06</a></td>
     </tr>
     <tr>
       <td><a href="http://download.eclipse.org/modeling/tmf/xtext/updates/releases/2.26.0/">2.26.0</a></td>
@@ -485,7 +493,7 @@
       <td><a href="http://download.eclipse.org/modeling/emft/mwe/updates/releases/2.12.2/">2.12.2</a> (2.9.1)</td>
       <td><a href="http://download.eclipse.org/modeling/m2t/xpand/updates/releases/R201605260315">2.2.0</a> (1.4)</td>
       <td><a href="http://download.eclipse.org/releases/2022-03">4.23.0</a> (4.7.3)</td>
-      <td><a href="http://download.eclipse.org/releases/2021-03">2022-03</a></td>
+      <td><a href="http://download.eclipse.org/releases/2022-03">2022-03</a></td>
     </tr>
     <tr>
       <td><a href="http://download.eclipse.org/modeling/tmf/xtext/updates/releases/2.25.0/">2.25.0</a></td>
@@ -650,7 +658,7 @@
   </tbody>
 </table>
 
-<p>The following is an example target platform definition for Xtext 2.27.0 and Eclipse 4.24 alias 2022-06.</p>
+<p>The following is an example target platform definition for Xtext 2.28.0 and Eclipse 4.25 alias 2022-09.</p>
 
 <pre><code class="language-xml">&lt;?xml version="1.0" encoding="UTF-8" standalone="no"?&gt;
 &lt;?pde version="3.8"?&gt;
@@ -658,7 +666,7 @@
 &lt;locations&gt;
   &lt;location includeAllPlatforms="false" includeConfigurePhase="false" includeMode="planner" includeSource="false" type="InstallableUnit"&gt;
     &lt;unit id="org.eclipse.xtext.sdk.feature.group" version="0.0.0"/&gt;
-    &lt;repository location="http://download.eclipse.org/modeling/tmf/xtext/updates/releases/2.27.0/"/&gt;
+    &lt;repository location="http://download.eclipse.org/modeling/tmf/xtext/updates/releases/2.28.0/"/&gt;
   &lt;/location&gt;
   &lt;location includeAllPlatforms="false" includeConfigurePhase="false" includeMode="planner" includeSource="false" type="InstallableUnit"&gt;
     &lt;unit id="org.eclipse.jdt.feature.group" version="0.0.0"/&gt;
@@ -667,7 +675,7 @@
     &lt;unit id="org.eclipse.draw2d.feature.group" version="0.0.0"/&gt;
     &lt;unit id="org.eclipse.emf.sdk.feature.group" version="0.0.0"/&gt;
     &lt;unit id="org.eclipse.emf.mwe2.launcher.feature.group" version="0.0.0"/&gt;
-    &lt;repository location="http://download.eclipse.org/releases/2022-06/"/&gt;
+    &lt;repository location="http://download.eclipse.org/releases/2022-09/"/&gt;
   &lt;/location&gt;
 &lt;/locations&gt;
 &lt;/target&gt;
diff --git a/download.html b/download.html
index 369a2b9..1728625 100644
--- a/download.html
+++ b/download.html
@@ -136,7 +136,7 @@
 				</p>
 				<p>
 				
-					<strong><a href="releasenotes.html">Xtext 2.27.0 Release Notes</a></strong>
+					<strong><a href="releasenotes.html">Xtext 2.28.0 Release Notes</a></strong>
 				
 				</p>
 			</div>
diff --git a/feed.xml b/feed.xml
index 9020492..3565cd0 100644
--- a/feed.xml
+++ b/feed.xml
@@ -6,11 +6,74 @@
 </description>
     <link>http://xtext.org/Xtext/</link>
     <atom:link href="http://xtext.org/Xtext/feed.xml" rel="self" type="application/rss+xml"/>
-    <pubDate>Wed, 20 Jul 2022 12:38:44 +0000</pubDate>
-    <lastBuildDate>Wed, 20 Jul 2022 12:38:44 +0000</lastBuildDate>
+    <pubDate>Mon, 29 Aug 2022 07:20:36 +0000</pubDate>
+    <lastBuildDate>Mon, 29 Aug 2022 07:20:36 +0000</lastBuildDate>
     <generator>Jekyll v2.5.3</generator>
     
       <item>
+        <title>Xtext 2.28.0 Release Notes</title>
+        <description>&lt;p&gt;Xtext 2.28.0 is a maintenance release.&lt;/p&gt;
+
+&lt;h2 id=&quot;call-to-action-secure-the-future-maintenance-of-xtext&quot;&gt;Call to Action: Secure the future maintenance of Xtext&lt;/h2&gt;
+
+&lt;p&gt;As you might have recognized, the number of people contributing to Xtext on a regular basis has declined over the past years and so has the number of contributions. At the same time the amount of work for basic maintenance has stayed the same or even increased with the new release cadence of Java and the Eclipse simultaneous release. Briefly: The future maintenance of Xtext is at risk, at least in the current form and as part of the Eclipse Simrel. If you care, please join the discussion in &lt;a href=&quot;https://github.com/eclipse/xtext/issues/1721&quot;&gt;https://github.com/eclipse/xtext/issues/1721&lt;/a&gt;.&lt;/p&gt;
+
+&lt;h2 id=&quot;changes-to-orgeclipsextextsdk-feature&quot;&gt;Changes to &lt;code&gt;org.eclipse.xtext.sdk&lt;/code&gt; feature.&lt;/h2&gt;
+
+&lt;p&gt;The &lt;code&gt;org.eclipse.xtext.sdk&lt;/code&gt; does no longer package the deprecated &lt;code&gt;org.eclipse.xtext.generator&lt;/code&gt; bundle. Please migrate to the new workflow/generator. The old and deprecated generator can still be found in the new &lt;code&gt;org.eclipse.xtext.generator&lt;/code&gt; feature.&lt;/p&gt;
+
+&lt;h2 id=&quot;upgrades&quot;&gt;Upgrades&lt;/h2&gt;
+
+&lt;ul&gt;
+  &lt;li&gt;LSP4J was updated to 0.15.0&lt;/li&gt;
+  &lt;li&gt;GSON was updated to 2.9.0&lt;/li&gt;
+&lt;/ul&gt;
+
+&lt;h2 id=&quot;changes--enhancements&quot;&gt;Changes / Enhancements&lt;/h2&gt;
+
+&lt;ul&gt;
+  &lt;li&gt;LSP Code was optimized and enhanced. We have e.g. done some enhancements to Quickfix API.&lt;/li&gt;
+  &lt;li&gt;Xtext Supports M2E 2.x&lt;/li&gt;
+  &lt;li&gt;Xbase based formatters now can be subclassed in Java more easily.&lt;/li&gt;
+  &lt;li&gt;Better support for needRebuild api in platform.&lt;/li&gt;
+&lt;/ul&gt;
+
+&lt;h2 id=&quot;credits&quot;&gt;Credits&lt;/h2&gt;
+
+&lt;p&gt;The Xtext project is thankful for the dedication of each committer and contributor. This release has been made possible by the following persons (in order of the number of contributed commits to this release to &lt;a href=&quot;https://github.com/eclipse/xtext#repositories&quot;&gt;all repositories&lt;/a&gt; except &lt;a href=&quot;https://github.com/eclipse/xtext-xtend&quot;&gt;xtext-xtend&lt;/a&gt;):&lt;/p&gt;
+
+&lt;p&gt;Christian Dietrich (itemis)&lt;br /&gt;
+Ruben Porras&lt;br /&gt;
+Karsten Thoms (karakun)&lt;br /&gt;
+Frank Benoit (ETAS)&lt;br /&gt;
+Hannes Wellmann (IILS mbH) &lt;img src=&quot;https://img.shields.io/badge/-first%20time%20contributor-green.svg&quot; alt=&quot;&quot; /&gt;&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. 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.28+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.28+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.28&amp;amp;list_id=16618269&amp;amp;product=TMF&amp;amp;product=Xtend&amp;amp;query_based_on=Xtext%202.28&amp;amp;query_format=advanced&amp;amp;status_whiteboard=v2.28&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>Mon, 29 Aug 2022 00:00:00 +0000</pubDate>
+        <link>http://xtext.org/Xtext/releasenotes/2022/08/29/version-2-28-0.html</link>
+        <guid isPermaLink="true">http://xtext.org/Xtext/releasenotes/2022/08/29/version-2-28-0.html</guid>
+        
+        
+        <category>releasenotes</category>
+        
+      </item>
+    
+      <item>
         <title>Xtext 2.27.0 Release Notes</title>
         <description>&lt;p&gt;Xtext 2.27.0 is a maintenance release.&lt;/p&gt;
 
@@ -837,149 +900,5 @@
         
       </item>
     
-      <item>
-        <title>Xtext 2.18.0 Release Notes</title>
-        <description>&lt;p&gt;Xtext 2.18.0 is mainly a maintenance release.&lt;/p&gt;
-
-&lt;h2 id=&quot;eclipse-integration&quot;&gt;Eclipse Integration&lt;/h2&gt;
-
-&lt;h3 id=&quot;search-references-result-page-new-context-actions&quot;&gt;Search References Result Page: New Context Actions&lt;/h3&gt;
-
-&lt;p&gt;The results of the &lt;em&gt;Search References&lt;/em&gt; action can now be copied to the clipboard. Further an action has been added to remove search results from the view. Both actions are available from the context menu and by common keyboard shortcuts.&lt;/p&gt;
-
-&lt;p&gt;&lt;img src=&quot;/Xtext/images/releasenotes/2_18_SearchReferencesResultActions.png&quot; alt=&quot;Search References Result Page: New Context Actions&quot; height=&quot;50%&quot; width=&quot;50%&quot; /&gt;&lt;/p&gt;
-
-&lt;h3 id=&quot;new-quickfix-on-empty-keywords&quot;&gt;New Quickfix on Empty Keywords&lt;/h3&gt;
-
-&lt;p&gt;Grammar rules with empty keyword statements (&lt;code&gt;&#39;&#39;&lt;/code&gt;) are raising errors already. Two new quickfixes have been added that can be used to resolve these errors:&lt;/p&gt;
-
-&lt;ul&gt;
-  &lt;li&gt;Remove the empty keyword&lt;/li&gt;
-  &lt;li&gt;Set the keyword value from the declaring rule name&lt;/li&gt;
-&lt;/ul&gt;
-
-&lt;p&gt;(&lt;a href=&quot;https://github.com/eclipse/xtext-eclipse/issues/994&quot;&gt;xtext-eclipse#994&lt;/a&gt;)&lt;/p&gt;
-
-&lt;h3 id=&quot;fixed-potential-deadlock-on-startup&quot;&gt;Fixed Potential Deadlock on Startup&lt;/h3&gt;
-
-&lt;p&gt;A deadlock may occur on startup of Eclipse. The builder infrastructure has been improved to avoid locking on loading its stored state. (&lt;a href=&quot;https://github.com/eclipse/xtext/issues/1460&quot;&gt;#1460&lt;/a&gt;)&lt;/p&gt;
-
-&lt;h3 id=&quot;fixed-exceptions-for-closed-projects&quot;&gt;Fixed: Exceptions for Closed Projects&lt;/h3&gt;
-
-&lt;p&gt;When projects are removed from the workspace the &lt;code&gt;ProjectOpenedOrClosedListener&lt;/code&gt; may caused exceptions that were logged to the error log. This situation has been fixed with &lt;a href=&quot;https://github.com/eclipse/xtext-eclipse/issues/1066&quot;&gt;xtext-eclipse#1066&lt;/a&gt;.&lt;/p&gt;
-
-&lt;h3 id=&quot;refactoring-support-improved-progress-reporting&quot;&gt;Refactoring Support: Improved Progress Reporting&lt;/h3&gt;
-
-&lt;p&gt;The &lt;code&gt;ResourceRelocationProcessor&lt;/code&gt; did not forward the progress monitor to the change serializer, which prevented proper feedback and cancellation support during the application of a rename refactoring. The progress monitor is now forwarded. (&lt;a href=&quot;https://github.com/eclipse/xtext-eclipse/issues/1053&quot;&gt;xtext-eclipse#1053&lt;/a&gt;)&lt;/p&gt;
-
-&lt;h3 id=&quot;refactoring-support-improved-memory-utilization&quot;&gt;Refactoring Support: Improved Memory Utilization&lt;/h3&gt;
-
-&lt;p&gt;During rename or move refactorings a temporary resource set is created and populated. This resource set was kept in memory, leading to unnecessary memory consumption. Now the memory held by this temporary resource set is released properly. (&lt;a href=&quot;https://github.com/eclipse/xtext-eclipse/issues/1048&quot;&gt;xtext-eclipse#1048&lt;/a&gt;)&lt;/p&gt;
-
-&lt;h2 id=&quot;lsp-integration&quot;&gt;LSP Integration&lt;/h2&gt;
-
-&lt;h3 id=&quot;ilanguageserveraccess-provide-access-to-xtext-index&quot;&gt;&lt;code&gt;ILanguageServerAccess&lt;/code&gt;: Provide Access to Xtext Index&lt;/h3&gt;
-
-&lt;p&gt;A new method &lt;code&gt;doReadIndex&lt;/code&gt; has been added to &lt;code&gt;ILanguageServerAccess&lt;/code&gt; to allow access to the &lt;code&gt;IResourceDescritions&lt;/code&gt; instance (a.k.a. the Xtext Index). This is useful for certain use cases for LS extension developers. (&lt;a href=&quot;https://github.com/eclipse/xtext-core/issues/1067&quot;&gt;xtext#1067&lt;/a&gt;)&lt;/p&gt;
-
-&lt;h3 id=&quot;report-partial-results-of-cancelled-multi-project-builds&quot;&gt;Report Partial Results of Cancelled Multi-Project Builds&lt;/h3&gt;
-
-&lt;p&gt;When a multi-project build is canceled (another &lt;code&gt;runWrite&lt;/code&gt; coming in from the &lt;code&gt;RequestManager&lt;/code&gt;), it could be that some projects have already been built. Even though their &lt;code&gt;ProjectManager&lt;/code&gt;s have been updated (e.g. their index state), their deltas were never returned, because the &lt;code&gt;BuildManager&lt;/code&gt; aggregated all results in a local variable. Build listeners were never be informed about these changes.&lt;/p&gt;
-
-&lt;p&gt;The &lt;code&gt;BuildManager&lt;/code&gt; has been improved to report also partial results to listeners. (&lt;a href=&quot;https://github.com/eclipse/xtext-core/issues/1124&quot;&gt;xtext-core#1124&lt;/a&gt;)&lt;/p&gt;
-
-&lt;h3 id=&quot;improved-handling-of-builds-cancellations-by-didchangewatchedfiles-notifications&quot;&gt;Improved Handling of Builds Cancellations by &lt;code&gt;didChangeWatchedFiles&lt;/code&gt; Notifications&lt;/h3&gt;
-
-&lt;p&gt;When editing files in an auto-saving editor, &lt;code&gt;didChange&lt;/code&gt; notifications are usually followed by &lt;code&gt;didChangeWatchedFiles&lt;/code&gt; notifications. The latter cancel the build, but only look at their own changes to decide whether a new build should be issued. The changes from the prior &lt;code&gt;didChange&lt;/code&gt; queued on the &lt;code&gt;BuildManager&lt;/code&gt; were ignored.&lt;/p&gt;
-
-&lt;p&gt;This issue has been improved by reprocessing URIs from cancelled builds in. (&lt;a href=&quot;https://github.com/eclipse/xtext-core/issues/1121&quot;&gt;xtext-core#1121&lt;/a&gt;)&lt;/p&gt;
-
-&lt;h3 id=&quot;fixed-unexpected-occurrance-highlighting&quot;&gt;Fixed Unexpected Occurrance Highlighting&lt;/h3&gt;
-
-&lt;p&gt;In certain situations occurrances were not highlighted properly. The highlighting service has been improved for that. See &lt;a href=&quot;https://github.com/eclipse/xtext-core/issues/1090&quot;&gt;xtext-core#1090&lt;/a&gt; for details.&lt;/p&gt;
-
-&lt;h2 id=&quot;xtext-grammar--code-generator&quot;&gt;Xtext Grammar &amp;amp; Code Generator&lt;/h2&gt;
-
-&lt;h3 id=&quot;fixed-illegal-whitespace-removal-in-merged-manifests&quot;&gt;Fixed: Illegal Whitespace Removal in Merged Manifests&lt;/h3&gt;
-
-&lt;p&gt;When re-generating language implementations whitespace was illegally removed for required bundles with changed versions. (&lt;a href=&quot;https://github.com/eclipse/xtext-extras/issues/406&quot;&gt;xtext-extras#406&lt;/a&gt;)&lt;/p&gt;
-
-&lt;h2 id=&quot;security&quot;&gt;Security&lt;/h2&gt;
-
-&lt;p&gt;With &lt;a href=&quot;https://bugs.eclipse.org/bugs/show_bug.cgi?id=544852&quot;&gt;Bug#544852&lt;/a&gt; a theoretical security issue was reported (CVE-2019-10249). While building Xtext artifacts may be downloaded through HTTP instead of HTTPS. To avoid this, all build related resources have been revised and assured that all artifacts participating in the software build are only downloaded with HTTPS.&lt;/p&gt;
-
-&lt;ul&gt;
-  &lt;li&gt;p2 mirrors are disabled for builds using Eclipse Tycho. (&lt;a href=&quot;https://github.com/eclipse/xtext/issues/1427&quot;&gt;#1427&lt;/a&gt;)&lt;/li&gt;
-  &lt;li&gt;p2 repository URLs changed from HTTP to HTTPS. (&lt;a href=&quot;https://github.com/eclipse/xtext-xtend/issues/759&quot;&gt;xtext-xtend#759&lt;/a&gt;)&lt;/li&gt;
-  &lt;li&gt;Maven repository URLs changed from HTTP to HTTPS. (&lt;a href=&quot;https://github.com/eclipse/xtext-maven/issues/74&quot;&gt;xtext-maven&lt;/a&gt;)&lt;/li&gt;
-&lt;/ul&gt;
-
-&lt;h2 id=&quot;upgrades&quot;&gt;Upgrades&lt;/h2&gt;
-
-&lt;ul&gt;
-  &lt;li&gt;LSP4J has been upgraded to its latest release 0.7.2.&lt;/li&gt;
-  &lt;li&gt;The Java Bytecode Manipultation library ASM has been upgraded to version 7.1.0. (&lt;a href=&quot;https://github.com/eclipse/xtext/issues/1440&quot;&gt;#1440&lt;/a&gt;)&lt;/li&gt;
-  &lt;li&gt;Gradle based projects have been upgraded to use the Gradle Wrapper version 5.4.1.&lt;/li&gt;
-  &lt;li&gt;Eclipse Tycho has been upgraded to release 1.4.0. (&lt;a href=&quot;https://github.com/eclipse/xtext/issues/1422&quot;&gt;#1422&lt;/a&gt;)&lt;/li&gt;
-  &lt;li&gt;In Gradle builds usages of Spring’s &lt;code&gt;dependency-management-plugin&lt;/code&gt; have been upgraded to version 1.0.7.RELEASE. (&lt;a href=&quot;https://github.com/eclipse/xtext/issues/1420&quot;&gt;#1420&lt;/a&gt;)&lt;/li&gt;
-&lt;/ul&gt;
-
-&lt;h2 id=&quot;new-features-in-xtend&quot;&gt;New Features in Xtend&lt;/h2&gt;
-
-&lt;p&gt;Xtend has learned try-with-resources and the ternary operator. See the &lt;a href=&quot;https://www.eclipse.org/xtend/releasenotes.html#/releasenotes/2019/06/04/version-2-18-0&quot;&gt;Xtend Releasenotes&lt;/a&gt; for details.&lt;/p&gt;
-
-&lt;h2 id=&quot;credits&quot;&gt;Credits&lt;/h2&gt;
-
-&lt;p&gt;The Xtext project is thankful for the dedication of each committer and contributor. This release has been made possible by the following persons (in order of the number of contributed commits to this release to &lt;a href=&quot;https://github.com/eclipse/xtext#repositories&quot;&gt;all repositories&lt;/a&gt; except &lt;a href=&quot;https://github.com/eclipse/xtext-xtend&quot;&gt;xtext-xtend&lt;/a&gt;):&lt;/p&gt;
-
-&lt;ul&gt;
-  &lt;li&gt;Christian Dietrich (itemis)&lt;/li&gt;
-  &lt;li&gt;Karsten Thoms (itemis)&lt;/li&gt;
-  &lt;li&gt;Sebastian Zarnekow (itemis)&lt;/li&gt;
-  &lt;li&gt;Jan Koehnlein (TypeFox)&lt;/li&gt;
-  &lt;li&gt;Holger Schill (itemis)&lt;/li&gt;
-  &lt;li&gt;Arne Deutsch (itemis)&lt;/li&gt;
-  &lt;li&gt;Christian Schneider (TypeFox)&lt;/li&gt;
-  &lt;li&gt;Titouan Vervack (Sigasi)&lt;/li&gt;
-  &lt;li&gt;Max Leuthäuser (itemis) &lt;img src=&quot;https://img.shields.io/badge/-first%20time%20contributor-green.svg&quot; alt=&quot;&quot; /&gt;&lt;/li&gt;
-  &lt;li&gt;Akos Kitta (TypeFox)&lt;/li&gt;
-  &lt;li&gt;Lorenzo Addazi&lt;/li&gt;
-  &lt;li&gt;Lorenzo Bettini (Università degli Studi di Firenze)&lt;/li&gt;
-  &lt;li&gt;Tamas Miklossy (itemis)&lt;/li&gt;
-  &lt;li&gt;Dennis Huebner (TypeFox)&lt;/li&gt;
-  &lt;li&gt;RhiobeT &lt;img src=&quot;https://img.shields.io/badge/-first%20time%20contributor-green.svg&quot; alt=&quot;&quot; /&gt;&lt;/li&gt;
-  &lt;li&gt;Sergio Otero Lopez &lt;img src=&quot;https://img.shields.io/badge/-first%20time%20contributor-green.svg&quot; alt=&quot;&quot; /&gt;&lt;/li&gt;
-  &lt;li&gt;Eva Poell (itemis)&lt;/li&gt;
-  &lt;li&gt;Lieven Lemiengre (Sigasi)&lt;/li&gt;
-  &lt;li&gt;Mark Christiaens (Sigasi)&lt;/li&gt;
-  &lt;li&gt;Michael Budnick (all4net) &lt;img src=&quot;https://img.shields.io/badge/-first%20time%20contributor-green.svg&quot; alt=&quot;&quot; /&gt;&lt;/li&gt;
-  &lt;li&gt;Stéphane Galland (Université de Technologie de Belfort)&lt;/li&gt;
-&lt;/ul&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. Almost 100 issues and 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.18+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.18+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.18&amp;amp;list_id=16618269&amp;amp;product=TMF&amp;amp;product=Xtend&amp;amp;query_based_on=Xtext%202.18&amp;amp;query_format=advanced&amp;amp;status_whiteboard=v2.18&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 Jun 2019 00:00:00 +0000</pubDate>
-        <link>http://xtext.org/Xtext/releasenotes/2019/06/04/version-2-18-0.html</link>
-        <guid isPermaLink="true">http://xtext.org/Xtext/releasenotes/2019/06/04/version-2-18-0.html</guid>
-        
-        
-        <category>releasenotes</category>
-        
-      </item>
-    
   </channel>
 </rss>
diff --git a/releasenotes.html b/releasenotes.html
index 2ac80fe..c57d417 100644
--- a/releasenotes.html
+++ b/releasenotes.html
@@ -134,6 +134,8 @@
 					<h3>Table of Contents</h3>
 					<ul>
 						
+							<li><p><a href="#/releasenotes/2022/08/29/version-2-28-0">Xtext 2.28.0 Release Notes &mdash; Aug 29, 2022</a></p>
+						
 							<li><p><a href="#/releasenotes/2022/05/30/version-2-27-0">Xtext 2.27.0 Release Notes &mdash; May 30, 2022</a></p>
 						
 							<li><p><a href="#/releasenotes/2022/02/28/version-2-26-0">Xtext 2.26.0 Release Notes &mdash; Feb 28, 2022</a></p>
@@ -152,12 +154,68 @@
 						
 							<li><p><a href="#/releasenotes/2019/09/03/version-2-19-0">Xtext 2.19.0 Release Notes &mdash; Sep 3, 2019</a></p>
 						
-							<li><p><a href="#/releasenotes/2019/06/04/version-2-18-0">Xtext 2.18.0 Release Notes &mdash; Jun 4, 2019</a></p>
-						
 					</ul>
 				</div>
 				
 				  <hr/>
+				  <section id="/releasenotes/2022/08/29/version-2-28-0">
+				  	<h1>Xtext 2.28.0 Release Notes<small>&nbsp;&nbsp;Aug 29, 2022</small></h1>
+				    <br/>
+				    <p>Xtext 2.28.0 is a maintenance release.</p>
+
+<h2 id="call-to-action-secure-the-future-maintenance-of-xtext">Call to Action: Secure the future maintenance of Xtext</h2>
+
+<p>As you might have recognized, the number of people contributing to Xtext on a regular basis has declined over the past years and so has the number of contributions. At the same time the amount of work for basic maintenance has stayed the same or even increased with the new release cadence of Java and the Eclipse simultaneous release. Briefly: The future maintenance of Xtext is at risk, at least in the current form and as part of the Eclipse Simrel. If you care, please join the discussion in <a href="https://github.com/eclipse/xtext/issues/1721">https://github.com/eclipse/xtext/issues/1721</a>.</p>
+
+<h2 id="changes-to-orgeclipsextextsdk-feature">Changes to <code>org.eclipse.xtext.sdk</code> feature.</h2>
+
+<p>The <code>org.eclipse.xtext.sdk</code> does no longer package the deprecated <code>org.eclipse.xtext.generator</code> bundle. Please migrate to the new workflow/generator. The old and deprecated generator can still be found in the new <code>org.eclipse.xtext.generator</code> feature.</p>
+
+<h2 id="upgrades">Upgrades</h2>
+
+<ul>
+  <li>LSP4J was updated to 0.15.0</li>
+  <li>GSON was updated to 2.9.0</li>
+</ul>
+
+<h2 id="changes--enhancements">Changes / Enhancements</h2>
+
+<ul>
+  <li>LSP Code was optimized and enhanced. We have e.g. done some enhancements to Quickfix API.</li>
+  <li>Xtext Supports M2E 2.x</li>
+  <li>Xbase based formatters now can be subclassed in Java more easily.</li>
+  <li>Better support for needRebuild api in platform.</li>
+</ul>
+
+<h2 id="credits">Credits</h2>
+
+<p>The Xtext project is thankful for the dedication of each committer and contributor. This release has been made possible by the following persons (in order of the number of contributed commits to this release to <a href="https://github.com/eclipse/xtext#repositories">all repositories</a> except <a href="https://github.com/eclipse/xtext-xtend">xtext-xtend</a>):</p>
+
+<p>Christian Dietrich (itemis)<br />
+Ruben Porras<br />
+Karsten Thoms (karakun)<br />
+Frank Benoit (ETAS)<br />
+Hannes Wellmann (IILS mbH) <img src="https://img.shields.io/badge/-first%20time%20contributor-green.svg" alt="" /></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. 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.28+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.28+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.28&amp;list_id=16618269&amp;product=TMF&amp;product=Xtend&amp;query_based_on=Xtext%202.28&amp;query_format=advanced&amp;status_whiteboard=v2.28&amp;status_whiteboard_type=allwordssubstr">Fixed Eclipse Bugzilla tickets</a></p>
+  </li>
+</ul>
+
+				  </section>
+				
+				  <hr/>
 				  <section id="/releasenotes/2022/05/30/version-2-27-0">
 				  	<h1>Xtext 2.27.0 Release Notes<small>&nbsp;&nbsp;May 30, 2022</small></h1>
 				    <br/>
@@ -939,145 +997,6 @@
 
 				  </section>
 				
-				  <hr/>
-				  <section id="/releasenotes/2019/06/04/version-2-18-0">
-				  	<h1>Xtext 2.18.0 Release Notes<small>&nbsp;&nbsp;Jun 4, 2019</small></h1>
-				    <br/>
-				    <p>Xtext 2.18.0 is mainly a maintenance release.</p>
-
-<h2 id="eclipse-integration">Eclipse Integration</h2>
-
-<h3 id="search-references-result-page-new-context-actions">Search References Result Page: New Context Actions</h3>
-
-<p>The results of the <em>Search References</em> action can now be copied to the clipboard. Further an action has been added to remove search results from the view. Both actions are available from the context menu and by common keyboard shortcuts.</p>
-
-<p><img src="/Xtext/images/releasenotes/2_18_SearchReferencesResultActions.png" alt="Search References Result Page: New Context Actions" height="50%" width="50%" /></p>
-
-<h3 id="new-quickfix-on-empty-keywords">New Quickfix on Empty Keywords</h3>
-
-<p>Grammar rules with empty keyword statements (<code>''</code>) are raising errors already. Two new quickfixes have been added that can be used to resolve these errors:</p>
-
-<ul>
-  <li>Remove the empty keyword</li>
-  <li>Set the keyword value from the declaring rule name</li>
-</ul>
-
-<p>(<a href="https://github.com/eclipse/xtext-eclipse/issues/994">xtext-eclipse#994</a>)</p>
-
-<h3 id="fixed-potential-deadlock-on-startup">Fixed Potential Deadlock on Startup</h3>
-
-<p>A deadlock may occur on startup of Eclipse. The builder infrastructure has been improved to avoid locking on loading its stored state. (<a href="https://github.com/eclipse/xtext/issues/1460">#1460</a>)</p>
-
-<h3 id="fixed-exceptions-for-closed-projects">Fixed: Exceptions for Closed Projects</h3>
-
-<p>When projects are removed from the workspace the <code>ProjectOpenedOrClosedListener</code> may caused exceptions that were logged to the error log. This situation has been fixed with <a href="https://github.com/eclipse/xtext-eclipse/issues/1066">xtext-eclipse#1066</a>.</p>
-
-<h3 id="refactoring-support-improved-progress-reporting">Refactoring Support: Improved Progress Reporting</h3>
-
-<p>The <code>ResourceRelocationProcessor</code> did not forward the progress monitor to the change serializer, which prevented proper feedback and cancellation support during the application of a rename refactoring. The progress monitor is now forwarded. (<a href="https://github.com/eclipse/xtext-eclipse/issues/1053">xtext-eclipse#1053</a>)</p>
-
-<h3 id="refactoring-support-improved-memory-utilization">Refactoring Support: Improved Memory Utilization</h3>
-
-<p>During rename or move refactorings a temporary resource set is created and populated. This resource set was kept in memory, leading to unnecessary memory consumption. Now the memory held by this temporary resource set is released properly. (<a href="https://github.com/eclipse/xtext-eclipse/issues/1048">xtext-eclipse#1048</a>)</p>
-
-<h2 id="lsp-integration">LSP Integration</h2>
-
-<h3 id="ilanguageserveraccess-provide-access-to-xtext-index"><code>ILanguageServerAccess</code>: Provide Access to Xtext Index</h3>
-
-<p>A new method <code>doReadIndex</code> has been added to <code>ILanguageServerAccess</code> to allow access to the <code>IResourceDescritions</code> instance (a.k.a. the Xtext Index). This is useful for certain use cases for LS extension developers. (<a href="https://github.com/eclipse/xtext-core/issues/1067">xtext#1067</a>)</p>
-
-<h3 id="report-partial-results-of-cancelled-multi-project-builds">Report Partial Results of Cancelled Multi-Project Builds</h3>
-
-<p>When a multi-project build is canceled (another <code>runWrite</code> coming in from the <code>RequestManager</code>), it could be that some projects have already been built. Even though their <code>ProjectManager</code>s have been updated (e.g. their index state), their deltas were never returned, because the <code>BuildManager</code> aggregated all results in a local variable. Build listeners were never be informed about these changes.</p>
-
-<p>The <code>BuildManager</code> has been improved to report also partial results to listeners. (<a href="https://github.com/eclipse/xtext-core/issues/1124">xtext-core#1124</a>)</p>
-
-<h3 id="improved-handling-of-builds-cancellations-by-didchangewatchedfiles-notifications">Improved Handling of Builds Cancellations by <code>didChangeWatchedFiles</code> Notifications</h3>
-
-<p>When editing files in an auto-saving editor, <code>didChange</code> notifications are usually followed by <code>didChangeWatchedFiles</code> notifications. The latter cancel the build, but only look at their own changes to decide whether a new build should be issued. The changes from the prior <code>didChange</code> queued on the <code>BuildManager</code> were ignored.</p>
-
-<p>This issue has been improved by reprocessing URIs from cancelled builds in. (<a href="https://github.com/eclipse/xtext-core/issues/1121">xtext-core#1121</a>)</p>
-
-<h3 id="fixed-unexpected-occurrance-highlighting">Fixed Unexpected Occurrance Highlighting</h3>
-
-<p>In certain situations occurrances were not highlighted properly. The highlighting service has been improved for that. See <a href="https://github.com/eclipse/xtext-core/issues/1090">xtext-core#1090</a> for details.</p>
-
-<h2 id="xtext-grammar--code-generator">Xtext Grammar &amp; Code Generator</h2>
-
-<h3 id="fixed-illegal-whitespace-removal-in-merged-manifests">Fixed: Illegal Whitespace Removal in Merged Manifests</h3>
-
-<p>When re-generating language implementations whitespace was illegally removed for required bundles with changed versions. (<a href="https://github.com/eclipse/xtext-extras/issues/406">xtext-extras#406</a>)</p>
-
-<h2 id="security">Security</h2>
-
-<p>With <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=544852">Bug#544852</a> a theoretical security issue was reported (CVE-2019-10249). While building Xtext artifacts may be downloaded through HTTP instead of HTTPS. To avoid this, all build related resources have been revised and assured that all artifacts participating in the software build are only downloaded with HTTPS.</p>
-
-<ul>
-  <li>p2 mirrors are disabled for builds using Eclipse Tycho. (<a href="https://github.com/eclipse/xtext/issues/1427">#1427</a>)</li>
-  <li>p2 repository URLs changed from HTTP to HTTPS. (<a href="https://github.com/eclipse/xtext-xtend/issues/759">xtext-xtend#759</a>)</li>
-  <li>Maven repository URLs changed from HTTP to HTTPS. (<a href="https://github.com/eclipse/xtext-maven/issues/74">xtext-maven</a>)</li>
-</ul>
-
-<h2 id="upgrades">Upgrades</h2>
-
-<ul>
-  <li>LSP4J has been upgraded to its latest release 0.7.2.</li>
-  <li>The Java Bytecode Manipultation library ASM has been upgraded to version 7.1.0. (<a href="https://github.com/eclipse/xtext/issues/1440">#1440</a>)</li>
-  <li>Gradle based projects have been upgraded to use the Gradle Wrapper version 5.4.1.</li>
-  <li>Eclipse Tycho has been upgraded to release 1.4.0. (<a href="https://github.com/eclipse/xtext/issues/1422">#1422</a>)</li>
-  <li>In Gradle builds usages of Spring’s <code>dependency-management-plugin</code> have been upgraded to version 1.0.7.RELEASE. (<a href="https://github.com/eclipse/xtext/issues/1420">#1420</a>)</li>
-</ul>
-
-<h2 id="new-features-in-xtend">New Features in Xtend</h2>
-
-<p>Xtend has learned try-with-resources and the ternary operator. See the <a href="https://www.eclipse.org/xtend/releasenotes.html#/releasenotes/2019/06/04/version-2-18-0">Xtend Releasenotes</a> for details.</p>
-
-<h2 id="credits">Credits</h2>
-
-<p>The Xtext project is thankful for the dedication of each committer and contributor. This release has been made possible by the following persons (in order of the number of contributed commits to this release to <a href="https://github.com/eclipse/xtext#repositories">all repositories</a> except <a href="https://github.com/eclipse/xtext-xtend">xtext-xtend</a>):</p>
-
-<ul>
-  <li>Christian Dietrich (itemis)</li>
-  <li>Karsten Thoms (itemis)</li>
-  <li>Sebastian Zarnekow (itemis)</li>
-  <li>Jan Koehnlein (TypeFox)</li>
-  <li>Holger Schill (itemis)</li>
-  <li>Arne Deutsch (itemis)</li>
-  <li>Christian Schneider (TypeFox)</li>
-  <li>Titouan Vervack (Sigasi)</li>
-  <li>Max Leuthäuser (itemis) <img src="https://img.shields.io/badge/-first%20time%20contributor-green.svg" alt="" /></li>
-  <li>Akos Kitta (TypeFox)</li>
-  <li>Lorenzo Addazi</li>
-  <li>Lorenzo Bettini (Università degli Studi di Firenze)</li>
-  <li>Tamas Miklossy (itemis)</li>
-  <li>Dennis Huebner (TypeFox)</li>
-  <li>RhiobeT <img src="https://img.shields.io/badge/-first%20time%20contributor-green.svg" alt="" /></li>
-  <li>Sergio Otero Lopez <img src="https://img.shields.io/badge/-first%20time%20contributor-green.svg" alt="" /></li>
-  <li>Eva Poell (itemis)</li>
-  <li>Lieven Lemiengre (Sigasi)</li>
-  <li>Mark Christiaens (Sigasi)</li>
-  <li>Michael Budnick (all4net) <img src="https://img.shields.io/badge/-first%20time%20contributor-green.svg" alt="" /></li>
-  <li>Stéphane Galland (Université de Technologie de Belfort)</li>
-</ul>
-
-<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. Almost 100 issues and 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.18+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.18+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.18&amp;list_id=16618269&amp;product=TMF&amp;product=Xtend&amp;query_based_on=Xtext%202.18&amp;query_format=advanced&amp;status_whiteboard=v2.18&amp;status_whiteboard_type=allwordssubstr">Fixed Eclipse Bugzilla tickets</a></p>
-  </li>
-</ul>
-
-				  </section>
-				
 			
 		</div>
   	</div>
diff --git a/releasenotes/2022/08/29/version-2-28-0.html b/releasenotes/2022/08/29/version-2-28-0.html
new file mode 100644
index 0000000..97595a1
--- /dev/null
+++ b/releasenotes/2022/08/29/version-2-28-0.html
@@ -0,0 +1,287 @@
+<!DOCTYPE html>
+<html>
+
+  <head>
+	<meta charset="UTF-8">
+	<title>Xtext - Xtext 2.28.0 Release Notes</title>
+	
+	<meta name="viewport" content="width=device-width, initial-scale=1.0">
+	<meta name="description"
+		content="The website of Eclipse Xtext, an open-source framework for development of programming languages and domain-specific languages">
+	<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="/Xtext/images/favicon.png">
+	
+	<link href="/Xtext/css/bootstrap.css" rel="stylesheet" type='text/css'>
+	<link href="/Xtext/css/bootstrap-responsive.css" rel="stylesheet" type='text/css'>
+	<link href="/Xtext/css/shield-responsive.css" rel="stylesheet" type='text/css'>
+	<link href='/Xtext/css/fonts.css' rel='stylesheet' type='text/css'>
+	<link href="/Xtext/css/prettyPhoto.css" rel="stylesheet" media="screen" type='text/css'>
+	<link href="/Xtext/css/prettify.css" type="text/css" rel="stylesheet"/>
+	<link href="/Xtext/css/style.css" rel="stylesheet" type='text/css'>
+	<!-- cover flow -->
+	<link href="/Xtext/css/coverflow.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>
+  
+    <header class="site-header">
+
+  <!-- Navbar -->
+  <div class="navbar navbar-fixed-top">
+    <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="/Xtext/index.html"></a>
+        <div class="nav-collapse collapse" style="height: 0px;">
+          <ul class="nav">
+            <!--li ><a href="/Xtext/news.html">News</a></li-->
+            <li ><a href="/Xtext/download.html">Download</a></li>
+            <li ><a href="/Xtext/documentation/index.html">Documentation</a></li>
+            <li ><a href="/Xtext/community.html">Community</a></li>
+            <li class="dropdown">
+              <a class="dropdown-toggle" data-toggle="dropdown" href="#">Support &amp; Trainings<span class="caret"></span></a>
+              <ul class="dropdown-menu">
+                <li><a href="https://www.itemis.com/en/xtext/support-and-team/" target="_blank">itemis</a></li>
+                <li><a href="https://www.typefox.io/language-engineering/" target="_blank">TypeFox</a></li>
+              </ul>
+            </li>
+            <li ><a href="http://xtend-lang.org">Xtend</a></li>
+          </ul>
+          <!--div class="nav pull-right">
+            <li ><a><iframe src="https://ghbtns.com/github-btn.html?user=eclipse&repo=xtext&type=star&count=true" frameborder="0" scrolling="0" width="170px" height="20px"></iframe></a></li>
+          </div-->
+        </div>
+        <!--/.nav-collapse -->
+      </div>
+    </div>
+  </div>
+  <!-- Navbar End -->
+
+</header>
+
+
+    <div class="page-content">
+  <div class="wrapper">
+    <div id="page">  
+    	<div class="inner">
+    		<br/><br/>
+    		<div id="maincontainer" class="container">
+    			<div class="span8 offset1">
+    				<h1>Xtext 2.28.0 Release Notes</h1>
+    				<h4>Aug 29, 2022</h4>
+    				<br/>
+    				<p>Xtext 2.28.0 is a maintenance release.</p>
+
+<h2 id="call-to-action-secure-the-future-maintenance-of-xtext">Call to Action: Secure the future maintenance of Xtext</h2>
+
+<p>As you might have recognized, the number of people contributing to Xtext on a regular basis has declined over the past years and so has the number of contributions. At the same time the amount of work for basic maintenance has stayed the same or even increased with the new release cadence of Java and the Eclipse simultaneous release. Briefly: The future maintenance of Xtext is at risk, at least in the current form and as part of the Eclipse Simrel. If you care, please join the discussion in <a href="https://github.com/eclipse/xtext/issues/1721">https://github.com/eclipse/xtext/issues/1721</a>.</p>
+
+<h2 id="changes-to-orgeclipsextextsdk-feature">Changes to <code>org.eclipse.xtext.sdk</code> feature.</h2>
+
+<p>The <code>org.eclipse.xtext.sdk</code> does no longer package the deprecated <code>org.eclipse.xtext.generator</code> bundle. Please migrate to the new workflow/generator. The old and deprecated generator can still be found in the new <code>org.eclipse.xtext.generator</code> feature.</p>
+
+<h2 id="upgrades">Upgrades</h2>
+
+<ul>
+  <li>LSP4J was updated to 0.15.0</li>
+  <li>GSON was updated to 2.9.0</li>
+</ul>
+
+<h2 id="changes--enhancements">Changes / Enhancements</h2>
+
+<ul>
+  <li>LSP Code was optimized and enhanced. We have e.g. done some enhancements to Quickfix API.</li>
+  <li>Xtext Supports M2E 2.x</li>
+  <li>Xbase based formatters now can be subclassed in Java more easily.</li>
+  <li>Better support for needRebuild api in platform.</li>
+</ul>
+
+<h2 id="credits">Credits</h2>
+
+<p>The Xtext project is thankful for the dedication of each committer and contributor. This release has been made possible by the following persons (in order of the number of contributed commits to this release to <a href="https://github.com/eclipse/xtext#repositories">all repositories</a> except <a href="https://github.com/eclipse/xtext-xtend">xtext-xtend</a>):</p>
+
+<p>Christian Dietrich (itemis)<br />
+Ruben Porras<br />
+Karsten Thoms (karakun)<br />
+Frank Benoit (ETAS)<br />
+Hannes Wellmann (IILS mbH) <img src="https://img.shields.io/badge/-first%20time%20contributor-green.svg" alt="" /></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. 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.28+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.28+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.28&amp;list_id=16618269&amp;product=TMF&amp;product=Xtend&amp;query_based_on=Xtext%202.28&amp;query_format=advanced&amp;status_whiteboard=v2.28&amp;status_whiteboard_type=allwordssubstr">Fixed Eclipse Bugzilla tickets</a></p>
+  </li>
+</ul>
+
+    			</div>
+    		</div>
+      </div>
+    </div>
+  </div>
+</div>
+    
+    <footer class="site-footer">
+  <div id="extra">
+    <div class="inner">
+      <div class="container">
+        <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://www.planeteclipse.org/">Eclipse Planet</a></li>
+              <li><a href="https://www.eclipse.org/forums/index.php/f/27/">Xtext Forum</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/xtext"><img src="/Xtext/images/Twitter-bird-darkgray.png" class="img-responsive" style="margin-right: 5px;height: 1em;" alt="Twitter icon">@xtext on Twitter</a>
+              </li>
+            </ul>
+          </div>
+        </div>
+      </div>
+    </div>
+  </div>
+  <a href="#" class="scrollup fadeOutRight animated" style="display: none;">ScrollUp</a>
+  <!-- Le javascript
+      ================================================== -->
+  <!-- Placed at the end of the document so the pages load faster -->
+  
+  <script src="/Xtext/js/jquery-1.11.3.min.js"></script>
+  <script src="/Xtext/js/bootstrap.min.js"></script>
+  <script src="/Xtext/js/jquery.easing.1.3.js" type="text/javascript"></script>
+  <script src="/Xtext/js/jquery.prettyPhoto.js" type="text/javascript"></script>
+  <script src="/Xtext/js/prettify.js" type="text/javascript"></script>
+  <script src="/Xtext/js/lang-xtend.js" type="text/javascript"></script>
+  <script src="/Xtext/js/lang-common.js" type="text/javascript"></script>
+  <script src="/Xtext/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-3' ]);
+    _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-->
+  <script src="/Xtext/js/coverflow.min.js" type="text/javascript"></script>
+  <script>
+      $(function() {
+        $('#coverflow').coverflow({
+          active : 1,
+          visibleAside: 2,
+          overlap : 0.5,
+          scale : 0.9,
+          angle : 20,
+          trigger : {
+            "itemfocus" : true,
+            "swipe" : true,
+            "mousewheel" : false
+          }
+        });
+        $('#coverflow :hidden').toggle();
+        $(window).resize(function() {
+          $('#coverflow').coverflow();
+        });
+      });
+
+  </script>
+</footer>
+
+
+  </body>
+
+</html>
