diff --git a/README.md b/README.md
index bbe3f5b8a..9e3f1d76d 100644
--- a/README.md
+++ b/README.md
@@ -48,7 +48,7 @@ To build Tuplex, you need several other packages first which can be easily insta
 ```
 brew install llvm@9 boost boost-python3 aws-sdk-cpp pcre2 antlr4-cpp-runtime googletest gflags yaml-cpp celero protobuf libmagic
 python3 -m pip install cloudpickle numpy
-python3 setup.py install
+python3 setup.py install --user
 ```
 
 #### Ubuntu build from source
@@ -56,19 +56,19 @@ To faciliate installing the dependencies for Ubuntu, we do provide two scripts (
 ```
 ./scripts/ubuntu1804/install_reqs.sh
 python3 -m pip install cloudpickle numpy
-python3 setup.py install
+python3 setup.py install --user
 ```
 
 #### Customizing the build
 
-Besides building a pip package, cmake can be also directly invoked. To compile the package via cmake
+Besides building a pip package, especially for development it may be more useful to invoke cmake directly. To create a development version of Tuplex and work with it like a regular cmake project, go to the folder `tuplex` and then use the standard workflow to compile the package via cmake (and not the top-level setup.py file):
 ```
 mkdir build
 cd build
 cmake ..
 make -j$(nproc)
 ```
-The python package corresponding to Tuplex can be then found in `build/dist/python` with C++ test executables based on googletest in `build/dist/bin`.
+The python package corresponding to Tuplex can be then found in `build/dist/python` with C++ test executables based on googletest in `build/dist/bin`. If you'd like to use a cmake-compatible IDE like CLion or VSCode you can simply open the `tuplex/` folder and import the `CMakeLists.txt` contained there.
 
 To customize the cmake build, the following options are available to be passed via `-D<option>=<value>`:
 
diff --git a/scripts/ubuntu1804/install_reqs.sh b/scripts/ubuntu1804/install_reqs.sh
index be14fb862..1200b446e 100644
--- a/scripts/ubuntu1804/install_reqs.sh
+++ b/scripts/ubuntu1804/install_reqs.sh
@@ -23,7 +23,7 @@ apt-get install -y build-essential autoconf automake libtool software-properties
   uuid-dev git python3.7 python3.7-dev python3-pip libffi-dev \
   doxygen doxygen-doc doxygen-latex doxygen-gui graphviz \
   gcc-7 g++-7 libgflags-dev libncurses-dev \
-  awscli openjdk-8-jdk libyaml-dev libmagic-dev
+  awscli openjdk-8-jdk libyaml-dev libmagic-dev ninja-build
 
 # LLVM 9 packages (prob not all of them needed, but here for complete install)
 wget https://apt.llvm.org/llvm.sh && chmod +x llvm.sh &&
diff --git a/scripts/ubuntu2004/install_reqs.sh b/scripts/ubuntu2004/install_reqs.sh
index ed57c4b78..1bccf600b 100644
--- a/scripts/ubuntu2004/install_reqs.sh
+++ b/scripts/ubuntu2004/install_reqs.sh
@@ -23,13 +23,19 @@ apt-get install -y build-essential software-properties-common wget libedit-dev l
   uuid-dev git libffi-dev libmagic-dev \
   doxygen doxygen-doc doxygen-latex doxygen-gui graphviz \
   libgflags-dev libncurses-dev \
-  awscli openjdk-8-jdk libyaml-dev
+  awscli openjdk-8-jdk libyaml-dev ninja-build gcc-10 g++-10 autoconf libtool m4
 
 # use GCC 10, as Tuplex doesn't work with GCC 9
 update-alternatives --remove-all gcc
 update-alternatives --remove-all g++
 update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-10 100 --slave /usr/bin/g++ g++ /usr/bin/g++-10
 
+# update to make sure everything is compiled using gcc-10
+ldconfig
+export CC=gcc-10
+export CXX=g++-10
+
+
 # LLVM 9 packages (prob not all of them needed, but here for complete install)
 wget https://apt.llvm.org/llvm.sh && chmod +x llvm.sh &&
 ./llvm.sh 9 && rm -rf llvm.sh
@@ -91,7 +97,7 @@ mkdir -p /tmp/celero-v2.6.0 &&
   git checkout tags/v2.6.0 &&
   mkdir build &&
   cd build &&
-  cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=/opt -DBUILD_SHARED_LIBS=OFF -DCMAKE_CXX_FLAGS=$CXX_FLAGS .. &&
+  cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=/opt -DBUILD_SHARED_LIBS=OFF -DCMAKE_CXX_FLAGS="-fPIC" .. &&
   make -j 32 &&
   make install &&
   cd &&
@@ -151,6 +157,16 @@ popd
 # install python packages for tuplex (needs cloudpickle to compile, numpy to run certain tests)
 pip3 install cloudpickle numpy
 
+# protobuf 3.12
+cd /tmp &&
+curl -OL https://github.com/protocolbuffers/protobuf/releases/download/v3.12.0/protobuf-cpp-3.12.0.tar.gz &&
+tar xf protobuf-cpp-3.12.0.tar.gz &&
+pushd protobuf-3.12.0 &&
+./autogen.sh && ./configure "CFLAGS=-fPIC" "CXXFLAGS=-fPIC" &&
+make -j4 && make install && ldconfig &&
+pushd
+
+
 # setup bash aliases
 echo "alias antlr='java -jar /opt/lib/antlr-4.8-complete.jar'" >>"$HOME/.bashrc"
 echo "alias grun='java org.antlr.v4.gui.TestRig'" >>"$HOME/.bashrc"
diff --git a/setup.py b/setup.py
index 4e3ef39a1..4e5a0c5a4 100644
--- a/setup.py
+++ b/setup.py
@@ -33,11 +33,17 @@
     'six>=1.11.0',
     'wcwidth>=0.1.7',
     'astor>=0.7.1',
-    'jedi>=0.13.2',
+    'prompt_toolkit',
+    'jedi',
     'cloudpickle>=0.6.1',
     'PyYAML>=3.13'
 ]
 
+def ninja_installed():
+    # check whether ninja is on the path
+    from distutils.spawn import find_executable
+    return find_executable('ninja') is not None
+
 def find_files(pattern, path):
     result = []
     for root, dirs, files in os.walk(path):
@@ -55,7 +61,6 @@ def find_files(pattern, path):
     "win-arm64": "ARM64",
 }
 
-
 # A CMakeExtension needs a sourcedir instead of a file list.
 # The name must be the _single_ output extension from the CMake build.
 # If you need multiple extensions, see scikit-build.
@@ -64,7 +69,6 @@ def __init__(self, name, sourcedir=""):
         Extension.__init__(self, name, sources=[])
         self.sourcedir = os.path.abspath(sourcedir)
 
-
 class CMakeBuild(build_ext):
 
     def build_extension(self, ext):
@@ -180,8 +184,10 @@ def find_pkg_path(lines):
             # Users can override the generator with CMAKE_GENERATOR in CMake
             # 3.15+.
             if not cmake_generator:
-                cmake_args += ["-GNinja"]
 
+                # yet, check if Ninja exists...
+                if ninja_installed():
+                    cmake_args += ["-GNinja"]
         else:
 
             # Single config generators are handled "normally"
@@ -215,10 +221,13 @@ def find_pkg_path(lines):
         if not os.path.exists(self.build_temp):
             os.makedirs(self.build_temp)
 
-        if os.environ.get('CIBUILDWHEEL', '0') == '1':
-            # on cibuildwheel b.c. manylinux2014 does not have python shared objects, build
-            # only tuplex target (the python shared object)
-            build_args += ['--target', 'tuplex']
+        ## on cibuildwheel b.c. manylinux2014 does not have python shared objects, build
+        ## only tuplex target (the python shared object)
+        #if os.environ.get('CIBUILDWHEEL', '0') == '1':
+
+        # because the goal of setup.py is to only build the package, build only target tuplex.
+        # changed from before.
+        build_args += ['--target', 'tuplex']
 
         # hack: only run for first invocation!
         if ext_filename == 'tuplex_runtime':
