diff --git a/Makefile.am b/Makefile.am
index bf4c80872..379d36803 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -33,8 +33,10 @@ SUBDIRS =
 include $(top_srcdir)/admin/Makefile.am
 
 # core
+include $(top_srcdir)/src/proc/Makefile.am
+include $(top_srcdir)/src/common/Makefile.am
 include $(top_srcdir)/src/lib/Makefile.am
-#include $(top_srcdir)/src/backend/Makefile.am
+include $(top_srcdir)/src/backend/Makefile.am
 
 # gui
 include $(top_srcdir)/src/gui/Makefile.am
@@ -43,6 +45,8 @@ include $(top_srcdir)/src/gui/Makefile.am
 #include $(top_srcdir)/src...
 
 # tests
+include $(top_srcdir)/tests/common/Makefile.am
+include $(top_srcdir)/tests/components/Makefile.am
 include $(top_srcdir)/tests/Makefile.am
 include $(top_srcdir)/tests/plugin/Makefile.am
 
diff --git a/admin/vgsuppression.c b/admin/vgsuppression.c
index 0e1f41fca..cad026e52 100644
--- a/admin/vgsuppression.c
+++ b/admin/vgsuppression.c
@@ -18,7 +18,6 @@
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
-#define _GNU_SOURCE
 
 /*
   just place any problematic calls where valgrind whines about in main (with comments please)
diff --git a/configure.ac b/configure.ac
index e179d8a24..b06820e0e 100644
--- a/configure.ac
+++ b/configure.ac
@@ -23,6 +23,8 @@ AC_COPYRIGHT([
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 ])
 
+AC_GNU_SOURCE
+
 #
 # Required programs
 #
@@ -37,11 +39,12 @@ AC_PROG_LIBTOOL
 # test for headers
 #
 AC_STDC_HEADERS
-AC_CHECK_HEADER([nobug.h], AC_DEFINE(HAVE_NOBUG_H))
-AC_CHECK_HEADER([execinfo.h], AC_DEFINE(HAVE_EXECINFO_H))
-# there is a warning in nobug, disabled til fixed AC_CHECK_HEADER([valgrind/valgrind.h], AC_DEFINE(HAVE_VALGRIND_VALGRIND_H))
 
 ACX_PTHREAD
+LIBS="$PTHREAD_LIBS $LIBS"
+CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
+CC="$PTHREAD_CC"
+
 ##AM_CONDITIONAL([HAVE_THREADING], [test x"$acx_pthread_ok" = xyes])
 
 
@@ -71,9 +74,62 @@ AC_ARG_ENABLE(release, AC_HELP_STRING([--enable-release], [select NoBug RELEASE
               nobug_level=alpha
               AC_DEFINE(EBUG_ALPHA)
 )])])
-AC_MSG_RESULT([NoBug build level: $nobug_level])
 # END NoBug
 
+# C headers and libraries
+AC_LANG_PUSH([C])
+
+AC_CHECK_HEADER([nobug.h],
+        AC_DEFINE(HAVE_NOBUG_H),
+        AC_MSG_ERROR([NoBug header missing                      (http://www.pipapo.org/pipawiki/NoBug)])
+        )
+AC_CHECK_LIB([nobugmt],  nobug_thread_id_get,
+        ,
+        AC_MSG_ERROR([NoBug multithreading library missing      (http://www.pipapo.org/pipawiki/NoBug)])
+        )
+
+AC_CHECK_HEADER([execinfo.h], AC_DEFINE(HAVE_EXECINFO_H))
+# there is a warning in nobug, disabled til fixed AC_CHECK_HEADER([valgrind/valgrind.h], AC_DEFINE(HAVE_VALGRIND_VALGRIND_H))
+
+AC_LANG_POP([C])
+
+
+# C++ headers and libraries
+AC_LANG_PUSH([C++])
+
+AC_CHECK_HEADER([tr1/memory],
+        ,
+        AC_MSG_ERROR([std::tr1 proposed standard extension for shared_ptr missing])
+        )
+
+AC_CHECK_HEADER([boost/shared_ptr.hpp],
+        ,
+        AC_MSG_ERROR([boost::shared_ptr missing                 (http://www.boost.org/)])
+        )
+
+AC_CHECK_HEADER([boost/program_options.hpp],
+        ,
+        AC_MSG_ERROR([boost::program_options missing            (http://www.boost.org/)])
+        )
+# checking for library left out, name contains compiler version here  (libboost_program_options-gcc42-mt-1_34_1.so.1.34.1) any ides how to use that?
+
+AC_CHECK_HEADER([boost/regex.hpp],
+        ,
+        AC_MSG_ERROR([boost::regex missing                      (http://www.boost.org/)])
+        )
+
+AC_LANG_POP([C++])
+
+
+# Print a summary
+AC_MSG_RESULT([
+Configuration Summary:])
+AC_MSG_RESULT([        NoBug build level:               $nobug_level])
+# Add more summary results here
+
+AC_MSG_RESULT([
+Configuration complete, you can now build Lumiera with 'make'
+])
 
 ############## Internatinalization
 #GETTEXT_PACKAGE=gtk-lumiera
diff --git a/src/backend/Makefile.am b/src/backend/Makefile.am
index 5f693f8bf..8b33df06a 100644
--- a/src/backend/Makefile.am
+++ b/src/backend/Makefile.am
@@ -21,17 +21,20 @@ noinst_LIBRARIES += liblumibackend.a
 liblumibackend_a_CFLAGS = $(CFLAGS) -std=gnu99 -Wall -Werror
 liblumibackend_a_CPPFLAGS = -I$(top_srcdir)/src/
 
-liblumibackend_a_SOURCES = \
-	$(liblumibackend_a_srcdir)/backend.c \
-	$(liblumibackend_a_srcdir)/file.c \
-	$(liblumibackend_a_srcdir)/filehandle.c \
-	$(liblumibackend_a_srcdir)/filedescriptor.c \
+liblumibackend_a_SOURCES =					\
+	$(liblumibackend_a_srcdir)/mediaaccessfacade.cpp	\
+	$(liblumibackend_a_srcdir)/backend.c			\
+	$(liblumibackend_a_srcdir)/file.c			\
+	$(liblumibackend_a_srcdir)/filehandle.c			\
+	$(liblumibackend_a_srcdir)/filedescriptor.c		\
 	$(liblumibackend_a_srcdir)/filehandlecache.c
 
-noinst_HEADERS += \
-	$(liblumibackend_a_srcdir)/backend.h \
-	$(liblumibackend_a_srcdir)/file.h \
-	$(liblumibackend_a_srcdir)/filehandle.h \
-	$(liblumibackend_a_srcdir)/filedescriptor.h \
+
+noinst_HEADERS +=						\
+	$(liblumibackend_a_srcdir)/mediaaccessfacade.cpp	\
+	$(liblumibackend_a_srcdir)/backend.h			\
+	$(liblumibackend_a_srcdir)/file.h			\
+	$(liblumibackend_a_srcdir)/filehandle.h			\
+	$(liblumibackend_a_srcdir)/filedescriptor.h		\
 	$(liblumibackend_a_srcdir)/filehandlecache.h
 
diff --git a/src/backend/backend.c b/src/backend/backend.c
new file mode 100644
index 000000000..024f7e6f8
--- /dev/null
+++ b/src/backend/backend.c
@@ -0,0 +1,53 @@
+/*
+  backend  -  common lumiera backend things
+
+  Copyright (C)         Lumiera.org
+    2008,               Christian Thaeter <ct@pipapo.org>
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License as
+  published by the Free Software Foundation; either version 2 of the
+  License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include "backend/backend.h"
+#include "backend/filehandlecache.h"
+#include "backend/filedescriptor.h"
+
+//NOBUG_DEFINE_FLAG_PARENT (backend, lumiera); TODO
+NOBUG_DEFINE_FLAG (backend);
+NOBUG_DEFINE_FLAG_PARENT (file_all, backend);
+
+int
+lumiera_backend_init (void)
+{
+  NOBUG_INIT_FLAG (backend);
+  NOBUG_INIT_FLAG (file_all);
+  NOBUG_INIT_FLAG (file);
+  TRACE (backend);
+  lumiera_filedescriptor_registry_init ();
+
+  int max_entries = 10;         TODO("determine by sysconf (_SC_OPEN_MAX) minus some (big) safety margin "
+                                     "add some override to run tests with few filehandles");
+
+  lumiera_filehandlecache_new (max_entries);
+
+  return 0;
+}
+
+void
+lumiera_backend_destroy (void)
+{
+  TRACE (backend);
+  lumiera_filedescriptor_registry_destroy ();
+  lumiera_filehandlecache_delete ();
+}
diff --git a/src/backend/backend.h b/src/backend/backend.h
new file mode 100644
index 000000000..bd4c86815
--- /dev/null
+++ b/src/backend/backend.h
@@ -0,0 +1,36 @@
+/*
+  backend  -  common lumiera backend things
+
+  Copyright (C)         Lumiera.org
+    2008,               Christian Thaeter <ct@pipapo.org>
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License as
+  published by the Free Software Foundation; either version 2 of the
+  License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+#ifndef LUMIERA_BACKEND_H
+#define LUMIERA_BACKEND_H
+
+#include <nobug.h>
+
+NOBUG_DECLARE_FLAG (backend);
+NOBUG_DECLARE_FLAG (file_all);
+NOBUG_DECLARE_FLAG (file);
+
+int
+lumiera_backend_init (void);
+
+void
+lumiera_backend_destroy (void);
+
+#endif
diff --git a/src/backend/file.c b/src/backend/file.c
new file mode 100644
index 000000000..9af608567
--- /dev/null
+++ b/src/backend/file.c
@@ -0,0 +1,130 @@
+/*
+  file.c  -  file handling
+
+  Copyright (C)         Lumiera.org
+    2008,               Christian Thaeter <ct@pipapo.org>
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License as
+  published by the Free Software Foundation; either version 2 of the
+  License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include "lib/mutex.h"
+#include "lib/safeclib.h"
+
+#include "backend/file.h"
+#include "backend/filehandlecache.h"
+#include "backend/filedescriptor.h"
+
+#include <limits.h>
+#include <unistd.h>
+
+NOBUG_DEFINE_FLAG_PARENT (file, file_all);
+
+LUMIERA_ERROR_DEFINE(FILE_CHANGED, "File changed unexpected");
+
+
+LumieraFile
+lumiera_file_init (LumieraFile self, const char* name, int flags)
+{
+  TRACE (file);
+  if (!(self->descriptor = lumiera_filedescriptor_acquire (name, flags)))
+    return NULL;
+  self->name = lumiera_strndup (name, PATH_MAX);
+
+  return self;
+}
+
+LumieraFile
+lumiera_file_destroy (LumieraFile self)
+{
+  TRACE (file);
+  lumiera_filedescriptor_release (self->descriptor);
+  free ((void*)self->name);
+  return self;
+}
+
+
+LumieraFile
+lumiera_file_new (const char* name, int flags)
+{
+  TRACE (file);
+  LumieraFile self = lumiera_malloc (sizeof (lumiera_file));
+  return lumiera_file_init (self, name, flags);
+}
+
+void
+lumiera_file_delete (LumieraFile self)
+{
+  TRACE (file);
+  free (lumiera_file_destroy (self));
+}
+
+
+int
+lumiera_file_handle_acquire (LumieraFile self)
+{
+  TRACE (file);
+  REQUIRE (self);
+  REQUIRE (self->descriptor);
+  REQUIRE (lumiera_fhcache);
+
+  LUMIERA_MUTEX_SECTION (file, self->descriptor->rh, &self->descriptor->lock)
+    {
+      if (!self->descriptor->handle)
+        /* no handle yet, get a new one */
+        lumiera_filehandlecache_handle_acquire (lumiera_fhcache, self->descriptor);
+      else
+        lumiera_filehandlecache_checkout (lumiera_fhcache, self->descriptor->handle);
+
+      if (self->descriptor->handle->fd == -1)
+        {
+          int fd;
+          fd = open (self->name, self->descriptor->flags & LUMIERA_FILE_MASK);
+          if (fd == -1)
+            {
+              LUMIERA_ERROR_SET (file, ERRNO);
+            }
+          else
+            {
+              struct stat st;
+              if (fstat (fd, &st) == -1)
+                {
+                  close (fd);
+                  LUMIERA_ERROR_SET (file, ERRNO);
+                }
+              else if (self->descriptor->stat.st_dev != st.st_dev || self->descriptor->stat.st_ino != st.st_ino)
+                {
+                  close (fd);
+                  /* Woops this is not the file we expected to use */
+                  LUMIERA_ERROR_SET (file, FILE_CHANGED);
+                }
+            }
+          self->descriptor->handle->fd = fd;
+        }
+    }
+
+  return self->descriptor->handle->fd;
+}
+
+
+void
+lumiera_file_handle_release (LumieraFile self)
+{
+  TRACE (file);
+
+  LUMIERA_MUTEX_SECTION (file, self->descriptor->rh, &self->descriptor->lock)
+    {
+      lumiera_filehandlecache_checkin (lumiera_fhcache, self->descriptor->handle);
+    }
+}
diff --git a/src/backend/file.h b/src/backend/file.h
new file mode 100644
index 000000000..bba12a167
--- /dev/null
+++ b/src/backend/file.h
@@ -0,0 +1,123 @@
+/*
+  file.h  -  interface to files by filename
+
+  Copyright (C)         Lumiera.org
+    2008,               Christian Thaeter <ct@pipapo.org>
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License as
+  published by the Free Software Foundation; either version 2 of the
+  License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#ifndef LUMIERA_FILE_H
+#define LUMIERA_FILE_H
+
+
+#include "lib/mutex.h"
+#include "lib/llist.h"
+#include "lib/error.h"
+
+NOBUG_DECLARE_FLAG (file);
+
+LUMIERA_ERROR_DECLARE(FILE_CHANGED);
+
+/**
+ * @file
+ * File management
+ * Handling Files is splitted into different classes:
+ * 1. The 'lumiera_file' class which acts as interface to the outside for managing files.
+ *    'lumiera_file' is addressed by the name of the file. Since files can have more than one name (hardlinks)
+ *    many 'lumiera_file' can point to a single 'lumiera_filedescriptor'
+ * 2. The 'lumiera_filedescriptor' class which does the real work managing the file in the back.
+ * 3. Since OS-filehandles are a limited resource we access the lazily as 'lumiera_filehandle' which are
+ *    managed in a 'lumiera_filehandlecache'
+ */
+
+typedef struct lumiera_file_struct lumiera_file;
+typedef lumiera_file* LumieraFile;
+
+
+#include "backend/filehandle.h"
+#include "backend/filedescriptor.h"
+
+#define LUMIERA_FILE_READONLY (O_RDONLY | O_LARGEFILE | O_NOATIME)
+#define LUMIERA_FILE_READWRITE (O_RDWR | O_LARGEFILE | O_NOATIME)
+#define LUMIERA_FILE_CREATE (O_RDWR | O_LARGEFILE | O_NOATIME | O_CREAT | O_EXCL)
+#define LUMIERA_FILE_RECREATE (O_RDWR | O_LARGEFILE | O_NOATIME | O_CREAT | O_TRUNC)
+
+/* creat and excl flags will be masked out for descriptor lookup */
+#define LUMIERA_FILE_MASK ~(O_CREAT | O_EXCL | O_TRUNC)
+
+struct lumiera_file_struct
+{
+  const char* name;
+  LumieraFiledescriptor descriptor;
+};
+
+/**
+ * Initialize a file structure.
+ * @param self pointer to the file structure
+ * @param name filename
+ * @param flags open flags
+ * @return self
+ */
+LumieraFile
+lumiera_file_init (LumieraFile self, const char* name, int flags);
+
+/**
+ * Destroy a file structure.
+ * frees all associated resources, releases the filedescriptor etc.
+ * @param self file structure to be destroyed
+ * @return self
+ */
+LumieraFile
+lumiera_file_destroy (LumieraFile self);
+
+/**
+ * Allocate a new file structure.
+ * @param name filename
+ * @param flags open flags
+ * @return new file structure
+ */
+LumieraFile
+lumiera_file_new (const char* name, int flags);
+
+/**
+ * Frees a file structure.
+ * @param self file structure to be freed
+ */
+void
+lumiera_file_delete (LumieraFile self);
+
+/**
+ * Get a POSIX filehandle for a file.
+ * Filehandles are opened on demand and must be acquired for use.
+ * Using filehandles is refcounted and might be nested.
+ * After using them they must be released which puts them back into filehandlecache aging.
+ * @param self file structure
+ * @return POSIX filehandle or -1 on error, check lumiera_error() to retrieve the errorcode
+ * Currently only LUMIERA_ERROR_ERRNO will be raised but this might change in future.
+ * Opening files can fail for many reasons and at any time!
+ */
+int
+lumiera_file_handle_acquire (LumieraFile self);
+
+/**
+ * Put filehandle back into cache aging.
+ * @param self file which handle to be released
+ */
+void
+lumiera_file_handle_release (LumieraFile self);
+
+#endif
+
diff --git a/src/backend/filedescriptor.c b/src/backend/filedescriptor.c
new file mode 100644
index 000000000..b9608984f
--- /dev/null
+++ b/src/backend/filedescriptor.c
@@ -0,0 +1,240 @@
+/*
+  filedescriptor.c  -  file handling
+
+  Copyright (C)         Lumiera.org
+    2008,               Christian Thaeter <ct@pipapo.org>
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License as
+  published by the Free Software Foundation; either version 2 of the
+  License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include "lib/mutex.h"
+#include "lib/safeclib.h"
+#include "lib/cuckoo.h"
+
+#include "backend/file.h"
+#include "backend/filedescriptor.h"
+#include "backend/filehandle.h"
+#include "backend/filehandlecache.h"
+
+#include <sys/types.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <unistd.h>
+
+
+NOBUG_DEFINE_FLAG_PARENT (filedescriptor, file_all);
+
+/*
+  Filedescriptor registry
+
+  This registry stores all acquired filedescriptors for lookup, they will be freed when not referenced anymore.
+ */
+static Cuckoo registry = NULL;
+static lumiera_mutex registry_mutex = {PTHREAD_MUTEX_INITIALIZER};
+
+/*
+ * setup hashing and compare functions for cuckoo hashing
+ */
+static size_t
+h1 (const void* item, const uint32_t r)
+{
+  const LumieraFiledescriptor i = *(const LumieraFiledescriptor*)item;
+  return i->stat.st_dev^i->stat.st_ino^(i->flags&LUMIERA_FILE_MASK)
+    ^((i->stat.st_dev^i->stat.st_ino^(i->flags&LUMIERA_FILE_MASK))>>7)^r;
+}
+
+static size_t
+h2 (const void* item, const uint32_t r)
+{
+  const LumieraFiledescriptor i = *(const LumieraFiledescriptor*)item;
+  return i->stat.st_dev^i->stat.st_ino^(i->flags&LUMIERA_FILE_MASK)
+    ^((i->stat.st_dev^i->stat.st_ino^(i->flags&LUMIERA_FILE_MASK))>>5)^r;
+}
+
+static size_t
+h3 (const void* item, const uint32_t r)
+{
+  const LumieraFiledescriptor i = *(const LumieraFiledescriptor*)item;
+  return i->stat.st_dev^i->stat.st_ino^(i->flags&LUMIERA_FILE_MASK)
+    ^((i->stat.st_dev^i->stat.st_ino^(i->flags&LUMIERA_FILE_MASK))>>3)^r;
+}
+
+
+static int
+cmp (const void* keya, const void* keyb)
+{
+  const LumieraFiledescriptor a = *(const LumieraFiledescriptor*)keya;
+  const LumieraFiledescriptor b = *(const LumieraFiledescriptor*)keyb;
+  return a->stat.st_dev == b->stat.st_dev && a->stat.st_ino == b->stat.st_ino
+    && (a->flags&LUMIERA_FILE_MASK) == (b->flags&LUMIERA_FILE_MASK);
+}
+
+void
+lumiera_filedescriptor_registry_init (void)
+{
+  NOBUG_INIT_FLAG (filedescriptor);
+  TRACE (filedescriptor);
+  REQUIRE (!registry);
+
+  registry = cuckoo_new (h1, h2, h3, cmp,
+                         sizeof (LumieraFiledescriptor),
+                         3);
+  if (!registry)
+    LUMIERA_DIE (NO_MEMORY);
+}
+
+void
+lumiera_filedescriptor_registry_destroy (void)
+{
+  TRACE (filedescriptor);
+  REQUIRE (!cuckoo_nelements (registry));
+  if (registry)
+    cuckoo_free (registry);
+  registry = NULL;
+}
+
+
+LumieraFiledescriptor
+lumiera_filedescriptor_acquire (const char* name, int flags)
+{
+  TRACE (filedescriptor, "%s", name);
+  REQUIRE (registry, "not initialized");
+
+  lumiera_mutexacquirer registry_lock;
+  lumiera_mutexacquirer_init_mutex (&registry_lock, &registry_mutex, LUMIERA_LOCKED);
+
+  lumiera_filedescriptor fdesc;
+  fdesc.flags = flags;
+
+  if (stat (name, &fdesc.stat) != 0)
+    {
+      if (errno == ENOENT && flags&O_CREAT)
+        {
+          char* dir = lumiera_tmpbuf_strndup (name, PATH_MAX);
+          char* slash = dir;
+          while ((slash = strchr (slash+1, '/')))
+            {
+              *slash = '\0';
+              INFO (filedescriptor, "try creating dir: %s", dir);
+              if (mkdir (dir, 0777) == -1 && errno != EEXIST)
+                {
+                  LUMIERA_ERROR_SET (filedescriptor, ERRNO);
+                  goto efile;
+                }
+              *slash = '/';
+            }
+          int fd;
+          INFO (filedescriptor, "try creating file: %s", name);
+          fd = creat (name, 0777);
+          if (fd == -1)
+            {
+              LUMIERA_ERROR_SET (filedescriptor, ERRNO);
+              goto efile;
+            }
+          close (fd);
+          if (stat (name, &fdesc.stat) != 0)
+            {
+              /* finally, no luck */
+              LUMIERA_ERROR_SET (filedescriptor, ERRNO);
+              goto efile;
+            }
+        }
+    }
+
+  /* lookup/create descriptor */
+  LumieraFiledescriptor dest = &fdesc;
+  LumieraFiledescriptor* found = cuckoo_find (registry, &dest);
+
+  if (!found)
+    {
+      TRACE (filedescriptor, "Descriptor not found");
+
+      dest = lumiera_filedescriptor_new (&fdesc);
+      if (!dest)
+        goto ecreate;
+
+      cuckoo_insert (registry, &dest);
+    }
+  else
+    {
+      TRACE (filedescriptor, "Descriptor already existing");
+      dest = *found;
+      ++dest->refcount;
+    }
+
+  lumiera_mutexacquirer_unlock (&registry_lock);
+  return dest;
+
+ efile:
+ ecreate:
+  lumiera_mutexacquirer_unlock (&registry_lock);
+  return NULL;
+}
+
+
+void
+lumiera_filedescriptor_release (LumieraFiledescriptor self)
+{
+  TRACE (filedescriptor);
+  if (!--self->refcount)
+    lumiera_filedescriptor_delete (self);
+}
+
+
+LumieraFiledescriptor
+lumiera_filedescriptor_new (LumieraFiledescriptor template)
+{
+  LumieraFiledescriptor self = lumiera_malloc (sizeof (lumiera_filedescriptor));
+  TRACE (filedescriptor, "at %p", self);
+
+  self->stat = template->stat;
+
+  self->flags = template->flags;
+  lumiera_mutex_init (&self->lock);
+  self->refcount = 1;
+  self->handle = 0;
+
+  const char* type = "mutex";
+  const char* name = "filedescriptor";
+
+  RESOURCE_ANNOUNCE (filedescriptor, type, name, self, self->rh);
+
+  return self;
+}
+
+
+void
+lumiera_filedescriptor_delete (LumieraFiledescriptor self)
+{
+  TRACE (filedescriptor, "%p", self);
+  lumiera_mutexacquirer registry_lock;
+  lumiera_mutexacquirer_init_mutex (&registry_lock, &registry_mutex, LUMIERA_LOCKED);
+
+  REQUIRE (self->refcount == 0);
+
+  RESOURCE_FORGET (filedescriptor, self->rh);
+
+  cuckoo_remove (registry, cuckoo_find (registry, &self));
+
+  TODO ("destruct other members (WIP)");
+
+
+  TODO ("release filehandle");
+
+  lumiera_mutex_destroy (&self->lock);
+  free (self);
+
+  lumiera_mutexacquirer_unlock (&registry_lock);
+}
diff --git a/src/backend/filedescriptor.h b/src/backend/filedescriptor.h
new file mode 100644
index 000000000..528be41e8
--- /dev/null
+++ b/src/backend/filedescriptor.h
@@ -0,0 +1,113 @@
+/*
+  filedescriptor.h  -  file handling
+
+  Copyright (C)         Lumiera.org
+    2008,               Christian Thaeter <ct@pipapo.org>
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License as
+  published by the Free Software Foundation; either version 2 of the
+  License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#ifndef LUMIERA_FILEDESCRIPTOR_H
+#define LUMIERA_FILEDESCRIPTOR_H
+
+#include "lib/mutex.h"
+
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+typedef struct lumiera_filedescriptor_struct lumiera_filedescriptor;
+typedef lumiera_filedescriptor* LumieraFiledescriptor;
+
+
+#include "backend/filehandle.h"
+#include "backend/file.h"
+
+/**
+ * @file
+ * Filedescriptors.
+ * Filedescriptors are the underlying working horse in accessing files.
+ * All information associated with managing a file is kept here.
+ */
+
+
+
+struct lumiera_filedescriptor_struct
+{
+  struct stat stat;                     /* create after first open, maintained metadata, MUST BE FIRST! */
+  int flags;                            /* open flags, must be masked for reopen */
+  lumiera_mutex lock;                   /* locks operations on this file descriptor */
+  unsigned refcount;                    /* reference counter, all users sans registry */
+
+  LumieraFilehandle handle;
+  //LumieraFileMap mappings;
+  //LumieraWriteBuffer writebuffer;
+
+  RESOURCE_HANDLE (rh);
+};
+
+/**
+ * Initialize the global filedescriptor registry.
+ * All filedescriptors are looked up by dev/ino/open-flags in a hashtable. Opening hardlinked
+ * files will be targeted to the same filedescriptor.
+ * This function never fails but dies on error.
+ */
+void
+lumiera_filedescriptor_registry_init (void);
+
+/**
+ * Destroy and free the global filedescriptor registry.
+ * Never fails.
+ */
+void
+lumiera_filedescriptor_registry_destroy (void);
+
+
+/**
+ * Find existing filedescriptor or create one
+ * @param name name of the file
+ * @param flags opening flags for the filedescriptor
+ * @return descriptor on success or NULL on error
+ */
+LumieraFiledescriptor
+lumiera_filedescriptor_acquire (const char* name, int flags);
+
+
+/**
+ * Release a filedescriptor.
+ * @param self filedescriptor to be released
+ */
+void
+lumiera_filedescriptor_release (LumieraFiledescriptor self);
+
+
+/**
+ * Allocate a new filedescriptor cloned from a template
+ * @param template the source filedescriptor
+ * @return the constrccted filedescriptor
+ */
+LumieraFiledescriptor
+lumiera_filedescriptor_new (LumieraFiledescriptor template);
+
+/**
+ * Delete a filedescriptor
+ * Called whenever its reference count drops to zero.
+ * @param self the filedescriptor to be deleted
+ */
+void
+lumiera_filedescriptor_delete (LumieraFiledescriptor self);
+
+#endif
diff --git a/src/backend/filehandle.c b/src/backend/filehandle.c
new file mode 100644
index 000000000..60d54cf82
--- /dev/null
+++ b/src/backend/filehandle.c
@@ -0,0 +1,70 @@
+/*
+  filehandle  -  filehandle management and caching
+
+  Copyright (C)         Lumiera.org
+    2008,               Christian Thaeter <ct@pipapo.org>
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License as
+  published by the Free Software Foundation; either version 2 of the
+  License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include "lib/llist.h"
+#include "lib/safeclib.h"
+
+#include "backend/file.h"
+#include "backend/filehandle.h"
+#include "backend/filedescriptor.h"
+
+#include <unistd.h>
+
+NOBUG_DEFINE_FLAG_PARENT (filehandle, file_all);
+
+LumieraFilehandle
+lumiera_filehandle_new ()
+{
+  LumieraFilehandle self = lumiera_malloc (sizeof (lumiera_filehandle));
+  TRACE (filehandle, "%p", self);
+
+  llist_init (&self->cachenode);
+  self->fd = -1;
+  self->use_cnt = 1;
+  self->descriptor = NULL;
+
+  return self;
+}
+
+
+void*
+lumiera_filehandle_destroy_node (LList node)
+{
+  TRACE (filehandle);
+  REQUIRE (llist_is_empty (node));
+  LumieraFilehandle self = (LumieraFilehandle)node;
+  REQUIRE (self->use_cnt == 0);
+
+  if (self->fd >= 0)
+    close (self->fd);
+  self->fd = -1;
+  self->descriptor = NULL;
+  return self;
+}
+
+
+int
+lumiera_filehandle_get (LumieraFilehandle self)
+{
+  REQUIRE (self->descriptor);
+  return -1;
+}
+
diff --git a/src/backend/filehandle.h b/src/backend/filehandle.h
new file mode 100644
index 000000000..e1b02b2e4
--- /dev/null
+++ b/src/backend/filehandle.h
@@ -0,0 +1,69 @@
+/*
+  filehandle  -  filehandle management and caching
+
+  Copyright (C)         Lumiera.org
+    2008,               Christian Thaeter <ct@pipapo.org>
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License as
+  published by the Free Software Foundation; either version 2 of the
+  License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+#ifndef LUMIERA_FILEHANDLE_H
+#define LUMIERA_FILEHANDLE_H
+
+#include "lib/error.h"
+#include "lib/llist.h"
+
+typedef struct lumiera_filehandle_struct lumiera_filehandle;
+typedef lumiera_filehandle* LumieraFilehandle;
+
+#include "backend/filedescriptor.h"
+
+/**
+ * @file
+ * Filehandles.
+ * Filehandles manage the underlying POSIX filehandle for a filedescriptor.
+ * Since we want to support handling of more files than POSIX filehandles are available on a common system
+ * the filehandles are opened, cached and closed on demand, see 'filehandlecache'.
+ */
+
+
+/**
+ * File handles
+ */
+struct lumiera_filehandle_struct
+{
+  llist cachenode;
+  int fd;
+  unsigned use_cnt;
+  LumieraFiledescriptor descriptor;
+};
+
+/**
+ * Allocate a new filehandle structure.
+ * @return new filehandle structure
+ */
+LumieraFilehandle
+lumiera_filehandle_new ();
+
+
+/**
+ * destroy the resources associated eith a filehandle structure.
+ * This function is used by the filehandlecache to recycle filehandle structs.
+ * @param node pointer to the cachenode member of a struct filehandle
+ * @return pointer to the start of the memory of the destroyed filehandle
+ */
+void*
+lumiera_filehandle_destroy_node (LList node);
+
+#endif
diff --git a/src/backend/filehandlecache.c b/src/backend/filehandlecache.c
new file mode 100644
index 000000000..181807661
--- /dev/null
+++ b/src/backend/filehandlecache.c
@@ -0,0 +1,138 @@
+/*
+  filehandlecache  -  filehandle management and caching
+
+  Copyright (C)         Lumiera.org
+    2008,               Christian Thaeter <ct@pipapo.org>
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License as
+  published by the Free Software Foundation; either version 2 of the
+  License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include "lib/safeclib.h"
+
+#include "backend/file.h"
+#include "backend/filehandlecache.h"
+
+NOBUG_DEFINE_FLAG_PARENT (filehandlecache, file_all);
+
+/* errors */
+
+LUMIERA_ERROR_DEFINE (FILEHANDLECACHE_NOHANDLE, "No filehandle available");
+
+
+LumieraFilehandlecache lumiera_fhcache = NULL;
+
+
+void
+lumiera_filehandlecache_new (int max_entries)
+{
+  REQUIRE (!lumiera_fhcache, "Filehandlecache already initialized");
+
+  NOBUG_INIT_FLAG (filehandlecache);
+  lumiera_fhcache = lumiera_malloc (sizeof (lumiera_filehandlecache));
+  lumiera_mrucache_init (&lumiera_fhcache->cache, lumiera_filehandle_destroy_node);
+  lumiera_fhcache->available = max_entries;
+  lumiera_fhcache->checked_out = 0;
+  lumiera_mutex_init (&lumiera_fhcache->lock);
+  RESOURCE_ANNOUNCE (filehandlecache, "mutex", "filehandlecache", lumiera_fhcache, lumiera_fhcache->rh);
+}
+
+
+void
+lumiera_filehandlecache_delete (void)
+{
+  if (lumiera_fhcache)
+    {
+      REQUIRE (!lumiera_fhcache->checked_out, "Filehandles in use at shutdown");
+      RESOURCE_FORGET (filehandlecache, lumiera_fhcache->rh);
+      lumiera_mrucache_destroy (&lumiera_fhcache->cache);
+      lumiera_mutex_destroy (&lumiera_fhcache->lock);
+      free (lumiera_fhcache);
+      lumiera_fhcache = NULL;
+    }
+}
+
+
+LumieraFilehandle
+lumiera_filehandlecache_handle_acquire (LumieraFilehandlecache self, LumieraFiledescriptor desc)
+{
+  TRACE (filehandlecache);
+  LumieraFilehandle ret = NULL;
+  LUMIERA_MUTEX_SECTION (filehandlecache, self->rh, &self->lock)
+  {
+    if (self->available <= 0 && self->cache.cached)
+      {
+        /* pop a filehandle from cache */
+        ret = lumiera_mrucache_pop (&self->cache);
+        if (self->available < 0)
+          /* try to free overallocated filehandles */
+          self->available -= self->available + lumiera_mrucache_age (&self->cache, -self->available);
+      }
+    else
+      {
+        /* allocate new filehandle if we are below the limit or no cached handles are available (overallocating) */
+        ret = lumiera_filehandle_new ();
+        if (!ret)
+          LUMIERA_ERROR_SET (filehandlecache, FILEHANDLECACHE_NOHANDLE);
+        else
+          --self->available;
+      }
+    ret->use_cnt = 1;
+    ret->descriptor = desc;
+    desc->handle = ret;
+    ++self->checked_out;
+  }
+  return ret;
+}
+
+
+LumieraFilehandle
+lumiera_filehandlecache_checkout (LumieraFilehandlecache self, LumieraFilehandle handle)
+{
+  REQUIRE (self);
+  REQUIRE (handle);
+  /* This function is called with the associated descriptor locked, nothing can modify 'handle' */
+  if (!handle->use_cnt)
+    {
+      /* lock cache and checkout */
+      LUMIERA_MUTEX_SECTION (filehandlecache, self->rh, &self->lock)
+        {
+          lumiera_mrucache_checkout (&self->cache, &handle->cachenode);
+        }
+    }
+  ++handle->use_cnt;
+  ++self->checked_out;
+
+  return handle;
+}
+
+void
+lumiera_filehandlecache_checkin (LumieraFilehandlecache self, LumieraFilehandle handle)
+{
+  REQUIRE (self);
+  REQUIRE (handle);
+  REQUIRE (handle->use_cnt);
+
+  /* This function is called with the associated descriptor locked, nothing can modify 'self' */
+  if (!--handle->use_cnt)
+    {
+      /* lock cache and checin */
+      LUMIERA_MUTEX_SECTION (filehandlecache, self->rh, &self->lock)
+        {
+          --self->checked_out;
+          lumiera_mrucache_checkin (&self->cache, &handle->cachenode);
+        }
+    }
+}
+
diff --git a/src/backend/filehandlecache.h b/src/backend/filehandlecache.h
new file mode 100644
index 000000000..37c2a416b
--- /dev/null
+++ b/src/backend/filehandlecache.h
@@ -0,0 +1,108 @@
+/*
+  filehandlecache  -  filehandle management and caching
+
+  Copyright (C)         Lumiera.org
+    2008,               Christian Thaeter <ct@pipapo.org>
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License as
+  published by the Free Software Foundation; either version 2 of the
+  License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+#ifndef LUMIERA_FILEHANDLECACHE_H
+#define LUMIERA_FILEHANDLECACHE_H
+
+#include "lib/error.h"
+#include "lib/mrucache.h"
+#include "lib/mutex.h"
+
+typedef struct lumiera_filehandlecache_struct lumiera_filehandlecache;
+typedef lumiera_filehandlecache* LumieraFilehandlecache;
+
+#include "backend/filehandle.h"
+
+/**
+ * @file
+ * Filehandle management and caching
+ * The number of filehandles a program can held open is usually limited, since we want to support
+ * using a less limited number of files and closing/opening for each operation is expensive, we
+ * provide a cache to keep the most frequent used files open and gracefully close/recycle unused filehandles.
+ * The filehandlecache defined here protects all operations on the cache with a mutex.
+ */
+
+
+/*
+  File handle cache manages file handles
+ */
+struct lumiera_filehandlecache_struct
+{
+  lumiera_mrucache cache;
+  int available;
+  int checked_out;
+  lumiera_mutex lock;
+  RESOURCE_HANDLE (rh);
+};
+
+extern LumieraFilehandlecache lumiera_fhcache;
+
+/**
+ * Initializes the filehandle cache.
+ * @param max_entries number how much filehandles shall be managed
+ * The number of elements the cache can hold is static and should be
+ * determined by sysconf (_SC_OPEN_MAX) minus some (big) safety margin.
+ */
+void
+lumiera_filehandlecache_new (int max_entries);
+
+/**
+ * Delete the filehandle cache.
+ * No filehandles in the cache must be locked, this would be a fatal error.
+ * The handles are closed automatically.
+ */
+void
+lumiera_filehandlecache_delete (void);
+
+/**
+ * Get a fresh filehandle.
+ * @param self pointer to the cache
+ * @return the new filehandle
+ */
+LumieraFilehandle
+lumiera_filehandlecache_handle_acquire (LumieraFilehandlecache self, LumieraFiledescriptor desc);
+
+/**
+ * Add filehande back to cache, the filehandle becomes subject of aging.
+ * @param self pointer to the cache
+ * @param handle filehandle to be put back
+ */
+void
+lumiera_filehandlecache_add_filehandle (LumieraFilehandlecache self, LumieraFilehandle handle);
+
+/**
+ * Remove a filehandle from cache aging
+ * Filehandles which are subject of cache aging must be checked out before they can be used.
+ * @param self the filehandlecache
+ * @param handle the filehandle to be checked out
+ */
+LumieraFilehandle
+lumiera_filehandlecache_checkout (LumieraFilehandlecache self, LumieraFilehandle handle);
+
+/**
+ * Put a filehandle into the cache
+ * Filehandles which are checked in are subject of cache aging and might get destroyed and reused.
+ * @param self the filehandlecache
+ * @param handle the filehandle to be checked in
+ */
+void
+lumiera_filehandlecache_checkin (LumieraFilehandlecache self, LumieraFilehandle handle);
+
+#endif
diff --git a/src/backend/mmap.h b/src/backend/mmap.h
new file mode 100644
index 000000000..608e40133
--- /dev/null
+++ b/src/backend/mmap.h
@@ -0,0 +1,88 @@
+/*
+  mmap.h  -  memory mapped acces to files
+
+  Copyright (C)         Lumiera.org
+    2008,               Christian Thaeter <ct@pipapo.org>
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License as
+  published by the Free Software Foundation; either version 2 of the
+  License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#ifndef LUMIERA_MMAP_H
+#define LUMIERA_MMAP_H
+
+#include "lib/llist.h"
+
+
+typedef struct lumiera_mmap_struct lumiera_mmap;
+typedef lumiera_mmap* LumieraMMap;
+
+
+#include "backend/filedescriptor.h"
+
+
+#include <nobug.h>
+#include <sys/mman.h>
+
+NOBUG_DECLARE_FLAG (mmap);
+
+/**
+ * @file
+ * MMap objects cover a memory maped range in a file
+ */
+
+
+
+/**
+ * mmaped area
+ *
+ */
+struct lumiera_mmap_struct
+{
+  /** used for the mrucache when checked in the cache OR for attaching owners when checked out **/
+  llist cachenode;
+
+  /** all mmaps of a file are chained in this list, used to find ranges **/
+  llist searchnode;
+
+  off_t start;
+  size_t size;
+  void* address;
+
+  /** array with refcounters per page **/
+  unsigned short* refmap;
+
+  /** 0 when this mmap is in cache, else the count of attached owners **/
+  unsigned use_cnt;
+  //RESOURCE_HANDLE (rh);
+};
+
+
+LumieraMMap
+lumiera_mmap_init (LumieraMMap self, LumieraFile file, LList acquirer, off_t start, size_t size, size_t chunksize);
+
+LumieraMMap
+lumiera_mmap_new (LumieraFile file, LList acquirer, off_t start, size_t size, size_t chunksize);
+
+void*
+lumiera_mmap_destroy_node (LList node);
+
+#endif
+/*
+// Local Variables:
+// mode: C
+// c-file-style: "gnu"
+// indent-tabs-mode: nil
+// End:
+*/
diff --git a/src/backend/mmapcache.h b/src/backend/mmapcache.h
new file mode 100644
index 000000000..ed2efcb43
--- /dev/null
+++ b/src/backend/mmapcache.h
@@ -0,0 +1,136 @@
+/*
+  mmapcache.h  -  handle aging of mmap objects
+
+  Copyright (C)         Lumiera.org
+    2008,               Christian Thaeter <ct@pipapo.org>
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License as
+  published by the Free Software Foundation; either version 2 of the
+  License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#ifndef LUMIERA_MMAPCACHE_H
+#define LUMIERA_MMAPCACHE_H
+
+#include "lib/error.h"
+#include "lib/mrucache.h"
+#include "lib/mutex.h"
+
+
+typedef struct lumiera_mmapcache_struct lumiera_mmapcache;
+typedef lumiera_mmapcache* LumieraMMapcache;
+
+#include "backend/mmap.h"
+
+#include <nobug.h>
+
+/**
+ * @file
+ * Mmapcache stores a MRU cache of all established mmaped memory regions which are currently not in use.
+ * The mmapcache also manages the upper limit about how much memory can be mmaped.
+ */
+
+struct lumiera_mmapcache_struct
+{
+  lumiera_mrucache cache;
+  size_t limit;
+  size_t total;
+  size_t cached;
+  lumiera_mutex lock;
+  RESOURCE_HANDLE (rh);
+};
+
+extern LumieraMMapcache lumiera_mcache;
+
+
+/**
+ * Initializes the mmapcache.
+ * @param limit the mmapcache will drop elements when the sum of all mmapings gives over limit
+ */
+void
+lumiera_mmapcache_new (size_t limit);
+
+/**
+ * Delete the mmap cache.
+ * No mmaps in the cache must be locked, this would be a fatal error.
+ * The handles are closed automatically.
+ */
+void
+lumiera_mmapcache_delete (void);
+
+/**
+ * Get a fresh mmap object.
+ * when mmaped_limit is reached, the oldest mmap object gets dropped else a new allocated object
+ * is returned
+ * @param self pointer to the cache
+ * @return the new mmap
+ */
+LumieraMMap
+lumiera_mmapcache_mmap_acquire (LumieraMMapcache self);
+
+
+/**
+ * Announce a new mmap object to the cache quotas.
+ * Update the statistics kept in the cache,
+ * the map object is still considered to be checked out
+ * @param self pointer to the cache
+ * @param map object to be announced
+ */
+void
+lumiera_mmapcache_announce (LumieraMMapcache self, LumieraMMap map);
+
+/**
+ * Remove a mmap object from the cache quotas.
+ * Update the statistics kept in the cache,
+ * called by mmap's destructor only
+ * @param self pointer to the cache
+ * @param map object to be removed
+ */
+void
+lumiera_mmapcache_forget (LumieraMMapcache self, LumieraMMap map);
+
+/**
+ * Destroy and free the nelem oldest elements.
+ * Used to free up resources and memory.
+ * @param self cache where to free elements.
+ * @return nelem-(numer of elements which got freed), that is 0 if all requested elements got freed
+ */
+int
+lumiera_mmapcache_age (LumieraMMapcache self);
+
+/**
+ * Remove a mmap from cache aging
+ * Mmaps which are subject of cache aging must be checked out before they can be used.
+ * @param self the mmapcache
+ * @param handle the mmap to be checked out
+ */
+LumieraMMap
+lumiera_mmapcache_checkout (LumieraMMapcache self, LumieraMMap handle);
+
+/**
+ * Put a mmap into the cache
+ * Mmaps which are checked in are subject of cache aging and might get destroyed and reused.
+ * @param self the mmapcache
+ * @param handle the mmap to be checked in
+ */
+void
+lumiera_mmapcache_checkin (LumieraMMapcache self, LumieraMMap handle);
+
+#endif
+/*
+// Local Variables:
+// mode: C
+// c-file-style: "gnu"
+// indent-tabs-mode: nil
+// End:
+*/
diff --git a/src/backend/mmapings.h b/src/backend/mmapings.h
new file mode 100644
index 000000000..234ab280b
--- /dev/null
+++ b/src/backend/mmapings.h
@@ -0,0 +1,118 @@
+/*
+  mmapings.h  -  manage ranges of mmaped areas on a filedescriptor
+
+  Copyright (C)         Lumiera.org
+    2008,               Christian Thaeter <ct@pipapo.org>
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License as
+  published by the Free Software Foundation; either version 2 of the
+  License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#ifndef LUMIERA_MMAPINGS_H
+#define LUMIERA_MMAPINGS_H
+
+#include "lib/mutex.h"
+#include "lib/llist.h"
+
+typedef struct lumiera_mmapings_struct lumiera_mmapings;
+typedef lumiera_mmapings* LumieraMMapings;
+
+#include "backend/filedescriptor.h"
+#include "backend/mmap.h"
+
+#include <nobug.h>
+
+
+/**
+ * @file
+ * Keeps all mmaped areas
+ *
+ */
+
+struct lumiera_mmapings_struct
+{
+  /** mmaped ranges are kept in an list sorted by the size of the mmaping, might be improved to a tree someday **/
+  llist mmaps;
+
+  /** sum of all mmaped areas, areas might be overlapping **/
+  //  size_t vsz;
+
+  /**
+   * chunkssize is the smallest granularity which is used for mmapping files, it
+   * should reflect the intended file usage, that is 'pagesize' for small or non growing
+   * files and some MB for media files. Must be a 2's exponent of pagesize.
+   **/
+  size_t chunksize;
+
+  LumieraFiledescriptor descriptor;
+  lumiera_mutex lock;
+  RESOURCE_HANDLE (rh);
+};
+
+/**
+ * initialize mmapings container
+ *
+ */
+LumieraMMapings
+lumiera_mmapings_init (LumieraMMapings self, LumieraFile file, size_t chunksize);
+
+/**
+ * destroy mmapings container and free all resources.
+ *
+ */
+LumieraMMapings
+lumiera_mmapings_destroy (LumieraMMapings self);
+
+/**
+ * allocate and initialize new mmapings container
+ *
+ */
+LumieraMMapings
+lumiera_mmapings_new (LumieraFile file, size_t chunksize);
+
+/**
+ * destroy and free mmapings container and all its resources
+ *
+ */
+void
+lumiera_mmapings_delete (LumieraMMapings self);
+
+/**
+ * acquire a mmap which covers the given range
+ * @param self mmapings where to search
+ * @param acquirer list node of the new owner which will registered in the mmap
+ * @param start begin of the required range
+ * @param size requested size
+ * @return MMap object covering the requested range or NULL on error
+ */
+LumieraMMap
+lumiera_mmapings_mmap_acquire (LumieraMMapings self, LumieraFile file, LList acquirer, off_t start, size_t size);
+
+/**
+ * release a previously acquired MMap object
+ * @param self mmapings to which the map belongs
+ * @param acquirer holding node
+ * @param map object to be released
+ */
+void
+lumiera_mmapings_release_mmap (LumieraMMapings self, LList acquirer, LumieraMMap map);
+
+#endif
+/*
+// Local Variables:
+// mode: C
+// c-file-style: "gnu"
+// indent-tabs-mode: nil
+// End:
+*/
diff --git a/src/common/Makefile.am b/src/common/Makefile.am
new file mode 100644
index 000000000..06082da31
--- /dev/null
+++ b/src/common/Makefile.am
@@ -0,0 +1,65 @@
+#  Copyright (C)         Lumiera.org
+#    2008,               Christian Thaeter <ct@pipapo.org>
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License as
+#  published by the Free Software Foundation; either version 2 of the
+#  License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+
+# TODO use -Wextra -Werror
+
+liblumicommon_a_srcdir = $(top_srcdir)/src/common
+noinst_LIBRARIES += liblumicommon.a
+
+liblumicommon_a_CXXFLAGS = $(CXXFLAGS) -Wall
+liblumicommon_a_CPPFLAGS = -I$(top_srcdir)/src/
+
+liblumicommon_a_SOURCES =					\
+	$(liblumicommon_a_srcdir)/time.cpp			\
+	$(liblumicommon_a_srcdir)/util.cpp			\
+	$(liblumicommon_a_srcdir)/visitor.cpp			\
+	$(liblumicommon_a_srcdir)/cmdline.cpp			\
+	$(liblumicommon_a_srcdir)/configrules.cpp		\
+	$(liblumicommon_a_srcdir)/error.cpp			\
+	$(liblumicommon_a_srcdir)/query.cpp			\
+	$(liblumicommon_a_srcdir)/query/mockconfigrules.cpp	\
+	$(liblumicommon_a_srcdir)/test/suite.cpp		\
+	$(liblumicommon_a_srcdir)/test/testoption.cpp
+
+
+noinst_HEADERS +=						\
+	$(liblumicommon_a_srcdir)/cmdline.hpp			\
+	$(liblumicommon_a_srcdir)/factory.hpp			\
+	$(liblumicommon_a_srcdir)/singleton.hpp			\
+	$(liblumicommon_a_srcdir)/singletonpolicies.hpp		\
+	$(liblumicommon_a_srcdir)/singletonpreconfigure.hpp	\
+	$(liblumicommon_a_srcdir)/time.hpp			\
+	$(liblumicommon_a_srcdir)/typelist.hpp			\
+	$(liblumicommon_a_srcdir)/visitor.hpp			\
+	$(liblumicommon_a_srcdir)/visitordispatcher.hpp		\
+	$(liblumicommon_a_srcdir)/visitorpolicies.hpp		\
+	$(liblumicommon_a_srcdir)/configrules.hpp		\
+	$(liblumicommon_a_srcdir)/error.hpp			\
+	$(liblumicommon_a_srcdir)/multithread.hpp		\
+	$(liblumicommon_a_srcdir)/p.hpp				\
+	$(liblumicommon_a_srcdir)/query.hpp			\
+	$(liblumicommon_a_srcdir)/query/mockconfigrules.hpp	\
+	$(liblumicommon_a_srcdir)/singletonfactory.hpp		\
+	$(liblumicommon_a_srcdir)/singletonsubclass.hpp		\
+	$(liblumicommon_a_srcdir)/typelistutil.hpp		\
+	$(liblumicommon_a_srcdir)/util.hpp			\
+	$(liblumicommon_a_srcdir)/test/mockinjector.hpp		\
+	$(liblumicommon_a_srcdir)/test/suite.hpp		\
+	$(liblumicommon_a_srcdir)/test/testoption.hpp		\
+	$(liblumicommon_a_srcdir)/test/run.hpp
+
diff --git a/src/lib/Makefile.am b/src/lib/Makefile.am
index 0e0c2f22e..ffdb9a176 100644
--- a/src/lib/Makefile.am
+++ b/src/lib/Makefile.am
@@ -21,28 +21,30 @@ noinst_LIBRARIES += liblumi.a
 liblumi_a_CFLAGS = $(CFLAGS) -std=gnu99 -Wall -Werror
 liblumi_a_CPPFLAGS = -I$(top_srcdir)/src/
 
