From 4db6a221a3045d2ba731c093cfcd46dbc6a2eb58 Mon Sep 17 00:00:00 2001
From: Your Name <you@example.com>
Date: Sun, 8 Dec 2024 22:33:51 +0100
Subject: [PATCH] * added new types `NSUIntegerAtomic` and `NSIntegerAtomic` to
 facilitate @property code * experimental and *untested* `MulleProxy` class
 added * added NSAutoreleasePool debugging facility to dump contents into CSV
 format for postprocessing with sqlite or scripts * method `-[NSThread
 mulleDetach]` no longer exists! * new NSThread methods
 `-mulleInitWithObjectFunction:object:` for convenient ownership transfer even
 when using C functions * improved the teardown code of NSThread and improved
 the detached case * added various `Instance` functions, where previously
 `Object` was used exlusively to properly differentiate Class and Instance
 code * improved and simplified tracing with `MULLE_OBJC_TRACE_ZOMBIE` and
 `MULLE_OBJC_TRACE_LEAK`, which eliminates the need to use he finer grained
 variables a lot of times * added `MulleObjCObjectIsInstance` and a host of
 other introspection functions dealing with Class and Instance distinctions

---
 .idea/misc.xml                                |   5 +-
 .idea/workspace.xml                           | 111 +++---
 CMakeLists.txt                                |   2 +-
 RELEASENOTES.md                               |  13 +
 cmake/reflect/_Headers.cmake                  |   1 +
 cmake/reflect/_Sources.cmake                  |   1 +
 src/MulleObjCIntegralType.h                   | 159 ++++++++
 src/MulleObjCVersion.h                        |   2 +-
 src/class/MulleDynamicObject.m                |   3 +-
 src/class/MulleObjCAutoreleasePool.h          |   3 +-
 src/class/MulleObject-Private.h               | 140 +++++++
 src/class/MulleObject.m                       | 122 +-----
 src/class/MulleProxy.h                        |  78 ++++
 src/class/MulleProxy.m                        | 363 ++++++++++++++++++
 src/class/NSAutoreleasePool.h                 |  58 ++-
 src/class/NSAutoreleasePool.m                 | 363 ++++++++++++++++--
 src/class/NSInvocation.m                      |  30 +-
 src/class/NSNull.m                            |   4 +-
 src/class/NSObject.m                          |  12 +
 src/class/NSProxy.m                           |   2 +-
 src/class/NSThread.h                          |  32 +-
 src/class/NSThread.m                          | 253 ++++++++----
 src/function/MulleObjCAllocation.h            |  40 +-
 src/function/MulleObjCAllocation.m            |   2 +
 src/function/MulleObjCDebug.m                 |   3 +
 src/function/MulleObjCFunctions.h             |  40 +-
 src/function/MulleObjCFunctions.m             |  10 +-
 src/function/MulleObjCHashFunctions.h         |   5 +-
 src/function/MulleObjCIvar.m                  |   1 +
 src/function/MulleObjCPrinting.h              |   4 +
 src/function/MulleObjCProperty.m              |   6 +
 src/function/mulle-sprintf-object.h           |   5 +
 src/mulle-objc-atomicid.m                     |   4 +
 ...lle-objc-autoreleasepointerarray-private.h |  33 +-
 src/mulle-objc-threadfoundationinfo.h         |  14 +-
 ...ulle-objc-universefoundationinfo-private.h |   1 +
 src/mulle-objc-universefoundationinfo.m       |  38 +-
 src/mulle-objc.h                              |  48 ++-
 src/protocol/MulleObjCException.m             |   2 +-
 src/protocol/MulleObjCProtocol.m              |  12 +-
 src/protocol/MulleObjCRootObject.m            |  13 +-
 src/protocol/MulleObjCRuntimeObject.h         |   4 +-
 src/protocol/MulleObjCSingleton.m             |   5 +-
 src/protocol/NSCopyingWithAllocator.h         |   6 +-
 src/protocol/NSCopyingWithAllocator.m         |  10 +-
 src/reflect/objc-loader.inc                   |   1 +
 test/MulleObject/30-bench/various-calls.m     |   3 +-
 test/NSAutoreleasePool/pooldump-dot.awk       | 108 ++++++
 test/NSAutoreleasePool/pooldump.m             | 105 +++++
 test/NSAutoreleasePool/pooldump.sh            |   6 +
 test/NSAutoreleasePool/pooldump.stdout        |   7 +
 test/NSAutoreleasePool/pooldump_script.sql    |  28 ++
 test/NSThread/cfunction.m                     |  31 ++
 test/NSThread/cfunction.stdout                |   3 +
 test/NSThread/detached.m                      |  23 +-
 test/NSThread/detached.stdout                 |   2 +-
 test/NSThread/invokedonce.m                   |  55 +++
 test/NSThread/invokedonce.stdout              |   1 +
 test/NSThread/neverinvoked.m                  |  52 +++
 test/NSThread/objectfunction.m                |  47 +++
 test/NSThread/objectfunction.stdout           |   3 +
 test/TAO/README.md                            |  10 +
 test/TAO/backandforth/README.md               |   1 +
 test/TAO/backandforth/TAOStrategyTest.inc     |  72 ++++
 test/TAO/backandforth/default.stdout          |   0
 test/TAO/backandforth/performsfinalize.m      |  37 ++
 test/TAO/backandforth/performsfinalize.stdout |  21 +
 test/TAO/backandforth/removefromallpools.m    |  45 +++
 .../backandforth/removefromallpools.stdout    |  23 ++
 test/TAO/backandforth/removefromcurrent.m     |  37 ++
 .../TAO/backandforth/removefromcurrent.stdout |  19 +
 test/TAO/backandforth/removefrompool.stdout   |  21 +
 test/TAO/backandforth/threadsafe.m            |  38 ++
 test/TAO/backandforth/threadsafe.stdout       |  21 +
 test/TAO/backandforth/threadsafemethods.m     |  37 ++
 .../TAO/backandforth/threadsafemethods.stdout |  21 +
 test/TAO/backward/README.md                   |   1 +
 test/TAO/backward/TAOStrategyTest2.inc        |  87 +++++
 test/TAO/backward/performsfinalize.m          |  37 ++
 test/TAO/backward/performsfinalize.stdout     |  12 +
 test/TAO/backward/removefromallpools.m        |  44 +++
 test/TAO/backward/removefromallpools.stdout   |  15 +
 test/TAO/backward/removefromcurrent.m         |  37 ++
 test/TAO/backward/removefromcurrent.stdout    |  11 +
 test/TAO/backward/threadsafe.m                |  38 ++
 test/TAO/backward/threadsafe.stdout           |  12 +
 test/TAO/backward/threadsafemethods.m         |  37 ++
 test/TAO/backward/threadsafemethods.stdout    |  12 +
 test/TAO/forward/README.md                    |   5 +
 test/TAO/forward/TAOStrategyTest.inc          | 270 +++++++++++++
 test/TAO/forward/default.stdout               |   0
 test/TAO/forward/generate-animation.sh        | 196 ++++++++++
 test/TAO/forward/performsfinalize.m           |  37 ++
 test/TAO/forward/performsfinalize.stdout      |  28 ++
 test/TAO/forward/pooldump-dot.awk             | 173 +++++++++
 test/TAO/forward/removefromallpools.m         |  40 ++
 test/TAO/forward/removefromallpools.stdout    |  26 ++
 test/TAO/forward/removefromcurrent.m          |  37 ++
 test/TAO/forward/removefromcurrent.stdout     |  26 ++
 test/TAO/forward/removefrompool.stdout        |  21 +
 test/TAO/forward/threadsafe.m                 |  37 ++
 test/TAO/forward/threadsafe.stdout            |  28 ++
 test/TAO/forward/threadsafemethods.m          |  36 ++
 test/TAO/forward/threadsafemethods.stdout     |  28 ++
 104 files changed, 3881 insertions(+), 391 deletions(-)
 create mode 100644 src/class/MulleProxy.h
 create mode 100644 src/class/MulleProxy.m
 create mode 100755 test/NSAutoreleasePool/pooldump-dot.awk
 create mode 100644 test/NSAutoreleasePool/pooldump.m
 create mode 100755 test/NSAutoreleasePool/pooldump.sh
 create mode 100644 test/NSAutoreleasePool/pooldump.stdout
 create mode 100644 test/NSAutoreleasePool/pooldump_script.sql
 create mode 100644 test/NSThread/cfunction.m
 create mode 100644 test/NSThread/cfunction.stdout
 create mode 100644 test/NSThread/invokedonce.m
 create mode 100644 test/NSThread/invokedonce.stdout
 create mode 100644 test/NSThread/neverinvoked.m
 create mode 100644 test/NSThread/objectfunction.m
 create mode 100644 test/NSThread/objectfunction.stdout
 create mode 100644 test/TAO/README.md
 create mode 100644 test/TAO/backandforth/README.md
 create mode 100644 test/TAO/backandforth/TAOStrategyTest.inc
 create mode 100644 test/TAO/backandforth/default.stdout
 create mode 100644 test/TAO/backandforth/performsfinalize.m
 create mode 100644 test/TAO/backandforth/performsfinalize.stdout
 create mode 100644 test/TAO/backandforth/removefromallpools.m
 create mode 100644 test/TAO/backandforth/removefromallpools.stdout
 create mode 100644 test/TAO/backandforth/removefromcurrent.m
 create mode 100644 test/TAO/backandforth/removefromcurrent.stdout
 create mode 100644 test/TAO/backandforth/removefrompool.stdout
 create mode 100644 test/TAO/backandforth/threadsafe.m
 create mode 100644 test/TAO/backandforth/threadsafe.stdout
 create mode 100644 test/TAO/backandforth/threadsafemethods.m
 create mode 100644 test/TAO/backandforth/threadsafemethods.stdout
 create mode 100644 test/TAO/backward/README.md
 create mode 100644 test/TAO/backward/TAOStrategyTest2.inc
 create mode 100644 test/TAO/backward/performsfinalize.m
 create mode 100644 test/TAO/backward/performsfinalize.stdout
 create mode 100644 test/TAO/backward/removefromallpools.m
 create mode 100644 test/TAO/backward/removefromallpools.stdout
 create mode 100644 test/TAO/backward/removefromcurrent.m
 create mode 100644 test/TAO/backward/removefromcurrent.stdout
 create mode 100644 test/TAO/backward/threadsafe.m
 create mode 100644 test/TAO/backward/threadsafe.stdout
 create mode 100644 test/TAO/backward/threadsafemethods.m
 create mode 100644 test/TAO/backward/threadsafemethods.stdout
 create mode 100644 test/TAO/forward/README.md
 create mode 100644 test/TAO/forward/TAOStrategyTest.inc
 create mode 100644 test/TAO/forward/default.stdout
 create mode 100755 test/TAO/forward/generate-animation.sh
 create mode 100644 test/TAO/forward/performsfinalize.m
 create mode 100644 test/TAO/forward/performsfinalize.stdout
 create mode 100755 test/TAO/forward/pooldump-dot.awk
 create mode 100644 test/TAO/forward/removefromallpools.m
 create mode 100644 test/TAO/forward/removefromallpools.stdout
 create mode 100644 test/TAO/forward/removefromcurrent.m
 create mode 100644 test/TAO/forward/removefromcurrent.stdout
 create mode 100644 test/TAO/forward/removefrompool.stdout
 create mode 100644 test/TAO/forward/threadsafe.m
 create mode 100644 test/TAO/forward/threadsafe.stdout
 create mode 100644 test/TAO/forward/threadsafemethods.m
 create mode 100644 test/TAO/forward/threadsafemethods.stdout

diff --git a/.idea/misc.xml b/.idea/misc.xml
index 9b6b4d93..da5f1b3c 100644
--- a/.idea/misc.xml
+++ b/.idea/misc.xml
@@ -1,5 +1,8 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
+  <component name="CMakePythonSetting">
+    <option name="pythonIntegrationState" value="YES" />
+  </component>
   <component name="CMakeWorkspace" PROJECT_DIR="$PROJECT_DIR$" />
   <component name="CidrRootsConfiguration">
     <libraryRoots>
@@ -21,4 +24,4 @@
       <file path="$PROJECT_DIR$/test/kitchen" />
     </excludeRoots>
   </component>
-</project>
+</project>
\ No newline at end of file
diff --git a/.idea/workspace.xml b/.idea/workspace.xml
index 4e41158c..db36109b 100644
--- a/.idea/workspace.xml
+++ b/.idea/workspace.xml
@@ -6,6 +6,9 @@
   <component name="CMakePresetLoader">{
   &quot;useNewFormat&quot;: true
 }</component>
+  <component name="CMakeProjectFlavorService">
+    <option name="flavorId" value="CMakePlainProjectFlavor" />
+  </component>
   <component name="CMakeReloadState">
     <option name="reloaded" value="true" />
   </component>
@@ -13,7 +16,7 @@
     <generated>
       <config projectName="MulleObjC" targetName="_1_MulleObjC" />
       <config projectName="MulleObjC" targetName="_2_MulleObjC" />
-      <config projectName="MulleObjC" targetName="__objc_loader_inc__" />
+      <config projectName="MulleObjC" targetName="MulleObjC__objc_loader_inc__" />
       <config projectName="MulleObjC" targetName="_3_MulleObjC" />
       <config projectName="MulleObjC" targetName="MulleObjC" />
     </generated>
@@ -25,86 +28,49 @@
   </component>
   <component name="ChangeListManager">
     <list default="true" id="556511f9-4131-46d8-8674-26219e17cebf" name="Changes" comment="">
-      <change afterPath="$PROJECT_DIR$/test/NSObject/ivar_atomic.m" afterDir="false" />
-      <change afterPath="$PROJECT_DIR$/test/NSObject/strategy.m" afterDir="false" />
-      <change afterPath="$PROJECT_DIR$/test/NSObject/strategy.stdout" afterDir="false" />
-      <change afterPath="$PROJECT_DIR$/test/functions/zombify-large.errors" afterDir="false" />
-      <change afterPath="$PROJECT_DIR$/test/functions/zombify-large.m" afterDir="false" />
-      <change afterPath="$PROJECT_DIR$/test/functions/zombify.errors" afterDir="false" />
-      <change afterPath="$PROJECT_DIR$/test/functions/zombify.m" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/.idea/MulleObjC.iml" beforeDir="false" afterPath="$PROJECT_DIR$/.idea/MulleObjC.iml" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/.idea/modules.xml" beforeDir="false" afterPath="$PROJECT_DIR$/.idea/modules.xml" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/.idea/misc.xml" beforeDir="false" afterPath="$PROJECT_DIR$/.idea/misc.xml" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/.idea/workspace.xml" beforeDir="false" afterPath="$PROJECT_DIR$/.idea/workspace.xml" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/cmake/reflect/_Headers.cmake" beforeDir="false" afterPath="$PROJECT_DIR$/cmake/reflect/_Headers.cmake" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/cmake/reflect/_Sources.cmake" beforeDir="false" afterPath="$PROJECT_DIR$/cmake/reflect/_Sources.cmake" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/class/MulleDynamicObject.h" beforeDir="false" afterPath="$PROJECT_DIR$/src/class/MulleDynamicObject.h" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/MulleObjCIntegralType.h" beforeDir="false" afterPath="$PROJECT_DIR$/src/MulleObjCIntegralType.h" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/src/class/MulleDynamicObject.m" beforeDir="false" afterPath="$PROJECT_DIR$/src/class/MulleDynamicObject.m" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/class/MulleObject.h" beforeDir="false" afterPath="$PROJECT_DIR$/src/class/MulleObject.h" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/class/MulleObjCAutoreleasePool.h" beforeDir="false" afterPath="$PROJECT_DIR$/src/class/MulleObjCAutoreleasePool.h" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/class/MulleObject-Private.h" beforeDir="false" afterPath="$PROJECT_DIR$/src/class/MulleObject-Private.h" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/src/class/MulleObject.m" beforeDir="false" afterPath="$PROJECT_DIR$/src/class/MulleObject.m" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/src/class/NSAutoreleasePool.h" beforeDir="false" afterPath="$PROJECT_DIR$/src/class/NSAutoreleasePool.h" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/class/NSConditionLock.m" beforeDir="false" afterPath="$PROJECT_DIR$/src/class/NSConditionLock.m" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/class/NSInvocation.h" beforeDir="false" afterPath="$PROJECT_DIR$/src/class/NSInvocation.h" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/class/NSAutoreleasePool.m" beforeDir="false" afterPath="$PROJECT_DIR$/src/class/NSAutoreleasePool.m" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/src/class/NSInvocation.m" beforeDir="false" afterPath="$PROJECT_DIR$/src/class/NSInvocation.m" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/class/NSMethodSignature.h" beforeDir="false" afterPath="$PROJECT_DIR$/src/class/NSMethodSignature.h" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/class/NSMethodSignature.m" beforeDir="false" afterPath="$PROJECT_DIR$/src/class/NSMethodSignature.m" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/class/NSObject.h" beforeDir="false" afterPath="$PROJECT_DIR$/src/class/NSObject.h" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/class/NSNull.m" beforeDir="false" afterPath="$PROJECT_DIR$/src/class/NSNull.m" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/src/class/NSObject.m" beforeDir="false" afterPath="$PROJECT_DIR$/src/class/NSObject.m" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/src/class/NSProxy.m" beforeDir="false" afterPath="$PROJECT_DIR$/src/class/NSProxy.m" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/src/class/NSThread.h" beforeDir="false" afterPath="$PROJECT_DIR$/src/class/NSThread.h" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/src/class/NSThread.m" beforeDir="false" afterPath="$PROJECT_DIR$/src/class/NSThread.m" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/function/MulleObjCAllocation.h" beforeDir="false" afterPath="$PROJECT_DIR$/src/function/MulleObjCAllocation.h" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/function/MulleObjCAllocation.m" beforeDir="false" afterPath="$PROJECT_DIR$/src/function/MulleObjCAllocation.m" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/function/MulleObjCDebug.m" beforeDir="false" afterPath="$PROJECT_DIR$/src/function/MulleObjCDebug.m" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/src/function/MulleObjCFunctions.h" beforeDir="false" afterPath="$PROJECT_DIR$/src/function/MulleObjCFunctions.h" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/src/function/MulleObjCFunctions.m" beforeDir="false" afterPath="$PROJECT_DIR$/src/function/MulleObjCFunctions.m" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/function/MulleObjCIvar.h" beforeDir="false" afterPath="$PROJECT_DIR$/src/function/MulleObjCIvar.h" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/function/MulleObjCHashFunctions.h" beforeDir="false" afterPath="$PROJECT_DIR$/src/function/MulleObjCHashFunctions.h" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/src/function/MulleObjCIvar.m" beforeDir="false" afterPath="$PROJECT_DIR$/src/function/MulleObjCIvar.m" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/src/function/MulleObjCPrinting.h" beforeDir="false" afterPath="$PROJECT_DIR$/src/function/MulleObjCPrinting.h" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/function/MulleObjCPrinting.m" beforeDir="false" afterPath="$PROJECT_DIR$/src/function/MulleObjCPrinting.m" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/function/MulleObjCProperty.h" beforeDir="false" afterPath="$PROJECT_DIR$/src/function/MulleObjCProperty.h" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/function/NSByteOrder.h" beforeDir="false" afterPath="$PROJECT_DIR$/src/function/NSByteOrder.h" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/function/NSDebug.h" beforeDir="false" afterPath="$PROJECT_DIR$/src/function/NSDebug.h" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/function/NSDebug.m" beforeDir="false" afterPath="$PROJECT_DIR$/src/function/NSDebug.m" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/generic/include.h" beforeDir="false" afterPath="$PROJECT_DIR$/src/generic/include.h" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/mulle-objc-type.c" beforeDir="false" afterPath="$PROJECT_DIR$/src/mulle-objc-type.c" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/mulle-objc-type.h" beforeDir="false" afterPath="$PROJECT_DIR$/src/mulle-objc-type.h" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/function/MulleObjCProperty.m" beforeDir="false" afterPath="$PROJECT_DIR$/src/function/MulleObjCProperty.m" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/function/mulle-sprintf-object.h" beforeDir="false" afterPath="$PROJECT_DIR$/src/function/mulle-sprintf-object.h" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/mulle-objc-atomicid.m" beforeDir="false" afterPath="$PROJECT_DIR$/src/mulle-objc-atomicid.m" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/mulle-objc-autoreleasepointerarray-private.h" beforeDir="false" afterPath="$PROJECT_DIR$/src/mulle-objc-autoreleasepointerarray-private.h" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/mulle-objc-threadfoundationinfo.h" beforeDir="false" afterPath="$PROJECT_DIR$/src/mulle-objc-threadfoundationinfo.h" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/mulle-objc-universefoundationinfo-private.h" beforeDir="false" afterPath="$PROJECT_DIR$/src/mulle-objc-universefoundationinfo-private.h" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/mulle-objc-universefoundationinfo.m" beforeDir="false" afterPath="$PROJECT_DIR$/src/mulle-objc-universefoundationinfo.m" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/src/mulle-objc.h" beforeDir="false" afterPath="$PROJECT_DIR$/src/mulle-objc.h" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/protocol/MulleObjCException.h" beforeDir="false" afterPath="$PROJECT_DIR$/src/protocol/MulleObjCException.h" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/protocol/MulleObjCProtocol.h" beforeDir="false" afterPath="$PROJECT_DIR$/src/protocol/MulleObjCProtocol.h" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/protocol/MulleObjCException.m" beforeDir="false" afterPath="$PROJECT_DIR$/src/protocol/MulleObjCException.m" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/src/protocol/MulleObjCProtocol.m" beforeDir="false" afterPath="$PROJECT_DIR$/src/protocol/MulleObjCProtocol.m" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/protocol/MulleObjCRootObject.h" beforeDir="false" afterPath="$PROJECT_DIR$/src/protocol/MulleObjCRootObject.h" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/src/protocol/MulleObjCRootObject.m" beforeDir="false" afterPath="$PROJECT_DIR$/src/protocol/MulleObjCRootObject.m" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/src/protocol/MulleObjCRuntimeObject.h" beforeDir="false" afterPath="$PROJECT_DIR$/src/protocol/MulleObjCRuntimeObject.h" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/protocol/MulleObjCSingleton.h" beforeDir="false" afterPath="$PROJECT_DIR$/src/protocol/MulleObjCSingleton.h" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/src/protocol/MulleObjCSingleton.m" beforeDir="false" afterPath="$PROJECT_DIR$/src/protocol/MulleObjCSingleton.m" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/protocol/NSFastEnumeration.h" beforeDir="false" afterPath="$PROJECT_DIR$/src/protocol/NSFastEnumeration.h" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/protocol/NSLocking.h" beforeDir="false" afterPath="$PROJECT_DIR$/src/protocol/NSLocking.h" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/reflect/_MulleObjC-provide.h" beforeDir="false" afterPath="$PROJECT_DIR$/src/reflect/_MulleObjC-provide.h" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/test/0_noleak/noleak.m" beforeDir="false" afterPath="$PROJECT_DIR$/test/0_noleak/noleak.m" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/test/MulleObjCThreadSafe/tao-check-fail.m" beforeDir="false" afterPath="$PROJECT_DIR$/test/MulleObjCThreadSafe/tao-check-fail.m" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/test/MulleObjCThreadSafe/tao-check-ok.m" beforeDir="false" afterPath="$PROJECT_DIR$/test/MulleObjCThreadSafe/tao-check-ok.m" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/test/MulleObject/20-misc/verify-forward-locked.m" beforeDir="false" afterPath="$PROJECT_DIR$/test/MulleObject/20-misc/verify-forward-locked.m" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/test/MulleObject/20-misc/verify-locked.m" beforeDir="false" afterPath="$PROJECT_DIR$/test/MulleObject/20-misc/verify-locked.m" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/test/MulleObject/20-misc/verify-super-forward-locked.m" beforeDir="false" afterPath="$PROJECT_DIR$/test/MulleObject/20-misc/verify-super-forward-locked.m" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/test/MulleObject/20-misc/verify-unlocked.m" beforeDir="false" afterPath="$PROJECT_DIR$/test/MulleObject/20-misc/verify-unlocked.m" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/test/MulleObject/20-misc/verify-unlocked2.m" beforeDir="false" afterPath="$PROJECT_DIR$/test/MulleObject/20-misc/verify-unlocked2.m" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/test/NSAutoreleasePool/autopool.m" beforeDir="false" afterPath="$PROJECT_DIR$/test/NSAutoreleasePool/autopool.m" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/test/NSInvocation/vararg-invoke-simple.m" beforeDir="false" afterPath="$PROJECT_DIR$/test/NSInvocation/vararg-invoke-simple.m" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/test/NSInvocation/vararg-invoke.m" beforeDir="false" afterPath="$PROJECT_DIR$/test/NSInvocation/vararg-invoke.m" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/test/NSInvocation/vararg-invoke.stdout" beforeDir="false" afterPath="$PROJECT_DIR$/test/NSInvocation/vararg-invoke.stdout" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/test/NSThread/a-one-thread-noleak.m" beforeDir="false" afterPath="$PROJECT_DIR$/test/NSThread/a-one-thread-noleak.m" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/test/NSThread/a-one-thread-scenario.m" beforeDir="false" afterPath="$PROJECT_DIR$/test/NSThread/a-one-thread-scenario.m" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/test/NSThread/a-two-thread-scenario.m" beforeDir="false" afterPath="$PROJECT_DIR$/test/NSThread/a-two-thread-scenario.m" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/test/NSThread/acquire-relinquish-fail-thread.m" beforeDir="false" afterPath="$PROJECT_DIR$/test/NSThread/acquire-relinquish-fail-thread.m" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/test/NSThread/acquire-relinquish-simple.m" beforeDir="false" afterPath="$PROJECT_DIR$/test/NSThread/acquire-relinquish-simple.m" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/test/NSThread/acquire-relinquish.m" beforeDir="false" afterPath="$PROJECT_DIR$/test/NSThread/acquire-relinquish.m" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/test/NSThread/cache-stress.m" beforeDir="false" afterPath="$PROJECT_DIR$/test/NSThread/cache-stress.m" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/test/NSThread/call-stress.m" beforeDir="false" afterPath="$PROJECT_DIR$/test/NSThread/call-stress.m" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/test/NSThread/lookup-stress.m" beforeDir="false" afterPath="$PROJECT_DIR$/test/NSThread/lookup-stress.m" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/test/NSThread/simple.m" beforeDir="false" afterPath="$PROJECT_DIR$/test/NSThread/simple.m" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/test/NSThread/tao-dilemma-fixed.m" beforeDir="false" afterPath="$PROJECT_DIR$/test/NSThread/tao-dilemma-fixed.m" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/test/NSThread/tao-dilemma.m" beforeDir="false" afterPath="$PROJECT_DIR$/test/NSThread/tao-dilemma.m" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/test/NSThread/threadautopool.m" beforeDir="false" afterPath="$PROJECT_DIR$/test/NSThread/threadautopool.m" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/test/NS_ENUM/options.m" beforeDir="false" afterPath="$PROJECT_DIR$/test/NS_ENUM/options.m" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/test/functions/inheritance/protocolclass-initialize.m" beforeDir="false" afterPath="$PROJECT_DIR$/test/functions/inheritance/protocolclass-initialize.m" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/test/functions/inheritance/protocolclass-initialize.stdout" beforeDir="false" afterPath="$PROJECT_DIR$/test/functions/inheritance/protocolclass-initialize.stdout" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/protocol/NSCopyingWithAllocator.h" beforeDir="false" afterPath="$PROJECT_DIR$/src/protocol/NSCopyingWithAllocator.h" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/protocol/NSCopyingWithAllocator.m" beforeDir="false" afterPath="$PROJECT_DIR$/src/protocol/NSCopyingWithAllocator.m" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/reflect/objc-loader.inc" beforeDir="false" afterPath="$PROJECT_DIR$/src/reflect/objc-loader.inc" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/test/MulleObject/30-bench/various-calls.m" beforeDir="false" afterPath="$PROJECT_DIR$/test/MulleObject/30-bench/various-calls.m" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/test/NSThread/detached.m" beforeDir="false" afterPath="$PROJECT_DIR$/test/NSThread/detached.m" afterDir="false" />
     </list>
     <option name="SHOW_DIALOG" value="false" />
     <option name="HIGHLIGHT_CONFLICTS" value="true" />
@@ -135,45 +101,57 @@
   <component name="PropertiesComponent">{
   &quot;keyToString&quot;: {
     &quot;RunOnceActivity.CodyAccountHistoryMigration&quot;: &quot;true&quot;,
+    &quot;RunOnceActivity.CodyAccountsIdsRefresh&quot;: &quot;true&quot;,
+    &quot;RunOnceActivity.CodyAssignOrphanedChatsToActiveAccount&quot;: &quot;true&quot;,
     &quot;RunOnceActivity.CodyConvertUrlToCodebaseName&quot;: &quot;true&quot;,
     &quot;RunOnceActivity.CodyHistoryLlmMigration&quot;: &quot;true&quot;,
+    &quot;RunOnceActivity.CodyMigrateChatHistory-v2&quot;: &quot;true&quot;,
     &quot;RunOnceActivity.CodyProjectSettingsMigration&quot;: &quot;true&quot;,
     &quot;RunOnceActivity.OpenProjectViewOnStart&quot;: &quot;true&quot;,
     &quot;RunOnceActivity.ShowReadmeOnStart&quot;: &quot;true&quot;,
+    &quot;RunOnceActivity.ToggleCodyToolWindowAfterMigration&quot;: &quot;true&quot;,
     &quot;RunOnceActivity.cidr.known.project.marker&quot;: &quot;true&quot;,
     &quot;RunOnceActivity.readMode.enableVisualFormatting&quot;: &quot;true&quot;,
     &quot;cf.first.check.clang-format&quot;: &quot;false&quot;,
     &quot;cidr.known.project.marker&quot;: &quot;true&quot;,
+    &quot;git-widget-placeholder&quot;: &quot;develop&quot;,
+    &quot;last_opened_file_path&quot;: &quot;/home/src/srcO/mulle-objc/MulleObjC/dox&quot;,
     &quot;node.js.detected.package.eslint&quot;: &quot;true&quot;,
     &quot;node.js.detected.package.tslint&quot;: &quot;true&quot;,
     &quot;node.js.selected.package.eslint&quot;: &quot;(autodetect)&quot;,
     &quot;node.js.selected.package.tslint&quot;: &quot;(autodetect)&quot;,
     &quot;nodejs_package_manager_path&quot;: &quot;npm&quot;,
+    &quot;structure.view.defaults.are.configured&quot;: &quot;true&quot;,
     &quot;vue.rearranger.settings.migration&quot;: &quot;true&quot;
   }
 }</component>
   <component name="RunManager" selected="CMake Application._1_MulleObjC">
+    <configuration default="true" type="CLionExternalRunConfiguration" factoryName="Application" REDIRECT_INPUT="false" ELEVATE="false" USE_EXTERNAL_CONSOLE="false" EMULATE_TERMINAL="false" PASS_PARENT_ENVS_2="true">
+      <method v="2">
+        <option name="CLION.EXTERNAL.BUILD" enabled="true" />
+      </method>
+    </configuration>
     <configuration name="MulleObjC" type="CMakeRunConfiguration" factoryName="Application" REDIRECT_INPUT="false" ELEVATE="false" USE_EXTERNAL_CONSOLE="false" EMULATE_TERMINAL="false" PASS_PARENT_ENVS_2="true" PROJECT_NAME="MulleObjC" TARGET_NAME="MulleObjC" CONFIG_NAME="Debug">
       <method v="2">
         <option name="com.jetbrains.cidr.execution.CidrBuildBeforeRunTaskProvider$BuildBeforeRunTask" enabled="true" />
       </method>
     </configuration>