diff --git a/tuplex/CMakeLists.txt b/tuplex/CMakeLists.txt
index 531d8cbc4..c53f5d984 100755
--- a/tuplex/CMakeLists.txt
+++ b/tuplex/CMakeLists.txt
@@ -1,5 +1,24 @@
 # (c) 2017 Leonhard Spiegelberg
 cmake_minimum_required(VERSION 3.12 FATAL_ERROR)
+
+# Tuplex build options:
+# =====================
+
+# Option on whether to use shared libraries or perform a static link.
+# Must be identical to how AWS SDK was installed. E.g., when installing brew aws-sdk-cpp the default is
+# shared for the AWS C++ SDK build.
+# --> We use static build per default.
+option(BUILD_SHARED_LIBS "Build shared libraries" OFF)
+option(SKIP_AWS_TESTS "Skip AWS tests" ON)
+option(BUILD_WITH_ORC "Build with Orc file support" OFF)
+option(BUILD_NATIVE "Build with -march=native" OFF)
+option(BUILD_FOR_LAMBDA "use to specify whether this is a Lambda build" OFF)
+option(BUILD_FOR_CI "Build for the CI - disable tests that require AWS credentials." OFF)
+option(BUILD_WITH_AWS "Build Tuplex with AWS support. This will include access to S3 and the AWS Lambda execution engine backend. Requires AWS C++ SDK" ON)
+option(GENERATE_PDFS "whether to generate PDFs in Debug mode or not. Disable for faster testing speeds." OFF)
+option(SHOW_EXPLICIT_WARNINGS "Show the output of #warning directives in the code (lots of output)" OFF)
+option(USE_LD_GOLD "Use GNU gold linker" ON)
+
 # via -DVERSION_INFO a string may be passed down. --> include it somehow
 if(VERSION_INFO)
     message(STATUS "Version info supplied to cmake: ${VERSION_INFO}")
@@ -12,9 +31,33 @@ endif()
 # before writing additional cmake modules to put in cmake/, check the list of supported cmake standard modules
 # available here: https://cmake.org/cmake/help/latest/manual/cmake-modules.7.html#find-modules
 
+# top-level language specification
+# enable c++14
+set(CMAKE_CXX_STANDARD 14)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+# enable c11
+set(CMAKE_C_STANDARD 11)
+set(CMAKE_C_STANDARD_REQUIRED ON)
+message(STATUS "Using language versions C++${CMAKE_CXX_STANDARD} and C${CMAKE_C_STANDARD}")
+# add cmake modules from cmake folder
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/")
+message(STATUS "additional cmake module path is ${CMAKE_MODULE_PATH}")
+include("${CMAKE_SOURCE_DIR}/cmake/ucm.cmake") #handy package to manipulate compiler flags
 # for debug mode export all symbols
 set(CMAKE_ENABLE_EXPORTS true)
 
+# this here will enable LTO (link-time optimization) globally
+include(CheckIPOSupported)
+check_ipo_supported(RESULT IPO_SUPPORTED)
+if(IPO_SUPPORTED)
+    # on Ubuntu gcc is buggy, so deactivate LTO for Linux...
+    if(NOT CMAKE_SYSTEM_NAME MATCHES "Linux" AND "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+        set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)
+        message(STATUS "Enabling interprocedural optimization for built")
+    endif()
+else()
+    message(WARNING "target does not support interprocedural optimization/link time optimization.")
+endif()
 # Check if ccache exists to speed up compilation when switching branches
 # taken from https://invent.kde.org/utilities/konsole/-/merge_requests/26?tab=diffs
 find_program(CCACHE_FOUND "ccache")
@@ -23,26 +66,14 @@ if (CCACHE_FOUND AND CCACHE_SUPPORT)
     if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU" # GNU is GNU GCC
             OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
         # without this compiler messages in `make` backend would be uncolored
-        set(CMAKE_CXX_FLAGS  "${CMAKE_CXX_FLAGS} -fdiagnostics-color=auto")
+        ucm_add_flags("-fdiagnostics-color=auto")
     endif()
     set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE "ccache")
     set_property(GLOBAL PROPERTY RULE_LAUNCH_LINK "ccache")
 endif()
 
-# Tuplex build options:
-# =====================
-
-# Option on whether to use shared libraries or perform a static link.
-# Must be identical to how AWS SDK was installed. E.g., when installing brew aws-sdk-cpp the default is
-# shared for the AWS C++ SDK build.
-# --> We use static build per default.
-option(BUILD_SHARED_LIBS "Build shared libraries" OFF)
 set(CMAKE_MACOSX_RPATH 1) # fix for gtest warning
 
-option(SKIP_AWS_TESTS "Skip AWS tests" ON)
-option(BUILD_WITH_ORC "Build with Orc file support" OFF)
-option(BUILD_NATIVE "Build with -march=native" OFF)
-
 # translate to C++ flags
 if(SKIP_AWS_TESTS)
     add_definitions(-DSKIP_AWS_TESTS)
@@ -58,28 +89,26 @@ macro(append_if list condition var)
         list(APPEND ${list} ${var})
     endif()
 endmacro()
+
+# manipulate warnings
 if (NOT MSVC)
-    append_if(LIBCXX_COMPILE_FLAGS LIBCXX_HAS_WALL_FLAG -Wall)
-    list(APPEND LIBCXX_COMPILE_FLAGS -Werror=return-type)
+    # supress "#warning" if desired, else enable all
+    if(SHOW_EXPLICIT_WARNINGS)
+        ucm_add_flags("-Wall")
+    else()
+        ucm_add_flags("-Wno-cpp")
+    endif()
 
     # make no return warning into an error because it easily leads to bugs
     # https://foonathan.net/2018/10/cmake-warnings/
-    # alternative is to use target dependent options, i.e.
-    # target_compile_options(my_library PRIVATE
-    #     $<$<OR:$<CXX_COMPILER_ID:Clang>,$<CXX_COMPILER_ID:AppleClang>,$<CXX_COMPILER_ID:GNU>>:
-    #          -Wall>
-    #     $<$<CXX_COMPILER_ID:MSVC>:
-    #          /W4>)
-    list(APPEND CMAKE_CXX_FLAGS "-Werror=return-type")
+    ucm_add_flags("-Werror=return-type")
+else()
+    message(FATAL_ERROR "msvc not supported yet")
 endif()
 
 ###########################################################################
 # (0) add additional cmake modules
 ###########################################################################
-# add cmake modules from cmake folder
-list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/")
-
-message("module path" ${CMAKE_MODULE_PATH})
 
 # global config, brew there?
 FIND_PROGRAM(BREW_FOUND "brew")
@@ -114,8 +143,6 @@ endif()
 # add to debug/gcc stack protector
 # -fstack-protector-strong
 
-message(STATUS "build type is " "${CMAKE_BUILD_TYPE}")
-
 
 # fix for Mac OS X/ brew, find openSSL (required by some dependencies)
 ## check for ICU
@@ -138,13 +165,11 @@ ENDIF()
 
 # Options:
 # build for CI (disable some tests)
-option(BUILD_FOR_CI "Build for the CI - disable tests that require AWS credentials." OFF)
 if(BUILD_FOR_CI)
     add_definitions(-DBUILD_FOR_CI)
 endif()
 
 # build with AWS support
-option(BUILD_WITH_AWS "Build Tuplex with AWS support. This will include access to S3 and the AWS Lambda execution engine backend. Requires AWS C++ SDK" ON)
 if(BUILD_WITH_AWS)
     # special case: if using mac os and a brew installed aws-sdk-cpp, can't use static libs => need to force to shared_libs
     if(APPLE AND BREW_FOUND)
@@ -168,7 +193,6 @@ if(BUILD_WITH_AWS)
     endif ()
 endif()
 
-option(GENERATE_PDFS "whether to generate PDFs in Debug mode or not. Disable for faster testing speeds." OFF)
 if(GENERATE_PDFS)
     message(STATUS "Tuplex configured to emit PDF files for various AST stages")
     add_definitions(-DGENERATE_PDFS)