-liblumi_a_SOURCES = \
-	$(liblumi_a_srcdir)/plugin.c \
-	$(liblumi_a_srcdir)/error.c \
-	$(liblumi_a_srcdir)/mutex.c \
-	$(liblumi_a_srcdir)/rwlock.c \
-	$(liblumi_a_srcdir)/condition.c \
-	$(liblumi_a_srcdir)/references.c \
-	$(liblumi_a_srcdir)/uuid.c \
-	$(liblumi_a_srcdir)/safeclib.c \
-	$(liblumi_a_srcdir)/cuckoo.c \
-	$(liblumi_a_srcdir)/mrucache.c
+liblumi_a_SOURCES =				\
+	$(liblumi_a_srcdir)/plugin.c		\
+	$(liblumi_a_srcdir)/error.c		\
+	$(liblumi_a_srcdir)/mutex.c		\
+	$(liblumi_a_srcdir)/rwlock.c		\
+	$(liblumi_a_srcdir)/condition.c		\
+	$(liblumi_a_srcdir)/references.c	\
+	$(liblumi_a_srcdir)/uuid.c		\
+	$(liblumi_a_srcdir)/safeclib.c		\
+	$(liblumi_a_srcdir)/cuckoo.c		\
+	$(liblumi_a_srcdir)/mrucache.c		\
+	$(liblumi_a_srcdir)/appconfig.cpp
 
