diff --git a/core/installer/app_repository.go b/core/installer/app_repository.go
index 4f15b7d..b51f766 100644
--- a/core/installer/app_repository.go
+++ b/core/installer/app_repository.go
@@ -21,16 +21,16 @@
 	"values-tmpl/url-shortener.cue",
 	"values-tmpl/matrix.cue",
 	"values-tmpl/vaultwarden.cue",
-	"values-tmpl/open-project.cue",
+	// "values-tmpl/open-project.cue",
 	"values-tmpl/gerrit.cue",
 	"values-tmpl/jenkins.cue",
 	"values-tmpl/zot.cue",
-	"values-tmpl/penpot.cue",
+	// "values-tmpl/penpot.cue",
 	"values-tmpl/soft-serve.cue",
 	"values-tmpl/pihole.cue",
 	// "values-tmpl/maddy.cue",
-	"values-tmpl/qbittorrent.cue",
-	"values-tmpl/jellyfin.cue",
+	// "values-tmpl/qbittorrent.cue",
+	// "values-tmpl/jellyfin.cue",
 	"values-tmpl/rpuppy.cue",
 }
 
diff --git a/core/installer/values-tmpl/launcher.cue b/core/installer/values-tmpl/launcher.cue
index 07bc41e..8aabbd5 100644
--- a/core/installer/values-tmpl/launcher.cue
+++ b/core/installer/values-tmpl/launcher.cue
@@ -9,7 +9,6 @@
 
 _subdomain: "launcher"
 _domain: "\(_subdomain).\(networks.public.domain)"
-url: "https://\(_domain)"
 
 name: "Launcher"
 namespace: "launcher"
diff --git a/core/installer/values-tmpl/vaultwarden.cue b/core/installer/values-tmpl/vaultwarden.cue
index 072b5f2..fd2962c 100644
--- a/core/installer/values-tmpl/vaultwarden.cue
+++ b/core/installer/values-tmpl/vaultwarden.cue
@@ -47,3 +47,8 @@
 		}
 	}
 }
+
+help: [{
+	title: "Access"
+	contents: "Open [\(url)](\(url)) in a new tab."
+}]
diff --git a/core/installer/welcome/appmanager-tmpl/app.html b/core/installer/welcome/appmanager-tmpl/app.html
index 64c1458..bc3e1d2 100644
--- a/core/installer/welcome/appmanager-tmpl/app.html
+++ b/core/installer/welcome/appmanager-tmpl/app.html
@@ -81,6 +81,27 @@
 {{ end }}
 
 {{ define "main" }}
+<style>
+  pre {
+    white-space: pre-wrap;       /* Since CSS 2.1 */
+    white-space: -moz-pre-wrap;  /* Mozilla, since 1999 */
+    white-space: -pre-wrap;      /* Opera 4-6 */
+    white-space: -o-pre-wrap;    /* Opera 7 */
+    word-wrap: break-word;       /* Internet Explorer 5.5+ */
+    background-color: transparent;
+  }
+
+ .hidden {
+     visibility: hidden;
+ }
+
+ .toast {
+     position: fixed;
+     z-index: 999;
+     bottom: 10px;
+ }
+</style>
+
 {{ $instance := .Instance }}
 <h1 style="margin-bottom: 20px">{{ .App.Icon }}{{ .App.Name }}</h1>
 <pre id="readme" style="margin-bottom: 50px">{{ .App.Description }}</pre>
@@ -143,27 +164,6 @@
   <svg xmlns="http://www.w3.org/2000/svg" width="36" height="36" viewBox="0 0 24 24"><path fill="none" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5" d="M12 22c5.523 0 10-4.477 10-10S17.523 2 12 2S2 6.477 2 12s4.477 10 10 10Zm3-6L9 8m0 8l6-8"/></svg> Failed to uninstall application
 </div>
 
-<style>
-  pre {
-    white-space: pre-wrap;       /* Since CSS 2.1 */
-    white-space: -moz-pre-wrap;  /* Mozilla, since 1999 */
-    white-space: -pre-wrap;      /* Opera 4-6 */
-    white-space: -o-pre-wrap;    /* Opera 7 */
-    word-wrap: break-word;       /* Internet Explorer 5.5+ */
-    background-color: transparent;
-  }
-
- .hidden {
-     visibility: hidden;
- }
-
- .toast {
-     position: fixed;
-     z-index: 999;
-     bottom: 10px;
- }
-</style>
-
 <script>
  let config = {{ if $instance }}JSON.parse({{ toJson ($instance.InputToValues $schema) }}){{ else }}{}{{ end }};
 
diff --git a/core/installer/welcome/appmanager-tmpl/index.html b/core/installer/welcome/appmanager-tmpl/index.html
index 02150ff..2306876 100644
--- a/core/installer/welcome/appmanager-tmpl/index.html
+++ b/core/installer/welcome/appmanager-tmpl/index.html
@@ -1,4 +1,26 @@
 {{ define "main" }}
+<style>
+  article {
+    margin: 0.3em;
+    margin-bottom: 0.3em;
+
+    display: flex;
+    flex-direction: row;
+  }
+
+  .logo {
+    display: table-cell;
+    vertical-align: middle;
+  }
+  nav li {
+    padding-top: 0;
+    padding-bottom: 0;
+  }
+
+  input[type="search"] {
+    margin-bottom: 0;
+  }
+</style>
 <form>
   <input type="search" placeholder="Search" />
 </form>