-    <configuration name="_1_MulleObjC" type="CMakeRunConfiguration" factoryName="Application" REDIRECT_INPUT="false" ELEVATE="false" USE_EXTERNAL_CONSOLE="false" EMULATE_TERMINAL="false" PASS_PARENT_ENVS_2="true" PROJECT_NAME="MulleObjC" TARGET_NAME="_1_MulleObjC" CONFIG_NAME="Debug">
+    <configuration name="MulleObjC__objc_loader_inc__" type="CMakeRunConfiguration" factoryName="Application" REDIRECT_INPUT="false" ELEVATE="false" USE_EXTERNAL_CONSOLE="false" EMULATE_TERMINAL="false" PASS_PARENT_ENVS_2="true" PROJECT_NAME="MulleObjC" TARGET_NAME="MulleObjC__objc_loader_inc__" CONFIG_NAME="Debug">
       <method v="2">
         <option name="com.jetbrains.cidr.execution.CidrBuildBeforeRunTaskProvider$BuildBeforeRunTask" enabled="true" />
       </method>
     </configuration>
-    <configuration name="_2_MulleObjC" type="CMakeRunConfiguration" factoryName="Application" REDIRECT_INPUT="false" ELEVATE="false" USE_EXTERNAL_CONSOLE="false" EMULATE_TERMINAL="false" PASS_PARENT_ENVS_2="true" PROJECT_NAME="MulleObjC" TARGET_NAME="_2_MulleObjC" CONFIG_NAME="Debug">
+    <configuration name="_1_MulleObjC" type="CMakeRunConfiguration" factoryName="Application" REDIRECT_INPUT="false" ELEVATE="false" USE_EXTERNAL_CONSOLE="false" EMULATE_TERMINAL="false" PASS_PARENT_ENVS_2="true" PROJECT_NAME="MulleObjC" TARGET_NAME="_1_MulleObjC" CONFIG_NAME="Debug">
       <method v="2">
         <option name="com.jetbrains.cidr.execution.CidrBuildBeforeRunTaskProvider$BuildBeforeRunTask" enabled="true" />
       </method>
     </configuration>
-    <configuration name="_3_MulleObjC" type="CMakeRunConfiguration" factoryName="Application" REDIRECT_INPUT="false" ELEVATE="false" USE_EXTERNAL_CONSOLE="false" EMULATE_TERMINAL="false" PASS_PARENT_ENVS_2="true" PROJECT_NAME="MulleObjC" TARGET_NAME="_3_MulleObjC" CONFIG_NAME="Debug">
+    <configuration name="_2_MulleObjC" type="CMakeRunConfiguration" factoryName="Application" REDIRECT_INPUT="false" ELEVATE="false" USE_EXTERNAL_CONSOLE="false" EMULATE_TERMINAL="false" PASS_PARENT_ENVS_2="true" PROJECT_NAME="MulleObjC" TARGET_NAME="_2_MulleObjC" CONFIG_NAME="Debug">
       <method v="2">
         <option name="com.jetbrains.cidr.execution.CidrBuildBeforeRunTaskProvider$BuildBeforeRunTask" enabled="true" />
       </method>
     </configuration>
-    <configuration name="__objc_loader_inc__" type="CMakeRunConfiguration" factoryName="Application" REDIRECT_INPUT="false" ELEVATE="false" USE_EXTERNAL_CONSOLE="false" EMULATE_TERMINAL="false" PASS_PARENT_ENVS_2="true" PROJECT_NAME="MulleObjC" TARGET_NAME="__objc_loader_inc__" CONFIG_NAME="Debug">
+    <configuration name="_3_MulleObjC" type="CMakeRunConfiguration" factoryName="Application" REDIRECT_INPUT="false" ELEVATE="false" USE_EXTERNAL_CONSOLE="false" EMULATE_TERMINAL="false" PASS_PARENT_ENVS_2="true" PROJECT_NAME="MulleObjC" TARGET_NAME="_3_MulleObjC" CONFIG_NAME="Debug">
       <method v="2">
         <option name="com.jetbrains.cidr.execution.CidrBuildBeforeRunTaskProvider$BuildBeforeRunTask" enabled="true" />
       </method>
@@ -183,7 +161,7 @@
       <item itemvalue="CMake Application._1_MulleObjC" />
       <item itemvalue="CMake Application._2_MulleObjC" />
       <item itemvalue="CMake Application._3_MulleObjC" />
-      <item itemvalue="CMake Application.__objc_loader_inc__" />
+      <item itemvalue="CMake Application.MulleObjC__objc_loader_inc__" />
     </list>
   </component>
   <component name="SpellCheckerSettings" RuntimeDictionaries="0" Folders="0" CustomDictionaries="0" DefaultDictionary="application-level" UseSingleDictionary="true" transferred="true" />
@@ -198,6 +176,7 @@
       <workItem from="1724939453407" duration="414000" />
       <workItem from="1726043501930" duration="1000" />
       <workItem from="1726043532122" duration="11000" />
+      <workItem from="1733486514464" duration="3015000" />
     </task>
     <servers />
   </component>
diff --git a/CMakeLists.txt b/CMakeLists.txt
index cb7d2b12..c8871d5e 100755
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,6 +1,6 @@
 cmake_minimum_required( VERSION 3.18) # 3.15 fails on windows
 
-project( MulleObjC VERSION 0.24.0 LANGUAGES C)
+project( MulleObjC VERSION 0.25.0 LANGUAGES C)
 
 
 if( "${CMAKE_BUILD_TYPE}" STREQUAL "Release")
diff --git a/RELEASENOTES.md b/RELEASENOTES.md
index c60010e1..1c2292a4 100644
--- a/RELEASENOTES.md
+++ b/RELEASENOTES.md
@@ -1,3 +1,16 @@
+## 0.25.0
+
+* added new types `NSUIntegerAtomic` and `NSIntegerAtomic` to facilitate @property code
+* experimental and *untested* `MulleProxy` class added
+* added NSAutoreleasePool debugging facility to dump contents into CSV format for postprocessing with sqlite or scripts
+* method `-[NSThread mulleDetach]` no longer exists!
+* new NSThread methods `-mulleInitWithObjectFunction:object:` for convenient ownership transfer even when using C functions
+* improved the teardown code of NSThread and improved the detached case
+* added various `Instance` functions, where previously `Object` was used exlusively to properly differentiate Class and Instance code
+* improved and simplified tracing with ``MULLE_OBJC_TRACE_ZOMBIE`` and ``MULLE_OBJC_TRACE_LEAK`,` which eliminates the need to use he finer grained variables a lot of times
+* added `MulleObjCObjectIsInstance` and a host of other introspection functions dealing with Class and Instance distinctions
+
+
 ## 0.24.0
 
 
diff --git a/cmake/reflect/_Headers.cmake b/cmake/reflect/_Headers.cmake
index cd82f8bb..c44edae7 100644
--- a/cmake/reflect/_Headers.cmake
+++ b/cmake/reflect/_Headers.cmake
@@ -73,6 +73,7 @@ src/class/MulleObjCAutoreleasePool.h
 src/class/MulleObjCLoader.h
 src/class/MulleObjCLockFoundation.h
 src/class/MulleObject.h
+src/class/MulleProxy.h
 src/class/NSAutoreleasePool.h
 src/class/NSConditionLock.h
 src/class/NSCondition.h
diff --git a/cmake/reflect/_Sources.cmake b/cmake/reflect/_Sources.cmake
index 9bec8dc0..8a5f69c7 100644
--- a/cmake/reflect/_Sources.cmake
+++ b/cmake/reflect/_Sources.cmake
@@ -13,6 +13,7 @@ endif()
 set( SOURCES
 src/class/MulleDynamicObject.m
 src/class/MulleObject.m
+src/class/MulleProxy.m
 src/class/NSAutoreleasePool.m
 src/class/NSConditionLock.m
 src/class/NSCondition.m
diff --git a/src/MulleObjCIntegralType.h b/src/MulleObjCIntegralType.h
index 811cd8bc..93bee1de 100644
--- a/src/MulleObjCIntegralType.h
+++ b/src/MulleObjCIntegralType.h
@@ -28,4 +28,163 @@ static inline char   *_NSComparisonResultUTF8String( NSComparisonResult result)
 }
 
 
+
+union _NSUIntegerAtomic
+{
+   NSUInteger               value;      // dont read, except when debugging
+   mulle_atomic_pointer_t   pointer;
+};
+
+typedef union _NSUIntegerAtomic   NSUIntegerAtomic;
+
+
+// ivarType:
+//     _C_ASSIGN_ID    for an ivar/property that is assign only (its a bug don't do this)
+//     _C_COPY_ID      for an ivar/property that stores a copy
+//     _C_RETAIN_ID    the default ivar stores the value retained
+//
+
+
+static inline NSUInteger   NSUIntegerAtomicGet( NSUIntegerAtomic *ivar)
+{
+   NSUInteger   value;
+
+   value = (NSUInteger) _mulle_atomic_pointer_read( &ivar->pointer);
+   return( value);
+}
+
+
+static inline NSUInteger   NSUIntegerAtomicUpdate( NSUIntegerAtomic *ivar,
+                                                   NSUInteger value)
+
+{
+   NSUInteger   old;
+
+   for(;;)
+   {
+      old = (NSUInteger) _mulle_atomic_pointer_read( &ivar->pointer);
+
+      // can't cas with same value
+      if( old == value)
+         return( old);
+
+      if( _mulle_atomic_pointer_cas( &ivar->pointer, (void *) value, (void *) old))
+      {
+         return( old);
+      }
+   }
+}
+
+
+static inline NSUInteger   NSUIntegerAtomicMaskedOr( NSUIntegerAtomic *ivar,
+                                                     NSUInteger mask,
+                                                     NSUInteger bits)
+
+{
+   NSUInteger   old;
+   NSUInteger   value;
+
+   for(;;)
+   {
+      old   = (NSUInteger) _mulle_atomic_pointer_read( &ivar->pointer);
+      value = (old & mask) | bits;
+
+      // can't cas with same value
+      if( old == value)
+         return( old);
+
+      if( _mulle_atomic_pointer_cas( &ivar->pointer, (void *) value, (void *) old))
+      {
+         return( old);
+      }
+   }
+}
+
+static inline NSUInteger   NSUIntegerAtomicOr( NSUIntegerAtomic *ivar,
+                                               NSUInteger bits)
+
+{
+   NSUInteger   old;
+   NSUInteger   value;
+
+   for(;;)
+   {
+      old   = (NSUInteger) _mulle_atomic_pointer_read( &ivar->pointer);
+      value = old | bits;
+
+      // can't cas with same value
+      if( old == value)
+         return( old);
+
+      if( _mulle_atomic_pointer_cas( &ivar->pointer, (void *) value, (void *) old))
+      {
+         return( old);
+      }
+   }
+}
+
+
+
+static inline void   NSUIntegerAtomicSet( NSUIntegerAtomic *ivar,
+                                          NSUInteger value)
+{
+   (void) NSUIntegerAtomicUpdate( ivar, value);
+}
+
+
+
+union _NSIntegerAtomic
+{
+   NSInteger               value;      // dont read, except when debugging
+   mulle_atomic_pointer_t   pointer;
+};
+
+typedef union _NSIntegerAtomic   NSIntegerAtomic;
+
+
+// ivarType:
+//     _C_ASSIGN_ID    for an ivar/property that is assign only (its a bug don't do this)
+//     _C_COPY_ID      for an ivar/property that stores a copy
+//     _C_RETAIN_ID    the default ivar stores the value retained
+//
+
+
+static inline NSInteger   NSIntegerAtomicGet( NSIntegerAtomic *ivar)
+{
+   NSInteger   value;
+
+   value = (NSInteger) _mulle_atomic_pointer_read( &ivar->pointer);
+   return( value);
+}
+
+
+static inline NSInteger   NSIntegerAtomicUpdate( NSIntegerAtomic *ivar,
+                                                 NSInteger value)
+
+{
+   NSInteger   old;
+
+   for(;;)
+   {
+      old = (NSInteger) _mulle_atomic_pointer_read( &ivar->pointer);
+
+      // can't cas with same value
+      if( old == value)
+         return( old);
+
+      if( _mulle_atomic_pointer_cas( &ivar->pointer, (void *) value, (void *) old))
+      {
+         return( old);
+      }
+   }
+}
+
+
+static inline void   NSIntegerAtomicSet( NSIntegerAtomic *ivar,
+                                         NSInteger value)
+{
+   (void) NSIntegerAtomicUpdate( ivar, value);
+}
+
+
 #endif /* ns_int_type_h */
diff --git a/src/MulleObjCVersion.h b/src/MulleObjCVersion.h
index 4920e2c3..627dfacf 100644
--- a/src/MulleObjCVersion.h
+++ b/src/MulleObjCVersion.h
@@ -41,7 +41,7 @@
 #define MulleObjC_version__h__
 
 
-#define MULLE_OBJC_VERSION    ((0UL << 20) | (24 << 8) | 0)
+#define MULLE_OBJC_VERSION    ((0UL << 20) | (25 << 8) | 0)
 
 #endif
 
diff --git a/src/class/MulleDynamicObject.m b/src/class/MulleDynamicObject.m
index d5b7b224..758afb36 100644
--- a/src/class/MulleDynamicObject.m
+++ b/src/class/MulleDynamicObject.m
@@ -36,6 +36,7 @@
 #import "MulleDynamicObject.h"
 
 #import "MulleObjCProtocol.h"
+#import "MulleObjCFunctions.h"
 
 #import "import-private.h"
 #include <ctype.h>
@@ -1949,7 +1950,7 @@ - (id) mutableCopy
    MulleDynamicObject                          *copy;
    unsigned int                         n;
 
-   copy      = [MulleObjCObjectGetClass( self) new];
+   copy      = [MulleObjCInstanceGetClass( self) new];
 
    // wipe possibly copied ivars
    n         = mulle__pointermap_get_count( &self->__ivars);
diff --git a/src/class/MulleObjCAutoreleasePool.h b/src/class/MulleObjCAutoreleasePool.h
index 25e6b205..5fa3bf32 100644
--- a/src/class/MulleObjCAutoreleasePool.h
+++ b/src/class/MulleObjCAutoreleasePool.h
@@ -99,7 +99,8 @@ void   _mulle_objc_poolconfiguration_done( struct _mulle_objc_poolconfiguration
 
 // for NSThread
 MULLE_OBJC_GLOBAL
-void   mulle_objc_thread_new_poolconfiguration( struct _mulle_objc_universe *universe);
+struct _mulle_objc_poolconfiguration  *
+   mulle_objc_thread_new_poolconfiguration( struct _mulle_objc_universe *universe);
 
 MULLE_OBJC_GLOBAL
 void   mulle_objc_thread_reset_poolconfiguration( struct _mulle_objc_universe *universe);
diff --git a/src/class/MulleObject-Private.h b/src/class/MulleObject-Private.h
index ff5eb6aa..46ff5827 100644
--- a/src/class/MulleObject-Private.h
+++ b/src/class/MulleObject-Private.h
@@ -25,3 +25,143 @@ static inline void   _MulleObjectUnlock( MulleObject *self)
       _MulleObjCRecursiveLockUnlock( _self->__lock);
 }
 
+
+
+//
+// the idea here was to separate self from __target which would then be
+// proxied forward to. alas its not so easy, because we would have to
+// change more in the code above, which makes it seem not very useful
+//
+MULLE_C_ALWAYS_INLINE
+static inline
+   void  *MulleObjectLockingForward( MulleObject *self,
+                                     mulle_objc_methodid_t methodid,
+                                     void *parameter)
+{
+   mulle_functionpointer_t            p;
+   mulle_objc_implementation_t        imp;
+   struct _mulle_objc_cache           *cache;
+   struct _mulle_objc_cacheentry      *entries;
+   struct _mulle_objc_impcachepivot   *cachepivot;
+   struct _mulle_objc_class           *cls;
+   struct _mulle_objc_method          *method;
+   struct _mulle_objc_universe        *universe;
+   void                               *rval;
+   NSRecursiveLock                    *lock;
+
+   assert( mulle_objc_uniqueid_is_sane( methodid));
+
+   assert( sizeof( void *) >= sizeof( struct _mulle_objc_cachepivot));
+
+   cls        = _mulle_objc_object_get_non_tps_isa( self);
+   cachepivot = (struct _mulle_objc_impcachepivot *) &cls->userinfo;
+   entries    = _mulle_objc_impcachepivot_get_entries_atomic( cachepivot);
+   cache      = _mulle_objc_cacheentry_get_cache_from_entries( entries);
+   p          = _mulle_objc_cache_probe_functionpointer( cache, methodid);
+   imp        = (mulle_objc_implementation_t) p;
+
+   if( ! imp)
+   {
+      method     = mulle_objc_class_search_method_nofail( cls, methodid);
+      imp        = _mulle_objc_method_get_implementation( method);
+      universe   = _mulle_objc_class_get_universe( cls);
+      _mulle_objc_impcachepivot_fill( cachepivot,
+                                      imp,
+                                      methodid,
+                                      MULLE_OBJC_CACHESIZE_GROW,
+                                      universe);
+   }
+
+   lock = ((struct { @defs( MulleObject); } *) self)->__lock; // can be NULL
+
+   // it's vital, that we increment and decrement the identical lock
+   // for performance reasons, we don't retain it (users responsibility
+   // not to torch it)
+   if( lock)
+      _MulleObjCRecursiveLockLock( lock);
+
+#ifdef NDEBUG
+   rval = mulle_objc_implementation_invoke( imp, self, methodid, parameter);
+#else
+   @try
+   {
+      rval = mulle_objc_implementation_invoke( imp, self, methodid, parameter);
+   }
+   @catch( id exception)
+   {
+      __mulle_objc_universe_raise_internalinconsistency( universe,
+                               "An exception %@ is passing thru a -[%@ %s] "
+                               "method call, which will lead to a deadlock",
+                               exception,
+                               MulleObjCObjectGetClass( self),
+                               mulle_objc_universe_lookup_methodname( universe, methodid));
+   }
+#endif
+   if( lock)
+      _MulleObjCRecursiveLockUnlock( lock);
+
+   return( rval);
+}
+
+
+
+MULLE_C_ALWAYS_INLINE
+static inline
+   void  *MulleObjectLockingSuperForward( MulleObject *self,
+                                          mulle_objc_methodid_t methodid,
+                                          void *parameter)
+
+{
+   void                               *rval;
+   NSRecursiveLock                    *lock;
+   mulle_objc_implementation_t        imp;
+   struct _mulle_objc_impcachepivot   *cachepivot;
+   struct _mulle_objc_impcache        *icache;
+   struct _mulle_objc_class           *cls;
+   struct _mulle_objc_method          *forward;
+
+   cls        = _mulle_objc_object_get_non_tps_isa( self);
+   cachepivot = (struct _mulle_objc_impcachepivot *) &cls->userinfo;
+   icache     = _mulle_objc_impcachepivot_get_impcache_atomic( cachepivot);
+   forward    = _mulle_atomic_pointer_read( &icache->callback.userinfo);
+   if( ! forward)
+   {
+      forward    = mulle_objc_class_search_method_nofail( cls, @selector( forward:));
+      _mulle_atomic_pointer_write( &icache->callback.userinfo, forward);
+   }
+
+   imp  = _mulle_objc_method_get_implementation( forward);
+   lock = ((struct { @defs( MulleObject); } *) self)->__lock; // can be NULL
+
+   // it's vital, that we increment and decrement the identical lock
+   // for performance reasons, we don't retain it (users responsibility
+   // not to torch it)
+   if( lock)
+      _MulleObjCRecursiveLockLock( lock);
+
+#ifdef NDEBUG
+   rval = mulle_objc_implementation_invoke( imp, self, methodid, parameter);
+#else
+   @try
+   {
+      rval = mulle_objc_implementation_invoke( imp, self, methodid, parameter);
+   }
+   @catch( id exception)
+   {
+      struct _mulle_objc_universe   *universe;
+
+      universe = _mulle_objc_object_get_universe( self);
+      __mulle_objc_universe_raise_internalinconsistency( universe,
+                               "An exception %@ is passing thru a -[%@ %s] "
+                               "method call, which will lead to a deadlock",
+                               exception,
+                               MulleObjCObjectGetClass( self),
+                               mulle_objc_universe_lookup_methodname( universe, methodid));
+   }
+#endif
+   if( lock)
+      _MulleObjCRecursiveLockUnlock( lock);
+
+   return( rval);
+}
+
diff --git a/src/class/MulleObject.m b/src/class/MulleObject.m
index c0e7e92c..dc9082aa 100644
--- a/src/class/MulleObject.m
+++ b/src/class/MulleObject.m
@@ -3,6 +3,7 @@
 #import "import-private.h"
 
 #import "MulleObjCException.h"
+#import "MulleObjCFunctions.h"
 
 #import "MulleObjCExceptionHandler-Private.h"
 #import "NSLock-Private.h"
@@ -370,133 +371,16 @@ + (void) deinitialize
 
 - (void *) __lockingForward:(void *) parameter
 {
-   mulle_functionpointer_t            p;
-   mulle_objc_methodid_t              methodid;
-   mulle_objc_implementation_t        imp;
-   struct _mulle_objc_cache           *cache;
-   struct _mulle_objc_cacheentry      *entries;
-   struct _mulle_objc_impcachepivot   *cachepivot;
-   struct _mulle_objc_class           *cls;
-   struct _mulle_objc_method          *method;
-   struct _mulle_objc_universe        *universe;
-   void                               *rval;
-   NSRecursiveLock                    *lock;
-
-   methodid = _cmd;
-   assert( mulle_objc_uniqueid_is_sane( methodid));
-
-   assert( sizeof( void *) >= sizeof( struct _mulle_objc_cachepivot));
-
-   cls        = _mulle_objc_object_get_non_tps_isa( self);
-   cachepivot = (struct _mulle_objc_impcachepivot *) &cls->userinfo;
-   entries    = _mulle_objc_impcachepivot_get_entries_atomic( cachepivot);
-   cache      = _mulle_objc_cacheentry_get_cache_from_entries( entries);
-   p          = _mulle_objc_cache_probe_functionpointer( cache, methodid);
-   imp        = (mulle_objc_implementation_t) p;
-
-   if( ! imp)
-   {
-      method    = mulle_objc_class_search_method_nofail( cls, methodid);
-      imp       = _mulle_objc_method_get_implementation( method);
-      universe  = _mulle_objc_class_get_universe( cls);
-      _mulle_objc_impcachepivot_fill( cachepivot,
-                                      imp,
-                                      methodid,
-                                      MULLE_OBJC_CACHESIZE_GROW,
-                                      universe);
-   }
-
-   lock = self->__lock; // can be NULL
-
-   // it's vital, that we increment and decrement the identical lock
-   // for performance reasons, we don't retain it (users responsibility
-   // not to torch it)
-   if( lock)
-      _MulleObjCRecursiveLockLock( lock);
-
-#ifdef NDEBUG
-   rval = mulle_objc_implementation_invoke( imp, self, methodid, parameter);
-#else
-   @try
-   {
-      rval = mulle_objc_implementation_invoke( imp, self, methodid, parameter);
-   }
-   @catch( id exception)
-   {
-      __mulle_objc_universe_raise_internalinconsistency( universe,
-                               "An exception %@ is passing thru a -[%@ %s] "
-                               "method call, which will lead to a deadlock",
-                               exception,
-                               MulleObjCObjectGetClass( self),
-                               mulle_objc_universe_lookup_methodname( universe, methodid));
-   }
-#endif
-   if( lock)
-      _MulleObjCRecursiveLockUnlock( lock);
-
-   return( rval);
+   return( MulleObjectLockingForward( self, _cmd, parameter));
 }
 
 
 - (void *) __lockingSuperForward:(void *) parameter
 {
-   void                               *rval;
-   NSRecursiveLock                    *lock;
-   mulle_objc_methodid_t              methodid;
-   mulle_objc_implementation_t        imp;
-   struct _mulle_objc_impcachepivot   *cachepivot;
-   struct _mulle_objc_impcache        *icache;
-   struct _mulle_objc_class           *cls;
-   struct _mulle_objc_method          *forward;
-
-   methodid   = _cmd;
-   cls        = _mulle_objc_object_get_non_tps_isa( self);
-   cachepivot = (struct _mulle_objc_impcachepivot *) &cls->userinfo;
-   icache     = _mulle_objc_impcachepivot_get_impcache_atomic( cachepivot);
-   forward    = _mulle_atomic_pointer_read( &icache->callback.userinfo);
-   if( ! forward)
-   {
-      forward  = mulle_objc_class_search_method_nofail( cls, @selector( forward:));
-      _mulle_atomic_pointer_write( &icache->callback.userinfo, forward);
-   }
-
-   imp  = _mulle_objc_method_get_implementation( forward);
-   lock = self->__lock; // can be NULL
-
-   // it's vital, that we increment and decrement the identical lock
-   // for performance reasons, we don't retain it (users responsibility
-   // not to torch it)
-   if( lock)
-      _MulleObjCRecursiveLockLock( lock);
-
-#ifdef NDEBUG
-   rval = mulle_objc_implementation_invoke( imp, self, methodid, parameter);
-#else
-   @try
-   {
-      rval = mulle_objc_implementation_invoke( imp, self, methodid, parameter);
-   }
-   @catch( id exception)
-   {
-      struct _mulle_objc_universe   *universe;
-
-      universe = _mulle_objc_object_get_universe( self);
-      __mulle_objc_universe_raise_internalinconsistency( universe,
-                               "An exception %@ is passing thru a -[%@ %s] "
-                               "method call, which will lead to a deadlock",
-                               exception,
-                               MulleObjCObjectGetClass( self),
-                               mulle_objc_universe_lookup_methodname( universe, methodid));
-   }
-#endif
-   if( lock)
-      _MulleObjCRecursiveLockUnlock( lock);
-
-   return( rval);
+   return( MulleObjectLockingSuperForward( self, _cmd, parameter));
 }
 
 
