diff --git a/community.html b/community.html
index dc54aa1..715dcf5 100644
--- a/community.html
+++ b/community.html
@@ -809,16 +809,6 @@
 					</tr>
 
 					<tr>
-						<td><a href="http://www.gentleware.com/poseidon-for-dsls.html">Poseidon for DSLs</a></td>
-						<td>Framework for creating graphical tools for DSLs, based on internal
-							Xtext models. Poseidon for UML 8.0 as a sample DSL platform.
-						</td>
-						<td>commercial</td>
-						<td>Framework</td>
-						<td>Gentleware AG</td>
-					</tr>
-
-					<tr>
 						<td><a href="https://github.com/Protelis/Protelis">Protelis</a></td>
 						<td>Protelis is a programming language aiming to produce reliable and robust collective behavior from uncoordinated local interactions among an assortment of different potentially mobile devices. Protelis is grounded on the paradigm of <i>aggregate programming</i>, a way of thinking about and decomposing problems that can be solved with a network of distributed sensors and computers.</td>
 						<td>GPL with linking exception</td>
diff --git a/documentation/302_configuration.html b/documentation/302_configuration.html
index 97e4ce9..7cd8d41 100644
--- a/documentation/302_configuration.html
+++ b/documentation/302_configuration.html
@@ -268,7 +268,7 @@
 
 <p>This documentation is about the new generator infrastructure introduced with Xtext 2.9. In order to migrate an older Xtext project to this new infrastructure, the recommended approach is to create a new Xtext project and copy the grammar and existing configuration from the old project to the new one step by step.</p>
 
-<p>The entry point for Xtext code generation is <a href="https://github.com/eclipse/xtext-core/blob/master/org.eclipse.xtext.xtext.generator/src/org/eclipse/xtext/xtext/generator/XtextGenerator.xtend">XtextGenerator</a>, which is composed of a <em>general configuration</em> and a set of <em>language configurations</em>. The general configuration describes the structure of your project as well as general settings for generating code. Each language configuration corresponds to a specific grammar file and allows to configure the generated code for the respective language. The actual code generation is performed by <em>generator fragments</em> contained in a language configuration.</p>
+<p>The entry point for Xtext code generation is <a href="https://github.com/eclipse/xtext-core/blob/master/org.eclipse.xtext.xtext.generator/src/org/eclipse/xtext/xtext/generator/XtextGenerator.java">XtextGenerator</a>, which is composed of a <em>general configuration</em> and a set of <em>language configurations</em>. The general configuration describes the structure of your project as well as general settings for generating code. Each language configuration corresponds to a specific grammar file and allows to configure the generated code for the respective language. The actual code generation is performed by <em>generator fragments</em> contained in a language configuration.</p>
 
 <p>In the following we see an exemplary language generator configuration written in MWE2:</p>
 
@@ -372,7 +372,7 @@
   <li><code>preferXtendStubs</code> – Whether to prefer Xtend over Java for stub files to be implemented manually; this option applies only to files in <code>src</code> folders, while for <code>src-gen</code> folders Java files are always generated.</li>
 </ul>
 
