diff --git a/kalamar.conf b/kalamar.conf
index 96df587..b9d1519 100644
--- a/kalamar.conf
+++ b/kalamar.conf
@@ -36,7 +36,11 @@
 
     # In case, the user management of Kustvakt
     # is used, make this a true value
-    auth_support => 0
+    auth_support => 0,
+
+    # The name of the base corpus,
+    # for query examples (see kalamar.queries.dict)
+    # examplecorpus => 'corola'
   },
 
   # See Mojolicious::Plugin::TagHelpers::MailToChiffre
diff --git a/kalamar.queries.dict b/kalamar.queries.dict
new file mode 100644
index 0000000..0a3eacf
--- /dev/null
+++ b/kalamar.queries.dict
@@ -0,0 +1,12 @@
+{
+  Q => {
+    _ => sub { shift->config('Kalamar')->{'examplecorpus'} },
+    -dereko => {
+      poliqarp => {
+        simple => 'Baum',
+        simpleseq => 'der Baum',
+        simpleci => 'laufen/i'
+      }
+    }
+  }
+};
diff --git a/lib/Kalamar.pm b/lib/Kalamar.pm
index 95d4762..b89b968 100644
--- a/lib/Kalamar.pm
+++ b/lib/Kalamar.pm
@@ -101,7 +101,7 @@
 
   # Localization framework
   $self->plugin(Localize => {
-    resources => ['kalamar.dict']
+    resources => ['kalamar.dict', 'kalamar.queries.dict']
   });
 
   # Pagination widget
diff --git a/templates/de/doc/ql/poliqarp-plus.html.ep b/templates/de/doc/ql/poliqarp-plus.html.ep
index 757c407..fa85afa 100644
--- a/templates/de/doc/ql/poliqarp-plus.html.ep
+++ b/templates/de/doc/ql/poliqarp-plus.html.ep
@@ -9,17 +9,17 @@
 
   <p>Die einzelnen Elemente von Poliqarp sind Segmente. Meistens repräsentieren Segmente Wörter und können leicht abgefragt werden:</p>
 
-  %= doc_query poliqarp => 'Baum'
+  %= doc_query poliqarp => loc('Q_poliqarp_simple', 'Tree')
 
   <p>Abfolgen einfacher Segmenten werden durch Leerzeichen getrennt:</p>
 
-  %= doc_query poliqarp => 'der Baum'
+  %= doc_query poliqarp => loc('Q_poliqarp_simpleseq', 'the Tree')
 
   <p>Einfache Segmente beziehen sich immer auf die Oberflächenform eines Wortes. Wenn Sie nach einer Oberflächenform ohne Beachtung der Groß- und Kleinschreibung suchen, können Sie <code>/i</code> anfügen.</p>
 
-  %= doc_query poliqarp => 'laufen/i'
+  %= doc_query poliqarp => loc('Q_poliqarp_simpleci', 'run/i')
 
-  <p>Die Abfrage oben findet alle Vorkommen von <code>laufen</code> unabhängig von der Großschreibung von Buchstaben, so wird <code>wir laufen</code> genauso gefunden wie <code>das Laufen</code> und sogar <code>&quot;GEH LAUFEN!&quot;</code>.
+  <p>Die Abfrage oben findet alle Vorkommen des Wortes unabhängig von der Großschreibung von Buchstaben.
 
   <h4 id="regexp">Reguläre Ausdrücke</h4>
 
@@ -243,7 +243,7 @@
     
   <h4>Positionen</h4>
 
-    <p>Sequenzen wie oben gezeigt können in weiteren komplexen Abfragen verschachtelt und als Unterabfragen behandelt werden (siehe <%= doc_link_to 'Klassenoperatoren', 'ql', 'poliqarp-plus#class-operator' %>, um direkten Zugriff auf auf Unterabfragen zu erhalten).</p>
+    <p>Sequenzen wie oben gezeigt können in weiteren komplexen Abfragen verschachtelt und als Unterabfragen behandelt werden (siehe <%= doc_link_to 'Klassenoperatoren', 'ql', 'poliqarp-plus#class-operator' %>, um direkten Zugriff auf Unterabfragen zu erhalten).</p>
     
     <p>Positionsoperatoren vergleichen zwei Varianten von Unterabfragen und ergeben einen Treffer, falls eine bestimmte Bedingung bezüglich der Position von beiden wahr ist.</p>
 
diff --git a/templates/doc/ql/poliqarp-plus.html.ep b/templates/doc/ql/poliqarp-plus.html.ep
index 884f21a..68b079d 100644
--- a/templates/doc/ql/poliqarp-plus.html.ep
+++ b/templates/doc/ql/poliqarp-plus.html.ep
@@ -10,17 +10,17 @@
   <p>The atomic elements of Poliqarp queries are segments. Most of the time segments represent words and can be simply queried:</p>
   %# footnote: In the polish national corpus, Poliqarp can join multiple segments when identifying a single word.
 
-  %= doc_query poliqarp => 'Baum'
+  %= doc_query poliqarp => loc('Q_poliqarp_simple', 'Tree')
 
   <p>Sequences of simple segments are expressed using a space delimiter:</p>
 
-  %= doc_query poliqarp => 'der Baum'
+  %= doc_query poliqarp => loc('Q_poliqarp_simpleseq', 'the Tree')
 
   <p>Simple segments always refer to the surface form of a word. To search for surface forms without case sensitivity, you can use the <code>/i</code> flag.</p>
 
-  %= doc_query poliqarp => 'laufen/i'
+  %= doc_query poliqarp => loc('Q_poliqarp_simpleci', 'run/i')
 
-  <p>The query above will find all occurrences of <code>laufen</code> irrespective of the capitalization of letters, so <code>wir laufen</code> will be found as well as <code>das Laufen</code> and even <code>&quot;GEH LAUFEN!&quot;</code>.</p>
+  <p>The query above will find all occurrences of the term irrespective of the capitalization of letters.</p>
 
   <h4 id="regexp">Regular Expressions</h4>
 