@@ -24,27 +46,4 @@
     </ul>
   </nav>
 </aside>
-
-<style>
-  article {
-    margin: 0.3em;
-    margin-bottom: 0.3em;
-
-    display: flex;
-    flex-direction: row;
-  }
-
-  .logo {
-    display: table-cell;
-    vertical-align: middle;
-  }
-  nav li {
-    padding-top: 0;
-    padding-bottom: 0;
-  }
-
-  input[type="search"] {
-    margin-bottom: 0;
-  }
-</style>
 {{ end }}
diff --git a/core/installer/welcome/env-manager-tmpl/base.html b/core/installer/welcome/env-manager-tmpl/base.html
index a9ca048..689ca79 100644
--- a/core/installer/welcome/env-manager-tmpl/base.html
+++ b/core/installer/welcome/env-manager-tmpl/base.html
@@ -2,7 +2,7 @@
 <html lang="en" data-theme="light">
 	<head>
 		<link rel="stylesheet" href="/static/pico.2.0.6.min.css">
-		<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/hack-font@3/build/web/hack.css">
+		<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/hack-font/3.3.0/web/hack.min.css">
 		<link rel="stylesheet" href="/static/main.css">
 		<meta charset="utf-8" />
 		<meta name="viewport" content="width=device-width, initial-scale=1" />
diff --git a/core/installer/welcome/env-manager-tmpl/status.html b/core/installer/welcome/env-manager-tmpl/status.html
index 65e1e15..87ed86d 100644
--- a/core/installer/welcome/env-manager-tmpl/status.html
+++ b/core/installer/welcome/env-manager-tmpl/status.html
@@ -1,7 +1,7 @@
 {{ define "task" }}
 {{ range . }}
 <li aria-busy="{{ eq .Status 1 }}">
-	{{ .Title }}{{ if .Err }} - {{ .Err.Error }} {{ end }}
+	{{ if eq .Status 3 }}<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24"><path fill="black" d="M21 7L9 19l-5.5-5.5l1.41-1.41L9 16.17L19.59 5.59z"/></svg>{{ end }}{{ .Title }}{{ if .Err }} - {{ .Err.Error }} {{ end }}
 	{{ if .Subtasks }}
 	<ul>
    		{{ template "task" .Subtasks }}
@@ -30,12 +30,11 @@
 		{{ if .DNSRecords }}
 		<form action="" method="POST">
 			<p>You will have to publish following DNS records via your domain registrar.</p>
-			<textarea rows="7" disabled>{{ .DNSRecords }}</textarea>
+			<textarea rows="7">{{ .DNSRecords }}</textarea>
 			<label for="domain-registrar">Domain Registrar</label>
 			<select id="domain-registrar" required tabindex="1">
 				<option value="" selected>Select registrar</option>
 				<option value="gandi">Gandi</option>
-				<option value="namecheap">Namecheap</option>
 			</select>
 			<label for="api-token">API Token</label>
 			<input
@@ -59,7 +58,11 @@
 	 if (resp.ok) {
 		 var tmp = document.createElement("html");
 		 tmp.innerHTML = await resp.text();
-		 document.getElementById("contents").innerHTML = tmp.getElementsByClassName("env-status")[0].innerHTML;
+		 if (document.getElementsByTagName("form").length === 0) {
+			 document.getElementById("contents").innerHTML = tmp.getElementsByClassName("env-status")[0].innerHTML;
+		 } else {
+			 document.getElementsByClassName("progress")[0].innerHTML = tmp.getElementsByClassName("progress")[0].innerHTML;
+		 }
 	 }
 	 setTimeout(refresh, 5000);
  }
diff --git a/core/installer/welcome/launcher-tmpl/launcher.html b/core/installer/welcome/launcher-tmpl/launcher.html
index 24f5c27..6b79d80 100644
--- a/core/installer/welcome/launcher-tmpl/launcher.html
+++ b/core/installer/welcome/launcher-tmpl/launcher.html
@@ -3,7 +3,7 @@
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>App Launcher</title>
+    <title>dodo: Launcher</title>
     <link rel="stylesheet" type="text/css" href="/static/pico.2.0.6.min.css">
     <link rel="stylesheet" type="text/css" href="/static/launcher.css">
 </head>
diff --git a/core/installer/welcome/static/launcher.js b/core/installer/welcome/static/launcher.js
index b8c2ae5..a1a88e9 100644
--- a/core/installer/welcome/static/launcher.js
+++ b/core/installer/welcome/static/launcher.js
@@ -1,4 +1,6 @@
 document.addEventListener("DOMContentLoaded", function () {
+  document.querySelector('iframe').contentDocument.write("Welcome to the dodo: application launcher, think of it as your desktop environment. You can launch applications from left-hand side dock. You should setup VPN clients on your devices, so you can install applications from Application Manager and access your private network. Instructions on how to do that can be viewed by clicking <b>Help</b> button after hovering over <b>Headscale</b> icon in the dock.");
+
     function showTooltip(obj) {
         // obj.style.display = 'flex';
         obj.style.visibility = 'visible';
