diff --git a/doc/efun/set_bit b/doc/efun/set_bit
new file mode 100644
index 0000000..847c6b5
--- /dev/null
+++ b/doc/efun/set_bit
@@ -0,0 +1,30 @@
+SYNOPSIS
+        string set_bit(string str, int n);
+
+BESCHREIBUNG
+        Liefert einen neuen String, bei dem das Bit <n> in <str> gesetzt
+        ist. Dabei wird der urspruengliche String <str> nicht veraendert.
+
+        Jedes Zeichen enthaelt 6 Bits. In jedem Zeichen kann deshalb eine
+        Zahl von 0 bis 63 gespeichert werde (2^6=64). Das erste Zeichen
+        ist der Leerschlag " " mit dem Wert 0. Das erste Zeichen im String
+        ist jenes mit den niedrigsten Bits (0-5).
+
+        Der neue String wird automatisch verlaengert, falls noetig.
+
+BEISPIEL
+        string s;
+        s=set_bit("?",5);
+
+        Weil "?" einen Wert von 31 hat, ist das 6. Bit nicht gesetzt. Wird
+        es gesetzt, so ergibt sich "_". Der String s enthaelt nun also "_".
+
+        string s;
+        s=set_bit("78",3);
+        s=set_bit(s,8);
+
+        s enthaelt nun "?<".
+
+SIEHE AUCH
+        clear_bit(E), last_bit(E), next_bit(E), test_bit(E), count_bits(E),
+        and_bits(E), or_bits(E), xor_bits(E), invert_bits(E), copy_bits(E)
