diff --git a/OLD.entwicklung b/OLD.entwicklung
index b25f0a1..68888aa 100644
--- a/OLD.entwicklung
+++ b/OLD.entwicklung
@@ -130148,3 +130148,36 @@
 
 
 
+Familienaliase (Zesstra, 27. Mai 2019, 22:23:55):
+Huhu allerseits,
+
+ich habe vorhin eine Erweiterung der Aliase im Spiel eingebaut. Und zwar kann
+man nun Familienaliase definieren, welche sich alle Chars in einer
+Zweitiefamilie (inkl. dem Erstie) teilen.
+
+Hierbei ist es unerheblich, welcher Char das Familienalias erstellt hat. Alle
+anderen Chars bekommen Aenderungen der Familienaliase beim naechsten Login
+automatisch mit (vorher kennen sie ein neues nicht oder benutzen, falls eins
+geaendert wurde).
+
+Familienaliase werden ggf. von gleichnamigen Aliasen im Char ueberdeckt, d.h.
+das Familienalias ist dann nicht erreichbar oder benutzbar.
+
+Bitte beachten: wenn ihr einen Char verleiht, sieht der Entleiher alle eure
+Familienaliase und kann diese alle aendern oder loeschen.
+
+Die Familienaliase kann mit ganz normal mit alias anlegen und anzeigen und mit
+unalias loeschen, wenn man das Argument "-f" mit angibt. Details findet ihr in
+der Hilfeseite zu alias + unalias.
+
+Hinweis: Die Familienaliase sind ab jetzt fuer *Menschen* (und Magier) nach
+Ende/Reboot verfuegbar. In 1-2 Tagen werden sie fuer alle Rassen verfuegbar
+sein, bis dahin sind die Menschen die Versuchskaninchen. ;-) Feedback bitte an
+mich.
+
+Zesstra
+
+-----------------------------------------------------------------------------
+
+
+
diff --git a/OLD.hardsoftware b/OLD.hardsoftware
index 71528ed..bcd3680 100644
--- a/OLD.hardsoftware
+++ b/OLD.hardsoftware
@@ -76951,3 +76951,19 @@
 
 
 
+Re^3: Bildschirmaufloesungen (Amaryllis,  3. Jun 2019, 19:16:08):
+~#! rn=Amaryllis rt=1559504511 rg=hardsoftware
+~#! tid=1558386996
+Ich mach hier mal die Ingrid...:
+
+Bei Win10 gibt es in den Einstellungen unter "Anzeige" den Punkt "erweiterte
+Skalierungseinstellungen".
+Dort kann man "Skalierung fuer Apps korrigieren" aktivieren. Das tuts bei mir
+noch besser als das haendische Gefrickel ueber die App-Properties.
+
+Ama*
+
+-----------------------------------------------------------------------------
+
+
+
diff --git a/OLD.megaschmarrn b/OLD.megaschmarrn
index 38c2ab9..a30a247 100644
--- a/OLD.megaschmarrn
+++ b/OLD.megaschmarrn
Binary files differ
