diff --git a/app/app.py b/app/app.py
index 09aa5d8..afe12fc 100644
--- a/app/app.py
+++ b/app/app.py
@@ -378,22 +378,23 @@ option = st.sidebar.radio("hidden_label",
 
 # Optionales einzeiliges Eingabefeld nur für bestimmte Funktionen
 additional_parameter = None
-if option in ["Vigenere-Chiffre", "Wolseley-Chiffre", "Autokey-Chiffre", "Polybios kodieren", "Polybios dekodieren"]:
+if ("Vigenere-Chiffre" or "Wolseley-Chiffre" or "Autokey-Chiffre" or "Polybios kodieren" or
+        "Polybios dekodieren" in option):
     additional_parameter = st.text_input(
         "Schlüsselwort:",
         placeholder="Schlüsselwort hier eingeben"
     )
-elif option in ["Mono.-Substitution"]:
+elif "Mono.-Substitution" in option:
     additional_parameter = st.text_input(
         "Schlüsselwort/Schlüsselalphabet:",
         placeholder="Schlüsselwort/Schlüsselalphabet hier eingeben"
     )
-elif option in ["Jägerzaun kodieren", "Jägerzaun dekodieren"]:
+elif "Jägerzaun kodieren" or "Jägerzaun dekodieren" in option:
     additional_parameter = st.text_input(
         "Schlüsselfeld:",
         placeholder="Schlüsselzahl hier eingeben"
     )
-elif option in ["ADFGX kodieren", "ADFGX dekodieren", "ADFGVX kodieren", "ADFGVX dekodieren"]:
+elif "ADFGX kodieren" or "ADFGX dekodieren" or "ADFGVX kodieren" or "ADFGVX dekodieren" in option:
     additional_parameter = st.text_input(
         "Passwörter:",
         placeholder="PasswortEins, PasswortZwei"
diff --git a/app/helper.py b/app/helper.py
index 1ac6e17..d41a09b 100644
--- a/app/helper.py
+++ b/app/helper.py
@@ -237,7 +237,7 @@ def remorse_germandic(eingabetext):
     ualphabet["...--.."] = "ß"
     eingabetext = eingabetext.rstrip()
     wbfile = open("./data/german.dic", "r", encoding="iso-8859-15")
-    ausgabetext = "_der eingegebene Morsecode kann für folgendes stehen:_  \n"
+    ausgabetext = ":blue[der eingegebene Morsecode kann für folgendes stehen:]  \n"
     if eingabetext in ualphabet:
         ausgabetext += ualphabet[eingabetext] + "  \n"
     for zeile in wbfile:
@@ -264,7 +264,7 @@ def t9_germandic(eingabetext):
                 '-': '1', ',': '1', '+': '0', ')': '1', '(': '1', 'SS': '7'}
     eingabetext = eingabetext.rstrip()
     wbfile = open("./data/german.dic", "r", encoding="iso-8859-15")
-    ausgabetext = "_der eingegebene T9-Code kann für folgendes stehen:_  \n"
+    ausgabetext = ":blue[der eingegebene T9-Code kann für folgendes stehen:]  \n"
     for zeile in wbfile:
         zeile = zeile.strip(" \t\n\r")
         mzeile = ""
diff --git a/app/tools.py b/app/tools.py
index 4bc8fd5..fdf539c 100644
--- a/app/tools.py
+++ b/app/tools.py
@@ -32,7 +32,7 @@ def cesar_all(eingabetext):
                             atxt = atxt + abc[j + r - 26]
                         else:
                             atxt = atxt + abc[j + r]
-            ausgabe += f"__{r:02}:__ {atxt}  \n"
+            ausgabe += f":blue[{r:02}:] {atxt}  \n"
         return ausgabe
 
 def buchstabenwortwert(eingabetext):
@@ -85,21 +85,21 @@ def buchstabenwortwert(eingabetext):
         ausgabe += atxt + "  \n"
         ausgabe += '|    |    |\n'
         ausgabe += '|----|----|\n'
-        ausgabe += "|_Buchstabenwerte:_|"
+        ausgabe += "|:blue[Buchstabenwerte:]|"
         ausgabe += az[0:-1] + "|\n"
-        ausgabe += "|_Buchstabenwortwerte:_|"
+        ausgabe += "|:blue[Buchstabenwortwerte:]|"
         ausgabe += eworttxt[0:-1] + "|\n"
-        ausgabe += "|_Summe aller Buchstabenwerte:_|"
+        ausgabe += "|:blue[Summe aller Buchstabenwerte:]|"
         ausgabe += str(wortsumme) + "|\n"
-        ausgabe += "|_Quersumme der Summe aller Buchstabenwerte / iterierte Quersumme:_|"
+        ausgabe += "|:blue[Quersumme der Summe aller Buchstabenwerte / iterierte Quersumme:]|"
         ausgabe += str(helper.q_sum(wortsumme)) + " / " + str(helper.iq_sum(wortsumme)) + "|\n"
-        ausgabe += "|_Buchstabenanzahl pro Wort:_|"
+        ausgabe += "|:blue[Buchstabenanzahl pro Wort:]|"
         ausgabe += banzwtxt[0:-1] + "|\n"
-        ausgabe += "|_Gesamtanzahl aller Buchstaben:_|"
+        ausgabe += "|:blue[Gesamtanzahl aller Buchstaben:]|"
         ausgabe += str(banzahla) + "|\n"
-        ausgabe += "|_Wortprodukte(0 wenn kein Buchstabe gefunden):_|"
+        ausgabe += "|:blue[Wortprodukte(0 wenn kein Buchstabe gefunden):]|"
         ausgabe += ewortptxt[0:-1] + "|\n"
-        ausgabe += "|_Buchstabenwert-Produkt:(Nullen werden ignoriert):_|"
+        ausgabe += "|:blue[Buchstabenwert-Produkt:(Nullen werden ignoriert):]|"
         ausgabe += str(wortprodukt) + "|\n"
         return ausgabe
 
@@ -123,10 +123,10 @@ def buchstabenwert_zu_text(eingabetext):
             try:
                 ausz = int(eingabetext)
             except ValueError:
-                return "Keine Zahl oder gültiges Trennzeichen (, ; . / - _ | oder Leerzeichen) erkannt!\n"
+                return ":red[Keine Zahl oder gültiges Trennzeichen (, ; . / - _ | oder Leerzeichen) erkannt!]"
             else:
                 if ausz not in bw:
-                    return "Die eingegebene Zahl ist kein gültiger Buchstabenwert!\n"
+                    return ":red[Die eingegebene Zahl ist kein gültiger Buchstabenwert!]"
                 else:
                     return bw[ausz]
         else:
@@ -145,9 +145,9 @@ def buchstabenwert_zu_text(eingabetext):
                     else:
                         ignor = ignor + str(z) + " "
             if ignor != "":
-                ausgabe_text += "_Achtung folgendes wurde ignoriert:_  \n"
+                ausgabe_text += ":red[Achtung folgendes wurde ignoriert:]  \n"
                 ausgabe_text += ignor + "  \n \n"
-            ausgabe_text += "_umgewandelte Zeichen:_  \n"
+            ausgabe_text += ":blue[umgewandelte Zeichen:]  \n"
             ausgabe_text += atxt
             return ausgabe_text
 
@@ -174,8 +174,8 @@ def zeichenanzahl(eingabetext):
         for key in anzahl:
             s.append(key)
         s.sort()
-        ausgabetext += f"Es wurden {len(anzahl)} unterschiedliche Zeichen gefunden.  \n"
-        ausgabetext += "| Zeichen | Anzahl |\n|----|----|\n"
+        ausgabetext += f"Es wurden __:orange[{len(anzahl)}]__ unterschiedliche Zeichen gefunden.  \n"
+        ausgabetext += "| :blue[Zeichen] | :blue[Anzahl] |\n|----|----|\n"
         for i in s:
             if ord(i) == 9:
                 ausgabetext += f"|TAB|{anzahl[i]}|\n"
@@ -203,9 +203,9 @@ def quersummen(eingabetext):
             try:
                 ausz = int(eingabetext)
             except ValueError:
-                return "Keine Zahl oder gültiges Trennzeichen (, ; . / - _ | oder Leerzeichen) erkannt!"
+                return ":red[Keine Zahl oder gültiges Trennzeichen (, ; . / - _ | oder Leerzeichen) erkannt!]"
             else:
-                return f"_Quersumme:_ {helper.q_sum(ausz)}  \n_iterierte Quersumme:_ {helper.iq_sum(ausz)}"
+                return f" :blue[Quersumme:] {helper.q_sum(ausz)}  \n:blue[iterierte Quersumme:] {helper.iq_sum(ausz)}"
         else:
             ausgabetext = ""
             txt = eingabetext.split(se)
@@ -221,11 +221,11 @@ def quersummen(eingabetext):
                     qtxt = qtxt + str(helper.q_sum(az)) + "/"
                     iqtxt = iqtxt + str(helper.iq_sum(az)) + "/"
             if ignor != "":
-                ausgabetext += "_Achtung nicht erkannte Zeichen:_  \n"
+                ausgabetext += ":red[Achtung nicht erkannte Zeichen:]  \n"
                 ausgabetext += ignor + "  \n  \n"
-            ausgabetext += "_Quersummen:_  \n"
+            ausgabetext += ":blue[Quersummen:]  \n"
             ausgabetext += qtxt[:-1] + "  \n  \n"
-            ausgabetext += "_iterierte Quersummen_  \n"
+            ausgabetext += ":blue[iterierte Quersummen]  \n"
             ausgabetext += iqtxt[:-1]
             return ausgabetext
 
@@ -252,17 +252,17 @@ def einschluss_count(eingabetext):
                     wz_ohne += 1
             wortsummenliste_ohne.append(wz_ohne)
             wortsummenliste_mit.append(wz_mit)
-        ausgabetext = "__mit 4__  \n"
-        ausgabetext += "_insgesamt gefundene Einschlüsse:_ "
+        ausgabetext = "__:orange[mit 4]__  \n"
+        ausgabetext += ":blue[insgesamt gefundene Einschlüsse:] "
         ausgabetext += f"{sum(wortsummenliste_mit)}  \n"
-        ausgabetext += "_Einschlüsse pro Wort:_ "
+        ausgabetext += ":blue[Einschlüsse pro Wort:] "
         for z in wortsummenliste_mit:
             ausgabetext += f"{z} "
         ausgabetext += "  \n  \n"
-        ausgabetext += "__ohne 4__  \n"
-        ausgabetext += "_insgesamt gefundene Einschlüsse:_ "
+        ausgabetext += "__:orange[ohne 4]__  \n"
+        ausgabetext += ":blue[insgesamt gefundene Einschlüsse:] "
         ausgabetext += f"{sum(wortsummenliste_ohne)}  \n"
-        ausgabetext += "_Einschlüsse pro Wort:_ "
+        ausgabetext += ":blue[Einschlüsse pro Wort:] "
         for z in wortsummenliste_ohne:
             ausgabetext += f"{z} "
         return ausgabetext
@@ -289,7 +289,7 @@ def morse_to_abc(eingabetext):
             if sign == "/":
                 atxt = atxt + " "
             elif sign not in alphabet:
-                atxt = atxt + "#"
+                atxt = atxt + ":red[#]"
             else:
                 atxt = atxt + alphabet[sign]
         return atxt
@@ -416,7 +416,7 @@ def dez_to_ascii(eingabetext):
             try:
                 ausz = int(eingabetext)
             except ValueError:
-                return "Keine Zahl oder gültiges Trennzeichen (, ; . / - _ | oder Leerzeichen) erkannt!"
+                return ":red[Keine Zahl oder gültiges Trennzeichen (, ; . / - _ | oder Leerzeichen) erkannt!]"
             else:
                 return chr(ausz)
         else:
@@ -432,9 +432,9 @@ def dez_to_ascii(eingabetext):
                 else:
                     atxt = atxt + chr(az)
             if ignor != "":
-                ausgabetext += "_Achtung nicht erkannte Zeichen:_  \n"
+                ausgabetext += ":red[Achtung nicht erkannte Zeichen:]  \n"
                 ausgabetext += ignor + "  \n  \n"
-            ausgabetext += "_umgewandelte Zeichen:_  \n"
+            ausgabetext += ":blue[umgewandelte Zeichen:]  \n"
             ausgabetext += atxt
             return ausgabetext
 
@@ -465,7 +465,7 @@ def hex_to_ascii(eingabetext):
             try:
                 ausz = int(eingabetext, 16)
             except ValueError:
-                return "Keine Zahl oder gültiges Trennzeichen (, ; . / - _ | oder Leerzeichen) erkannt!"
+                return ":red[Keine Zahl oder gültiges Trennzeichen (, ; . / - _ | oder Leerzeichen) erkannt!]"
             else:
                 return chr(ausz)
         else:
@@ -481,9 +481,9 @@ def hex_to_ascii(eingabetext):
                 else:
                     atxt = atxt + chr(az)
             if ignor != "":
-                ausgabetext += "_Achtung nicht erkannte Zeichen:_  \n"
+                ausgabetext += ":red[Achtung nicht erkannte Zeichen]  \n"
                 ausgabetext += ignor + "  \n  \n"
-            ausgabetext += "_umgewandelte Zeichen:_  \n"
+            ausgabetext += ":blue[umgewandelte Zeichen:]  \n"
             ausgabetext += atxt
             return ausgabetext
 
@@ -513,7 +513,7 @@ def octal_to_ascii(eingabetext):
             try:
                 ausz = int(eingabetext, 8)
             except ValueError:
-                return "Keine Zahl oder gültiges Trennzeichen (, ; . / - _ | oder Leerzeichen) erkannt!"
+                return ":red[Keine Zahl oder gültiges Trennzeichen (, ; . / - _ | oder Leerzeichen) erkannt!]"
             else:
                 return chr(ausz)
         else:
@@ -529,9 +529,9 @@ def octal_to_ascii(eingabetext):
                 else:
                     atxt = atxt + chr(az)
             if ignor != "":
-                ausgabetext += "_Achtung nicht erkannte Zeichen:_  \n"
+                ausgabetext += ":red[Achtung nicht erkannte Zeichen]  \n"
                 ausgabetext += ignor + "  \n  \n"
-            ausgabetext += "_umgewandelte Zeichen:_  \n"
+            ausgabetext += ":blue[umgewandelte Zeichen:]  \n"
             ausgabetext += atxt
             return ausgabetext
 
@@ -553,8 +553,8 @@ def ascii_to_bin8(eingabetext):
         z = []
         for i in eingabetext:
             if ord(i) > 255:
-                return ("Sorry der Eingabetext enthält Zeichen,welche sich nicht mit 8 bit in binär darstellen "
-                        "lassen!")
+                return (":red[Sorry der Eingabetext enthält Zeichen,welche sich nicht mit 8 bit in binär darstellen "
+                        "lassen!]")
             z.append("{:0>8b}".format(ord(i)))
         return ' '.join(z)
 
@@ -574,7 +574,7 @@ def bin_to_ascii(eingabetext):
             try:
                 ausz = int(eingabetext, 2)
             except ValueError:
-                return "Keine Zahl oder gültiges Trennzeichen (, ; . / - _ | oder Leerzeichen) erkannt!"
+                return ":red[Keine Zahl oder gültiges Trennzeichen (, ; . / - _ | oder Leerzeichen) erkannt!]"
             else:
                 return chr(ausz)
         else:
@@ -590,9 +590,9 @@ def bin_to_ascii(eingabetext):
                 else:
                     atxt = atxt + chr(az)
             if ignor != "":
-                ausgabetext += "_Achtung nicht erkannte Zeichen:_  \n"
+                ausgabetext += ":red[Achtung nicht erkannte Zeichen]  \n"
                 ausgabetext += ignor + "  \n  \n"
-            ausgabetext += "_umgewandelte Zeichen:_  \n"
+            ausgabetext += ":blue[umgewandelte Zeichen:]  \n"
             ausgabetext += atxt
             return ausgabetext
 
@@ -624,11 +624,11 @@ def zahlwortsuche_de(eingabetext):
             if tt:
                 atxt = atxt + b
         if atxt == "":
-            return "Leider keine Zahlwörter gefunden!"
+            return ":red[Leider keine Zahlwörter gefunden!]"
         else:
-            ausgabetext = "_Gefundene Zahlwörter:_  \n"
+            ausgabetext = ":blue[Gefundene Zahlwörter:]  \n"
             ausgabetext += atxt + "  \n  \n"
-            ausgabetext += "_Eingangstext:_  \n"
+            ausgabetext += ":blue[Eingangstext:]  \n"
             ausgabetext += ntxt
             return ausgabetext
 
@@ -661,11 +661,11 @@ def zahlwortsuche_en(eingabetext):
             if tt:
                 atxt = atxt + b
         if atxt == "":
-            return "Leider keine Zahlwörter gefunden!"
+            return ":red[Leider keine Zahlwörter gefunden!]"
         else:
-            ausgabetext = "_Gefundene Zahlwörter:_  \n"
+            ausgabetext = ":blue[Gefundene Zahlwörter:]  \n"
             ausgabetext += atxt + "  \n  \n"
-            ausgabetext += "_Eingangstext:_  \n"
+            ausgabetext += ":blue[Eingangstext:]  \n"
             ausgabetext += ntxt
             return ausgabetext
 
@@ -750,7 +750,7 @@ def kenny_raten(eingabetext):
                 tri = txt2[i:i + 3]
                 if tri in wbk:
                     atxt = atxt + wbk[tri]
-            ausgabetext += f"_{p}_  \n"
+            ausgabetext += f":blue[{p}]  \n"
             ausgabetext += f"{atxt}  \n  \n"
         return ausgabetext
 
@@ -779,12 +779,12 @@ def primzahlalphabet_dekodieren(eingabetext):
             try:
                 ausz = int(eingabetext)
             except ValueError:
-                return "Keine Zahl oder gültiges Trennzeichen (, ; . / - _ | oder Leerzeichen) erkannt!"
+                return ":red[Keine Zahl oder gültiges Trennzeichen (, ; . / - _ | oder Leerzeichen) erkannt!]"
             else:
                 if ausz in pdict:
                     return pdict[ausz]
                 else:
-                    return eingabetext + " ist keine Primzahl oder größer als 1 Million!"
+                    return f":red[{eingabetext} ist keine Primzahl oder größer als 1 Million!]"
         else:
             ausgabetext = ""
             txt = eingabetext.split(se)
@@ -801,9 +801,9 @@ def primzahlalphabet_dekodieren(eingabetext):
                     else:
                         ignor = ignor + str(z) + " "
             if ignor != "":
-                ausgabetext += "_ignoriert wurde:_  \n"
+                ausgabetext += ":red[ignoriert wurde:]  \n"
                 ausgabetext += ignor + "  \n  \n"
-            ausgabetext += "_umgewandelte Zahlen:_  \n"
+            ausgabetext += ":blue[umgewandelte Zahlen:]  \n"
             ausgabetext += atxt
             return ausgabetext
 
@@ -815,16 +815,16 @@ def primzahlpruefen(eingabetext):
         try:
             ausz = int(eingabetext)
         except ValueError:
-            return "Keine Zahl erkannt!"
+            return ":red[Keine Zahl erkannt!]"
         else:
             if ausz > 1299709:
-                return ("Sorry, aber ich mag nur die ersten 100,000 Primzahlen, das sind Zahlen bis maximal "
-                        "1,299,709 !")
+                return (":red[Sorry, aber ich mag nur die ersten 100,000 Primzahlen, das sind Zahlen bis maximal "
+                        "1,299,709 !]")
             primes = helper.primzahlliste(1299710)
             if ausz not in primes:
-                return f"{ausz:,} ist keine Primzahl"
+                return f":orange[{ausz:,}] ist keine Primzahl"
             else:
-                return f"{ausz:,} ist die {primes.index(ausz) + 1:,}. Primzahl"
+                return f":orange[{ausz:,}] ist die :orange[{primes.index(ausz) + 1:,}.] Primzahl"
 
 def nte_primzahl(eingabetext):
     eingabetext = eingabetext.rstrip()
@@ -834,12 +834,12 @@ def nte_primzahl(eingabetext):
         try:
             ausz = int(eingabetext)
         except ValueError:
-            return "Keine Zahl erkannt!"
+            return ":red[Keine Zahl erkannt!]"
         if ausz > 100000:
-            return "Sorry, aber ich mag nur die ersten 100,000 Primzahlen, das sind Zahlen bis maximal 1,299,709 !"
+            return ":red[Sorry, aber ich mag nur die ersten 100,000 Primzahlen, das sind Zahlen bis maximal 1,299,709 !]"
         else:
             primes = helper.primzahlliste(1299710)
-            return f"Die {ausz:,}. Primzahl lautet: {primes[ausz - 1]:,}"
+            return f"Die :orange[{ausz:,}.] Primzahl lautet: :orange[{primes[ausz - 1]:,}]"
 
 def primfaktoren(eingabetext):
     eingabetext = eingabetext.rstrip()
@@ -849,20 +849,20 @@ def primfaktoren(eingabetext):
         try:
             n = int(eingabetext)
         except ValueError:
-            return "Es konnte leider keine Zahl erkannt werden."
+            return ":red[Es konnte leider keine Zahl erkannt werden.]"
         faktoren = []
         for i in chain([2], range(3, n // 2 + 1, 2)):
             if i > 100000000:
-                return ("Sorry, aber die Primfaktorensuche wurde abgebrochen, da mindestens 1 Faktor größer als "
-                        "100 Millionen ist.")
+                return (":red[Sorry, aber die Primfaktorensuche wurde abgebrochen, da mindestens 1 Faktor größer als "
+                        "100 Millionen ist.]")
             while n % i == 0:
                 faktoren.append(i)
                 n = n // i
             if i > n:
                 break
-        out = f"_Die Zahl {eingabetext} hat folgende Primfaktoren:_  \n"
+        out = f"_Die Zahl :orange[{eingabetext}] hat folgende Primfaktoren:_  \n"
         if not faktoren:
-            return f"Die Zahl {eingabetext} ist eine Primzahl!!"
+            return f"Die Zahl :orange[{eingabetext}] ist eine Primzahl!!"
         else:
             for z in faktoren:
                 out += str(z) + ", "
@@ -884,9 +884,9 @@ def dez_to_hex_oct_bin(eingabetext):
             try:
                 ausz = int(eingabetext)
             except ValueError:
-                return "Keine Zahl oder gültiges Trennzeichen (, ; / _ | oder Leerzeichen) erkannt!"
+                return ":red[Keine Zahl oder gültiges Trennzeichen (, ; / _ | oder Leerzeichen) erkannt!]"
             else:
-                return "Dez: {0:}  \nHEX: {0:X}  \nOCT: {0:o}  \nBIN: {0:b}".format(ausz)
+                return ":blue[DEZ:] {0:}  \n:blue[HEX:] {0:X}  \n:blue[OCT:] {0:o}  \n:blue[BIN:] {0:b}".format(ausz)
         else:
             ausgabetext = ""
             txt = eingabetext.split(se)
@@ -902,11 +902,11 @@ def dez_to_hex_oct_bin(eingabetext):
                     octtxt = octtxt + "{:o}".format(az) + "/"
                     bintxt = bintxt + "{:b}".format(az) + "/"
             if ignor != "":
-                ausgabetext += f"_Achtung nicht erkannte Zeichen:_ {ignor}  \n"
-            ausgabetext += f"_DEZ:_ {deztxt[:-1]}  \n"
-            ausgabetext += f"_HEX:_ {hextxt[:-1]}  \n"
-            ausgabetext += f"_OCT:_ {octtxt[:-1]}  \n"
-            ausgabetext += f"_BIN:_ {bintxt[:-1]}  \n"
+                ausgabetext += f":red[Achtung nicht erkannte Zeichen] {ignor}  \n"
+            ausgabetext += f":blue[DEZ:] {deztxt[:-1]}  \n"
+            ausgabetext += f":blue[HEX:] {hextxt[:-1]}  \n"
+            ausgabetext += f":blue[OCT:] {octtxt[:-1]}  \n"
+            ausgabetext += f":blue[BIN:] {bintxt[:-1]}  \n"
             return ausgabetext
 
 def hex_to_dez_oct_bin(eingabetext):
@@ -925,9 +925,9 @@ def hex_to_dez_oct_bin(eingabetext):
             try:
                 ausz = int(eingabetext, 16)
             except ValueError:
-                return "Keine Zahl oder gültiges Trennzeichen (, ; / _ | oder Leerzeichen) erkannt!"
+                return ":red[Keine Zahl oder gültiges Trennzeichen (, ; / _ | oder Leerzeichen) erkannt!]"
             else:
-                return "HEX: {0:X}  \nDez: {0:}  \nOCT: {0:o}  \nBIN: {0:b}".format(ausz)
+                return ":blue[HEX:] {0:X}  \n:blue[DEZ:] {0:}  \n:blue[OCT:] {0:o}  \n:blue[BIN:] {0:b}".format(ausz)
         else:
             ausgabetext = ""
             txt = eingabetext.split(se)
@@ -943,11 +943,11 @@ def hex_to_dez_oct_bin(eingabetext):
                     octtxt = octtxt + "{:o}".format(az) + "/"
                     bintxt = bintxt + "{:b}".format(az) + "/"
             if ignor != "":
-                ausgabetext += f"_Achtung nicht erkannte Zeichen:_ {ignor}  \n"
-            ausgabetext += f"_HEX:_ {hextxt[:-1]}  \n"
-            ausgabetext += f"_DEZ:_ {deztxt[:-1]}  \n"
-            ausgabetext += f"_OCT:_ {octtxt[:-1]}  \n"
-            ausgabetext += f"_BIN:_ {bintxt[:-1]}  \n"
+                ausgabetext += f":red[Achtung nicht erkannte Zeichen] {ignor}  \n"
+            ausgabetext += f":blue[HEX:] {hextxt[:-1]}  \n"
+            ausgabetext += f":blue[DEZ:] {deztxt[:-1]}  \n"
+            ausgabetext += f":blue[OCT:] {octtxt[:-1]}  \n"
+            ausgabetext += f":blue[BIN:] {bintxt[:-1]}  \n"
             return ausgabetext
 
 def oct_to_hex_dez_bin(eingabetext):
@@ -966,9 +966,9 @@ def oct_to_hex_dez_bin(eingabetext):
             try:
                 ausz = int(eingabetext, 8)
             except ValueError:
-                return "Keine Zahl oder gültiges Trennzeichen (, ; / _ | oder Leerzeichen) erkannt!"
+                return ":red[Keine Zahl oder gültiges Trennzeichen (, ; / _ | oder Leerzeichen) erkannt!]"
             else:
-                return "OCT: {0:o}  \nHEX: {0:X}  \nDez: {0:}  \nBIN: {0:b}".format(ausz)
+                return ":blue[OCT:] {0:o}  \n:blue[HEX:] {0:X}  \n:blue[DEZ:] {0:}  \n:blue[BIN:] {0:b}".format(ausz)
         else:
             ausgabetext = ""
             txt = eingabetext.split(se)
@@ -984,11 +984,11 @@ def oct_to_hex_dez_bin(eingabetext):
                     octtxt = octtxt + "{:o}".format(az) + "/"
                     bintxt = bintxt + "{:b}".format(az) + "/"
             if ignor != "":
-                ausgabetext += f"_Achtung nicht erkannte Zeichen:_ {ignor}  \n"
-            ausgabetext += f"_OCT:_ {octtxt[:-1]}  \n"
-            ausgabetext += f"_HEX:_ {hextxt[:-1]}  \n"
-            ausgabetext += f"_DEZ:_ {deztxt[:-1]}  \n"
-            ausgabetext += f"_BIN:_ {bintxt[:-1]}  \n"
+                ausgabetext += f":red[Achtung nicht erkannte Zeichen] {ignor}  \n"
+            ausgabetext += f":blue[OCT:] {octtxt[:-1]}  \n"
+            ausgabetext += f":blue[HEX:] {hextxt[:-1]}  \n"
+            ausgabetext += f":blue[DEZ:] {deztxt[:-1]}  \n"
+            ausgabetext += f":blue[BIN:] {bintxt[:-1]}  \n"
             return ausgabetext
 
 def bin_to_hex_dez_oct(eingabetext):
@@ -1007,9 +1007,9 @@ def bin_to_hex_dez_oct(eingabetext):
             try:
                 ausz = int(eingabetext, 2)
             except ValueError:
-                return "Keine Zahl oder gültiges Trennzeichen (, ; / _ | oder Leerzeichen) erkannt!"
+                return ":red[Keine Zahl oder gültiges Trennzeichen (, ; / _ | oder Leerzeichen) erkannt!]"
             else:
-                return "BIN: {0:b}  \nHEX: {0:X}  \nDez: {0:}  \nOCT: {0:o}".format(ausz)
+                return ":blue[BIN:] {0:b}  \n:blue[HEX:] {0:X}  \n:blue[DEZ:] {0:}  \n:blue[OCT:] {0:o}".format(ausz)
         else:
             ausgabetext = ""
             txt = eingabetext.split(se)
@@ -1025,11 +1025,11 @@ def bin_to_hex_dez_oct(eingabetext):
                     octtxt = octtxt + "{:o}".format(az) + "/"
                     bintxt = bintxt + "{:b}".format(az) + "/"
             if ignor != "":
-                ausgabetext += f"_Achtung nicht erkannte Zeichen:_ {ignor}  \n"
-            ausgabetext += f"_BIN:_ {bintxt[:-1]}  \n"
-            ausgabetext += f"_HEX:_ {hextxt[:-1]}  \n"
-            ausgabetext += f"_DEZ:_ {deztxt[:-1]}  \n"
-            ausgabetext += f"_OCT:_ {octtxt[:-1]}  \n"
+                ausgabetext += f":red[Achtung nicht erkannte Zeichen] {ignor}  \n"
+            ausgabetext += f":blue[BIN:] {bintxt[:-1]}  \n"
+            ausgabetext += f":blue[HEX:] {hextxt[:-1]}  \n"
+            ausgabetext += f":blue[DEZ:] {deztxt[:-1]}  \n"
+            ausgabetext += f":blue[OCT:] {octtxt[:-1]}  \n"
             return ausgabetext
 
 def abc_to_tomtom(eingabetext):
@@ -1053,9 +1053,9 @@ def abc_to_tomtom(eingabetext):
             else:
                 atxt = atxt + alphabet[b.lower()]
         if ignor != "":
-            ausgabetext += "_ignorierte Zeichen:_  \n"
+            ausgabetext += ":red[ignorierte Zeichen:]  \n"
             ausgabetext += ignor + "  \n  \n"
-        ausgabetext += "_kodierter Text:_  \n"
+        ausgabetext += ":blue[kodierter Text:]  \n"
         ausgabetext += atxt
         return ausgabetext
 
@@ -1105,9 +1105,9 @@ def text_to_slashpipe(eingabetext):
             else:
                 atxt = atxt + alphabet[b.lower()]
         if ignor != "":
-            ausgabetext += "_ignorierte Zeichen:_  \n"
+            ausgabetext += ":red[ignorierte Zeichen:]  \n"
             ausgabetext += ignor + "  \n  \n"
-        ausgabetext += "_kodierter Text:_  \n"
+        ausgabetext += ":blue[kodierter Text:]  \n"
         ausgabetext += atxt
         return ausgabetext
 
@@ -1167,7 +1167,7 @@ def periodensystem(eingabetext):
                 if eingabetext in um_pse:
                     return str(um_pse[eingabetext])
                 else:
-                    return "Keine gültige Eingabe erkannt!"
+                    return ":red[Keine gültige Eingabe erkannt!]"
             else:
                 return pse[ausz]
         else:
@@ -1182,7 +1182,7 @@ def periodensystem(eingabetext):
                     az = int(z)
                 except ValueError:
                     if z in um_pse:
-                        atxt3 += z + ":" + str(um_pse[z]) + " "
+                        atxt3 += f"|{z}|{str(um_pse[z])}|\n"
                     else:
                         ignor = ignor + z + " "
                 else:
@@ -1192,13 +1192,13 @@ def periodensystem(eingabetext):
                     else:
                         ignor = ignor + z + " "
             if ignor != "":
-                ausgabetext += "_Achtung nicht erkannte Zeichen:_  \n" + ignor + "  \n  \n"
+                ausgabetext += ":red[Achtung nicht erkannte Zeichen]  \n" + ignor + "  \n  \n"
             if atxt != "":
-                ausgabetext += "_Symbole:_  \n" + atxt + "  \n  \n"
+                ausgabetext += ":blue[Symbole:]  \n" + atxt + "  \n  \n"
             if atxt2 != "":
-                ausgabetext += "_Nur Anfangsbuchstaben:_  \n" + atxt2 + "  \n  \n"
+                ausgabetext += ":blue[Nur Anfangsbuchstaben:]  \n" + atxt2 + "  \n  \n"
             if atxt3 != "":
-                ausgabetext += "_Symbol:Ordnungszahl_  \n" + atxt3
+                ausgabetext += "|:blue[Symbol]|:blue[Ordnungszahl]|\n|-|-|\n" + atxt3
             return ausgabetext
 
 def naknak_to_text(eingabetext):
@@ -1220,7 +1220,7 @@ def naknak_to_text(eingabetext):
                 utxt = utxt + nakwb[nak]
                 z = 1
         atxt = urllib_parse_unquote(utxt)
-        return  "_dekodiertes Geschnatter:_  \n" + atxt
+        return  f":blue[dekodiertes Geschnatter:]  \n{atxt}"
 
 def navajo_to_text(eingabetext):
     nabc = {"WOL-LA-CHEE": "A", "BE-LA-SANA": "A", "TSE-NILL": "A", "NA-HASH-CHID": "B", "SHUSH": "B", "TOISH-JEH": "B",
@@ -1245,7 +1245,7 @@ def navajo_to_text(eingabetext):
             w = wort.upper()
             if w in nabc:
                 atxt = atxt + nabc[w]
-        return "_dekodierter Text:_  \n" + atxt
+        return ":blue[dekodierter Text:]  \n" + atxt
 
 def pi_suche(eingabetext):
     eingabetext = eingabetext.rstrip()
@@ -1255,7 +1255,7 @@ def pi_suche(eingabetext):
         try:
             piread = open("./data/pi.txt", "r")
         except FileNotFoundError:
-            return "Sorry es scheint die Datei pi.txt zu fehlen, welche von dieser Funktion benötigt wird."
+            return ":red[Sorry es scheint die Datei pi.txt zu fehlen, welche von dieser Funktion benötigt wird.]"
         else:
             pistr = ""
             for zeile in piread:
@@ -1265,21 +1265,22 @@ def pi_suche(eingabetext):
             try:
                 zahlx = int(eingabetext)
             except ValueError:
-                return "Sorry aber ohne gültige Zahleneingabe funktioniert das nicht!"
+                return ":red[Sorry aber ohne gültige Zahleneingabe funktioniert das nicht!]"
             else:
-                ausgabetext = "_PI (Kreiszahl)_  \n  \n"
+                ausgabetext = ":blue[PI (Kreiszahl)]  \n  \n"
                 pos = pistr.find(eingabetext)
                 if pilen >= zahlx > 0:
-                    ausgabetext += (f"_Die {zahlx}. Nachkommstelle lautet:_ {pistr[zahlx + 1]}  \n_20 Stellen ab "
-                                    f"{zahlx}. Nachkommstelle:_ {pistr[zahlx + 1:zahlx + 21]}...  \n  \n")
+                    ausgabetext += (f"Die :orange[{zahlx}.] Nachkommstelle lautet: :orange[{pistr[zahlx + 1]}]  \n"
+                                    f"20 Stellen ab :orange[{zahlx}.] Nachkommstelle: "
+                                    f":orange[{pistr[zahlx + 1:zahlx + 21]}...]  \n  \n")
                 else:
-                    ausgabetext += f"_Die verwendete pi.txt kennt leider nur {pilen:,} Nachkommstellen._  \n  \n"
+                    ausgabetext += f"Die verwendete pi.txt kennt leider nur :orange[{pilen:,}] Nachkommstellen.  \n  \n"
                 if pos == -1:
-                    ausgabetext += f"_Zahlenreihe in {pilen:,} Nachkommastellen nicht zu finden._"
+                    ausgabetext += f"Zahlenreihe in :orange[{pilen:,}] Nachkommastellen nicht zu finden."
                 else:
-                    ausgabetext += (f'erstes Vorkommen von Zahlenfolge "{eingabetext.rstrip()}" ab {pos - 1}. '
-                                    f'Nachkommastelle  \n20 Stellen ab {pos - 1}. Nachkommstelle: '
-                                    f'{pistr[pos:pos + 20]}...')
+                    ausgabetext += (f'erstes Vorkommen von Zahlenfolge :orange[{eingabetext.rstrip()}] ab '
+                                    f':orange[{pos - 1}.] Nachkommastelle  \n20 Stellen ab :orange[{pos - 1}.] '
+                                    f'Nachkommstelle: :orange[{pistr[pos:pos + 20]}...]')
                 return ausgabetext
 
 def euler_suche(eingabetext):
@@ -1290,7 +1291,7 @@ def euler_suche(eingabetext):
         try:
             eread = open("./data/e.txt", "r")
         except FileNotFoundError:
-            return "Sorry es scheint die Datei e.txt zu fehlen, welche von dieser Funktion benötigt wird."
+            return ":red[Sorry es scheint die Datei e.txt zu fehlen, welche von dieser Funktion benötigt wird.]"
         else:
             estr = ""
             for zeile in eread:
@@ -1300,21 +1301,22 @@ def euler_suche(eingabetext):
             try:
                 zahlx = int(eingabetext)
             except ValueError:
-                return "Sorry aber ohne gültige Zahleneingabe funktioniert das nicht!"
+                return ":red[Sorry aber ohne gültige Zahleneingabe funktioniert das nicht!]"
             else:
-                ausgabetext = "_e (Eulersche Zahl)_  \n  \n"
+                ausgabetext = ":blue[e (Eulersche Zahl)]  \n  \n"
                 pos = estr.find(eingabetext)
                 if elen >= zahlx > 0:
-                    ausgabetext += (f"_Die {zahlx}. Nachkommstelle lautet:_ {estr[zahlx + 1]}  \n_20 Stellen ab "
-                                    f"{zahlx}. Nachkommstelle:_ {estr[zahlx + 1:zahlx + 21]}...  \n  \n")
+                    ausgabetext += (f"Die :orange[{zahlx}.] Nachkommstelle lautet: :orange[{estr[zahlx + 1]}]  \n"
+                                    f"20 Stellen ab :orange[{zahlx}.] Nachkommstelle: "
+                                    f":orange[{estr[zahlx + 1:zahlx + 21]}...]  \n  \n")
                 else:
-                    ausgabetext += f"_Die verwendete pi.txt kennt leider nur {elen:,} Nachkommstellen._  \n  \n"
+                    ausgabetext += f"Die verwendete e.txt kennt leider nur :orange[{elen:,}] Nachkommstellen.  \n  \n"
                 if pos == -1:
-                    ausgabetext += f"_Zahlenreihe in {elen:,} Nachkommastellen nicht zu finden._"
+                    ausgabetext += f"Zahlenreihe in :orange[{elen:,}] Nachkommastellen nicht zu finden."
                 else:
-                    ausgabetext += (f'erstes Vorkommen von Zahlenfolge "{eingabetext.rstrip()}" ab {pos - 1}. '
-                                    f'Nachkommastelle  \n20 Stellen ab {pos - 1}. Nachkommstelle: '
-                                    f'{estr[pos:pos + 20]}...')
+                    ausgabetext += (f'erstes Vorkommen von Zahlenfolge :orange[{eingabetext.rstrip()}] ab '
+                                    f':orange[{pos - 1}.] Nachkommastelle  \n20 Stellen ab :orange[{pos - 1}.] '
+                                    f'Nachkommstelle: :orange[{estr[pos:pos + 20]}...]')
                 return ausgabetext
 
 def goldener_schnitt_suche(eingabetext):
@@ -1325,7 +1327,7 @@ def goldener_schnitt_suche(eingabetext):
         try:
             phiread = open("./data/phi.txt", "r")
         except ValueError:
-            return "Sorry es scheint die Datei phi.txt zu fehlen, welche von dieser Funktion benötigt wird."
+            return ":red[Sorry es scheint die Datei phi.txt zu fehlen, welche von dieser Funktion benötigt wird.]"
         else:
             phistr = ""
             for zeile in phiread:
@@ -1335,21 +1337,23 @@ def goldener_schnitt_suche(eingabetext):
             try:
                 zahlx = int(eingabetext)
             except ValueError:
-                return "Sorry aber ohne gültige Zahleneingabe funktioniert das nicht!"
+                return ":red[Sorry aber ohne gültige Zahleneingabe funktioniert das nicht!]"
             else:
-                ausgabetext = "_phi (Goldener Schnitt)_  \n  \n"
+                ausgabetext = ":blue[phi (Goldener Schnitt)]  \n  \n"
                 pos = phistr.find(eingabetext)
                 if philen >= zahlx > 0:
-                    ausgabetext += (f"_Die {zahlx}. Nachkommstelle lautet:_ {phistr[zahlx + 1]}  \n_20 Stellen ab "
-                                    f"{zahlx}. Nachkommstelle:_ {phistr[zahlx + 1:zahlx + 21]}...  \n  \n")
+                    ausgabetext += (f"Die :orange[{zahlx}.] Nachkommstelle lautet: :orange[{phistr[zahlx + 1]}]  \n"
+                                    f"20 Stellen ab :orange[{zahlx}.] Nachkommstelle: "
+                                    f":orange[{phistr[zahlx + 1:zahlx + 21]}...]  \n  \n")
                 else:
-                    ausgabetext += f"_Die verwendete pi.txt kennt leider nur {philen:,} Nachkommstellen._  \n  \n"
+                    ausgabetext += (f"Die verwendete pi.txt kennt leider nur :orange[{philen:,}] "
+                                    f"Nachkommstellen.  \n  \n")
                 if pos == -1:
-                    ausgabetext += f"_Zahlenreihe in {philen:,} Nachkommastellen nicht zu finden._"
+                    ausgabetext += f"Zahlenreihe in :orange[{philen:,}] Nachkommastellen nicht zu finden."
                 else:
-                    ausgabetext += (f'erstes Vorkommen von Zahlenfolge "{eingabetext.rstrip()}" ab {pos - 1}. '
-                                    f'Nachkommastelle  \n20 Stellen ab {pos - 1}. Nachkommstelle: '
-                                    f'{phistr[pos:pos + 20]}...')
+                    ausgabetext += (f'erstes Vorkommen von Zahlenfolge :orange[{eingabetext.rstrip()}] ab '
+                                    f':orange[{pos - 1}.] Nachkommastelle  \n20 Stellen ab :orange[{pos - 1}.] '
+                                    f'Nachkommstelle: :orange[{phistr[pos:pos + 20]}...]')
                 return ausgabetext
 
 def anagramm_suche_de(eingabetext):
@@ -1361,10 +1365,10 @@ def anagramm_suche_de(eingabetext):
             wbfile = open("./data/german.dic", "r",
                           encoding="iso-8859-15")  # german.dic von https://sourceforge.net/projects/germandict/
         except FileNotFoundError:
-            return "Leider konnte die Wörterbuchdatei nicht geladen werden."
+            return ":red[Leider konnte die Wörterbuchdatei nicht geladen werden.]"
         else:
             eingabezaehl = helper.wortzaehl(eingabetext)
-            ausgabetext = "_gefundene Anagramme:_  \n"
+            ausgabetext = ":blue[gefundene Anagramme:]  \n"
             for zeile in wbfile:
                 zeile = zeile.strip(" \t\n\r")
                 if eingabetext.upper() == zeile.upper():
@@ -1384,10 +1388,10 @@ def anagramm_suche_en(eingabetext):
         try:
             wbfile = open("./data/en_US-large.txt", "r", encoding="UTF-8")
         except FileNotFoundError:
-            return "Leider konnte die Wörterbuchdatei nicht geladen werden."
+            return ":red[Leider konnte die Wörterbuchdatei nicht geladen werden.]"
         else:
             eingabezaehl = helper.wortzaehl(eingabetext)
-            ausgabetext = "_gefundene Anagramme:_  \n"
+            ausgabetext = ":blue[gefundene Anagramme:]  \n"
             for zeile in wbfile:
                 zeile = zeile.strip(" \t\n\r")
                 if eingabetext.upper() == zeile.upper():
@@ -1407,9 +1411,9 @@ def wortsuche_de(eingabetext):
         try:
             wbfile = open("./data/german.dic", "r", encoding="iso-8859-15")
         except FileNotFoundError:
-            return "Leider konnte die Wörterbuchdatei nicht geladen werden."
+            return ":red[Leider konnte die Wörterbuchdatei nicht geladen werden.]"
         else:
-            ausgabetext = "_im Wörterbuch gefundene passende Wörter:_  \n"
+            ausgabetext = ":blue[im Wörterbuch gefundene passende Wörter:]  \n"
             for zeile in wbfile:
                 zeile = zeile.strip(" \t\n\r")
                 if len(eingabetext) != len(zeile):
@@ -1433,9 +1437,9 @@ def wortsuche_en(eingabetext):
         try:
             wbfile = open("./data/en_US-large.txt", "r", encoding="UTF-8")
         except FileNotFoundError:
-            return "Leider konnte die Wörterbuchdatei nicht geladen werden."
+            return ":red[Leider konnte die Wörterbuchdatei nicht geladen werden.]"
         else:
-            ausgabetext = "_im Wörterbuch gefundene passende Wörter:_  \n"
+            ausgabetext = ":blue[im Wörterbuch gefundene passende Wörter:]  \n"
             for zeile in wbfile:
                 zeile = zeile.strip(" \t\n\r")
                 if len(eingabetext) != len(zeile):
@@ -1465,18 +1469,19 @@ def remorse_de(eingabetext):
                 testfile.close()
                 if eingabetext == "GENERATE":
                     helper.remorse_generate_morsede()
-                    return "Remorse-Wörterbuch wurde erzeugt und wird ab dem nächsten Aufruf der Funktion benutzt."
+                    return (":green[Remorse-Wörterbuch wurde erzeugt und wird ab dem nächsten Aufruf der Funktion "
+                            "benutzt.]")
                 else:
-                    ausgabetext = ("_Da das Remorse-Wörterbuch noch nicht generiert wurde, wurde das normale_ "
-                                   "_Wörterbuch für die Suche benutzt, das dauert zwar ca. 5x so lange, aber geht_ "
-                                   "_auch._  \n"
-                                   "_Um das Remorse-Wörterbuch zu erzeugen bitte das Wort:_ __GENERATE__ _ins_ "
-                                   "_Eingabefeld eingeben und die Funktion starten._  \n  \n")
+                    ausgabetext = (":green[Da das Remorse-Wörterbuch noch nicht generiert wurde, wurde das normale "
+                                   "Wörterbuch für die Suche benutzt, das dauert zwar ca. 5x so lange, aber geht "
+                                   "auch.  \n"
+                                   "Um das Remorse-Wörterbuch zu erzeugen bitte das Wort:] :orange[GENERATE] "
+                                   ":green[ins Eingabefeld eingeben und die Funktion starten.]  \n  \n")
                 return ausgabetext + helper.remorse_germandic(eingabetext)
             except FileNotFoundError:
-                return "Leider konnte die Wörterbuchdatei nicht geladen werden."
+                return ":red[Leider konnte die Wörterbuchdatei nicht geladen werden.]"
         else:
-            ausgabetext = "_der eingegebene Morsecode kann für folgendes stehen:_  \n"
+            ausgabetext = ":blue[der eingegebene Morsecode kann für folgendes stehen:]  \n"
             for zeile in wbfile:
                 zeile = zeile.strip(" \t\n\r")
                 mline = zeile.split(",")
@@ -1505,9 +1510,9 @@ def remorse_en(eingabetext):
         try:
             wbfile = open("./data/en_US-large.txt", "r", encoding="UTF-8")
         except FileNotFoundError:
-            return "Leider konnte die Wörterbuchdatei nicht geladen werden."
+            return ":red[Leider konnte die Wörterbuchdatei nicht geladen werden.]"
         else:
-            ausgabetext = "_der eingegebene Morsecode kann für folgendes stehen:_  \n"
+            ausgabetext = ":blue[der eingegebene Morsecode kann für folgendes stehen:]  \n"
             if eingabetext in ualphabet:
                 ausgabetext += ualphabet[eingabetext] + "  \n"
             for zeile in wbfile:
@@ -1536,17 +1541,17 @@ def t9_de(eingabetext):
                 testfile.close()
                 if eingabetext == "GENERATE":
                     helper.t9_generate_t9de()
-                    return "t9-Wörterbuch wurde erzeugt und wird ab dem nächsten Aufruf der Funktion benutzt."
+                    return ":green[t9-Wörterbuch wurde erzeugt und wird ab dem nächsten Aufruf der Funktion benutzt.]"
                 else:
-                    ausgabetext = ("_Da das T9-Wörterbuch nicht vorhanden ist, wurde das normale Wörterbuch für die_ "
-                                   "_Suche benutzt. Das dauert zwar ca. 7x so lange, aber geht auch._  \n"
-                                   "_Um das spezielle T9-Wörterbuch zu erzeugen bitte das Wort:_ __GENERATE__ _ins_ "
-                                   "_Eingabefeld eingeben und die Funktion starten._  \n  \n")
+                    ausgabetext = (":green[Da das T9-Wörterbuch nicht vorhanden ist, wurde das normale Wörterbuch für "
+                                   "die Suche benutzt. Das dauert zwar ca. 7x so lange, aber geht auch.  \n"
+                                   "Um das spezielle T9-Wörterbuch zu erzeugen bitte das Wort:] :orange[GENERATE] "
+                                   ":green[ins Eingabefeld eingeben und die Funktion starten.]  \n  \n")
                 return ausgabetext + helper.t9_germandic(eingabetext)
             except FileNotFoundError:
-                return "Leider konnte die Wörterbuchdatei nicht geladen werden."
+                return ":red[Leider konnte die Wörterbuchdatei nicht geladen werden.]"
         else:
-            ausgabetext = "_der eingegebene T9-Code kann für folgendes stehen:_  \n"
+            ausgabetext = ":blue[der eingegebene T9-Code kann für folgendes stehen:]  \n"
             for zeile in wbfile:
                 zeile = zeile.strip(" \t\n\r")
                 mline = zeile.split(",")
@@ -1571,9 +1576,9 @@ def t9_en(eingabetext):
         try:
             wbfile = open("./data/en_US-large.txt", "r", encoding="UTF-8")
         except FileNotFoundError:
-            return "Leider konnte die Wörterbuchdatei nicht geladen werden."
+            return ":red[Leider konnte die Wörterbuchdatei nicht geladen werden.]"
         else:
-            ausgabetext = "_der eingegebene T9-Code kann für folgendes stehen:_  \n"
+            ausgabetext = ":blue[der eingegebene T9-Code kann für folgendes stehen:]  \n"
             for zeile in wbfile:
                 zeile = zeile.strip(" \t\n\r")
                 mzeile = ""
@@ -1601,7 +1606,7 @@ def vigenere(eingabetext, pw):
     else:
         for b in pw:
             if b.upper() not in bw:
-                return "Das Passwort darf nur die Buchstaben A-Z / a-z enthalten!"
+                return ":red[Das Passwort darf nur die Buchstaben A-Z / a-z enthalten!]"
         pwl = len(pw)
         encoded_text = ""
         encoded_text_s = ""  # wenn Leer und Sonderzeichen Schlüsselbuchstaben verbrauchen