diff --git a/data/kalamar.xs.conf b/data/kalamar.xs.conf
index c03dc0d..81b800a 100644
--- a/data/kalamar.xs.conf
+++ b/data/kalamar.xs.conf
@@ -40,9 +40,15 @@
      mount => 'http://kalamar-export-plugin:7777',
      service => 'export-plugin-proxy'
   }],
+  navi_ext => [
+        {
+        "title" => "virtual_subcorpora",
+        "id" => "virtual_subcorpora"
+      }
+    ],
  },
   CSP => {
-    'frame-src' => 'self',
+    'frame-src' => ['self','https://korap.dnb.de/','https://korap.ids-mannheim.de','https://www.youtube.com'],
     'frame-ancestors' => ['self','http://korap.dnb.de/','https://korap.dnb.de/']
    },
  'Kalamar-Plugins' => {
@@ -50,6 +56,8 @@
   },
   Localize => {
     dict => {
+      'en_Nav_virtual_subcorpora' => 'Useful Virtual Subcorpora',
+      'de_Nav_virtual_subcorpora' => 'Nützliche virtuelle Subkorpora',
       'en_title_addon' => 'DeLiKo@DNB',
       'de_Template_intro' => 'custom/intro',
       'en_Template_intro' => 'custom/intro',