@@ -176,13 +200,6 @@ else()
     message(STATUS "PDF generation for ASTs and logical plans disabled. Enable by setting -DGENERATE_PDFS=ON.")
 endif()
 
-# suppress "#warning" directive otuput
-option(SHOW_EXPLICIT_WARNINGS "Show the output of #warning directives in the code (lots of output)" OFF)
-if(SHOW_EXPLICIT_WARNINGS)
-else()
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-cpp")
-endif()
-
 ###########################################################################
 # (1) supported compilers and fixes
 ###########################################################################
@@ -219,40 +236,43 @@ if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
     add_link_options("-Wl,--start-group")
 endif()
 
+
+
+
 ###########################################################################
 # (2) global flags
 ###########################################################################
-find_package(Threads REQUIRED)
+# i.e., manipulate here using ucm
 
-# enable c++14
-set(CMAKE_CXX_STANDARD 14)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-# enable c11
-set(CMAKE_C_STANDARD 11)
-set(CMAKE_C_STANDARD_REQUIRED ON)
+# set here initial compiler flags
+# DO NOT USE MARCH=NATIVE for wheels... => option should be disabled per default
+# use march=native if available and NOT building wheels
 
-message(STATUS "Using language versions C++${CMAKE_CXX_STANDARD} and C${CMAKE_C_STANDARD}")
+# specific Release flags, i.e. targeting loop unrolling.
+ucm_add_flags(-m64 -O3 -funroll-loops CONFIG Release)
 
+# for GCC add stack protector
+# -fstack-protector-strong
+if("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU")
+    ucm_add_flags(-fstack-protector-strong)
+endif()
+
+include(CheckCXXCompilerFlag)
+if(BUILD_NATIVE AND NOT BUILD_FOR_LAMBDA) # for lambda build, specific architecture has been targeted.
+    CHECK_CXX_COMPILER_FLAG("-march=native" COMPILER_SUPPORTS_MARCH_NATIVE)
+    if(COMPILER_SUPPORTS_MARCH_NATIVE)
+        ucm_add_flags(-march=native)
+    endif()
+    message(STATUS "Building Tuplex with native optimizations")
+endif()
+
+find_package(Threads REQUIRED)
 # enable PIC
 set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 
-
-# release flags
-# don't use Ofast unless you're ok to break NAN/INF compatibility.
-option(BUILD_FOR_LAMBDA "use to specify whether this is a Lambda build")
+# for release mode, don't use Ofast unless you're ok to break NAN/INF compatibility.
 if(BUILD_FOR_LAMBDA)
-    set(TARGET_BUILD_ARCH "haswell")
-else()
-    set(TARGET_BUILD_ARCH "native")
-endif()
-message("TARGET_BUILD_ARCH=${TARGET_BUILD_ARCH}")
-set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -m64 -O3 -flto -march=${TARGET_BUILD_ARCH} -funroll-loops")
-
-# for GCC add stack protector
-# -fstack-protector-strong
-if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fstack-protector-strong")
-    set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -fstack-protector-strong")
+    ucm_add_flags(-march=haswell)
 endif()
 
 # add compiler flags for specific SIMD instructions
@@ -267,11 +287,15 @@ if(HAVE_SSE42)
     add_compile_options("-msse4.2")
 endif()
 if(HAVE_AVX)
-    message(STATUS "Found AVX support, adding -mavx")
-    # no msvc support, so use clang/gcc flag approach!
-    #add_compile_options("-mavx")
-    else()
-    message(STATUS "no avx support")
+    # only add avx (because not any architecture supports it) if native build is enabled or build for lambda
+    # because Haswell supports both AVX and AVX2!
+    if(BUILD_NATIVE OR BUILD_FOR_LAMBDA)
+        message(STATUS "Found AVX support, adding -mavx")
+        # no msvc support, so use clang/gcc flag approach!
+        add_compile_options("-mavx")
+    endif()
+else()
+    message(STATUS "no avx support, build with -DBUILD_NATIVE=ON to enable")
 endif()
 
 ###########################################################################
@@ -420,7 +444,7 @@ if(PYTHON3_VERSION STREQUAL "")
     # try first to find full Python3, if it fails find only Interpreter & Module
     find_package(Python3 COMPONENTS Interpreter Development QUIET)
     if(Python3_FOUND)
-        message(STATUS "found full python3-dev installation")
+        message(STATUS "Found full python3-dev installation")
         set(Python3_Embed_FOUND TRUE)
     else()
         find_package(Python3 COMPONENTS Interpreter REQUIRED)
@@ -441,7 +465,7 @@ else()
         # try first to find full Python3, if it fails find only Interpreter & Module
         find_package(Python3 ${VERSION_STRING} EXACT COMPONENTS Interpreter Development QUIET)
         if(Python3_FOUND)
-            message(STATUS "found full python3-dev installation")
+            message(STATUS "Found full python3-dev installation")
             set(Python3_Embed_FOUND TRUE)
         else()
             find_package(Python3 ${VERSION_STRING} EXACT COMPONENTS Interpreter REQUIRED)
@@ -557,27 +581,15 @@ endif()
 
 
 # use gold linker for gcc
-option(USE_LD_GOLD "Use GNU gold linker" ON)
 if(USE_LD_GOLD AND "${CMAKE_C_COMPILER_ID}" STREQUAL "GNU")
     execute_process(COMMAND ${CMAKE_C_COMPILER} -fuse-ld=gold -Wl,--version OUTPUT_VARIABLE stdout ERROR_QUIET)
     if("${stdout}" MATCHES "GNU gold")
-        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fuse-ld=gold")
-        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fuse-ld=gold")
+        ucm_add_flags(-fuse-ld=gold)
+        ucm_add_linker_flags(-fuse-ld=gold)
     else()
         message(WARNING "GNU gold linker isn't available, using the default system linker.")
     endif()
 endif()
 
-# DO NOT USE MARCH=NATIVE for wheels... => option should be disabled per default
-# use march=native if available and NOT building wheels
-include(CheckCXXCompilerFlag)
-if(BUILD_NATIVE)
-CHECK_CXX_COMPILER_FLAG("-march=native" COMPILER_SUPPORTS_MARCH_NATIVE)
-if(COMPILER_SUPPORTS_MARCH_NATIVE)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=native")
-    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -march=native")
-endif()
-message(STATUS "Building Tuplex for native platform")
-message(STATUS "Using following CMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS}")
-message(STATUS "Using following CMAKE_C_FLAGS=${CMAKE_C_FLAGS}")
-endif()
\ No newline at end of file
+# print flags
+ucm_print_flags()
\ No newline at end of file
diff --git a/tuplex/awslambda/CMakeLists.txt b/tuplex/awslambda/CMakeLists.txt
index f6d95f9cc..72fa27508 100644
--- a/tuplex/awslambda/CMakeLists.txt
+++ b/tuplex/awslambda/CMakeLists.txt
@@ -6,6 +6,9 @@ set(LAMBDA_NAME tplxlam)
 # enable c++14
 set(CMAKE_CXX_STANDARD 14)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
