diff --git a/doc/efun/call_out b/doc/efun/call_out
index dba28b3..0293b3e 100644
--- a/doc/efun/call_out
+++ b/doc/efun/call_out
@@ -2,53 +2,48 @@
         void call_out(string fun, int delay, mixed arg, ...)
         void call_out(closure cl, int delay, mixed arg, ...)
 
-DESCRIPTION
-        Set up a call to function fun in the current object, or to
-        closure cl. The call will take place in delay seconds, with the
-        remaining argument list provided. delay can be 0, but be careful!
+BESCHREIBUNG
+        Ruft zeitverzoegert die Funktion <fun> im aktuellen Objekt oder
+        die Closure <cl> auf. Der Aufruf erfolgt in <delay> Sekunden.
+        Die Funktion / Closure wird mit den <arg> Argumenten aufgerufen.
+        Die minimale Verzoegerung ist 0 (negative <delay> werden implizit als
+        0 behandelt). Allerdings ist die reale Verzoegerung etwas zwischen
+        <delay> und __ALARM_TIME__.
 
-        call_out() saves and restores the current user. It is now
-        possible to use say() or write() which rely on a current
-        user to be something useful.
+        call_out() merkt sich den aktuellen User und ruft die Funktion
+        entsprechend auf. call_out() kann nur Funktionen aufrufen, die
+        oeffentlich zugaenglich sind, das heisst "public" und "static"
+        deklarierte Funtionen. "private" und "protected" deklarierte
+        Funktionen koennen nicht aufgerufen werden.
 
-        call_out() can only call functions which are publicly accessible,
-        i.e. "public" and "static" functions. "private" and "protected"
-        functions can't be called.
+        Die Ausfuehrung von call_out()s erfordert einen einfachen (nicht
+        zu aufwendigen) Schutz gegen Rabbits: die Evalkosten aller
+        gleichzeitig anstehenden call_out()s werden auf einer pro-UID-Basis
+        summiert. Uebersteigt die Summe ein vorgegebenes Maximum, wird
+        ein Fehler 'too long evaluation' erzeugt, und es werden alle
+        call_out()s des betreffenden Benutzers, die zur gleichen Zeit
+        faellig werden, entfernt.
 
-        The execution of the call_out()s implies a simple (not
-        exhaustive) measure against rabbits: the evaluation costs of
-        those call_outs() executing at the same time are summed up on
-        a per-UID base. If the summed-up costs exceed the given maximum,
-        a 'too long evaluation' error will occur and any remaining
-        call_outs() of this user scheduled for the same time are
-        discarded.
+        Wenn zwei call_out()s zum gleichen Zeitpunkt ausgefuehrt werden
+        sollen, wird der zuerst gestartete zuerst ausgefuehrt.
 
-        Callouts are executed every 2s, therefore your delay may be bigger
-        than the you specified. In fact, a Callout with delay==0 is
-        executed within 2s from the function call to call_out(). 
-
-WARNING
-        Please never use call_out(...,0) in recursive Callouts and be at least
-        very careful in other cases. That Callout would be executed directly
-        after your current function and you really get 0 delay.
-
-EXAMPLE
+BEISPIELE
         call_out("RefreshMe", 10);
 
-        This will call the function RefreshMe() in 10 seconds without
-        any arguments. The function RefreshMe() can then call out
-        itself again which will result in a loop (not in a recursion)
-        which can be used to check or set up things in the object in
-        intervals. Be aware that callouts are stored in a linear
-        list, and so are somewhat expensive for the driver.
+        Dies ruft die Funktion RefreshMe() nach Ablauf von 10 Sekunden ohne
+        irgendwelche Argumente auf. Die Funktion RefresMe() kann dann
+        wiederum selbst call_out()s starten, auch auf sich selbst, was
+        eine Schleife erzeugt (keine Rekursion). Mit einer solchen Schleife
+        koennen Anweisungen in einem Objekt in regelmaessigen Zeitintervallen
+        ausgefuehrt werden. Es ist allerdings zu beachten, dass call_out()s
+        in einer linearen Liste gespeichert werden, und deshalb ziemlich
+        rechenaufwendig fuer den Treiber sind.
 
-        And YES: self-replicating call_out()s, where each call_out()
-        creates two or more other call_out()s in a loop (so called
-        'rabbits') slow the mud down very fast, and are even able
-        to crash it. No need to try it yourself.
+        Und JA: selbst-replizierende call_out()s, bei denen jeder call_out()
+        selbst zwei oder mehr call_out()s in einem Loop erzeugt (sogenannte
+        Rabbits) verlangsamen das Mud ungemein und koennen es sogar zum
+        Crash bringen. Kein Grund, es selbst auszuprobieren.
 
-SEE ALSO
+SIEHE AUCH
         remove_call_out(E), call_out_info(E), find_call_out(E),
         this_player(E), reset(A), heart_beat(A)
-
-05.11.06 Zesstra