-
-noinst_HEADERS += \
-	$(liblumi_a_srcdir)/plugin.h \
-	$(liblumi_a_srcdir)/error.h \
-	$(liblumi_a_srcdir)/locking.h \
-	$(liblumi_a_srcdir)/mutex.h \
-	$(liblumi_a_srcdir)/rwlock.h \
-	$(liblumi_a_srcdir)/condition.h \
-	$(liblumi_a_srcdir)/references.h \
-	$(liblumi_a_srcdir)/uuid.h \
-	$(liblumi_a_srcdir)/safeclib.h \
-	$(liblumi_a_srcdir)/cuckoo.h \
-	$(liblumi_a_srcdir)/mrucache.h
+noinst_HEADERS +=						\
+	$(liblumi_a_srcdir)/plugin.h				\
+	$(liblumi_a_srcdir)/error.h				\
+	$(liblumi_a_srcdir)/locking.h				\
+	$(liblumi_a_srcdir)/mutex.h				\
+	$(liblumi_a_srcdir)/rwlock.h				\
+	$(liblumi_a_srcdir)/condition.h				\
+	$(liblumi_a_srcdir)/references.h			\
+	$(liblumi_a_srcdir)/uuid.h				\
+	$(liblumi_a_srcdir)/safeclib.h				\
+	$(liblumi_a_srcdir)/cuckoo.h				\
+	$(liblumi_a_srcdir)/mrucache.h				\
+	$(liblumi_a_srcdir)/appconfig.hpp			\
+	$(liblumi_a_srcdir)/lifecycleregistry.hpp
diff --git a/src/lib/condition.c b/src/lib/condition.c
index 1bfa2ef96..60e8b6f10 100644
--- a/src/lib/condition.c
+++ b/src/lib/condition.c
@@ -22,7 +22,8 @@
 #include "lib/condition.h"
 
 /**
- * @file Condition variables
+ * @file
+ * Condition variables
  */
 
 LUMIERA_ERROR_DEFINE (CONDITION_DESTROY, "condition destroy failed");
