diff --git a/templates/de/doc/korap/koral.html.ep b/templates/de/doc/korap/koral.html.ep
index 861eb52..1c52293 100644
--- a/templates/de/doc/korap/koral.html.ep
+++ b/templates/de/doc/korap/koral.html.ep
@@ -6,6 +6,6 @@
 
 <p><strong>Hauptentwickler:</strong> Joachim Bingel</p>
 
-<p>Koral ist eine Bibliothek, die für die Übersetzung verschiedener Korpus-Abfragesprachen nach <%= embedded_link_to('KoralQuery', 'api', 'koralquery')%> konzipiert ist. Derzeit unterstützte Abfragesprachen sind <%= embedded_link_to 'Cosmas II', 'ql', 'cosmas2'%>, <%= embedded_link_to('Annis QL', 'ql', 'annis')%>, <%= embedded_link_to ( 'Poliqarp +', 'ql', 'poliqarp-plus')%> (eine erweiterte Version von Poliqarp) und <%= embedded_link_to('CQL', 'ql', 'cql')%>.
+<p>Koral ist eine Bibliothek, die für die Übersetzung verschiedener Korpus-Abfragesprachen nach <%= embedded_link_to('doc', 'KoralQuery', 'api', 'koralquery')%> konzipiert ist. Derzeit unterstützte Abfragesprachen sind <%= embedded_link_to 'doc', 'Cosmas II', 'ql', 'cosmas2'%>, <%= embedded_link_to('doc', 'Annis QL', 'ql', 'annis')%>, <%= embedded_link_to('doc',  'Poliqarp+', 'ql', 'poliqarp-plus')%> (eine erweiterte Version von Poliqarp) und <%= embedded_link_to('doc', 'CQL', 'ql', 'cql')%>.
 
 <p>Koral ist Open Source und steht unter <%= ext_link_to 'GitHub', "https://github.com/KorAP/Koral"%> zur Verfügung.</p>
diff --git a/templates/de/doc/korap/krill.html.ep b/templates/de/doc/korap/krill.html.ep
index 64aab10..ba138d0 100644
--- a/templates/de/doc/korap/krill.html.ep
+++ b/templates/de/doc/korap/krill.html.ep
@@ -6,6 +6,6 @@
 
 <p><strong>Hauptentwickler:</strong> Nils Diewald, Eliza Margaretha</p>
 
-<p>Krill ist eine <%= ext_link_to 'Lucene', "https://lucene.apache.org/"%> basierte Suchmaschine für große kommentierte Korpora, die als Backend-Komponente für KorAP verwendet wird. Es ist die Referenzimplementierung für <%= embedded_link_to('KoralQuery', 'api', 'koralquery')%>, die die meisten Protokolleigenschaften abdeckt.</p>
+<p>Krill ist eine <%= ext_link_to 'Lucene', "https://lucene.apache.org/"%> basierte Suchmaschine für große kommentierte Korpora, die als Backend-Komponente für KorAP verwendet wird. Es ist die Referenzimplementierung für <%= embedded_link_to('doc', 'KoralQuery', 'api', 'koralquery')%>, die die meisten Protokolleigenschaften abdeckt.</p>
 
 <p>Krill ist Open Source und steht unter <%= ext_link_to 'GitHub', "https://github.com/KorAP/Krill"%> zur Verfügung.</p>
diff --git a/templates/de/doc/ql/poliqarp-plus.html.ep b/templates/de/doc/ql/poliqarp-plus.html.ep
index 9080f8e..d203a98 100644
--- a/templates/de/doc/ql/poliqarp-plus.html.ep
+++ b/templates/de/doc/ql/poliqarp-plus.html.ep
@@ -23,7 +23,7 @@
 
   <h4 id="regexp">Reguläre Ausdrücke</h4>
 
-  <p>Segmente können auch durch <%= embedded_link_to 'Reguläre Ausdrücke', 'ql', 'regexp' %> abgefragt werden - indem das Segment mit doppelten Anführungszeichen umschlossen wird.</p>
+  <p>Segmente können auch durch <%= embedded_link_to 'doc', 'Reguläre Ausdrücke', 'ql', 'regexp' %> abgefragt werden - indem das Segment mit doppelten Anführungszeichen umschlossen wird.</p>
 
   %= doc_query poliqarp => loc('Q_poliqarp_re', '** "r(u|a)n"'), cutoff => 1
 
@@ -72,12 +72,12 @@
 
   %= doc_query poliqarp => loc('Q_poliqarp_complexre', '** [orth="r(u|a)n"/xi]'), cutoff => 1
 
-  <p>Ein weiterer spezieller Schlüssel ist <code>base</code>, bezogen auf die Lemma-Annotation der <%= embedded_link_to 'Standard-Foundry', 'data', 'annotation'%>.
+  <p>Ein weiterer spezieller Schlüssel ist <code>base</code>, bezogen auf die Lemma-Annotation der <%= embedded_link_to 'doc', 'Standard-Foundry', 'data', 'annotation'%>.
     Die folgende Abfrage findet alle Vorkommen von Segmenten, die mit dem eingegebenen Lemma in der Standard-Foundry annotiert wurden.</p>
 
   %= doc_query poliqarp => loc('Q_poliqarp_complexlemma', '** [base=Tree]'), cutoff => 1
 