-<p>The container for the <a href="https://github.com/eclipse/xtext-core/blob/master/org.eclipse.xtext.xtext.generator/src/org/eclipse/xtext/xtext/generator/model/project/StandardProjectConfig.java">StandardProjectConfig</a> and <a href="https://github.com/eclipse/xtext-core/blob/master/org.eclipse.xtext.xtext.generator/src/org/eclipse/xtext/xtext/generator/CodeConfig.java">CodeConfig</a> is of type <a href="https://github.com/eclipse/xtext-core/blob/master/org.eclipse.xtext.xtext.generator/src/org/eclipse/xtext/xtext/generator/DefaultGeneratorModule.java">DefaultGeneratorModule</a> and is assigned to the property <code>configuration</code> of the <a href="https://github.com/eclipse/xtext-core/blob/master/org.eclipse.xtext.xtext.generator/src/org/eclipse/xtext/xtext/generator/XtextGenerator.xtend">XtextGenerator</a>. The DefaultGeneratorModule is actually a <a href="https://github.com/google/guice">Guice</a> module, which can be subclassed in a similar way as explained in <a href="#dependency-injection">Dependency Injection</a> for overriding default configurations. This allows to alter the configuration in places that are not accessible through MWE2. For instance, you could bind your own subclass of <a href="https://github.com/eclipse/xtext-core/blob/master/org.eclipse.xtext.xtext.generator/src/org/eclipse/xtext/xtext/generator/XtextGeneratorNaming.java">XtextGeneratorNaming</a> in order to influence the names of generated classes.</p>
+<p>The container for the <a href="https://github.com/eclipse/xtext-core/blob/master/org.eclipse.xtext.xtext.generator/src/org/eclipse/xtext/xtext/generator/model/project/StandardProjectConfig.java">StandardProjectConfig</a> and <a href="https://github.com/eclipse/xtext-core/blob/master/org.eclipse.xtext.xtext.generator/src/org/eclipse/xtext/xtext/generator/CodeConfig.java">CodeConfig</a> is of type <a href="https://github.com/eclipse/xtext-core/blob/master/org.eclipse.xtext.xtext.generator/src/org/eclipse/xtext/xtext/generator/DefaultGeneratorModule.java">DefaultGeneratorModule</a> and is assigned to the property <code>configuration</code> of the <a href="https://github.com/eclipse/xtext-core/blob/master/org.eclipse.xtext.xtext.generator/src/org/eclipse/xtext/xtext/generator/XtextGenerator.java">XtextGenerator</a>. The DefaultGeneratorModule is actually a <a href="https://github.com/google/guice">Guice</a> module, which can be subclassed in a similar way as explained in <a href="#dependency-injection">Dependency Injection</a> for overriding default configurations. This allows to alter the configuration in places that are not accessible through MWE2. For instance, you could bind your own subclass of <a href="https://github.com/eclipse/xtext-core/blob/master/org.eclipse.xtext.xtext.generator/src/org/eclipse/xtext/xtext/generator/XtextGeneratorNaming.java">XtextGeneratorNaming</a> in order to influence the names of generated classes.</p>
 
 <h3 id="language-configuration">Language Configuration</h3>
 
diff --git a/feed.xml b/feed.xml
index df3ad4a..8446088 100644
--- a/feed.xml
+++ b/feed.xml
@@ -6,8 +6,8 @@
 </description>
     <link>http://xtext.org/Xtext/</link>
     <atom:link href="http://xtext.org/Xtext/feed.xml" rel="self" type="application/rss+xml"/>
-    <pubDate>Mon, 27 Sep 2021 06:05:50 +0000</pubDate>
-    <lastBuildDate>Mon, 27 Sep 2021 06:05:50 +0000</lastBuildDate>
+    <pubDate>Thu, 18 Nov 2021 14:14:04 +0000</pubDate>
+    <lastBuildDate>Thu, 18 Nov 2021 14:14:04 +0000</lastBuildDate>
     <generator>Jekyll v2.5.3</generator>
     
       <item>
diff --git a/releasenotes/2017/02/01/version-2-11-0.html b/releasenotes/2017/02/01/version-2-11-0.html
index 229d571..b9c2620 100644
--- a/releasenotes/2017/02/01/version-2-11-0.html
+++ b/releasenotes/2017/02/01/version-2-11-0.html
@@ -240,7 +240,7 @@
 
 <h3 id="old-xtext-generator">Old Xtext Generator</h3>
 
-<p>With Xtext 2.9 a <a href="/Xtext/releasenotes.html#/releasenotes/2015/11/16/version-2-9-0">new generator infrastructure was introduced</a>. In favor of this new generator <a href="https://github.com/eclipse/xtext-core/issues/58">the old generator has been deprecated</a>. Bugfixes will be done primarily for the new generator and most of them will not be backported, thus it is highly recommended to migrate your languages’ <code>.mwe2</code> workflows to use the new <a href="https://github.com/eclipse/xtext-core/blob/master/org.eclipse.xtext.xtext.generator/src/org/eclipse/xtext/xtext/generator/XtextGenerator.xtend"><code>org.eclipse.xtext.xtext.XtextGenerator</code></a> component.</p>
+<p>With Xtext 2.9 a <a href="/Xtext/releasenotes.html#/releasenotes/2015/11/16/version-2-9-0">new generator infrastructure was introduced</a>. In favor of this new generator <a href="https://github.com/eclipse/xtext-core/issues/58">the old generator has been deprecated</a>. Bugfixes will be done primarily for the new generator and most of them will not be backported, thus it is highly recommended to migrate your languages’ <code>.mwe2</code> workflows to use the new <a href="https://github.com/eclipse/xtext-core/blob/master/org.eclipse.xtext.xtext.generator/src/org/eclipse/xtext/xtext/generator/XtextGenerator.java"><code>org.eclipse.xtext.xtext.XtextGenerator</code></a> component.</p>
 
 <h3 id="running-the-language-generator-from-maven">Running the Language Generator from Maven</h3>
 