diff --git a/src/lib/condition.h b/src/lib/condition.h
index 066c6b267..dd92f326b 100644
--- a/src/lib/condition.h
+++ b/src/lib/condition.h
@@ -25,7 +25,8 @@
 #include "lib/locking.h"
 
 /**
- * @file Condition variables, header
+ * @file
+ * Condition variables, header
  */
 
 LUMIERA_ERROR_DECLARE (CONDITION_DESTROY);
@@ -167,7 +168,7 @@ lumiera_conditionacquirer_wait (LumieraConditionacquirer self)
  * a conditionacquirer must be unlocked before leaving scope
  * @param self conditionacquirer associated with a condition variable
  */
-static inline int
+static inline void
 lumiera_conditionacquirer_unlock (LumieraConditionacquirer self)
 {
   REQUIRE (self);
@@ -195,7 +196,7 @@ lumiera_conditionacquirer_signal (LumieraConditionacquirer self)
  * signal all waiting threads
  * @param self conditionacquirer associated with the condition variable to be signaled
  */
-static inline int
+static inline void
 lumiera_conditionacquirer_broadcast (LumieraConditionacquirer self)
 {
   REQUIRE (self);
diff --git a/src/lib/cuckoo.c b/src/lib/cuckoo.c
index 0d0b4efef..bbcb0e71a 100644
--- a/src/lib/cuckoo.c
+++ b/src/lib/cuckoo.c
@@ -208,6 +208,13 @@ cuckoo_insert_internal_ (Cuckoo self, void* item)
 }
 
 
+size_t
+cuckoo_nelements (Cuckoo self)
+{
+  return self->elements;
+}
+
+
 static void
 cuckoo_rehash (Cuckoo self)
 {
diff --git a/src/lib/cuckoo.h b/src/lib/cuckoo.h
index db1d33da3..323b5cc75 100644
--- a/src/lib/cuckoo.h
+++ b/src/lib/cuckoo.h
@@ -22,7 +22,8 @@
 #define CUCKOO_H
 
 /**
- * @file Cuckoo hashing
+ * @file
+ * Cuckoo hashing
  * This hashing gives guaranteed O(1) lookup complexity and amortized O(1) insert and remove complexity.
  * Hash tables by default grow and shrink automatically. It is posible to preallocate entries and turn
  * automatic shrinking off taking out the memory management factors for insert and remove operations.
@@ -105,6 +106,13 @@ cuckoo_destroy (Cuckoo self);
 void
 cuckoo_free (Cuckoo self);
 
+/**
+ * Get the number of elements stored in a hash.
+ * @return number of elements, 0 when empty
+ */
+size_t
+cuckoo_nelements (Cuckoo self);
+
 /**
  * Insert an element into a hash.
  * amortized O(1) complexity because it may rarely rehash the tables or even grow them.
diff --git a/src/lib/error.c b/src/lib/error.c
index 81e24bad8..b2bc390b6 100644
--- a/src/lib/error.c
+++ b/src/lib/error.c
@@ -24,7 +24,8 @@
 #include "lib/error.h"
 
 /**
- * @file C Error handling in Lumiera.
+ * @file
+ * C Error handling in Lumiera.
  */
 
 
diff --git a/src/lib/error.h b/src/lib/error.h
index e71c0cdfa..1eeb42dda 100644
--- a/src/lib/error.h
+++ b/src/lib/error.h
@@ -31,7 +31,8 @@ extern "C" {
 #include <stdlib.h>
 
 /**
- * @file C Error handling in Lumiera, header.
+ * @file
+ * C Error handling in Lumiera, header.
  */
 
 
diff --git a/src/lib/llist.h b/src/lib/llist.h
index efb3f5202..128a3e826 100644
--- a/src/lib/llist.h
+++ b/src/lib/llist.h
@@ -27,7 +27,8 @@
 #include <stddef.h>
 
 /**
- * @file Intrusive cyclic double linked list
+ * @file
+ * Intrusive cyclic double linked list
  * There is only one node type which contains a forward and a backward pointer. In a empty initialized node,
  * this pointers point to the node itself. Note that these pointers can never ever become NULL.
  * This lists are used by using one node as 'root' node where its both pointers are the head/tail pointer to the actual list.
diff --git a/src/lib/locking.h b/src/lib/locking.h
index f62dd6c29..3c4d497d8 100644
--- a/src/lib/locking.h
+++ b/src/lib/locking.h
@@ -34,7 +34,8 @@ LUMIERA_ERROR_DECLARE (MUTEX_UNLOCK);
 LUMIERA_ERROR_DECLARE (MUTEX_DESTROY);
 
 /**
- * @file Shared declarations for all locking primitives.
+ * @file
+ * Shared declarations for all locking primitives.
  */
 
 /**
diff --git a/src/lib/mrucache.c b/src/lib/mrucache.c
index d98976184..0f9bb86df 100644
--- a/src/lib/mrucache.c
+++ b/src/lib/mrucache.c
@@ -21,12 +21,6 @@
 
 #include "lib/mrucache.h"
 
-/**
- * @file Most recent used cache
- * Elements (addressed by a LList node) are either in the cache and thereby subject of aging
- * or checked out under control of the user.
- */
-
 
 LumieraMruCache
 lumiera_mrucache_init (LumieraMruCache self, lumiera_cache_destructor_fn destructor_cb)
@@ -43,6 +37,7 @@ lumiera_mrucache_destroy (LumieraMruCache self)
 {
   LLIST_WHILE_TAIL (&self->cache_list, node)
     {
+      llist_unlink (node);
       if (self->destructor_cb)
         free (self->destructor_cb (node));
       else
@@ -52,10 +47,6 @@ lumiera_mrucache_destroy (LumieraMruCache self)
   return self;
 }
 
-
-/**
- * destroy and free the nelem oldest elements
- */
 int
 lumiera_mrucache_age (LumieraMruCache self, int nelem)
 {
diff --git a/src/lib/mrucache.h b/src/lib/mrucache.h
index 8af7434d9..08654754f 100644
--- a/src/lib/mrucache.h
+++ b/src/lib/mrucache.h
@@ -27,14 +27,17 @@
 #include <nobug.h>
 
 /**
- * @file Most recent used cache
- * Elements (addressed by a LList node) are either in the cache and thereby subject of aging
- * or checked out under control of the user.
+ * @file
+ * Most recent used cache
+ * Elements (addressed by a LList node) are either checked in the cache and thereby subject of aging
+ * or checked out under control of the user. Most operations require that the chache is locked. This locking
+ * must be done from elsewhere.
  */
 
 /**
  * Callback function used to destruct/cleanup aged elements.
- * shall clean the element sufficiently up to be ready for being freed or reused
+ * shall clean the element sufficiently up to be ready for being freed or reused,
+ * this callback function must be reentrant and prepared to be called twice.
  * @param node the llist node used to link cache elements (will be empty at call)
  * @return pointer to the begin of the element.
  */
@@ -50,24 +53,34 @@ typedef struct lumiera_mrucache_struct lumiera_mrucache;
 typedef lumiera_mrucache* LumieraMruCache;
 
 /**
- * Initialize a mrucache
+ * Initialize a cache.
+ * @param self cache to be initialized
+ * @param destructor_cb function for destructing a cache node, preparing for reuse.
+ * @return self
  */
 LumieraMruCache
 lumiera_mrucache_init (LumieraMruCache self, lumiera_cache_destructor_fn destructor_cb);
 
-
 /**
- * Destroy a mrucache
+ * Destroy a cache.
+ * frees all checked in items.
+ * @param self cache to be destroyed
+ * @return self
  */
 LumieraMruCache
 lumiera_mrucache_destroy (LumieraMruCache self);
 
 
 /**
- * add an element to a mrucache
+ * Add an element to a mrucache.
+ * When added the element is subject of aging and must not be accessed anymore.
+ * To acces elements they have to be checked out again.
+ * Checkin and checkout operations must be protected by a lock over the cache.
+ * @param self cache where to checkin
+ * @param node a llist member in the cached data which is used as queue in the cache
  */
 static inline void
-lumiera_mrucache_add (LumieraMruCache self, LList node)
+lumiera_mrucache_checkin (LumieraMruCache self, LList node)
 {
   REQUIRE (self);
   REQUIRE (node && llist_is_empty (node));
@@ -77,10 +90,47 @@ lumiera_mrucache_add (LumieraMruCache self, LList node)
 
 
 /**
- * Remove an element from a mrucache.
+ * Schedule an element for fast aging.
+ * When an element is not longer needed it can be placed at the end of the chache
+ * aging queue and thus become the first one to be reused when a new element is queried.
+ * This can be done on a checked out element as well as on an element which is in the cache.
+ * The cache must be locked for this operation.
+ * @param self cache
+ * @param node a llist member in the cached data which is used as queue in the cache
  */
 static inline void
-lumiera_mrucache_remove (LumieraMruCache self, LList node)
+lumiera_mrucache_drop (LumieraMruCache self, LList node)
+{
+  REQUIRE (self);
+  REQUIRE (node);
+
+  if (llist_is_empty (node))
+    {
+      /* was not in list, we need to count it */
+      ++self->cached;
+    }
+  else
+    {
+      /* speedup loop warning :P, this check is costly */
+      REQUIRE (llist_is_member (&self->cache_list, node), "node must be empty or member of cache");
+    }
+  llist_insert_tail (&self->cache_list, node);
+
+  if (self->destructor_cb)
+    self->destructor_cb (node);
+}
+
+
+/**
+ * Checkout an element from a cache.
+ * A checked out element is not under cache control anymore until is gets checked in again.
+ * The code which checked the element out takes ownership of the element.
+ * The cache must be locked for this operation.
+ * @param self cache
+ * @param node a llist member in the cached data which is used as queue in the cache
+ */
+static inline void
+lumiera_mrucache_checkout (LumieraMruCache self, LList node)
 {
   REQUIRE (self);
   REQUIRE (node && llist_is_member (&self->cache_list, node));   /* speedup loop warning :P, this check is costly */
@@ -88,8 +138,13 @@ lumiera_mrucache_remove (LumieraMruCache self, LList node)
   --self->cached;
 }
 
+
 /**
- * destroy the oldest element and return a pointer to it for reuse.
+ * Destroy the oldest element from the cache and return it.
+ * This function is used to get a new element by deleting the oldest least used one from the cache.
+ * The cache must be locked for this operation.
+ * @param self cache
+ * @return pointer to the uninitialized memory ready for being reused
  */
 static inline void*
 lumiera_mrucache_pop (LumieraMruCache self)
@@ -98,7 +153,7 @@ lumiera_mrucache_pop (LumieraMruCache self)
   if (llist_is_empty (&self->cache_list))
     return NULL;
 
-  LList node =  llist_tail (&self->cache_list);
+  LList node = llist_tail (&self->cache_list);
   llist_unlink (node);
   --self->cached;
 
@@ -110,7 +165,11 @@ lumiera_mrucache_pop (LumieraMruCache self)
 
 
 /**
- * destroy and free the nelem oldest elements
+ * Destroy and free the nelem oldest elements.
+ * Used to free up resources and memory.
+ * @param self cache where to free elements.
+ * @param nelem number of elements wished to be freed
+ * @return nelem-(numer of elements which got freed), that is 0 if all requested elements got freed
  */
 int
 lumiera_mrucache_age (LumieraMruCache self, int nelem);
diff --git a/src/lib/mutex.c b/src/lib/mutex.c
index 009502e5a..b7c5f1844 100644
--- a/src/lib/mutex.c
+++ b/src/lib/mutex.c
@@ -22,7 +22,8 @@
 #include "lib/mutex.h"
 
 /**
- * @file Mutual exclusion locking.
+ * @file
+ * Mutual exclusion locking.
  */
 
 LUMIERA_ERROR_DEFINE (MUTEX_LOCK, "Mutex locking failed");
diff --git a/src/lib/mutex.h b/src/lib/mutex.h
index 9381c3ca1..f19058e7a 100644
--- a/src/lib/mutex.h
+++ b/src/lib/mutex.h
@@ -25,14 +25,18 @@
 #include "lib/locking.h"
 
 /**
- * @file Mutual exclusion locking, header.
+ * @file
+ * Mutual exclusion locking, header.
  */
-
-#define LUMIERA_MUTEX_SECTION(mutex)                                                    \
+#define LUMIERA_MUTEX_SECTION(flag, handle, mutex)                                      \
+RESOURCE_HANDLE (rh_##__LINE__##_);                                                     \
 lumiera_mutexacquirer lock_##__LINE__##_;                                               \
+RESOURCE_ENTER (flag, handle, "acquire mutex", &lock_##__LINE__##_,                     \
+                NOBUG_RESOURCE_EXCLUSIVE, rh_##__LINE__##_);                            \
 for (lumiera_mutexacquirer_init_mutex (&lock_##__LINE__##_, mutex, LUMIERA_LOCKED);     \
      lock_##__LINE__##_.state == LUMIERA_LOCKED;                                        \
-     lumiera_mutexacquirer_unlock (&lock_##__LINE__##_))
+     lumiera_mutexacquirer_unlock (&lock_##__LINE__##_),                                \
+       ({RESOURCE_LEAVE(flag, rh_##__LINE__##_);}))
 
 
 /**
diff --git a/src/lib/plugin.c b/src/lib/plugin.c
index 8345d9887..1f5e8576e 100644
--- a/src/lib/plugin.c
+++ b/src/lib/plugin.c
@@ -31,7 +31,8 @@
 #include "safeclib.h"
 
 /**
- * @file Plugin loader.
+ * @file
+ * Plugin loader.
  */
 
 
diff --git a/src/lib/plugin.h b/src/lib/plugin.h
index f8916ae96..54dad6372 100644
--- a/src/lib/plugin.h
+++ b/src/lib/plugin.h
@@ -33,7 +33,8 @@ extern "C" {
 #include "error.h"
 
 /**
- * @file Plugin loader, header.
+ * @file
+ * Plugin loader, header.
  */
 
 
diff --git a/src/lib/references.c b/src/lib/references.c
index 3e9d5f260..925258377 100644
--- a/src/lib/references.c
+++ b/src/lib/references.c
@@ -22,7 +22,8 @@
 #include "lib/safeclib.h"
 
 /**
- * @file Strong and Weak references
+ * @file
+ * Strong and Weak references
  * Strong references keep some object alive while they existing
  * Weak references become invalidated when the referenced object gets destroyed
  *
diff --git a/src/lib/references.h b/src/lib/references.h
index 3e00457e7..6ad65d62f 100644
--- a/src/lib/references.h
+++ b/src/lib/references.h
@@ -25,7 +25,8 @@
 #include <nobug.h>
 
 /**
- * @file Strong and Weak references, header.
+ * @file
+ * Strong and Weak references, header.
  */
 
 
diff --git a/src/lib/rwlock.c b/src/lib/rwlock.c
index 0862aa808..077ff9766 100644
--- a/src/lib/rwlock.c
+++ b/src/lib/rwlock.c
@@ -18,8 +18,6 @@
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
-#define _GNU_SOURCE
-
 #include <errno.h>
 #include "lib/rwlock.h"
 
@@ -31,7 +29,8 @@ LUMIERA_ERROR_DEFINE(RWLOCK_RLOCK, "rlock");
 LUMIERA_ERROR_DEFINE(RWLOCK_WLOCK, "wlock");
 
 /**
- * @file Read/write locks.
+ * @file
+ * Read/write locks.
  */
 
 
diff --git a/src/lib/rwlock.h b/src/lib/rwlock.h
index 5e121fbcc..d58627dda 100644
--- a/src/lib/rwlock.h
+++ b/src/lib/rwlock.h
@@ -39,7 +39,8 @@ LUMIERA_ERROR_DECLARE(RWLOCK_RLOCK);
 LUMIERA_ERROR_DECLARE(RWLOCK_WLOCK);
 
 /**
- * @file Read/write locks, header.
+ * @file
+ * Read/write locks, header.
  */
 
 
diff --git a/src/lib/safeclib.c b/src/lib/safeclib.c
index 71e347ab7..f500ea71c 100644
--- a/src/lib/safeclib.c
+++ b/src/lib/safeclib.c
@@ -1,7 +1,7 @@
 /*
   safe_clib.c  -  Portable and safe wrapers around some clib functions and some tools
 
-  Copyright (C)         CinelerraCV
+  Copyright (C)         Lumiera.org
     2008,               Christian Thaeter <ct@pipapo.org>
 
   This program is free software; you can redistribute it and/or
@@ -18,8 +18,6 @@
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
-#define _GNU_SOURCE
-
 #include "error.h"
 
 #include <string.h>
@@ -29,7 +27,8 @@
 #include <stdarg.h>
 
 /**
- * @file Portable and safe wrapers around some clib functions and some tools
+ * @file
+ * Portable and safe wrapers around some clib functions and some tools
  */
 
 LUMIERA_ERROR_DEFINE (NO_MEMORY, "Out of Memory!");
@@ -41,9 +40,26 @@ LUMIERA_ERROR_DEFINE (NO_MEMORY, "Out of Memory!");
  * @return pointer to the allocated memory
  */
 void*
-lumiera_malloc (size_t sz)
+lumiera_malloc (size_t size)
 {
-  void* o = sz? malloc (sz) : NULL;
+  void* o = size ? malloc (size) : NULL;
+  if (!o)
+    LUMIERA_DIE (NO_MEMORY);
+  return o;
+}
+
+
+/**
+ * Allocate cleared memory for an array.
+ * always succeeds or dies
+ * @param n number of elements
+ * @param size memory to be allocated
+ * @return pointer to the allocated memory
+ */
+void*
+lumiera_calloc (size_t n, size_t size)
+{
+  void* o = (n&&size)? calloc (n, size) : NULL;
   if (!o)
     LUMIERA_DIE (NO_MEMORY);
   return o;
@@ -122,7 +138,6 @@ static void
 lumiera_tmpbuf_destroy (void* buf)
 {
   lumiera_tmpbuf_freeall ();
-  free (buf);
 }
 
 static void
@@ -141,17 +156,13 @@ lumiera_tmpbuf_freeall (void)
 {
   pthread_once (&lumiera_tmpbuf_tls_once, lumiera_tmpbuf_init);
   struct lumiera_tmpbuf_struct* buf = pthread_getspecific (lumiera_tmpbuf_tls_key);
-  if (!buf)
-    pthread_setspecific (lumiera_tmpbuf_tls_key,
-                         buf = lumiera_malloc (sizeof (struct lumiera_tmpbuf_struct)));
-
-  for (buf->idx = 0; buf->idx < 64; ++buf->idx)
+  if (buf)
     {
-      free (buf->buffers[buf->idx]);
-      buf->buffers[buf->idx] = NULL;
-      buf->sizes[buf->idx] = 0;
+      pthread_setspecific (lumiera_tmpbuf_tls_key, NULL);
+      for (int idx = 0; idx < 64; ++idx)
+        free (buf->buffers[idx]);
+      free (buf);
     }
-  buf->idx = 0;
 }
 
 
@@ -167,7 +178,7 @@ lumiera_tmpbuf_provide (size_t size)
   struct lumiera_tmpbuf_struct* buf = pthread_getspecific (lumiera_tmpbuf_tls_key);
   if (!buf)
     pthread_setspecific (lumiera_tmpbuf_tls_key,
-                         buf = lumiera_malloc (sizeof (struct lumiera_tmpbuf_struct)));
+                         buf = lumiera_calloc (1, sizeof (struct lumiera_tmpbuf_struct)));
 
   buf->idx = (buf->idx + 1) & 0x3f;
 
@@ -196,7 +207,7 @@ lumiera_tmpbuf_strndup (const char* src, size_t size)
 
 
 char*
-lumiera_tmpbuf_sprintf (size_t size, const char* fmt, ...)
+lumiera_tmpbuf_snprintf (size_t size, const char* fmt, ...)
 {
   va_list args;
 
@@ -205,9 +216,9 @@ lumiera_tmpbuf_sprintf (size_t size, const char* fmt, ...)
   va_end (args);
 
   len = len > size ? size : len;
-  char* buf = lumiera_tmpbuf_provide (len);
+  char* buf = lumiera_tmpbuf_provide (len+1);
   va_start (args, fmt);
-  vsnprintf (buf, len, fmt, args);
+  vsnprintf (buf, len+1, fmt, args);
   va_end (args);
 
   return buf;
diff --git a/src/lib/safeclib.h b/src/lib/safeclib.h
index 02d931cb7..6fc532239 100644
--- a/src/lib/safeclib.h
+++ b/src/lib/safeclib.h
@@ -24,7 +24,8 @@
 #include <stdlib.h>
 
 /**
- * @file Portable and safe wrapers around some clib functions and some tools
+ * @file
+ * Portable and safe wrapers around some clib functions and some tools
  */
 LUMIERA_ERROR_DECLARE(NO_MEMORY);
 
@@ -38,6 +39,17 @@ void*
 lumiera_malloc (size_t sz);
 
 
+/**
+ * Allocate cleared memory for an array.
+ * always succeeds or dies
+ * @param n number of elements
+ * @param size memory to be allocated
+ * @return pointer to the allocated memory
+ */
+void*
+lumiera_calloc (size_t n, size_t size);
+
+
 /**
  * Duplicate a C string.
  * always succeeds or dies
@@ -84,7 +96,6 @@ lumiera_streq (const char* a, const char* b);
 void
 lumiera_tmpbuf_freeall (void);
 
-
 /**
  * Query a thread local tmpbuf.
  * @param size minimal needed size for the tmpbuf
@@ -110,5 +121,5 @@ lumiera_tmpbuf_strndup (const char* src, size_t size);
  * @return temporary buffer containing the constructed of the string
  */
 char*
-lumiera_tmpbuf_sprintf (size_t size, const char* fmt, ...);
+lumiera_tmpbuf_snprintf (size_t size, const char* fmt, ...);
 
diff --git a/src/proc/Makefile.am b/src/proc/Makefile.am
new file mode 100644
index 000000000..603f4d825
--- /dev/null
+++ b/src/proc/Makefile.am
@@ -0,0 +1,251 @@
+#  Copyright (C)         Lumiera.org
+#    2008,               Christian Thaeter <ct@pipapo.org>
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License as
+#  published by the Free Software Foundation; either version 2 of the
+#  License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+
+# TODO use -Wextra -Werror
+
+liblumiproc_a_srcdir = $(top_srcdir)/src/proc
+noinst_LIBRARIES += liblumiproc.a
+
+liblumiproc_a_CXXFLAGS = $(CXXFLAGS) -Wall
+liblumiproc_a_CPPFLAGS = -I$(top_srcdir)/src/
+
+liblumiproc_a_SOURCES =							\
+	$(liblumiproc_a_srcdir)/controllerfacade.cpp			\
+	$(liblumiproc_a_srcdir)/frame.cpp				\
+	$(liblumiproc_a_srcdir)/stateproxy.cpp				\
+	$(liblumiproc_a_srcdir)/asset.cpp				\
+	$(liblumiproc_a_srcdir)/assetmanager.cpp			\
+	$(liblumiproc_a_srcdir)/nobugcfg.cpp
+
+
+
+liblumiprocasset_a_srcdir = $(top_srcdir)/src/proc/asset
+noinst_LIBRARIES += liblumiprocasset.a
+
+liblumiprocasset_a_CXXFLAGS = $(CXXFLAGS) -Wall
+liblumiprocasset_a_CPPFLAGS = -I$(top_srcdir)/src/
+
+liblumiprocasset_a_SOURCES =				\
+	$(liblumiprocasset_a_srcdir)/codec.cpp		\
+	$(liblumiprocasset_a_srcdir)/compoundmedia.cpp	\
+	$(liblumiprocasset_a_srcdir)/dataset.cpp	\
+	$(liblumiprocasset_a_srcdir)/effect.cpp		\
+	$(liblumiprocasset_a_srcdir)/preview.cpp	\
+	$(liblumiprocasset_a_srcdir)/unknown.cpp	\
+	$(liblumiprocasset_a_srcdir)/clip.cpp		\
+	$(liblumiprocasset_a_srcdir)/meta.cpp		\
+	$(liblumiprocasset_a_srcdir)/category.cpp	\
+	$(liblumiprocasset_a_srcdir)/media.cpp		\
+	$(liblumiprocasset_a_srcdir)/pipe.cpp		\
+	$(liblumiprocasset_a_srcdir)/proc.cpp		\
+	$(liblumiprocasset_a_srcdir)/procpatt.cpp	\
+	$(liblumiprocasset_a_srcdir)/struct.cpp		\
+	$(liblumiprocasset_a_srcdir)/track.cpp
+
+
+
+liblumiprocengine_a_srcdir = $(top_srcdir)/src/proc/engine
+noinst_LIBRARIES += liblumiprocengine.a
+
+liblumiprocengine_a_CXXFLAGS = $(CXXFLAGS) -Wall
+liblumiprocengine_a_CPPFLAGS = -I$(top_srcdir)/src/
+
+liblumiprocengine_a_SOURCES =				\
+	$(liblumiprocengine_a_srcdir)/aframe.cpp	\
+	$(liblumiprocengine_a_srcdir)/arender.cpp	\
+	$(liblumiprocengine_a_srcdir)/codecadapter.cpp	\
+	$(liblumiprocengine_a_srcdir)/exitnode.cpp	\
+	$(liblumiprocengine_a_srcdir)/glbuf.cpp		\
+	$(liblumiprocengine_a_srcdir)/glpipe.cpp	\
+	$(liblumiprocengine_a_srcdir)/glrender.cpp	\
+	$(liblumiprocengine_a_srcdir)/hub.cpp		\
+	$(liblumiprocengine_a_srcdir)/link.cpp		\
+	$(liblumiprocengine_a_srcdir)/mask.cpp		\
+	$(liblumiprocengine_a_srcdir)/pluginadapter.cpp	\
+	$(liblumiprocengine_a_srcdir)/processor.cpp	\
+	$(liblumiprocengine_a_srcdir)/procnode.cpp	\
+	$(liblumiprocengine_a_srcdir)/projector.cpp	\
+	$(liblumiprocengine_a_srcdir)/renderengine.cpp	\
+	$(liblumiprocengine_a_srcdir)/source.cpp	\
+	$(liblumiprocengine_a_srcdir)/trafo.cpp		\
+	$(liblumiprocengine_a_srcdir)/vframe.cpp	\
+	$(liblumiprocengine_a_srcdir)/vrender.cpp
+
+
+
+liblumiprocmobject_a_srcdir = $(top_srcdir)/src/proc/mobject
+noinst_LIBRARIES += liblumiprocmobject.a
+
+liblumiprocmobject_a_CXXFLAGS = $(CXXFLAGS) -Wall
+liblumiprocmobject_a_CPPFLAGS = -I$(top_srcdir)/src/
+
+liblumiprocmobject_a_SOURCES =					\
+	$(liblumiprocmobject_a_srcdir)/builderfacade.cpp	\
+	$(liblumiprocmobject_a_srcdir)/interpolator.cpp		\
+	$(liblumiprocmobject_a_srcdir)/mobject.cpp		\
+	$(liblumiprocmobject_a_srcdir)/parameter.cpp		\
+	$(liblumiprocmobject_a_srcdir)/paramprovider.cpp	\
+	$(liblumiprocmobject_a_srcdir)/placement.cpp
+
+
+
+liblumiprocmobjectbuilder_a_srcdir = $(top_srcdir)/src/proc/mobject/builder
+noinst_LIBRARIES += liblumiprocmobjectbuilder.a
+
+liblumiprocmobjectbuilder_a_CXXFLAGS = $(CXXFLAGS) -Wall
+liblumiprocmobjectbuilder_a_CPPFLAGS = -I$(top_srcdir)/src/
+
+liblumiprocmobjectbuilder_a_SOURCES =					\
+	$(liblumiprocmobjectbuilder_a_srcdir)/assembler.cpp		\
+	$(liblumiprocmobjectbuilder_a_srcdir)/conmanager.cpp		\
+	$(liblumiprocmobjectbuilder_a_srcdir)/nodecreatertool.cpp	\
+	$(liblumiprocmobjectbuilder_a_srcdir)/segmentationtool.cpp	\
+	$(liblumiprocmobjectbuilder_a_srcdir)/toolfactory.cpp
+
+
+liblumiprocmobjectcontroller_a_srcdir = $(top_srcdir)/src/proc/mobject/controller
+noinst_LIBRARIES += liblumiprocmobjectcontroller.a
+
+liblumiprocmobjectcontroller_a_CXXFLAGS = $(CXXFLAGS) -Wall
+liblumiprocmobjectcontroller_a_CPPFLAGS = -I$(top_srcdir)/src/
+
+liblumiprocmobjectcontroller_a_SOURCES =				\
+	$(liblumiprocmobjectcontroller_a_srcdir)/pathmanager.cpp	\
+	$(liblumiprocmobjectcontroller_a_srcdir)/renderstate.cpp
+
+
+liblumiprocmobjectsession_a_srcdir = $(top_srcdir)/src/proc/mobject/session
+noinst_LIBRARIES += liblumiprocmobjectsession.a
+
+liblumiprocmobjectsession_a_CXXFLAGS = $(CXXFLAGS) -Wall
+liblumiprocmobjectsession_a_CPPFLAGS = -I$(top_srcdir)/src/
+
+liblumiprocmobjectsession_a_SOURCES =					\
+	$(liblumiprocmobjectsession_a_srcdir)/abstractmo.cpp		\
+	$(liblumiprocmobjectsession_a_srcdir)/allocation.cpp		\
+	$(liblumiprocmobjectsession_a_srcdir)/auto.cpp			\
+	$(liblumiprocmobjectsession_a_srcdir)/compoundclip.cpp		\
+	$(liblumiprocmobjectsession_a_srcdir)/effect.cpp		\
+	$(liblumiprocmobjectsession_a_srcdir)/fixedlocation.cpp		\
+	$(liblumiprocmobjectsession_a_srcdir)/label.cpp			\
+	$(liblumiprocmobjectsession_a_srcdir)/meta.cpp			\
+	$(liblumiprocmobjectsession_a_srcdir)/relativelocation.cpp	\
+	$(liblumiprocmobjectsession_a_srcdir)/segment.cpp		\
+	$(liblumiprocmobjectsession_a_srcdir)/simpleclip.cpp		\
+	$(liblumiprocmobjectsession_a_srcdir)/plug.cpp			\
+	$(liblumiprocmobjectsession_a_srcdir)/sessionimpl.cpp		\
+	$(liblumiprocmobjectsession_a_srcdir)/sessmanagerimpl.cpp	\
+	$(liblumiprocmobjectsession_a_srcdir)/edl.cpp			\
+	$(liblumiprocmobjectsession_a_srcdir)/session.cpp		\
+	$(liblumiprocmobjectsession_a_srcdir)/track.cpp			\
+	$(liblumiprocmobjectsession_a_srcdir)/clip.cpp			\
+	$(liblumiprocmobjectsession_a_srcdir)/constraint.cpp		\
+	$(liblumiprocmobjectsession_a_srcdir)/defsmanager.cpp		\
+	$(liblumiprocmobjectsession_a_srcdir)/fixture.cpp		\
+	$(liblumiprocmobjectsession_a_srcdir)/locatingpin.cpp		\
+	$(liblumiprocmobjectsession_a_srcdir)/mobjectfactory.cpp	\
+	$(liblumiprocmobjectsession_a_srcdir)/wish.cpp
+
+
+
+
+noinst_HEADERS +=							\
+	$(liblumiproc_a_srcdir)/asset/category.hpp			\
+	$(liblumiproc_a_srcdir)/asset/clip.hpp				\
+	$(liblumiproc_a_srcdir)/asset/codec.hpp				\
+	$(liblumiproc_a_srcdir)/asset/compoundmedia.hpp			\
+	$(liblumiproc_a_srcdir)/asset/dataset.hpp			\
+	$(liblumiproc_a_srcdir)/asset/effect.hpp			\
+	$(liblumiproc_a_srcdir)/asset/preview.hpp			\
+	$(liblumiproc_a_srcdir)/asset/db.hpp				\
+	$(liblumiproc_a_srcdir)/asset/buildinstruct.hpp			\
+	$(liblumiproc_a_srcdir)/asset/media.hpp				\
+	$(liblumiproc_a_srcdir)/asset/meta.hpp				\
+	$(liblumiproc_a_srcdir)/asset/pipe.hpp				\
+	$(liblumiproc_a_srcdir)/asset/proc.hpp				\
+	$(liblumiproc_a_srcdir)/asset/procpatt.hpp			\
+	$(liblumiproc_a_srcdir)/asset/struct.hpp			\
+	$(liblumiproc_a_srcdir)/asset/structfactoryimpl.hpp		\
+	$(liblumiproc_a_srcdir)/asset/track.hpp				\
+	$(liblumiproc_a_srcdir)/asset/unknown.hpp			\
+	$(liblumiproc_a_srcdir)/controllerfacade.hpp			\
+	$(liblumiproc_a_srcdir)/engine/aframe.hpp			\
+	$(liblumiproc_a_srcdir)/engine/arender.hpp			\
+	$(liblumiproc_a_srcdir)/engine/codecadapter.hpp			\
+	$(liblumiproc_a_srcdir)/engine/exitnode.hpp			\
+	$(liblumiproc_a_srcdir)/engine/glbuf.hpp			\
+	$(liblumiproc_a_srcdir)/engine/glpipe.hpp			\
+	$(liblumiproc_a_srcdir)/engine/glrender.hpp			\
+	$(liblumiproc_a_srcdir)/engine/hub.hpp				\
+	$(liblumiproc_a_srcdir)/engine/link.hpp				\
+	$(liblumiproc_a_srcdir)/engine/mask.hpp				\
+	$(liblumiproc_a_srcdir)/engine/pluginadapter.hpp		\
+	$(liblumiproc_a_srcdir)/engine/procnode.hpp			\
+	$(liblumiproc_a_srcdir)/engine/projector.hpp			\
+	$(liblumiproc_a_srcdir)/engine/renderengine.hpp			\
+	$(liblumiproc_a_srcdir)/engine/source.hpp			\
+	$(liblumiproc_a_srcdir)/engine/trafo.hpp			\
+	$(liblumiproc_a_srcdir)/engine/vframe.hpp			\
+	$(liblumiproc_a_srcdir)/engine/vrender.hpp			\
+	$(liblumiproc_a_srcdir)/engine/processor.hpp			\
+	$(liblumiproc_a_srcdir)/frame.hpp				\
+	$(liblumiproc_a_srcdir)/mobject/builder/assembler.hpp		\
+	$(liblumiproc_a_srcdir)/mobject/builder/buildertool.hpp		\
+	$(liblumiproc_a_srcdir)/mobject/builder/conmanager.hpp		\
+	$(liblumiproc_a_srcdir)/mobject/builder/nodecreatertool.hpp	\
+	$(liblumiproc_a_srcdir)/mobject/builder/segmentationtool.hpp	\
+	$(liblumiproc_a_srcdir)/mobject/builder/toolfactory.hpp		\
+	$(liblumiproc_a_srcdir)/mobject/builderfacade.hpp		\
+	$(liblumiproc_a_srcdir)/mobject/controller/pathmanager.hpp	\
+	$(liblumiproc_a_srcdir)/mobject/controller/renderstate.hpp	\
+	$(liblumiproc_a_srcdir)/mobject/interpolator.hpp		\
+	$(liblumiproc_a_srcdir)/mobject/parameter.hpp			\
+	$(liblumiproc_a_srcdir)/mobject/paramprovider.hpp		\
+	$(liblumiproc_a_srcdir)/mobject/session/abstractmo.hpp		\
+	$(liblumiproc_a_srcdir)/mobject/session/allocation.hpp		\
+	$(liblumiproc_a_srcdir)/mobject/session/auto.hpp		\
+	$(liblumiproc_a_srcdir)/mobject/session/compoundclip.hpp	\
+	$(liblumiproc_a_srcdir)/mobject/session/effect.hpp		\
+	$(liblumiproc_a_srcdir)/mobject/session/fixedlocation.hpp	\
+	$(liblumiproc_a_srcdir)/mobject/session/label.hpp		\
+	$(liblumiproc_a_srcdir)/mobject/session/meta.hpp		\
+	$(liblumiproc_a_srcdir)/mobject/session/relativelocation.hpp	\
+	$(liblumiproc_a_srcdir)/mobject/session/simpleclip.hpp		\
+	$(liblumiproc_a_srcdir)/mobject/session/mobjectfactory.hpp	\
+	$(liblumiproc_a_srcdir)/mobject/session/segment.hpp		\
+	$(liblumiproc_a_srcdir)/mobject/session/track.hpp		\
+	$(liblumiproc_a_srcdir)/mobject/session/wish.hpp		\
+	$(liblumiproc_a_srcdir)/mobject/session/clip.hpp		\
+	$(liblumiproc_a_srcdir)/mobject/session/constraint.hpp		\
+	$(liblumiproc_a_srcdir)/mobject/session/defsmanager.hpp		\
+	$(liblumiproc_a_srcdir)/mobject/session/edl.hpp			\
+	$(liblumiproc_a_srcdir)/mobject/session/fixture.hpp		\
+	$(liblumiproc_a_srcdir)/mobject/session/locatingpin.hpp		\
+	$(liblumiproc_a_srcdir)/mobject/session/plug.hpp		\
+	$(liblumiproc_a_srcdir)/mobject/session/sessionimpl.hpp		\
+	$(liblumiproc_a_srcdir)/mobject/session/defsregistry.hpp	\
+	$(liblumiproc_a_srcdir)/mobject/explicitplacement.hpp		\
+	$(liblumiproc_a_srcdir)/mobject/mobject.hpp			\
+	$(liblumiproc_a_srcdir)/mobject/placement.hpp			\
+	$(liblumiproc_a_srcdir)/mobject/session.hpp			\
+	$(liblumiproc_a_srcdir)/stateproxy.hpp				\
+	$(liblumiproc_a_srcdir)/asset.hpp				\
+	$(liblumiproc_a_srcdir)/assetmanager.hpp			\
+	$(liblumiproc_a_srcdir)/lumiera.hpp				\
+	$(liblumiproc_a_srcdir)/nobugcfg.hpp
+
diff --git a/tests/20filedescriptor.tests b/tests/20filedescriptor.tests
new file mode 100644
index 000000000..78639e7b8
--- /dev/null
+++ b/tests/20filedescriptor.tests
@@ -0,0 +1,26 @@
+
+TESTING "Filedescriptor management" ./test-filedescriptors
+
+echo testdata > ,tmp_testfile
+
+TEST "acquire existing file" acquire_existing <<END
+return: 0
+END
+
+TEST "acquire existing file twice" acquire_existing_again <<END
+return: 0
+END
+
+rm ,tmp_testfile
+
+TEST "acquire file, creating it" acquire_create <<END
+return: 0
+END
+
+rm ,tmp_testfile
+
+TEST "acquire file, creating it, nested dir" acquire_create_dir <<END
+return: 0
+END
+
+rm ,tmp_testdir -r
diff --git a/tests/20filehandle.tests b/tests/20filehandle.tests
new file mode 100644
index 000000000..0365bbffc
--- /dev/null
+++ b/tests/20filehandle.tests
@@ -0,0 +1,13 @@
+
+TESTING "Filehandle management" ./test-filehandles
+
+
+TEST "basic filehandle usage" basic <<END
+return: 0
+END
+
+rm -rf ,tmpdir
+
+TEST "using many filehandles" more <<END
+return: 0
+END
diff --git a/tests/50components.tests b/tests/50components.tests
index 2bac409cb..18f04ee4b 100644
--- a/tests/50components.tests
+++ b/tests/50components.tests
@@ -62,7 +62,7 @@ out: caught error::Logic: LUMIERA_ERROR_FATAL:floundered (test-2).
 out: caught error::Invalid: LUMIERA_ERROR_INVALID:invalid input or parameters (test-3).
 out: caught lumiera::Error: LUMIERA_ERROR_EXTERNAL:failure in external service (test-4).
 out: caught std::runtime_error: test-5
-out: caught std::exception: St9exception
+out: caught std::exception: std::exception
 out: intermediate handler caught: LUMIERA_ERROR_EXTERNAL:failure in external service (test-7).....will rethrow as error::State
 out: caught lumiera::Error: LUMIERA_ERROR_STATE:unforseen state -- caused by: LUMIERA_ERROR_EXTERNAL:failure in external service (test-7).
 out: intermediate handler caught: LUMIERA_ERROR_EXTERNAL:failure in external service (test-8).....will rethrow as error::State
diff --git a/tests/Makefile.am b/tests/Makefile.am
index a6ccae010..c51133995 100644
--- a/tests/Makefile.am
+++ b/tests/Makefile.am
@@ -1,5 +1,5 @@
 #  Copyright (C)         Lumiera.org
-#    2007,               Christian Thaeter <ct@pipapo.org>
+#    2007-2008,          Christian Thaeter <ct@pipapo.org>
 #                        Hermann Vosseler <Ichthyostega@web.de>
 #
 #  This program is free software; you can redistribute it and/or
@@ -51,9 +51,14 @@ test_references_SOURCES = $(tests_srcdir)/library/test-references.c
 test_references_CPPFLAGS = $(AM_CPPFLAGS) -std=gnu99 -Wall -Werror -I$(top_srcdir)/src/
 test_references_LDADD = liblumi.a -lnobugmt -lpthread -ldl -lm -lrt
 
-#check_PROGRAMS += test-filehandles
-#test_filehandles_SOURCES = $(tests_srcdir)/backend/test-filehandles.c
-#test_filehandles_CPPFLAGS = $(AM_CPPFLAGS) -std=gnu99 -Wall -Werror -I$(top_srcdir)/src/
-#test_filehandles_LDADD = liblumibackend.a liblumi.a -lnobugmt -lpthread -ldl -lm
+check_PROGRAMS += test-filedescriptors
+test_filedescriptors_SOURCES = $(tests_srcdir)/backend/test-filedescriptors.c
+test_filedescriptors_CPPFLAGS = $(AM_CPPFLAGS) -std=gnu99 -Wall -Werror -I$(top_srcdir)/src/
+test_filedescriptors_LDADD = liblumibackend.a liblumi.a -lnobugmt -lpthread -ldl -lm
+
+check_PROGRAMS += test-filehandles
+test_filehandles_SOURCES = $(tests_srcdir)/backend/test-filehandles.c
+test_filehandles_CPPFLAGS = $(AM_CPPFLAGS) -std=gnu99 -Wall -Werror -I$(top_srcdir)/src/
+test_filehandles_LDADD = liblumibackend.a liblumi.a -lnobugmt -lpthread -ldl -lm
 
 TESTS = $(tests_srcdir)/test.sh
diff --git a/tests/backend/test-filedescriptors.c b/tests/backend/test-filedescriptors.c
new file mode 100644
index 000000000..3e14ead1d
--- /dev/null
+++ b/tests/backend/test-filedescriptors.c
@@ -0,0 +1,89 @@
+/*
+  test-filedescriptors.c
+
+  Copyright (C)         Lumiera.org
+    2008,               Christian Thaeter <ct@pipapo.org>
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License as
+  published by the Free Software Foundation; either version 2 of the
+  License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+#include "lib/safeclib.h"
+
+#include "backend/backend.h"
+#include "backend/filedescriptor.h"
+
+#include "tests/test.h"
+
+TESTS_BEGIN
+
+TEST ("acquire_existing")
+{
+  lumiera_backend_init ();
+  LumieraFiledescriptor descriptor = lumiera_filedescriptor_acquire (",tmp_testfile", LUMIERA_FILE_READONLY);
+  if (descriptor)
+    {
+      lumiera_filedescriptor_release (descriptor);
+      lumiera_backend_destroy ();
+      return 0;
+    }
+  else
+    return 1;
+}
+
+TEST ("acquire_existing_again")
+{
+  lumiera_backend_init ();
+  LumieraFiledescriptor descriptor = lumiera_filedescriptor_acquire (",tmp_testfile", LUMIERA_FILE_READONLY);
+  if (descriptor)
+    {
+      LumieraFiledescriptor descriptor2 = lumiera_filedescriptor_acquire (",tmp_testfile", LUMIERA_FILE_READONLY);
+      lumiera_filedescriptor_release (descriptor2);
+      lumiera_filedescriptor_release (descriptor);
+      lumiera_backend_destroy ();
+      return 0;
+    }
+  else
+    return 1;
+}
+
+TEST ("acquire_create")
+{
+  lumiera_backend_init ();
+  LumieraFiledescriptor descriptor = lumiera_filedescriptor_acquire (",tmp_testfile", LUMIERA_FILE_CREATE);
+  if (descriptor)
+    {
+      lumiera_filedescriptor_release (descriptor);
+      lumiera_backend_destroy ();
+      return 0;
+    }
+  else
+    return 1;
+}
+
+TEST ("acquire_create_dir")
+{
+  lumiera_backend_init ();
+  LumieraFiledescriptor descriptor =
+    lumiera_filedescriptor_acquire (",tmp_testdir/nested/,tmp_testfile", LUMIERA_FILE_CREATE);
+  if (descriptor)
+    {
+      lumiera_filedescriptor_release (descriptor);
+      lumiera_backend_destroy ();
+      return 0;
+    }
+  else
+    return 1;
+}
+
+TESTS_END
diff --git a/tests/backend/test-filehandles.c b/tests/backend/test-filehandles.c
new file mode 100644
index 000000000..17c237d4f
--- /dev/null
+++ b/tests/backend/test-filehandles.c
@@ -0,0 +1,87 @@
+/*
+  test-filehandles.c  -  test filehandle management
+
+  Copyright (C)         Lumiera.org
+    2008,               Christian Thaeter <ct@pipapo.org>
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License as
+  published by the Free Software Foundation; either version 2 of the
+  License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+#include "lib/llist.h"
+#include "lib/safeclib.h"
+
+#include "backend/backend.h"
+#include "backend/filehandlecache.h"
+
+#include "tests/test.h"
+
+TESTS_BEGIN
+
+TEST ("basic")
+{
+  lumiera_backend_init ();
+  LumieraFile file = lumiera_file_new (",tmp_testfile", LUMIERA_FILE_CREATE);
+
+  /* get the filehandle */
+  int fd = lumiera_file_handle_acquire (file);
+
+  /* we now 'own'it and can use it */
+  ENSURE (fd > -1);
+  printf ("got filehandle #%d\n", fd);
+
+  /* put it into aging, can't use anymore */
+  lumiera_file_handle_release (file);
+
+  lumiera_file_delete (file);
+  lumiera_backend_destroy ();
+}
+
+
+TEST ("more")
+{
+  lumiera_backend_init ();
+
+  LumieraFile files[100];
+  int fds[100];
+
+  /*create 100 files*/
+  for (int i=0; i<100; ++i)
+    {
+      files[i]= lumiera_file_new (lumiera_tmpbuf_snprintf (256, ",tmpdir/testfile%d", i), LUMIERA_FILE_CREATE);
+    }
+
+  /* get the filehandles, this gross overallocates filehandles */
+  for (int i=0; i<100; ++i)
+    {
+      fds[i] = lumiera_file_handle_acquire (files[i]);
+      ENSURE (fds[i] > -1);
+      printf ("got filehandle #%d\n", fds[i]);
+    }
+
+  /* put them into aging, can't use anymore */
+  for (int i=0; i<100; ++i)
+    {
+      lumiera_file_handle_release (files[i]);
+    }
+
+  /* cleanup */
+  for (int i=0; i<100; ++i)
+    {
+      lumiera_file_delete (files[i]);
+    }
+
+  lumiera_backend_destroy ();
+}
+
+TESTS_END
diff --git a/tests/common/Makefile.am b/tests/common/Makefile.am
new file mode 100644
index 000000000..cc027e477
--- /dev/null
+++ b/tests/common/Makefile.am
@@ -0,0 +1,61 @@
+#  Copyright (C)         Lumiera.org
+#    2008,               Christian Thaeter <ct@pipapo.org>
+#                        Hermann Vosseler <Ichthyostega@web.de>
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License as
+#  published by the Free Software Foundation; either version 2 of the
+#  License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+testcommon_srcdir = $(top_srcdir)/tests/common
+
+check_PROGRAMS += test-common
+test_common_CPPFLAGS = $(AM_CPPFLAGS) -Wall -I$(top_srcdir)/src -I$(testcommon_srcdir)
+test_common_LDADD =								\
+	liblumiproc.a								\
+	liblumiprocengine.a							\
+	liblumiprocmobjectbuilder.a						\
+	liblumiprocmobjectsession.a						\
+	liblumiprocasset.a							\
+	liblumiprocmobject.a							\
+	liblumiprocmobjectcontroller.a						\
+	liblumi.a								\
+	liblumicommon.a								\
+	liblumibackend.a							\
+	-lnobugmt -lpthread -ldl -lboost_program_options-mt -lboost_regex-mt
+
+test_common_SOURCES =						\
+	$(testcommon_srcdir)/appconfigtest.cpp			\
+	$(testcommon_srcdir)/customsharedptrtest.cpp		\
+	$(testcommon_srcdir)/exceptionerrortest.cpp		\
+	$(testcommon_srcdir)/factoryspecialtest.cpp		\
+	$(testcommon_srcdir)/factorytest.cpp			\
+	$(testcommon_srcdir)/helloworldtest.cpp			\
+	$(testcommon_srcdir)/lifecycletest.cpp			\
+	$(testcommon_srcdir)/mainsuite.cpp			\
+	$(testcommon_srcdir)/query/queryutilstest.cpp		\
+	$(testcommon_srcdir)/removefromsettest.cpp		\
+	$(testcommon_srcdir)/sanitizedidentifiertest.cpp	\
+	$(testcommon_srcdir)/singletonsubclasstest.cpp		\
+	$(testcommon_srcdir)/singletontest.cpp			\
+	$(testcommon_srcdir)/singletontestmocktest.cpp		\
+	$(testcommon_srcdir)/test/cmdlinewrappertest.cpp	\
+	$(testcommon_srcdir)/test/testoptiontest.cpp		\
+	$(testcommon_srcdir)/typelisttest.cpp			\
+	$(testcommon_srcdir)/typelistutiltest.cpp		\
+	$(testcommon_srcdir)/visitingtoolconcept.cpp		\
+	$(testcommon_srcdir)/visitingtoolextendedtest.cpp	\
+	$(testcommon_srcdir)/visitingtooltest.cpp
+
+noinst_HEADERS +=					\
+	$(testcommon_srcdir)/query/querydiagnostics.hpp	\
+	$(testcommon_srcdir)/testtargetobj.hpp
diff --git a/tests/components/Makefile.am b/tests/components/Makefile.am
new file mode 100644
index 000000000..088dbe668
--- /dev/null
+++ b/tests/components/Makefile.am
@@ -0,0 +1,72 @@
+#  Copyright (C)         Lumiera.org
+#    2008,               Christian Thaeter <ct@pipapo.org>
+#                        Hermann Vosseler <Ichthyostega@web.de>
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License as
+#  published by the Free Software Foundation; either version 2 of the
+#  License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+testcomponents_srcdir = $(top_srcdir)/tests/components
+
+check_PROGRAMS += test-components
+test_components_CPPFLAGS = $(AM_CPPFLAGS) -Wall -I$(top_srcdir)/src -I$(testcomponents_srcdir)
+test_components_LDADD =								\
+	liblumiproc.a								\
+	liblumiprocengine.a							\
+	liblumiprocmobjectbuilder.a						\
+	liblumiprocmobjectsession.a						\
+	liblumiprocasset.a							\
+	liblumiprocmobject.a							\
+	liblumiprocmobjectcontroller.a						\
+	liblumi.a								\
+	liblumicommon.a								\
+	liblumibackend.a							\
+	-lnobugmt -lpthread -ldl -lboost_program_options-mt -lboost_regex-mt
+
+test_components_SOURCES =							\
+	$(testcomponents_srcdir)/backend/mediaaccessmock.cpp			\
+	$(testcomponents_srcdir)/backend/mediaaccessmocktest.cpp		\
+	$(testcomponents_srcdir)/proc/asset/assetcategorytest.cpp		\
+	$(testcomponents_srcdir)/proc/asset/compoundmediatest.cpp		\
+	$(testcomponents_srcdir)/proc/asset/deleteassettest.cpp			\
+	$(testcomponents_srcdir)/proc/asset/identityofassetstest.cpp		\
+	$(testcomponents_srcdir)/proc/asset/mediastructurequerytest.cpp		\
+	$(testcomponents_srcdir)/proc/asset/basicpipetest.cpp			\
+	$(testcomponents_srcdir)/proc/asset/createassettest.cpp			\
+	$(testcomponents_srcdir)/proc/asset/dependantassetstest.cpp		\
+	$(testcomponents_srcdir)/proc/asset/makecliptest.cpp			\
+	$(testcomponents_srcdir)/proc/asset/orderingofassetstest.cpp		\
+	$(testcomponents_srcdir)/proc/asset/testasset.cpp			\
+	$(testcomponents_srcdir)/proc/engine/sourcenodetest.cpp			\
+	$(testcomponents_srcdir)/proc/mobject/builder/buildertooltest.cpp	\
+	$(testcomponents_srcdir)/proc/mobject/builder/buildsegmenttest.cpp	\
+	$(testcomponents_srcdir)/proc/mobject/controller/rendersegmenttest.cpp	\
+	$(testcomponents_srcdir)/proc/mobject/placementbasictest.cpp		\
+	$(testcomponents_srcdir)/proc/mobject/session/addcliptest.cpp		\
+	$(testcomponents_srcdir)/proc/mobject/session/deletecliptest.cpp	\
+	$(testcomponents_srcdir)/proc/mobject/session/rebuildfixturetest.cpp	\
+	$(testcomponents_srcdir)/proc/mobject/session/sessionmanagertest.cpp	\
+	$(testcomponents_srcdir)/proc/mobject/session/testclip.cpp		\
+	$(testcomponents_srcdir)/proc/mobject/session/defsmanagerimpltest.cpp	\
+	$(testcomponents_srcdir)/proc/mobject/session/defsmanagertest.cpp	\
+	$(testcomponents_srcdir)/proc/mobject/session/defsregistryimpltest.cpp	\
+	$(testcomponents_srcdir)/proc/mobject/session/sessionstructuretest.cpp	\
+	$(testcomponents_srcdir)/mainsuite.cpp
+
+noinst_HEADERS +=							\
+	$(testcomponents_srcdir)/backend/mediaaccessmock.hpp		\
+	$(testcomponents_srcdir)/proc/asset/testclipasset.hpp		\
+	$(testcomponents_srcdir)/proc/asset/assetdiagnostics.hpp	\
+	$(testcomponents_srcdir)/proc/asset/testasset.hpp		\
+	$(testcomponents_srcdir)/proc/mobject/session/testclip.hpp	\
+	$(testcomponents_srcdir)/proc/mobject/session/testsession1.hpp
diff --git a/wiki/todo.html b/wiki/todo.html
index d6caf66be..763c8a80a 100644
--- a/wiki/todo.html
+++ b/wiki/todo.html
@@ -3344,6 +3344,15 @@ Someone might pickup a Doxygen-Maintainer. This is not writing actual documentat
 <div title="video player mockup" modifier="Ichthyostega" modified="200804120416" created="200804090216" changecount="4">
 <pre>Use the backend, gmerlin/avdecoder and a Player widget to playback videos. This should be a small application which can open and playback many videos from one instance in parallel. Later on scrubbing for this videos might be supported.
 
+The idea here is to show and measure backend and scheduler performance
+  and beeing a proof of concept for the design. It will run
+  independent of the Proc layer but needs quite some work on the
+  backend to be done.
+</pre>
+</div>
+<div title="video player mockup" modifier="CehTeh" modified="200804090218" created="200804090216" changecount="3">
+<pre>Use the backend, gmerlin/avdecoder and a Player widget to playback videos. This should be a small application which can open and playback many videos from on instance in parallel. Later on scrubbing for this videos might be supported.
+
 The idea here is to show and measure backend and scheduler performance and beeing a proof of concept for the design. It will run independent of the Proc layer but needs quite some work on the backend to be done.</pre>
 </div>
 </div>