diff --git a/20230509/antiknirps-2.red b/20230509/antiknirps-2.red
new file mode 100644
index 0000000000000000000000000000000000000000..39c64c8f42632fe5c9941ba7e88feaa6878168e4
--- /dev/null
+++ b/20230509/antiknirps-2.red
@@ -0,0 +1,10 @@
+;redcode
+;name Antiknirps
+;author Peter Gerwinski
+;strategy Modifiziere den Code von Knirps, um ihn zu stoppen
+;assert 1
+
+falle DAT   #0
+      DAT   #0
+start JMP   start, <falle
+      END   start
diff --git a/20230509/antiknirps.red b/20230509/antiknirps.red
new file mode 100644
index 0000000000000000000000000000000000000000..86843ea77791cca4138c0d2a3684be10a341c1c4
--- /dev/null
+++ b/20230509/antiknirps.red
@@ -0,0 +1,11 @@
+;redcode
+;name Antiknirps
+;author Peter Gerwinski
+;strategy Modifiziere den Code von Knirps, um ihn zu stoppen
+;assert 1
+
+falle DAT   #0
+      DAT   #0
+start DJN   start, falle
+      JMP   start
+      END   start
diff --git a/20230509/dwarf-ak-01.red b/20230509/dwarf-ak-01.red
new file mode 100644
index 0000000000000000000000000000000000000000..c119bf0ba5d9cc261bbf59f970914ca8bf07a293
--- /dev/null
+++ b/20230509/dwarf-ak-01.red
@@ -0,0 +1,16 @@
+;redcode
+;name Dwarf
+;author A. K. Dewdney
+;strategy Throw DAT bombs around memory, hitting every 4th memory cell.
+;strategy This program was presented in the first Corewar article.
+;assert 1
+
+bomb  DAT   #0
+      DAT   #0
+dwarf SUB   #4,    bomb
+      MOV   bomb, @bomb
+      JMP   dwarf
+      END   dwarf          ; Programs start at the first line unless
+                           ; an "END start" pseudo-op appears to indicate
+                           ; the first logical instruction.  Also, nothing
+                           ; after the END instruction will be assembled.
diff --git a/20230509/dwarf-ak-02.red b/20230509/dwarf-ak-02.red
new file mode 100644
index 0000000000000000000000000000000000000000..184a1b32616ea50d55665586f3de3f927779b22a
--- /dev/null
+++ b/20230509/dwarf-ak-02.red
@@ -0,0 +1,17 @@
+;redcode
+;name Dwarf
+;author A. K. Dewdney
+;strategy Throw DAT bombs around memory, hitting every 4th memory cell.
+;strategy This program was presented in the first Corewar article.
+;assert 1
+
+bomb  DAT   #0
+      DAT   #0
+dwarf SUB   #2,    bomb
+      MOV   bomb, <bomb
+      DJN   dwarf, bomb
+      JMP   dwarf
+      END   dwarf          ; Programs start at the first line unless
+                           ; an "END start" pseudo-op appears to indicate
+                           ; the first logical instruction.  Also, nothing
+                           ; after the END instruction will be assembled.
diff --git a/20230509/dwarf-ak-03.red b/20230509/dwarf-ak-03.red
new file mode 100644
index 0000000000000000000000000000000000000000..e5f359ce72114a22c32de20d36662d896fd88f78
--- /dev/null
+++ b/20230509/dwarf-ak-03.red
@@ -0,0 +1,16 @@
+;redcode
+;name Dwarf
+;author A. K. Dewdney
+;strategy Throw DAT bombs around memory, hitting every 4th memory cell.
+;strategy This program was presented in the first Corewar article.
+;assert 1
+
+bomb  DAT   #0
+      DAT   #0
+dwarf SUB   #2,     bomb
+      MOV   bomb,  <bomb
+      JMP   dwarf, <bomb
+      END   dwarf          ; Programs start at the first line unless
+                           ; an "END start" pseudo-op appears to indicate
+                           ; the first logical instruction.  Also, nothing
+                           ; after the END instruction will be assembled.
diff --git a/20230509/dwarf-ak-04.red b/20230509/dwarf-ak-04.red
new file mode 100644
index 0000000000000000000000000000000000000000..9271d7741387d0525d3ba240f8f3fde9f193f882
--- /dev/null
+++ b/20230509/dwarf-ak-04.red
@@ -0,0 +1,17 @@
+;redcode
+;name Dwarf
+;author A. K. Dewdney
+;strategy Throw DAT bombs around memory, hitting every 4th memory cell.
+;strategy This program was presented in the first Corewar article.
+;assert 1
+
+bomb   DAT   #0
+       DAT   #0
+dwarf  SUB   #2,      bomb
+       MOV   knirps, <bomb
+       JMP   dwarf,  <bomb
+knirps MOV   0,       1
+       END   dwarf          ; Programs start at the first line unless
+                            ; an "END start" pseudo-op appears to indicate
+                            ; the first logical instruction.  Also, nothing
+                            ; after the END instruction will be assembled.
diff --git a/20230509/dwarf-ak-05.red b/20230509/dwarf-ak-05.red
new file mode 100644
index 0000000000000000000000000000000000000000..f1dc9863adff7536d47189898156eef291e0252b
--- /dev/null
+++ b/20230509/dwarf-ak-05.red
@@ -0,0 +1,16 @@
+;redcode
+;name Dwarf
+;author A. K. Dewdney
+;strategy Throw DAT bombs around memory, hitting every 4th memory cell.
+;strategy This program was presented in the first Corewar article.
+;assert 1
+
+bomb  DAT   #0
+      DAT   #0
+dwarf SUB   #3,     bomb
+      MOV   bomb,  <bomb
+      JMP   dwarf
+      END   dwarf          ; Programs start at the first line unless
+                           ; an "END start" pseudo-op appears to indicate
+                           ; the first logical instruction.  Also, nothing
+                           ; after the END instruction will be assembled.
diff --git a/20230509/dwarf-ak-06.red b/20230509/dwarf-ak-06.red
new file mode 100644
index 0000000000000000000000000000000000000000..c1869ea808958e5192c66f7e7f0fa3d6b2abdb05
--- /dev/null
+++ b/20230509/dwarf-ak-06.red
@@ -0,0 +1,15 @@
+;redcode
+;name Dwarf
+;author A. K. Dewdney
+;strategy Throw DAT bombs around memory, hitting every 4th memory cell.
+;strategy This program was presented in the first Corewar article.
+;assert 1
+
+bomb  DAT   #0
+      DAT   #0
+dwarf MOV   bomb,  <bomb
+      JMP   dwarf, <bomb
+      END   dwarf          ; Programs start at the first line unless
+                           ; an "END start" pseudo-op appears to indicate
+                           ; the first logical instruction.  Also, nothing
+                           ; after the END instruction will be assembled.
diff --git a/20230509/dwarf-ak-07.red b/20230509/dwarf-ak-07.red
new file mode 100644
index 0000000000000000000000000000000000000000..e889dec5d4de22552e0fb44db0707a912acc206a
--- /dev/null
+++ b/20230509/dwarf-ak-07.red
@@ -0,0 +1,17 @@
+;redcode
+;name Dwarf
+;author A. K. Dewdney
+;strategy Throw DAT bombs around memory, hitting every 4th memory cell.
+;strategy This program was presented in the first Corewar article.
+;assert 1
+
+ptr   DAT   #0
+      DAT   #0
+dwarf SUB   #2,     ptr
+      MOV   bomb,  <ptr
+      JMP   dwarf, <ptr
+bomb  DAT   #0
+      END   dwarf          ; Programs start at the first line unless
+                           ; an "END start" pseudo-op appears to indicate
+                           ; the first logical instruction.  Also, nothing
+                           ; after the END instruction will be assembled.
diff --git a/20230509/rtech-20230509.txt b/20230509/rtech-20230509.txt
new file mode 100644
index 0000000000000000000000000000000000000000..069f5968ac962446888392fa7b85c7399bca38eb
--- /dev/null
+++ b/20230509/rtech-20230509.txt
@@ -0,0 +1,50 @@
+xzoom -mag 2 -source 640x480+0+0 &
+
+./pmars -s 4001 -p 64 -e -v 704 knirps.red dwarf-ak-06.red
+
+Warum spielt der optimierte Dwarf gegen Knirps unentschieden?
+mov -2, <-2
+ - Dwarf liest die Speicherzelle ("in ein Primary-Secondary-D-Flipflop").
+ - Dwarf dekrementiert die Speicherzelle. Danach zeigt sie auf sich selbst.
+ - Dwarf speichert die soeben gelesene Kopie wieder in der Speicherzelle.
+Lösung des Problems: etwas anderes dorthin-mov-en.
+(Beim Testen hatten wir noch einmal das alte Programm getestet.)
+
+Physik: https://www.peter.gerwinski.de/physik/
+
+Knirps-Lanze
+mov 1 20
+--> durch spl-Befehl verlangsamen, dann grundsätzlich kampfstark
+
+Selbsterkennung ohne Schwanz
+ - Suchen mit großer Schrittweite
+ - etwas gefunden: Schritt zurück, dann kontinuierlich suchen
+ - letzte Speicherzelle (Adresse bekannt!) des eigenen Programms gefunden --> überspringen
+Nachteil: rechenzeitintensiv
+ - Man verliert gegen Gegner, die "interessante" Muster in den Speicher malen.
+
+Stealth-Taktik: Man wird nicht gefunden von Gegnern, die nach != 0 suchen.
+  mov #42, 0
+  mov #137, 0
+  mov #13, 0
+  ...
+Nachteil: rechenzeitintensiv
+
+Knirps als Waffe gegen Mäuse?
+ - mit Knirpsen schießen
+   --> Maus wird zu Knirps, räumt andere Mäuse ab.
+ - Eigene Knirpsfalle sammelt die Mäuse ein.
+--> Hat in der Praxis bis jetzt nicht funktioniert.
+
+Gegner für sich selbst arbeiten lassen: chml83b.red
+
+Supermaus?
+Idee: Mice geht freiwillig direkt in eine Laufzeitfalle.
+Von Anfang an 64 Tasks.
+Beim Vermehren gehen 32 in die Kopie, 32 bleiben im Original.
+Danach splitten wir uns weiter auf.
+--> Treffer durch Laufzeitfalle sind vergleichsweise harmlos.
+Problem: Koordinierung der verschiedenen Threads.
+ - Kopieren sollte funktionieren. (Evtl. wird die Kopie zu lang.)
+ - Aufteilen beim SPL: selbstmodifizierender Code
+   (z.B. eigenen SPL-Befehl mit JMP überschreiben)