+# enable c11
+set(CMAKE_C_STANDARD 11)
+set(CMAKE_C_STANDARD_REQUIRED ON)
 
 # only compiles on Linux, check here
 if(NOT ${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
diff --git a/tuplex/cmake/ucm.cmake b/tuplex/cmake/ucm.cmake
new file mode 100644
index 000000000..651464872
--- /dev/null
+++ b/tuplex/cmake/ucm.cmake
@@ -0,0 +1,663 @@
+#
+# ucm.cmake - useful cmake macros
+#
+# Copyright (c) 2016 Viktor Kirilov
+#
+# Distributed under the MIT Software License
+# See accompanying file LICENSE.txt or copy at
+# https://opensource.org/licenses/MIT
+#
+# The documentation can be found at the library's page:
+# https://github.com/onqtam/ucm
+
+cmake_minimum_required(VERSION 2.8.12)
+
+include(CMakeParseArguments)
+
+# optionally include cotire - the git submodule might not be inited (or the user might have already included it)
+if(NOT COMMAND cotire)
+    include(${CMAKE_CURRENT_LIST_DIR}/../cotire/CMake/cotire.cmake OPTIONAL)
+endif()
+
+if(COMMAND cotire AND "1.7.9" VERSION_LESS "${COTIRE_CMAKE_MODULE_VERSION}")
+    set(ucm_with_cotire 1)
+else()
+    set(ucm_with_cotire 0)
+endif()
+
+option(UCM_UNITY_BUILD          "Enable unity build for targets registered with the ucm_add_target() macro"                     OFF)
+option(UCM_NO_COTIRE_FOLDER     "Do not use a cotire folder in the solution explorer for all unity and cotire related targets"  ON)
+
+# ucm_add_flags
+# Adds compiler flags to CMAKE_<LANG>_FLAGS or to a specific config
+macro(ucm_add_flags)
+    cmake_parse_arguments(ARG "C;CXX;CLEAR_OLD" "" "CONFIG" ${ARGN})
+
+    if(NOT ARG_CONFIG)
+        set(ARG_CONFIG " ")
+    endif()
+
+    foreach(CONFIG ${ARG_CONFIG})
+        # determine to which flags to add
+        if(NOT ${CONFIG} STREQUAL " ")
+            string(TOUPPER ${CONFIG} CONFIG)
+            set(CXX_FLAGS CMAKE_CXX_FLAGS_${CONFIG})
+            set(C_FLAGS CMAKE_C_FLAGS_${CONFIG})
+        else()
+            set(CXX_FLAGS CMAKE_CXX_FLAGS)
+            set(C_FLAGS CMAKE_C_FLAGS)
+        endif()
+
+        # clear the old flags
+        if(${ARG_CLEAR_OLD})
+            if("${ARG_CXX}" OR NOT "${ARG_C}")
+                set(${CXX_FLAGS} "")
+            endif()
+            if("${ARG_C}" OR NOT "${ARG_CXX}")
+                set(${C_FLAGS} "")
+            endif()
+        endif()
+
+        # add all the passed flags
+        foreach(flag ${ARG_UNPARSED_ARGUMENTS})
+            if("${ARG_CXX}" OR NOT "${ARG_C}")
+                set(${CXX_FLAGS} "${${CXX_FLAGS}} ${flag}")
+            endif()
+            if("${ARG_C}" OR NOT "${ARG_CXX}")
+                set(${C_FLAGS} "${${C_FLAGS}} ${flag}")
+            endif()
+        endforeach()
+    endforeach()
+
+endmacro()
+
+# ucm_set_flags
+# Sets the CMAKE_<LANG>_FLAGS compiler flags or for a specific config
+macro(ucm_set_flags)
+    ucm_add_flags(CLEAR_OLD ${ARGN})
+endmacro()
+
+# ucm_add_linker_flags
+# Adds linker flags to CMAKE_<TYPE>_LINKER_FLAGS or to a specific config
+macro(ucm_add_linker_flags)
+    cmake_parse_arguments(ARG "CLEAR_OLD;EXE;MODULE;SHARED;STATIC" "" "CONFIG" ${ARGN})
+
+    if(NOT ARG_CONFIG)
+        set(ARG_CONFIG " ")
+    endif()
+
+    foreach(CONFIG ${ARG_CONFIG})
+        string(TOUPPER "${CONFIG}" CONFIG)
+
+        if(NOT ${ARG_EXE} AND NOT ${ARG_MODULE} AND NOT ${ARG_SHARED} AND NOT ${ARG_STATIC})
+            set(ARG_EXE 1)
+            set(ARG_MODULE 1)
+            set(ARG_SHARED 1)
+            set(ARG_STATIC 1)
+        endif()
+
+        set(flags_configs "")
+        if(${ARG_EXE})
+            if(NOT "${CONFIG}" STREQUAL " ")
+                list(APPEND flags_configs CMAKE_EXE_LINKER_FLAGS_${CONFIG})
+            else()
+                list(APPEND flags_configs CMAKE_EXE_LINKER_FLAGS)
+            endif()
+        endif()
+        if(${ARG_MODULE})
+            if(NOT "${CONFIG}" STREQUAL " ")
+                list(APPEND flags_configs CMAKE_MODULE_LINKER_FLAGS_${CONFIG})
+            else()
+                list(APPEND flags_configs CMAKE_MODULE_LINKER_FLAGS)
+            endif()
+        endif()
+        if(${ARG_SHARED})
+            if(NOT "${CONFIG}" STREQUAL " ")
+                list(APPEND flags_configs CMAKE_SHARED_LINKER_FLAGS_${CONFIG})
+            else()
+                list(APPEND flags_configs CMAKE_SHARED_LINKER_FLAGS)
+            endif()
+        endif()
+        if(${ARG_STATIC})
+            if(NOT "${CONFIG}" STREQUAL " ")
+                list(APPEND flags_configs CMAKE_STATIC_LINKER_FLAGS_${CONFIG})
+            else()
+                list(APPEND flags_configs CMAKE_STATIC_LINKER_FLAGS)
+            endif()
+        endif()
+
+        # clear the old flags
+        if(${ARG_CLEAR_OLD})
+            foreach(flags ${flags_configs})
+                set(${flags} "")
+            endforeach()
+        endif()
+
+        # add all the passed flags
+        foreach(flag ${ARG_UNPARSED_ARGUMENTS})
+            foreach(flags ${flags_configs})
+                set(${flags} "${${flags}} ${flag}")
+            endforeach()
+        endforeach()
+    endforeach()
+endmacro()
+
+# ucm_set_linker_flags
+# Sets the CMAKE_<TYPE>_LINKER_FLAGS linker flags or for a specific config
+macro(ucm_set_linker_flags)
+    ucm_add_linker_flags(CLEAR_OLD ${ARGN})
+endmacro()
+
+# ucm_gather_flags
+# Gathers all lists of flags for printing or manipulation
+macro(ucm_gather_flags with_linker result)
+    set(${result} "")
+    # add the main flags without a config
+    list(APPEND ${result} CMAKE_C_FLAGS)
+    list(APPEND ${result} CMAKE_CXX_FLAGS)
+    if(${with_linker})
+        list(APPEND ${result} CMAKE_EXE_LINKER_FLAGS)
+        list(APPEND ${result} CMAKE_MODULE_LINKER_FLAGS)
+        list(APPEND ${result} CMAKE_SHARED_LINKER_FLAGS)
+        list(APPEND ${result} CMAKE_STATIC_LINKER_FLAGS)
+    endif()
+
+    if("${CMAKE_CONFIGURATION_TYPES}" STREQUAL "" AND NOT "${CMAKE_BUILD_TYPE}" STREQUAL "")
+        # handle single config generators - like makefiles/ninja - when CMAKE_BUILD_TYPE is set
+        string(TOUPPER ${CMAKE_BUILD_TYPE} config)
+        list(APPEND ${result} CMAKE_C_FLAGS_${config})
+        list(APPEND ${result} CMAKE_CXX_FLAGS_${config})
+        if(${with_linker})
+            list(APPEND ${result} CMAKE_EXE_LINKER_FLAGS_${config})
+            list(APPEND ${result} CMAKE_MODULE_LINKER_FLAGS_${config})
+            list(APPEND ${result} CMAKE_SHARED_LINKER_FLAGS_${config})
+            list(APPEND ${result} CMAKE_STATIC_LINKER_FLAGS_${config})
+        endif()
+    else()
+        # handle multi config generators (like msvc, xcode)
+        foreach(config ${CMAKE_CONFIGURATION_TYPES})
+            string(TOUPPER ${config} config)
+            list(APPEND ${result} CMAKE_C_FLAGS_${config})
+            list(APPEND ${result} CMAKE_CXX_FLAGS_${config})
+            if(${with_linker})
+                list(APPEND ${result} CMAKE_EXE_LINKER_FLAGS_${config})
+                list(APPEND ${result} CMAKE_MODULE_LINKER_FLAGS_${config})
+                list(APPEND ${result} CMAKE_SHARED_LINKER_FLAGS_${config})
+                list(APPEND ${result} CMAKE_STATIC_LINKER_FLAGS_${config})
+            endif()
+        endforeach()
+    endif()
+endmacro()
+
+# ucm_set_runtime
+# Sets the runtime (static/dynamic) for msvc/gcc
+macro(ucm_set_runtime)
+    cmake_parse_arguments(ARG "STATIC;DYNAMIC" "" "" ${ARGN})
+
+    if(ARG_UNPARSED_ARGUMENTS)
+        message(FATAL_ERROR "unrecognized arguments: ${ARG_UNPARSED_ARGUMENTS}")
+    endif()
+
+    if(CMAKE_CXX_COMPILER_ID MATCHES "Clang" STREQUAL "")
+        message(AUTHOR_WARNING "ucm_set_runtime() does not support clang yet!")
+    endif()
+
+    ucm_gather_flags(0 flags_configs)
+
+    # add/replace the flags
+    # note that if the user has messed with the flags directly this function might fail
+    # - for example if with MSVC and the user has removed the flags - here we just switch/replace them
+    if("${ARG_STATIC}")
+        foreach(flags ${flags_configs})
+            if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
+                if(NOT ${flags} MATCHES "-static-libstdc\\+\\+")
+                    set(${flags} "${${flags}} -static-libstdc++")
+                endif()
+                if(NOT ${flags} MATCHES "-static-libgcc")
+                    set(${flags} "${${flags}} -static-libgcc")
+                endif()
+            elseif(MSVC)
+                if(${flags} MATCHES "/MD")
+                    string(REGEX REPLACE "/MD" "/MT" ${flags} "${${flags}}")
+                endif()
+            endif()
+        endforeach()
+    elseif("${ARG_DYNAMIC}")
+        foreach(flags ${flags_configs})
+            if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
+                if(${flags} MATCHES "-static-libstdc\\+\\+")
+                    string(REGEX REPLACE "-static-libstdc\\+\\+" "" ${flags} "${${flags}}")
+                endif()
+                if(${flags} MATCHES "-static-libgcc")
+                    string(REGEX REPLACE "-static-libgcc" "" ${flags} "${${flags}}")
+                endif()
+            elseif(MSVC)
+                if(${flags} MATCHES "/MT")
+                    string(REGEX REPLACE "/MT" "/MD" ${flags} "${${flags}}")
+                endif()
+            endif()
+        endforeach()
+    endif()
+endmacro()
+
+# ucm_print_flags
+# Prints all compiler flags for all configurations
+macro(ucm_print_flags)
+    ucm_gather_flags(1 flags_configs)
+    message(STATUS "")
+    foreach(flags ${flags_configs})
+        message(STATUS "${flags}: ${${flags}}")
+    endforeach()
+    message(STATUS "")
+endmacro()
+
+# ucm_set_xcode_attrib
+# Set xcode attributes - name value CONFIG config1 conifg2..
+macro(ucm_set_xcode_attrib)
+    cmake_parse_arguments(ARG "" "CLEAR" "CONFIG" ${ARGN})
+
+    if(NOT ARG_CONFIG)
+        set(ARG_CONFIG " ")
+    endif()
+
+    foreach(CONFIG ${ARG_CONFIG})
+        # determine to which attributes to add
+        if(${CONFIG} STREQUAL " ")
+            if(${ARG_CLEAR})
+                # clear the old flags
+                unset(CMAKE_XCODE_ATTRIBUTE_${ARGV0})
+            else()
+                set(CMAKE_XCODE_ATTRIBUTE_${ARGV0} ${ARGV1})
+            endif()
+        else()
+            if(${ARG_CLEAR})
+                # clear the old flags
+                unset(CMAKE_XCODE_ATTRIBUTE_${ARGV0}[variant=${CONFIG}])
+            else()
+                set(CMAKE_XCODE_ATTRIBUTE_${ARGV0}[variant=${CONFIG}] ${ARGV1})
+            endif()
+        endif()
+    endforeach()
+endmacro()
+
+# ucm_count_sources
+# Counts the number of source files
+macro(ucm_count_sources)
+    cmake_parse_arguments(ARG "" "RESULT" "" ${ARGN})
+    if(${ARG_RESULT} STREQUAL "")
+        message(FATAL_ERROR "Need to pass RESULT and a variable name to ucm_count_sources()")
+    endif()
+
+    set(result 0)
+    foreach(SOURCE_FILE ${ARG_UNPARSED_ARGUMENTS})
+        if("${SOURCE_FILE}" MATCHES \\.\(c|C|cc|cp|cpp|CPP|c\\+\\+|cxx|i|ii\)$)
+            math(EXPR result "${result} + 1")
+        endif()
+    endforeach()
+    set(${ARG_RESULT} ${result})
+endmacro()
+
+# ucm_include_file_in_sources
+# Includes the file to the source with compiler flags
+macro(ucm_include_file_in_sources)
+    cmake_parse_arguments(ARG "" "HEADER" "" ${ARGN})
+    if(${ARG_HEADER} STREQUAL "")
+        message(FATAL_ERROR "Need to pass HEADER and a header file to ucm_include_file_in_sources()")
+    endif()
+
+    foreach(src ${ARG_UNPARSED_ARGUMENTS})
+        if(${src} MATCHES \\.\(c|C|cc|cp|cpp|CPP|c\\+\\+|cxx\)$)
+            # get old flags
+            get_source_file_property(old_compile_flags ${src} COMPILE_FLAGS)
+            if(old_compile_flags STREQUAL "NOTFOUND")
+                set(old_compile_flags "")
+            endif()
+
+            # update flags
+            if(MSVC)
+                set_source_files_properties(${src} PROPERTIES COMPILE_FLAGS
+                        "${old_compile_flags} /FI\"${CMAKE_CURRENT_SOURCE_DIR}/${ARG_HEADER}\"")
+            else()
+                set_source_files_properties(${src} PROPERTIES COMPILE_FLAGS
+                        "${old_compile_flags} -include \"${CMAKE_CURRENT_SOURCE_DIR}/${ARG_HEADER}\"")
+            endif()
+        endif()
+    endforeach()
+endmacro()
+
+# ucm_dir_list
+# Returns a list of subdirectories for a given directory
+macro(ucm_dir_list thedir result)
+    file(GLOB sub-dir "${thedir}/*")
+    set(list_of_dirs "")
+    foreach(dir ${sub-dir})
+        if(IS_DIRECTORY ${dir})
+            get_filename_component(DIRNAME ${dir} NAME)
+            LIST(APPEND list_of_dirs ${DIRNAME})
+        endif()
+    endforeach()
+    set(${result} ${list_of_dirs})
+endmacro()
+
+# ucm_trim_front_words
+# Trims X times the front word from a string separated with "/" and removes
+# the front "/" characters after that (used for filters for visual studio)
+macro(ucm_trim_front_words source out num_filter_trims)
+    set(result "${source}")
+    set(counter 0)
+    while(${counter} LESS ${num_filter_trims})
+        MATH(EXPR counter "${counter} + 1")
+        # removes everything at the front up to a "/" character
+        string(REGEX REPLACE "^([^/]+)" "" result "${result}")
+        # removes all consecutive "/" characters from the front
+        string(REGEX REPLACE "^(/+)" "" result "${result}")
+    endwhile()
+    set(${out} ${result})
+endmacro()
+
+# ucm_remove_files
+# Removes source files from a list of sources (path is the relative path for it to be found)
+macro(ucm_remove_files)
+    cmake_parse_arguments(ARG "" "FROM" "" ${ARGN})
+
+    if("${ARG_UNPARSED_ARGUMENTS}" STREQUAL "")
+        message(FATAL_ERROR "Need to pass some relative files to ucm_remove_files()")
+    endif()
+    if(${ARG_FROM} STREQUAL "")
+        message(FATAL_ERROR "Need to pass FROM and a variable name to ucm_remove_files()")
+    endif()
+
+    foreach(cur_file ${ARG_UNPARSED_ARGUMENTS})
+        list(REMOVE_ITEM ${ARG_FROM} ${cur_file})
+    endforeach()
+endmacro()
+
+# ucm_remove_directories
+# Removes all source files from the given directories from the sources list
+macro(ucm_remove_directories)
+    cmake_parse_arguments(ARG "" "FROM" "MATCHES" ${ARGN})
+
+    if("${ARG_UNPARSED_ARGUMENTS}" STREQUAL "")
+        message(FATAL_ERROR "Need to pass some relative directories to ucm_remove_directories()")
+    endif()
+    if(${ARG_FROM} STREQUAL "")
+        message(FATAL_ERROR "Need to pass FROM and a variable name to ucm_remove_directories()")
+    endif()
+
+    foreach(cur_dir ${ARG_UNPARSED_ARGUMENTS})
+        foreach(cur_file ${${ARG_FROM}})
+            string(REGEX MATCH ${cur_dir} res ${cur_file})
+            if(NOT "${res}" STREQUAL "")
+                if("${ARG_MATCHES}" STREQUAL "")
+                    list(REMOVE_ITEM ${ARG_FROM} ${cur_file})
+                else()
+                    foreach(curr_ptrn ${ARG_MATCHES})
+                        string(REGEX MATCH ${curr_ptrn} res ${cur_file})
+                        if(NOT "${res}" STREQUAL "")
+                            list(REMOVE_ITEM ${ARG_FROM} ${cur_file})
+                            break()
+                        endif()
+                    endforeach()
+                endif()
+            endif()
+        endforeach()
+    endforeach()
+endmacro()
+
+# ucm_add_files_impl
+macro(ucm_add_files_impl result trim files)
+    foreach(cur_file ${files})
+        SET(${result} ${${result}} ${cur_file})
+        get_filename_component(FILEPATH ${cur_file} PATH)
+        ucm_trim_front_words("${FILEPATH}" FILEPATH "${trim}")
+        # replacing forward slashes with back slashes so filters can be generated (back slash used in parsing...)
+        STRING(REPLACE "/" "\\" FILTERS "${FILEPATH}")
+        SOURCE_GROUP("${FILTERS}" FILES ${cur_file})
+    endforeach()
+endmacro()
+
+# ucm_add_files
+# Adds files to a list of sources
+macro(ucm_add_files)
+    cmake_parse_arguments(ARG "" "TO;FILTER_POP" "" ${ARGN})
+
+    if("${ARG_UNPARSED_ARGUMENTS}" STREQUAL "")
+        message(FATAL_ERROR "Need to pass some relative files to ucm_add_files()")
+    endif()
+    if(${ARG_TO} STREQUAL "")
+        message(FATAL_ERROR "Need to pass TO and a variable name to ucm_add_files()")
+    endif()
+
+    if("${ARG_FILTER_POP}" STREQUAL "")
+        set(ARG_FILTER_POP 0)
+    endif()
+
+    ucm_add_files_impl(${ARG_TO} ${ARG_FILTER_POP} "${ARG_UNPARSED_ARGUMENTS}")
+endmacro()
+
+# ucm_add_dir_impl
+macro(ucm_add_dir_impl result rec trim dirs_in additional_ext)
+    set(dirs "${dirs_in}")
+
+    # handle the "" and "." cases
+    if("${dirs}" STREQUAL "" OR "${dirs}" STREQUAL ".")
+        set(dirs "./")
+    endif()
+
+    foreach(cur_dir ${dirs})
+        # to circumvent some linux/cmake/path issues - barely made it work...
+        if(cur_dir STREQUAL "./")
+            set(cur_dir "")
+        else()
+            set(cur_dir "${cur_dir}/")
+        endif()
+
+        # since unix is case sensitive - add these valid extensions too
+        # we don't use "UNIX" but instead "CMAKE_HOST_UNIX" because we might be cross
+        # compiling (for example emscripten) under windows and UNIX may be set to 1
+        # Also OSX is case insensitive like windows...
+        set(additional_file_extensions "")
+        if(CMAKE_HOST_UNIX AND NOT APPLE)
+            set(additional_file_extensions
+                    "${cur_dir}*.CPP"
+                    "${cur_dir}*.C"
+                    "${cur_dir}*.H"
+                    "${cur_dir}*.HPP"
+                    )
+        endif()
+
+        foreach(ext ${additional_ext})
+            list(APPEND additional_file_extensions "${cur_dir}*.${ext}")
+        endforeach()
+
+        # find all sources and set them as result
+        FILE(GLOB found_sources RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
+                # https://gcc.gnu.org/onlinedocs/gcc-4.4.1/gcc/Overall-Options.html#index-file-name-suffix-71
+                # sources
+                "${cur_dir}*.cpp"
+                "${cur_dir}*.cxx"
+                "${cur_dir}*.c++"
+                "${cur_dir}*.cc"
+                "${cur_dir}*.cp"
+                "${cur_dir}*.c"
+                "${cur_dir}*.i"
+                "${cur_dir}*.ii"
+                # headers
+                "${cur_dir}*.h"
+                "${cur_dir}*.h++"
+                "${cur_dir}*.hpp"
+                "${cur_dir}*.hxx"
+                "${cur_dir}*.hh"
+                "${cur_dir}*.inl"
+                "${cur_dir}*.inc"
+                "${cur_dir}*.ipp"
+                "${cur_dir}*.ixx"
+                "${cur_dir}*.txx"
+                "${cur_dir}*.tpp"
+                "${cur_dir}*.tcc"
+                "${cur_dir}*.tpl"
+                ${additional_file_extensions})
+        SET(${result} ${${result}} ${found_sources})
+
+        # set the proper filters
+        ucm_trim_front_words("${cur_dir}" cur_dir "${trim}")
+        # replacing forward slashes with back slashes so filters can be generated (back slash used in parsing...)
+        STRING(REPLACE "/" "\\" FILTERS "${cur_dir}")
+        SOURCE_GROUP("${FILTERS}" FILES ${found_sources})
+    endforeach()
+
+    if(${rec})
+        foreach(cur_dir ${dirs})
+            ucm_dir_list("${cur_dir}" subdirs)
+            foreach(subdir ${subdirs})
+                ucm_add_dir_impl(${result} ${rec} ${trim} "${cur_dir}/${subdir}" "${additional_ext}")
+            endforeach()
+        endforeach()
+    endif()
+endmacro()
+
+# ucm_add_dirs
+# Adds all files from directories traversing them recursively to a list of sources
+# and generates filters according to their location (accepts relative paths only).
+# Also this macro trims X times the front word from the filter string for visual studio filters.
+macro(ucm_add_dirs)
+    cmake_parse_arguments(ARG "RECURSIVE" "TO;FILTER_POP" "ADDITIONAL_EXT" ${ARGN})
+
+    if(${ARG_TO} STREQUAL "")
+        message(FATAL_ERROR "Need to pass TO and a variable name to ucm_add_dirs()")
+    endif()
+
+    if("${ARG_FILTER_POP}" STREQUAL "")
+        set(ARG_FILTER_POP 0)
+    endif()
+
+    ucm_add_dir_impl(${ARG_TO} ${ARG_RECURSIVE} ${ARG_FILTER_POP} "${ARG_UNPARSED_ARGUMENTS}" "${ARG_ADDITIONAL_EXT}")
+endmacro()
+
+# ucm_add_target
+# Adds a target eligible for cotiring - unity build and/or precompiled header
+macro(ucm_add_target)
+    cmake_parse_arguments(ARG "UNITY" "NAME;TYPE;PCH_FILE;CPP_PER_UNITY" "UNITY_EXCLUDED;SOURCES" ${ARGN})
+
+    if(NOT "${ARG_UNPARSED_ARGUMENTS}" STREQUAL "")
+        message(FATAL_ERROR "Unrecognized options passed to ucm_add_target()")
+    endif()
+    if("${ARG_NAME}" STREQUAL "")
+        message(FATAL_ERROR "Need to pass NAME and a name for the target to ucm_add_target()")
+    endif()
+    set(valid_types EXECUTABLE STATIC SHARED MODULE)
+    list(FIND valid_types "${ARG_TYPE}" is_type_valid)
+    if(${is_type_valid} STREQUAL "-1")
+        message(FATAL_ERROR "Need to pass TYPE and the type for the target [EXECUTABLE/STATIC/SHARED/MODULE] to ucm_add_target()")
+    endif()
+    if("${ARG_SOURCES}" STREQUAL "")
+        message(FATAL_ERROR "Need to pass SOURCES and a list of source files to ucm_add_target()")
+    endif()
+
+    # init with the global unity flag
+    set(do_unity ${UCM_UNITY_BUILD})
+
+    # check the UNITY argument
+    if(NOT ARG_UNITY)
+        set(do_unity FALSE)
+    endif()
+
+    # if target is excluded through the exclusion list
+    list(FIND UCM_UNITY_BUILD_EXCLUDE_TARGETS ${ARG_NAME} is_target_excluded)
+    if(NOT ${is_target_excluded} STREQUAL "-1")
+        set(do_unity FALSE)
+    endif()
+
+    # unity build only for targets with > 1 source file (otherwise there will be an additional unnecessary target)
+    if(do_unity) # optimization
+        ucm_count_sources(${ARG_SOURCES} RESULT num_sources)
+        if(${num_sources} LESS 2)
+            set(do_unity FALSE)
+        endif()
+    endif()
+
+    set(wanted_cotire ${do_unity})
+
+    # if cotire cannot be used
+    if(do_unity AND NOT ucm_with_cotire)
+        set(do_unity FALSE)
+    endif()
+
+    # inform the developer that the current target might benefit from a unity build
+    if(NOT ARG_UNITY AND ${UCM_UNITY_BUILD})
+        ucm_count_sources(${ARG_SOURCES} RESULT num_sources)
+        if(${num_sources} GREATER 1)
+            message(AUTHOR_WARNING "Target '${ARG_NAME}' may benefit from a unity build.\nIt has ${num_sources} sources - enable with UNITY flag")
+        endif()
+    endif()
+
+    # prepare for the unity build
+    set(orig_target ${ARG_NAME})
+    if(do_unity)
+        # the original target will be added with a different name than the requested
+        set(orig_target ${ARG_NAME}_ORIGINAL)
+
+        # exclude requested files from unity build of the current target
+        foreach(excluded_file "${ARG_UNITY_EXCLUDED}")
+            set_source_files_properties(${excluded_file} PROPERTIES COTIRE_EXCLUDED TRUE)
+        endforeach()
+    endif()
+
+    # add the original target
+    if(${ARG_TYPE} STREQUAL "EXECUTABLE")
+        add_executable(${orig_target} ${ARG_SOURCES})
+    else()
+        add_library(${orig_target} ${ARG_TYPE} ${ARG_SOURCES})
+    endif()
+
+    if(do_unity)
+        # set the number of unity cpp files to be used for the unity target
+        if(NOT "${ARG_CPP_PER_UNITY}" STREQUAL "")
+            set_property(TARGET ${orig_target} PROPERTY COTIRE_UNITY_SOURCE_MAXIMUM_NUMBER_OF_INCLUDES "${ARG_CPP_PER_UNITY}")
+        else()
+            set_property(TARGET ${orig_target} PROPERTY COTIRE_UNITY_SOURCE_MAXIMUM_NUMBER_OF_INCLUDES "100")
+        endif()
+
+        if(NOT "${ARG_PCH_FILE}" STREQUAL "")
+            set_target_properties(${orig_target} PROPERTIES COTIRE_CXX_PREFIX_HEADER_INIT "${ARG_PCH_FILE}")
+        else()
+            set_target_properties(${orig_target} PROPERTIES COTIRE_ENABLE_PRECOMPILED_HEADER FALSE)
+        endif()
+        # add a unity target for the original one with the name intended for the original
+        set_target_properties(${orig_target} PROPERTIES COTIRE_UNITY_TARGET_NAME ${ARG_NAME})
+
+        # this is the library call that does the magic
+        cotire(${orig_target})
+        set_target_properties(clean_cotire PROPERTIES FOLDER "CMakePredefinedTargets")
+
+        # disable the original target and enable the unity one
+        get_target_property(unity_target_name ${orig_target} COTIRE_UNITY_TARGET_NAME)
+        set_target_properties(${orig_target} PROPERTIES EXCLUDE_FROM_ALL 1 EXCLUDE_FROM_DEFAULT_BUILD 1)
+        set_target_properties(${unity_target_name} PROPERTIES EXCLUDE_FROM_ALL 0 EXCLUDE_FROM_DEFAULT_BUILD 0)
+
+        # also set the name of the target output as the original one
+        set_target_properties(${unity_target_name} PROPERTIES OUTPUT_NAME ${ARG_NAME})
+        if(UCM_NO_COTIRE_FOLDER)
+            # reset the folder property so all unity targets dont end up in a single folder in the solution explorer of VS
+            set_target_properties(${unity_target_name} PROPERTIES FOLDER "")
+        endif()
+        set_target_properties(all_unity PROPERTIES FOLDER "CMakePredefinedTargets")
+    elseif(NOT "${ARG_PCH_FILE}" STREQUAL "")
+        set(wanted_cotire TRUE)
+        if(ucm_with_cotire)
+            set_target_properties(${orig_target} PROPERTIES COTIRE_ADD_UNITY_BUILD FALSE)
+            set_target_properties(${orig_target} PROPERTIES COTIRE_CXX_PREFIX_HEADER_INIT "${ARG_PCH_FILE}")
+            cotire(${orig_target})
+            set_target_properties(clean_cotire PROPERTIES FOLDER "CMakePredefinedTargets")
+        endif()
+    endif()
+
+    # print a message if the target was requested to be cotired but it couldn't
+    if(wanted_cotire AND NOT ucm_with_cotire)
+        if(NOT COMMAND cotire)
+            message(AUTHOR_WARNING "Target \"${ARG_NAME}\" not cotired because cotire isn't loaded")
+        else()
+            message(AUTHOR_WARNING "Target \"${ARG_NAME}\" not cotired because cotire is older than the required version")
+        endif()
+    endif()
+endmacro()
\ No newline at end of file
diff --git a/tuplex/codegen/CMakeLists.txt b/tuplex/codegen/CMakeLists.txt
index 6171d4d1f..16a94584b 100755
--- a/tuplex/codegen/CMakeLists.txt
+++ b/tuplex/codegen/CMakeLists.txt
@@ -79,8 +79,6 @@ ENDIF()
 
 # for brewed llvm, add to cmakemodulepath
 IF(LLVM_ROOT_DIR)
-    EXECUTE_PROCESS(COMMAND "ls" "/opt" COMMAND_ECHO STDOUT)
-    EXECUTE_PROCESS(COMMAND "ls" "${LLVM_ROOT_DIR}" COMMAND_ECHO STDOUT)
     # make cmake find in config mode the right LLVMConfig.cmake file which is located here
     set(LLVM_DIR "${LLVM_ROOT_DIR}/lib/cmake/llvm")
 ENDIF()
diff --git a/tuplex/python/tuplex/context.py b/tuplex/python/tuplex/context.py
index e6af62a43..be9f3d2c4 100644
--- a/tuplex/python/tuplex/context.py
+++ b/tuplex/python/tuplex/context.py
@@ -17,7 +17,7 @@
 import glob
 import sys
 import cloudpickle
-from tuplex.utils.common import flatten_dict, load_conf_yaml, stringify_dict, unflatten_dict, save_conf_yaml, in_jupyter_notebook, in_google_colab, is_in_interactive_mode, current_user, host_name
+from tuplex.utils.common import flatten_dict, load_conf_yaml, stringify_dict, unflatten_dict, save_conf_yaml, in_jupyter_notebook, in_google_colab, is_in_interactive_mode, current_user, is_shared_lib, host_name
 import uuid
 import json
 from .metrics import Metrics
@@ -78,8 +78,12 @@ def __init__(self, conf=None, name="", **kwargs):
         """
         runtime_path = os.path.join(os.path.dirname(__file__), 'libexec', 'tuplex_runtime')
         paths = glob.glob(runtime_path + '*')
+
         if len(paths) != 1:
+            # filter based on type (runtime must be shared object!)
+            paths = list(filter(is_shared_lib, paths))
 
+        if len(paths) != 1:
             if len(paths) == 0:
                 logging.error("found no tuplex runtime (tuplex_runtime.so). Faulty installation?")
             else:
diff --git a/tuplex/python/tuplex/utils/common.py b/tuplex/python/tuplex/utils/common.py
index c55275d85..a0c916bdb 100644
--- a/tuplex/python/tuplex/utils/common.py
+++ b/tuplex/python/tuplex/utils/common.py
@@ -19,6 +19,7 @@
 import os
 import socket
 import shutil
+import subprocess
 
 try:
   import pwd
@@ -38,6 +39,20 @@ def cmd_exists(cmd):
     """
     return shutil.which(cmd) is not None
 
+def is_shared_lib(path):
+    """
+    Args:
+        path: str path to a file
+    detects whether given path is a shared object or not
+    Returns: true if shared object, false else
+    """
+
+    # use file command
+    assert cmd_exists('file')
+
+    res = subprocess.check_output(['file', '--mime-type', path])
+    mime_type = res.split()[-1].decode()
+    return mime_type == 'application/x-sharedlib' or mime_type == 'application/x-application'
 
 def current_timestamp():
     """
diff --git a/tuplex/python/tuplex/utils/interactive_shell.py b/tuplex/python/tuplex/utils/interactive_shell.py
index a20e67aa9..bdcc84210 100644
--- a/tuplex/python/tuplex/utils/interactive_shell.py
+++ b/tuplex/python/tuplex/utils/interactive_shell.py
@@ -33,6 +33,17 @@
 from tuplex.utils.globs import get_globals
 
 
+# this is a helper to allow for tuplex.Context syntax
+# the idea is basically, we can't simply call 'import tuplex' because this would
+# lead to a circular import. Yet, for user convenience, simply exposing tuplex.Context should be sufficient!
+class TuplexModuleHelper:
+    def __init__(self, context_cls):
+        self._context_cls = context_cls
+
+    @property
+    def Context(self):
+        return self._context_cls
+
 # Interactive shell
 # check https://github.com/python/cpython/blob/master/Lib/code.py for overwriting this class
 class TuplexShell(InteractiveConsole):
@@ -44,6 +55,11 @@ def __init__(self):
         self.__dict__ = self.__shared_state
 
     def init(self, locals=None, filename="<console>", histfile=os.path.expanduser("~/.console_history")):
+
+        # add dummy helper for context
+        if locals is not None and 'Context' in locals.keys():
+            locals['tuplex'] = TuplexModuleHelper(locals['Context'])
+
         self.initialized = True
         self.filename = "console-0"
         self.lineno = 0
diff --git a/tuplex/test/CMakeLists.txt b/tuplex/test/CMakeLists.txt
index c22994431..ee4aac87e 100755
--- a/tuplex/test/CMakeLists.txt
+++ b/tuplex/test/CMakeLists.txt
@@ -51,7 +51,7 @@ if(NOT GTest_FOUND)
             EXCLUDE_FROM_ALL)
     set(GTest_LIBRARIES "gtest")
 else()
-    message(STATUS "using locally installed GoogleTest")
+    message(STATUS "Using locally installed GoogleTest")
     set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
     set(GTest_LIBRARIES GTest::gtest)
 endif()
diff --git a/tuplex/test/runtime/CMakeLists.txt b/tuplex/test/runtime/CMakeLists.txt
index cb3075765..1bf63b34d 100755
--- a/tuplex/test/runtime/CMakeLists.txt
+++ b/tuplex/test/runtime/CMakeLists.txt
@@ -2,6 +2,10 @@ CMAKE_MINIMUM_REQUIRED(VERSION 3.12 FATAL_ERROR)
 
 # enable c++14
 set(CMAKE_CXX_STANDARD 14)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+# enable c11
+set(CMAKE_C_STANDARD 11)
+set(CMAKE_C_STANDARD_REQUIRED ON)
 
 file(GLOB SRCS *.cc)
 
diff --git a/tuplex/test/wrappers/CMakeLists.txt b/tuplex/test/wrappers/CMakeLists.txt
index a090b3052..adfa18109 100644
--- a/tuplex/test/wrappers/CMakeLists.txt
+++ b/tuplex/test/wrappers/CMakeLists.txt
@@ -1,7 +1,11 @@
 CMAKE_MINIMUM_REQUIRED(VERSION 3.12 FATAL_ERROR)
 
 # enable c++14
-SET(CMAKE_CXX_STANDARD 14)
+set(CMAKE_CXX_STANDARD 14)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+# enable c11
+set(CMAKE_C_STANDARD 11)
+set(CMAKE_C_STANDARD_REQUIRED ON)
 
 FILE(GLOB SRCS *.cc)
 FILE(GLOB PYSRCS ../../python/src/*.cc)
@@ -10,7 +14,6 @@ FILE(GLOB PYSRCS ../../python/src/*.cc)
 #list(REMOVE_ITEM PYSRCS "../../python/src/PythonBindings.cc")
 list(FILTER PYSRCS EXCLUDE REGEX ".*PythonBindings.cc$")
 
-
 include(GoogleTest)
 
 ADD_EXECUTABLE(testwrappers ${SRCS} ${PYSRCS})
diff --git a/tuplex/utils/CMakeLists.txt b/tuplex/utils/CMakeLists.txt
index d32f0dfc0..07decaa15 100644
--- a/tuplex/utils/CMakeLists.txt
+++ b/tuplex/utils/CMakeLists.txt
@@ -11,6 +11,7 @@ set(EXTERNAL_INSTALL_LOCATION ${CMAKE_BINARY_DIR}/third_party)
 ExternalProject_Add(fmt
         GIT_REPOSITORY https://github.com/fmtlib/fmt.git
         GIT_TAG 6.2.0
+        GIT_CONFIG advice.detachedHead=false
         TIMEOUT 5
         CMAKE_ARGS -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER} -DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS}
         PREFIX "${EXTERNAL_INSTALL_LOCATION}"
@@ -27,6 +28,7 @@ set(EXTERNAL_INSTALL_LOCATION ${CMAKE_BINARY_DIR}/third_party)
 ExternalProject_Add(spdlog
         GIT_REPOSITORY https://github.com/gabime/spdlog.git
         GIT_TAG v1.3.1
+        GIT_CONFIG advice.detachedHead=false
         TIMEOUT 5
         CMAKE_ARGS -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER} -DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS} #-DSPDLOG_BUILD_BENCH=OFF
         PREFIX "${EXTERNAL_INSTALL_LOCATION}"
@@ -48,6 +50,7 @@ if(NOT BUILD_WITH_AWS)
     FetchContent_Declare(cJSON
         GIT_REPOSITORY https://github.com/DaveGamble/cJSON.git
         GIT_TAG        v1.7.14
+        GIT_CONFIG advice.detachedHead=false
     )
     FetchContent_GetProperties(cJSON)
     if(NOT cjson_Populated)
@@ -69,6 +72,7 @@ set_target_properties(libutils PROPERTIES PREFIX "")
 ExternalProject_Add(json
         GIT_REPOSITORY https://github.com/nlohmann/json.git
         GIT_TAG v3.5.0
+        GIT_CONFIG advice.detachedHead=false
         TIMEOUT 5
         CMAKE_ARGS -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER} -DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS}
         PREFIX "${EXTERNAL_INSTALL_LOCATION}"
@@ -102,6 +106,4 @@ target_include_directories(libutils PUBLIC
         ${AWSSDK_INCLUDE_DIR})
 
 # Specify here the libraries this program depends on
-target_link_libraries(libutils Boost::filesystem Boost::thread Boost::system Boost::system Boost::iostreams ${AWSSDK_LINK_LIBRARIES})
-
-#install(TARGETS libutils DESTINATION lib)
\ No newline at end of file
+target_link_libraries(libutils Boost::filesystem Boost::thread Boost::system Boost::system Boost::iostreams ${AWSSDK_LINK_LIBRARIES})
\ No newline at end of file