diff --git a/kalamar.ids-mannheim.conf b/kalamar.ids-mannheim.conf
index 8674272..36890b0 100644
--- a/kalamar.ids-mannheim.conf
+++ b/kalamar.ids-mannheim.conf
@@ -29,8 +29,23 @@
     },
     navi_ext => [
       {
-        "title" => "corpora",
-        "id" => "corpus"
+        "title" => "corpus",
+        "id" => "corpus",
+        "class" => "folded",
+        "items" => [
+          {
+            "title" => "composition",
+            "id" => "composition"
+          },
+          {
+            "title" => "useful_subcorpora",
+            "id" => "useful_subcorpora"
+          },
+          {
+            "title" => "named_vc",
+            "id" => "named_vc"
+          }
+        ]
       },
       {
         "title" => "Privacy",
@@ -86,6 +101,14 @@
       en_currentdb => 'Current data set: Virtual corpus <%= t code => stash("vc") %>',
       de_compositionbysource => 'Zusammensetzung nach Quelle',
       en_compositionbysource => 'Composition by source',
+      de_Title_composition => 'Korpus-Zusammensetzung',
+      en_Title_composition => 'Corpus Composition',
+      en_Nav_composition => 'Composition',
+      de_Nav_composition => 'Zusammensetzung',
+      en_Nav_useful_subcorpora => 'Useful subcorpora',
+      de_Nav_useful_subcorpora => 'Nützliche Subkorpora',
+      en_Nav_named_vc => 'Named VC',
+      de_Nav_named_vc => 'Benamte VC',
     }
   },
   'TagHelpers-ContentBlock' => {
diff --git a/templates/custom/doc/corpus.html.ep b/templates/custom/doc/corpus.html.ep
index 6f33a5a..4751515 100644
--- a/templates/custom/doc/corpus.html.ep
+++ b/templates/custom/doc/corpus.html.ep
@@ -1,12 +1,75 @@
-% layout 'main', title => 'KorAP: ' . loc('Nav_corpora');
-
+% layout 'main', title => 'KorAP: ' . loc('Nav_corpus');
+% my $corpus = 'DeReKo-KorAP-2026-I';
 %= page_title
-
+<style>
+  section { max-width: 50em; }
+  dl dt { margin-top: 1em; font-weight: bold; }
+  dl dd { margin-left: 1.5em; }
+</style>
 <section> 
-  <p><%== loc 'currentdb', vc => 'dereko-korap-2026-I' %></p>
-  <h3><%= loc 'compositionbysource' %></h3>
-  <iframe src="https://korap.ids-mannheim.de/data/dereko-korap-2026-I.html" sandbox="allow-forms allow-same-origin allow-scripts allow-popups" style="position: relative; border-width: 0; min-height: 40vh" height="45%" width="100%"></iframe>
-
-  <h3><%= loc 'usefulvcs' %></h3>
-  <iframe src="https://korap.ids-mannheim.de/data/useful_dereko_corpora.html" sandbox="allow-forms allow-same-origin allow-scripts allow-popups" style="position: relative; border-width: 0; min-height: 40vh" height="45%" width="100%"></iframe>
+% my $lang = c(@{$c->localize->locale})->first(qr!^(?i:de|en)$!) // 'en';
+% if ($lang eq 'de') {
+  <h3>Datengrundlage</h3>
+  <p>
+    Grundlage dieser KorAP-Instanz ist das Korpus <a href="corpus/composition?embedded=true"><strong><%=$corpus%></strong></a>, 
+    ein virtuelles Subkorpus der entsprechenden Version des 
+    <a href="https://www.ids-mannheim.de/digspra/pb-s1/projekte/korpora/archiv-1/">Deutschen Referenzkorpus DeReKo</a>, 
+    das am IDS vom <a href="https://www.ids-mannheim.de/digspra/pb-s1/projekte/korpora/">Korpusausbauprojekt</a> gepflegt wird.
+    </p>
+    <p>
+    <%=$corpus%> enthält neben dem W-Gesamt-Archiv aus COSMAS II u.a. Korpora, die die Abdeckung bezüglich Region oder Textsorte verbessern und/oder vom Rat für Deutsche Rechtschreibung benötigt werden.
+  </p>
+  <p>
+    Eine genaue Übersicht über die Zusammensetzung von <%=$corpus%> finden Sie auf der Seite <a href="corpus/composition?embedded=true">Zusammensetzung nach Quelle</a>.
+  </p>
+  <h3>Virtuelle Subkorpora</h3>
+    <p>DeReKo und KorAP laden ihre Nutzer:innen ein, sich selbst ein bezüglich ihrer aktuellen Fragestellung und gemeinten Sprachdomäne möglichst repräsentatives virtuelles Subkorpus zu definieren.
+  </p>
+  <dl>
+    <dt><a href="corpus/useful_subcorpora?embedded=true">Häufig verwendete Subkorpora</a></dt>
+    <dd>Einige häufig verwendete Zusammenstellungen finden Sie vordefiniert. Sie können alle Definitionen an Ihre Bedürfnisse anpassen.</dd>
+    
+    <dt><a href="corpus/named_vc?embedded=true">Persistente virtuelle Korpora</a></dt>
+    <dd>Persistent definierte, meistens auch über COSMAS II zugängliche virtuelle Subkorpora.</dd>
+    
+    <dt>Ihre Vorschläge</dt>
+    <dd>Wenn Sie Ihr eigenes virtuelles Subkorpus persistent machen oder Ergänzungen vorschlagen möchten, melden Sie sich einfach <%= mail_to_chiffre join('@', 'corpuslinguistics', 'ids-mannheim.de'), subject => 'VC request', begin %>per E-Mail<% end %> bei uns.</dd>
+  </dl>
+ <h3>Wie zitieren?</h3>
+ <p>
+    Hinweise zum Zitieren der Datengrundlage und der Analyseplattform KorAP finden sie unter <%= link_to loc("howToCite") => url_for(doc => { page => "faq" })->fragment("howToCite")->query({ embedded => "true" }) %>.
+  </p>
+% } else {
+  <h3>Data Basis</h3>
+  <p>
+    The basis of this KorAP instance is the corpus <a href="corpus/composition?embedded=true"><strong><%=$corpus%></strong></a>, 
+    a virtual subcorpus of the corresponding version of the 
+    <a href="https://www.ids-mannheim.de/digspra/pb-s1/projekte/korpora/archiv-1/">German Reference Corpus DeReKo</a>, 
+    maintained by the <a href="https://www.ids-mannheim.de/digspra/pb-s1/projekte/korpora/">Corpus Development Project</a> at IDS.
+  </p>
+  <p>
+    <%=$corpus%> contains, in addition to the W-Gesamt archive from COSMAS II, corpora that improve coverage regarding region or text type and/or are required by the Council for German Orthography.
+  </p>
+  <p>
+    A detailed overview of the composition of <%=$corpus%> can be found on the <a href="corpus/composition?embedded=true">Composition by Source</a> page.
+  </p>
+  <h3>Virtual Subcorpora</h3>
+    <p>
+    DeReKo and KorAP invite their users to define their own virtual subcorpus that is as representative as possible with regard to their current research question and intended language domain.
+    </p>
+  <dl>   
+    <dt><a href="corpus/useful_subcorpora?embedded=true">Frequently Used Subcorpora</a></dt>
+    <dd>Some frequently used collections are available predefined. You can adapt all definitions to your needs.</dd>
+    
+    <dt><a href="corpus/named_vc?embedded=true">Persistent Virtual Corpora</a></dt>
+    <dd>Persistently defined virtual subcorpora, mostly also accessible via COSMAS II.</dd>
+    
+    <dt>Your Suggestions</dt>
+    <dd>If you would like to make your own virtual subcorpus persistent or suggest additions, simply contact us <%= mail_to_chiffre join('@', 'corpuslinguistics', 'ids-mannheim.de'), subject => 'VC request', begin %>via email<% end %>.</dd>
+  </dl>
+  <h3>How to Cite?</h3>
+  <p>
+    Information on citing the data basis and the KorAP analysis platform can be found at <%= link_to loc("howToCite") => url_for(doc => { page => "faq" })->fragment("howToCite")->query({ embedded => "true" }) %>.
+  </p>
+% }
 </section>
diff --git a/templates/custom/doc/corpus/composition.html.ep b/templates/custom/doc/corpus/composition.html.ep
new file mode 100644
index 0000000..61906c1
--- /dev/null
+++ b/templates/custom/doc/corpus/composition.html.ep
@@ -0,0 +1,6 @@
+% layout 'main', title => 'KorAP: ' . loc('Title_composition');
+%= page_title
+<section> 
+  <h3>DeReKo-KorAP-2026-I</h3>
+  <iframe src="https://korap.ids-mannheim.de/data/dereko-korap-2026-I.html" sandbox="allow-forms allow-same-origin allow-scripts allow-popups" style="position: relative; border-width: 0; min-height: 90vh" height="90%" width="100%"></iframe>
+</section>
diff --git a/templates/custom/doc/corpus/named_vc.html.ep b/templates/custom/doc/corpus/named_vc.html.ep
new file mode 100644
index 0000000..6023ea8
--- /dev/null
+++ b/templates/custom/doc/corpus/named_vc.html.ep
@@ -0,0 +1,5 @@
+% layout 'main', title => 'KorAP: ' . loc('Nav_named_vc');
+%= page_title
+<section> 
+  <iframe src="https://korap.ids-mannheim.de/data/named_vc.html" sandbox="allow-forms allow-same-origin allow-scripts allow-popups" style="position: relative; border-width: 0; min-height: 90vh" height="90%" width="100%"></iframe>
+</section>
diff --git a/templates/custom/doc/corpus/useful_subcorpora.html.ep b/templates/custom/doc/corpus/useful_subcorpora.html.ep
new file mode 100644
index 0000000..edd7120
--- /dev/null
+++ b/templates/custom/doc/corpus/useful_subcorpora.html.ep
@@ -0,0 +1,10 @@
+% layout 'main', title => 'KorAP: ' . loc('Nav_useful_subcorpora');
+%= page_title
+<section> 
+% my $lang = c(@{$c->localize->locale})->first(qr!^(?i:de|en)$!) // 'en';
+% if ($lang eq 'de') {
+  <iframe src="https://korap.ids-mannheim.de/data/useful_dereko_corpora.html" sandbox="allow-forms allow-same-origin allow-scripts allow-popups" style="position: relative; border-width: 0; min-height: 90vh" height="90%" width="100%"></iframe>
+% } else {
+  <iframe src="https://korap.ids-mannheim.de/data/useful_dereko_corpora_en.html" sandbox="allow-forms allow-same-origin allow-scripts allow-popups" style="position: relative; border-width: 0; min-height: 90vh" height="90%" width="100%"></iframe>
+% }
+</section>