-  <p>Der dritte Sonderschlüssel ist <code>pos</code> und bezieht sich auf die Wortarten-Annotation der <%= embedded_link_to 'Standard-Foundry', 'data', 'annotation'%>.
+  <p>Der dritte Sonderschlüssel ist <code>pos</code> und bezieht sich auf die Wortarten-Annotation der <%= embedded_link_to 'doc', 'Standard-Foundry', 'data', 'annotation'%>.
     Die folgende Abfrage findet alle attributiven Adjektive:</p>
 
   %= doc_query poliqarp => loc('Q_poliqarp_complexpos', '** [pos=ADJA]'), cutoff => 1
@@ -99,7 +99,7 @@
 
   <blockquote class="warning">
     <p>Vorsicht: Negierte komplexe Segmente können nicht alleinstehend gesucht werden.
-      Allerdings funktionieren sie, wenn sie Teil einer <%= embedded_link_to 'Sequenz', 'ql', 'poliqarp-plus#syntagmatic-operators-sequence'%> sind.</p>
+      Allerdings funktionieren sie, wenn sie Teil einer <%= embedded_link_to 'doc', 'Sequenz', 'ql', 'poliqarp-plus#syntagmatic-operators-sequence'%> sind.</p>
   </blockquote>
 
   <h4 id="empty-segments">Leere Segmente</h4>
@@ -108,11 +108,11 @@
 
   %= doc_query poliqarp => '[]', cutoff => 1
 
-  <p>Leere Segmente sind nützlich, um Abstände von Wörtern auszudrücken, indem sie <%= embedded_link_to 'Wiederholungen', 'ql', 'poliqarp-plus#syntagmatic-operators-repetitions' %> verwenden.</p>
+  <p>Leere Segmente sind nützlich, um Abstände von Wörtern auszudrücken, indem sie <%= embedded_link_to 'doc', 'Wiederholungen', 'ql', 'poliqarp-plus#syntagmatic-operators-repetitions' %> verwenden.</p>
 
   <blockquote class="warning">
     <p>Vorsicht: Leere Segmente können nicht alleinstehend gesucht werden. 
-      Allerdings funktionieren sie, wenn sie Teil einer <%= embedded_link_to 'Sequenz', 'ql', 'poliqarp-plus#syntagmatic-operators-sequence' %> sind.</p>
+      Allerdings funktionieren sie, wenn sie Teil einer <%= embedded_link_to 'doc', 'Sequenz', 'ql', 'poliqarp-plus#syntagmatic-operators-sequence' %> sind.</p>
   </blockquote>
 </section>
 
@@ -193,7 +193,7 @@
 
   <h4 id="syntagmatic-operators-repetitions">Wiederholungen</h4>
 
-  <p>Wiederholungen in Poliqarp werden wie in <%= embedded_link_to 'regulären Ausdrücken', 'ql', 'regexp'%> realisiert, indem Quantifizierer in geschweifte Klammern gesetzt werden.</p>
+  <p>Wiederholungen in Poliqarp werden wie in <%= embedded_link_to 'doc', 'regulären Ausdrücken', 'ql', 'regexp'%> realisiert, indem Quantifizierer in geschweifte Klammern gesetzt werden.</p>
 
     <p>Um eine Sequenz von drei Vorkommen eines Wortes zu suchen, können Sie Ihre Abfrage auf eine der folgenden Arten formulieren - sie werden die selben Ergebnisse erhalten:</p>
 
@@ -234,7 +234,7 @@
     <p>Denken Sie daran, dass Optionalität auf unterschiedliche Arten <i>vererbt</i> sein kann, zum Beispiel wird eine ganze Abfrage optional, sobald ein Segment der Alternative optional ist.</p>
   </blockquote>
 
-  <p>Die Wiederholung kann auch verwendet werden, um Distanzen zwischen Segmenten auszudrücken, indem Sie <%= embedded_link_to 'leere Segmente', 'ql', 'poliqarp-plus # leere Segmente'%> verwenden.</p>
+  <p>Die Wiederholung kann auch verwendet werden, um Distanzen zwischen Segmenten auszudrücken, indem Sie <%= embedded_link_to 'doc', 'leere Segmente', 'ql', 'poliqarp-plus # leere Segmente'%> verwenden.</p>
 
   %= doc_query poliqarp => loc('Q_poliqarp_seqdistance1', '** [base=the][][base=Tree]'), cutoff => 1
   %= doc_query poliqarp => loc('Q_poliqarp_seqdistance2', '** [base=the][]{2}[base=Tree]'), cutoff => 1
@@ -249,7 +249,7 @@
     
   <h4>Positionen</h4>
 
-    <p>Sequenzen wie oben können in weiteren komplexen Abfragen verschachtelt und als Unterabfragen behandelt werden (siehe <%= embedded_link_to 'Klassenoperatoren', 'ql', 'poliqarp-plus#class-operator' %>, um direkten Zugriff auf Unterabfragen zu erhalten).</p>
+    <p>Sequenzen wie oben können in weiteren komplexen Abfragen verschachtelt und als Unterabfragen behandelt werden (siehe <%= embedded_link_to 'doc', 'Klassenoperatoren', 'ql', 'poliqarp-plus#class-operator' %>, um direkten Zugriff auf Unterabfragen zu erhalten).</p>
     
     <p>Positionsoperatoren vergleichen zwei Treffer von Unterabfragen und ergeben einen Treffer, falls eine bestimmte Bedingung bezüglich der Position von beiden wahr ist.</p>
 