-
 + (instancetype) locklessObject
 {
    id   obj;
diff --git a/src/class/MulleProxy.h b/src/class/MulleProxy.h
new file mode 100644
index 00000000..394d2a82
--- /dev/null
+++ b/src/class/MulleProxy.h
@@ -0,0 +1,78 @@
+//
+//  MulleProxy.m
+//  MulleObjC
+//
+//  Copyright (c) 2024 Nat! - Mulle kybernetiK.
+//  All rights reserved.
+//
+//
+//  Redistribution and use in source and binary forms, with or without
+//  modification, are permitted provided that the following conditions are met:
+//
+//  Redistributions of source code must retain the above copyright notice, this
+//  list of conditions and the following disclaimer.
+//
+//  Redistributions in binary form must reproduce the above copyright notice,
+//  this list of conditions and the following disclaimer in the documentation
+//  and/or other materials provided with the distribution.
+//
+//  Neither the name of Mulle kybernetiK nor the names of its contributors
+//  may be used to endorse or promote products derived from this software
+//  without specific prior written permission.
+//
+//  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+//  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+//  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+//  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+//  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+//  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+//  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+//  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+//  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+//  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+//  POSSIBILITY OF SUCH DAMAGE.
+//
+#ifdef __has_include
+# if __has_include( "NSProxy.h")
+#  import "NSProxy.h"
+# endif
+#endif
+
+#import "import.h"
+
+@class NSRecursiveLock;
+@class MulleObject;
+
+
+// another experiment
+@interface MulleProxy : NSProxy
+{
+   NSRecursiveLock   *__lock;        // use __ to "hide" it (keep here to stay compatible with MulleObject)
+
+   id                __target;
+   IMP               __gain_imp;
+   IMP               __relinquish_imp;
+   NSUInteger        __taoStrategy;
+}
+
+//
+// the idea here is to create a locking front for a target
+//
++ (instancetype) proxyWithObject:(id) target;
+- (instancetype) initWithObject:(id) target;
+
++ (instancetype) locklessProxyWithObject:(id) target;
+- (instancetype) initNoLockWithObject:(id) target;
+
+
+- (BOOL) tryLock                                            MULLE_OBJC_THREADSAFE_METHOD;
+
+
+- (void) didShareRecursiveLock:(NSRecursiveLock *) lock     MULLE_OBJC_THREADSAFE_METHOD;
+- (void) shareRecursiveLock:(NSRecursiveLock *) other       MULLE_OBJC_THREADSAFE_METHOD;
+
+// this is a little fake
+- (void) shareRecursiveLockWithObject:(MulleObject *) other MULLE_OBJC_THREADSAFE_METHOD;
+- (void) shareRecursiveLockWithProxy:(MulleProxy *) other   MULLE_OBJC_THREADSAFE_METHOD;
+
+@end
diff --git a/src/class/MulleProxy.m b/src/class/MulleProxy.m
new file mode 100644
index 00000000..f89612da
--- /dev/null
+++ b/src/class/MulleProxy.m
@@ -0,0 +1,363 @@
+//
+//  MulleProxy.m
+//  MulleObjC
+//
+//  Copyright (c) 2024 Nat! - Mulle kybernetiK.
+//  All rights reserved.
+//
+//
+//  Redistribution and use in source and binary forms, with or without
+//  modification, are permitted provided that the following conditions are met:
+//
+//  Redistributions of source code must retain the above copyright notice, this
+//  list of conditions and the following disclaimer.
+//
+//  Redistributions in binary form must reproduce the above copyright notice,
+//  this list of conditions and the following disclaimer in the documentation
+//  and/or other materials provided with the distribution.
+//
+//  Neither the name of Mulle kybernetiK nor the names of its contributors
+//  may be used to endorse or promote products derived from this software
+//  without specific prior written permission.
+//
+//  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+//  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+//  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+//  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+//  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+//  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+//  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+//  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+//  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+//  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+//  POSSIBILITY OF SUCH DAMAGE.
+//
+#import "MulleProxy.h"
+
+#import "import-private.h"
+
+#import "MulleObjCExceptionHandler.h"
+#import "NSLock.h"
+#import "NSRecursiveLock.h"
+#import "MulleObject.h"
+
+#import "MulleObjCExceptionHandler-Private.h"
+#import "NSLock-Private.h"
+#import "NSRecursiveLock-Private.h"
+
+
+
+@implementation MulleProxy
+
+
++ (instancetype) proxyWithObject:(id) target
+{
+   MulleProxy   *obj;
+
+   obj = [self alloc];
+   obj = [obj initWithObject:target];
+   obj = [obj autorelease];
+   return( obj);
+}
+
+
++ (instancetype) locklessProxyWithObject:(id) target
+{
+   MulleProxy   *obj;
+
+   obj = [self alloc];
+   obj = [obj initNoLockWithObject:target];
+   obj = [obj autorelease];
+   return( obj);
+}
+
+
+static void   initWithTarget( MulleProxy *self, id target)
+{
+   self->__target         = [target retain];
+   self->__taoStrategy    = [target mulleTAOStrategy];
+
+   //
+   // we don't do autoreleasepool manipulations
+   //
+   if( self->__taoStrategy < MulleObjCTAOReceiverPerformsFinalize)
+      self->__taoStrategy = MulleObjCTAOReceiverPerformsFinalize;
+
+   self->__gain_imp       = [target methodForSelector:@selector( mulleGainAccessWithTAOStrategy:)];
+   self->__relinquish_imp = [target methodForSelector:@selector( mulleRelinquishAccessWithTAOStrategy:)];
+}
+
+
+- (instancetype) initNoLockWithObject:(id) target
+{
+   initWithTarget( self, target);
+   return( self);
+}
+
+
+- (instancetype) initWithObject:(id) target
+{
+   initWithTarget( self, target);
+   __lock = [NSRecursiveLock new];
+   return( self);
+}
+
+
+- (void) dealloc
+{
+   [__target release];
+   [__lock release];
+   [super dealloc];
+}
+
+
++ (instancetype) locklessObject
+{
+   abort();
+   return( nil);
+}
+
+
++ (instancetype) object
+{
+   abort();
+   return( nil);
+}
+
+
+- (void *) forward:(void *) parameter
+{
+   NSRecursiveLock               *lock;
+   void                          *rval;
+   mulle_objc_methodid_t         methodid;
+
+   methodid = (mulle_objc_methodid_t) _cmd;
+
+   // it's vital, that we increment and decrement the identical lock
+   // for performance reasons, we don't retain it (users responsibility
+   // not to torch it)
+   lock = self->__lock; // can be NULL
+   if( lock)
+   {
+      _MulleObjCRecursiveLockLock( lock);
+      mulle_objc_implementation_invoke( (mulle_objc_implementation_t) self->__gain_imp,
+                                        self->__target,
+                                        @selector( mulleGainAccessWithTAOStrategy:),
+                                        (void *) self->__taoStrategy);
+   }
+
+#ifdef NDEBUG
+   rval = mulle_objc_object_call_inline_full_variable( self->__target, methodid, parameter);
+#else
+   @try
+   {
+      rval = mulle_objc_object_call_inline_full_variable( self->__target, methodid, parameter);
+   }
+   @catch( id exception)
+   {
+      struct _mulle_objc_universe   *universe;
+
+      universe = _mulle_objc_object_get_universe( self);
+      __mulle_objc_universe_raise_internalinconsistency( universe,
+                               "An exception %@ is passing thru a -[%@ %s] "
+                               "method call, which will lead to a deadlock",
+                               exception,
+                               MulleObjCObjectGetClass( self),
+                               mulle_objc_universe_lookup_methodname( universe, methodid));
+   }
+#endif
+
+   if( lock)
+   {
+      mulle_objc_implementation_invoke( (mulle_objc_implementation_t) self->__relinquish_imp,
+                                        self->__target,
+                                        @selector( mulleRelinquishAccessWithTAOStrategy:),
+                                        (void *) self->__taoStrategy);
+      _MulleObjCRecursiveLockUnlock( lock);
+   }
+
+   return( rval);
+}
+
+
+#pragma mark - NSLocking
+
+
+- (void) lock
+{
+   if( self->__lock)
+      _MulleObjCRecursiveLockLock( self->__lock);
+}
+
+
+- (void) unlock
+{
+   if( self->__lock)
+      _MulleObjCRecursiveLockUnlock( self->__lock);
+}
+
+
+- (BOOL) tryLock
+{
+   if( ! self->__lock)
+      return( NO);
+   return( _MulleObjCRecursiveLockTryLock( self->__lock));
+}
+
+#pragma mark - Lock sharing (could make this a protocolclass or ?)
+
+- (void) didShareRecursiveLock:(NSRecursiveLock *) lock
+{
+   //
+   // if we have no lock (any more), change affinity to current thread
+   // otherwise we iz now threadsafe
+   //
+   _mulle_objc_object_set_thread( (struct _mulle_objc_object *) self, lock
+                                        ? mulle_objc_object_is_threadsafe
+                                        : mulle_thread_self());
+}
+
+
+- (void) shareRecursiveLock:(NSRecursiveLock *) lock
+{
+   NSLockingDo( lock)
+   {
+      if( lock != self->__lock)
+      {
+         [self->__lock autorelease];
+         self->__lock = [lock retain];
+
+         [self didShareRecursiveLock:lock];
+      }
+   }
+}
+
+
+- (void) shareRecursiveLockWithObject:(MulleObject *) other
+{
+   struct { @defs( MulleObject); } *_other = (void *) other;
+
+   [self shareRecursiveLock:other ? _other->__lock : nil];
+}
+
+
+- (void) shareRecursiveLockWithProxy:(MulleProxy *) other
+{
+   [self shareRecursiveLock:other ? other->__lock : nil];
+}
+
+
+#pragma mark - TAO support
+
+//
+// check if an object can be safely accessed by a thread, use this for
+// validatation and debugging only
+- (BOOL) mulleIsThreadSafe          MULLE_OBJC_THREADSAFE_METHOD
+{
+   return( YES);
+}
+
+
+- (BOOL) mulleIsAccessible          MULLE_OBJC_THREADSAFE_METHOD
+{
+   return( YES);
+}
+
+
+- (BOOL) mulleIsAccessibleByThread:(NSThread *) threadObject   MULLE_OBJC_THREADSAFE_METHOD
+{
+   return( YES);
+}
+
+
+- (MulleObjCTAOStrategy) mulleTAOStrategy  MULLE_OBJC_THREADSAFE_METHOD
+{
+   return( MulleObjCTAOKnownThreadSafe);
+}
+
+
+- (void) mulleRelinquishAccess      MULLE_OBJC_THREADSAFE_METHOD
+{
+   [self retain];
+}
+
+
+- (void) mulleGainAccess      MULLE_OBJC_THREADSAFE_METHOD
+{
+   [self autorelease];
+}
+
+
+- (void) mulleGainAccessWithTAOStrategy:(MulleObjCTAOStrategy) strategy MULLE_OBJC_THREADSAFE_METHOD
+{
+   assert( strategy == MulleObjCTAOKnownThreadSafe);
+   [self autorelease];
+}
+
+
+- (void) mulleRelinquishAccessWithTAOStrategy:(MulleObjCTAOStrategy) strategy MULLE_OBJC_THREADSAFE_METHOD
+{
+   assert( strategy == MulleObjCTAOKnownThreadSafe);
+   [self retain];
+}
+
+
+#pragma mark - class introspection
+
+- (Class) class                                MULLE_OBJC_THREADSAFE_METHOD
+{
+   return( [__target class]);
+}
+
+
+- (Class) superclass                           MULLE_OBJC_THREADSAFE_METHOD;
+{
+   return( [__target superclass]);
+}
+
+
+- (BOOL) isKindOfClass:(Class) otherClass      MULLE_OBJC_THREADSAFE_METHOD;
+{
+   return( [__target isKindOfClass:otherClass]);
+}
+
+
+- (BOOL) isMemberOfClass:(Class) otherClass    MULLE_OBJC_THREADSAFE_METHOD;
+{
+   return( [__target isMemberOfClass:otherClass]);
+}
+
+
+#pragma mark - protocol introspection
+
+// mulleContainsProtocol checks only current class, not superclasses
+- (BOOL) mulleContainsProtocol:(PROTOCOL) protocol  MULLE_OBJC_THREADSAFE_METHOD
+{
+   return( [__target mulleContainsProtocol:protocol]);
+}
+
+
+- (BOOL) conformsToProtocol:(PROTOCOL) protocol     MULLE_OBJC_THREADSAFE_METHOD;
+{
+   return( [__target conformsToProtocol:protocol]);
+}
+
+
+#pragma mark - method introspection and calls
+
+- (IMP) methodForSelector:(SEL) sel                  MULLE_OBJC_THREADSAFE_METHOD
+{
+   return( [__target methodForSelector:sel]);
+}
+
+- (BOOL) respondsToSelector:(SEL) sel                MULLE_OBJC_THREADSAFE_METHOD
+{
+   return( [__target respondsToSelector:sel]);
+}
+
+- (NSMethodSignature *) methodSignatureForSelector:(SEL) sel    MULLE_OBJC_THREADSAFE_METHOD
+{
+   return( [__target methodSignatureForSelector:sel]);
+}
+
+@end
diff --git a/src/class/NSAutoreleasePool.h b/src/class/NSAutoreleasePool.h
index 0ed74302..f5041e15 100644
--- a/src/class/NSAutoreleasePool.h
+++ b/src/class/NSAutoreleasePool.h
@@ -49,7 +49,9 @@
 // This is not a subclass of NSObject, because it really is different
 //
 // A NSAutoreleasePool is not even a MulleObjCRuntimeObject, you can't do
-// much with it
+// much with it. As a consequence of it being a root object, instance methods
+// like -init or -mulleNameUTF8String will wrap around, so be careful.
+//
 @interface NSAutoreleasePool
 {
    NSAutoreleasePool   *_owner;
@@ -60,6 +62,7 @@
 // MEMO: this is marked as threadsafe, but that's because its assumed
 //       you set it only during initialization. Its sort of a blemish
 //       (compare with NSThread: -mulleNameUTF8String)
+//       returns address of pool if uninitialized
 @property( dynamic, assign) char  *mulleNameUTF8String   MULLE_OBJC_THREADSAFE_PROPERTY;
 
 + (id) alloc;
@@ -211,3 +214,56 @@ static inline id   NSAutoreleaseObject( id obj)
       _MulleObjCAutoreleaseObject( obj);
    return( obj);
 }
+
+
+
+//
+// Use this in the debugger in a breakpoint, then all threads are stopped
+// and the output should be meaningful. You get a CSV file, which you can
+// then import into sqlite and then post-process, like this for example:
+//
+// .mode csv
+// .import 'pooldump.stdout' data
+// .headers on
+//
+// CREATE TABLE NSThread AS
+// SELECT DISTINCT thread_id, thread AS thread_name
+// FROM data;
+//
+// CREATE TABLE NSAutoreleasePool AS
+// SELECT DISTINCT pool_id, pool AS pool_name, thread_id
+// FROM data;
+//
+// CREATE TABLE pool_objects AS
+// SELECT DISTINCT pool_id, thread_id, object_id
+// FROM data;
+//
+// CREATE TABLE objects AS
+// SELECT
+//     object_id,
+//     object AS object_name,
+//     class AS class_name,
+//     rc AS retain_count,
+//     (SELECT COUNT(*) FROM data AS d WHERE d.object_id = data.object_id) AS pool_count
+// FROM
+//     data
+// GROUP BY
+//     object_id, object, class, rc;
+//
+// Remember that objects that are "roots", which are also autoreleased
+// somewhere will have diverging pool_count and retain_count.
+//
+// Next escalation would be to have SQL on our objects live...
+//
+
+MULLE_OBJC_GLOBAL
+void   MulleObjCDumpAutoreleasePoolsToFile( char *filename);
+
+MULLE_OBJC_GLOBAL
+void   MulleObjCDumpAutoreleasePoolsToFileIndexed( char *filename);
+
+MULLE_OBJC_GLOBAL
+void   MulleObjCDumpAutoreleasePoolsToFILEWithOptions( FILE *fp, int indexed);
+
+MULLE_OBJC_GLOBAL
+unsigned long   MulleObjCDumpAutoreleasePoolsFrame( void);
diff --git a/src/class/NSAutoreleasePool.m b/src/class/NSAutoreleasePool.m
index bed59ee9..3f55f239 100644
--- a/src/class/NSAutoreleasePool.m
+++ b/src/class/NSAutoreleasePool.m
@@ -43,14 +43,24 @@
 #import "MulleObjCAutoreleasePool.h"
 #import "MulleObjCExceptionHandler.h"
 #import "MulleObjCExceptionHandler-Private.h"
+#import "MulleObjCFunctions.h"
 #import "NSDebug.h"
+#import "NSThread.h"
 #import "NSZone.h"
 #import "mulle-objc-autoreleasepointerarray-private.h"
+#import "mulle-objc-universefoundationinfo-private.h"
 
 // other libraries of MulleObjCFoundation
 
 // std-c and dependencies
 
+@interface NSThread( Private)
+
+// hidden for debug only
+- (void *) _poolconfiguration;
+
+@end
+
 
 #ifdef DEBUG
 # define DEBUG_MAX_OBJECTS
@@ -193,11 +203,16 @@ static void   _mulle_objc_thread_set_poolconfiguration( struct _mulle_objc_unive
 }
 
 
-void   mulle_objc_thread_new_poolconfiguration( struct _mulle_objc_universe *universe)
+struct _mulle_objc_poolconfiguration  *mulle_objc_thread_new_poolconfiguration( struct _mulle_objc_universe *universe)
 {
-   if( universe)
-      _mulle_objc_thread_set_poolconfiguration( universe,
-                                                mulle_objc_thread_get_poolconfiguration( universe));
+   struct _mulle_objc_poolconfiguration   *config;
+
+   if( ! universe)
+      return( NULL);
+
+   config = mulle_objc_thread_get_poolconfiguration( universe);
+   _mulle_objc_thread_set_poolconfiguration( universe, config);
+   return( config);
 }
 
 
@@ -225,7 +240,9 @@ void   mulle_objc_thread_done_poolconfiguration( struct _mulle_objc_universe *un
 
 - (char *) mulleNameUTF8String
 {
-   return( _mulleNameUTF8String[ 0] ? &_mulleNameUTF8String[ 0] : "unnamed");
+   if( ! _mulleNameUTF8String[ 0])
+      mulle_snprintf( _mulleNameUTF8String, sizeof( _mulleNameUTF8String), "%p", self);
+   return( &_mulleNameUTF8String[ 0]);
 }
 
 
@@ -235,6 +252,20 @@ - (void) mulleSetNameUTF8String:(char *) s
 }
 
 
+// boobytrappe accidental wrap-around calls for debugging
+#ifdef DEBUG
++ (char *) mulleNameUTF8String
+{
+   abort();
+}
+
+
++ (void) mulleSetNameUTF8String:(char *) s
+{
+   abort();
+}
+#endif
+
 //
 // Apparently not used anymore
 //
@@ -284,15 +315,21 @@ static inline void   addObject( struct _mulle_objc_poolconfiguration *config, id
    pool = config->tail;
 
 #ifndef NDEBUG
-   struct _mulle_objc_universe *universe;
-
-   assert( pool != nil);
-   assert( p != nil);
-   universe = _mulle_objc_object_get_universe( p);
-   assert( _mulle_objc_object_get_isa( p));
-   assert( _mulle_objc_class_get_universe( _mulle_objc_object_get_isa( p)) ==
-           _mulle_objc_infraclass_get_universe( _mulle_objc_thread_get_autoreleasepoolclass( universe))) ;
-   assert( _mulle_objc_object_get_infraclass( p) != _mulle_objc_thread_get_autoreleasepoolclass( universe));
+   struct _mulle_objc_universe   *object_universe;
+   struct _mulle_objc_universe   *pool_universe;
+
+   assert( pool != nil);      // empty pool ? something has been clobbered
+   assert( p != nil);         // shouls have been caught earlier
+
+   assert( _mulle_objc_object_get_isa( p));  // not really an object is it ?
+
+   // object and pool must be of the same universe
+   object_universe = _mulle_objc_object_get_universe( p);
+   pool_universe   = _mulle_objc_infraclass_get_universe( config->poolClass);
+   assert( object_universe == pool_universe);
+
+   // can't autorelease an autoreleasepool
+   assert( _mulle_objc_object_get_infraclass( p) != config->poolClass);
 // this messages ObjC too much, which gets boring in traces
 //   assert( [p isProxy] || [p respondsToSelector:@selector( release)]);
 #endif
@@ -602,14 +639,14 @@ static inline void   autoreleaseObjects( id *objects,
 
 
 - (void) mulleAddObjects:(id *) objects
-               count:(NSUInteger) count
+                   count:(NSUInteger) count
 {
    autoreleaseObjects( objects, count, _mulle_objc_object_get_universe( self));
 }
 
 
 + (void) mulleAddObjects:(id *) objects
-               count:(NSUInteger) count
+                   count:(NSUInteger) count
 {
    autoreleaseObjects( objects, count, _mulle_objc_object_get_universe( self));
 }
@@ -781,7 +818,7 @@ static inline void   releaseObjects( NSAutoreleasePool *self,
 
 
 - (void) mulleReleasePoolObjects:(id *) p
-                       count:(NSUInteger) count
+                           count:(NSUInteger) count
 {
    struct _mulle_objc_poolconfiguration   *config;
    struct _mulle_objc_universe            *universe;
@@ -793,7 +830,7 @@ - (void) mulleReleasePoolObjects:(id *) p
 
 
 + (void) mulleReleasePoolObjects:(id *) p
-                       count:(NSUInteger) count
+                           count:(NSUInteger) count
 {
    NSAutoreleasePool                      *pool;
    struct _mulle_objc_poolconfiguration   *config;
@@ -852,9 +889,7 @@ static void   releaseAllObjectsInPool( struct _mulle_objc_poolconfiguration *con
       {
          fprintf( stderr, "[pool] %p releases objects of storage %p\n", pool, storage);
 
-         _mulle_autoreleasepointerarray_dump_objects( storage,
-                                                      "releases",
-                                                      static_storage( config, pool));
+         _mulle_autoreleasepointerarray_dump_objects( storage, "releases");
       }
       _mulle_autoreleasepointerarray_release_and_free( storage,
                                                        static_storage( config, pool),
@@ -1007,6 +1042,284 @@ - (void) dealloc
 }
 
 
+struct dump_info
+{
+   struct _mulle_objc_universefoundationinfo    *info;
+
+   FILE                       *fp;
+   mulle_objc_walkcommand_t   (*dumper)( id obj, void *userinfo);
+
+   void                       *thread_adr;
+   void                       *pool_adr;
+
+   int                        thread_index;
+   int                        pool_index;
+
+   char                       *thread_name;
+   char                       *pool_name;
+   int                        options;
+
+   struct mulle__pointermap   object_index_map;
+   struct mulle__pointermap   thread_index_map;
+};
+
+
+static void   dump_object( id obj, struct dump_info *info)
+{
+   uintptr_t        rc;
+   char             *name;
+   mulle_thread_t   osThread;
+   NSThread         *thread;
+   NSUInteger       thread_index;
+
+   if( [obj respondsToSelector:@selector( mulleNameUTF8String)])
+   {
+      name = [obj mulleNameUTF8String];
+      mulle_fprintf( info->fp, "\"%s\"", name);
+   }
+   else
+      mulle_fprintf( info->fp, "\"%p\"", obj);
+
+   mulle_fprintf( info->fp, ",\"%s\"", MulleObjCObjectGetClassNameUTF8String( obj));
+   rc = _mulle_objc_object_get_retaincount_notps_noslow( obj);
+   if( rc == MULLE_OBJC_NEVER_RELEASE)
+      mulle_fprintf( info->fp, ",constant");
+   else
+      mulle_fprintf( info->fp, ",%td", rc);
+
+   if( info->options & 0x2)
+   {
+      osThread = _mulle_objc_object_get_thread( (struct _mulle_objc_object *) obj);
+      if( osThread == mulle_objc_object_is_threadsafe)
+         mulle_fprintf( info->fp, ",NULL,\"threadsafe\"");
+      else
+         if( osThread == mulle_objc_object_has_no_thread)
+            mulle_fprintf( info->fp, ",-1,\"unowned\"");
+         else
+         {
+            thread = mulle_map_get( info->info->object.threads, (void *) osThread);
+            name   = [thread mulleNameUTF8String];
+            if( info->options & 0x1)
+            {
+               thread_index = (NSUInteger) _mulle__pointermap_get( &info->thread_index_map, thread);
+               mulle_fprintf( info->fp, ",%td,\"%s\"", thread_index, name);
+            }
+            else
+            {
+               mulle_fprintf( info->fp, ",%td,\"%s\"", (intptr_t) thread, name);
+            }
+         }
+   }
+
+   mulle_fprintf( info->fp, "\n");
+}
+
+
+static mulle_objc_walkcommand_t   dump_object_indexed( id obj, void *userinfo)
+{
+   struct dump_info   *info = userinfo;
+   intptr_t           object_index;
+
+   object_index = mulle__pointermap_get_count( &info->object_index_map);
+   object_index = (intptr_t) mulle__pointermap_register( &info->object_index_map,
+                                                         obj,
+                                                         (void *) object_index,
+                                                         NULL);
+   mulle_fprintf( info->fp, "%d,\"%s\",%d,\"%s\",%td,",
+                            info->thread_index,
+                            info->thread_name,
+                            info->pool_index,
+                            info->pool_name,
+                            object_index);
+
+   dump_object( obj, info);
+
+   return( mulle_objc_walk_ok);
+}
+
+
+static mulle_objc_walkcommand_t   dump_object_addressed( id obj, void *userinfo)
+{
+   struct dump_info   *info = userinfo;
+
+   mulle_fprintf( info->fp, "%td,\"%s\",%td,\"%s\",%td,",
+                            (intptr_t) info->thread_adr,
+                            info->thread_name,
+                            (intptr_t) info->pool_adr,
+                            info->pool_name,
+                            (intptr_t) obj);
+
+   dump_object( obj, info);
+
+   return( mulle_objc_walk_ok);
+}
+
+
+static inline void   _dump_info_init( struct dump_info *p,
+                                      FILE *fp,
+                                      struct _mulle_objc_universefoundationinfo *info,
+                                      int options)
+{
+   NSThread         *thread;
+   NSUInteger       thread_index;
+   mulle_thread_t   osThread;
+
+   memset( p, 0, sizeof( *p));
+
+   p->fp      = fp;
+   p->info    = info;
+   p->dumper  = (options & 0x1) ? dump_object_indexed : dump_object_addressed;
+   p->options = options;
+
+   _mulle__pointermap_init( &p->object_index_map, 1024, NULL);
+   _mulle__pointermap_init( &p->thread_index_map, 8, NULL);
+
+   mulle__pointermap_set( &p->thread_index_map, info->thread.mainthread, (void *) 0, NULL);
+
+   thread_index = 1;
+   mulle_map_for( info->object.threads, osThread, thread)
+   {
+      if( thread != info->thread.mainthread)
+      {
+         mulle__pointermap_set( &p->thread_index_map, thread, (void *) (intptr_t) thread_index, NULL);
+         ++thread_index;
+      }
+   }
+}
+
+
+static inline void   _dump_info_done( struct dump_info *p)
+{
+   _mulle__pointermap_done( &p->thread_index_map, NULL);
+   _mulle__pointermap_done( &p->object_index_map, NULL);
+}
+
+
+static void   _dumpinfo_dump_thread( struct dump_info *info,
+                                     NSThread *thread,
+                                     NSUInteger index,
+                                     FILE *fp)
+{
+   NSAutoreleasePool                      *pool;
+   struct _mulle_objc_poolconfiguration   *config;
+
+   info->thread_adr   = thread;
+   info->thread_name  = [thread mulleNameUTF8String];
+   info->thread_index = (int) index;
+   info->pool_index   = 0;
+
+   config = [thread _poolconfiguration];
+   for( pool = config->tail; pool; pool = pool->_owner)
+      info->pool_index++;
+
+   for( pool = config->tail; pool; pool = pool->_owner)
+   {
+      info->pool_name = [pool mulleNameUTF8String];
+      info->pool_adr  = pool;
+
+      --info->pool_index;
+      _mulle_autoreleasepointerarray_walk_objects( pool->_storage, info->dumper, info);
+   }
+}
+
+
+static void
+   _mulle_objc_universefoundationinfo_dump_autoreleasepools( struct _mulle_objc_universefoundationinfo *info,
+                                                             FILE *fp,
+                                                             int indexed)
+{
+   NSThread           *thread;
+   void               *osThread;
+   NSUInteger         thread_index;
+   struct dump_info   dump_info;
+
+   _dump_info_init( &dump_info, fp, info, indexed);
+
+   thread = info->thread.mainthread;
+   _dumpinfo_dump_thread( &dump_info, thread, 0, fp);
+
+   mulle_map_for( info->object.threads, osThread, thread)
+   {
+      thread_index = (NSUInteger) _mulle__pointermap_get( &dump_info.thread_index_map, thread);
+      if( thread_index)
+      {
+         _dumpinfo_dump_thread( &dump_info, thread, thread_index, fp);
+      }
+   }
+
+   _dump_info_done( &dump_info);
+}
+
+
+void   MulleObjCDumpAutoreleasePoolsToFILEWithOptions( FILE *fp, int options)
+{
+   struct _mulle_objc_universe                 *universe;
+   struct _mulle_objc_universefoundationinfo   *info;
+
+   if( ! fp)
+      fp = stdout;
+
+   universe = MulleObjCGetUniverse();
+   if( universe)
+   {
+      mulle_fprintf( fp, "thread_id,thread,pool_id,pool,object_id,object,class,rc");
+      if( options & 0x2)
+         mulle_fprintf( fp, ",owner_id,owner");
+      mulle_fprintf( fp, "\n");
+
+      _mulle_objc_universe_lock( universe);
+      {
+         info = _mulle_objc_universe_get_foundationdata( universe);
+         _mulle_objc_universefoundationinfo_dump_autoreleasepools( info, fp, options);
+      }
+      _mulle_objc_universe_unlock( universe);
+   }
+}
+
+
+void  MulleObjCDumpAutoreleasePoolsToFileIndexed( char *filename)
+{
+   FILE   *fp;
+
+   fp = fopen( filename, "w");
+   if( ! fp)
+   {
+      perror( "fopen:");
+      return;
+   }
+   MulleObjCDumpAutoreleasePoolsToFILEWithOptions( fp, 0x3);
+   fclose( fp);
+}
+
+
+void  MulleObjCDumpAutoreleasePoolsToFile( char *filename)
+{
+   FILE   *fp;
+
+   fp = fopen( filename, "w");
+   if( ! fp)
+   {
+      perror( "fopen:");
+      return;
+   }
+   MulleObjCDumpAutoreleasePoolsToFILEWithOptions( fp, 0x2);
+   fclose( fp);
+}
+
+
+unsigned long   MulleObjCDumpAutoreleasePoolsFrame( void)
+{
+   static mulle_atomic_pointer_t   counter;
+   auto char                       buf[ 19 + 32 + 4 + 1];
+   unsigned long                   nr;
+
+   nr = (unsigned long) (uintptr_t) _mulle_atomic_pointer_increment( &counter);
+   mulle_snprintf( buf, sizeof( buf), "NSAutoreleasePools_%06d.csv", nr);
+   MulleObjCDumpAutoreleasePoolsToFile( buf);
+
+   return( nr);
+}
+
 @end
 
 
@@ -1056,6 +1369,12 @@ static void   dealloc( _MulleObjCAutoreleaseAllocation *self)
 }
 
 
+- (Class) class
+{
+   return( MulleObjCInstanceGetClass( self));
+}
+
+
 - (void) dealloc
 {
    dealloc( self);
@@ -1067,6 +1386,7 @@ - (void) finalize
 {
 }
 
+
 // we are just in an autoreleasepool and don't retaincount
 - (void) release
 {
@@ -1088,7 +1408,6 @@ - (BOOL) respondsToSelector:(SEL) sel
 @end
 
 
-
 void   *MulleObjCAutoreleaseAllocation( void *pointer, struct mulle_allocator *allocator)
 {
 	_MulleObjCAutoreleaseAllocation   *allocation;
diff --git a/src/class/NSInvocation.m b/src/class/NSInvocation.m
index 0873843f..923dfbae 100644
--- a/src/class/NSInvocation.m
+++ b/src/class/NSInvocation.m
@@ -43,6 +43,7 @@
 #import "MulleObjCException.h"
 #import "MulleObjCExceptionHandler.h"
 #import "MulleObjCExceptionHandler-Private.h"
+#import "MulleObjCFunctions.h"
 
 #pragma clang diagnostic ignored "-Wobjc-missing-super-calls"
 
@@ -152,14 +153,13 @@ static inline void   pointerAndSizeOfArgumentValue( NSInvocation *self,
    size_t                             size;
 
    if( ! self->_methodSignature)
-      __mulle_objc_universe_raise_internalinconsistency( _mulle_objc_object_get_universe( self),
-                                                         "methodSignature not found on target");
+      MulleObjCThrowInternalInconsistencyExceptionUTF8String( "methodSignature not found on target");
    p    = [self->_methodSignature mulleSignatureTypeInfoAtIndex:i];
    adr  = &((char *) self->_storage)[ p->invocation_offset];
    size = p->natural_size;
 
    if( ! is_valid_frame_range( self, adr, size))
-      __mulle_objc_universe_raise_invalidindex( NULL, i);
+      MulleObjCThrowInvalidIndexException( i);
 
    *p_adr  = adr;
    *p_size = size;
@@ -270,14 +270,11 @@ + (NSInvocation *) mulleInvocationWithTarget:(id) target
 
    signature = [target methodSignatureForSelector:sel];
    if( ! signature)
-      __mulle_objc_universe_raise_internalinconsistency( _mulle_objc_object_get_universe( self),
-                                                         "method not found on target");
+      MulleObjCThrowInternalInconsistencyExceptionUTF8String( "method not found on target");
    if( [signature numberOfArguments] != 3)
-      __mulle_objc_universe_raise_internalinconsistency( _mulle_objc_object_get_universe( self),
-                                                         "method must accept one argument");
+      MulleObjCThrowInternalInconsistencyExceptionUTF8String( "method must accept one argument");
    if( [signature isVariadic])
-      __mulle_objc_universe_raise_internalinconsistency( _mulle_objc_object_get_universe( self),
-                                                         "method must not be variadic");
+      MulleObjCThrowInternalInconsistencyExceptionUTF8String( "method must not be variadic");
 
    invocation = [self invocationWithMethodSignature:signature];
    [invocation setTarget:target];
@@ -302,11 +299,9 @@ + (NSInvocation *) mulleInvocationWithTarget:(id) target
 #endif
    signature = [target methodSignatureForSelector:sel];
    if( ! signature)
-      __mulle_objc_universe_raise_internalinconsistency( _mulle_objc_object_get_universe( self),
-                                                         "method %x not found on target", sel);
+      MulleObjCThrowInternalInconsistencyExceptionUTF8String( "method %x not found on target", sel);
    if( [signature isVariadic])
-      __mulle_objc_universe_raise_internalinconsistency( _mulle_objc_object_get_universe( self),
-                                                         "method must not be variadic");
+      MulleObjCThrowInternalInconsistencyExceptionUTF8String( "method must not be variadic");
 
    invocation = [self invocationWithMethodSignature:signature];
    [invocation setTarget:target];
@@ -595,8 +590,7 @@ - (void) retainArguments
       return;
 
    if( [_methodSignature isVariadic])
-      __mulle_objc_universe_raise_internalinconsistency( _mulle_objc_object_get_universe( self),
-                                                        "NSInvocation can not \
+      MulleObjCThrowInternalInconsistencyExceptionUTF8String( "NSInvocation can not \
 retain the arguments of variadic methods");
 
    _argumentsRetained = YES;
@@ -783,11 +777,9 @@ - (void) invokeWithTarget:(id) target
 
    sel = [self selector];
    if( ! sel)
-      __mulle_objc_universe_raise_internalinconsistency( _mulle_objc_object_get_universe( self),
-                                                         "NSInvocation: selector has not been set yet");
+      MulleObjCThrowInternalInconsistencyExceptionUTF8String( "NSInvocation: selector has not been set yet");
    if( ! _methodSignature)
-      __mulle_objc_universe_raise_internalinconsistency( _mulle_objc_object_get_universe( self),
-                                                         "NSInvocation: methodSignature has not been set yet");
+      MulleObjCThrowInternalInconsistencyExceptionUTF8String( "NSInvocation: methodSignature has not been set yet");
 
    pType = [_methodSignature _methodMetaABIParameterType];
    rType = [_methodSignature _methodMetaABIReturnType];
diff --git a/src/class/NSNull.m b/src/class/NSNull.m
index 44d75557..192fd2ac 100644
--- a/src/class/NSNull.m
+++ b/src/class/NSNull.m
@@ -37,9 +37,11 @@
 
 // other files in this library
 
-// other libraries of MulleObjCValueFoundation
+// other libraries of MulleObjC
 #import "import.h"
 
+#import "MulleObjCFunctions.h"
+
 // std-c and dependencies
 
 
diff --git a/src/class/NSObject.m b/src/class/NSObject.m
index 68a69412..9b6d02eb 100644
--- a/src/class/NSObject.m
+++ b/src/class/NSObject.m
@@ -743,4 +743,16 @@ + (void) mulleInterposeBeforeClass:(Class) subClass
    MulleObjCClassInterposeBeforeClass( self, subClass);
 }
 
+
+
+//
+// as a class method, prevent [Foo autorelease] to end up in the autorelease
+// pool (at least when running -O0)
+//
++ (instancetype) autorelease
+{
+   return( (id) self);
+}
+
+
 @end
diff --git a/src/class/NSProxy.m b/src/class/NSProxy.m
index 584aa079..4c8c714e 100644
--- a/src/class/NSProxy.m
+++ b/src/class/NSProxy.m
@@ -49,7 +49,7 @@
 
 @implementation NSProxy
 
-+ (BOOL) isProxy        MULLE_OBJC_THREADSAFE_METHOD
++ (BOOL) isProxy        MULLE_OBJC_THREADSAFE_METHOD  // sic
 {
    return( NO);
 }
diff --git a/src/class/NSThread.h b/src/class/NSThread.h
index 38407d94..8642abbe 100644
--- a/src/class/NSThread.h
+++ b/src/class/NSThread.h
@@ -44,6 +44,7 @@ struct MulleObjCAutoreleasePoolConfiguration;
 
 
 typedef int   MulleThreadFunction_t( NSThread *, void *);
+typedef int   MulleThreadObjectFunction_t( NSThread *, id);
 
 //
 // A NSThread is a 1:1 relationship to a mulle_thread, if the mulle_thread dies
@@ -51,7 +52,7 @@ typedef int   MulleThreadFunction_t( NSThread *, void *);
 // If you pass non-threadsafe objects to the NSThread via the NSInvocation,
 // these objects will be unusable in the caller thread once the thread is
 // started. You must not access them anymore. This includes the target.
-// The default strategy even removes not-threadsafe objects from the active
+// The default strategy may even remove not-threadsafe objects from the active
 // NSAutoreleasePool of the caller thread.
 //
 @interface NSThread : NSObject < MulleObjCThreadSafe>
@@ -64,19 +65,18 @@ typedef int   MulleThreadFunction_t( NSThread *, void *);
    NSInvocation             *_invocation;
    id                       _userInfo;           // only valid in thread
    MulleThreadFunction_t    *_function;          // unmanaged
-   void                     *_functionArgument;  // unmanaged
+   void                     *_functionArgument;  // unmanaged (unless _isObjectFunctionArgument is 1)
 
+   // autoreleasepool root config (intended for debugging only)
+   void                     *_poolconfiguration;
    struct mulle_map         _map;  // not the -threadDictionary !
    int                      _rval;
 
+   char                     _isObjectFunctionArgument;
    char                     _isDetached;
-   char                     _invocationGainedAccess;
+   char                     _threadDidGainAccess;     // NSThread did gain accesss
 }
 
-// this property can only be set by the caller, before the thread is
-// actually executed
-@property( dynamic, assign) char   *mulleNameUTF8String  MULLE_OBJC_THREADSAFE_PROPERTY;
-
 + (NSThread *) mainThread;
 
 // this oughta crash for a thread that is not a MulleObjC thread, because 
@@ -114,6 +114,9 @@ typedef int   MulleThreadFunction_t( NSThread *, void *);
                               argument:(void *) argument;
 
 
+- (instancetype) mulleInitWithObjectFunction:(MulleThreadObjectFunction_t) f
+                                      object:(id) obj;
+
 // caller is responsible to call -retainArguments on invocation
 - (instancetype) mulleInitWithInvocation:(NSInvocation *) invocation;
 
@@ -150,7 +153,6 @@ typedef int   MulleThreadFunction_t( NSThread *, void *);
 // from the NSThread
 //
 - (NSInvocation *) mulleJoin;    // __attribute__((availability(mulleobjc,introduced=0.2)));
-- (void) mulleDetach;            // __attribute__((availability(mulleobjc,introduced=0.2)));
 
 // This is legacy interface, which runs the thread in a detached state.
 // Prefer mulleStart and then keep the NSThread object around for later.
@@ -172,10 +174,20 @@ typedef int   MulleThreadFunction_t( NSThread *, void *);
 
 - (int) mulleReturnStatus;
 
+
+// this is not any longer a property, because we only want to clear it in
+// -dealloc. At time of writing properties are zeroed in -finalize
+//
+// This "property" can only be set by the caller, before the thread is
+// actually executed, if none is set this will be the address of NSThread
+- (void) mulleSetNameUTF8String:(char *) s   MULLE_OBJC_THREADSAFE_METHOD;
+- (char *) mulleNameUTF8String               MULLE_OBJC_THREADSAFE_METHOD;
+
 #pragma mark - Internal
 
 // don't call these functions yourself
 
+
 MULLE_OBJC_GLOBAL
 NSThread   *_MulleThreadGetCurrentThreadObjectInUniverse( struct _mulle_objc_universe *universe);
 
@@ -293,7 +305,9 @@ static inline mulle_thread_t  MulleThreadGetCurrentOSThread( void)
 
 
 
-typedef void   MulleObjCTAOFailureHandler( void *obj, mulle_thread_t osThread, struct _mulle_objc_descriptor *des) MULLE_C_NO_RETURN;
+typedef void   MulleObjCTAOFailureHandler( void *obj,
+                                           mulle_thread_t osThread,
+                                           struct _mulle_objc_descriptor *des) MULLE_C_NO_RETURN;
 
 // no coming back from this, just print nicely and abort
 #pragma mark - TAO Wrong Thread Failure
diff --git a/src/class/NSThread.m b/src/class/NSThread.m
index 2cde8127..8780a561 100644
--- a/src/class/NSThread.m
+++ b/src/class/NSThread.m
@@ -44,6 +44,7 @@
 #import "MulleObjCException.h"
 #import "MulleObjCExceptionHandler.h"
 #import "MulleObjCExceptionHandler-Private.h"
+#import "MulleObjCFunctions.h"
 #import "NSAutoreleasePool.h"
 #import "NSInvocation.h"
 #import "mulle-objc-exceptionhandlertable-private.h"
@@ -174,10 +175,42 @@ - (instancetype) mulleInitWithFunction:(MulleThreadFunction_t) f
 }
 
 
+- (instancetype) mulleInitWithObjectFunction:(MulleThreadObjectFunction_t) f
+                                      object:(id) obj
+{
+   if( ! f)
+      __mulle_objc_universe_raise_invalidargument( _mulle_objc_object_get_universe( self),
+                                                   "function must not be nil");
+
+   // for subclasses
+   self = [self init];
+
+   self->_function                 = (MulleThreadFunction_t *) f;
+   self->_functionArgument         = [obj retain];
+   self->_isObjectFunctionArgument = 1;
+
+   return( self);
+}
+
+
+//
+// there are two threads that can run -finalize, it's expected that its
+// the "osTread" of the NSThread (i.e. we ran through bouncy bounce, and
+// now are in [NSThread exit] which does a performFinalize). But you can
+// also have a NSThread that was never invoked.
+//
 - (void) finalize
 {
    id   runLoop;
 
+   //
+   // it's an error to call mullePerformFinalize from the main thread. From
+   // the the actual thread, you should use +[NSThread exit];
+   //
+   assert( (! MulleThreadObjectGetOSThread( self)
+           || MulleThreadGetCurrentOSThread() == MulleThreadObjectGetOSThread( self))
+           && "Do not call mullePerformFinalize on NSThread");
+
    runLoop = [self mulleRunLoop];
    _mulle_atomic_pointer_write_nonatomic( &self->_runLoop, nil);
 
@@ -200,8 +233,29 @@ - (void) finalize
    //   context = [context mulleGainAccess];
    //
 
-   if( self->_invocationGainedAccess)
-      [self->_invocation mulleRelinquishAccess];
+   if( self->_isDetached)
+   {
+      [self->_invocation autorelease];
+      self->_invocation = nil;
+
+      if( _isObjectFunctionArgument)
+      {
+         [(id) self->_functionArgument autorelease];
+         self->_functionArgument = NULL;
+      }
+   }
+   else
+      if( self->_threadDidGainAccess)
+      {
+         if( _isObjectFunctionArgument)
+         {
+            [(id) self->_functionArgument mulleRelinquishAccess];
+         }
+         else
+         {
+            [self->_invocation mulleRelinquishAccess];
+         }
+      }
 
    [super finalize];
 }
@@ -212,15 +266,29 @@ - (void) dealloc
    assert( ! [self mulleRunLoop]);
    assert( ! self->_userInfo);
 
-   // need to do this "deeply" to autorelease all we have
-   // the -autorelease is unwanted though or ? would prefer -release
-   // but can't have it. NSAutoreleasepool should immediately release 
-   // during pool cleaning though...
-   if( self->_invocationGainedAccess)
-      [self->_invocation mulleGainAccess]; // or gainAccess again ???
+   //
+   // in the detached case, invocation and functionArgument are
+   // already niled away
+   //
+   if( self->_threadDidGainAccess)
+   {
+      if( _isObjectFunctionArgument)
+         [(id) self->_functionArgument mulleGainAccess];
+      else
+         [self->_invocation mulleGainAccess];
+   }
+
    [self->_invocation release];
+   self->_invocation = nil;
 
-   MulleObjCInstanceDeallocateMemory( self, _nameUTF8String);
+   if( _isObjectFunctionArgument)
+   {
+      [(id) self->_functionArgument release];
+      self->_functionArgument = NULL;
+   }
+
+   // need to free it like this
+   [self mulleSetNameUTF8String:NULL];
    _MulleObjCInstanceFree( self);
 }
 
@@ -289,20 +357,20 @@ static void   _mulle_objc_thread_become_universethread( struct _mulle_objc_unive
 
 // this is used by mulle_objc_thread_get_threadfoundationinfo to create
 // a new NSThread on demand if needed
-static void   _MulleThreadRegisterInUniverse( NSThread *threadObject,
+static void   _MulleThreadRegisterInUniverse( NSThread *self,
                                               struct _mulle_objc_universe *universe)
 {
-   _mulle_objc_universe_set_threadobject_for_thread( universe, mulle_thread_self(), threadObject); // does not retain
-   _mulle_objc_thread_set_threadobject( universe, threadObject);   // this owns it!
+   _mulle_objc_universe_set_threadobject_for_thread( universe, mulle_thread_self(), self); // does not retain
+   _mulle_objc_thread_set_threadobject( universe, self);   // this owns it!
 }
 
 
-static void   _MulleThreadDeregisterInUniverse( NSThread *threadObject,
+static void   _MulleThreadDeregisterInUniverse( NSThread *self,
                                                 struct _mulle_objc_universe *universe)
 {
-   assert( MulleThreadObjectGetOSThread( threadObject) == mulle_thread_self());
+   assert( MulleThreadObjectGetOSThread( self) == mulle_thread_self());
 
-   _mulle_objc_universe_remove_threadobject_for_thread( universe, mulle_thread_self(), threadObject); // does not retain
+   _mulle_objc_universe_remove_threadobject_for_thread( universe, mulle_thread_self(), self); // does not retain
    _mulle_objc_thread_set_threadobject( universe, NULL);   // this owns it!
 }
 
@@ -312,21 +380,21 @@ static void   _MulleThreadDeregisterInUniverse( NSThread *threadObject,
  */
 NSThread   *_MulleThreadGetCurrentThreadObjectInUniverse( struct _mulle_objc_universe *universe)
 {
-   NSThread                                    *threadObject;
+   NSThread                                    *self;
    struct _mulle_objc_universefoundationinfo   *info;
 
-   info          = _mulle_objc_universe_get_universefoundationinfo( universe);
-   threadObject  = _mulle_objc_universefoundationinfo_get_mainthreadobject( info);
-   return( threadObject);
+   info  = _mulle_objc_universe_get_universefoundationinfo( universe);
+   self  = _mulle_objc_universefoundationinfo_get_mainthreadobject( info);
+   return( self);
 }
 
 
 static NSThread   *__MulleThreadCreateThreadObjectInUniverse( struct _mulle_objc_universe *universe)
 {
-   NSThread   *threadObject;
+   NSThread   *self;
 
-   threadObject = [NSThread new];
-   _mulle_atomic_pointer_write_nonatomic( &threadObject->_osThread, (void *) mulle_thread_self());
+   self = [NSThread new];
+   _mulle_atomic_pointer_write_nonatomic( &self->_osThread, (void *) mulle_thread_self());
 
    //
    // create pool configuration, ahead of register so it can
@@ -334,11 +402,11 @@ static void   _MulleThreadDeregisterInUniverse( NSThread *threadObject,
    //
    [NSAutoreleasePool class];
 //   assert( mulle_objc_universe_lookup_infraclass_nofail( universe, @selector( NSAutoreleasePool)));
-   mulle_objc_thread_new_poolconfiguration( universe);
+   self->_poolconfiguration = mulle_objc_thread_new_poolconfiguration( universe);
 
-   _MulleThreadRegisterInUniverse( threadObject, universe);
+   _MulleThreadRegisterInUniverse( self, universe);
 
-   return( threadObject);
+   return( self);
 }
 
 
@@ -362,6 +430,21 @@ static void   _MulleThreadDeregisterInUniverse( NSThread *threadObject,
 }
 
 
+
+static void   _MulleThreadTakedownPoolAndRelease( NSThread *threadObject,
+                                                  struct _mulle_objc_universe *universe)
+{
+   [threadObject mullePerformFinalize];
+
+   mulle_objc_thread_reset_poolconfiguration( universe);
+
+   _MulleThreadDeregisterInUniverse( threadObject, universe);
+   [threadObject release];
+
+   mulle_objc_thread_done_poolconfiguration( universe);
+}
+
+
 void   _MulleThreadRemoveThreadObjectFromUniverse( NSThread *threadObject,
                                                    struct _mulle_objc_universe *universe)
 {
@@ -372,10 +455,13 @@ void   _MulleThreadRemoveThreadObjectFromUniverse( NSThread *threadObject,
    assert( thread == mulle_thread_self());
    assert( thread != _mulle_objc_universe_get_thread( universe));
 #endif
-   _MulleThreadDeregisterInUniverse( threadObject, universe);
-   [threadObject release];
 
-   mulle_objc_thread_done_poolconfiguration( universe);
+
+   // MEMO: used to be above mulle_objc_thread_done_poolconfigurationm but
+   //       then -dealloc code could not find the current thread
+   //       disadvantage now: no enveloping autorelasepool!
+
+   _MulleThreadTakedownPoolAndRelease( threadObject, universe);
 
    _mulle_objc_thread_resignas_universethread( universe, YES);
 }
@@ -436,11 +522,8 @@ void   _MulleThreadResignAsMainThreadObjectInUniverse( struct _mulle_objc_univer
    assert( MulleThreadObjectGetOSThread( threadObject) == _mulle_objc_universe_get_thread( universe));
    assert( [threadObject retainCount] == 1);
 
-   _MulleThreadDeregisterInUniverse( threadObject, universe);
-   [threadObject release];
-
    // we don't resign as universe thread, just pop the pools
-   mulle_objc_thread_done_poolconfiguration( universe);
+   _MulleThreadTakedownPoolAndRelease( threadObject, universe);
 
    info = _mulle_objc_universe_get_universefoundationinfo( universe);
    _mulle_objc_universefoundationinfo_set_mainthreadobject( info, NULL);
@@ -503,10 +586,7 @@ void   _mulle_objc_threadinfo_destructor( struct _mulle_objc_threadinfo *info,
    threadkey = _mulle_objc_universe_get_threadkey( universe);
    mulle_thread_tss_set( threadkey, info);
 
-   _MulleThreadDeregisterInUniverse( threadObject, universe);
-   [threadObject release];
-
-   mulle_objc_thread_done_poolconfiguration( universe);
+   _MulleThreadTakedownPoolAndRelease( threadObject, universe);
 
    _mulle_objc_thread_resignas_universethread( universe, NO);
 
@@ -555,7 +635,7 @@ static mulle_thread_rval_t   bouncyBounce( void *arg)
    [NSAutoreleasePool class];
 
 //   assert( mulle_objc_universe_lookup_infraclass_nofail( universe, @selector( NSAutoreleasePool)));
-   mulle_objc_thread_new_poolconfiguration( universe);
+   self->_poolconfiguration = mulle_objc_thread_new_poolconfiguration( universe);
 
    // make threadObject known to universe and thread
    _MulleThreadRegisterInUniverse( self, universe);
@@ -575,10 +655,14 @@ static mulle_thread_rval_t   bouncyBounce( void *arg)
    // start
    //
    assert( ! self->_userInfo);
-   assert( ! self->_invocationGainedAccess);
+   assert( ! self->_threadDidGainAccess);
+
+   if( self->_isObjectFunctionArgument)
+      [(id) self->_functionArgument mulleGainAccess];
+   else
+      [self->_invocation mulleGainAccess];
+   self->_threadDidGainAccess = YES;
 
-   [self->_invocation mulleGainAccess];
-   self->_invocationGainedAccess = YES;
    [self main];
 
    // this will call -finalize on us, which will release the invocation
@@ -612,18 +696,23 @@ - (void) mulleStart
    //
    [self retain];
    _mulle_objc_universe_retain( universe);
-   [self->_invocation mulleRelinquishAccess];
+
+   if( self->_isObjectFunctionArgument)
+      [(id) self->_functionArgument mulleRelinquishAccess];
+   else
+      [self->_invocation mulleRelinquishAccess];
 
    if( mulle_thread_create( bouncyBounce, self, &thread))
    {
       // undo this
+      self->_isDetached = NO;
       _mulle_objc_universe_release( universe);
       [self release];
 
       __mulle_objc_universe_raise_errno( universe, "thread creation");
    }
 
-   // we can not be sure thread has done this already, but we want to
+   // we can not be sure, that the thread has done this already, but we want to
    // be up-to-date
    _NSThreadSetOSThread( self, thread);
 
@@ -638,21 +727,6 @@ - (void) mulleStartUndetached
 }
 
 
-/*
-   The pthread_detach() function marks the thread identified by thread as
-   detached.  When a detached thread terminates, its resources are
-   automatically released back to the system without the need for another
-   thread to join with the terminated thread.
-   Once a thread has been detached, it can't be joined with pthread_join(3) or
-   be made joinable again.
-*/
-- (void) mulleDetach
-{
-   self->_isDetached = YES;
-   mulle_thread_detach( MulleThreadObjectGetOSThread( self));
-}
-
-
 /*
    The pthread_join() function waits for the thread specified by thread to
    terminate.  If that thread has already terminated, then pthread_join()
@@ -671,13 +745,25 @@ - (NSInvocation *) mulleJoin
    }
    mulle_thread_join( MulleThreadObjectGetOSThread( self));
 
-   // could regain invocation here, but how many threads will actually
-   // be joined ? And what does this do to ownership and autorelease ?
-   if( self->_invocationGainedAccess)
-      [self->_invocation mulleGainAccess];
+   invocation = nil;
 
-   invocation = [self->_invocation autorelease];
-   self->_invocation = nil;
+   if( self->_isObjectFunctionArgument)
+   {
+      // now mainThread (or caller thread) will get access back
+      if( self->_threadDidGainAccess)
+         [(id) self->_functionArgument mulleGainAccess];
+
+      [(id) self->_functionArgument autorelease];
+      self->_functionArgument = NULL;
+   }
+   else
+   {
+      // now mainThread (or caller thread) will get access back
+      if( self->_threadDidGainAccess)
+         [self->_invocation mulleGainAccess];
+      invocation = [self->_invocation autorelease];
+      self->_invocation = nil;
+   }
 
    return( invocation);
 }
@@ -705,8 +791,24 @@ - (void) cancel
 
 - (void) start
 {
+   mulle_thread_t   os_thread;
+
+   // we set this early, otherwise things could get racy
+   // in case we don't really detach, we set this back to NO
+   self->_isDetached = YES;
    [self mulleStartUndetached];
-   [self mulleDetach];
+
+   /*
+      The pthread_detach() function marks the thread identified by thread as
+      detached.  When a detached thread terminates, its resources are
+      automatically released back to the system without the need for another
+      thread to join with the terminated thread.
+      Once a thread has been detached, it can't be joined with pthread_join(3)
+      or be made joinable again.
+   */
+
+   os_thread = MulleThreadObjectGetOSThread( self);
+   mulle_thread_detach( os_thread);
 }
 
 
@@ -750,6 +852,12 @@ void  _mulle_objc_threadinfo_initializer( struct _mulle_objc_threadinfo *config)
 }
 
 
+// hidden for debug only
+- (void *) _poolconfiguration
+{
+   return( _poolconfiguration);
+}
+
 //
 // not 100% compatible to Apple, where this flag is "sticky"
 //
@@ -757,11 +865,10 @@ + (BOOL) isMultiThreaded
 {
    BOOL   flag;
 
-   mulle_thread_mutex_lock( &Self._lock);
+   mulle_thread_mutex_do( Self._lock)
    {
       flag = Self._isMultiThreaded;
    }
-   mulle_thread_mutex_unlock( &Self._lock);
    return( flag);
 }
 
@@ -778,7 +885,7 @@ - (void) __isProbablyGoingSingleThreaded
    // another thread could be starting up right now from the main thread
    // also some thread destructors might be running
    //
-   mulle_thread_mutex_lock( &Self._lock);
+   mulle_thread_mutex_do( Self._lock)
    {
       if( Self._isMultiThreaded)
       {
@@ -786,7 +893,6 @@ - (void) __isProbablyGoingSingleThreaded
          [self _isProbablyGoingSingleThreaded];
       }
    }
-   mulle_thread_mutex_unlock( &Self._lock);
 }
 
 
@@ -803,7 +909,7 @@ - (void) __isGoingMultiThreaded
    // single threaded. We serialize here, so that other threads don't
    // overtake us.
    //
-   mulle_thread_mutex_lock( &Self._lock);
+   mulle_thread_mutex_do( Self._lock)
    {
       if( ! Self._isMultiThreaded)
       {
@@ -811,7 +917,6 @@ - (void) __isGoingMultiThreaded
          [self _isGoingMultiThreaded];
       }
    }
-   mulle_thread_mutex_unlock( &Self._lock);
 }
 
 
@@ -897,7 +1002,8 @@ + (BOOL) mulleMainThreadWaitsAtExit
    struct _mulle_objc_universe   *universe;
 
    universe = _mulle_objc_infraclass_get_universe( self);
-   return( universe->config.wait_threads_on_exit);
+   // both will wait, so for introspection check both flags
+   return( universe->config.wait_threads_on_exit || universe->config.pedantic_exit);
 }
 
 
@@ -934,7 +1040,6 @@ void   MulleThreadSetCurrentThreadUserInfo( id info)
 
 
 
-
 + (void) detachNewThreadSelector:(SEL) sel
                         toTarget:(id) target
                       withObject:(id) argument
@@ -1001,7 +1106,9 @@ - (char *) mulleNameUTF8String
    char  *s;
 
    s = _mulle_atomic_pointer_read( &_nameUTF8String);
-   return( s ? s : "unnamed");
+   if( ! s)
+      s = MulleObjC_asprintf( "%p", self);
+   return( s);
 }
 
 
diff --git a/src/function/MulleObjCAllocation.h b/src/function/MulleObjCAllocation.h
index dd57cebb..9d9e4ded 100644
--- a/src/function/MulleObjCAllocation.h
+++ b/src/function/MulleObjCAllocation.h
@@ -33,11 +33,17 @@
 //  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 //  POSSIBILITY OF SUCH DAMAGE.
 //
+#ifndef MulleObjectAllocation_h__
+#define MulleObjectAllocation_h__
+
 #include "mulle-objc.h"
 
 #include <stdarg.h>
 
 
+
+// -------------
+
 #ifndef MULLE_OBJC_EMBEDDED_ALLOCATOR
 MULLE_C_CONST_RETURN
 #endif
@@ -48,6 +54,8 @@ static inline struct mulle_allocator   *MulleObjCInstanceGetAllocator( id obj)
    if( ! obj)
       return( NULL);
 
+   assert( MulleObjCObjectIsInstance( obj));
+
 #ifdef MULLE_OBJC_EMBEDDED_ALLOCATOR
    void   **p_allocator;
 
@@ -81,6 +89,8 @@ static inline struct mulle_allocator   *MulleObjCClassGetAllocator( Class cls)
    if( ! cls)
       return( NULL);
 
+   assert( MulleObjCObjectIsClass( cls)); // just a convenient check here
+
 #ifdef MULLE_OBJC_EMBEDDED_ALLOCATOR
    struct _mulle_objc_threadfoundationinfo   *info;
    struct _mulle_objc_universe               *universe;
@@ -130,31 +140,31 @@ void   *MulleObjCCallocAutoreleased( NSUInteger n,
 
 #pragma mark - allocate memory for objects
 
-static inline void  *MulleObjCInstanceAllocateNonZeroedMemory( id self, NSUInteger size)
+static inline void   *MulleObjCInstanceAllocateNonZeroedMemory( id self, NSUInteger size)
 {
    return( _mulle_allocator_malloc( MulleObjCInstanceGetAllocator( self), size));
 }
 
 
-static inline void  *MulleObjCInstanceReallocateNonZeroedMemory( id self, void *p, NSUInteger size)
+static inline void   *MulleObjCInstanceReallocateNonZeroedMemory( id self, void *p, NSUInteger size)
 {
    return( _mulle_allocator_realloc( MulleObjCInstanceGetAllocator( self), p, size));
 }
 
 
-static inline void  *MulleObjCInstanceAllocateMemory( id self, NSUInteger size)
+static inline void   *MulleObjCInstanceAllocateMemory( id self, NSUInteger size)
 {
    return( _mulle_allocator_calloc( MulleObjCInstanceGetAllocator( self), 1, size));
 }
 
 
-static inline void  *MulleObjCInstanceDuplicateUTF8String( id self, char *s)
+static inline void   *MulleObjCInstanceDuplicateUTF8String( id self, char *s)
 {
    return( _mulle_allocator_strdup( MulleObjCInstanceGetAllocator( self), s));
 }
 
 
-static inline void  MulleObjCInstanceDeallocateMemory( id self, void *p)
+static inline void   MulleObjCInstanceDeallocateMemory( id self, void *p)
 {
    if( p)
       _mulle_allocator_free( MulleObjCInstanceGetAllocator( self), p);
@@ -163,31 +173,31 @@ static inline void  MulleObjCInstanceDeallocateMemory( id self, void *p)
 
 #pragma mark - allocate memory for class methods
 
-static inline void  *MulleObjCClassAllocateNonZeroedMemory( Class cls, NSUInteger size)
+static inline void   *MulleObjCClassAllocateNonZeroedMemory( Class cls, NSUInteger size)
 {
    return( _mulle_allocator_malloc( MulleObjCClassGetAllocator( cls), size));
 }
 
 
-static inline void  *MulleObjCClassReallocateNonZeroedMemory( Class cls, void *p, NSUInteger size)
+static inline void   *MulleObjCClassReallocateNonZeroedMemory( Class cls, void *p, NSUInteger size)
 {
    return( _mulle_allocator_realloc( MulleObjCClassGetAllocator( cls), p, size));
 }
 
 
-static inline void  *MulleObjCClassAllocateMemory( Class cls, NSUInteger size)
+static inline void   *MulleObjCClassAllocateMemory( Class cls, NSUInteger size)
 {
    return( _mulle_allocator_calloc( MulleObjCClassGetAllocator( cls), 1, size));
 }
 
 
-static inline void  *MulleObjCClassDuplicateUTF8String( Class cls, char *s)
+static inline void   *MulleObjCClassDuplicateUTF8String( Class cls, char *s)
 {
    return( _mulle_allocator_strdup( MulleObjCClassGetAllocator( cls), s));
 }
 
 
-static inline void  MulleObjCClassDeallocateMemory( Class cls, void *p)
+static inline void   MulleObjCClassDeallocateMemory( Class cls, void *p)
 {
    if( p)
       _mulle_allocator_free( MulleObjCClassGetAllocator( cls), p);
@@ -287,6 +297,7 @@ static inline NSUInteger  MulleObjCClassGetInstanceSize( Class infra)
 {
    if( ! infra)
       return( 0);
+
    return( _mulle_objc_infraclass_get_allocationsize( infra));
 }
 
@@ -303,6 +314,8 @@ static inline id   MulleObjCClassConstructInstance( Class infra,
    if( ! infra)
       return( nil);
 
+   assert( MulleObjCObjectIsClass( infra));  // convenience check
+
    assert( length >= _mulle_objc_infraclass_get_allocationsize( infra));
 
    cls    = _mulle_objc_infraclass_as_class( infra);
@@ -411,12 +424,19 @@ static inline NSUInteger   MulleObjCCopyObjectArray( id *objects,
 // MEMO: only use in your root class -retain method
 static inline id   _MulleObjCRetainObject( id obj)
 {
+   assert( MulleObjCObjectIsInstance( obj));
+
    _mulle_objc_object_retain_inline( obj);
    return( obj);
 }
 
+
 // MEMO: only use in your root class -release method
 static inline void   _MulleObjCReleaseObject( id obj)
 {
+   assert( MulleObjCObjectIsInstance( obj));
+
    _mulle_objc_object_release_inline( obj);
 }
+
+#endif
diff --git a/src/function/MulleObjCAllocation.m b/src/function/MulleObjCAllocation.m
index 37c67367..78b2be72 100644
--- a/src/function/MulleObjCAllocation.m
+++ b/src/function/MulleObjCAllocation.m
@@ -59,6 +59,8 @@ void   _MulleObjCInstanceFree( id obj)
    struct _mulle_objc_class                    *cls;
    struct mulle_allocator                      *allocator;
 
+   assert( MulleObjCObjectIsInstance( obj));
+
    cls      = _mulle_objc_object_get_isa( obj);
    universe = _mulle_objc_class_get_universe( cls);
    config   = _mulle_objc_universe_get_universefoundationinfo( universe);
diff --git a/src/function/MulleObjCDebug.m b/src/function/MulleObjCDebug.m
index 07d42c08..2f536540 100644
--- a/src/function/MulleObjCDebug.m
+++ b/src/function/MulleObjCDebug.m
@@ -46,6 +46,8 @@
 #include <string.h>
 
 
+#import "MulleObjCFunctions.h"
+
 
 
 static struct _mulle_objc_infraclass   *infraclass_from_string( char *classname)
@@ -428,3 +430,4 @@ void   MulleObjCDumpObject( id obj)
 }
 
 #endif
+
diff --git a/src/function/MulleObjCFunctions.h b/src/function/MulleObjCFunctions.h
index 0ba17a26..9868ee63 100644
--- a/src/function/MulleObjCFunctions.h
+++ b/src/function/MulleObjCFunctions.h
@@ -33,10 +33,13 @@
 //  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 //  POSSIBILITY OF SUCH DAMAGE.
 //
+#ifndef MulleObjCFunctions_h__
+#define MulleObjCFunctions_h__
 
 #include "minimal.h"
 
 
+
 #pragma mark - accessor shortcuts
 
 // BOOL
@@ -665,7 +668,10 @@ IMP   MulleObjCObjectSearchClobberedIMP( id obj,
 // If called from -bar in Foo(A) this will find the IMP -bar of Foo.
 // Unless it doesn't exist.
 // Or unless there is an intervening category Foo(B), which its own -bar,
-// then you get the IMP for -bar of Foo(B)
+// then you get the IMP for -bar of Foo(B). If there is no implementation of
+// -bar in Foo or its categories, you will get 0 back!
+// e.g. Foo : NSObject, if you search for -autorelease and Foo doesn't
+// implement it but NSObject does, then you get 0.
 //
 #define MulleObjCClobberedIMP \
    MulleObjCObjectSearchClobberedIMP( (self), (_cmd), __MULLE_OBJC_CLASSID__, __MULLE_OBJC_CATEGORYID__)
@@ -904,18 +910,30 @@ static inline Class   MulleObjCObjectGetClass( id obj)
 }
 
 
+// common expectation to have this available as well
+static inline Class   MulleObjCInstanceGetClass( id obj)
+{
+   return( MulleObjCObjectGetClass( obj));
+}
+
+
+
 MULLE_OBJC_GLOBAL
-void    MulleObjCObjectSetClass( id obj, Class cls);
+void    MulleObjCInstanceSetClass( id obj, Class cls);
+
 
 //
 // only cheatin' strings should use this
 // this must be used in init and nowhere else, as it is
 // not atomic
 //
-static inline void   MulleObjCObjectConstantify( id obj)
+static inline void   MulleObjCInstanceConstantify( id obj)
 {
    if( obj)
+   {
+      assert( MulleObjCObjectIsInstance( obj));
       _mulle_objc_object_constantify_noatomic( obj);
+   }
 }
 
 
@@ -974,19 +992,24 @@ Class   MulleObjCLookupClassByClassID( SEL classid);
 MULLE_OBJC_GLOBAL
 SEL     MulleObjCCreateSelectorUTF8String( char *name);
 
+
 MULLE_OBJC_GLOBAL
-char  *MulleObjCInstanceGetClassNameUTF8String( id obj);
+char   *MulleObjCObjectGetClassNameUTF8String( id obj);
 
 
 static inline 
-char  *MulleObjCObjectGetClassNameUTF8String( id obj)
+char  *MulleObjCInstanceGetClassNameUTF8String( id obj)
 {
-   return( MulleObjCInstanceGetClassNameUTF8String( obj));
+   assert( MulleObjCObjectIsInstanceOrNil( obj));
+
+   return( MulleObjCObjectGetClassNameUTF8String( obj));
 }
 
 
 static inline void   *MulleObjCInstanceGetExtraBytes( id obj)
 {
+   assert( MulleObjCObjectIsInstanceOrNil( obj));
+
    return( obj ? _mulle_objc_object_get_extra( obj) : NULL);
 }
 
@@ -1027,6 +1050,8 @@ static inline struct _mulle_objc_property  *MulleObjCInstanceSearchProperty( id
 {
    struct _mulle_objc_infraclass   *infra;
 
+   assert( MulleObjCObjectIsInstanceOrNil( obj));
+
    if( ! obj)
       return( NULL);
 
@@ -1061,3 +1086,6 @@ BOOL  MulleObjCDescribeMemory( struct mulle_buffer *buffer,
 
 // dump known instance variables of an object
 void  MulleObjCDescribeIvars( struct mulle_buffer *buffer, id obj);
+
+
+#endif
diff --git a/src/function/MulleObjCFunctions.m b/src/function/MulleObjCFunctions.m
index 0a7a039b..78a3120c 100644
--- a/src/function/MulleObjCFunctions.m
+++ b/src/function/MulleObjCFunctions.m
@@ -131,9 +131,12 @@ void   MulleObjCMakeObjectsPerformSelector2( id *objects,
 // should be CString something
 char  *MulleObjCClassGetNameUTF8String( Class cls)
 {
+
    if( ! cls)
       return( NULL); // return NULL to stay compatible with NSStringFromClass
 
+   assert( MulleObjCObjectIsClass( cls)); // convenience check
+
    return( _mulle_objc_infraclass_get_name( cls));
 }
 
@@ -278,16 +281,19 @@ Class   MulleObjCLookupClassByClassID( SEL classid)
 }
 
 
-char  *MulleObjCInstanceGetClassNameUTF8String( id obj)
+char  *MulleObjCObjectGetClassNameUTF8String( id obj)
 {
    return( MulleObjCClassGetNameUTF8String( [obj class]));
 }
 
 
-void    MulleObjCObjectSetClass( id obj, Class cls)
+void    MulleObjCInstanceSetClass( id obj, Class cls)
 {
    struct _mulle_objc_class   *new_cls;
 
+   // can't do this, isa pointer might be trash yet
+   // assert( ! MulleObjCObjectIsInstanceOrNil( obj));
+
    if( ! obj)
       return;
 
diff --git a/src/function/MulleObjCHashFunctions.h b/src/function/MulleObjCHashFunctions.h
index e402eddd..d788e247 100644
--- a/src/function/MulleObjCHashFunctions.h
+++ b/src/function/MulleObjCHashFunctions.h
@@ -33,6 +33,9 @@
 //  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 //  POSSIBILITY OF SUCH DAMAGE.
 //
+#ifndef MulleObjCHashFunctions_h__
+#define MulleObjCHashFunctions_h__
+
 #include "include.h"
 
 #include "NSRange.h"
@@ -79,4 +82,4 @@ static inline NSUInteger   MulleObjCBytesPartialHash( void *buf, NSUInteger leng
    return( MulleObjCBytesHashRange( buf, range));
 }
 
-
+#endif
diff --git a/src/function/MulleObjCIvar.m b/src/function/MulleObjCIvar.m
index e1aad4b7..0b48fb6e 100644
--- a/src/function/MulleObjCIvar.m
+++ b/src/function/MulleObjCIvar.m
@@ -43,6 +43,7 @@
 #import "MulleObjCExceptionHandler.h"
 #import "MulleObjCExceptionHandler-Private.h"
 #import "MulleObjCIntegralType.h"
+#import "MulleObjCFunctions.h"
 #import "NSCopying.h"
 #import "mulle-objc-exceptionhandlertable-private.h"
 #import "mulle-objc-universefoundationinfo-private.h"
diff --git a/src/function/MulleObjCPrinting.h b/src/function/MulleObjCPrinting.h
index 4d98d4c2..e98385e1 100644
--- a/src/function/MulleObjCPrinting.h
+++ b/src/function/MulleObjCPrinting.h
@@ -33,6 +33,9 @@
 //  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 //  POSSIBILITY OF SUCH DAMAGE.
 //
+#ifndef MulleObjCPrinting_h__
+#define MulleObjCPrinting_h__
+
 #include "mulle-objc.h"
 
 #include <stdarg.h>
@@ -74,3 +77,4 @@ char   *MulleObjC_strdup( char *s);
            name ## __j < 1;                                                    \
            name ## __j++)
 
+#endif
diff --git a/src/function/MulleObjCProperty.m b/src/function/MulleObjCProperty.m
index 8e7b5b8f..8f9b9e05 100644
--- a/src/function/MulleObjCProperty.m
+++ b/src/function/MulleObjCProperty.m
@@ -53,6 +53,8 @@ int   _MulleObjCInstanceClearProperty( struct _mulle_objc_property *property,
    struct _mulle_objc_ivar    *ivar;
    mulle_objc_ivarid_t        ivarid;
 
+   assert( MulleObjCObjectIsInstance( (id) self));
+
    bits = _mulle_objc_property_get_bits( property);
    if( bits & _mulle_objc_property_setterclear)
    {
@@ -98,6 +100,8 @@ int   _MulleObjCInstanceClearPropertyNoReadOnly( struct _mulle_objc_property *pr
    struct _mulle_objc_ivar    *ivar;
    mulle_objc_ivarid_t        ivarid;
 
+   assert( MulleObjCObjectIsInstance( (id) self));
+
    // don't clear readonly properties for (seems incompatible with Apple)
    bits = _mulle_objc_property_get_bits( property);
    if( bits & _mulle_objc_property_readonly)
@@ -169,6 +173,8 @@ void   _MulleObjCInstanceClearProperties( id obj, BOOL clearReadOnly)
    struct _mulle_objc_class        *cls;
    struct _mulle_objc_infraclass   *infra;
 
+   assert( MulleObjCObjectIsInstance( obj));
+
    // walk through properties and release them
    cls  = _mulle_objc_object_get_isa( obj);
    // if it's a meta class it's an error during debug
diff --git a/src/function/mulle-sprintf-object.h b/src/function/mulle-sprintf-object.h
index 68e01d6d..878719d7 100644
--- a/src/function/mulle-sprintf-object.h
+++ b/src/function/mulle-sprintf-object.h
@@ -33,7 +33,12 @@
 //  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 //  POSSIBILITY OF SUCH DAMAGE.
 //
+#ifndef mulle_sprintf_object_h__
+#define mulle_sprintf_object_h__
+
 #include "include.h"
 
 MULLE_OBJC_GLOBAL
 void  mulle_sprintf_register_object_functions( struct mulle_sprintf_conversion *tables);
+
+#endif
diff --git a/src/mulle-objc-atomicid.m b/src/mulle-objc-atomicid.m
index 7ffb6e64..105e4a2a 100644
--- a/src/mulle-objc-atomicid.m
+++ b/src/mulle-objc-atomicid.m
@@ -60,6 +60,10 @@ id   _mulle_atomic_id_update( mulle_atomic_id_t *ivar,
       if( ivarType == _C_RETAIN_ID)
          value = mulle_objc_object_call_retain( value);
 
+   // MEMO: need to document why this is rereading pointer in the loop
+   //       and not just once outside the loop and then using previous.
+   //       from __cas. I benchmarked just using "cas" with a random value
+   //       for retrieval, but a failing CAS is markedly worse.
    for(;;)
    {
       old = (id) _mulle_atomic_pointer_read( &ivar->pointer);
diff --git a/src/mulle-objc-autoreleasepointerarray-private.h b/src/mulle-objc-autoreleasepointerarray-private.h
index 58cf01ad..4f2ff7f9 100644
--- a/src/mulle-objc-autoreleasepointerarray-private.h
+++ b/src/mulle-objc-autoreleasepointerarray-private.h
@@ -357,8 +357,7 @@ static inline unsigned int
 static inline void
    _mulle_autoreleasepointerarray_dump_objects(
                                struct _mulle_autoreleasepointerarray *end,
-                               char *verb,
-                               struct _mulle_autoreleasepointerarray *staticStorage)
+                               char *verb)
 {
    id                                      *objects;
    id                                      *sentinel;
@@ -386,4 +385,34 @@ static inline void
 }
 
 
+static inline
+void   _mulle_autoreleasepointerarray_walk_objects(
+                               struct _mulle_autoreleasepointerarray *end,
+                               mulle_objc_walkcommand_t (*callback)( id obj, void *userinfo),
+                               void *userinfo)
+{
+   id                                      *objects;
+   id                                      *sentinel;
+   struct _mulle_autoreleasepointerarray   *p, *q;
+   id                                      obj;
+
+   for( p = end; p; p = q)
+   {
+      q = p->previous;
+
+      objects  = p->objects;
+      sentinel = &p->objects[ p->used];
+      while( objects < sentinel)
+      {
+         obj = *objects++;
+         if( obj)
+         {
+            if( (*callback)( obj, userinfo) != mulle_objc_walk_ok)
+               break;
+         }
+      }
+   }
+}
+
+
 #endif
diff --git a/src/mulle-objc-threadfoundationinfo.h b/src/mulle-objc-threadfoundationinfo.h
index 7a5d592c..07f2457b 100644
--- a/src/mulle-objc-threadfoundationinfo.h
+++ b/src/mulle-objc-threadfoundationinfo.h
@@ -60,17 +60,17 @@ struct _mulle_objc_poolconfiguration
    struct _mulle_objc_infraclass   *poolClass;
 
 
-   void   *(*push)( struct _mulle_objc_poolconfiguration *);
-   void   (*pop)( struct _mulle_objc_poolconfiguration *, id pool);
+   void               *(*push)( struct _mulle_objc_poolconfiguration *);
+   void               (*pop)( struct _mulle_objc_poolconfiguration *, id pool);
 
-   int             releasing;
+   int                releasing;
    // debugging support
-   int             trace;
-   unsigned int    maxObjects;  // coarse
+   int                trace;
+   unsigned int       maxObjects;  // coarse
 
    // used for debugging when MULLE_OBJC_AUTORELEASEPOOL_MAP is YES
-   struct mulle_map                *object_map;
-   struct mulle_map                _object_map;
+   struct mulle_map   *object_map;
+   struct mulle_map   _object_map;
 };
 
 
diff --git a/src/mulle-objc-universefoundationinfo-private.h b/src/mulle-objc-universefoundationinfo-private.h
index 804fccdd..a65a98b1 100644
--- a/src/mulle-objc-universefoundationinfo-private.h
+++ b/src/mulle-objc-universefoundationinfo-private.h
@@ -52,6 +52,7 @@ struct _mulle_objc_universefoundationinfo_object
    // thread object
    struct mulle_map    *threads;
 
+   unsigned char       singlethreadautoreleasecheckerenabled;
    unsigned char       debugenabled;
    unsigned char       zombieenabled;
    unsigned char       deallocatezombie;
diff --git a/src/mulle-objc-universefoundationinfo.m b/src/mulle-objc-universefoundationinfo.m
index 07ca395b..852c6fd8 100644
--- a/src/mulle-objc-universefoundationinfo.m
+++ b/src/mulle-objc-universefoundationinfo.m
@@ -80,21 +80,29 @@ static void   assert_proper_testallocator_linkorder( void)
 #if DEBUG
    assert_proper_testallocator_linkorder();
 #endif
-   info->exception.vectors   = *exceptiontable;
-
-   info->object.roots        = mulle_set_create( 32,
-                                                 (void *) &_MulleObjCContainerAssignKeyCallback,
-                                                 allocator);
-   info->object.threads      = mulle_map_create( 32,
-                                                 (void *) &_MulleObjCContainerPointerKeyAssignValueCallback,
-                                                 allocator);
-
-   info->object.debugenabled      = mulle_objc_environment_get_yes_no( "MULLE_OBJC_DEBUG_ENABLED") ||
-         mulle_objc_environment_get_yes_no( "NSDebugEnabled");
-   info->object.zombieenabled     = mulle_objc_environment_get_yes_no( "MULLE_OBJC_ZOMBIE_ENABLED") ||
-         mulle_objc_environment_get_yes_no( "NSZombieEnabled");
-   info->object.deallocatezombie  = mulle_objc_environment_get_yes_no( "MULLE_OBJC_DEALLOCATE_ZOMBIE") ||
-         mulle_objc_environment_get_yes_no( "NSDeallocateZombies");
+   info->exception.vectors = *exceptiontable;
+
+   info->object.roots      = mulle_set_create( 32,
+                                               (void *) &_MulleObjCContainerAssignKeyCallback,
+                                               allocator);
+   info->object.threads    = mulle_map_create( 32,
+                                               (void *) &_MulleObjCContainerPointerKeyAssignValueCallback,
+                                               allocator);
+
+   // sometimes useful
+   info->object.singlethreadautoreleasecheckerenabled = mulle_objc_environment_get_yes_no( "MULLE_OBJC_SINGLE_THREAD_AUTORELEASE_CHECKER_ENABLED");
+
+   info->object.debugenabled      = mulle_objc_environment_get_yes_no( "MULLE_OBJC_DEBUG_ENABLED")
+                                    | mulle_objc_environment_get_yes_no( "NSDebugEnabled");
+
+   info->object.zombieenabled     = mulle_objc_environment_get_yes_no( "MULLE_OBJC_ZOMBIE_ENABLED")
+                                    | mulle_objc_environment_get_yes_no( "MULLE_OBJC_TRACE_ZOMBIE")
+                                    | mulle_objc_environment_get_yes_no( "NSZombieEnabled");
+   // when leak checkingt must deallocate
+   info->object.deallocatezombie  = mulle_objc_environment_get_yes_no( "MULLE_OBJC_DEALLOCATE_ZOMBIE")
+                                    | mulle_objc_environment_get_yes_no( "NSDeallocateZombies")
+                                    | mulle_objc_environment_get_yes_no( "MULLE_OBJC_TRACE_LEAK");
+
    info->object.shredzombie       = ! mulle_objc_environment_get_yes_no( "MULLE_OBJC_PRESERVE_ZOMBIE");
 }
 
diff --git a/src/mulle-objc.h b/src/mulle-objc.h
index 8eee92ac..753c8ed3 100644
--- a/src/mulle-objc.h
+++ b/src/mulle-objc.h
@@ -20,10 +20,57 @@
 
 #include "minimal.h"
 
+
 // additional stuff requiring the runtime
 #include "mulle-objc-atomicid.h"
 #include "mulle-objc-classbit.h"
 #include "mulle-objc-threadfoundationinfo.h"
+
+//
+// useful for asserts.. here for reasons...
+//
+static inline BOOL   MulleObjCClassMetaClass( Class cls)
+{
+   return( mulle_objc_class_is_metaclass( (struct _mulle_objc_class *) cls));
+}
+
+
+static inline BOOL   MulleObjCObjectIsClass( id obj)
+{
+   struct _mulle_objc_class  *cls;
+
+   cls =  mulle_objc_object_get_isa( obj);
+   return( mulle_objc_class_is_metaclass( cls));
+}
+
+
+static inline BOOL   MulleObjCObjectIsClassOrNil( id obj)
+{
+   struct _mulle_objc_class  *cls;
+
+   cls =  mulle_objc_object_get_isa( obj);
+   return( ! mulle_objc_class_is_infraclass( cls));
+}
+
+
+static inline BOOL   MulleObjCObjectIsInstance( id obj)
+{
+   struct _mulle_objc_class  *cls;
+
+   cls = mulle_objc_object_get_isa( obj);
+   return( mulle_objc_class_is_infraclass( cls));
+}
+
+
+static inline BOOL   MulleObjCObjectIsInstanceOrNil( id obj)
+{
+   struct _mulle_objc_class  *cls;
+
+   cls =  mulle_objc_object_get_isa( obj);
+   return( ! mulle_objc_class_is_metaclass( cls));
+}
+
+
 #include "MulleObjCAllocation.h"
 #include "MulleObjCAutoreleasePool.h"
 #include "MulleObjCExceptionHandler.h"
@@ -33,7 +80,6 @@
 #include "MulleObjCUniverse.h"
 
 
-
 #ifdef __has_include
 # if __has_include( "_MulleObjC-versioncheck.h")
 #  include "_MulleObjC-versioncheck.h"
diff --git a/src/protocol/MulleObjCException.m b/src/protocol/MulleObjCException.m
index 3e4863e2..b5e2e405 100644
--- a/src/protocol/MulleObjCException.m
+++ b/src/protocol/MulleObjCException.m
@@ -171,7 +171,7 @@ void   _MulleObjCThrowErrnoException( mulle_objc_universeid_t universeid,
  */
 MULLE_C_NO_RETURN
 void   _MulleObjCThrowInvalidArgumentExceptionUTF8String( mulle_objc_universeid_t universeid,
-                                                       char *format, ...)
+                                                          char *format, ...)
 {
    struct _mulle_objc_universe                 *universe;
    struct _mulle_objc_universefoundationinfo   *rootconfig;
diff --git a/src/protocol/MulleObjCProtocol.m b/src/protocol/MulleObjCProtocol.m
index 4225941e..6512bfe9 100644
--- a/src/protocol/MulleObjCProtocol.m
+++ b/src/protocol/MulleObjCProtocol.m
@@ -17,7 +17,7 @@ + (void) initialize
    _mulle_objc_class_set_state_bit( cls, MULLE_OBJC_CLASS_IS_NOT_THREAD_AFFINE);
 }
 
-- (BOOL) mulleIsThreadSafe
+- (BOOL) mulleIsThreadSafe                MULLE_OBJC_THREADSAFE_METHOD
 {
    return( YES);
 }
@@ -28,7 +28,15 @@ - (id) mulleThreadSafeCopy
    return( MulleObjCObjectRetain( self)); // is a little unclean
 }
 
+
+//
 // no need for mulleTAOStrategy as it doesn't apply to threadSafe objects
+// but still nicer for introspection
+//
+- (MulleObjCTAOStrategy) mulleTAOStrategy  MULLE_OBJC_THREADSAFE_METHOD
+{
+   return( MulleObjCTAOKnownThreadSafe);
+}
 
 PROTOCOLCLASS_END()
 
@@ -44,7 +52,7 @@ + (void) initialize
    _mulle_objc_class_clear_state_bit( cls, MULLE_OBJC_CLASS_IS_NOT_THREAD_AFFINE);
 }
 
-- (BOOL) mulleIsThreadSafe
+- (BOOL) mulleIsThreadSafe                MULLE_OBJC_THREADSAFE_METHOD
 {
    return( NO);
 }
diff --git a/src/protocol/MulleObjCRootObject.m b/src/protocol/MulleObjCRootObject.m
index ec7030d7..292be17c 100644
--- a/src/protocol/MulleObjCRootObject.m
+++ b/src/protocol/MulleObjCRootObject.m
@@ -5,6 +5,7 @@
 #import "MulleObjCException.h"
 #import "MulleObjCExceptionHandler.h"
 #import "MulleObjCExceptionHandler-Private.h"
+#import "MulleObjCFunctions.h"
 #import "MulleObjCProperty.h"
 #import "NSAutoreleasePool.h"
 #import "NSMethodSignature.h"
@@ -82,7 +83,7 @@ - (void) dealloc
    universe = _mulle_objc_object_get_universe( self);
    config   = _mulle_objc_universe_get_universefoundationinfo( universe);
 
-   if( config->object.zombieenabled)
+   if( config->object.singlethreadautoreleasecheckerenabled)
    {
       if( [NSAutoreleasePool mulleCountObject:self] )
          __mulle_objc_universe_raise_internalinconsistency( universe,
@@ -104,13 +105,13 @@ - (void) dealloc
 #ifdef DEBUG
 static void   checkAutoreleaseRelease( id self)
 {
-   struct _mulle_objc_universe                  *universe;
+   struct _mulle_objc_universe                 *universe;
    struct _mulle_objc_universefoundationinfo   *config;
 
    universe = _mulle_objc_object_get_universe( self);
    config   = _mulle_objc_universe_get_universefoundationinfo( universe);
 
-   if( config->object.zombieenabled)
+   if( config->object.singlethreadautoreleasecheckerenabled)
    {
       NSUInteger   autoreleaseCount;
       NSUInteger   retainCount;
@@ -264,7 +265,7 @@ - (void) mulleGainAccessWithTAOStrategy:(MulleObjCTAOStrategy) strategy
    switch( strategy)
    {
    case MulleObjCTAOKnownThreadSafe :
-      assert( ! _mulle_objc_object_get_thread( (struct _mulle_objc_object *) self));
+      assert( ! _mulle_objc_object_get_thread( (struct _mulle_objc_object *) self) && "MulleObjCTAOKnownThreadSafe should only be set by @protocol MulleObjCThreadSafe");
       goto autorelease;
 
       // the differentations are just for self commenting code
@@ -326,10 +327,10 @@ - (void) mulleRelinquishAccessWithTAOStrategy:(MulleObjCTAOStrategy) strategy
    switch( strategy)
    {
    case MulleObjCTAOKnownThreadSafe          :
-      assert( ! _mulle_objc_object_get_thread( (struct _mulle_objc_object *) self));
+      assert( ! _mulle_objc_object_get_thread( (struct _mulle_objc_object *) self) && "MulleObjCTAOKnownThreadSafe should only be set by @protocol MulleObjCThreadSafe");
       return;
 
-      // the differentations are just for self commenting code
+      // the differentiations are just for self commenting code
    case MulleObjCTAOKnownThreadSafeMethods   :
       // no way to check this, TAO will catch it
       // but don't change affinity
diff --git a/src/protocol/MulleObjCRuntimeObject.h b/src/protocol/MulleObjCRuntimeObject.h
index 741cb8a4..b93a9718 100644
--- a/src/protocol/MulleObjCRuntimeObject.h
+++ b/src/protocol/MulleObjCRuntimeObject.h
@@ -29,7 +29,7 @@ typedef NS_ENUM( NSUInteger, MulleObjCTAOStrategy)
 
 // (*) this means an instance is created and then presented to a thread in a one
 //     directional fashion. It won't work, if the instance is created in the
-//     thread and then acquired by the thread maker. I.e. hardly ever useful.
+//     thread and then acquired by the thread maker.
 //
 
 extern NS_ENUM_TABLE( MulleObjCTAOStrategy, 5);
@@ -204,6 +204,8 @@ _Pragma("clang diagnostic ignored \"-Wobjc-missing-super-calls\"") \
 // a class, that is MulleObjCThreadSafe.
 //
 - (void) mulleGainAccess            MULLE_OBJC_THREADSAFE_METHOD;
+- (void) mulleGainAccessWithTAOStrategy:(MulleObjCTAOStrategy) strategy MULLE_OBJC_THREADSAFE_METHOD;
+
 - (void) mulleRelinquishAccess      MULLE_OBJC_THREADSAFE_METHOD;
 - (void) mulleRelinquishAccessWithTAOStrategy:(MulleObjCTAOStrategy) strategy MULLE_OBJC_THREADSAFE_METHOD;
 - (MulleObjCTAOStrategy) mulleTAOStrategy MULLE_OBJC_THREADSAFE_METHOD;
diff --git a/src/protocol/MulleObjCSingleton.m b/src/protocol/MulleObjCSingleton.m
index 952bb094..ab2bbe63 100644
--- a/src/protocol/MulleObjCSingleton.m
+++ b/src/protocol/MulleObjCSingleton.m
@@ -43,6 +43,7 @@
 #import "MulleObjCExceptionHandler-Private.h"
 #import "MulleObjCIntegralType.h"
 #import "MulleObjCAllocation.h"
+#import "MulleObjCFunctions.h"
 #import "NSRange.h"
 #import "MulleObjCVersion.h"
 
@@ -100,7 +101,9 @@ + (void) initialize
    MulleObjCSingletonMarkClassAsSingleton( self);
    if( Self._useEphemeralSingleton == -1)
    {
-      Self._useEphemeralSingleton = mulle_objc_environment_get_yes_no( "MULLE_OBJC_EPHEMERAL_SINGLETON");
+      Self._useEphemeralSingleton = mulle_objc_environment_get_yes_no( "MULLE_OBJC_EPHEMERAL_SINGLETON")
+                                    | mulle_objc_environment_get_yes_no( "MULLE_OBJC_TRACE_LEAK")
+                                    | mulle_objc_environment_get_yes_no( "MULLE_OBJC_TRACE_ZOMBIE");
       if( Self._useEphemeralSingleton > 0)
       {
          // universe allocator partakes in aba GC, but not the class allocator
diff --git a/src/protocol/NSCopyingWithAllocator.h b/src/protocol/NSCopyingWithAllocator.h
index 71957e82..d39ee470 100644
--- a/src/protocol/NSCopyingWithAllocator.h
+++ b/src/protocol/NSCopyingWithAllocator.h
@@ -77,7 +77,7 @@
                                // protocol class
 
 MULLE_OBJC_GLOBAL
-id  MulleObjCInstanceCopyWithAllocator( id object,
-                                        NSUInteger extraBytes,
-                                        struct mulle_allocator *allocator);
+id  _MulleObjCInstanceCopyWithAllocator( id object,
+                                         NSUInteger extraBytes,
+                                         struct mulle_allocator *allocator);
 
diff --git a/src/protocol/NSCopyingWithAllocator.m b/src/protocol/NSCopyingWithAllocator.m
index b55cad9a..902e9d73 100644
--- a/src/protocol/NSCopyingWithAllocator.m
+++ b/src/protocol/NSCopyingWithAllocator.m
@@ -146,14 +146,16 @@ int   _MulleObjCClassCopyWithAllocatorProperties( struct _mulle_objc_infraclass
 
 
 
-id   MulleObjCInstanceCopyWithAllocator( id obj,
-                                NSUInteger extraBytes,
-                                struct mulle_allocator *allocator)
+id   _MulleObjCInstanceCopyWithAllocator( id obj,
+                                          NSUInteger extraBytes,
+                                          struct mulle_allocator *allocator)
 {
    id                clone;
    Class             infraCls;
    struct copy_info  info;
 
+   assert( MulleObjCObjectIsInstance( obj));
+
 
    if( [obj respondsToSelector:@selector( mulleAllocator)] &&
        [(NSObject *) obj mulleAllocator] == allocator)
@@ -187,7 +189,7 @@ @implementation NSCopyingWithAllocator
 
 - (id) copyWithAllocator:(struct mulle_allocator *) allocator
 {
-   return( MulleObjCInstanceCopyWithAllocator( self, 0, allocator));
+   return( _MulleObjCInstanceCopyWithAllocator( self, 0, allocator));
 }
 
 @end
diff --git a/src/reflect/objc-loader.inc b/src/reflect/objc-loader.inc
index 1e64f2a2..c7ffdb37 100644
--- a/src/reflect/objc-loader.inc
+++ b/src/reflect/objc-loader.inc
@@ -11,6 +11,7 @@
       { @selector( MulleObjCThreadSafe), MULLE_OBJC_NO_CATEGORYID },      // 8b122dd3;MulleObjCThreadSafe;;
       { @selector( MulleObjCThreadUnsafe), MULLE_OBJC_NO_CATEGORYID },      // 5414daed;MulleObjCThreadUnsafe;;
       { @selector( MulleObject), MULLE_OBJC_NO_CATEGORYID },      // a4b69f59;MulleObject;;
+      { @selector( MulleProxy), MULLE_OBJC_NO_CATEGORYID },      // 52ede52b;MulleProxy;;
       { @selector( NSAutoreleasePool), MULLE_OBJC_NO_CATEGORYID },      // 58bb178a;NSAutoreleasePool;;
       { @selector( NSCondition), MULLE_OBJC_NO_CATEGORYID },      // 0397143e;NSCondition;;
       { @selector( NSConditionLock), MULLE_OBJC_NO_CATEGORYID },      // 5e0deecf;NSConditionLock;;
diff --git a/test/MulleObject/30-bench/various-calls.m b/test/MulleObject/30-bench/various-calls.m
index d50efbb0..bc544c2a 100644
--- a/test/MulleObject/30-bench/various-calls.m
+++ b/test/MulleObject/30-bench/various-calls.m
@@ -1,4 +1,5 @@
 #import <MulleObjC/MulleObjC.h>
+#import <MulleObjC/MulleObjCExceptionHandler-Private.h>
 #import <MulleObjC/NSLock-Private.h>
 #import <MulleObjC/NSRecursiveLock-Private.h>
 #import <MulleObjC/MulleObject-Private.h>
@@ -33,7 +34,7 @@ - (void) safeCall:(NSUInteger) n
 
 @interface B : NSObject
 {
-   NSRecursiveLock  *_lock;
+   NSLock  *_lock;
 
 }
 - (void) safeCall:(NSUInteger) n     MULLE_OBJC_THREADSAFE_METHOD;
diff --git a/test/NSAutoreleasePool/pooldump-dot.awk b/test/NSAutoreleasePool/pooldump-dot.awk
new file mode 100755
index 00000000..cb277dae
--- /dev/null
+++ b/test/NSAutoreleasePool/pooldump-dot.awk
@@ -0,0 +1,108 @@
+#!/usr/bin/awk -f
+
+# ./pooldump-dot.awk pooldump.stdout > pooldump.dot
+# dot -Tsvg pooldump.dot -o pooldump.svg
+
+BEGIN {
+    FS=","
+    print "digraph G {"
+    print "  rankdir=LR;"
+    print "  node [shape=box];"
+    print "  edge [dir=forward];"
+}
+
+NR > 1 {
+    gsub(/"/, "", $2)  # thread name
+    gsub(/"/, "", $4)  # pool address
+    gsub(/"/, "", $6)  # object address
+    gsub(/"/, "", $7)  # class name
+
+    thread_id=$1
+    thread_name=$2
+    pool_id=$3
+    pool_addr=$4
+    obj_addr=$6
+    class_name=$7
+    rc=$8
+
+    # Store thread info
+    threads[thread_id] = thread_name
+
+    # Track pool addresses for each thread
+    if (!seen_pool[thread_id, pool_addr]) {
+        pool_sequence[thread_id, ++pool_count[thread_id]] = pool_addr
+        seen_pool[thread_id, pool_addr] = 1
+    }
+
+    # Store object relationships
+    pool_objects[pool_addr, obj_addr] = class_name
+    retain_counts[obj_addr] = rc
+    if (rc > 1) {
+        all_objects[obj_addr] = class_name
+    }
+}
+
+END {
+    # Create thread nodes
+    for (tid in threads) {
+        print "  \"thread_" tid "\" [shape=none,label=<"
+        print "    <TABLE BORDER=\"0\" CELLBORDER=\"1\" CELLSPACING=\"0\">"
+        print "    <TR><TD>Thread</TD></TR>"
+        print "    <TR><TD>" threads[tid] "</TD></TR>"
+        print "    </TABLE>"
+        print "  >];"
+
+        # Process pools in sequence
+        for (i = 1; i <= pool_count[tid]; i++) {
+            pool_addr = pool_sequence[tid, i]
+
+            print "  \"pool_" pool_addr "\" [shape=none,label=<"
+            print "    <TABLE BORDER=\"0\" CELLBORDER=\"1\" CELLSPACING=\"0\">"
+            print "    <TR><TD COLSPAN=\"2\">Pool " pool_addr "</TD></TR>"
+            print "    <TR><TD>Class</TD><TD>Address</TD></TR>"
+
+            for (obj_key in pool_objects) {
+                split(obj_key, obj_arr, SUBSEP)
+                if (obj_arr[1] == pool_addr) {
+                    print "    <TR><TD>" pool_objects[obj_key] "</TD><TD PORT=\"" obj_arr[2] "\">" obj_arr[2] "</TD></TR>"
+                }
+            }
+            print "    </TABLE>"
+            print "  >];"
+
+            # Connect pools in sequence
+            if (i == 1) {
+                print "  \"thread_" tid "\" -> \"pool_" pool_addr "\";"
+            } else {
+                prev_pool = pool_sequence[tid, i-1]
+                print "  \"pool_" prev_pool "\" -> \"pool_" pool_addr "\";"
+            }
+        }
+    }
+
+    # Create objects table
+    print "  objects [shape=none,label=<"
+    print "    <TABLE BORDER=\"0\" CELLBORDER=\"1\" CELLSPACING=\"0\">"
+    print "    <TR><TD COLSPAN=\"3\">Objects</TD></TR>"
+    print "    <TR><TD>Address</TD><TD>Class</TD><TD>RC</TD></TR>"
+
+    n = asorti(all_objects, sorted_addrs)
+    for (i = 1; i <= n; i++) {
+        addr = sorted_addrs[i]
+        print "    <TR><TD PORT=\"" addr "\">" addr "</TD><TD>" all_objects[addr] "</TD><TD>" retain_counts[addr] "</TD></TR>"
+    }
+    print "    </TABLE>"
+    print "  >];"
+
+    # Create edges from pools to objects only if they are in the global objects table
+    for (key in pool_objects) {
+        split(key, arr, SUBSEP)
+        pool_addr = arr[1]
+        obj_addr = arr[2]
+        if (retain_counts[obj_addr] > 1) {
+            print "  \"pool_" pool_addr "\":\"" obj_addr "\" -> \"objects\":\"" obj_addr "\";"
+        }
+    }
+    
+    print "}"
+}
diff --git a/test/NSAutoreleasePool/pooldump.m b/test/NSAutoreleasePool/pooldump.m
new file mode 100644
index 00000000..cd2e223a
--- /dev/null
+++ b/test/NSAutoreleasePool/pooldump.m
@@ -0,0 +1,105 @@
+#ifndef __MULLE_OBJC__
+# import <Foundation/Foundation.h>
+# pragma message "this test does not work with Apple Foundation"
+#else
+# import <MulleObjC/MulleObjC.h>
+#endif
+
+
+@interface Foo : NSObject
+{
+   char   _mulleNameUTF8String[ 32];
+}
+
+@property( dynamic, assign) char   *mulleNameUTF8String  MULLE_OBJC_THREADSAFE_PROPERTY;
+
+@end
+
+
+
+@implementation NSInvocation( Squelch)
+
+- (char *) mulleNameUTF8String  MULLE_OBJC_THREADSAFE_PROPERTY
+{
+   return( "unnamed");
+}
+
+@end
+
+
+
+@implementation Foo
+
++ (instancetype) objectWithNameUTF8String:(char *) s
+{
+   Foo  *obj;
+
+   obj = [Foo alloc];
+   obj = [obj init];
+   strncpy( obj->_mulleNameUTF8String, s ? s : "", sizeof( obj->_mulleNameUTF8String) - 1);
+   obj = [obj autorelease];
+   return( obj);
+}
+
+
+
+- (char *) mulleNameUTF8String
+{
+   if( ! _mulleNameUTF8String[ 0])
+      mulle_snprintf( _mulleNameUTF8String, sizeof( _mulleNameUTF8String), "%p", self);
+   return( &_mulleNameUTF8String[ 0]);
+}
+
+
+- (void) mulleSetNameUTF8String:(char *) s
+{
+   strncpy( _mulleNameUTF8String, s ? s : "", sizeof( _mulleNameUTF8String) - 1);
+}
+
+
+@end
+
+
+
+static int   test( NSThread *thread, id unused)
+{
+   Foo  *b;
+
+   [[NSAutoreleasePool mulleDefaultAutoreleasePool] mulleSetNameUTF8String:"thread root"];
+   b = [Foo objectWithNameUTF8String:"b"];  // place an object there
+
+   @autoreleasepool
+   {
+      // place b also here again, twice
+      [[b retain] autorelease];
+      [[b retain] autorelease];
+
+      [[NSAutoreleasePool mulleDefaultAutoreleasePool] mulleSetNameUTF8String:"thread inner"];
+      [Foo objectWithNameUTF8String:"c"];  // place an object there
+
+      // now dump all to standard out
+      MulleObjCDumpAutoreleasePoolsToFILEWithOptions( stdout, 0x1);
+   }
+   return( 0);
+}
+
+
+
+int  main()
+{
+   NSThread   *thread;
+   Class      cls;
+
+   [[NSAutoreleasePool mulleDefaultAutoreleasePool] mulleSetNameUTF8String:"main root"];
+   [Foo objectWithNameUTF8String:"a"];  // place an object there
+
+   cls    = [Foo class];
+   thread = [NSThread instantiate];
+   thread = [thread mulleInitWithObjectFunction:test
+                                         object:nil];
+   [thread mulleSetNameUTF8String:"test-thread"];
+   [thread mulleStart];
+   [thread mulleJoin];
+
+   return( 0);
+}
diff --git a/test/NSAutoreleasePool/pooldump.sh b/test/NSAutoreleasePool/pooldump.sh
new file mode 100755
index 00000000..f213961a
--- /dev/null
+++ b/test/NSAutoreleasePool/pooldump.sh
@@ -0,0 +1,6 @@
+#! /bin/sh
+
+./pooldump-dot.awk "$1.csv" > "$1.dot" \
+&& dot -Tsvg "$1.dot" -o "$1.svg" \
+&& xdg-open "$1.svg"
+
diff --git a/test/NSAutoreleasePool/pooldump.stdout b/test/NSAutoreleasePool/pooldump.stdout
new file mode 100644
index 00000000..dccba650
--- /dev/null
+++ b/test/NSAutoreleasePool/pooldump.stdout
@@ -0,0 +1,7 @@
+thread_id,thread,pool_id,pool,object_id,object,class,rc
+0,"NSMainThread",0,"main root",0,"a","Foo",1
+0,"NSMainThread",0,"main root",1,"test-thread","NSThread",2
+1,"test-thread",1,"thread inner",2,"b","Foo",3
+1,"test-thread",1,"thread inner",2,"b","Foo",3
+1,"test-thread",1,"thread inner",3,"c","Foo",1
+1,"test-thread",0,"thread root",2,"b","Foo",3
diff --git a/test/NSAutoreleasePool/pooldump_script.sql b/test/NSAutoreleasePool/pooldump_script.sql
new file mode 100644
index 00000000..a5738fa4
--- /dev/null
+++ b/test/NSAutoreleasePool/pooldump_script.sql
@@ -0,0 +1,28 @@
+.mode csv
+.import 'pooldump.stdout' data
+.headers on
+
+CREATE TABLE NSThread AS
+SELECT DISTINCT thread_id, thread AS thread_name
+FROM data;
+
+CREATE TABLE NSAutoreleasePool AS
+SELECT DISTINCT pool_id, pool AS pool_name, thread_id
+FROM data;
+
+CREATE TABLE pool_objects AS
+SELECT DISTINCT pool_id, thread_id, object_id
+FROM data;
+
+CREATE TABLE objects AS
+SELECT
+    object_id,
+    object AS object_name,
+    class AS class_name,
+    rc AS retain_count,
+    (SELECT COUNT(*) FROM data AS d WHERE d.object_id = data.object_id) AS pool_count
+FROM
+    data
+GROUP BY
+    object_id, object, class, rc;
+
diff --git a/test/NSThread/cfunction.m b/test/NSThread/cfunction.m
new file mode 100644
index 00000000..6410c550
--- /dev/null
+++ b/test/NSThread/cfunction.m
@@ -0,0 +1,31 @@
+#ifndef __MULLE_OBJC__
+# import <Foundation/Foundation.h>
+# pragma message "this test does not work with Apple Foundation"
+#else
+# import <MulleObjC/MulleObjC.h>
+#endif
+
+
+static int   threadFunction( NSThread *thread, void *text)
+{
+   mulle_printf( "%s\n", text);
+   return( 0);
+}
+
+
+int   main( void)
+{
+   NSThread   *thread;
+
+   threadFunction( nil, "a");
+
+   thread = [[NSThread alloc] mulleInitWithFunction:threadFunction
+                                           argument:"b"];
+   [thread mulleStart];
+   [thread mulleJoin];
+   [thread release];
+
+   threadFunction( nil, "c");
+
+   return( 0);
+}
diff --git a/test/NSThread/cfunction.stdout b/test/NSThread/cfunction.stdout
new file mode 100644
index 00000000..de980441
--- /dev/null
+++ b/test/NSThread/cfunction.stdout
@@ -0,0 +1,3 @@
+a
+b
+c
diff --git a/test/NSThread/detached.m b/test/NSThread/detached.m
index 95a34f36..34d61de0 100644
--- a/test/NSThread/detached.m
+++ b/test/NSThread/detached.m
@@ -12,10 +12,11 @@ @interface Foo : NSObject
 
 @implementation Foo
 
-+ (void) function:(id) arg
++ (void) method:(id) arg
 {
-   [[NSObject new] autorelease];
-   printf( "%s\n", __PRETTY_FUNCTION__);
+   [Foo object]; // create an object for leak test
+   mulle_printf( "%s\n", __PRETTY_FUNCTION__);
+   MulleObjCDumpAutoreleasePoolsFrame();
 }
 
 @end
@@ -25,13 +26,13 @@ int main( void)
 {
    NSThread    *thread;
 
-   [NSThread detachNewThreadSelector:@selector( function:)
-                            toTarget:[Foo class]
-                          withObject:nil];
-
-   // as we are running this in a test, it should be with
-   // pedantic exit, so the universe will wait for the other thread
-   // to finish...
-
+   @autoreleasepool
+   {
+      [NSThread mulleSetMainThreadWaitsAtExit:YES];  // ensure
+      [NSThread detachNewThreadSelector:@selector( method:)
+                               toTarget:[Foo class]
+                             withObject:nil];
+      MulleObjCDumpAutoreleasePoolsFrame();
+   }
    return( 0);
 }
diff --git a/test/NSThread/detached.stdout b/test/NSThread/detached.stdout
index c95bb390..729c8ec9 100644
--- a/test/NSThread/detached.stdout
+++ b/test/NSThread/detached.stdout
@@ -1 +1 @@
-+[Foo function:]
++[Foo method:]
diff --git a/test/NSThread/invokedonce.m b/test/NSThread/invokedonce.m
new file mode 100644
index 00000000..9f3c8821
--- /dev/null
+++ b/test/NSThread/invokedonce.m
@@ -0,0 +1,55 @@
+#ifndef __MULLE_OBJC__
+# import <Foundation/Foundation.h>
+# pragma message "this test does not work with Apple Foundation"
+#else
+# import <MulleObjC/MulleObjC.h>
+#endif
+
+
+//
+// just checking what happens if a NSThread is started but never joined
+//
+@interface Foo : NSObject
+@end
+
+
+@implementation Foo
+
+- (id) method:(id) arg
+{
+   mulle_printf( "%s\n", __PRETTY_FUNCTION__);
+   return( nil);
+}
+
+@end
+
+//
+@interface Bar : NSObject
+@end
+
+
+@implementation Bar
+@end
+
+
+int main( void)
+{
+   Foo        *foo;
+   Bar        *bar;
+   NSThread   *thread;
+
+   [NSThread mulleSetMainThreadWaitsAtExit:YES];
+
+   @autoreleasepool
+   {
+      foo = [Foo object];
+      bar = [Bar object];
+
+      thread = [[[NSThread alloc] initWithTarget:foo
+                                        selector:@selector( method:)
+                                          object:bar] autorelease];
+      [thread mulleStart];
+   }
+
+   return( 0);
+}
diff --git a/test/NSThread/invokedonce.stdout b/test/NSThread/invokedonce.stdout
new file mode 100644
index 00000000..dee14dae
--- /dev/null
+++ b/test/NSThread/invokedonce.stdout
@@ -0,0 +1 @@
+-[Foo method:]
diff --git a/test/NSThread/neverinvoked.m b/test/NSThread/neverinvoked.m
new file mode 100644
index 00000000..9343eb3e
--- /dev/null
+++ b/test/NSThread/neverinvoked.m
@@ -0,0 +1,52 @@
+#ifndef __MULLE_OBJC__
+# import <Foundation/Foundation.h>
+# pragma message "this test does not work with Apple Foundation"
+#else
+# import <MulleObjC/MulleObjC.h>
+#endif
+
+
+//
+// just checking what happens if a NSThread is never called
+//
+@interface Foo : NSObject
+@end
+
+
+@implementation Foo
+
+- (id) function:(id) arg
+{
+   printf( "%s\n", __PRETTY_FUNCTION__);
+   return( nil);
+}
+
+@end
+
+//
+@interface Bar : NSObject
+@end
+
+
+@implementation Bar
+@end
+
+
+int main( void)
+{
+   Foo        *foo;
+   Bar        *bar;
+   NSThread   *thread;
+
+   foo = [Foo object];
+   bar = [Bar object];
+
+   @autoreleasepool
+   {
+      thread = [[[NSThread alloc] initWithTarget:foo
+                                        selector:@selector( function:)
+                                          object:bar] autorelease];
+   }
+
+   return( 0);
+}
diff --git a/test/NSThread/objectfunction.m b/test/NSThread/objectfunction.m
new file mode 100644
index 00000000..9a544fe0
--- /dev/null
+++ b/test/NSThread/objectfunction.m
@@ -0,0 +1,47 @@
+#ifndef __MULLE_OBJC__
+# import <Foundation/Foundation.h>
+# pragma message "this test does not work with Apple Foundation"
+#else
+# import <MulleObjC/MulleObjC.h>
+#endif
+
+
+@interface Foo : NSObject
+@end
+
+
+@implementation Foo
+
+- (char *) UTF8String
+{
+   return( "Foo");
+}
+
+@end
+
+static int   threadFunction( NSThread *thread, id obj)
+{
+   mulle_printf( "%@\n", obj);
+   return( 0);
+}
+
+
+int   main( void)
+{
+   NSThread   *thread;
+   Foo        *obj;
+
+   obj    = [Foo object];
+
+   threadFunction( nil, obj);
+
+   thread = [[NSThread alloc] mulleInitWithObjectFunction:threadFunction
+                                                   object:obj];
+   [thread mulleStart];
+   [thread mulleJoin];
+   [thread release];
+
+   threadFunction( nil, obj);
+
+   return( 0);
+}
diff --git a/test/NSThread/objectfunction.stdout b/test/NSThread/objectfunction.stdout
new file mode 100644
index 00000000..1d6a8513
--- /dev/null
+++ b/test/NSThread/objectfunction.stdout
@@ -0,0 +1,3 @@
+Foo
+Foo
+Foo
diff --git a/test/TAO/README.md b/test/TAO/README.md
new file mode 100644
index 00000000..cd18620c
--- /dev/null
+++ b/test/TAO/README.md
@@ -0,0 +1,10 @@
+# TAO Strategy
+
+These tests show a value being passed from
+
+* caller to thread: `forward`
+* thread to caller: `backward` (using NSInvocation)
+* transfering ownership back and forth: `backandforth` using
+
+
+Ownership transfer backwards can not be done with detached threads.
diff --git a/test/TAO/backandforth/README.md b/test/TAO/backandforth/README.md
new file mode 100644
index 00000000..e417d8ef
--- /dev/null
+++ b/test/TAO/backandforth/README.md
@@ -0,0 +1 @@
+These tests just see an object passed back and forth between two threads.
diff --git a/test/TAO/backandforth/TAOStrategyTest.inc b/test/TAO/backandforth/TAOStrategyTest.inc
new file mode 100644
index 00000000..5780deda
--- /dev/null
+++ b/test/TAO/backandforth/TAOStrategyTest.inc
@@ -0,0 +1,72 @@
+#import <MulleObjC/MulleObjC.h>
+
+
+#define __THREAD_NAME__  [MulleThreadGetCurrentThread() mulleNameUTF8String]
+
+#ifndef TEST_PROTOCOLS
+# define TEST_PROTOCOLS
+#endif
+
+@interface Foo : NSObject  TEST_PROTOCOLS
+@end
+
+
+@implementation Foo
+
+- (MulleObjCTAOStrategy) mulleTAOStrategy MULLE_OBJC_THREADSAFE_METHOD
+{
+   return( TEST_TAO_STRATEGY);
+}
+
+
+- (void) release
+{
+   mulle_printf( "%s - -: %s %td -> %td\n", __THREAD_NAME__, __PRETTY_FUNCTION__, [self retainCount], [self retainCount] - 1);
+   [super release];
+}
+
+
+- (id) retain
+{
+   mulle_printf( "%s - +: %s %td -> %td\n", __THREAD_NAME__,__PRETTY_FUNCTION__, [self retainCount], [self retainCount] + 1);
+   [super retain];
+   return( self);
+}
+
+
+- (id) autorelease
+{
+   mulle_printf( "%s - a: %s %td\n", __THREAD_NAME__,__PRETTY_FUNCTION__, [self retainCount]);
+   return( [super autorelease]);
+}
+
+
+
+- (void) dealloc
+{
+   mulle_printf( "%s - d: %s %td\n", __THREAD_NAME__, __PRETTY_FUNCTION__, [self retainCount]);
+   [super dealloc];
+}
+
+
+- (void) mulleGainAccess
+{
+   [super mulleGainAccess];
+   mulle_printf( "%s - g: %s %td\n", __THREAD_NAME__,__PRETTY_FUNCTION__, [self retainCount]);
+}
+
+
+- (void) mulleRelinquishAccess
+{
+   [super mulleRelinquishAccess];
+   mulle_printf( "%s - q: %s %td\n", __THREAD_NAME__,__PRETTY_FUNCTION__, [self retainCount]);
+}
+
+@end
+
+
+static int   thread_function( NSThread *thread, id obj)
+{
+   mulle_printf( "%s - 3: %s %td\n", __THREAD_NAME__, __PRETTY_FUNCTION__, [obj retainCount]);
+   return( 0);
+}
diff --git a/test/TAO/backandforth/default.stdout b/test/TAO/backandforth/default.stdout
new file mode 100644
index 00000000..e69de29b
diff --git a/test/TAO/backandforth/performsfinalize.m b/test/TAO/backandforth/performsfinalize.m
new file mode 100644
index 00000000..d738737a
--- /dev/null
+++ b/test/TAO/backandforth/performsfinalize.m
@@ -0,0 +1,37 @@
+#define TEST_TAO_STRATEGY   MulleObjCTAOReceiverPerformsFinalize
+
+#include "TAOStrategyTest.inc"
+
+
+int   main( int argc, const char * argv[])
+{
+   NSThread    *thread;
+   Foo         *obj;
+
+#ifdef __MULLE_OBJC__
+   if( mulle_objc_global_check_universe( __MULLE_OBJC_UNIVERSENAME__) != mulle_objc_universe_is_ok)
+      return( 1);
+#endif
+
+   [[NSThread currentThread] mulleSetNameUTF8String:"#1"];
+
+   @autoreleasepool
+   {
+      obj    = [Foo object];
+      mulle_printf( "%s - 1: %s %td\n", __THREAD_NAME__, __PRETTY_FUNCTION__, [obj retainCount]);
+
+      thread = [NSThread alloc];
+      [thread mulleSetNameUTF8String:"#2"];
+      thread = [thread mulleInitWithObjectFunction:thread_function
+                                            object:obj];
+      thread = [thread autorelease];
+
+      mulle_printf( "%s - 2: %s %td\n", __THREAD_NAME__, __PRETTY_FUNCTION__, [obj retainCount]);
+      [thread mulleStart];
+      mulle_relativetime_sleep( 0.2); // just get sequencing nicer for test output
+      mulle_printf( "%s - 4: %s %td\n", __THREAD_NAME__, __PRETTY_FUNCTION__, [obj retainCount]);
+      [thread mulleJoin];
+      mulle_printf( "%s - 5: %s %td\n", __THREAD_NAME__, __PRETTY_FUNCTION__, [obj retainCount]);
+   }
+   return( 0);
+}
diff --git a/test/TAO/backandforth/performsfinalize.stdout b/test/TAO/backandforth/performsfinalize.stdout
new file mode 100644
index 00000000..97c1e5cb
--- /dev/null
+++ b/test/TAO/backandforth/performsfinalize.stdout
@@ -0,0 +1,21 @@
+#1 - a: -[Foo autorelease] 1
+#1 - 1: int main(int, const char **) 1
+#1 - +: -[Foo retain] 1 -> 2
+#1 - 2: int main(int, const char **) 2
+#1 - +: -[Foo retain] 2 -> 3
+#1 - q: -[Foo mulleRelinquishAccess] 3
+#2 - a: -[Foo autorelease] 3
+#2 - g: -[Foo mulleGainAccess] 3
+#2 - 3: int thread_function(NSThread *, id) 3
+#2 - +: -[Foo retain] 3 -> 4
+#2 - q: -[Foo mulleRelinquishAccess] 4
+#2 - -: -[Foo release] 4 -> 3
+#1 - 4: int main(int, const char **) 3
+#1 - a: -[Foo autorelease] 3
+#1 - g: -[Foo mulleGainAccess] 3
+#1 - a: -[Foo autorelease] 3
+#1 - 5: int main(int, const char **) 3
+#1 - -: -[Foo release] 3 -> 2
+#1 - -: -[Foo release] 2 -> 1
+#1 - -: -[Foo release] 1 -> 0
+#1 - d: -[Foo dealloc] 0
diff --git a/test/TAO/backandforth/removefromallpools.m b/test/TAO/backandforth/removefromallpools.m
new file mode 100644
index 00000000..9ba9af87
--- /dev/null
+++ b/test/TAO/backandforth/removefromallpools.m
@@ -0,0 +1,45 @@
+#define TEST_TAO_STRATEGY   MulleObjCTAOCallerRemovesFromAllPools
+
+#include "TAOStrategyTest.inc"
+
+
+int   main( int argc, const char * argv[])
+{
+   NSThread    *thread;
+   Foo         *obj;
+
+#ifdef __MULLE_OBJC__
+   if( mulle_objc_global_check_universe( __MULLE_OBJC_UNIVERSENAME__) != mulle_objc_universe_is_ok)
+      return( 1);
+#endif
+
+   [[NSThread currentThread] mulleSetNameUTF8String:"#1"];
+
+   @autoreleasepool
+   {
+      obj = [Foo object];
+      mulle_printf( "%s - 1: %s %td\n", __THREAD_NAME__, __PRETTY_FUNCTION__, [obj retainCount]);
+
+      @autoreleasepool
+      {
+         thread = [NSThread alloc];
+         [thread mulleSetNameUTF8String:"#2"];
+         thread = [thread mulleInitWithObjectFunction:thread_function
+                                               object:obj];
+         thread = [thread autorelease];
+
+         mulle_printf( "%s - 2: %s %td\n", __THREAD_NAME__, __PRETTY_FUNCTION__, [obj retainCount]);
+         [thread mulleStart];
+         mulle_relativetime_sleep( 0.2); // just get sequencing nicer for test output
+         mulle_printf( "%s - 4: %s %td\n", __THREAD_NAME__, __PRETTY_FUNCTION__, [obj retainCount]);
+         [thread mulleJoin];
+         mulle_printf( "%s - 5: %s %td\n", __THREAD_NAME__, __PRETTY_FUNCTION__, [obj retainCount]);
+
+         // clumsy
+         [obj retain];
+      }
+      [obj autorelease];
+      mulle_printf( "%s - 6: %s %td\n", __THREAD_NAME__, __PRETTY_FUNCTION__, [obj retainCount]);
+   }
+   return( 0);
+}
diff --git a/test/TAO/backandforth/removefromallpools.stdout b/test/TAO/backandforth/removefromallpools.stdout
new file mode 100644
index 00000000..e3bc3966
--- /dev/null
+++ b/test/TAO/backandforth/removefromallpools.stdout
@@ -0,0 +1,23 @@
+#1 - a: -[Foo autorelease] 1
+#1 - 1: int main(int, const char **) 1
+#1 - +: -[Foo retain] 1 -> 2
+#1 - 2: int main(int, const char **) 2
+#1 - +: -[Foo retain] 2 -> 3
+#1 - q: -[Foo mulleRelinquishAccess] 2
+#2 - a: -[Foo autorelease] 2
+#2 - g: -[Foo mulleGainAccess] 2
+#2 - 3: int thread_function(NSThread *, id) 2
+#2 - +: -[Foo retain] 2 -> 3
+#2 - q: -[Foo mulleRelinquishAccess] 2
+#1 - 4: int main(int, const char **) 2
+#1 - a: -[Foo autorelease] 2
+#1 - g: -[Foo mulleGainAccess] 2
+#1 - a: -[Foo autorelease] 2
+#1 - 5: int main(int, const char **) 2
+#1 - +: -[Foo retain] 2 -> 3
+#1 - -: -[Foo release] 3 -> 2
+#1 - -: -[Foo release] 2 -> 1
+#1 - a: -[Foo autorelease] 1
+#1 - 6: int main(int, const char **) 1
+#1 - -: -[Foo release] 1 -> 0
+#1 - d: -[Foo dealloc] 0
diff --git a/test/TAO/backandforth/removefromcurrent.m b/test/TAO/backandforth/removefromcurrent.m
new file mode 100644
index 00000000..6004a27e
--- /dev/null
+++ b/test/TAO/backandforth/removefromcurrent.m
@@ -0,0 +1,37 @@
+#define TEST_TAO_STRATEGY   MulleObjCTAOCallerRemovesFromCurrentPool
+
+#include "TAOStrategyTest.inc"
+
+
+int   main( int argc, const char * argv[])
+{
+   NSThread    *thread;
+   Foo         *obj;
+
+#ifdef __MULLE_OBJC__
+   if( mulle_objc_global_check_universe( __MULLE_OBJC_UNIVERSENAME__) != mulle_objc_universe_is_ok)
+      return( 1);
+#endif
+
+   [[NSThread currentThread] mulleSetNameUTF8String:"#1"];
+
+   @autoreleasepool
+   {
+      obj    = [Foo object];
+      mulle_printf( "%s - 1: %s %td\n", __THREAD_NAME__, __PRETTY_FUNCTION__, [obj retainCount]);
+
+      thread = [NSThread alloc];
+      [thread mulleSetNameUTF8String:"#2"];
+      thread = [thread mulleInitWithObjectFunction:thread_function
+                                            object:obj];
+      thread = [thread autorelease];
+
+      mulle_printf( "%s - 2: %s %td\n", __THREAD_NAME__, __PRETTY_FUNCTION__, [obj retainCount]);
+      [thread mulleStart];
+      mulle_relativetime_sleep( 0.2); // just get sequencing nicer for test output
+      mulle_printf( "%s - 4: %s %td\n", __THREAD_NAME__, __PRETTY_FUNCTION__, [obj retainCount]);
+      [thread mulleJoin];
+      mulle_printf( "%s - 5: %s %td\n", __THREAD_NAME__, __PRETTY_FUNCTION__, [obj retainCount]);
+   }
+   return( 0);
+}
diff --git a/test/TAO/backandforth/removefromcurrent.stdout b/test/TAO/backandforth/removefromcurrent.stdout
new file mode 100644
index 00000000..1ccb33e9
--- /dev/null
+++ b/test/TAO/backandforth/removefromcurrent.stdout
@@ -0,0 +1,19 @@
+#1 - a: -[Foo autorelease] 1
+#1 - 1: int main(int, const char **) 1
+#1 - +: -[Foo retain] 1 -> 2
+#1 - 2: int main(int, const char **) 2
+#1 - +: -[Foo retain] 2 -> 3
+#1 - q: -[Foo mulleRelinquishAccess] 2
+#2 - a: -[Foo autorelease] 2
+#2 - g: -[Foo mulleGainAccess] 2
+#2 - 3: int thread_function(NSThread *, id) 2
+#2 - +: -[Foo retain] 2 -> 3
+#2 - q: -[Foo mulleRelinquishAccess] 2
+#1 - 4: int main(int, const char **) 2
+#1 - a: -[Foo autorelease] 2
+#1 - g: -[Foo mulleGainAccess] 2
+#1 - a: -[Foo autorelease] 2
+#1 - 5: int main(int, const char **) 2
+#1 - -: -[Foo release] 2 -> 1
+#1 - -: -[Foo release] 1 -> 0
+#1 - d: -[Foo dealloc] 0
diff --git a/test/TAO/backandforth/removefrompool.stdout b/test/TAO/backandforth/removefrompool.stdout
new file mode 100644
index 00000000..97c1e5cb
--- /dev/null
+++ b/test/TAO/backandforth/removefrompool.stdout
@@ -0,0 +1,21 @@
+#1 - a: -[Foo autorelease] 1
+#1 - 1: int main(int, const char **) 1
+#1 - +: -[Foo retain] 1 -> 2
+#1 - 2: int main(int, const char **) 2
+#1 - +: -[Foo retain] 2 -> 3
+#1 - q: -[Foo mulleRelinquishAccess] 3
+#2 - a: -[Foo autorelease] 3
+#2 - g: -[Foo mulleGainAccess] 3
+#2 - 3: int thread_function(NSThread *, id) 3
+#2 - +: -[Foo retain] 3 -> 4
+#2 - q: -[Foo mulleRelinquishAccess] 4
+#2 - -: -[Foo release] 4 -> 3
+#1 - 4: int main(int, const char **) 3
+#1 - a: -[Foo autorelease] 3
+#1 - g: -[Foo mulleGainAccess] 3
+#1 - a: -[Foo autorelease] 3
+#1 - 5: int main(int, const char **) 3
+#1 - -: -[Foo release] 3 -> 2
+#1 - -: -[Foo release] 2 -> 1
+#1 - -: -[Foo release] 1 -> 0
+#1 - d: -[Foo dealloc] 0
diff --git a/test/TAO/backandforth/threadsafe.m b/test/TAO/backandforth/threadsafe.m
new file mode 100644
index 00000000..845aa306
--- /dev/null
+++ b/test/TAO/backandforth/threadsafe.m
@@ -0,0 +1,38 @@
+#define TEST_TAO_STRATEGY   MulleObjCTAOKnownThreadSafe
+#define TEST_PROTOCOLS      < MulleObjCThreadSafe>
+
+#include "TAOStrategyTest.inc"
+
+
+int   main( int argc, const char * argv[])
+{
+   NSThread    *thread;
+   Foo         *obj;
+
+#ifdef __MULLE_OBJC__
+   if( mulle_objc_global_check_universe( __MULLE_OBJC_UNIVERSENAME__) != mulle_objc_universe_is_ok)
+      return( 1);
+#endif
+
+   [[NSThread currentThread] mulleSetNameUTF8String:"#1"];
+
+   @autoreleasepool
+   {
+      obj    = [Foo object];
+      mulle_printf( "%s - 1: %s %td\n", __THREAD_NAME__, __PRETTY_FUNCTION__, [obj retainCount]);
+
+      thread = [NSThread alloc];
+      [thread mulleSetNameUTF8String:"#2"];
+      thread = [thread mulleInitWithObjectFunction:thread_function
+                                            object:obj];
+      thread = [thread autorelease];
+
+      mulle_printf( "%s - 2: %s %td\n", __THREAD_NAME__, __PRETTY_FUNCTION__, [obj retainCount]);
+      [thread mulleStart];
+      mulle_relativetime_sleep( 0.2); // just get sequencing nicer for test output
+      mulle_printf( "%s - 4: %s %td\n", __THREAD_NAME__, __PRETTY_FUNCTION__, [obj retainCount]);
+      [thread mulleJoin];
+      mulle_printf( "%s - 5: %s %td\n", __THREAD_NAME__, __PRETTY_FUNCTION__, [obj retainCount]);
+   }
+   return( 0);
+}
diff --git a/test/TAO/backandforth/threadsafe.stdout b/test/TAO/backandforth/threadsafe.stdout
new file mode 100644
index 00000000..97c1e5cb
--- /dev/null
+++ b/test/TAO/backandforth/threadsafe.stdout
@@ -0,0 +1,21 @@
+#1 - a: -[Foo autorelease] 1
+#1 - 1: int main(int, const char **) 1
+#1 - +: -[Foo retain] 1 -> 2
+#1 - 2: int main(int, const char **) 2
+#1 - +: -[Foo retain] 2 -> 3
+#1 - q: -[Foo mulleRelinquishAccess] 3
+#2 - a: -[Foo autorelease] 3
+#2 - g: -[Foo mulleGainAccess] 3
+#2 - 3: int thread_function(NSThread *, id) 3
+#2 - +: -[Foo retain] 3 -> 4
+#2 - q: -[Foo mulleRelinquishAccess] 4
+#2 - -: -[Foo release] 4 -> 3
+#1 - 4: int main(int, const char **) 3
+#1 - a: -[Foo autorelease] 3
+#1 - g: -[Foo mulleGainAccess] 3
+#1 - a: -[Foo autorelease] 3
+#1 - 5: int main(int, const char **) 3
+#1 - -: -[Foo release] 3 -> 2
+#1 - -: -[Foo release] 2 -> 1
+#1 - -: -[Foo release] 1 -> 0
+#1 - d: -[Foo dealloc] 0
diff --git a/test/TAO/backandforth/threadsafemethods.m b/test/TAO/backandforth/threadsafemethods.m
new file mode 100644
index 00000000..8d3d7ae7
--- /dev/null
+++ b/test/TAO/backandforth/threadsafemethods.m
@@ -0,0 +1,37 @@
+#define TEST_TAO_STRATEGY   MulleObjCTAOKnownThreadSafeMethods
+
+#include "TAOStrategyTest.inc"
+
+
+int   main( int argc, const char * argv[])
+{
+   NSThread    *thread;
+   Foo         *obj;
+
+#ifdef __MULLE_OBJC__
+   if( mulle_objc_global_check_universe( __MULLE_OBJC_UNIVERSENAME__) != mulle_objc_universe_is_ok)
+      return( 1);
+#endif
+
+   [[NSThread currentThread] mulleSetNameUTF8String:"#1"];
+
+   @autoreleasepool
+   {
+      obj    = [Foo object];
+      mulle_printf( "%s - 1: %s %td\n", __THREAD_NAME__, __PRETTY_FUNCTION__, [obj retainCount]);
+
+      thread = [NSThread alloc];
+      [thread mulleSetNameUTF8String:"#2"];
+      thread = [thread mulleInitWithObjectFunction:thread_function
+                                            object:obj];
+      thread = [thread autorelease];
+
+      mulle_printf( "%s - 2: %s %td\n", __THREAD_NAME__, __PRETTY_FUNCTION__, [obj retainCount]);
+      [thread mulleStart];
+      mulle_relativetime_sleep( 0.2); // just get sequencing nicer for test output
+      mulle_printf( "%s - 4: %s %td\n", __THREAD_NAME__, __PRETTY_FUNCTION__, [obj retainCount]);
+      [thread mulleJoin];
+      mulle_printf( "%s - 5: %s %td\n", __THREAD_NAME__, __PRETTY_FUNCTION__, [obj retainCount]);
+   }
+   return( 0);
+}
diff --git a/test/TAO/backandforth/threadsafemethods.stdout b/test/TAO/backandforth/threadsafemethods.stdout
new file mode 100644
index 00000000..97c1e5cb
--- /dev/null
+++ b/test/TAO/backandforth/threadsafemethods.stdout
@@ -0,0 +1,21 @@
+#1 - a: -[Foo autorelease] 1
+#1 - 1: int main(int, const char **) 1
+#1 - +: -[Foo retain] 1 -> 2
+#1 - 2: int main(int, const char **) 2
+#1 - +: -[Foo retain] 2 -> 3
+#1 - q: -[Foo mulleRelinquishAccess] 3
+#2 - a: -[Foo autorelease] 3
+#2 - g: -[Foo mulleGainAccess] 3
+#2 - 3: int thread_function(NSThread *, id) 3
+#2 - +: -[Foo retain] 3 -> 4
+#2 - q: -[Foo mulleRelinquishAccess] 4
+#2 - -: -[Foo release] 4 -> 3
+#1 - 4: int main(int, const char **) 3
+#1 - a: -[Foo autorelease] 3
+#1 - g: -[Foo mulleGainAccess] 3
+#1 - a: -[Foo autorelease] 3
+#1 - 5: int main(int, const char **) 3
+#1 - -: -[Foo release] 3 -> 2
+#1 - -: -[Foo release] 2 -> 1
+#1 - -: -[Foo release] 1 -> 0
+#1 - d: -[Foo dealloc] 0
diff --git a/test/TAO/backward/README.md b/test/TAO/backward/README.md
new file mode 100644
index 00000000..e417d8ef
--- /dev/null
+++ b/test/TAO/backward/README.md
@@ -0,0 +1 @@
+These tests just see an object passed back and forth between two threads.
diff --git a/test/TAO/backward/TAOStrategyTest2.inc b/test/TAO/backward/TAOStrategyTest2.inc
new file mode 100644
index 00000000..0d522b1c
--- /dev/null
+++ b/test/TAO/backward/TAOStrategyTest2.inc
@@ -0,0 +1,87 @@
+#import <MulleObjC/MulleObjC.h>
+
+
+#define __THREAD_NAME__  [MulleThreadGetCurrentThread() mulleNameUTF8String]
+
+#ifndef TEST_PROTOCOLS
+# define TEST_PROTOCOLS
+#endif
+
+@interface Foo : NSObject  TEST_PROTOCOLS
+@end
+
+
+@implementation Foo
+
+- (MulleObjCTAOStrategy) mulleTAOStrategy MULLE_OBJC_THREADSAFE_METHOD
+{
+   return( TEST_TAO_STRATEGY);
+}
+
+
+- (void) release
+{
+   mulle_printf( "%s - -: %s %td -> %td\n", __THREAD_NAME__, __PRETTY_FUNCTION__, [self retainCount], [self retainCount] - 1);
+   [super release];
+}
+
+
+- (id) retain
+{
+   mulle_printf( "%s - +: %s %td -> %td\n", __THREAD_NAME__,__PRETTY_FUNCTION__, [self retainCount], [self retainCount] + 1);
+   [super retain];
+   return( self);
+}
+
+
+- (id) autorelease
+{
+   mulle_printf( "%s - a: %s %td\n", __THREAD_NAME__,__PRETTY_FUNCTION__, [self retainCount]);
+   return( [super autorelease]);
+}
+
+
+
+- (void) dealloc
+{
+   mulle_printf( "%s - d: %s %td\n", __THREAD_NAME__, __PRETTY_FUNCTION__, [self retainCount]);
+   [super dealloc];
+}
+
+
+- (void) mulleGainAccess
+{
+   [super mulleGainAccess];
+   mulle_printf( "%s - g: %s %td\n", __THREAD_NAME__,__PRETTY_FUNCTION__, [self retainCount]);
+}
+
+
+- (void) mulleRelinquishAccess
+{
+   [super mulleRelinquishAccess];
+   mulle_printf( "%s - q: %s %td\n", __THREAD_NAME__,__PRETTY_FUNCTION__, [self retainCount]);
+}
+
+@end
+
+
+@interface Receiver : NSObject
+
++ (Foo *) foo:(id) unused;
+
+@end
+
+
+@implementation Receiver
+
++ (Foo *) foo:(id) unused
+{
+   Foo   *obj;
+
+   obj = [Foo object];
+   mulle_printf( "%s - 1: %s %td\n", __THREAD_NAME__, __PRETTY_FUNCTION__, [obj retainCount]);
+   return( obj);
+}
+
+@end
+
diff --git a/test/TAO/backward/performsfinalize.m b/test/TAO/backward/performsfinalize.m
new file mode 100644
index 00000000..8caa588a
--- /dev/null
+++ b/test/TAO/backward/performsfinalize.m
@@ -0,0 +1,37 @@
+#define TEST_TAO_STRATEGY   MulleObjCTAOReceiverPerformsFinalize
+
+#include "TAOStrategyTest2.inc"
+
+
+int   main( int argc, const char * argv[])
+{
+   NSThread       *thread;
+   Foo            *obj;
+   NSInvocation   *invocation;
+
+#ifdef __MULLE_OBJC__
+   if( mulle_objc_global_check_universe( __MULLE_OBJC_UNIVERSENAME__) != mulle_objc_universe_is_ok)
+      return( 1);
+#endif
+
+   [[NSThread currentThread] mulleSetNameUTF8String:"#1"];
+
+   @autoreleasepool
+   {
+      thread = [NSThread alloc];
+      [thread mulleSetNameUTF8String:"#2"];
+      thread = [thread initWithTarget:[Receiver class]
+                          selector:@selector( foo:)
+                          object:nil];
+      thread = [thread autorelease];
+
+      mulle_printf( "%s - 1: %s\n", __THREAD_NAME__, __PRETTY_FUNCTION__);
+      [thread mulleStart];
+      mulle_relativetime_sleep( 0.2); // just get sequencing nicer for test output
+      mulle_printf( "%s - 3: %s\n", __THREAD_NAME__, __PRETTY_FUNCTION__);
+      invocation = [thread mulleJoin];
+      [invocation getReturnValue:&obj];
+      mulle_printf( "%s - 4: %s %td\n", __THREAD_NAME__, __PRETTY_FUNCTION__, [obj retainCount]);
+   }
+   return( 0);
+}
diff --git a/test/TAO/backward/performsfinalize.stdout b/test/TAO/backward/performsfinalize.stdout
new file mode 100644
index 00000000..441f6526
--- /dev/null
+++ b/test/TAO/backward/performsfinalize.stdout
@@ -0,0 +1,12 @@
+#1 - 1: int main(int, const char **)
+#2 - a: -[Foo autorelease] 1
+#2 - 1: +[Receiver foo:] 1
+#2 - +: -[Foo retain] 1 -> 2
+#2 - q: -[Foo mulleRelinquishAccess] 2
+#2 - -: -[Foo release] 2 -> 1
+#1 - 3: int main(int, const char **)
+#1 - a: -[Foo autorelease] 1
+#1 - g: -[Foo mulleGainAccess] 1
+#1 - 4: int main(int, const char **) 1
+#1 - -: -[Foo release] 1 -> 0
+#1 - d: -[Foo dealloc] 0
diff --git a/test/TAO/backward/removefromallpools.m b/test/TAO/backward/removefromallpools.m
new file mode 100644
index 00000000..5ab75c92
--- /dev/null
+++ b/test/TAO/backward/removefromallpools.m
@@ -0,0 +1,44 @@
+#define TEST_TAO_STRATEGY   MulleObjCTAOCallerRemovesFromAllPools
+
+#include "TAOStrategyTest2.inc"
+
+
+int   main( int argc, const char * argv[])
+{
+   NSThread       *thread;
+   Foo            *obj;
+   NSInvocation   *invocation;
+
+#ifdef __MULLE_OBJC__
+   if( mulle_objc_global_check_universe( __MULLE_OBJC_UNIVERSENAME__) != mulle_objc_universe_is_ok)
+      return( 1);
+#endif
+
+   [[NSThread currentThread] mulleSetNameUTF8String:"#1"];
+
+   @autoreleasepool
+   {
+      @autoreleasepool
+      {
+         thread = [NSThread alloc];
+         [thread mulleSetNameUTF8String:"#2"];
+         thread = [thread initWithTarget:[Receiver class]
+                             selector:@selector( foo:)
+                             object:nil];
+         thread = [thread autorelease];
+
+         mulle_printf( "%s - 1: %s\n", __THREAD_NAME__, __PRETTY_FUNCTION__);
+         [thread mulleStart];
+         mulle_relativetime_sleep( 0.2); // just get sequencing nicer for test output
+         mulle_printf( "%s - 3: %s\n", __THREAD_NAME__, __PRETTY_FUNCTION__);
+         invocation = [thread mulleJoin];
+         [invocation getReturnValue:&obj];
+         mulle_printf( "%s - 4: %s %td\n", __THREAD_NAME__, __PRETTY_FUNCTION__, [obj retainCount]);
+         // clumsy (and pointless in this case)
+         [obj retain];
+      }
+      [obj autorelease];
+      mulle_printf( "%s - 5: %s %td\n", __THREAD_NAME__, __PRETTY_FUNCTION__, [obj retainCount]);
+   }
+   return( 0);
+}
diff --git a/test/TAO/backward/removefromallpools.stdout b/test/TAO/backward/removefromallpools.stdout
new file mode 100644
index 00000000..dd98c340
--- /dev/null
+++ b/test/TAO/backward/removefromallpools.stdout
@@ -0,0 +1,15 @@
+#1 - 1: int main(int, const char **)
+#2 - a: -[Foo autorelease] 1
+#2 - 1: +[Receiver foo:] 1
+#2 - +: -[Foo retain] 1 -> 2
+#2 - q: -[Foo mulleRelinquishAccess] 1
+#1 - 3: int main(int, const char **)
+#1 - a: -[Foo autorelease] 1
+#1 - g: -[Foo mulleGainAccess] 1
+#1 - 4: int main(int, const char **) 1
+#1 - +: -[Foo retain] 1 -> 2
+#1 - -: -[Foo release] 2 -> 1
+#1 - a: -[Foo autorelease] 1
+#1 - 5: int main(int, const char **) 1
+#1 - -: -[Foo release] 1 -> 0
+#1 - d: -[Foo dealloc] 0
diff --git a/test/TAO/backward/removefromcurrent.m b/test/TAO/backward/removefromcurrent.m
new file mode 100644
index 00000000..ce240a2f
--- /dev/null
+++ b/test/TAO/backward/removefromcurrent.m
@@ -0,0 +1,37 @@
+#define TEST_TAO_STRATEGY   MulleObjCTAOCallerRemovesFromCurrentPool
+
+#include "TAOStrategyTest2.inc"
+
+
+int   main( int argc, const char * argv[])
+{
+   NSThread       *thread;
+   Foo            *obj;
+   NSInvocation   *invocation;
+
+#ifdef __MULLE_OBJC__
+   if( mulle_objc_global_check_universe( __MULLE_OBJC_UNIVERSENAME__) != mulle_objc_universe_is_ok)
+      return( 1);
+#endif
+
+   [[NSThread currentThread] mulleSetNameUTF8String:"#1"];
+
+   @autoreleasepool
+   {
+      thread = [NSThread alloc];
+      [thread mulleSetNameUTF8String:"#2"];
+      thread = [thread initWithTarget:[Receiver class]
+                          selector:@selector( foo:)
+                          object:nil];
+      thread = [thread autorelease];
+
+      mulle_printf( "%s - 1: %s\n", __THREAD_NAME__, __PRETTY_FUNCTION__);
+      [thread mulleStart];
+      mulle_relativetime_sleep( 0.2); // just get sequencing nicer for test output
+      mulle_printf( "%s - 3: %s\n", __THREAD_NAME__, __PRETTY_FUNCTION__);
+      invocation = [thread mulleJoin];
+      [invocation getReturnValue:&obj];
+      mulle_printf( "%s - 4: %s %td\n", __THREAD_NAME__, __PRETTY_FUNCTION__, [obj retainCount]);
+   }
+   return( 0);
+}
diff --git a/test/TAO/backward/removefromcurrent.stdout b/test/TAO/backward/removefromcurrent.stdout
new file mode 100644
index 00000000..5a5e00a7
--- /dev/null
+++ b/test/TAO/backward/removefromcurrent.stdout
@@ -0,0 +1,11 @@
+#1 - 1: int main(int, const char **)
+#2 - a: -[Foo autorelease] 1
+#2 - 1: +[Receiver foo:] 1
+#2 - +: -[Foo retain] 1 -> 2
+#2 - q: -[Foo mulleRelinquishAccess] 1
+#1 - 3: int main(int, const char **)
+#1 - a: -[Foo autorelease] 1
+#1 - g: -[Foo mulleGainAccess] 1
+#1 - 4: int main(int, const char **) 1
+#1 - -: -[Foo release] 1 -> 0
+#1 - d: -[Foo dealloc] 0
diff --git a/test/TAO/backward/threadsafe.m b/test/TAO/backward/threadsafe.m
new file mode 100644
index 00000000..9c169dd8
--- /dev/null
+++ b/test/TAO/backward/threadsafe.m
@@ -0,0 +1,38 @@
+#define TEST_TAO_STRATEGY   MulleObjCTAOKnownThreadSafe
+#define TEST_PROTOCOLS      < MulleObjCThreadSafe>
+
+#include "TAOStrategyTest2.inc"
+
+
+int   main( int argc, const char * argv[])
+{
+   NSThread       *thread;
+   Foo            *obj;
+   NSInvocation   *invocation;
+
+#ifdef __MULLE_OBJC__
+   if( mulle_objc_global_check_universe( __MULLE_OBJC_UNIVERSENAME__) != mulle_objc_universe_is_ok)
+      return( 1);
+#endif
+
+   [[NSThread currentThread] mulleSetNameUTF8String:"#1"];
+
+   @autoreleasepool
+   {
+      thread = [NSThread alloc];
+      [thread mulleSetNameUTF8String:"#2"];
+      thread = [thread initWithTarget:[Receiver class]
+                          selector:@selector( foo:)
+                          object:nil];
+      thread = [thread autorelease];
+
+      mulle_printf( "%s - 1: %s\n", __THREAD_NAME__, __PRETTY_FUNCTION__);
+      [thread mulleStart];
+      mulle_relativetime_sleep( 0.2); // just get sequencing nicer for test output
+      mulle_printf( "%s - 3: %s\n", __THREAD_NAME__, __PRETTY_FUNCTION__);
+      invocation = [thread mulleJoin];
+      [invocation getReturnValue:&obj];
+      mulle_printf( "%s - 4: %s %td\n", __THREAD_NAME__, __PRETTY_FUNCTION__, [obj retainCount]);
+   }
+   return( 0);
+}
diff --git a/test/TAO/backward/threadsafe.stdout b/test/TAO/backward/threadsafe.stdout
new file mode 100644
index 00000000..441f6526
--- /dev/null
+++ b/test/TAO/backward/threadsafe.stdout
@@ -0,0 +1,12 @@
+#1 - 1: int main(int, const char **)
+#2 - a: -[Foo autorelease] 1
+#2 - 1: +[Receiver foo:] 1
+#2 - +: -[Foo retain] 1 -> 2
+#2 - q: -[Foo mulleRelinquishAccess] 2
+#2 - -: -[Foo release] 2 -> 1
+#1 - 3: int main(int, const char **)
+#1 - a: -[Foo autorelease] 1
+#1 - g: -[Foo mulleGainAccess] 1
+#1 - 4: int main(int, const char **) 1
+#1 - -: -[Foo release] 1 -> 0
+#1 - d: -[Foo dealloc] 0
diff --git a/test/TAO/backward/threadsafemethods.m b/test/TAO/backward/threadsafemethods.m
new file mode 100644
index 00000000..39b79b0d
--- /dev/null
+++ b/test/TAO/backward/threadsafemethods.m
@@ -0,0 +1,37 @@
+#define TEST_TAO_STRATEGY   MulleObjCTAOKnownThreadSafeMethods
+
+#include "TAOStrategyTest2.inc"
+
+
+int   main( int argc, const char * argv[])
+{
+   NSThread       *thread;
+   Foo            *obj;
+   NSInvocation   *invocation;
+
+#ifdef __MULLE_OBJC__
+   if( mulle_objc_global_check_universe( __MULLE_OBJC_UNIVERSENAME__) != mulle_objc_universe_is_ok)
+      return( 1);
+#endif
+
+   [[NSThread currentThread] mulleSetNameUTF8String:"#1"];
+
+   @autoreleasepool
+   {
+      thread = [NSThread alloc];
+      [thread mulleSetNameUTF8String:"#2"];
+      thread = [thread initWithTarget:[Receiver class]
+                          selector:@selector( foo:)
+                          object:nil];
+      thread = [thread autorelease];
+
+      mulle_printf( "%s - 1: %s\n", __THREAD_NAME__, __PRETTY_FUNCTION__);
+      [thread mulleStart];
+      mulle_relativetime_sleep( 0.2); // just get sequencing nicer for test output
+      mulle_printf( "%s - 3: %s\n", __THREAD_NAME__, __PRETTY_FUNCTION__);
+      invocation = [thread mulleJoin];
+      [invocation getReturnValue:&obj];
+      mulle_printf( "%s - 4: %s %td\n", __THREAD_NAME__, __PRETTY_FUNCTION__, [obj retainCount]);
+   }
+   return( 0);
+}
diff --git a/test/TAO/backward/threadsafemethods.stdout b/test/TAO/backward/threadsafemethods.stdout
new file mode 100644
index 00000000..441f6526
--- /dev/null
+++ b/test/TAO/backward/threadsafemethods.stdout
@@ -0,0 +1,12 @@
+#1 - 1: int main(int, const char **)
+#2 - a: -[Foo autorelease] 1
+#2 - 1: +[Receiver foo:] 1
+#2 - +: -[Foo retain] 1 -> 2
+#2 - q: -[Foo mulleRelinquishAccess] 2
+#2 - -: -[Foo release] 2 -> 1
+#1 - 3: int main(int, const char **)
+#1 - a: -[Foo autorelease] 1
+#1 - g: -[Foo mulleGainAccess] 1
+#1 - 4: int main(int, const char **) 1
+#1 - -: -[Foo release] 1 -> 0
+#1 - d: -[Foo dealloc] 0
diff --git a/test/TAO/forward/README.md b/test/TAO/forward/README.md
new file mode 100644
index 00000000..fce4b37d
--- /dev/null
+++ b/test/TAO/forward/README.md
@@ -0,0 +1,5 @@
+These tests just see an object passed back and forth between two threads.
+
+
+The animation.html is incomplete, because the autorelasepool wont be shown
+thats currently releasing objects.
\ No newline at end of file
diff --git a/test/TAO/forward/TAOStrategyTest.inc b/test/TAO/forward/TAOStrategyTest.inc
new file mode 100644
index 00000000..dd7392cb
--- /dev/null
+++ b/test/TAO/forward/TAOStrategyTest.inc
@@ -0,0 +1,270 @@
+#import <MulleObjC/MulleObjC.h>
+
+
+static inline char  *curr_thread_name( void)
+{
+   NSThread  *thread;
+   char      *name;
+
+   thread = MulleThreadGetCurrentThread();
+   name   = thread ? [thread mulleNameUTF8String] : "#?";
+   return( name ? name : "??");
+}
+
+
+#define __THREAD_NAME__    curr_thread_name()
+
+#ifndef TEST_PROTOCOLS
+# define TEST_PROTOCOLS
+#endif
+
+
+static void   dump_trace_text( unsigned long nr, char *format, va_list args)
+{
+   auto char   buf[ 19 + 32 + 4 + 1];
+   FILE        *fp;
+
+   mulle_snprintf( buf, sizeof( buf), "NSAutoreleasePools_%06d.txt", nr);
+   fp = fopen( buf, "w");
+   if( ! fp)
+   {
+      perror( "fopen:");
+      return;
+   }
+
+   mulle_vfprintf( fp, format, args);
+   mulle_fprintf( fp, "\n");
+   _mulle_stacktrace( NULL, 2, mulle_stacktrace_linefeed, fp);
+
+   fclose( fp);
+}
+
+
+static void   test_trace( char *format, ...)
+{
+   va_list   args;
+
+   va_start( args, format);
+   mulle_vprintf( format, args);
+   va_end( args);
+
+#ifdef TEST_TRACE_FRAME
+   {
+      unsigned long   nr;
+
+      nr = MulleObjCDumpAutoreleasePoolsFrame();
+      va_start( args, format);
+      dump_trace_text( nr, format, args);
+      va_end( args);
+   }
+#endif
+
+}
+
+
+
+@interface Foo : NSObject  TEST_PROTOCOLS
+@end
+
+
+@implementation Foo
+
+- (MulleObjCTAOStrategy) mulleTAOStrategy MULLE_OBJC_THREADSAFE_METHOD
+{
+   return( TEST_TAO_STRATEGY);
+}
+
+
+- (void) release
+{
+   test_trace( "%s - ->: %s %td -> %td\n", __THREAD_NAME__, __FUNCTION__, [self retainCount], [self retainCount] - 1);
+   [super release];
+}
+
+
+- (id) retain
+{
+   self = [super retain];
+
+   test_trace( "%s - +<: %s %td -> %td\n", __THREAD_NAME__, __FUNCTION__, [self retainCount], [self retainCount] + 1);
+
+   return( self);
+}
+
+
+- (id) autorelease
+{
+   self = [super autorelease];
+   test_trace( "%s - a<: %s %td\n", __THREAD_NAME__, __FUNCTION__, [self retainCount]);
+   return( self);
+}
+
+
+
+- (void) dealloc
+{
+   test_trace( "%s - d>: %s %td\n", __THREAD_NAME__, __FUNCTION__, [self retainCount]);
+   [super dealloc];
+}
+
+
+- (void) mulleGainAccess
+{
+   test_trace( "%s - g>: %s %td\n", __THREAD_NAME__, __FUNCTION__, [self retainCount]);
+   [super mulleGainAccess];
+   test_trace( "%s - g<: %s %td\n", __THREAD_NAME__, __FUNCTION__, [self retainCount]);
+}
+
+
+- (void) mulleRelinquishAccess
+{
+   test_trace( "%s - q>: %s %td\n", __THREAD_NAME__, __FUNCTION__, [self retainCount]);
+   [super mulleRelinquishAccess];
+   test_trace( "%s - q<: %s %td\n", __THREAD_NAME__, __FUNCTION__, [self retainCount]);
+}
+
+@end
+
+
+static int   thread_function( NSThread *thread, id obj)
+{
+   test_trace( "%s - 3*: %s %td\n", __THREAD_NAME__, __FUNCTION__, [obj retainCount]);
+   return( 0);
+}
+
+
+
+@implementation NSInvocation( Debug)
+
+- (void) release
+{
+   test_trace( "%s - ->: %s %td -> %td\n", __THREAD_NAME__, __FUNCTION__, [self retainCount], [self retainCount] - 1);
+   MulleObjCIMPCall0( MulleObjCOverriddenIMP, self, _cmd);
+}
+
+
+- (id) retain
+{
+   self = MulleObjCIMPCall0( MulleObjCOverriddenIMP, self, _cmd);
+
+   test_trace( "%s - +<: %s %td -> %td\n", __THREAD_NAME__, __FUNCTION__, [self retainCount], [self retainCount] + 1);
+
+   return( self);
+}
+
+
+- (id) autorelease
+{
+   self = MulleObjCIMPCall0( MulleObjCOverriddenIMP, self, _cmd);
+
+   test_trace( "%s - a<: %s %td\n", __THREAD_NAME__, __FUNCTION__, [self retainCount]);
+
+   return( self);
+}
+
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdealloc-in-category"
+#pragma clang diagnostic ignored "-Wobjc-missing-super-calls"
+
+- (void) dealloc
+{
+   test_trace( "%s - d>: %s %td\n", __THREAD_NAME__, __FUNCTION__, [self retainCount]);
+   MulleObjCIMPCall0( MulleObjCOverriddenIMP, self, _cmd);
+}
+#pragma clang diagnostic pop
+
+
+- (void) mulleGainAccess
+{
+   test_trace( "%s - g>: %s %td\n", __THREAD_NAME__, __FUNCTION__, [self retainCount]);
+   MulleObjCIMPCall0( MulleObjCOverriddenIMP, self, _cmd);
+   test_trace( "%s - g<: %s %td\n", __THREAD_NAME__, __FUNCTION__, [self retainCount]);
+}
+
+
+- (void) mulleRelinquishAccess
+{
+   test_trace( "%s - q>: %s %td\n", __THREAD_NAME__, __FUNCTION__, [self retainCount]);
+   MulleObjCIMPCall0( MulleObjCOverriddenIMP, self, _cmd);
+   test_trace( "%s - q<: %s %td\n", __THREAD_NAME__, __FUNCTION__, [self retainCount]);
+}
+
+@end
+
+
+
+@implementation NSThread( Debug)
+
+- (void) release
+{
+   test_trace( "%s - ->: %s %td -> %td\n", __THREAD_NAME__, __PRETTY_FUNCTION__, [self retainCount], [self retainCount] - 1);
+   MulleObjCIMPCall0( MulleObjCOverriddenIMP, self, _cmd);
+}
+
+
+- (id) retain
+{
+   self = MulleObjCIMPCall0( MulleObjCOverriddenIMP, self, _cmd);
+
+   test_trace( "%s - +<: %s %td -> %td\n", __THREAD_NAME__, __PRETTY_FUNCTION__, [self retainCount], [self retainCount] + 1);
+
+   return( self);
+}
+
+
+- (void) _autoreleaseInvocation
+{
+   test_trace( "%s - f>: %s %td\n", __THREAD_NAME__, __FUNCTION__, [self retainCount]);
+
+   MulleObjCIMPCall0( MulleObjCOverriddenIMP, self, _cmd);
+
+   test_trace( "%s - f<: %s %td\n", __THREAD_NAME__, __FUNCTION__, [self retainCount]);
+}
+
+
+- (void) _releaseInvocation
+{
+   test_trace( "%s - f>: %s %td\n", __THREAD_NAME__, __FUNCTION__, [self retainCount]);
+
+   MulleObjCIMPCall0( MulleObjCOverriddenIMP, self, _cmd);
+
+   test_trace( "%s - f<: %s %td\n", __THREAD_NAME__, __FUNCTION__, [self retainCount]);
+}
+
+
+- (void) finalize
+{
+   test_trace( "%s - f>: %s %td\n", __THREAD_NAME__, __FUNCTION__, [self retainCount]);
+
+   MulleObjCIMPCall0( MulleObjCOverriddenIMP, self, _cmd);
+
+   test_trace( "%s - f<: %s %td\n", __THREAD_NAME__, __FUNCTION__, [self retainCount]);
+}
+
+
+
+- (id) autorelease
+{
+   self = MulleObjCIMPCall0( MulleObjCOverriddenIMP, self, _cmd);
+
+   test_trace( "%s - a<: %s %td\n", __THREAD_NAME__, __FUNCTION__, [self retainCount]);
+
+   return( self);
+}
+
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdealloc-in-category"
+#pragma clang diagnostic ignored "-Wobjc-missing-super-calls"
+
+- (void) dealloc
+{
+   test_trace( "%s - d>: %s %td\n", __THREAD_NAME__, __FUNCTION__, [self retainCount]);
+   MulleObjCIMPCall0( MulleObjCOverriddenIMP, self, _cmd);
+}
+#pragma clang diagnostic pop
+
+
+@end
+
diff --git a/test/TAO/forward/default.stdout b/test/TAO/forward/default.stdout
new file mode 100644
index 00000000..e69de29b
diff --git a/test/TAO/forward/generate-animation.sh b/test/TAO/forward/generate-animation.sh
new file mode 100755
index 00000000..f687b6ea
--- /dev/null
+++ b/test/TAO/forward/generate-animation.sh
@@ -0,0 +1,196 @@
+#! /usr/bin/env mulle-bash
+
+# Check if at least one SVG file is provided
+if [ "$#" -lt 1 ]; then
+    echo "Usage: $0 file1.csv file2.csv ... fileN.csv"
+    exit 1
+fi
+
+output_html()
+{
+    log_entry "output_html" "$@"
+
+    local first_file="$1"
+
+    local first_file_name
+
+    # Start HTML file
+    cat <<EOF > animation.html
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>SVG Animation</title>
+    <style>
+        #svg-container {
+            width: 95%;
+            height: 300px;
+            margin: 0 auto;
+            text-align: center;
+        }
+        button {
+            margin: 10px;
+        }
+        code {
+            display: block;
+            text-align: center;
+            margin: 10px 0;
+            font-size: 1.2em;
+        }
+        pre {
+            width: 80%;
+            margin: 10px auto;
+            background-color: #f5f5f5;
+            padding: 10px;
+            border-radius: 4px;
+            overflow-x: auto;
+        }
+        .text-content { display: none; }
+        .text-content.active { display: block; }
+    </style>
+</head>
+<body>
+    <div id="titles"></div>
+    <div id="commands"></div>
+    <div style="text-align: center;">
+        <button id="prev-btn">Previous</button>
+        <button id="next-btn">Next</button>
+    </div>
+    <div id="svg-container">
+        <img id="svg-display" src="${first_file}" alt="SVG Animation" width="100%" height="100%">
+    </div>
+    <div id="traces"></div>
+    <script>
+        const svgFiles = [
+EOF
+
+    # Add SVG files array
+    local svg
+
+    for svg in "$@"; do
+        echo "            '$svg'," >> animation.html
+    done
+    echo "        ];" >> animation.html
+
+    # Add number divs
+    echo "        const titles = [" >> animation.html
+    for svg in "$@"; do
+         echo "            '${svg%.svg}'," >> animation.html
+    done
+    echo "        ];" >> animation.html
+
+    # Add title divs
+    echo "        const commands = [" >> animation.html
+    for svg in "$@"; do
+        txt_file="${svg%.svg}.txt"
+        if [ -f "$txt_file" ]; then
+            title=$(head -n1 "$txt_file")
+            echo "            '$title'," >> animation.html
+        else
+            echo "            ''," >> animation.html
+        fi
+    done
+    echo "        ];" >> animation.html
+
+    # Add stack traces
+    echo "        const traces = [" >> animation.html
+    for svg in "$@"; do
+        txt_file="${svg%.svg}.txt"
+        if [ -f "$txt_file" ]; then
+            trace=$(tail -n +2 "$txt_file" | sed 's/"/\\"/g' | tr '\n' '\\' | sed 's/\\/\\n/g')
+            echo "            '$trace'," >> animation.html
+        else
+            echo "            ''," >> animation.html
+        fi
+    done
+    echo "        ];" >> animation.html
+
+    # Complete the HTML file
+    cat <<EOF >> animation.html
+
+        let currentIndex = 0;
+        const svgDisplay = document.getElementById('svg-display');
+        const titlesDiv = document.getElementById('titles');
+        const commandsDiv = document.getElementById('commands');
+        const tracesDiv = document.getElementById('traces');
+        const prevBtn = document.getElementById('prev-btn');
+        const nextBtn = document.getElementById('next-btn');
+
+        titles.forEach((title, index) => {
+            const codeEl = document.createElement('h1');
+            codeEl.className = 'text-content' + (index === 0 ? ' active' : '');
+            codeEl.textContent = title;
+            titlesDiv.appendChild(codeEl);
+        });
+
+        // Create title and trace elements
+        commands.forEach((title, index) => {
+            const codeEl = document.createElement('code');
+            codeEl.className = 'text-content' + (index === 0 ? ' active' : '');
+            codeEl.textContent = title;
+            commandsDiv.appendChild(codeEl);
+
+            const preEl = document.createElement('pre');
+            preEl.className = 'text-content' + (index === 0 ? ' active' : '');
+            preEl.textContent = traces[index];
+            tracesDiv.appendChild(preEl);
+        });
+
+        function updateDisplay() {
+            svgDisplay.src = svgFiles[currentIndex];
+            document.querySelectorAll('.text-content').forEach(el => el.classList.remove('active'));
+            titlesDiv.children[currentIndex].classList.add('active');
+            commandsDiv.children[currentIndex].classList.add('active');
+            tracesDiv.children[currentIndex].classList.add('active');
+        }
+
+        prevBtn.addEventListener('click', () => {
+            currentIndex = (currentIndex > 0) ? currentIndex - 1 : svgFiles.length - 1;
+            updateDisplay();
+        });
+
+        nextBtn.addEventListener('click', () => {
+            currentIndex = (currentIndex < svgFiles.length - 1) ? currentIndex + 1 : 0;
+            updateDisplay();
+        });
+    </script>
+</body>
+</html>
+EOF
+}
+
+
+
+output()
+{
+   log_entry "output_csv" "$@"
+
+   local svg_files
+
+   svg_files=()
+
+   local csv
+   local dot
+   local svg
+
+   for csv in "$@"
+   do
+      r_extensionless_basename "${csv}"
+      dot="${RVAL}.dot"
+      svg="${RVAL}.svg"
+
+      pooldump-dot.awk "${csv}" > "${dot}" || exit 1
+      dot -Tsvg -o "${svg}" "${dot}"
+
+      svg_files+=("${svg}")
+   done
+
+   output_html "${svg_files[@]}"
+}
+
+
+PATH="${PATH}:${PWD}"
+
+output "$@"
+
diff --git a/test/TAO/forward/performsfinalize.m b/test/TAO/forward/performsfinalize.m
new file mode 100644
index 00000000..3ed2d1f8
--- /dev/null
+++ b/test/TAO/forward/performsfinalize.m
@@ -0,0 +1,37 @@
+#define TEST_TAO_STRATEGY   MulleObjCTAOReceiverPerformsFinalize
+#define TEST_TRACE_FRAME
+
+#include "TAOStrategyTest.inc"
+
+
+int   main( int argc, const char * argv[])
+{
+   NSThread    *thread;
+   Foo         *obj;
+
+#ifdef __MULLE_OBJC__
+   if( mulle_objc_global_check_universe( __MULLE_OBJC_UNIVERSENAME__) != mulle_objc_universe_is_ok)
+      return( 1);
+#endif
+
+   [NSThread mulleSetMainThreadWaitsAtExit:YES];
+   [[NSThread currentThread] mulleSetNameUTF8String:"#1"];
+
+   @autoreleasepool
+   {
+      obj    = [Foo object];
+      test_trace( "%s - 1*: %s %td\n", __THREAD_NAME__, __PRETTY_FUNCTION__, [obj retainCount]);
+
+      thread = [NSThread alloc];
+      [thread mulleSetNameUTF8String:"#2"];
+      thread = [thread mulleInitWithObjectFunction:thread_function
+                                            object:obj];
+      thread = [thread autorelease];
+
+      test_trace( "%s - 2*: %s %td\n", __THREAD_NAME__, __PRETTY_FUNCTION__, [obj retainCount]);
+      [thread start];
+      mulle_relativetime_sleep( 0.5);  // wait for thread before autoreleasepool clean up for nicer log
+      test_trace( "%s - 3*: %s %td\n", __THREAD_NAME__, __PRETTY_FUNCTION__, [obj retainCount]);
+   }
+   return( 0);
+}
diff --git a/test/TAO/forward/performsfinalize.stdout b/test/TAO/forward/performsfinalize.stdout
new file mode 100644
index 00000000..080f3b05
--- /dev/null
+++ b/test/TAO/forward/performsfinalize.stdout
@@ -0,0 +1,28 @@
+#1 - a<: -[Foo autorelease] 1
+#1 - 1*: int main(int, const char **) 1
+#1 - +<: -[Foo retain] 2 -> 3
+#1 - a<: -[NSThread(Debug) autorelease] 1
+#1 - 2*: int main(int, const char **) 2
+#1 - +<: -[NSThread(Debug) retain] 2 -> 3
+#1 - q>: -[Foo mulleRelinquishAccess] 2
+#1 - +<: -[Foo retain] 3 -> 4
+#1 - q<: -[Foo mulleRelinquishAccess] 3
+#2 - g>: -[Foo mulleGainAccess] 3
+#2 - a<: -[Foo autorelease] 3
+#2 - g<: -[Foo mulleGainAccess] 3
+#2 - 3*: thread_function 3
+#2 - f>: -[NSThread(Debug) finalize] 2
+#2 - a<: -[Foo autorelease] 3
+#2 - f<: -[NSThread(Debug) finalize] 2
+#2 - ->: -[Foo release] 3 -> 2
+#2 - ->: -[Foo release] 2 -> 1
+#? - ->: -[NSThread(Debug) release] 2 -> 1
+#1 - 3*: int main(int, const char **) 1
+#1 - ->: -[NSThread(Debug) release] 1 -> 0
+#1 - d>: -[NSThread(Debug) dealloc] 0
+#1 - ->: -[Foo release] 1 -> 0
+#1 - d>: -[Foo dealloc] 0
+#1 - f>: -[NSThread(Debug) finalize] 1
+#1 - f<: -[NSThread(Debug) finalize] 1
+#? - ->: -[NSThread(Debug) release] 1 -> 0
+#? - d>: -[NSThread(Debug) dealloc] 0
diff --git a/test/TAO/forward/pooldump-dot.awk b/test/TAO/forward/pooldump-dot.awk
new file mode 100755
index 00000000..e866155b
--- /dev/null
+++ b/test/TAO/forward/pooldump-dot.awk
@@ -0,0 +1,173 @@
+#!/usr/bin/awk -f
+
+BEGIN {
+    FS = ","
+
+    show_all_objects = 1  # Default to showing only objects with rc > 1
+
+    # Parse command-line arguments
+    for (i = 1; i < ARGC; i++) {
+        if (ARGV[i] == "--hide-rc-1") {
+            show_all_objects = 0
+            # Remove the argument from ARGV to prevent awk from treating it as a file
+            for (j = i; j < ARGC; j++) {
+                ARGV[j] = ARGV[j + 1]
+            }
+            ARGC--
+            break
+        }
+    }
+
+    print "digraph G {"
+    print "  rankdir=LR;"
+    print "  node [shape=box];"
+    print "  edge [dir=forward];"
+}
+
+NR == 2 {
+    num_fields = NF
+}
+
+NR > 1 {
+    gsub(/"/, "", $2)  # thread name
+    gsub(/"/, "", $4)  # pool name
+    gsub(/"/, "", $6)  # object name
+    gsub(/"/, "", $7)  # class name
+
+    thread_id = $1
+    thread_name = $2
+    pool_id = $3
+    pool_name = $4
+    obj_id = $5
+    obj_name = $6
+    class_name = $7
+    rc = $8
+
+    if (num_fields >= 10) {
+        gsub(/"/, "", $9)  # owner id
+        gsub(/"/, "", $10) # owner name
+        owner_id = $9
+        owner = $10
+    }
+
+    threads[thread_id] = thread_name
+
+    if (!seen_pool[thread_id, pool_id]) {
+        pool_sequence[thread_id, ++pool_count[thread_id]] = pool_id
+        pool_names[pool_id] = pool_name
+        seen_pool[thread_id, pool_id] = 1
+    }
+
+    pool_objects[pool_id, obj_id] = class_name
+    retain_counts[obj_id] = rc
+    obj_names[obj_id] = obj_name
+
+    if (show_all_objects || rc > 1) {
+        all_objects[obj_id] = class_name
+        if (num_fields >= 10) {
+            object_owners[obj_id] = owner_id
+            owner_names[obj_id] = owner
+        }
+    }
+}
+
+END {
+    # Create a subgraph for thread nodes to align them in the left column
+    print "  subgraph cluster_threads {"
+    print "    rank=same;"
+    print "    style=invis;"  # Make the subgraph box invisible
+
+    for (tid in threads) {
+        print "    \"thread_" tid "\" [shape=none,label=<"
+        print "      <TABLE BORDER=\"0\" CELLBORDER=\"1\" CELLSPACING=\"0\">"
+        print "      <TR><TD COLSPAN=\"2\">Thread</TD></TR>"
+        print "      <TR><TD>Address</TD><TD>Name</TD></TR>"
+        print "      <TR><TD>" tid "</TD><TD>" threads[tid] "</TD></TR>"
+        print "      </TABLE>>];"
+    }
+
+    print "  }"
+
+    # Create a subgraph for pool nodes to align them in the center column
+    print "  subgraph cluster_pools {"
+    print "    rank=same;"
+    print "    style=invis;"  # Make the subgraph box invisible
+
+    for (tid in threads) {
+        for (i = 1; i <= pool_count[tid]; i++) {
+            pool_id = pool_sequence[tid, i]
+            print "    \"pool:" pool_id "\" [shape=none,label=<"
+            print "      <TABLE BORDER=\"0\" CELLBORDER=\"1\" CELLSPACING=\"0\">"
+            print "      <TR><TD COLSPAN=\"2\">Pool " pool_id " (" pool_names[pool_id] ")</TD></TR>"
+            print "      <TR><TD>Address</TD><TD>Class</TD></TR>"
+
+            for (obj_key in pool_objects) {
+                split(obj_key, obj_arr, SUBSEP)
+                if (obj_arr[1] == pool_id) {
+                    print "      <TR><TD PORT=\"" obj_arr[2] "\">" obj_arr[2] "</TD><TD>" pool_objects[obj_key] "</TD></TR>"
+                }
+            }
+
+            print "      </TABLE>>];"
+
+            # Connect thread to each pool in sequence
+            if (i == 1) {
+                print "  \"thread_" tid "\" -> \"pool:" pool_id "\";"
+            } else {
+                prev_pool_id = pool_sequence[tid, i-1]
+                print "  \"pool:" prev_pool_id "\" -> \"pool:" pool_id "\";"
+            }
+        }
+    }
+
+    print "  }"
+
+    # Create the objects table and place it in the right column
+    print "  subgraph cluster_objects {"
+    print "    rank=same;"
+    print "    style=invis;"  # Make the subgraph box invisible
+
+    print "    objects [shape=none,label=<"
+    print "      <TABLE BORDER=\"0\" CELLBORDER=\"1\" CELLSPACING=\"0\">"
+
+    if (num_fields >= 10) {
+        print "      <TR><TD COLSPAN=\"6\">Objects</TD></TR>"
+        print "      <TR><TD>Address</TD><TD>Class</TD><TD>Name</TD><TD>RC</TD><TD>Owner ID</TD><TD>Owner</TD></TR>"
+    } else {
+        print "      <TR><TD COLSPAN=\"4\">Objects</TD></TR>"
+        print "      <TR><TD>Address</TD><TD>Class</TD><TD>Name</TD><TD>RC</TD></TR>"
+    }
+
+    n = asorti(all_objects, sorted_addrs)
+    for (i = 1; i <= n; i++) {
+        obj_id = sorted_addrs[i]
+        if (num_fields >= 10) {
+            print "      <TR><TD PORT=\"" obj_id "\">" obj_id "</TD><TD>" all_objects[obj_id] "</TD><TD>" obj_names[obj_id] "</TD><TD>" retain_counts[obj_id] "</TD><TD PORT=\"owner_" obj_id "\">" object_owners[obj_id] "</TD><TD>" owner_names[obj_id] "</TD></TR>"
+        } else {
+            print "      <TR><TD PORT=\"" obj_id "\">" obj_id "</TD><TD>" all_objects[obj_id] "</TD><TD>" obj_names[obj_id] "</TD><TD>" retain_counts[obj_id] "</TD></TR>"
+        }
+    }
+
+    print "      </TABLE>>];"
+    print "  }"
+
+    # Create edges from pools to objects
+    for (key in pool_objects) {
+        split(key, arr, SUBSEP)
+        pool_id = arr[1]
+        obj_id = arr[2]
+        print "  \"pool:" pool_id "\":\"" obj_id "\" -> \"objects\":\"" obj_id "\";"
+    }
+
+    # Create ownership arrows if owner data exists
+    if (num_fields >= 10) {
+        for (obj_id in all_objects) {
+            owner_id = object_owners[obj_id]
+            if (owner_id != "NULL" && owner_id != -1 && owner_id != 0) {
+                print "  \"objects\":\"owner_" obj_id "\" -> \"thread_" owner_id "\" [color=\"blue\",style=\"dashed\"];"
+            }
+        }
+    }
+
+    print "}"
+}
diff --git a/test/TAO/forward/removefromallpools.m b/test/TAO/forward/removefromallpools.m
new file mode 100644
index 00000000..c445143b
--- /dev/null
+++ b/test/TAO/forward/removefromallpools.m
@@ -0,0 +1,40 @@
+#define TEST_TAO_STRATEGY   MulleObjCTAOCallerRemovesFromAllPools
+
+#include "TAOStrategyTest.inc"
+
+
+int   main( int argc, const char * argv[])
+{
+   NSThread    *thread;
+   Foo         *obj;
+
+#ifdef __MULLE_OBJC__
+   if( mulle_objc_global_check_universe( __MULLE_OBJC_UNIVERSENAME__) != mulle_objc_universe_is_ok)
+      return( 1);
+#endif
+
+   [NSThread mulleSetMainThreadWaitsAtExit:YES];
+   [[NSThread currentThread] mulleSetNameUTF8String:"#1"];
+
+   @autoreleasepool
+   {
+      obj = [Foo object];
+      mulle_printf( "%s - 1: %s %td\n", __THREAD_NAME__, __PRETTY_FUNCTION__, [obj retainCount]);
+
+      @autoreleasepool
+      {
+         thread = [NSThread alloc];
+         [thread mulleSetNameUTF8String:"#2"];
+         thread = [thread mulleInitWithObjectFunction:thread_function
+                                               object:obj];
+         thread = [thread autorelease];
+
+         mulle_printf( "%s - 2: %s %td\n", __THREAD_NAME__, __PRETTY_FUNCTION__, [obj retainCount]);
+         [thread start];
+         mulle_relativetime_sleep( 0.5);  // wait for thread before autoreleasepool clean up for nicer log
+
+         // can't access foo anymore here
+      }
+   }
+   return( 0);
+}
diff --git a/test/TAO/forward/removefromallpools.stdout b/test/TAO/forward/removefromallpools.stdout
new file mode 100644
index 00000000..779824b3
--- /dev/null
+++ b/test/TAO/forward/removefromallpools.stdout
@@ -0,0 +1,26 @@
+#1 - a<: -[Foo autorelease] 1
+#1 - 1: int main(int, const char **) 1
+#1 - +<: -[Foo retain] 2 -> 3
+#1 - a<: -[NSThread(Debug) autorelease] 1
+#1 - 2: int main(int, const char **) 2
+#1 - +<: -[NSThread(Debug) retain] 2 -> 3
+#1 - q>: -[Foo mulleRelinquishAccess] 2
+#1 - +<: -[Foo retain] 3 -> 4
+#1 - q<: -[Foo mulleRelinquishAccess] 2
+#2 - g>: -[Foo mulleGainAccess] 2
+#2 - a<: -[Foo autorelease] 2
+#2 - g<: -[Foo mulleGainAccess] 2
+#2 - 3*: thread_function 2
+#2 - f>: -[NSThread(Debug) finalize] 2
+#2 - a<: -[Foo autorelease] 2
+#2 - f<: -[NSThread(Debug) finalize] 2
+#2 - ->: -[Foo release] 2 -> 1
+#2 - ->: -[Foo release] 1 -> 0
+#2 - d>: -[Foo dealloc] 0
+#? - ->: -[NSThread(Debug) release] 2 -> 1
+#1 - ->: -[NSThread(Debug) release] 1 -> 0
+#1 - d>: -[NSThread(Debug) dealloc] 0
+#1 - f>: -[NSThread(Debug) finalize] 1
+#1 - f<: -[NSThread(Debug) finalize] 1
+#? - ->: -[NSThread(Debug) release] 1 -> 0
+#? - d>: -[NSThread(Debug) dealloc] 0
diff --git a/test/TAO/forward/removefromcurrent.m b/test/TAO/forward/removefromcurrent.m
new file mode 100644
index 00000000..ee561584
--- /dev/null
+++ b/test/TAO/forward/removefromcurrent.m
@@ -0,0 +1,37 @@
+#define TEST_TAO_STRATEGY   MulleObjCTAOCallerRemovesFromCurrentPool
+
+#include "TAOStrategyTest.inc"
+
+
+int   main( int argc, const char * argv[])
+{
+   NSThread    *thread;
+   Foo         *obj;
+
+#ifdef __MULLE_OBJC__
+   if( mulle_objc_global_check_universe( __MULLE_OBJC_UNIVERSENAME__) != mulle_objc_universe_is_ok)
+      return( 1);
+#endif
+
+   [NSThread mulleSetMainThreadWaitsAtExit:YES];
+   [[NSThread currentThread] mulleSetNameUTF8String:"#1"];
+
+   @autoreleasepool
+   {
+      obj    = [Foo object];
+      mulle_printf( "%s - 1: %s %td\n", __THREAD_NAME__, __PRETTY_FUNCTION__, [obj retainCount]);
+
+      thread = [NSThread alloc];
+      [thread mulleSetNameUTF8String:"#2"];
+      thread = [thread mulleInitWithObjectFunction:thread_function
+                                            object:obj];
+      thread = [thread autorelease];
+
+      mulle_printf( "%s - 2: %s %td\n", __THREAD_NAME__, __PRETTY_FUNCTION__, [obj retainCount]);
+      [thread start];
+      mulle_relativetime_sleep( 0.5);  // wait for thread before autoreleasepool clean up for nicer log
+
+      // can't access foo anymore here
+   }
+   return( 0);
+}
diff --git a/test/TAO/forward/removefromcurrent.stdout b/test/TAO/forward/removefromcurrent.stdout
new file mode 100644
index 00000000..779824b3
--- /dev/null
+++ b/test/TAO/forward/removefromcurrent.stdout
@@ -0,0 +1,26 @@
+#1 - a<: -[Foo autorelease] 1
+#1 - 1: int main(int, const char **) 1
+#1 - +<: -[Foo retain] 2 -> 3
+#1 - a<: -[NSThread(Debug) autorelease] 1
+#1 - 2: int main(int, const char **) 2
+#1 - +<: -[NSThread(Debug) retain] 2 -> 3
+#1 - q>: -[Foo mulleRelinquishAccess] 2
+#1 - +<: -[Foo retain] 3 -> 4
+#1 - q<: -[Foo mulleRelinquishAccess] 2
+#2 - g>: -[Foo mulleGainAccess] 2
+#2 - a<: -[Foo autorelease] 2
+#2 - g<: -[Foo mulleGainAccess] 2
+#2 - 3*: thread_function 2
+#2 - f>: -[NSThread(Debug) finalize] 2
+#2 - a<: -[Foo autorelease] 2
+#2 - f<: -[NSThread(Debug) finalize] 2
+#2 - ->: -[Foo release] 2 -> 1
+#2 - ->: -[Foo release] 1 -> 0
+#2 - d>: -[Foo dealloc] 0
+#? - ->: -[NSThread(Debug) release] 2 -> 1
+#1 - ->: -[NSThread(Debug) release] 1 -> 0
+#1 - d>: -[NSThread(Debug) dealloc] 0
+#1 - f>: -[NSThread(Debug) finalize] 1
+#1 - f<: -[NSThread(Debug) finalize] 1
+#? - ->: -[NSThread(Debug) release] 1 -> 0
+#? - d>: -[NSThread(Debug) dealloc] 0
diff --git a/test/TAO/forward/removefrompool.stdout b/test/TAO/forward/removefrompool.stdout
new file mode 100644
index 00000000..97c1e5cb
--- /dev/null
+++ b/test/TAO/forward/removefrompool.stdout
@@ -0,0 +1,21 @@
+#1 - a: -[Foo autorelease] 1
+#1 - 1: int main(int, const char **) 1
+#1 - +: -[Foo retain] 1 -> 2
+#1 - 2: int main(int, const char **) 2
+#1 - +: -[Foo retain] 2 -> 3
+#1 - q: -[Foo mulleRelinquishAccess] 3
+#2 - a: -[Foo autorelease] 3
+#2 - g: -[Foo mulleGainAccess] 3
+#2 - 3: int thread_function(NSThread *, id) 3
+#2 - +: -[Foo retain] 3 -> 4
+#2 - q: -[Foo mulleRelinquishAccess] 4
+#2 - -: -[Foo release] 4 -> 3
+#1 - 4: int main(int, const char **) 3
+#1 - a: -[Foo autorelease] 3
+#1 - g: -[Foo mulleGainAccess] 3
+#1 - a: -[Foo autorelease] 3
+#1 - 5: int main(int, const char **) 3
+#1 - -: -[Foo release] 3 -> 2
+#1 - -: -[Foo release] 2 -> 1
+#1 - -: -[Foo release] 1 -> 0
+#1 - d: -[Foo dealloc] 0
diff --git a/test/TAO/forward/threadsafe.m b/test/TAO/forward/threadsafe.m
new file mode 100644
index 00000000..eee4b396
--- /dev/null
+++ b/test/TAO/forward/threadsafe.m
@@ -0,0 +1,37 @@
+#define TEST_TAO_STRATEGY   MulleObjCTAOKnownThreadSafe
+#define TEST_PROTOCOLS      <MulleObjCThreadSafe>
+
+#include "TAOStrategyTest.inc"
+
+
+int   main( int argc, const char * argv[])
+{
+   NSThread    *thread;
+   Foo         *obj;
+
+#ifdef __MULLE_OBJC__
+   if( mulle_objc_global_check_universe( __MULLE_OBJC_UNIVERSENAME__) != mulle_objc_universe_is_ok)
+      return( 1);
+#endif
+
+   [NSThread mulleSetMainThreadWaitsAtExit:YES];
+   [[NSThread currentThread] mulleSetNameUTF8String:"#1"];
+
+   @autoreleasepool
+   {
+      obj    = [Foo object];
+      mulle_printf( "%s - 1: %s %td\n", __THREAD_NAME__, __PRETTY_FUNCTION__, [obj retainCount]);
+
+      thread = [NSThread alloc];
+      [thread mulleSetNameUTF8String:"#2"];
+      thread = [thread mulleInitWithObjectFunction:thread_function
+                                            object:obj];
+      thread = [thread autorelease];
+
+      mulle_printf( "%s - 2: %s %td\n", __THREAD_NAME__, __PRETTY_FUNCTION__, [obj retainCount]);
+      [thread start];
+      mulle_relativetime_sleep( 0.5);  // wait for thread before autoreleasepool clean up for nicer log
+      mulle_printf( "%s - 3: %s %td\n", __THREAD_NAME__, __PRETTY_FUNCTION__, [obj retainCount]);
+   }
+   return( 0);
+}
diff --git a/test/TAO/forward/threadsafe.stdout b/test/TAO/forward/threadsafe.stdout
new file mode 100644
index 00000000..d7ea5297
--- /dev/null
+++ b/test/TAO/forward/threadsafe.stdout
@@ -0,0 +1,28 @@
+#1 - a<: -[Foo autorelease] 1
+#1 - 1: int main(int, const char **) 1
+#1 - +<: -[Foo retain] 2 -> 3
+#1 - a<: -[NSThread(Debug) autorelease] 1
+#1 - 2: int main(int, const char **) 2
+#1 - +<: -[NSThread(Debug) retain] 2 -> 3
+#1 - q>: -[Foo mulleRelinquishAccess] 2
+#1 - +<: -[Foo retain] 3 -> 4
+#1 - q<: -[Foo mulleRelinquishAccess] 3
+#2 - g>: -[Foo mulleGainAccess] 3
+#2 - a<: -[Foo autorelease] 3
+#2 - g<: -[Foo mulleGainAccess] 3
+#2 - 3*: thread_function 3
+#2 - f>: -[NSThread(Debug) finalize] 2
+#2 - a<: -[Foo autorelease] 3
+#2 - f<: -[NSThread(Debug) finalize] 2
+#2 - ->: -[Foo release] 3 -> 2
+#2 - ->: -[Foo release] 2 -> 1
+#? - ->: -[NSThread(Debug) release] 2 -> 1
+#1 - 3: int main(int, const char **) 1
+#1 - ->: -[NSThread(Debug) release] 1 -> 0
+#1 - d>: -[NSThread(Debug) dealloc] 0
+#1 - ->: -[Foo release] 1 -> 0
+#1 - d>: -[Foo dealloc] 0
+#1 - f>: -[NSThread(Debug) finalize] 1
+#1 - f<: -[NSThread(Debug) finalize] 1
+#? - ->: -[NSThread(Debug) release] 1 -> 0
+#? - d>: -[NSThread(Debug) dealloc] 0
diff --git a/test/TAO/forward/threadsafemethods.m b/test/TAO/forward/threadsafemethods.m
new file mode 100644
index 00000000..12d68771
--- /dev/null
+++ b/test/TAO/forward/threadsafemethods.m
@@ -0,0 +1,36 @@
+#define TEST_TAO_STRATEGY   MulleObjCTAOKnownThreadSafeMethods
+
+#include "TAOStrategyTest.inc"
+
+
+int   main( int argc, const char * argv[])
+{
+   NSThread    *thread;
+   Foo         *obj;
+
+#ifdef __MULLE_OBJC__
+   if( mulle_objc_global_check_universe( __MULLE_OBJC_UNIVERSENAME__) != mulle_objc_universe_is_ok)
+      return( 1);
+#endif
+
+   [NSThread mulleSetMainThreadWaitsAtExit:YES];
+   [[NSThread currentThread] mulleSetNameUTF8String:"#1"];
+
+   @autoreleasepool
+   {
+      obj    = [Foo object];
+      mulle_printf( "%s - 1: %s %td\n", __THREAD_NAME__, __PRETTY_FUNCTION__, [obj retainCount]);
+
+      thread = [NSThread alloc];
+      [thread mulleSetNameUTF8String:"#2"];
+      thread = [thread mulleInitWithObjectFunction:thread_function
+                                            object:obj];
+      thread = [thread autorelease];
+
+      mulle_printf( "%s - 2: %s %td\n", __THREAD_NAME__, __PRETTY_FUNCTION__, [obj retainCount]);
+      [thread start];
+      mulle_relativetime_sleep( 0.5);  // wait for thread before autoreleasepool clean up for nicer log
+      mulle_printf( "%s - 3: %s %td\n", __THREAD_NAME__, __PRETTY_FUNCTION__, [obj retainCount]);
+   }
+   return( 0);
+}
diff --git a/test/TAO/forward/threadsafemethods.stdout b/test/TAO/forward/threadsafemethods.stdout
new file mode 100644
index 00000000..d7ea5297
--- /dev/null
+++ b/test/TAO/forward/threadsafemethods.stdout
@@ -0,0 +1,28 @@
+#1 - a<: -[Foo autorelease] 1
+#1 - 1: int main(int, const char **) 1
+#1 - +<: -[Foo retain] 2 -> 3
+#1 - a<: -[NSThread(Debug) autorelease] 1
+#1 - 2: int main(int, const char **) 2
+#1 - +<: -[NSThread(Debug) retain] 2 -> 3
+#1 - q>: -[Foo mulleRelinquishAccess] 2
+#1 - +<: -[Foo retain] 3 -> 4
+#1 - q<: -[Foo mulleRelinquishAccess] 3
+#2 - g>: -[Foo mulleGainAccess] 3
+#2 - a<: -[Foo autorelease] 3
+#2 - g<: -[Foo mulleGainAccess] 3
+#2 - 3*: thread_function 3
+#2 - f>: -[NSThread(Debug) finalize] 2
+#2 - a<: -[Foo autorelease] 3
+#2 - f<: -[NSThread(Debug) finalize] 2
+#2 - ->: -[Foo release] 3 -> 2
+#2 - ->: -[Foo release] 2 -> 1
+#? - ->: -[NSThread(Debug) release] 2 -> 1
+#1 - 3: int main(int, const char **) 1
+#1 - ->: -[NSThread(Debug) release] 1 -> 0
+#1 - d>: -[NSThread(Debug) dealloc] 0
+#1 - ->: -[Foo release] 1 -> 0
+#1 - d>: -[Foo dealloc] 0
+#1 - f>: -[NSThread(Debug) finalize] 1
+#1 - f<: -[NSThread(Debug) finalize] 1
+#? - ->: -[NSThread(Debug) release] 1 -> 0
+#? - d>: -[NSThread(Debug) dealloc] 0