diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md
deleted file mode 100644
index dd84ea7824..0000000000
--- a/.github/ISSUE_TEMPLATE/bug_report.md
+++ /dev/null
@@ -1,38 +0,0 @@
----
-name: Bug report
-about: Create a report to help us improve
-title: ''
-labels: ''
-assignees: ''
-
----
-
-**Describe the bug**
-A clear and concise description of what the bug is.
-
-**To Reproduce**
-Steps to reproduce the behavior:
-1. Go to '...'
-2. Click on '....'
-3. Scroll down to '....'
-4. See error
-
-**Expected behavior**
-A clear and concise description of what you expected to happen.
-
-**Screenshots**
-If applicable, add screenshots to help explain your problem.
-
-**Desktop (please complete the following information):**
- - OS: [e.g. iOS]
- - Browser [e.g. chrome, safari]
- - Version [e.g. 22]
-
-**Smartphone (please complete the following information):**
- - Device: [e.g. iPhone6]
- - OS: [e.g. iOS8.1]
- - Browser [e.g. stock browser, safari]
- - Version [e.g. 22]
-
-**Additional context**
-Add any other context about the problem here.
diff --git a/.github/ISSUE_TEMPLATE/feature_request.md b/.github/ISSUE_TEMPLATE/feature_request.md
deleted file mode 100644
index bbcbbe7d61..0000000000
--- a/.github/ISSUE_TEMPLATE/feature_request.md
+++ /dev/null
@@ -1,20 +0,0 @@
----
-name: Feature request
-about: Suggest an idea for this project
-title: ''
-labels: ''
-assignees: ''
-
----
-
-**Is your feature request related to a problem? Please describe.**
-A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
-
-**Describe the solution you'd like**
-A clear and concise description of what you want to happen.
-
-**Describe alternatives you've considered**
-A clear and concise description of any alternative solutions or features you've considered.
-
-**Additional context**
-Add any other context or screenshots about the feature request here.
diff --git a/.gitmodules b/.gitmodules
index 74da17fb90..29a0412525 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -13,3 +13,6 @@
 [submodule "thirdparty/spdlog"]
 	path = thirdparty/spdlog
 	url = https://github.com/gabime/spdlog.git
+[submodule "thirdparty/googletest"]
+	path = thirdparty/googletest
+	url = https://github.com/google/googletest.git
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 4ebd069b56..a140f666a5 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -44,7 +44,8 @@ option(BUILD_APPS                              "Build the eCAL applications"
 option(BUILD_SAMPLES                           "Build the eCAL samples"                                            ON)
 option(BUILD_TIME                              "Build the eCAL time interfaces"                                    ON)
 option(BUILD_PY_BINDING                        "Build eCAL python binding"                                        OFF)
-option(ECAL_LAYER_FASTRTPS                     "Provide fast rtps as communication layer"                         OFF)
+option(BUILD_TESTS                             "Build the eCAL google tests"                                      OFF)
+
 option(ECAL_LAYER_ICEORYX                      "Provide iceoryx as communication layer"                           OFF)
 
 option(ECAL_INCLUDE_PY_SAMPLES                 "Include python language sample projects into CMake"               OFF)
@@ -55,8 +56,9 @@ option(ECAL_NPCAP_SUPPORT                      "Enable the eCAL Npcap Receiver (
 
 # Set option regarding third party library builds
 option(ECAL_THIRDPARTY_BUILD_CMAKE_FUNCTIONS   "Build CMakeFunctions with eCAL"                                    ON)
-option(ECAL_THIRDPARTY_BUILD_PROTOBUF          "Build Protobuf with eCAL"                                          ON)
+option(ECAL_THIRDPARTY_BUILD_PROTOBUF          "Build protobuf with eCAL"                                          ON)
 option(ECAL_THIRDPARTY_BUILD_SPDLOG            "Build spdlog with eCAL"                                            ON)
+option(ECAL_THIRDPARTY_BUILD_GTEST             "Build gtest with eCAL"                                            OFF)
 
 set(ECAL_INSTALL_PYTHON_DIR "bin" CACHE PATH "Location to install the Python extension modules. Might be set by setupdtools install.")
 
@@ -79,7 +81,7 @@ message(STATUS "Prefix Path: ${CMAKE_PREFIX_PATH}")
 # --------------------------------------------------------
 # third party dependencies as requested
 # --------------------------------------------------------
-if (ECAL_THIRDPARTY_BUILD_PROTOBUF OR ECAL_THIRDPARTY_BUILD_SPDLOG)
+if (ECAL_THIRDPARTY_BUILD_PROTOBUF OR ECAL_THIRDPARTY_BUILD_SPDLOG OR ECAL_THIRDPARTY_BUILD_GTEST)
   if(MSVC)
     # supress thirdparty warnings for windows platform
     set(CMAKE_CXX_FLAGS_OLD "${CMAKE_CXX_FLAGS}")
@@ -115,7 +117,24 @@ if (ECAL_THIRDPARTY_BUILD_SPDLOG)
   add_library(spdlog::spdlog ALIAS spdlog)
 endif ()
 
-if (ECAL_THIRDPARTY_BUILD_PROTOBUF OR ECAL_THIRDPARTY_BUILD_SPDLOG)
+if (ECAL_THIRDPARTY_BUILD_GTEST)
+  list(APPEND as_subproject GTest)
+  # Googletest automatically forces MT instead of MD if we do not set this option.
+  if(MSVC)
+    set(gtest_force_shared_crt ON CACHE BOOL "My option" FORCE)
+    set(BUILD_GMOCK OFF CACHE BOOL "My option" FORCE)
+    set(INSTALL_GTEST OFF CACHE BOOL "My option" FORCE)
+  endif()
+  add_subdirectory(thirdparty/googletest)
+  if(NOT TARGET GTest::GTest)
+    add_library(GTest::GTest ALIAS gtest)
+  endif()
+  if(NOT TARGET GTest::Main)
+    add_library(GTest::Main ALIAS gtest_main)
+  endif()
+endif()
+
+if (ECAL_THIRDPARTY_BUILD_PROTOBUF OR ECAL_THIRDPARTY_BUILD_SPDLOG OR ECAL_THIRDPARTY_BUILD_GTEST)
   if(MSVC)
     # reset thirdparty warnings for windows platform
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS_OLD}")
@@ -298,6 +317,7 @@ add_subdirectory(ecal/core/src)
 # custom libs
 # --------------------------------------------------------
 add_subdirectory(lib/ThreadingUtils)
+add_subdirectory(lib/CustomTclap)
 add_subdirectory(lib/EcalUtils)
 if(HAS_QT5)
   add_subdirectory(lib/CustomQt)
@@ -374,7 +394,7 @@ if(BUILD_APPS AND HAS_QT5)
   endif()
   add_subdirectory(app/mon/eCALMonPlugins)
 # --------------------------------------------------------
-# Qt5 Apps using HDF5
+# qt applications using hdf5
 # --------------------------------------------------------
 if(BUILD_APPS AND HAS_QT5 AND HAS_HDF5)
   add_subdirectory(app/play/eCALPlayGUI)
@@ -383,12 +403,40 @@ endif()
 endif()
 
 # --------------------------------------------------------
-# Samples
+# samples
 # --------------------------------------------------------
 if(BUILD_SAMPLES)
   add_subdirectory(samples)
 endif()
 
+# --------------------------------------------------------
+# unit tests
+# --------------------------------------------------------
+if(BUILD_TESTS)
+  enable_testing()
+
+  # ------------------------------------------------------
+  # test contrib
+  # ------------------------------------------------------
+  if(HAS_HDF5)
+    add_subdirectory(testing/contrib/ecalhdf5/hdf5_test/src)
+  endif()
+  add_subdirectory(testing/contrib/ecalproto/dynproto_test/src)
+  add_subdirectory(testing/contrib/ecalproto/ecal_proto_test/src)
+
+  # ------------------------------------------------------
+  # test ecal
+  # ------------------------------------------------------
+  add_subdirectory(testing/ecal/clientserver_test/src)
+  add_subdirectory(testing/ecal/core_test/src)
+  add_subdirectory(testing/ecal/event_test/src)
+  add_subdirectory(testing/ecal/expmap_test/src)
+  add_subdirectory(testing/ecal/io_memfile_test/src)
+  add_subdirectory(testing/ecal/pubsub_inproc_test/src)
+  add_subdirectory(testing/ecal/pubsub_proto_test/src)
+  add_subdirectory(testing/ecal/pubsub_test/src)
+endif()
+
 # --------------------------------------------------------
 # configs
 # --------------------------------------------------------
diff --git a/NOTICE.txt b/NOTICE.txt
index 4e0860c30b..ebdc70a476 100644
--- a/NOTICE.txt
+++ b/NOTICE.txt
@@ -21,7 +21,7 @@ This project has dependencies - list with dependency name and license follows.
  
   - Apache License 2.0 - https://www.apache.org/licenses/LICENSE-2.0
   - Boost Software License - http://www.boost.org/LICENSE_1_0.txt
-  - BSD 2-Clause License - http://www.opensource.org/licenses/bsd-license.php
+  - BSD 3-Clause License - https://opensource.org/licenses/BSD-3-Clause
   - GNU Lesser General Public License v2.1 - https://www.gnu.org/licenses/old-licenses/lgpl-2.1.de.html
   - GNU Lesser General Public License v3 - https://www.gnu.org/licenses/lgpl-3.0.de.html
   - MIT License - https://opensource.org/licenses/MIT
@@ -36,17 +36,8 @@ This project has dependencies - list with dependency name and license follows.
   - Copyright © 2003-2018 Christopher M. Kohlhoff
   - URL: https://think-async.com
   - License: Boost Software License - http://www.boost.org/LICENSE_1_0.txt
-
-2.1.2 LCM-Lite
-  - URL: https://github.com/lcm-proj/lcm/tree/master/lcm-lite
-  - License: GNU Lesser General Public License v2.1 - https://github.com/lcm-proj/lcm/blob/master/COPYING
-
-2.1.3 FastRTPS / FastCDR
-  - Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima)
-  - URL: https://github.com/eProsima/Fast-RTPS
-  - License: Apache License 2.0 - https://github.com/eProsima/Fast-RTPS/blob/master/LICENSE
   
-2.1.4 NPCAP
+2.1.2 NPCAP
   - Copyright 2013-2016 by Insecure.Com LLC
   - URL: https://nmap.org/npcap/
   - License: Npcap License - https://github.com/nmap/npcap/blob/master/LICENSE
@@ -99,3 +90,10 @@ This project has dependencies - list with dependency name and license follows.
   - Copyright 2013-2019 Freepik Company S.L. All rights reserved.
   - URL: https://www.flaticon.com/
   - License: Creative Commons 3.0 - https://creativecommons.org/licenses/by/3.0
+
+2.5 Testing
+
+2.5.1 GoogleTest
+  - Copyright 2008 Google Inc.
+  - URL: https://github.com/google/googletest
+  - License: BSD 3-Clause License - https://github.com/google/googletest/blob/master/LICENSE.txt
diff --git a/PVSSettings.xml b/PVSSettings.xml
index 71628d0473..d49ceb2ade 100644
--- a/PVSSettings.xml
+++ b/PVSSettings.xml
@@ -15,9 +15,6 @@
   <PathMasks>
     <string>\qt\</string>
     <string>\_build\</string>
-    <string>\ecal\core\src\readwrite\fastrtps\string_message_PubSubTypes.cxx</string>
-    <string>\ecal\core\src\readwrite\fastrtps\string_message_.cxx</string>
-    <string>\ecal\core\src\readwrite\lcm\lcmlite.cpp</string>
     <string>\thirdparty\</string>
   </PathMasks>
   <UncheckedButtons>toolstrip_L3Warnings toolStripButton_OP toolStripButton_64</UncheckedButtons>
diff --git a/README.md b/README.md
index 505d463523..76b6334d8d 100644
--- a/README.md
+++ b/README.md
@@ -26,7 +26,7 @@ additional informations like a unique name, a type and a description. A topic ca
   
   • Callback: A Callback can be used to react on time events, on incoming messages, on service requests or service responses. 
 
-eCAL is simplifying the data transport as much as possible, It uses different mechanism to transport a topic from a publisher to a connected subscriber. On the same computer node the data are exchanged by using memory mapped files. Between different computing nodes UDP multicast can be used for high performance data throughput, rtps can be used for reliable data transport.
+eCAL is simplifying the data transport as much as possible, It uses different mechanism to transport a topic from a publisher to a connected subscriber. On the same computer node the data are exchanged by using memory mapped files. Between different computing nodes UDP multicast can be used for high performance data throughput.
 
 
 ## Checkout the repository
@@ -67,8 +67,8 @@ eCAL is using CMake as build system. When configuring with CMake, you can turn o
   Build the eCAL time interfaces, necessary if you want to use ecal in time synchronized mode (based on ptp for example)
 - `BUILD_PY_BINDING`, default `OFF`
   Build the eCAL python language binding
-- `ECAL_LAYER_FASTRTPS`, default `OFF`
-  Provide fast rtps as communication layer, requires fast-rtps and fast-cdr installations
+- `BUILD_TESTS', default `OFF`
+  Build the eCAL google tests
 - `ECAL_LAYER_ICEORYX`, default `OFF`
   Provide iceoryx as communication layer, requires [eclipse/iceoryx](https://github.com/eclipse/iceoryx) installation
 - `ECAL_INCLUDE_PY_SAMPLES`, default: `OFF`
@@ -83,6 +83,8 @@ eCAL is using CMake as build system. When configuring with CMake, you can turn o
   Build Protobuf with eCAL, included as a submodule in the thirdparty folder. You can always use your custom protobuf installation, this is only for convenience. Note, at least protobuf 3.0 is required to compile eCAL, we recommend using 3.5.1 or newer (tested with 3.5.1).
 - `ECAL_THIRDPARTY_BUILD_SPDLOG`, default `ON`
   Build Spdlog with eCAL, included as a submodule in the thirdparty folder. You can always use your custom spdlog installation, this is only for convenience.
+- `ECAL_THIRDPARTY_BUILD_GTEST`, default `OFF`
+  Build GoogleTest with eCAL, included as a submodule in the thirdparty folder. You can always use your custom gtest installation, this is only for convenience.
 
 All options can be passed on the command line `cmake -D<option>=<value>` or in the CMake GUI application.
 
@@ -143,12 +145,12 @@ All options can be passed on the command line `cmake -D<option>=<value>` or in t
 3. Create a debian package and install it, if desired:
 	```bash
 	cpack -G DEB
-	sudo dpkg -i eCAL-*
+	sudo dpkg -i _deploy/eCAL-*
 	```
 3. Create and install the eCAL python egg:
 	```bash
 	cmake --build . --target create_python_egg --config Release
-	sudo python3 -m easy_install ecal-*
+	sudo python3 -m easy_install _deploy/ecal-*
 	```
 
 ### UDP network configuration
@@ -280,6 +282,33 @@ You can find the ecal.ini configuration file under %APPDATA%\eCAL.
 
 Don't forget to disable any windows firewall.
 
+
+## Transport Layer Concept
+
+eCAL is able to communicate on different so called transport layers, but first of all you have to decide if you want to communicate in a network or in a local host only mode. To configure this you need to set the ecal.ini [network/network_enabled] parameter to true (network communication mode) or false (local host only communication mode).
+
+After this you can fine tune the way of message transport for inner-process, interprocess and the interhost connections.
+There are different ways to configure these layers. They can be set up for a whole machine using the central configuration file (ecal.ini) or for a single eCAL process passed by command line arguments or finally for a single publish-subscribe connection using the C++ or python publisher API (see "Setup the transport layer"). Every single builtin transport layer has it's specific communication properties.
+
+| Layer           | Ini parameter            | Physical Layer     | Comment                                                                                   |
+|-----------------|--------------------------|--------------------|-------------------------------------------------------------------------------------------|
+| inproc          | [publisher/use_inproc]   | inner process      | inner process, zeroy copy communication (pointer forwarding)                              |
+| shm             | [publisher/use_shm]      | shared memory      | interprocess, shared memory communication, supports N:M connections, 2 memory copies      |
+| iceoryx         | [publisher/use_iceoryx]  | shared memory      | interprocess, shared memory communication, supports 1:1 connections, 1 memory copy        |
+| udp_mc          | [publisher/use_udp_mc]   | udp multicast      | interhost, topic name based dynamic multicast grouping to optimize pub/sub socket payload |
+
+Every layer can set up in 3 different activation modes. Every mode can be configured as default in the ecal.ini file and can be overwritten by the C++/Python publisher API. This is the activation logic
+
+  • off: layer will not be used for any communication
+  
+  • on: layer will be used independently if there is any local or host outside subscription
+  
+  • auto: layer will be used on demand (shm = 2 and udp_mc = 2 means shm layer will be used if there is any local subscription, udp_multicast will be used if there is a subscription outside the current host)
+  
+The "auto" mode is currently working for inproc, shm and udp_mc only (planned for iceoryx with the next release). In this mode a publisher send call will return without wasting any CPU time if there is no innerprocess, local host or network subscription.
+
+Independent from this publisher setting you can switch on/off the receiving logic for every layer. This can be done in the ecal.ini file [network] section. By default inproc (inproc_rec_enabled), shm (shm_rec_enabled) and udp_mc (udp_mc_rec_enabled) is switched on. If you want to experiment with iceoryx please set iceoryx_rec_enabled to true. For example switching off the udp multicast layer for a machine or a single process can avoid that the process will process incoming socket traffic even it is not interested in publications outside it's host.
+
 ## Applications
 
 Besides the communication core eCAL comes with some high-level applications for monitoring, recording and replaying messages. The monitoring application is used to provide an overview of all existing entities (publisher, subscriber, services) that are using the eCAL API to communicate. Recorder and player are designed to record messages in a distributed system efficiently and to replay them for post processing, analysis or simulation.
@@ -330,10 +359,10 @@ The table shows the results for a Windows and a Linux platform (200000 samples 1
 
 ```
 -------------------------------
- Platform Windows 10 (AMD64)
+ Platform
 -------------------------------
-OS Name:                            Microsoft Windows 10 Enterprise
-OS Version:                         10.0.16299
+OS Name:                            Microsoft Windows 10 Pro
+OS Version:                         10.0.18363
 OS Manufacturer:                    Microsoft Corporation
 OS Build Type:                      Multiprocessor Free
 System Manufacturer:                HP
@@ -341,44 +370,28 @@ System Model:                       HP ZBook 15 G5
 System Type:                        x64-based PC
 Processor(s):                       1 Prozessor(s) Installed.
                                     [01]: Intel64 Family 6 Model 158 Stepping 10 GenuineIntel ~2592 MHz
-Total Physical Memory:              32.579 MB
-
--------------------------------
- Platform Ubuntu 16 (AMD64)
--------------------------------
-H/W path      Device    Class       Description
-===============================================
-                        system      HP ZBook 15 G3 (M9R63AV)
-/0                      bus         80D5
-/0/0                    memory      128KiB L1 Cache
-/0/1                    memory      128KiB L1 Cache
-/0/2                    memory      1MiB L2 Cache
-/0/3                    memory      8MiB L3 Cache
-/0/4                    processor   Intel(R) Core(TM) i7-6820HQ CPU @ 2.70GHz
-/0/5                    memory      16GiB System Memory
-/0/5/0                  memory      8GiB SODIMM Synchron 2133 MHz (0,5 ns)
-/0/5/1                  memory      8GiB SODIMM Synchron 2133 MHz (0,5 ns)
+Total Physical Memory:              32.614 MB
 
 ```
 
-|Payload Size (kB)|Win10 AMD64 (µs)|Ubuntu16 AMD64 (µs)|Ubuntu16 AMD64 (µs)|
+|Payload Size (kB)|Win10 AMD64 (µs)|Ubuntu18 AMD64 (µs)|Ubuntu18 AMD64 (µs)|
 |----------------:|---------------:|------------------:|------------------:|
 |                 |      eCAL SHM  |         eCAL SHM  |      Iceoryx SHM  |
-|              1  |            10  |                5  |                5  |
-|              2  |            11  |                5  |                5  |
-|              4  |            16  |                6  |                6  |
-|              8  |            16  |                6  |                6  |
-|             16  |            17  |                7  |                6  |
-|             32  |            18  |                8  |                7  |
-|             64  |            21  |               11  |                8  |
-|            128  |            26  |               17  |               12  |
-|            256  |            38  |               34  |               19  |
-|            512  |            62  |               83  |               32  |
-|           1024  |           123  |              289  |              253  |
-|           2048  |           378  |              565  |              425  |
-|           4096  |           848  |              939  |              431  |
-|           8192  |          1762  |             1840  |              767  |
-|          16384  |          3681  |             3531  |             1565  |
+|              1  |            10  |                4  |                6  |
+|              2  |            10  |                4  |                6  |
+|              4  |            10  |                5  |                6  |
+|              8  |            11  |                5  |                6  |
+|             16  |            12  |                6  |                6  |
+|             32  |            13  |                7  |                8  |
+|             64  |            16  |               10  |               10  |
+|            128  |            21  |               15  |               13  |
+|            256  |            32  |               33  |               19  |
+|            512  |            56  |               50  |               28  |
+|           1024  |           103  |              154  |               82  |
+|           2048  |           363  |              392  |              177  |
+|           4096  |           867  |              877  |              420  |
+|           8192  |          1814  |             1119  |              534  |
+|          16384  |          3956  |             2252  |             1060  |
 
 ## Usage
 
@@ -629,10 +642,7 @@ The currently supported layers are
 enum eTransportLayer
 {
   tlayer_udp_mc     = 1,  // udp multicast (eCAL - using multiple multicast groups for high efficient data transport)
-  tlayer_udp_uc     = 2,  // udp unicast   (eCAL)
   tlayer_shm        = 4,  // shared memory (eCAL)
-  tlayer_lcm        = 5,  // lcm           (Google)
-  tlayer_rtps       = 6,  // rtps          (eProsima - a standard DDS transport layer)
   tlayer_iceoryx    = 7,  // iceoryx       (Bosch zero copy shared memory layer)
   tlayer_inproc     = 42, // inner process (eCAL - deterministic inner process communication)
 };
diff --git a/app/mon/eCALMon/CMakeLists.txt b/app/mon/eCALMon/CMakeLists.txt
index 5dd46ebc62..e84a227caf 100644
--- a/app/mon/eCALMon/CMakeLists.txt
+++ b/app/mon/eCALMon/CMakeLists.txt
@@ -43,10 +43,12 @@ set(source_files
     src/EcalmonGlobals.h
     src/main.cpp
     src/Util.h
-    
-    src/PluginLoader.cpp
-    src/PluginLoader.h
-    
+
+    src/Plugin/PluginManager.cpp
+    src/Plugin/PluginManager.h
+    src/Plugin/PluginWrapper.cpp
+    src/Plugin/PluginWrapper.h
+
     src/Widgets/AboutDialog/AboutDialog.cpp
     src/Widgets/AboutDialog/AboutDialog.h
 
@@ -112,7 +114,7 @@ set(source_files
     src/Widgets/Models/TopicTreeModel.cpp
     src/Widgets/Models/TopicTreeModel.h
     src/Widgets/Models/TreeItemType.h
-    
+
     src/Widgets/PluginSettingsDialog/PluginSettingsDialog.cpp
     src/Widgets/PluginSettingsDialog/PluginSettingsDialog.h
 
@@ -120,7 +122,7 @@ set(source_files
     src/Widgets/VisualisationWidget/VisualisationWidget.h
     src/Widgets/VisualisationWidget/VisualisationWindow.cpp
     src/Widgets/VisualisationWidget/VisualisationWindow.h
-    
+
     src/Widgets/SystemInformationWidget/SystemInformationWidget.cpp
     src/Widgets/SystemInformationWidget/SystemInformationWidget.h
 
diff --git a/app/mon/eCALMon/src/Ecalmon.cpp b/app/mon/eCALMon/src/Ecalmon.cpp
index 9bfd999159..ad4426ed13 100644
--- a/app/mon/eCALMon/src/Ecalmon.cpp
+++ b/app/mon/eCALMon/src/Ecalmon.cpp
@@ -30,7 +30,7 @@
 #endif //ECAL_NPCAP_SUPPORT
 
 #include "EcalmonGlobals.h"
-#include "PluginLoader.h"
+#include "Plugin/PluginManager.h"
 
 #include <QSettings>
 #include <QDesktopWidget>
@@ -212,15 +212,16 @@ Ecalmon::Ecalmon(QWidget *parent)
 
   ui_.action_monitor_refresh_speed_1s->trigger();
 
-  PluginLoader::getInstance()->discover();
+  PluginManager::getInstance()->discover();
 
   // Restore plugin states
   QSettings settings;
   settings.beginGroup("plugins");
-  for (const auto& iid : PluginLoader::getInstance()->getAvailableIIDs())
+  for (const auto& iid : PluginManager::getInstance()->getAvailableIIDs())
   {
-    if (settings.value(iid, true).toBool())
-      PluginLoader::getInstance()->getPluginByIID(iid).load();
+    // Maybe we should deactivate plugins with a false setting?
+    bool isActive{ settings.value(iid, true).toBool() };
+    PluginManager::getInstance()->setActive(iid, isActive);
   }
   settings.endGroup();
 }
@@ -473,8 +474,8 @@ void Ecalmon::closeEvent(QCloseEvent* event)
 
   // save plugin state by iid
   settings.beginGroup("plugins");
-  for (const auto& iid : PluginLoader::getInstance()->getAvailableIIDs())
-    settings.setValue(iid, PluginLoader::getInstance()->getPluginByIID(iid).isLoaded());
+  for (const auto& iid : PluginManager::getInstance()->getAvailableIIDs())
+    settings.setValue(iid, PluginManager::getInstance()->isActive(iid));
   settings.endGroup();
 
   event->accept();
diff --git a/app/mon/eCALMon/src/MainWindow.ui b/app/mon/eCALMon/src/MainWindow.ui
index cb85c0e04c..31901cb2bf 100644
--- a/app/mon/eCALMon/src/MainWindow.ui
+++ b/app/mon/eCALMon/src/MainWindow.ui
@@ -339,7 +339,7 @@
   <action name="action_clear_log">
    <property name="icon">
     <iconset resource="../../../iconset/ecalicons.qrc">
-     <normaloff>:/ecalicons/REMOVE</normaloff>:/ecalicons/REMOVE</iconset>
+     <normaloff>:/ecalicons/CLEAR</normaloff>:/ecalicons/CLEAR</iconset>
    </property>
    <property name="text">
     <string>&amp;Clear Log</string>
diff --git a/app/mon/eCALMon/src/Plugin/PluginManager.cpp b/app/mon/eCALMon/src/Plugin/PluginManager.cpp
new file mode 100644
index 0000000000..f3119fcc88
--- /dev/null
+++ b/app/mon/eCALMon/src/Plugin/PluginManager.cpp
@@ -0,0 +1,217 @@
+/* ========================= eCAL LICENSE =================================
+ *
+ * Copyright (C) 2016 - 2019 Continental Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * ========================= eCAL LICENSE =================================
+*/
+
+#include <Plugin/PluginManager.h>
+
+#include <memory>
+
+#include <QApplication>
+#include <QDir>
+#include <QLibrary>
+#include <QProcessEnvironment>
+
+#include <ecal/ecal_log.h>
+
+std::unique_ptr<PluginManager> PluginManager::instance_;
+
+
+PluginManager::PluginManager()
+{
+}
+
+QChar pathSeparator()
+{
+#ifdef Q_OS_WIN
+  return ';';
+#else
+  return ':';
+#endif
+}
+
+// Function returns a list of directories which are considered valid locations for plugins.
+QVector<QDir> GetPluginDirectories()
+{
+  QVector<QDir> plugin_directories;
+
+  // Specify the default plugin directory
+  // On windows: cwd/ecalmon_plugins
+  // On Linux: ../lib/ecal/mon_plugins
+  auto default_plugin_dir = QDir(qApp->applicationDirPath());
+#ifdef Q_OS_WIN
+  default_plugin_dir.cd("ecalmon_plugins");
+#else
+  default_plugin_dir.cdUp();
+  default_plugin_dir.cd("lib");
+  default_plugin_dir.cd("ecal");
+  default_plugin_dir.cd("plugins");
+  default_plugin_dir.cd("mon");
+#endif
+  plugin_directories.push_back(default_plugin_dir);
+
+  // Retrieve additional plugin directories through the environment varialbe "ECAL_MON_PLUGIN_PATH"
+  auto current_environment = QProcessEnvironment::systemEnvironment();
+  auto additional_plugin_paths = current_environment.value("ECAL_MON_PLUGIN_PATH");
+
+  if (!additional_plugin_paths.isEmpty())
+  {
+    auto paths = additional_plugin_paths.split(pathSeparator());
+    for (const auto& path : paths)
+    {
+      plugin_directories.push_back(QDir(path));
+    }
+  }
+
+  return plugin_directories;
+}
+
+// Function iterates over all specified directories and returns a list of library files contained in these directories
+QVector<QString> GetPluginLibraryPaths(const QVector<QDir>& plugin_directories)
+{
+  QVector<QString> plugin_library_paths;
+  for (const auto& dir : plugin_directories)
+  {
+    for (const auto& file_name : dir.entryList(QDir::Files))
+    {
+      auto file_path = dir.absoluteFilePath(file_name);
+      if (QLibrary::isLibrary(file_path))
+      {
+        plugin_library_paths.push_back(file_path);
+      }
+    }
+  }
+  return plugin_library_paths;
+}
+
+// Add Found plugins and deactivate them by default
+void PluginManager::AddFoundPlugins(const QVector<QString>& library_paths)
+{
+  for (const auto& file_path : library_paths)
+  {
+    try {
+      PluginWrapper plugin(file_path);
+      auto iid = plugin.getPluginData().iid;
+      auto meta_data = plugin.getPluginData().meta_data;
+
+      auto plugin_iter = plugins_.find(iid);
+
+      if (plugin_iter == plugins_.end())
+        plugins_.insert(iid, ActivePlugin{ plugin, false });
+      else {
+        if (plugin_iter->wrapper.getPluginData().path != file_path)
+          eCAL::Logging::Log(eCAL_Logging_eLogLevel::log_level_warning,
+            "Ambiguous plugin iid " + iid.toStdString() + " of " + meta_data.name.toStdString() + " " +
+            meta_data.version.toStdString() + ".  Plugin " + file_path.toStdString() +
+            " was not loaded.");
+      }
+    }
+    catch (const std::runtime_error &e) {
+      eCAL::Logging::Log(eCAL_Logging_eLogLevel::log_level_warning,
+        std::string(e.what()) + " Plugin " + file_path.toStdString() + " was not loaded.");
+    }
+  }
+}
+
+void PluginManager::ActivateDistinctPlugins()
+{
+  // Map that contains a vector of references to all plugins with the same name
+  QMap<QString, std::vector<std::reference_wrapper<ActivePlugin>>> plugins_by_name;
+  // 1. Get distinct plugin names
+  for (auto& plugin : plugins_)
+  {
+    QString name = plugin.wrapper.getPluginData().meta_data.name;
+    plugins_by_name[name].emplace_back(plugin);
+  }
+  // 2. For each distinct name
+  for (auto& vector_of_plugins_with_same_name : plugins_by_name)
+  {
+    // 3. Activate plugin with highest version number
+    auto max_plugin = std::max_element(vector_of_plugins_with_same_name.begin(), vector_of_plugins_with_same_name.end(), std::less<ActivePlugin>{});
+    max_plugin->get().active = true;
+  }
+}
+
+// This function creates a list with plugins
+void PluginManager::discover()
+{
+  auto plugin_directories = GetPluginDirectories();
+  auto library_paths = GetPluginLibraryPaths(plugin_directories);
+
+  AddFoundPlugins(library_paths);
+  ActivateDistinctPlugins();
+}
+
+QList<QString> PluginManager::getAvailableIIDs() const
+{
+  return plugins_.keys();
+}
+
+PluginWrapper::PluginData PluginManager::getPluginData(const QString & iid) const
+{
+  return plugins_[iid].wrapper.getPluginData();
+}
+
+bool PluginManager::isActive(const QString & iid) const
+{
+  return plugins_[iid].active;
+}
+
+void PluginManager::setActive(const QString & iid, bool active)
+{
+  plugins_[iid].active = active;
+}
+
+
+
+QList<QPair<PluginWrapper::PluginData, eCAL::mon::PluginWidgetInterface*>> PluginManager::CreatePlugins(QString topic_name, QString topic_type, QWidget* parent)
+{
+  QList<QPair<PluginWrapper::PluginData, eCAL::mon::PluginWidgetInterface*>> supported_plugins;
+  for (auto& plugin : plugins_)
+  {
+    if (!plugin.active)
+      continue;
+
+    bool accepts_topic{ AcceptsTopic(plugin.wrapper, topic_name, topic_type) };
+    if (accepts_topic)
+    {
+      auto interface { plugin.wrapper.create(topic_name, topic_type, parent) };
+      if (interface)
+      {
+        supported_plugins.push_back(QPair<PluginWrapper::PluginData, eCAL::mon::PluginWidgetInterface*>{plugin.wrapper.getPluginData(), interface});
+      }
+    }
+  }
+
+  // Sort return vector by priority
+  qSort(supported_plugins.begin(), supported_plugins.end(), [](const auto& lhs, const auto& rhs)
+  {
+    return lhs.first.meta_data.priority < rhs.first.meta_data.priority;
+  });
+
+  return supported_plugins;
+}
+
+PluginManager* PluginManager::getInstance()
+{
+  if (!instance_)
+  {
+    instance_.reset(new PluginManager);
+  }
+
+  return instance_.get();
+}
diff --git a/app/mon/eCALMon/src/Plugin/PluginManager.h b/app/mon/eCALMon/src/Plugin/PluginManager.h
new file mode 100644
index 0000000000..9bf71578e8
--- /dev/null
+++ b/app/mon/eCALMon/src/Plugin/PluginManager.h
@@ -0,0 +1,58 @@
+/* ========================= eCAL LICENSE =================================
+ *
+ * Copyright (C) 2016 - 2019 Continental Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * ========================= eCAL LICENSE =================================
+*/
+
+#pragma once
+
+#include <QMap>
+
+#include <Plugin/PluginWrapper.h>
+
+class PluginManager
+{
+public:
+  struct ActivePlugin
+  {
+    PluginWrapper wrapper;
+    bool active;
+
+    bool operator<(const ActivePlugin& rhs) const
+    {
+      return wrapper < rhs.wrapper;
+    }
+  };
+
+  static PluginManager* getInstance();
+  void discover();
+
+  QList<QString> getAvailableIIDs() const;
+  PluginWrapper::PluginData getPluginData(const QString& iid) const;
+  bool isActive(const QString& iid) const;
+  void setActive(const QString& iid, bool loaded);
+
+  QList<QPair<PluginWrapper::PluginData, eCAL::mon::PluginWidgetInterface*>> CreatePlugins(QString topic_name, QString topic_type, QWidget* parent);
+
+private:
+  PluginManager();
+
+  void AddFoundPlugins(const QVector<QString>& library_paths);
+  void ActivateDistinctPlugins();
+
+  static std::unique_ptr<PluginManager> instance_;
+  QMap<QString, ActivePlugin> plugins_;
+};
\ No newline at end of file
diff --git a/app/mon/eCALMon/src/Plugin/PluginWrapper.cpp b/app/mon/eCALMon/src/Plugin/PluginWrapper.cpp
new file mode 100644
index 0000000000..4f65f38274
--- /dev/null
+++ b/app/mon/eCALMon/src/Plugin/PluginWrapper.cpp
@@ -0,0 +1,195 @@
+/* ========================= eCAL LICENSE =================================
+ *
+ * Copyright (C) 2016 - 2019 Continental Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * ========================= eCAL LICENSE =================================
+*/
+
+#include <Plugin/PluginWrapper.h>
+
+#include <QJsonArray>
+#include <QPluginLoader>
+#define HAS_Q_VERSION_NUMBER (QT_VERSION >= QT_VERSION_CHECK(5, 6, 0))
+#if HAS_Q_VERSION_NUMBER
+#include <QVersionNumber>
+#endif
+
+#include <ecal/ecal_log.h>
+
+QPair<QString, QString> splitTopicType(const QString& topic_type)
+{
+  auto std_topic_type = topic_type.toStdString();
+  auto position = std_topic_type.find(":");
+  if (position == std::string::npos)
+    return qMakePair(QString(), topic_type);
+
+  auto format = std_topic_type.substr(0, position);
+  std_topic_type.erase(0, position + 1);
+
+  return qMakePair(QString(format.c_str()), QString(std_topic_type.c_str()));
+}
+
+PluginWrapper::PluginData::MetaData jsonToMetaStruct(const QJsonObject& json)
+{
+  PluginWrapper::PluginData::MetaData meta_data{};
+
+  auto json_meta_data = json["MetaData"].toObject();
+  meta_data.name = json_meta_data.contains("Name") ? json_meta_data["Name"].toString() : QString();
+  meta_data.version = json_meta_data.contains("Version") ? json_meta_data["Version"].toString() : QString();
+  meta_data.author = json_meta_data.contains("Author") ? json_meta_data["Author"].toString() : QString();
+  meta_data.priority = json_meta_data.contains("Priority") ? json_meta_data["Priority"].toInt() : 0;
+
+  auto json_topics = json_meta_data.contains("SupportedTopics") ? json_meta_data["SupportedTopics"].toArray() : QJsonArray();
+  for (const auto& json_topic : json_topics)
+  {
+    PluginWrapper::PluginData::MetaData::Topic topic;
+    auto json_topic_toObject = json_topic.toObject();
+    topic.name = json_topic_toObject.contains("Name") ? json_topic_toObject["Name"].toString() : QString();
+    topic.type = json_topic_toObject.contains("Type") ? json_topic_toObject["Type"].toString() : QString();
+    topic.format = json_topic_toObject.contains("Format") ? json_topic_toObject["Format"].toString() : QString();
+
+    meta_data.topics.push_back(topic);
+  }
+
+  return meta_data;
+}
+
+PluginWrapper::PluginWrapper(const QString& path)
+{
+  QPluginLoader loader(path);
+
+  auto json_meta_data = loader.metaData();
+  if (!json_meta_data.empty())
+  {
+    plugin_data_ = PluginData
+    {
+      json_meta_data["IID"].toString(),
+      path,
+      jsonToMetaStruct(json_meta_data)
+    };
+  }
+  else
+  {
+    throw std::runtime_error("Invalid meta data.");
+  }
+}
+
+const PluginWrapper::PluginData& PluginWrapper::getPluginData() const
+{
+  return plugin_data_;
+}
+
+bool PluginWrapper::load()
+{
+  if (!isLoaded())
+  {
+    QPluginLoader loader(plugin_data_.path);
+    auto instance = loader.instance();
+    if (instance)
+    {
+      eCAL::mon::PluginInterface* plugin = qobject_cast<eCAL::mon::PluginInterface*>(instance);
+      if (plugin)
+      {
+        eCAL::Logging::Log(eCAL_Logging_eLogLevel::log_level_info, "Plugin " + plugin_data_.meta_data.name.toStdString() + " " + plugin_data_.meta_data.version.toStdString() + " has been loaded.");
+        instance_ = std::shared_ptr<eCAL::mon::PluginInterface>(plugin,
+          [this](eCAL::mon::PluginInterface* p)
+        {
+          eCAL::Logging::Log(eCAL_Logging_eLogLevel::log_level_info, "Plugin " + plugin_data_.meta_data.name.toStdString() + " " + plugin_data_.meta_data.version.toStdString() + " has been unloaded.");
+          delete dynamic_cast<QObject*>(p);
+        });
+        return true;
+      }
+      else
+      {
+        eCAL::Logging::Log(eCAL_Logging_eLogLevel::log_level_warning, "Plugin " + plugin_data_.path.toStdString() + " is not suitable for eCAL Monitor");
+        loader.unload();
+      }
+    }
+    else
+      eCAL::Logging::Log(eCAL_Logging_eLogLevel::log_level_warning, "Unable to load plugin " + plugin_data_.path.toStdString() + ".");
+  }
+  else
+    return true;
+
+  return false;
+}
+
+bool PluginWrapper::isLoaded() const
+{
+  if (instance_.get() == nullptr)
+    return false;
+  return true;
+}
+
+bool PluginWrapper::unload()
+{
+  if (instance_.use_count() <= 1)
+  {
+    instance_.reset();
+    return true;
+  }
+
+  return false;
+}
+
+eCAL::mon::PluginWidgetInterface* PluginWrapper::create(const QString& topic_name, const QString& topic_type, QWidget* parent)
+{
+  if (!isLoaded())
+  {
+    if (!load())
+      return nullptr;
+  }
+
+  return instance_->create(topic_name, topic_type, parent);
+}
+
+bool AcceptsTopic(const PluginWrapper & wrapper, QString topic_name, QString topic_type)
+{
+  for (const auto& topic : wrapper.getPluginData().meta_data.topics)
+  {
+    if (
+      (topic.name.isEmpty() || (topic.name == topic_name)) &&
+      (topic.type.isEmpty() || (topic.type == splitTopicType(topic_type).second)) &&
+      (topic.format.isEmpty() || (topic.format == splitTopicType(topic_type).first))
+      )
+    {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool PluginWrapper::PluginData::MetaData::operator<(const MetaData & rhs) const
+{
+  {
+#if HAS_Q_VERSION_NUMBER
+    auto qversion{ QVersionNumber::fromString(version) };
+    auto rhs_qversion{ QVersionNumber::fromString(rhs.version) };
+    return std::tie(priority, name, qversion) < std::tie(rhs.priority, rhs.name, rhs_qversion);
+#else
+    return std::tie(priority, name, version) < std::tie(rhs.priority, rhs.name, rhs.version);
+#endif
+  }
+}
+
+bool PluginWrapper::PluginData::operator<(const PluginWrapper::PluginData& rhs) const
+{
+  return meta_data < rhs.meta_data;
+}
+
+bool PluginWrapper::operator<(const PluginWrapper& rhs) const
+{
+  return plugin_data_ < rhs.plugin_data_;
+}
\ No newline at end of file
diff --git a/app/mon/eCALMon/src/PluginLoader.h b/app/mon/eCALMon/src/Plugin/PluginWrapper.h
similarity index 55%
rename from app/mon/eCALMon/src/PluginLoader.h
rename to app/mon/eCALMon/src/Plugin/PluginWrapper.h
index 902274ee8c..885aca621f 100644
--- a/app/mon/eCALMon/src/PluginLoader.h
+++ b/app/mon/eCALMon/src/Plugin/PluginWrapper.h
@@ -23,66 +23,59 @@
 
 #include <ecal/mon/plugin.h>
 
-#include <QMap>
-
-class PluginLoader;
-
 class PluginWrapper
 {
 public:
-  PluginWrapper() = default;
-
-  struct MetaData
+  struct PluginData
   {
-    QString name;
-    QString version;
-    QString author;
-    int priority;
-
-    struct Topic
+    struct MetaData
     {
       QString name;
-      QString type;
-      QString format;
+      QString version;
+      QString author;
+      int priority;
+
+      struct Topic
+      {
+        QString name;
+        QString type;
+        QString format;
+      };
+
+      QVector<Topic> topics;
+      bool operator<(const MetaData& rhs) const;
     };
 
-    QVector<Topic> topics;
+    QString iid;
+    QString path;
+    MetaData meta_data;
+
+    bool operator<(const PluginData& rhs) const;
   };
 
-  MetaData getMetaData() const;
-  QString getPath() const;
-  QString getIID() const;
+  PluginWrapper() = default;
+  PluginWrapper(const QString& path);
 
-  bool load();
+  bool operator<(const PluginWrapper& rhs) const;
+
+  /* Returns the plugin data, that is associated with this plugin */
+  const PluginData& getPluginData() const;
+
+  /* Checks if the Plugin has been loaded (the underlying dll)*/
   bool isLoaded() const;
+  /* Load the plugin into memory */
+  bool load();
+  /* Unload the plugin from memory*/
   bool unload();
-
-  PluginWrapper(const QString& path);
   
+  /* Create an instance of a PluginWidgetInterface for this plugin */
   eCAL::mon::PluginWidgetInterface* create(const QString& topic_name, const QString& topic_type, QWidget* parent);
 
 private:
-  QString iid_;
-  QString path_;
-  MetaData meta_data_;
+  PluginData plugin_data_;
 
   std::shared_ptr<eCAL::mon::PluginInterface> instance_;
 };
 
-class PluginLoader
-{
-public:
-  static PluginLoader* getInstance();
-  void discover();
-
-  QList<QString> getAvailableIIDs() const;
-  PluginWrapper& getPluginByIID(const QString& iid);
-
-  QList<PluginWrapper> getSupportedPlugins(const QString& topic_name, const QString& topic_type) const;
-
-private:
-  PluginLoader();
-
-  static std::unique_ptr<PluginLoader> instance_;
-  QMap<QString, PluginWrapper> plugins_;
-};
+/* This function checks if a given topic name and topic type are accepted by the Plugin given in wrapper */
+bool AcceptsTopic(const PluginWrapper& wrapper, QString topic_name, QString topic_type);
\ No newline at end of file
diff --git a/app/mon/eCALMon/src/PluginLoader.cpp b/app/mon/eCALMon/src/PluginLoader.cpp
deleted file mode 100644
index 5c60cf1019..0000000000
--- a/app/mon/eCALMon/src/PluginLoader.cpp
+++ /dev/null
@@ -1,353 +0,0 @@
-/* ========================= eCAL LICENSE =================================
- *
- * Copyright (C) 2016 - 2019 Continental Corporation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * ========================= eCAL LICENSE =================================
-*/
-
-#include "PluginLoader.h"
-
-#include <ecal/ecal_log.h>
-
-#include <QDir>
-#include <QApplication>
-#include <QLibrary>
-#include <QPluginLoader>
-#include <QJsonArray>
-#include <QDebug>
-#include <QProcessEnvironment>
-
-using namespace eCAL::mon;
-
-PluginWrapper::MetaData PluginWrapper::getMetaData() const
-{
-  return meta_data_;
-}
-
-QString PluginWrapper::getPath() const
-{
-  return path_;
-}
-
-QString PluginWrapper::getIID() const
-{
-  return iid_;
-}
-
-bool PluginWrapper::load()
-{
-  if (!isLoaded())
-  {
-    QPluginLoader loader(path_);
-    auto instance = loader.instance();
-    if (instance)
-    {
-      eCAL::mon::PluginInterface* plugin = qobject_cast<eCAL::mon::PluginInterface*>(instance);
-      if (plugin)
-      {
-        eCAL::Logging::Log(eCAL_Logging_eLogLevel::log_level_info, "Plugin " + meta_data_.name.toStdString() + " " + meta_data_.version.toStdString() + " has been loaded.");
-        instance_ = std::shared_ptr<eCAL::mon::PluginInterface>(plugin, 
-          [this](eCAL::mon::PluginInterface* p)
-        {
-          eCAL::Logging::Log(eCAL_Logging_eLogLevel::log_level_info, "Plugin " + meta_data_.name.toStdString() + " " + meta_data_.version.toStdString() + " has been unloaded.");
-          delete dynamic_cast<QObject*>(p);
-        });
-        return true;
-      }
-      else
-      {
-        eCAL::Logging::Log(eCAL_Logging_eLogLevel::log_level_warning, "Plugin " + path_.toStdString() + " is not suitable for eCAL Monitor");
-        loader.unload();
-      }
-    }
-    else
-      eCAL::Logging::Log(eCAL_Logging_eLogLevel::log_level_warning, "Unable to load plugin " + path_.toStdString() + ".");
-  }
-  else
-    return true;
-
-  return false;
-}
-
-bool PluginWrapper::isLoaded() const
-{
-  if (instance_.get() == nullptr)
-    return false;
-  return true;
-}
-
-bool PluginWrapper::unload()
-{
-  if (instance_.use_count() <= 1)
-  {
-    instance_.reset();
-    return true;
-  }
-
-  return false;
-}
-
-static PluginWrapper::MetaData jsonToMetaStruct(const QJsonObject& json)
-{
-  PluginWrapper::MetaData meta_data{};
-
-  auto json_meta_data = json["MetaData"].toObject();
-  meta_data.name = json_meta_data.contains("Name") ? json_meta_data["Name"].toString() : QString();
-  meta_data.version = json_meta_data.contains("Version") ? json_meta_data["Version"].toString() : QString();
-  meta_data.author = json_meta_data.contains("Author") ? json_meta_data["Author"].toString() : QString();
-  meta_data.priority = json_meta_data.contains("Priority") ? json_meta_data["Priority"].toInt() : 0;
-
-  auto json_topics = json_meta_data.contains("SupportedTopics") ? json_meta_data["SupportedTopics"].toArray() : QJsonArray();
-  for (const auto& json_topic : json_topics)
-  {
-    PluginWrapper::MetaData::Topic topic;
-    auto json_topic_toObject = json_topic.toObject();
-    topic.name = json_topic_toObject.contains("Name") ? json_topic_toObject["Name"].toString() : QString();
-    topic.type = json_topic_toObject.contains("Type") ? json_topic_toObject["Type"].toString() : QString();
-    topic.format = json_topic_toObject.contains("Format") ? json_topic_toObject["Format"].toString() : QString();
-
-    meta_data.topics.push_back(topic);
-  }
-
-  return meta_data;
-}
-
-
-PluginWrapper::PluginWrapper(const QString& path)
-{
-  QPluginLoader loader(path);
-
-  auto json_meta_data = loader.metaData();
-  if (!json_meta_data.empty())
-  {
-    meta_data_ = jsonToMetaStruct(json_meta_data);
-    iid_ = json_meta_data["IID"].toString();
-    path_ = path;
-  }
-  else
-  {
-    throw std::runtime_error("Invalid meta data.");
-  }
-}
-
-PluginWidgetInterface* PluginWrapper::create(const QString& topic_name, const QString& topic_type, QWidget* parent)
-{
-  if (!isLoaded())
-  {
-    if (!load())
-      return nullptr;
-  }
-
-  return instance_->create(topic_name, topic_type, parent);
-}
-
-std::unique_ptr<PluginLoader> PluginLoader::instance_;
-
-PluginLoader::PluginLoader()
-{
-}
-
-QChar pathSeparator()
-{
-#ifdef Q_OS_WIN
-  return ';';
-#else
-  return ':';
-#endif
-}
-
-void PluginLoader::discover()
-{
-  // only (re)discover plugins that are not already loaded
-  QVector<QString> unused_plugin_iids;
-  for (const auto& plugin : plugins_)
-    if (!plugin.isLoaded())
-      unused_plugin_iids.push_back(plugin.getIID());
-  for (const auto& iid : unused_plugin_iids)
-    plugins_.erase(plugins_.find(iid));
-
-  // Specify the default plugin directory
-  // On windows: cwd/ecalmon_plugins
-  // On Linux: ../lib/ecal/mon_plugins
-  auto default_plugin_dir = QDir(qApp->applicationDirPath());
-#ifdef Q_OS_WIN
-  default_plugin_dir.cd("ecalmon_plugins");
-#else
-  default_plugin_dir.cdUp();
-  default_plugin_dir.cd("lib");
-  default_plugin_dir.cd("ecal");
-  default_plugin_dir.cd("plugins");
-  default_plugin_dir.cd("mon");
-#endif
-
-  // Vector to specify all pl
-  QVector<QDir> plugin_directories;
-  plugin_directories.push_back(default_plugin_dir);
-
-  // Retrieve additional plugin directories through the environment varialbe "ECAL_MON_PLUGIN_PATH"
-  auto current_environment =  QProcessEnvironment::systemEnvironment();
-  auto additional_plugin_paths = current_environment.value("ECAL_MON_PLUGIN_PATH");
-
-  if (!additional_plugin_paths.isEmpty())
-  {
-    auto paths = additional_plugin_paths.split(pathSeparator());
-    for (const auto& path : paths)
-    {
-      plugin_directories.push_back(QDir(path));
-    }
-  }
-
-  // Iterate through all specified plugin directories to locate plugins
-  for (const auto& dir : plugin_directories)
-  {
-    for (const auto& file_name : dir.entryList(QDir::Files)) {
-      auto file_path = dir.absoluteFilePath(file_name);
-      if (!QLibrary::isLibrary(file_path))
-        continue;
-      try {
-        PluginWrapper plugin(file_path);
-        auto iid = plugin.getIID();
-        auto meta_data = plugin.getMetaData();
-
-        auto plugin_iter = plugins_.find(iid);
-
-        if (plugin_iter == plugins_.end())
-          plugins_.insert(iid, plugin);
-        else {
-          if (plugin_iter->getPath() != file_path)
-            eCAL::Logging::Log(eCAL_Logging_eLogLevel::log_level_warning,
-                               "Ambiguous plugin iid " + iid.toStdString() + " of " + meta_data.name.toStdString() + " " +
-                               meta_data.version.toStdString() + ".  Plugin " + file_name.toStdString() +
-                               " was not loaded.");
-        }
-      }
-      catch (const std::runtime_error &e) {
-        eCAL::Logging::Log(eCAL_Logging_eLogLevel::log_level_warning,
-                           std::string(e.what()) + " Plugin " + file_path.toStdString() + " was not loaded.");
-      }
-    }
-  }  
-}
-
-QList<QString> PluginLoader::getAvailableIIDs() const
-{
-  return plugins_.keys();
-}
-
-PluginWrapper& PluginLoader::getPluginByIID(const QString& iid)
-{
-  return plugins_[iid];
-}
-
-static QPair<QString, QString> splitTopicType(const QString& topic_type)
-{
-  auto std_topic_type = topic_type.toStdString();
-  auto position = std_topic_type.find(":");
-  if (position == std::string::npos)
-    return qMakePair(QString(), topic_type);
-
-  auto format = std_topic_type.substr(0, position);
-  std_topic_type.erase(0, position + 1);
-
-  return qMakePair(QString(format.c_str()), QString(std_topic_type.c_str()));
-}
-
-QList<PluginWrapper> PluginLoader::getSupportedPlugins(const QString& topic_name, const QString& topic_type) const
-{
-  QList<PluginWrapper> supported_plugins;
-  for (const auto& plugin : plugins_)
-  {
-    if (!plugin.isLoaded())
-      continue;
-
-    bool accepts_topic{ false };
-    for (const auto& topic : plugin.getMetaData().topics)
-    {
-      if (
-        (topic.name.isEmpty() || (topic.name == topic_name)) &&
-        (topic.type.isEmpty() || (topic.type == splitTopicType(topic_type).second)) &&
-        (topic.format.isEmpty() || (topic.format == splitTopicType(topic_type).first))
-        )
-      {
-        accepts_topic = true;
-        break;
-      }
-    }
-    if (accepts_topic)
-      supported_plugins.push_back(plugin);
-  }
-
-  qSort(supported_plugins.begin(), supported_plugins.end(), [](const auto& lhs, const auto& rhs)
-  {
-    return lhs.getMetaData().priority < rhs.getMetaData().priority;
-  });
-
-  return supported_plugins;
-}
-
-
-//static QPair<QString, QString> splitTopicType(const QString& topic_type)
-//{
-//  auto std_topic_type = topic_type.toStdString();
-//  auto position = std_topic_type.find(":");
-//  if (position == std::string::npos)
-//    return qMakePair(QString(), topic_type);
-//
-//  auto format = std_topic_type.substr(0, position);
-//  std_topic_type.erase(0, position + 1);
-//
-//  return qMakePair(QString(format.c_str()), QString(std_topic_type.c_str()));
-//}
-//
-//QVector<QPair<PluginMetaData, PluginWidgetInterface*>> PluginLoader::createSupportedPluginWidgets(const QString& topic_name, const QString& topic_type, QWidget* parent )
-//{
-//  QVector<QPair<PluginMetaData, PluginWidgetInterface*>> plugin_widgets;
-//
-//  for (const auto& plugin : plugins_)
-//  {
-//    bool accepts_topic{ false };
-//    for (const auto& topic : plugin.first.topics)
-//    {
-//      if (
-//        (topic.name.isEmpty() || (topic.name == topic_name)) &&
-//        (topic.type.isEmpty() || (topic.type == splitTopicType(topic_type).second)) &&
-//        (topic.format.isEmpty() || (topic.format == splitTopicType(topic_type).first))
-//        )
-//      {
-//        accepts_topic = true;
-//        break;
-//      }
-//    }
-//    if (accepts_topic)
-//      plugin_widgets.push_back(qMakePair(plugin.first, plugin.second->create(topic_name, topic_type, parent)));
-//  }
-//
-//  qSort(plugin_widgets.begin(), plugin_widgets.end(), [](const auto& lhs, const auto& rhs)
-//  {
-//    return lhs.first.priority < rhs.first.priority;
-//  });
-//
-//  return plugin_widgets;
-//}
-//
-PluginLoader* PluginLoader::getInstance()
-{
-  if (instance_.get() == nullptr)
-  {
-    instance_.reset(new PluginLoader);
-  }
-
-  return instance_.get();
-}
diff --git a/app/mon/eCALMon/src/Widgets/EcalmonTreeWidget/ProcessWidget.cpp b/app/mon/eCALMon/src/Widgets/EcalmonTreeWidget/ProcessWidget.cpp
index f80a854eb0..927a5676e0 100644
--- a/app/mon/eCALMon/src/Widgets/EcalmonTreeWidget/ProcessWidget.cpp
+++ b/app/mon/eCALMon/src/Widgets/EcalmonTreeWidget/ProcessWidget.cpp
@@ -47,7 +47,7 @@ ProcessWidget::ProcessWidget(QWidget *parent)
     (int)ProcessTreeModel::Columns::HOST_NAME,
     (int)ProcessTreeModel::Columns::PROCESS_NAME,
     //(int)ProcessTreeModel::Columns::STATE, //TODO: Enable dynamic re-grouping
-    (int)ProcessTreeModel::Columns::TIMESYNC_MODE,
+    (int)ProcessTreeModel::Columns::TIMESYNC_STATE,
   };
 
   QList<EcalmonTreeWidget::GroupSetting> preconfigured_group_by_settings;
@@ -106,10 +106,10 @@ void ProcessWidget::autoSizeColumns()
 {
   eCAL::pb::Process example_process_pb;
   example_process_pb.set_rclock(999999);
-  example_process_pb.set_hname("CARPC00____");
+  example_process_pb.set_hname("HNAME00____");
   example_process_pb.set_pid(999999);
   example_process_pb.set_pname("");
-  example_process_pb.set_uname("CameraSensorMapFusionCAF___");
+  example_process_pb.set_uname("eCALProcessUnitNameABCDE___");
   example_process_pb.set_pparam("");
   example_process_pb.set_pmemory(99999999999);
   example_process_pb.set_pcpu(1000);
@@ -122,7 +122,7 @@ void ProcessWidget::autoSizeColumns()
   //example_process_pb.set_tsync_mode();
 
   ProcessTreeItem* example_process_item = new ProcessTreeItem(example_process_pb);
-  GroupTreeItem* example_group_item = new GroupTreeItem("CARPC00____", "", "", QVariant::Invalid, "");
+  GroupTreeItem* example_group_item = new GroupTreeItem("HNAME00____", "", "", QVariant::Invalid, "");
 
   process_tree_model_->insertItem(example_process_item);
   process_tree_model_->insertItem(example_group_item);
@@ -141,7 +141,9 @@ void ProcessWidget::autoSizeColumns()
     (int)ProcessTreeModel::Columns::USER_TIME,
     (int)ProcessTreeModel::Columns::DATAWRITE,
     (int)ProcessTreeModel::Columns::DATAREAD,
-    (int)ProcessTreeModel::Columns::TIMESYNC_MODE,
+    (int)ProcessTreeModel::Columns::TIMESYNC_STATE,
+    (int)ProcessTreeModel::Columns::TIMESYNC_MOD_NAME,
+    (int)ProcessTreeModel::Columns::COMPONENT_INIT_INFO,
   };
 
   for (int column : columns_to_resize)
diff --git a/app/mon/eCALMon/src/Widgets/EcalmonTreeWidget/TopicWidget.cpp b/app/mon/eCALMon/src/Widgets/EcalmonTreeWidget/TopicWidget.cpp
index fc8eef715a..4c50803ba4 100644
--- a/app/mon/eCALMon/src/Widgets/EcalmonTreeWidget/TopicWidget.cpp
+++ b/app/mon/eCALMon/src/Widgets/EcalmonTreeWidget/TopicWidget.cpp
@@ -388,4 +388,4 @@ void TopicWidget::setParseTimeEnabled(bool enabled)
   {
     visualisation_window->setParseTimeEnabled(parse_time_);
   }
-}
+}
\ No newline at end of file
diff --git a/app/mon/eCALMon/src/Widgets/Models/PluginTableModel.cpp b/app/mon/eCALMon/src/Widgets/Models/PluginTableModel.cpp
index 129250eb9a..28b9a8dd4c 100644
--- a/app/mon/eCALMon/src/Widgets/Models/PluginTableModel.cpp
+++ b/app/mon/eCALMon/src/Widgets/Models/PluginTableModel.cpp
@@ -14,7 +14,7 @@ int PluginTableModel::rowCount(const QModelIndex &parent) const// override
     return 0;
   }
 
-  return PluginLoader::getInstance()->getAvailableIIDs().count();
+  return PluginManager::getInstance()->getAvailableIIDs().count();
 }
 
 int PluginTableModel::columnCount(const QModelIndex &parent) const// override
@@ -26,7 +26,7 @@ int PluginTableModel::columnCount(const QModelIndex &parent) const// override
   return static_cast<int>(Columns::COLUMN_COUNT);
 }
 
-static QString GetTopicDisplayString(const PluginWrapper::MetaData::Topic& topic)
+static QString GetTopicDisplayString(const PluginWrapper::PluginData::MetaData::Topic& topic)
 {
   auto name = (!topic.name.isEmpty()) ? topic.name : QString("*");
   auto type = (!topic.type.isEmpty()) ? topic.type : QString("*");
@@ -39,8 +39,8 @@ QVariant PluginTableModel::data(const QModelIndex &index, int role) const// over
 {
   if (index.isValid())
   {
-    auto iid = PluginLoader::getInstance()->getAvailableIIDs().at(index.row());
-    PluginWrapper& plugin = PluginLoader::getInstance()->getPluginByIID(iid);
+    auto iid = PluginManager::getInstance()->getAvailableIIDs().at(index.row());
+    PluginWrapper::PluginData plugin_data = PluginManager::getInstance()->getPluginData(iid);
 
     Columns column = static_cast<Columns>(index.column());
 
@@ -49,21 +49,21 @@ QVariant PluginTableModel::data(const QModelIndex &index, int role) const// over
       switch (column)
       {
       case Columns::NAME:
-        return plugin.getMetaData().name;
+        return plugin_data.meta_data.name;
       case Columns::VERSION:
-        return plugin.getMetaData().version;
+        return plugin_data.meta_data.version;
       case Columns::AUTHOR:
-        return plugin.getMetaData().author;
+        return plugin_data.meta_data.author;
       case Columns::IID:
-        return plugin.getIID();
+        return plugin_data.iid;
       case Columns::PRIORITY:
-        return plugin.getMetaData().priority;
+        return plugin_data.meta_data.priority;
       case Columns::PATH:
-        return plugin.getPath();
+        return plugin_data.path;
       case Columns::TOPICS:
       {
         QString topics_str;
-        for (const auto& topic : plugin.getMetaData().topics)
+        for (const auto& topic : plugin_data.meta_data.topics)
           topics_str += "\"" + GetTopicDisplayString(topic) + "\"  ";
         return topics_str;
       }
@@ -74,7 +74,7 @@ QVariant PluginTableModel::data(const QModelIndex &index, int role) const// over
     if (role == Qt::ItemDataRole::CheckStateRole)
     {
       if (column == Columns::NAME)
-        return plugin.isLoaded() ? Qt::Checked : Qt::Unchecked;
+        return PluginManager::getInstance()->isActive(iid) ? Qt::Checked : Qt::Unchecked;
     }
   }
 
@@ -85,8 +85,7 @@ bool PluginTableModel::setData(const QModelIndex &index, const QVariant &value,
 {
   if (index.isValid())
   {
-    auto iid = PluginLoader::getInstance()->getAvailableIIDs().at(index.row());
-    PluginWrapper& plugin = PluginLoader::getInstance()->getPluginByIID(iid);
+    auto iid = PluginManager::getInstance()->getAvailableIIDs().at(index.row());
 
     Columns column = static_cast<Columns>(index.column());
 
@@ -96,13 +95,11 @@ bool PluginTableModel::setData(const QModelIndex &index, const QVariant &value,
       {
         if (value == Qt::Checked)
         {
-          if (!plugin.load())
-            QMessageBox::warning(nullptr, tr("eCAL Monitor"), tr("Unable to activate plugin. For more information see log output."), QMessageBox::Ok, QMessageBox::Ok);
+          PluginManager::getInstance()->setActive(iid, true);
         }
         else
         {
-          if (!plugin.unload())
-            QMessageBox::information(nullptr, tr("eCAL Monitor"), tr("The plugin cannot be deactivated because it is still in use. Please close all associated visualistion windows and try again."), QMessageBox::Ok, QMessageBox::Ok);
+          PluginManager::getInstance()->setActive(iid, false);
         }
         return true;
       }
@@ -142,6 +139,6 @@ QModelIndex PluginTableModel::parent(const QModelIndex & /*index*/) const
 void PluginTableModel::rediscover()
 {
   beginResetModel();
-  PluginLoader::getInstance()->discover();
+  PluginManager::getInstance()->discover();
   endResetModel();
 }
diff --git a/app/mon/eCALMon/src/Widgets/Models/PluginTableModel.h b/app/mon/eCALMon/src/Widgets/Models/PluginTableModel.h
index 0ba1662f85..8d7c48e7c8 100644
--- a/app/mon/eCALMon/src/Widgets/Models/PluginTableModel.h
+++ b/app/mon/eCALMon/src/Widgets/Models/PluginTableModel.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include "PluginLoader.h"
+#include "Plugin/PluginManager.h"
 #include <QAbstractItemModel>
 
 class PluginTableModel : public QAbstractItemModel
diff --git a/app/mon/eCALMon/src/Widgets/Models/ProcessTreeItem.cpp b/app/mon/eCALMon/src/Widgets/Models/ProcessTreeItem.cpp
index f69bda4792..601a298800 100644
--- a/app/mon/eCALMon/src/Widgets/Models/ProcessTreeItem.cpp
+++ b/app/mon/eCALMon/src/Widgets/Models/ProcessTreeItem.cpp
@@ -105,9 +105,17 @@ QVariant ProcessTreeItem::data(Columns column, Qt::ItemDataRole role) const
     {
       return process_.state().info().c_str();
     }
-    else if (column == Columns::TSYNC_MODE)
+    else if (column == Columns::TSYNC_STATE)
     {
-      return (int)process_.tsync_mode();
+      return (int)process_.tsync_state();
+    }
+    else if (column == Columns::TSYNC_MOD_NAME)
+    {
+      return process_.tsync_mod_name().c_str();
+    }
+    else if (column == Columns::COMPONENT_INIT_INFO)
+    {
+      return process_.component_init_info().c_str();
     }
     else
     {
@@ -152,9 +160,9 @@ QVariant ProcessTreeItem::data(Columns column, Qt::ItemDataRole role) const
     {
       return severityToString(process_.state().severity(), process_.state().severity_level());
     }
-    else if (column == Columns::TSYNC_MODE)
+    else if (column == Columns::TSYNC_STATE)
     {
-      switch (process_.tsync_mode())
+      switch (process_.tsync_state())
       {
       case 0:
         return "None";
@@ -185,9 +193,9 @@ QVariant ProcessTreeItem::data(Columns column, Qt::ItemDataRole role) const
     {
       return data(column, (Qt::ItemDataRole)ItemDataRoles::RawDataRole); //-V1016
     }
-    else if (column == Columns::TSYNC_MODE)
+    else if (column == Columns::TSYNC_STATE)
     {
-      switch (process_.tsync_mode())
+      switch (process_.tsync_state())
       {
       case 0:
         return "None";
@@ -286,11 +294,11 @@ QVariant ProcessTreeItem::data(Columns column, Qt::ItemDataRole role) const
       }
     }
     
-    else if (column == Columns::TSYNC_MODE)
+    else if (column == Columns::TSYNC_STATE)
     {
       QFont font;
       font.setItalic(true);
-      switch (process_.tsync_mode())
+      switch (process_.tsync_state())
       {
       case 0:
       case 1:
diff --git a/app/mon/eCALMon/src/Widgets/Models/ProcessTreeItem.h b/app/mon/eCALMon/src/Widgets/Models/ProcessTreeItem.h
index f27a6a5667..9fd2a2a53f 100644
--- a/app/mon/eCALMon/src/Widgets/Models/ProcessTreeItem.h
+++ b/app/mon/eCALMon/src/Widgets/Models/ProcessTreeItem.h
@@ -50,7 +50,9 @@ class ProcessTreeItem :
     DATAREAD,
     SEVERITY,
     INFO,
-    TSYNC_MODE,
+    TSYNC_STATE,
+    TSYNC_MOD_NAME,
+    COMPONENT_INIT_INFO
   };
 
   ProcessTreeItem();
diff --git a/app/mon/eCALMon/src/Widgets/Models/ProcessTreeModel.h b/app/mon/eCALMon/src/Widgets/Models/ProcessTreeModel.h
index 159cdc4d5d..04213953fc 100644
--- a/app/mon/eCALMon/src/Widgets/Models/ProcessTreeModel.h
+++ b/app/mon/eCALMon/src/Widgets/Models/ProcessTreeModel.h
@@ -59,7 +59,9 @@ class ProcessTreeModel : public GroupTreeModel
     USER_TIME,
     DATAWRITE,
     DATAREAD,
-    TIMESYNC_MODE,
+    TIMESYNC_STATE,
+    TIMESYNC_MOD_NAME,
+    COMPONENT_INIT_INFO,
 
     COLUMN_COUNT
   };
@@ -82,41 +84,44 @@ class ProcessTreeModel : public GroupTreeModel
 private:
   std::map<Columns, QString> columnLabels =
   {
-    { Columns::GROUP,         "Group" },
-    { Columns::UNIT_NAME,     "Process" },
-    { Columns::HOST_NAME,     "Host" },
-    { Columns::PID,           "PID" },
-    { Columns::PROCESS_NAME,  "Process Path" },
-    { Columns::PARAMETERS,    "Command line" },
-    { Columns::STATE,         "State" },
-    { Columns::INFO,          "Info" },
-    { Columns::HEARTBEAT,     "Heartbeat" },
-    { Columns::MEMORY,        "RAM [KiB]" },
-    { Columns::CPU_PERCENTAGE,"CPU %" },
-    { Columns::USER_TIME,     "User Time" },
-    { Columns::DATAWRITE,     "Data Write [Byte/s]" },
-    { Columns::DATAREAD,      "Data Read [Byte/s]" },
-    { Columns::TIMESYNC_MODE, "Timesync Mode" },
+    { Columns::GROUP,               "Group" },
+    { Columns::UNIT_NAME,           "Process" },
+    { Columns::HOST_NAME,           "Host" },
+    { Columns::PID,                 "PID" },
+    { Columns::PROCESS_NAME,        "Process Path" },
+    { Columns::PARAMETERS,          "Command line" },
+    { Columns::STATE,               "State" },
+    { Columns::INFO,                "Info" },
+    { Columns::HEARTBEAT,           "Heartbeat" },
+    { Columns::MEMORY,              "RAM [KiB]" },
+    { Columns::CPU_PERCENTAGE,      "CPU %" },
+    { Columns::USER_TIME,           "User Time" },
+    { Columns::DATAWRITE,           "Data Write [Byte/s]" },
+    { Columns::DATAREAD,            "Data Read [Byte/s]" },
+    { Columns::TIMESYNC_STATE,      "Timesync State" },
+    { Columns::TIMESYNC_MOD_NAME,   "Timesync Mod Name" },
+    { Columns::COMPONENT_INIT_INFO, "Component Initialization" },
   };
 
   std::map<Columns, int> column_mapping =
   {
-    { Columns::GROUP,          -1 },
-    { Columns::UNIT_NAME,      (int)ProcessTreeItem::Columns::UNAME },
-    { Columns::HOST_NAME,      (int)ProcessTreeItem::Columns::HNAME },
-    { Columns::PID,            (int)ProcessTreeItem::Columns::PID },
-    { Columns::PROCESS_NAME,   (int)ProcessTreeItem::Columns::PNAME },
-    { Columns::PARAMETERS,     (int)ProcessTreeItem::Columns::PPARAM },
-    { Columns::STATE,          (int)ProcessTreeItem::Columns::SEVERITY },
-    { Columns::INFO,           (int)ProcessTreeItem::Columns::INFO },
-    { Columns::HEARTBEAT,      (int)ProcessTreeItem::Columns::RCLOCK },
-    { Columns::CPU_PERCENTAGE, (int)ProcessTreeItem::Columns::PCPU },
-    { Columns::MEMORY,         (int)ProcessTreeItem::Columns::PMEMORY },
-    { Columns::USER_TIME,      (int)ProcessTreeItem::Columns::USRPTIME },
-    { Columns::DATAWRITE,      (int)ProcessTreeItem::Columns::DATAWRITE },
-    { Columns::DATAREAD,       (int)ProcessTreeItem::Columns::DATAREAD },
-    { Columns::TIMESYNC_MODE,  (int)ProcessTreeItem::Columns::TSYNC_MODE },
-
+    { Columns::GROUP,               -1 },
+    { Columns::UNIT_NAME,           (int)ProcessTreeItem::Columns::UNAME },
+    { Columns::HOST_NAME,           (int)ProcessTreeItem::Columns::HNAME },
+    { Columns::PID,                 (int)ProcessTreeItem::Columns::PID },
+    { Columns::PROCESS_NAME,        (int)ProcessTreeItem::Columns::PNAME },
+    { Columns::PARAMETERS,          (int)ProcessTreeItem::Columns::PPARAM },
+    { Columns::STATE,               (int)ProcessTreeItem::Columns::SEVERITY },
+    { Columns::INFO,                (int)ProcessTreeItem::Columns::INFO },
+    { Columns::HEARTBEAT,           (int)ProcessTreeItem::Columns::RCLOCK },
+    { Columns::CPU_PERCENTAGE,      (int)ProcessTreeItem::Columns::PCPU },
+    { Columns::MEMORY,              (int)ProcessTreeItem::Columns::PMEMORY },
+    { Columns::USER_TIME,           (int)ProcessTreeItem::Columns::USRPTIME },
+    { Columns::DATAWRITE,           (int)ProcessTreeItem::Columns::DATAWRITE },
+    { Columns::DATAREAD,            (int)ProcessTreeItem::Columns::DATAREAD },
+    { Columns::TIMESYNC_STATE,      (int)ProcessTreeItem::Columns::TSYNC_STATE },
+    { Columns::TIMESYNC_MOD_NAME,   (int)ProcessTreeItem::Columns::TSYNC_MOD_NAME },
+    { Columns::COMPONENT_INIT_INFO, (int)ProcessTreeItem::Columns::COMPONENT_INIT_INFO },
   };
 
   std::map<std::string, ProcessTreeItem*> tree_item_map_;
diff --git a/app/mon/eCALMon/src/Widgets/Models/TopicTreeItem.cpp b/app/mon/eCALMon/src/Widgets/Models/TopicTreeItem.cpp
index 540dac4e08..e66a9489ee 100644
--- a/app/mon/eCALMon/src/Widgets/Models/TopicTreeItem.cpp
+++ b/app/mon/eCALMon/src/Widgets/Models/TopicTreeItem.cpp
@@ -218,21 +218,9 @@ QVariant TopicTreeItem::data(Columns column, Qt::ItemDataRole role) const
         case eCAL::pb::eTLayerType::tl_ecal_udp_mc:
           this_layer_string = "udp_mc";
           break;
-        case eCAL::pb::eTLayerType::tl_ecal_udp_uc:
-          this_layer_string = "udp_uc";
-          break;
-        case eCAL::pb::eTLayerType::tl_ecal_udp_metal:
-          this_layer_string = "udp_metal";
-          break;
         case eCAL::pb::eTLayerType::tl_ecal_shm:
           this_layer_string = "shm";
           break;
-        case eCAL::pb::eTLayerType::tl_lcm:
-          this_layer_string = "lcm";
-          break;
-        case eCAL::pb::eTLayerType::tl_rtps:
-          this_layer_string = "rtps";
-          break;
         case eCAL::pb::eTLayerType::tl_iceoryx:
           this_layer_string = "iceoryx";
           break;
diff --git a/app/mon/eCALMon/src/Widgets/VisualisationWidget/VisualisationWidget.cpp b/app/mon/eCALMon/src/Widgets/VisualisationWidget/VisualisationWidget.cpp
index d4dd897fbb..da133b324d 100644
--- a/app/mon/eCALMon/src/Widgets/VisualisationWidget/VisualisationWidget.cpp
+++ b/app/mon/eCALMon/src/Widgets/VisualisationWidget/VisualisationWidget.cpp
@@ -55,15 +55,15 @@ VisualisationWidget::VisualisationWidget(const QString& topic_name, const QStrin
   }
   ui_.topic_name_label->setText(header);
 
-  supported_plugins_ = PluginLoader::getInstance()->getSupportedPlugins(topic_name, topic_type); 
+  auto supported_plugins_ = PluginManager::getInstance()->CreatePlugins(topic_name, topic_type, this);
 
   // add suitable plugin widgets to the tab view
-  for (auto& plugin : supported_plugins_)
+  for (const auto& plugin : supported_plugins_)
   {
-    auto plugin_widget = plugin.create(topic_name, topic_type, this);
-
+    auto plugin_info = plugin.first;
+    auto plugin_widget = plugin.second;
     plugin_widgets_.push_back(plugin_widget);
-    ui_.tab_widget->addTab(plugin_widget->getWidget(), plugin.getMetaData().name);
+    ui_.tab_widget->addTab(plugin_widget->getWidget(), plugin_info.meta_data.name);
 
     connect(ui_.pause_button, &QPushButton::toggled, [plugin_widget](bool checked) { if (checked) plugin_widget->onPause(); else plugin_widget->onResume(); });
     connect(&update_timer_, &QTimer::timeout, [this]() {if (!isPaused()) plugin_widgets_.at(ui_.tab_widget->currentIndex())->onUpdate(); });
diff --git a/app/mon/eCALMon/src/Widgets/VisualisationWidget/VisualisationWidget.h b/app/mon/eCALMon/src/Widgets/VisualisationWidget/VisualisationWidget.h
index 9dc53d9e4a..af1b3109be 100644
--- a/app/mon/eCALMon/src/Widgets/VisualisationWidget/VisualisationWidget.h
+++ b/app/mon/eCALMon/src/Widgets/VisualisationWidget/VisualisationWidget.h
@@ -22,7 +22,7 @@
 #include <QWidget>
 #include "ui_VisualisationWidget.h"
 
-#include "PluginLoader.h"
+#include "Plugin/PluginManager.h"
 
 #include <memory>
 #include <mutex>
@@ -67,7 +67,5 @@ public slots:
   
   QTabWidget tab_widget_;
 
-  QList<PluginWrapper> supported_plugins_;
-
   QVector<eCAL::mon::PluginWidgetInterface*> plugin_widgets_;
 };
diff --git a/app/play/eCALPlay/CMakeLists.txt b/app/play/eCALPlay/CMakeLists.txt
index 84ac4ad252..8e6f10bf24 100644
--- a/app/play/eCALPlay/CMakeLists.txt
+++ b/app/play/eCALPlay/CMakeLists.txt
@@ -68,8 +68,4 @@ endif()
 
 ecal_install_app(${PROJECT_NAME})
 
-if(MSVC)
-    set_property(TARGET ${PROJECT_NAME} PROPERTY LINK_FLAGS "/ignore:4098,4099")
-endif(MSVC)
-
 set_property(TARGET ${PROJECT_NAME} PROPERTY FOLDER app/play)
diff --git a/app/play/eCALPlayCore/include/EcalPlayState.h b/app/play/eCALPlayCore/include/EcalPlayState.h
index 0730335f3d..18d6233d84 100644
--- a/app/play/eCALPlayCore/include/EcalPlayState.h
+++ b/app/play/eCALPlayCore/include/EcalPlayState.h
@@ -39,7 +39,7 @@ struct EcalPlayState
   bool                                  playing_;                               /**< Whether the player is currently playing a measurement */
   double                                actual_play_rate_;                      /**< The current actual play rate. This may differ from the selected play rate. The play rate is relative, i.e. a play rate of 1.0 represents realtime. */
   
-  long long                             curren_frame_index;                     /**< The index of the last frame that was published. In cases where the player has just been started or the measurement position has been changed manually, this frame may not have been published, yet. In these cases, it represents the next frame. */
+  long long                             current_frame_index;                    /**< The index of the last frame that was published. In cases where the player has just been started or the measurement position has been changed manually, this frame may not have been published, yet. In these cases, it represents the next frame. */
   eCAL::Time::ecal_clock::time_point    current_frame_timestamp;                /**< The timestamp of the last frame that was published. In cases where the player has just been started or the measurement position has been changed manually, this frame may not have been published, yet. In these cases, it represents the next frame. */
 
   eCAL::Time::ecal_clock::time_point    last_simtime_;                          /**< The last sim time. This value will not be updated continuously. In order to compute the current sim time, interpolate this time using the @see{last_simtime_local_timestamp_} and the @see{simtime_rate_}. */
@@ -50,7 +50,7 @@ struct EcalPlayState
   {
     return (playing_                    == other.playing_)
       && (fabs(actual_play_rate_        -  other.actual_play_rate_) < DBL_EPSILON)
-      && (curren_frame_index            == other.curren_frame_index)
+      && (current_frame_index           == other.current_frame_index)
       && (current_frame_timestamp       == other.current_frame_timestamp)
       && (last_simtime_                 == other.last_simtime_)
       && (last_simtime_local_timestamp_ == other.last_simtime_local_timestamp_)
diff --git a/app/play/eCALPlayCore/src/PlayThread.cpp b/app/play/eCALPlayCore/src/PlayThread.cpp
index 8c29691e4e..3da44b4d03 100644
--- a/app/play/eCALPlayCore/src/PlayThread.cpp
+++ b/app/play/eCALPlayCore/src/PlayThread.cpp
@@ -102,7 +102,18 @@ void PlayThread::Run()
               // condition variable predicate function.
               // When pausing while waiting for the next frame, the outer
               // do-while loop causes the 
+#ifdef WIN32
               pause_cv_.wait_until(command_lock, wait_until_timepoint);
+#else // WIN32
+              if (wait_until_timepoint == std::chrono::steady_clock::time_point::max())
+              {
+                pause_cv_.wait(command_lock);
+              }
+              else
+              {
+                pause_cv_.wait_until(command_lock, wait_until_timepoint);
+              }
+#endif // WIN32
               wait_until_timepoint = GetSystemTime_Private(command_.next_frame_timestamp_);
             } 
 
@@ -1102,7 +1113,7 @@ EcalPlayState PlayThread::GetCurrentPlayState()
   std::lock_guard<std::mutex> command_lock_(command_mutex_);
   state.playing_                      = command_.playing_;
   state.actual_play_rate_             = GetCurrentPlaySpeed_Private();
-  state.curren_frame_index            = command_.current_frame_index_;
+  state.current_frame_index           = command_.current_frame_index_;
   state.current_frame_timestamp       = command_.current_frame_timestamp_;
   if (!command_.limit_play_speed_)
   {
diff --git a/app/play/eCALPlayCore/src/PlayThread.h b/app/play/eCALPlayCore/src/PlayThread.h
index 8a887d32cd..66a1e5d7b2 100644
--- a/app/play/eCALPlayCore/src/PlayThread.h
+++ b/app/play/eCALPlayCore/src/PlayThread.h
@@ -678,11 +678,15 @@ class PlayThread : public InterruptibleThread
   /**
    * @brief Calculates the system time that maps to the given simulation time considering the current play speed
    *
+   * If the current play speed is 0.0, the given simulation time will never be
+   * reached. In that case, std::chrono::steady_clock::time_point::max() is
+   * returned.
+   * 
    * This function does not lock any mutex. It reads the command_, so the
    * command_mutex_ has to be locked when calling this function.
    *
    * @param sim_time    The simulation time to calculate the system time for
-   * @return
+   * @return            The calculated system time or std::chrono::steady_clock::time_point::max()
    */
   std::chrono::steady_clock::time_point GetSystemTime_Private(eCAL::Time::ecal_clock::time_point sim_time) const;
 
diff --git a/app/play/eCALPlayCore/src/StatePublisherThread.cpp b/app/play/eCALPlayCore/src/StatePublisherThread.cpp
index 7cc2fa7d39..fff751a2a0 100644
--- a/app/play/eCALPlayCore/src/StatePublisherThread.cpp
+++ b/app/play/eCALPlayCore/src/StatePublisherThread.cpp
@@ -71,7 +71,7 @@ void StatePublisherThread::PublishState()
   state_pb.set_playing(state.playing_);
   state_pb.set_measurement_loaded(play_thread_.IsMeasurementLoaded());
   state_pb.set_actual_speed(state.actual_play_rate_);
-  state_pb.set_current_measurement_index(state.curren_frame_index);
+  state_pb.set_current_measurement_index(state.current_frame_index);
   state_pb.set_current_measurement_timestamp_nsecs(std::chrono::duration_cast<std::chrono::nanoseconds>(state.current_frame_timestamp.time_since_epoch()).count());
 
   if (state_pb.measurement_loaded())
diff --git a/app/play/eCALPlayGUI/CMakeLists.txt b/app/play/eCALPlayGUI/CMakeLists.txt
index 3daa8a7791..623731c08c 100644
--- a/app/play/eCALPlayGUI/CMakeLists.txt
+++ b/app/play/eCALPlayGUI/CMakeLists.txt
@@ -46,6 +46,8 @@ set(source_files
     src/EcalPlayGui.h
     src/EcalPlayService.cpp
     src/EcalPlayService.h
+    src/HelpWindow.cpp
+    src/HelpWindow.h
     src/main.cpp
     src/QEcalPlay.cpp
     src/QEcalPlay.h
@@ -91,6 +93,7 @@ if(WIN32)
 ENDIF(WIN32)
 
 set(ui_files
+    src/HelpWindow.ui
     src/MainWindow.ui
     src/Widgets/AboutDialog/AboutDialog.ui
     src/Widgets/ChannelWidget/ChannelWidget.ui
@@ -121,6 +124,7 @@ create_targets_protobuf()
 target_link_libraries (${PROJECT_NAME}
     simpleini::simpleini
     tclap::tclap
+    CustomTclap
     eCAL::play_core
     Qt5::Widgets
     CustomQt
diff --git a/app/play/eCALPlayGUI/src/EcalPlayGui.cpp b/app/play/eCALPlayGUI/src/EcalPlayGui.cpp
index aa85da2434..af8cdc37c5 100644
--- a/app/play/eCALPlayGUI/src/EcalPlayGui.cpp
+++ b/app/play/eCALPlayGUI/src/EcalPlayGui.cpp
@@ -184,7 +184,8 @@ EcalplayGui::EcalplayGui(QWidget *parent)
   //// Windows Taskbar                                                      ////
   //////////////////////////////////////////////////////////////////////////////
   taskbar_button_ = new QWinTaskbarButton(this);
-  connect(QEcalPlay::instance(), &QEcalPlay::playStateChangedSignal, this, &EcalplayGui::updateTaskbarProgress);
+  connect(QEcalPlay::instance(), &QEcalPlay::playStateChangedSignal,           this, &EcalplayGui::updateTaskbarProgress);
+  connect(QEcalPlay::instance(), &QEcalPlay::publishersInitStateChangedSignal, this, [this]() { EcalplayGui::updateTaskbarProgress(QEcalPlay::instance()->currentPlayState()); });
 
   thumbnail_toolbar_             = new QWinThumbnailToolBar(this);
   thumbnail_play_pause_button_   = new QWinThumbnailToolButton(thumbnail_toolbar_);
@@ -245,6 +246,10 @@ EcalplayGui::EcalplayGui(QWidget *parent)
     measurementClosed();
   }
 
+  frameDroppingAllowedChanged       (QEcalPlay::instance()->isFrameDroppingAllowed());
+  enforceDelayAccuracyEnabledChanged(QEcalPlay::instance()->isEnforceDelayAccuracyEnabled());
+  limitPlaySpeedEnabledChanged      (QEcalPlay::instance()->isLimitPlaySpeedEnabled());
+
   saveInitialLayout();
   restoreLayout();
 
@@ -348,7 +353,7 @@ void EcalplayGui::playStateChanged(const EcalPlayState& current_state)
     setPlayPauseActionToPlay();
   }
 
-  current_frame_label_->setText(tr(" Frame: ") + QString::number(current_state.curren_frame_index + 1) + " / " + QString::number(measurement_frame_count_) + " ");
+  current_frame_label_->setText(tr(" Frame: ") + QString::number(current_state.current_frame_index + 1) + " / " + QString::number(measurement_frame_count_) + " ");
   current_speed_label_->setText(tr(" Current Speed: ") + QString::number(current_state.actual_play_rate_, 'f', 2) + " ");
 }
 
@@ -689,7 +694,7 @@ void EcalplayGui::updateTaskbarProgress(const EcalPlayState& current_state)
   progress->setPaused(!current_state.playing_);
   progress->setValue(std::chrono::duration_cast<std::chrono::milliseconds>(current_state.current_frame_timestamp - measurement_boundaries_.first).count());
 
-  if (measurement_loaded_)
+  if (measurement_loaded_ && QEcalPlay::instance()->isInitialized())
   {
     if (current_state.playing_)
     {
diff --git a/app/play/eCALPlayGUI/src/HelpWindow.cpp b/app/play/eCALPlayGUI/src/HelpWindow.cpp
new file mode 100644
index 0000000000..5b733d521b
--- /dev/null
+++ b/app/play/eCALPlayGUI/src/HelpWindow.cpp
@@ -0,0 +1,33 @@
+/* ========================= eCAL LICENSE =================================
+ *
+ * Copyright (C) 2016 - 2019 Continental Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * ========================= eCAL LICENSE =================================
+*/
+
+#include "HelpWindow.h"
+
+HelpWindow::HelpWindow(const std::string& help_text, QWidget *parent)
+  : QMainWindow(parent)
+
+{
+  ui_.setupUi(this);
+  ui_.help_textedit->setPlainText(QString::fromStdString(help_text));
+
+  connect(ui_.close_button, &QPushButton::clicked, this, &QMainWindow::close);
+}
+
+HelpWindow::~HelpWindow()
+{}
diff --git a/ecal/core/src/readwrite/ecal_writer_lcm.h b/app/play/eCALPlayGUI/src/HelpWindow.h
similarity index 53%
rename from ecal/core/src/readwrite/ecal_writer_lcm.h
rename to app/play/eCALPlayGUI/src/HelpWindow.h
index 13951f0064..25c71934d0 100644
--- a/ecal/core/src/readwrite/ecal_writer_lcm.h
+++ b/app/play/eCALPlayGUI/src/HelpWindow.h
@@ -17,37 +17,21 @@
  * ========================= eCAL LICENSE =================================
 */
 
-/**
- * @brief  lcm data writer
-**/
-
 #pragma once
 
-#include <string>
-#include <memory>
+#include <QtWidgets/QMainWindow>
 
-#include "io/udp_sender.h"
-#include "lcm/lcmlite.h"
-#include "readwrite/ecal_writer_base.h"
+#include "ui_HelpWindow.h"
 
-namespace eCAL
+class HelpWindow : public QMainWindow
 {
-  class CDataWriterLCM : public CDataWriterBase
-  {
-  public:
-    CDataWriterLCM();
-    ~CDataWriterLCM();
-
-    void GetInfo(SWriterInfo info_) override;
+  Q_OBJECT
 
-    bool Create(const std::string& host_name_, const std::string& topic_name_, const std::string & topic_id_) override;
-    bool Destroy() override;
+public:
+  HelpWindow (const std::string& help_text, QWidget *parent = Q_NULLPTR);
 
-    size_t Send(const SWriterData& data_) override;
+  ~HelpWindow();
 
-  protected:
-    CUDPSender                      m_udp_sender;
-    std::shared_ptr<lcmlite_pub_t>  m_lcm;
-    bool                            m_initialized;
-  };
-}
+private:
+  Ui::HelpMainWindow  ui_;
+};
diff --git a/app/play/eCALPlayGUI/src/HelpWindow.ui b/app/play/eCALPlayGUI/src/HelpWindow.ui
new file mode 100644
index 0000000000..30e64e77f3
--- /dev/null
+++ b/app/play/eCALPlayGUI/src/HelpWindow.ui
@@ -0,0 +1,60 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>HelpMainWindow</class>
+ <widget class="QMainWindow" name="HelpMainWindow">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>640</width>
+    <height>480</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string/>
+  </property>
+  <property name="windowIcon">
+   <iconset resource="../resources/resources.qrc">
+    <normaloff>:/ecalplay/APP_ICON</normaloff>:/ecalplay/APP_ICON</iconset>
+  </property>
+  <property name="autoFillBackground">
+   <bool>false</bool>
+  </property>
+  <property name="dockOptions">
+   <set>QMainWindow::AllowNestedDocks|QMainWindow::AllowTabbedDocks|QMainWindow::AnimatedDocks</set>
+  </property>
+  <widget class="QWidget" name="central_widget">
+   <layout class="QVBoxLayout" name="verticalLayout">
+    <item>
+     <widget class="QPlainTextEdit" name="help_textedit">
+      <property name="font">
+       <font>
+        <family>Courier New</family>
+       </font>
+      </property>
+      <property name="lineWrapMode">
+       <enum>QPlainTextEdit::NoWrap</enum>
+      </property>
+      <property name="readOnly">
+       <bool>true</bool>
+      </property>
+     </widget>
+    </item>
+    <item>
+     <widget class="QPushButton" name="close_button">
+      <property name="text">
+       <string>Close</string>
+      </property>
+     </widget>
+    </item>
+   </layout>
+  </widget>
+  <widget class="QStatusBar" name="status_bar"/>
+ </widget>
+ <layoutdefault spacing="6" margin="11"/>
+ <resources>
+  <include location="../resources/resources.qrc"/>
+  <include location="../../../iconset/ecalicons.qrc"/>
+ </resources>
+ <connections/>
+</ui>
diff --git a/app/play/eCALPlayGUI/src/Widgets/PlayerControlsWidget/PlayerControlsWidget.ui b/app/play/eCALPlayGUI/src/Widgets/PlayerControlsWidget/PlayerControlsWidget.ui
index b589a1a4ae..f3758f7eb8 100644
--- a/app/play/eCALPlayGUI/src/Widgets/PlayerControlsWidget/PlayerControlsWidget.ui
+++ b/app/play/eCALPlayGUI/src/Widgets/PlayerControlsWidget/PlayerControlsWidget.ui
@@ -82,13 +82,13 @@
            <property name="minimumSize">
             <size>
              <width>16</width>
-             <height>42</height>
+             <height>35</height>
             </size>
            </property>
            <property name="maximumSize">
             <size>
-             <width>42</width>
-             <height>42</height>
+             <width>35</width>
+             <height>35</height>
             </size>
            </property>
            <property name="toolTip">
@@ -103,8 +103,8 @@
            </property>
            <property name="iconSize">
             <size>
-             <width>30</width>
-             <height>30</height>
+             <width>25</width>
+             <height>25</height>
             </size>
            </property>
           </widget>
@@ -123,13 +123,13 @@
            <property name="minimumSize">
             <size>
              <width>16</width>
-             <height>35</height>
+             <height>30</height>
             </size>
            </property>
            <property name="maximumSize">
             <size>
-             <width>35</width>
-             <height>35</height>
+             <width>30</width>
+             <height>30</height>
             </size>
            </property>
            <property name="toolTip">
@@ -164,13 +164,13 @@
            <property name="minimumSize">
             <size>
              <width>16</width>
-             <height>35</height>
+             <height>30</height>
             </size>
            </property>
            <property name="maximumSize">
             <size>
-             <width>35</width>
-             <height>35</height>
+             <width>30</width>
+             <height>30</height>
             </size>
            </property>
            <property name="toolTip">
@@ -185,8 +185,8 @@
            </property>
            <property name="iconSize">
             <size>
-             <width>25</width>
-             <height>25</height>
+             <width>20</width>
+             <height>20</height>
             </size>
            </property>
           </widget>
@@ -199,13 +199,13 @@
            <property name="minimumSize">
             <size>
              <width>40</width>
-             <height>35</height>
+             <height>30</height>
             </size>
            </property>
            <property name="maximumSize">
             <size>
              <width>16777215</width>
-             <height>35</height>
+             <height>30</height>
             </size>
            </property>
            <property name="toolTip">
@@ -220,8 +220,8 @@
            </property>
            <property name="iconSize">
             <size>
-             <width>25</width>
-             <height>25</height>
+             <width>20</width>
+             <height>20</height>
             </size>
            </property>
            <property name="popupMode">
@@ -259,13 +259,13 @@
            <property name="minimumSize">
             <size>
              <width>16</width>
-             <height>35</height>
+             <height>30</height>
             </size>
            </property>
            <property name="maximumSize">
             <size>
-             <width>35</width>
-             <height>35</height>
+             <width>30</width>
+             <height>30</height>
             </size>
            </property>
            <property name="toolTip">
@@ -280,8 +280,8 @@
            </property>
            <property name="iconSize">
             <size>
-             <width>25</width>
-             <height>25</height>
+             <width>20</width>
+             <height>20</height>
             </size>
            </property>
            <property name="checkable">
@@ -332,13 +332,13 @@
            <property name="minimumSize">
             <size>
              <width>16</width>
-             <height>35</height>
+             <height>30</height>
             </size>
            </property>
            <property name="maximumSize">
             <size>
-             <width>35</width>
-             <height>35</height>
+             <width>30</width>
+             <height>30</height>
             </size>
            </property>
            <property name="toolTip">
@@ -350,8 +350,8 @@
            </property>
            <property name="iconSize">
             <size>
-             <width>25</width>
-             <height>25</height>
+             <width>20</width>
+             <height>20</height>
             </size>
            </property>
           </widget>
diff --git a/app/play/eCALPlayGUI/src/Widgets/SettingsWidget/SettingsWidget.cpp b/app/play/eCALPlayGUI/src/Widgets/SettingsWidget/SettingsWidget.cpp
index c97bb43ab9..3825262007 100644
--- a/app/play/eCALPlayGUI/src/Widgets/SettingsWidget/SettingsWidget.cpp
+++ b/app/play/eCALPlayGUI/src/Widgets/SettingsWidget/SettingsWidget.cpp
@@ -26,6 +26,8 @@
 
 #include <chrono>
 #include <cfloat>
+#include <math.h>
+#include <cmath>
 
 SettingsWidget::SettingsWidget(QWidget *parent)
   : QWidget(parent)
@@ -128,14 +130,14 @@ void SettingsWidget::measurementClosed()
 
 void SettingsWidget::playSpeedChanged(double play_speed)
 {
-  if (fabs(ui_.play_speed_spinbox->value() - play_speed) > DBL_EPSILON)
+  if (std::fabs(ui_.play_speed_spinbox->value() - play_speed) > DBL_EPSILON)
   {
     ui_.play_speed_spinbox->blockSignals(true);
     ui_.play_speed_spinbox->setValue(play_speed);
     ui_.play_speed_spinbox->blockSignals(false);
   }
 
-  ui_.play_speed_warning_label->setVisible(fabs(play_speed) < DBL_EPSILON);
+  ui_.play_speed_warning_label->setVisible(std::fabs(play_speed) < DBL_EPSILON);
 }
 
 void SettingsWidget::limitPlaySpeedEnabledChanged(bool enabled)
@@ -279,4 +281,4 @@ void SettingsWidget::resetLayout()
   QEcalPlay::instance()->setFrameDroppingAllowed       (false);
   QEcalPlay::instance()->setEnforceDelayAccuracyEnabled(false);
   QEcalPlay::instance()->setRepeatEnabled              (false);
-}
\ No newline at end of file
+}
diff --git a/app/play/eCALPlayGUI/src/main.cpp b/app/play/eCALPlayGUI/src/main.cpp
index 2e1f0ee97d..3a36f25fba 100644
--- a/app/play/eCALPlayGUI/src/main.cpp
+++ b/app/play/eCALPlayGUI/src/main.cpp
@@ -23,30 +23,235 @@
 
 #include "QEcalPlay.h"
 
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable: 4505)
+#endif
+#include <tclap/CmdLine.h>
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+#include <custom_tclap/advanced_tclap_output.h>
+#include <custom_tclap/fuzzy_value_switch_arg.h>
+
+#include "HelpWindow.h"
+#include <EcalPlayLogger.h>
+
+
 int main(int argc, char *argv[])
 {
+  //////////////////////////////////////////////////////////////////////////////
+  // Parse the command line
+  //////////////////////////////////////////////////////////////////////////////
 
-  // Just make sure that eCAL is initialized
-  eCAL::Initialize(0, nullptr, "eCALPlayGUI", eCAL::Init::Default | eCAL::Init::ProcessReg | eCAL::Init::Publisher | eCAL::Init::Service | eCAL::Init::Monitoring);
+  TCLAP::CmdLine cmd("eCAL Player", ' ', EcalPlayGlobals::VERSION_STRING, false);
+
+  TCLAP::UnlabeledMultiArg<std::string> unlabled_meas_path_arg("measurement_",                "Loads the measurement from the path.",                                                                       false, "Path");
+  TCLAP::SwitchArg                 help_arg                       ("h", "help",                   "Displays help.",                                                                                             false);
+  TCLAP::SwitchArg                 version_arg                    ("v", "version",                "Displays version information.",                                                                              false);
+  TCLAP::ValueArg<std::string>     measurement_path_arg           ("m", "measurement",            "Loads the measurement from the path.",                                                                       false, "", "Path");
+  TCLAP::SwitchArg                 play_arg                       ("p", "play",                   "Automatically starts the playback. Requires a measurement being loaded.",                                    false);
+  TCLAP::ValueArg<std::string>     channel_rename_file_path_arg   ("c", "channel-mapping",        "Loads the channel mapping from the given file and uses it to filter and intialize eCAL publishers. Otherwise, all publishers from the measurement will keep their default name.", false, "", "Path");
+  CustomTclap::FuzzyValueSwitchArg no_play_speed_limit_arg        ("u", "unlimited-speed",        "Publish frames as fast as possible",                                                                         false, false, "true|false");
+  TCLAP::ValueArg<double>          play_speed_arg                 ("s", "speed",                  "Relative rate at which the player shall publish the messages. Ignored, when using \"unlimited_play_speed\"", false, 1.0, "Factor");
+  CustomTclap::FuzzyValueSwitchArg allow_framedropping_arg        ("f", "framedropping",          "Drop frames when the messages cannot be sent at the required speed",                                         false, false, "true|false");
+  CustomTclap::FuzzyValueSwitchArg enforce_delay_accuracy_arg     ("d", "enforce-delay-accuracy", "Always wait the correct amount of time between two messages, even if this will slow down the playback",      false, false, "true|false");
+  CustomTclap::FuzzyValueSwitchArg repeat_arg                     ("r", "repeat",                 "Repeat playback from the beginning if the end has been reached",                                             false, false, "true|false");
+  TCLAP::ValueArg<double>          limit_interval_start_arg       ("l", "limit-interval-start",   "Start the playback from this time (relative value in seconds, 0.0 indicates the begin of the measurement)",  false, -1.0, "Seconds");
+  TCLAP::ValueArg<double>          limit_interval_end_arg         ("e", "limit-interval-end",     "End the playback at this time (relative value in seconds)",                                                  false, -1.0, "Seconds");
+
+  std::vector<TCLAP::Arg*> arg_vector =
+  {
+    &help_arg,
+    &version_arg,
+    &play_arg,
+    &measurement_path_arg,
+    &channel_rename_file_path_arg,
+    &no_play_speed_limit_arg,
+    &play_speed_arg,
+    &allow_framedropping_arg,
+    &enforce_delay_accuracy_arg,
+    &repeat_arg,
+    &limit_interval_start_arg,
+    &limit_interval_end_arg,
+    &unlabled_meas_path_arg,
+  };
+
+  for (auto arg_iterator = arg_vector.rbegin(); arg_iterator != arg_vector.rend(); arg_iterator++)
+  {
+    cmd.add(*arg_iterator);
+  }
+
+  std::stringstream tclap_output_stream;
+  CustomTclap::AdvancedTclapOutput advanced_tclap_output(std::vector<std::ostream*>{ &tclap_output_stream, &std::cout }, 75);
+  advanced_tclap_output.setArgumentHidden(&unlabled_meas_path_arg, true);
+
+  cmd.setOutput(&advanced_tclap_output);
+
+  try
+  {
+    cmd.parse(argc, argv);
+  }
+  catch (TCLAP::ArgException& e)
+  {
+    std::cerr << "Error parsing command line: " << e.what() << std::endl;
+  }
 
   QApplication a(argc, argv);
 
-  a.setOrganizationName      ("Continental");
-  a.setOrganizationDomain    ("continental-corporation.com");
-  a.setApplicationName       ("ecalplaygui");
+  a.setOrganizationName("Continental");
+  a.setOrganizationDomain("continental-corporation.com");
+  a.setApplicationName("ecalplaygui");
   a.setApplicationDisplayName("eCAL Player");
 
-  if (argc > 1)
+  //////////////////////////////////////
+  // --help
+  // --version
+  //////////////////////////////////////
+  if (help_arg.isSet() || version_arg.isSet())
   {
-    QEcalPlay::instance()->loadMeasurement(argv[1]);
+    tclap_output_stream.clear();
+
+    if (help_arg.isSet())
+    {
+      advanced_tclap_output.usage(cmd);
+    }
+    else if (version_arg.isSet())
+    {
+      advanced_tclap_output.version(cmd);
+    }
+
+#ifdef WIN32
+    // On Windows we display the command line help as GUI window. That approach
+    // is somehow standard on Windows, as Windows will not print the
+    // stdout/stderr streams to the console the app was started from.
+
+    HelpWindow w(tclap_output_stream.str());
+
+    w.show();
+    return a.exec();
+#else // WIN32
+    return 0;
+#endif // WIN32
   }
 
+
+  //////////////////////////////////////////////////////////////////////////////
+  // Start eCAL Play
+  //////////////////////////////////////////////////////////////////////////////
+
+  // Just make sure that eCAL is initialized
+  eCAL::Initialize(0, nullptr, "eCALPlayGUI", eCAL::Init::Default | eCAL::Init::ProcessReg | eCAL::Init::Publisher | eCAL::Init::Service | eCAL::Init::Monitoring);
+
   EcalplayGui* w = new EcalplayGui();
   w->setAttribute(Qt::WidgetAttribute::WA_DeleteOnClose);
 
   QEcalPlay::instance()->setParent(w);
-
   w->show();
+
+  //////////////////////////////////////
+  // --measurement
+  //////////////////////////////////////
+  std::string meas_path = "";
+
+  if (measurement_path_arg.isSet())
+  {
+    meas_path = measurement_path_arg.getValue();
+  }
+  else if (unlabled_meas_path_arg.isSet())
+  {
+    meas_path = unlabled_meas_path_arg.getValue()[0];
+  }
+
+  if (!meas_path.empty())
+  {
+    QEcalPlay::instance()->loadMeasurement(QString::fromStdString(meas_path));
+  }
+
+  //////////////////////////////////////
+  // --channel-mapping
+  //////////////////////////////////////
+  if (channel_rename_file_path_arg.isSet())
+  {
+    QEcalPlay::instance()->loadChannelMappingFile(QString::fromStdString(channel_rename_file_path_arg.getValue()));
+  }
+
+  //////////////////////////////////////
+  // --unlimited-speed
+  // --speed
+  //////////////////////////////////////
+  if (no_play_speed_limit_arg.isSet())
+  {
+    QEcalPlay::instance()->setLimitPlaySpeedEnabled(!no_play_speed_limit_arg.getValue());
+  }
+
+  if (play_speed_arg.isSet())
+  {
+    QEcalPlay::instance()->setPlaySpeed(play_speed_arg.getValue());
+  }
+
+  //////////////////////////////////////
+  // --framedropping
+  // --enforce-delay-accuracy
+  // --repeat
+  // --limit-interval-start
+  // --limit-interval-end
+  //////////////////////////////////////
+  if (allow_framedropping_arg.isSet())
+  {
+    QEcalPlay::instance()->setFrameDroppingAllowed(allow_framedropping_arg.getValue());
+  }
+
+  if (enforce_delay_accuracy_arg.isSet())
+  {
+    QEcalPlay::instance()->setEnforceDelayAccuracyEnabled(enforce_delay_accuracy_arg.getValue());
+  }
+
+  if (repeat_arg.isSet())
+  {
+    QEcalPlay::instance()->setRepeatEnabled(repeat_arg.getValue());
+  }
+
+  if (limit_interval_start_arg.isSet() || limit_interval_end_arg.isSet())
+  {
+    if (QEcalPlay::instance()->isMeasurementLoaded())
+    {
+      auto limit_interval = QEcalPlay::instance()->measurementBoundaries();
+      auto measurement_start = limit_interval.first;
+
+      if (limit_interval_start_arg.isSet())
+      {
+        limit_interval.first = measurement_start + std::chrono::duration_cast<eCAL::Time::ecal_clock::duration>(std::chrono::duration<double>(limit_interval_start_arg.getValue()));
+      }
+
+      if (limit_interval_end_arg.isSet())
+      {
+        limit_interval.second = measurement_start + std::chrono::duration_cast<eCAL::Time::ecal_clock::duration>(std::chrono::duration<double>(limit_interval_end_arg.getValue()));
+      }
+
+      QEcalPlay::instance()->setLimitInterval(limit_interval);
+    }
+    else
+    {
+      EcalPlayLogger::Instance()->error("Unable to set limit interval: No measurement is loaded.");
+    }
+  }
+
+  //////////////////////////////////////
+  // --play
+  //////////////////////////////////////
+  if (play_arg.isSet())
+  {
+    if (QEcalPlay::instance()->isMeasurementLoaded())
+    {
+      QEcalPlay::instance()->play();
+    }
+    else
+    {
+      EcalPlayLogger::Instance()->error("Unable to start playback: No measurement is loaded.");
+    }
+  }
+
   int return_code = a.exec();
 
   eCAL::Finalize();
diff --git a/build_win/win_run_tests.bat b/build_win/win_run_tests.bat
new file mode 100644
index 0000000000..343e5b2738
--- /dev/null
+++ b/build_win/win_run_tests.bat
@@ -0,0 +1,11 @@
+@echo off
+
+pushd %~dp0\..
+
+call build_win\win_set_vars.bat
+
+cd %BUILD_DIR%
+ctest -C Release --verbose
+cd ..
+
+popd
diff --git a/cmake/eCALConfig.cmake.in b/cmake/eCALConfig.cmake.in
index cb7a47b535..bc106ba178 100644
--- a/cmake/eCALConfig.cmake.in
+++ b/cmake/eCALConfig.cmake.in
@@ -19,7 +19,6 @@
 @PACKAGE_INIT@
 
 # Set some build relevant variables to build samples appropriately
-set(ECAL_LAYER_FASTRTPS      "@ECAL_LAYER_FASTRTPS@")
 set(eCAL_install_samples_dir "@eCAL_install_samples_dir@")
 
 set(eCAL_VERSION_MAJOR  @eCAL_VERSION_MAJOR@)
diff --git a/cmake/helper_functions/ecal_add_functions.cmake b/cmake/helper_functions/ecal_add_functions.cmake
index af018267cb..8263172669 100644
--- a/cmake/helper_functions/ecal_add_functions.cmake
+++ b/cmake/helper_functions/ecal_add_functions.cmake
@@ -35,8 +35,7 @@ function(ecal_add_gtest TARGET_NAME)
     COMMAND           $<TARGET_FILE:${TARGET_NAME}>
     WORKING_DIRECTORY $<TARGET_FILE_DIR:${TARGET_NAME}>
   )
-  target_include_directories(${TARGET_NAME} PRIVATE ${GTEST_INCLUDE_DIRS})
-  target_link_libraries(${TARGET_NAME} PRIVATE ${GTEST_BOTH_LIBRARIES})
+  target_link_libraries(${TARGET_NAME} PRIVATE GTest::GTest GTest::Main)
   #ecal_set_subsystem_windows(${TARGET_NAME})
   set_target_properties(${TARGET_NAME} PROPERTIES
     VERSION ${eCAL_VERSION_STRING}
@@ -66,10 +65,6 @@ function(ecal_add_app_qt TARGET_NAME)
   endif()
 endfunction()
 
-function(ecal_add_conv_plugin TARGET_NAME)
-  add_library(${TARGET_NAME} MODULE ${ARGN})
-endfunction()
-
 function(ecal_add_mon_plugin TARGET_NAME)
   add_library(${TARGET_NAME} MODULE ${ARGN})
 endfunction()
diff --git a/cmake/helper_functions/ecal_install_functions.cmake b/cmake/helper_functions/ecal_install_functions.cmake
index 0893e0a4c5..beba1a6f1b 100644
--- a/cmake/helper_functions/ecal_install_functions.cmake
+++ b/cmake/helper_functions/ecal_install_functions.cmake
@@ -131,15 +131,6 @@ install(TARGETS ${TARGET_NAME}
   )
 endfunction()
 
-# Use this function to install converter plugins
-# We need to provide a similar function for installing custom build plugins.
-function(ecal_install_conv_plugin TARGET_NAME)
-install(TARGETS ${TARGET_NAME}
-    RUNTIME DESTINATION  "${eCAL_install_bin_dir}/${ECAL_CONV_PLUGIN_DIR}" COMPONENT app
-    LIBRARY DESTINATION  "${eCAL_install_lib_dir}/${ECAL_CONV_PLUGIN_DIR}" COMPONENT app
-  )
-endfunction()
-
 # Use this function to install monitor plugins
 # We need to provide a similar function for installing custom build plugins.
 function(ecal_install_mon_plugin TARGET_NAME)
diff --git a/contrib/ecaltime/include/ecaltime.h b/contrib/ecaltime/include/ecaltime.h
index 53cc54d168..822b6f94eb 100644
--- a/contrib/ecaltime/include/ecaltime.h
+++ b/contrib/ecaltime/include/ecaltime.h
@@ -101,9 +101,9 @@ extern "C"
    * set of error codes. Everything non-zero is considered to indicate a
    * problem. Adapters may provide aditional information with a status message.
    *
-   * @param error [out] the current error code. 0 indicates that everything is OK
+   * @param error_ [out] the current error code. 0 indicates that everything is OK
    * @param status_message_ [in, out] a pre-allocated char array. The status message will be written to this memory. May be null, if the caller is not interested in the message.
-   * @param maxlen [in] length of the allocated memory
+   * @param max_len_ [in] length of the allocated memory
    */
   ECALTIME_API void etime_get_status(int* error_, char* status_message_, int max_len_);
 
diff --git a/cpack/cpack_variables.cmake b/cpack/cpack_variables.cmake
index 5f8fb118af..66de0bddbc 100644
--- a/cpack/cpack_variables.cmake
+++ b/cpack/cpack_variables.cmake
@@ -39,7 +39,7 @@ endif()
 
 set(CPACK_SOURCE_PACKAGE_FILE_NAME "${CPACK_PACKAGE_NAME}-${CPACK_PACKAGE_VERSION}")
 set(CPACK_DEBIAN_PACKAGE_MAINTAINER "Rex Schilasky <rex.schilasky@continental-corporation.com>")
-set(CPACK_DEBIAN_PACKAGE_HOMEPAGE "github.com/Continental/ecal")
+set(CPACK_DEBIAN_PACKAGE_HOMEPAGE "https://github.com/continental/ecal")
 set(CPACK_DEBIAN_PACKAGE_SHLIBDEPS ON)
 set(CPACK_DEBIAN_PACKAGE_GENERATE_SHLIBS ON)
 set(CPACK_DEBIAN_PACKAGE_DEBUG ON)
diff --git a/doc/eCAL.pdf b/doc/eCAL.pdf
index 2ccaf1263b..9a784709ce 100644
Binary files a/doc/eCAL.pdf and b/doc/eCAL.pdf differ
diff --git a/doc/eCAL.pptx b/doc/eCAL.pptx
index 3a9b146ce3..ba45eca935 100644
Binary files a/doc/eCAL.pptx and b/doc/eCAL.pptx differ
diff --git a/ecal/core/cfg/ecal.ini b/ecal/core/cfg/ecal.ini
index f0617f19f3..f3b2fea93a 100644
--- a/ecal/core/cfg/ecal.ini
+++ b/ecal/core/cfg/ecal.ini
@@ -19,17 +19,11 @@
 ;  
 ; multicast_rcvbuf    = 1024 * x              UDP receive buffer in bytes
 ;  
-; unicast_ipaddr      = 127.0.0.1             UDP unicast group for eCAL unicast
-; unicast_port        = 15000                 UDP unicast port number for eCAL unicast
-; 
 ; bandwidth_max_udp   = 1048576               UDP bandwidth limit for eCAL udp layer (-1 == unlimited)
 ;  
 ; inproc_rec_enabled  = true                  Enable to receive on eCAL inner process layer
 ; shm_rec_enabled     = true                  Enable to receive on eCAL shared memory layer
 ; udp_mc_rec_enabled  = true                  Enable to receive on eCAL udp multicast layer
-; udp_uc_rec_enabled  = false                 Enable to receive on eCAL udp unicast layer
-; lcm_rec_enabled     = false                 Enable to receive on Google lcm layer
-; rtps_rec_enabled    = false                 Enable to receive on FastRtps layer (ROS2)
 ; iceoryx_rec_enabled = false                 Enable to receive on Iceoryx layer
 ;
 ; npcap_enabled       = false                 Enable to receive UDP traffic with the Npcap based receiver
@@ -44,20 +38,11 @@ multicast_ttl       = 0
 multicast_sndbuf    = 5242880
 multicast_rcvbuf    = 5242880
 
-multicast_group_mtl = 239.0.0.1
-multicast_port_mtl  = 14100
-
-unicast_ipaddr      = 127.0.0.1
-unicast_port        = 15000
-
 bandwidth_max_udp   = -1
 
 inproc_rec_enabled  = true
 shm_rec_enabled     = true
 udp_mc_rec_enabled  = true
-udp_uc_rec_enabled  = false
-lcm_rec_enabled     = false
-rtps_rec_enabled    = false
 iceoryx_rec_enabled = false
 
 npcap_enabled       = false
@@ -89,16 +74,6 @@ registration_refresh  = 1000
 [time]
 timesync_module_rt        = "ecaltime-localtime"
 
-; ---------------------------------------------
-; RTPS SETTINGS
-; ---------------------------------------------
-;
-; domain                    = "eCAL"                 default fastRTPS domain name
-;
-; ---------------------------------------------
-[rtps]
-domain                    = "eCAL"
-
 ; ---------------------------------------------
 ; ICEORYX SETTINGS
 ; ---------------------------------------------
@@ -118,9 +93,6 @@ instance                  = ""
 ; use_inproc                = 0, 1, 2                use inner process transport layer (0 = off, 1 = on, 2 = auto, default = 0)
 ; use_shm                   = 0, 1, 2                use shared memory transport layer (0 = off, 1 = on, 2 = auto, default = 2)
 ; use_udp_mc                = 0, 1, 2                use udp multicast transport layer (0 = off, 1 = on, 2 = auto, default = 2)
-; use_udp_uc                = 0, 1                   use udp unicast transport layer   (0 = off, 1 = on,           default = 0)
-; use_lcm                   = 0, 1                   use lcm transport layer           (0 = off, 1 = on,           default = 0)
-; use_rtps                  = 0, 1                   use rtps transport layer          (0 = off, 1 = on            default = 0)
 ; use_iceoryx               = 0, 1                   use iceoryx transport layer       (0 = off, 1 = on            default = 0)
 ;
 ; memfile_minsize           = x * 4096 kB            default memory file size for new publisher
@@ -137,9 +109,6 @@ instance                  = ""
 use_inproc                = 0
 use_shm                   = 2
 use_udp_mc                = 2
-use_udp_uc                = 0
-use_lcm                   = 0
-use_rtps                  = 0
 use_iceoryx               = 0
 
 memfile_minsize           = 4096
@@ -177,4 +146,4 @@ filter_log_udp     = info, warning, error, fatal
 ;
 ; ---------------------------------------------
 [sys]
-filter_excl        = ^eCALRPCService$|^eCALMon$|^eCALPlay$|^eCALPlayGUI$|^eCALRec$|^eCALRecGUI$|^eCALSys$|^eCALSysGUI$|^Machine Monitoring Agent|^Any \(LCM\)$
+filter_excl        = ^eCALMon$|^eCALPlay$|^eCALPlayGUI$|^eCALRec$|^eCALRecGUI$
diff --git a/ecal/core/include/ecal/cimpl/ecal_tlayer_cimpl.h b/ecal/core/include/ecal/cimpl/ecal_tlayer_cimpl.h
index f88748a0c6..6265efdd59 100644
--- a/ecal/core/include/ecal/cimpl/ecal_tlayer_cimpl.h
+++ b/ecal/core/include/ecal/cimpl/ecal_tlayer_cimpl.h
@@ -32,11 +32,8 @@ enum eTransportLayerC
 {
   tlayer_none       = 0,
   tlayer_udp_mc     = 1,
-  tlayer_udp_uc     = 2,
-  tlayer_udp_metal  = 3,
   tlayer_shm        = 4,
-  tlayer_lcm        = 5,
-  tlayer_rtps       = 6,
+  tlayer_iceoryx    = 7,
   tlayer_inproc     = 42,
   tlayer_all        = 255
 };
diff --git a/ecal/core/include/ecal/ecal_publisher.h b/ecal/core/include/ecal/ecal_publisher.h
index f17c3a17f9..00b34ca100 100644
--- a/ecal/core/include/ecal/ecal_publisher.h
+++ b/ecal/core/include/ecal/ecal_publisher.h
@@ -395,10 +395,7 @@ namespace eCAL
 
       // set layer mode if changed class method function
       if (m_tlayer.sm_udp_mc != TLayer::smode_none) eCAL_Pub_SetLayerMode(m_publisher, static_cast<eTransportLayerC>(TLayer::tlayer_udp_mc), static_cast<eSendModeC>(m_tlayer.sm_udp_mc));
-      if (m_tlayer.sm_udp_uc != TLayer::smode_none) eCAL_Pub_SetLayerMode(m_publisher, static_cast<eTransportLayerC>(TLayer::tlayer_udp_uc), static_cast<eSendModeC>(m_tlayer.sm_udp_uc));
       if (m_tlayer.sm_shm    != TLayer::smode_none) eCAL_Pub_SetLayerMode(m_publisher, static_cast<eTransportLayerC>(TLayer::tlayer_shm),    static_cast<eSendModeC>(m_tlayer.sm_shm));
-      if (m_tlayer.sm_lcm    != TLayer::smode_none) eCAL_Pub_SetLayerMode(m_publisher, static_cast<eTransportLayerC>(TLayer::tlayer_lcm),    static_cast<eSendModeC>(m_tlayer.sm_lcm));
-      if (m_tlayer.sm_rtps   != TLayer::smode_none) eCAL_Pub_SetLayerMode(m_publisher, static_cast<eTransportLayerC>(TLayer::tlayer_rtps),   static_cast<eSendModeC>(m_tlayer.sm_rtps));
 
       // set qos
       struct SWriterQOSC qos;
@@ -471,24 +468,20 @@ namespace eCAL
         case TLayer::tlayer_udp_mc:
           m_tlayer.sm_udp_mc = mode_;
           break;
-        case TLayer::tlayer_udp_uc:
-          m_tlayer.sm_udp_uc = mode_;
-          break;
         case TLayer::tlayer_shm:
           m_tlayer.sm_shm = mode_;
           break;
-        case TLayer::tlayer_lcm:
-          m_tlayer.sm_lcm = mode_;
+        case TLayer::tlayer_iceoryx:
+          m_tlayer.sm_iceoryx = mode_;
           break;
-        case TLayer::tlayer_rtps:
-          m_tlayer.sm_rtps = mode_;
+        case TLayer::tlayer_inproc:
+          m_tlayer.sm_inproc = mode_;
           break;
         case TLayer::tlayer_all:
-          m_tlayer.sm_udp_mc = mode_;
-          m_tlayer.sm_udp_uc = mode_;
-          m_tlayer.sm_shm    = mode_;
-          m_tlayer.sm_lcm    = mode_;
-          m_tlayer.sm_rtps   = mode_;
+          m_tlayer.sm_udp_mc  = mode_;
+          m_tlayer.sm_shm     = mode_;
+          m_tlayer.sm_iceoryx = mode_;
+          m_tlayer.sm_inproc  = mode_;
           break;
         default:
           break;
@@ -575,11 +568,10 @@ namespace eCAL
 
     void InitializeTLayer()
     {
-      m_tlayer.sm_udp_mc = TLayer::smode_none;
-      m_tlayer.sm_udp_uc = TLayer::smode_none;
-      m_tlayer.sm_shm    = TLayer::smode_none;
-      m_tlayer.sm_lcm    = TLayer::smode_none;
-      m_tlayer.sm_rtps   = TLayer::smode_none;
+      m_tlayer.sm_udp_mc  = TLayer::smode_none;
+      m_tlayer.sm_shm     = TLayer::smode_none;
+      m_tlayer.sm_iceoryx = TLayer::smode_none;
+      m_tlayer.sm_inproc  = TLayer::smode_none;
     }
 
     std::string Dump() const
diff --git a/ecal/core/include/ecal/ecal_tlayer.h b/ecal/core/include/ecal/ecal_tlayer.h
index bd2c7a2573..d7139ddd91 100644
--- a/ecal/core/include/ecal/ecal_tlayer.h
+++ b/ecal/core/include/ecal/ecal_tlayer.h
@@ -35,11 +35,7 @@ namespace eCAL
     {
       tlayer_none       = 0,
       tlayer_udp_mc     = 1,
-      tlayer_udp_uc     = 2,
-      tlayer_udp_metal  = 3,
       tlayer_shm        = 4,
-      tlayer_lcm        = 5,
-      tlayer_rtps       = 6,
       tlayer_iceoryx    = 7,
       tlayer_inproc     = 42,
       tlayer_all        = 255
@@ -63,18 +59,14 @@ namespace eCAL
     {
       STLayer()
       {
-        sm_udp_mc = smode_none;
-        sm_udp_uc = smode_none;
-        sm_shm    = smode_none;
-        sm_lcm    = smode_none;
-        sm_rtps   = smode_none;
-        sm_inproc = smode_none;
+        sm_udp_mc  = smode_none;
+        sm_shm     = smode_none;
+        sm_iceoryx = smode_none;
+        sm_inproc  = smode_none;
       }
       eSendMode sm_udp_mc;  //!< udp multicast
-      eSendMode sm_udp_uc;  //!< udp unicast
       eSendMode sm_shm;     //!< shared memory
-      eSendMode sm_lcm;     //!< lcm (google)
-      eSendMode sm_rtps;    //!< rtps (eProsima)
+      eSendMode sm_iceoryx; //!< shared memory (iceoryx)
       eSendMode sm_inproc;  //!< inner process (inner process memory forwarding only)
     };
   }
diff --git a/ecal/core/src/CMakeLists.txt b/ecal/core/src/CMakeLists.txt
index 965c591571..d3ca0f882a 100644
--- a/ecal/core/src/CMakeLists.txt
+++ b/ecal/core/src/CMakeLists.txt
@@ -72,22 +72,6 @@ set(ecal_pubsub_cpp_src
     pubsub/ecal_subscriber.cpp
 )
 
-set(ecal_readwrite_lcm_cpp_src
-    readwrite/lcm/lcmlite.cpp
-)
-
-if(ECAL_LAYER_FASTRTPS)
-  set(ecal_readwrite_rtps_msg_cpp_src
-      readwrite/fastrtps/string_message_.cxx
-      readwrite/fastrtps/string_message_PubSubTypes.cxx
-  )
-
-  set(ecal_readwrite_rtps_cpp_src
-    readwrite/ecal_reader_rtps.cpp
-    readwrite/ecal_writer_rtps.cpp
-  )
-endif()
-
 if(ECAL_LAYER_ICEORYX)
   set(ecal_readwrite_iceoryx_cpp_src
     readwrite/ecal_reader_iceoryx.cpp
@@ -98,18 +82,13 @@ endif()
 set(ecal_readwrite_cpp_src
     readwrite/ecal_reader.cpp
     readwrite/ecal_reader_inproc.cpp
-    readwrite/ecal_reader_lcm.cpp
-    readwrite/ecal_reader_metal.cpp
     readwrite/ecal_reader_shm.cpp
     readwrite/ecal_reader_udp.cpp
     readwrite/ecal_reader_udp_mc.cpp
-    readwrite/ecal_reader_udp_uc.cpp
     readwrite/ecal_writer.cpp
     readwrite/ecal_writer_inproc.cpp
-    readwrite/ecal_writer_lcm.cpp
     readwrite/ecal_writer_shm.cpp
     readwrite/ecal_writer_udp_mc.cpp
-    readwrite/ecal_writer_udp_uc.cpp
 )
 
 set(ecal_service_cpp_src
@@ -184,21 +163,6 @@ set(ecal_pubsub_header_src
     pubsub/ecal_subgate.h
 )
 
-set(ecal_readwrite_lcm_header_src
-    readwrite/lcm/lcmlite.h
-)
-
-if(ECAL_LAYER_FASTRTPS)
-  set(ecal_readwrite_rtps_msg_header_src
-      readwrite/fastrtps/string_message_.h
-      readwrite/fastrtps/string_message_PubSubTypes.h
-)
-set(ecal_readwrite_rtps_header_src
-    readwrite/ecal_reader_rtps.h
-    readwrite/ecal_writer_rtps.h
-)
-endif()
-
 if(ECAL_LAYER_ICEORYX)
 set(ecal_readwrite_iceoryx_header_src
     readwrite/ecal_reader_iceoryx.h
@@ -209,19 +173,14 @@ endif()
 set(ecal_readwrite_header_src
     readwrite/ecal_reader.h
     readwrite/ecal_reader_inproc.h
-    readwrite/ecal_reader_lcm.h
-    readwrite/ecal_reader_metal.h
     readwrite/ecal_reader_shm.h
     readwrite/ecal_reader_udp.h
     readwrite/ecal_reader_udp_mc.h
-    readwrite/ecal_reader_udp_uc.h
     readwrite/ecal_writer.h
     readwrite/ecal_writer_base.h
     readwrite/ecal_writer_inproc.h
-    readwrite/ecal_writer_lcm.h
     readwrite/ecal_writer_shm.h
     readwrite/ecal_writer_udp_mc.h
-    readwrite/ecal_writer_udp_uc.h
 )
 
 set(ecal_service_header_src
@@ -352,10 +311,7 @@ ecal_add_ecal_shared_library(${PROJECT_NAME}
     ${ecal_mon_cpp_src} 
     ${ecal_pubsub_cpp_src} 
     ${ecal_readwrite_iceoryx_cpp_src}
-    ${ecal_readwrite_lcm_cpp_src} 
     ${ecal_readwrite_cpp_src} 
-    ${ecal_readwrite_rtps_msg_cpp_src}
-    ${ecal_readwrite_rtps_cpp_src}
     ${ecal_service_cpp_src}
     ${ecal_cmn_cpp_src}
 
@@ -366,10 +322,7 @@ ecal_add_ecal_shared_library(${PROJECT_NAME}
     ${ecal_mon_header_src}
     ${ecal_pubsub_header_src}
     ${ecal_readwrite_iceoryx_header_src}
-    ${ecal_readwrite_lcm_header_src}
     ${ecal_readwrite_header_src}
-    ${ecal_readwrite_rtps_msg_header_src}
-    ${ecal_readwrite_rtps_header_src}
     ${ecal_service_header_src}
 
     ${ecal_header_base}
@@ -399,19 +352,6 @@ target_compile_definitions(${PROJECT_NAME}
   PUBLIC ASIO_STANDALONE
   PRIVATE eCAL_EXPORTS)
 
-if(ECAL_LAYER_FASTRTPS)
-  if(WIN32)
-    find_package(fastrtps REQUIRED)
-    target_include_directories(${PROJECT_NAME} PRIVATE ${FASTRTPS_INCLUDE_DIRS})
-    target_link_libraries(${PROJECT_NAME} PRIVATE ${FASTRTPS_LIBRARIES})
-  endif()
-
-  if(UNIX)
-    target_link_libraries(${PROJECT_NAME} PRIVATE fastcdr fastrtps)
-  endif()
-    target_compile_definitions(${PROJECT_NAME} PUBLIC ECAL_LAYER_FASTRTPS)
-endif()
-
 if(ECAL_LAYER_ICEORYX)
   if(UNIX)
     find_package(iceoryx_posh REQUIRED)
@@ -481,10 +421,7 @@ if(NOT ${CMAKE_VERSION} VERSION_LESS "3.8.0")
     ${ecal_io_cpp_win32_src}
     ${ecal_mon_cpp_src}
     ${ecal_pubsub_cpp_src}
-    ${ecal_readwrite_rtps_msg_cpp_src}
-    ${ecal_readwrite_lcm_cpp_src}
     ${ecal_readwrite_cpp_src}
-    ${ecal_readwrite_rtps_cpp_src}
     ${ecal_service_cpp_src}
   )
   
@@ -495,10 +432,7 @@ if(NOT ${CMAKE_VERSION} VERSION_LESS "3.8.0")
     ${ecal_io_header_win_src}
     ${ecal_mon_header_src}
     ${ecal_pubsub_header_src}
-    ${ecal_readwrite_rtps_msg_header_src}
-    ${ecal_readwrite_lcm_header_src}
     ${ecal_readwrite_header_src}
-    ${ecal_readwrite_rtps_header_src}
     ${ecal_service_header_src}
   )
   
diff --git a/ecal/core/src/ecal_def.h b/ecal/core/src/ecal_def.h
index dddf47b074..e962d68c69 100644
--- a/ecal/core/src/ecal_def.h
+++ b/ecal/core/src/ecal_def.h
@@ -68,8 +68,6 @@
 #define NET_UDP_MULTICAST_GROUP                    "239.0.0.1"
 #define NET_UDP_MULTICAST_MASK                     "0.0.0.15"
 #define NET_UDP_MULTICAST_PORT                     14000
-#define NET_UDP_MULTICAST_GROUP_METAL              "239.0.0.1"
-#define NET_UDP_MULTICAST_PORT_METAL               14100
 #ifdef CFG_FORCE_DEFAULT_LOCAL
 #define NET_UDP_MULTICAST_TTL                          0
 #else /* CFG_FORCE_DEFAULT_LOCAL */
@@ -81,15 +79,9 @@
 #define NET_UDP_MULTICAST_SNDBUF            (5*1024*1024)  /* 5 MByte */
 #define NET_UDP_MULTICAST_RCVBUF            (5*1024*1024)  /* 5 MByte */
 
-#define NET_UDP_UNICAST_IPADDR                     "127.0.0.1"
-#define NET_UDP_UNICAST_PORT                       15000
-
 #define NET_UDP_RECBUFFER_TIMEOUT                   1000   /* ms */
 #define NET_UDP_RECBUFFER_CLEANUP                     10   /* ms */
 
-#define NET_UDP_MULTICAST_GROUP_LCM                "239.255.76.67"
-#define NET_UDP_MULTICAST_PORT_LCM                  7667
-
 /* overall udp multicast bandwidth limitation in bytes/s, -1 == no limitation*/
 #define NET_BANDWIDTH_MAX_UDP                         -1
 
@@ -102,19 +94,10 @@
 #define NET_UDP_MC_REC_ENABLED                      true
 #endif /* CFG_FORCE_DEFAULT_LOCAL */
 
-#define NET_UDP_UC_REC_ENABLED                      false
-#define NET_METAL_REC_ENABLED                       false
-#define NET_LCM_REC_ENABLED                         false
-#define NET_RTPS_REC_ENABLED                        false
 #define NET_ICEORYX_REC_ENABLED                     false
 
 #define NET_NPCAP_ENABLED                           false
 
-/**********************************************************************************************/
-/*                                     rtps settings                                          */
-/**********************************************************************************************/
-#define RTPS_DOMAIN                                "eCAL"
-
 /**********************************************************************************************/
 /*                                     iceoryx settings                                       */
 /**********************************************************************************************/
@@ -134,12 +117,6 @@
 #else /* CFG_FORCE_DEFAULT_LOCAL */
 #define PUB_USE_UDP_MC                                 2
 #endif /* CFG_FORCE_DEFAULT_LOCAL */
-/* use udp unicast transport layer   [          on = 1, off = 0] */
-#define PUB_USE_UDP_UC                                 0
-/* use lcm transport layer           [          on = 1, off = 0] */
-#define PUB_USE_LCM                                    0
-/* use rtps transport layer          [          on = 1, off = 0] */
-#define PUB_USE_RTPS                                   0
 /* use iceoryx transport layer       [          on = 1, off = 0] */
 #define PUB_USE_ICEORYX                                0
 
diff --git a/ecal/core/src/ecal_def_ini.h b/ecal/core/src/ecal_def_ini.h
index ef8bd8d61b..22eb6f9098 100644
--- a/ecal/core/src/ecal_def_ini.h
+++ b/ecal/core/src/ecal_def_ini.h
@@ -42,24 +42,13 @@
 #define  NET_UDP_MULTICAST_PORT_S         "multicast_port"
 #define  NET_UDP_MULTICAST_TTL_S          "multicast_ttl"
 
-#define  NET_UDP_MULTICAST_GROUP_METAL_S  "multicast_group_mtl"
-#define  NET_UDP_MULTICAST_PORT_METAL_S   "multicast_port_mtl"
-
 #define  NET_UDP_MULTICAST_SNDBUF_S       "multicast_sndbuf"
 #define  NET_UDP_MULTICAST_RCVBUF_S       "multicast_rcvbuf"
 
-#define  NET_UNICAST_MODE_S               "unicast_mode"
-#define  NET_UDP_UNICAST_IPADDR_S         "unicast_ipaddr"
-#define  NET_UDP_UNICAST_PORT_S           "unicast_port"
-
 #define  NET_BANDWIDTH_MAX_UDP_S          "bandwidth_max_udp"
 
 #define  NET_UDP_MC_REC_ENABLED_S         "udp_mc_rec_enabled"
-#define  NET_UDP_UC_REC_ENABLED_S         "udp_uc_rec_enabled"
 #define  NET_SHM_REC_ENABLED_S            "shm_rec_enabled"
-#define  NET_METAL_REC_ENABLED_S          "metal_rec_enabled"
-#define  NET_LCM_REC_ENABLED_S            "lcm_rec_enabled"
-#define  NET_RTPS_REC_ENABLED_S           "rtps_rec_enabled"
 #define  NET_ICEORYX_REC_ENABLED_S        "iceoryx_rec_enabled"
 #define  NET_INPROC_REC_ENABLED_S         "inproc_rec_enabled"
 
@@ -97,12 +86,6 @@
 #define  SYS_SECTION_S                    "sys"
 #define  SYS_FILTER_EXCL_S                "filter_excl"
 
-/////////////////////////////////////
-// rtps
-/////////////////////////////////////
-#define  RTPS_SECTION_S                   "rtps"
-#define  RTPS_DOMAIN_S                    "domain"
-
 /////////////////////////////////////
 // iceoryx
 /////////////////////////////////////
@@ -116,10 +99,7 @@
 #define  PUB_SECTION_S                    "publisher"
 
 #define  PUB_USE_UDP_MC_S                 "use_udp_mc"
-#define  PUB_USE_UDP_UC_S                 "use_udp_uc"
 #define  PUB_USE_SHM_S                    "use_shm"
-#define  PUB_USE_LCM_S                    "use_lcm"
-#define  PUB_USE_RTPS_S                   "use_rtps"
 #define  PUB_USE_ICEORYX_S                "use_iceoryx"
 #define  PUB_USE_INPROC_S                 "use_inproc"
 
diff --git a/ecal/core/src/ecal_globals.cpp b/ecal/core/src/ecal_globals.cpp
index be08462938..74c7bbb6ef 100644
--- a/ecal/core/src/ecal_globals.cpp
+++ b/ecal/core/src/ecal_globals.cpp
@@ -27,7 +27,7 @@
 
 namespace eCAL
 {
-  CGlobals::CGlobals() : initialized(false)
+  CGlobals::CGlobals() : initialized(false), components(0)
   {}
 
   CGlobals::~CGlobals()
@@ -189,7 +189,8 @@ namespace eCAL
     if (timegate_instance && (components_ & Init::TimeSync))      timegate_instance->Create(CTimeGate::eTimeSyncMode::realtime);
     if (monitoring_instance && (components_ & Init::Monitoring))  monitoring_instance->Create();
 
-    initialized = true;
+    initialized =  true;
+    components  |= components_;
 
     if (new_initialization) return 0;
     else                    return 1;
diff --git a/ecal/core/src/ecal_globals.h b/ecal/core/src/ecal_globals.h
index f2697598d9..2455085c56 100644
--- a/ecal/core/src/ecal_globals.h
+++ b/ecal/core/src/ecal_globals.h
@@ -48,6 +48,8 @@ namespace eCAL
     int Initialize    ( unsigned int components_, std::vector<std::string>* config_keys_ = nullptr);
     int IsInitialized ( unsigned int component_  );
 
+    unsigned int GetComponents() { return(components); };
+
     int Finalize(unsigned int components_);
 
     const std::unique_ptr<CConfig>&                                       config()           { return config_instance; };
@@ -65,6 +67,7 @@ namespace eCAL
 
   private:
     bool                                                                  initialized;
+    unsigned int                                                          components;
     std::unique_ptr<CConfig>                                              config_instance;
     std::unique_ptr<CLog>                                                 log_instance;
     std::unique_ptr<CMonitoring>                                          monitoring_instance;
diff --git a/ecal/core/src/ecal_process.cpp b/ecal/core/src/ecal_process.cpp
index bf248ba3b2..26fa529d4f 100644
--- a/ecal/core/src/ecal_process.cpp
+++ b/ecal/core/src/ecal_process.cpp
@@ -120,26 +120,26 @@ namespace
       IP_ADAPTER_INFO AdapterInfo;
       GetAdaptersInfo(&AdapterInfo, &alloc_adapters_size);
     }
-    // get number of active adapters
-    int num_adapters = alloc_adapters_size / sizeof(IP_ADAPTER_INFO);
-    if (num_adapters == 0) return std::make_pair(false, 0);
+    if(alloc_adapters_size == 0) return std::make_pair(false, 0);
 
     // allocate adapter memory
-    std::vector<IP_ADAPTER_INFO> adapter_vec;
-    adapter_vec.resize(num_adapters);
+    auto adapter_mem = std::make_unique<char[]>(alloc_adapters_size);
 
     // get all adapter infos
-    DWORD dwStatus = GetAdaptersInfo(adapter_vec.data(), &alloc_adapters_size);
+    PIP_ADAPTER_INFO pAdapter(nullptr);
+    pAdapter = reinterpret_cast<PIP_ADAPTER_INFO>(adapter_mem.get());
+    DWORD dwStatus = GetAdaptersInfo(pAdapter, &alloc_adapters_size);
     if (dwStatus != ERROR_SUCCESS) return std::make_pair(false, 0);
 
     // iterate adapters and create hash
     int hash(0);
-    for(auto adapter : adapter_vec)
+    while(pAdapter)
     {
-      for (UINT i = 0; i < adapter.AddressLength; ++i)
+      for (UINT i = 0; i < pAdapter->AddressLength; ++i)
       {
-        hash += (adapter.Address[i] << ((i & 1) * 8));
+        hash += (pAdapter->Address[i] << ((i & 1) * 8));
       }
+      pAdapter = pAdapter->Next;
     }
 
     // return success
@@ -252,8 +252,6 @@ namespace eCAL
       sstream << "Multicast mask           : " << eCALPAR(NET, UDP_MULTICAST_MASK) << std::endl;
       int port = eCALPAR(NET, UDP_MULTICAST_PORT);
       sstream << "Multicast ports          : " << port << " - " << port + 10 << std::endl;
-      sstream << "Multicast group (metal)  : " << eCALPAR(NET, UDP_MULTICAST_GROUP_METAL) << std::endl;
-      sstream << "Multicast port  (metal)  : " << eCALPAR(NET, UDP_MULTICAST_PORT_METAL) << std::endl;
       auto bandwidth = eCALPAR(NET, BANDWIDTH_MAX_UDP);
       if (bandwidth < 0)
       {
@@ -284,9 +282,6 @@ namespace eCAL
       sstream << "Layer Mode INPROC  (eCAL)     : " << LayerMode(eCALPAR(PUB, USE_INPROC))  << std::endl;
       sstream << "Layer Mode SHM     (eCAL)     : " << LayerMode(eCALPAR(PUB, USE_SHM))     << std::endl;
       sstream << "Layer Mode UDP MC  (eCAL)     : " << LayerMode(eCALPAR(PUB, USE_UDP_MC))  << std::endl;
-      sstream << "Layer Mode UDP UC  (eCAL)     : " << LayerMode(eCALPAR(PUB, USE_UDP_UC))  << std::endl;
-      sstream << "Layer Mode LCM     (GOOGLE)   : " << LayerMode(eCALPAR(PUB, USE_LCM))     << std::endl;
-      sstream << "Layer Mode RTPS    (eProsima) : " << LayerMode(eCALPAR(PUB, USE_RTPS))    << std::endl;
       sstream << "Layer Mode ICEORYX (Bosch)    : " << LayerMode(eCALPAR(PUB, USE_ICEORYX)) << std::endl;
       sstream << std::endl;
 
@@ -294,9 +289,6 @@ namespace eCAL
       sstream << "Layer Mode INPROC  (eCAL)     : " << LayerMode(eCALPAR(NET, INPROC_REC_ENABLED))  << std::endl;
       sstream << "Layer Mode SHM     (eCAL)     : " << LayerMode(eCALPAR(NET, SHM_REC_ENABLED))     << std::endl;
       sstream << "Layer Mode UDP MC  (eCAL)     : " << LayerMode(eCALPAR(NET, UDP_MC_REC_ENABLED))  << std::endl;
-      sstream << "Layer Mode UDP UC  (eCAL)     : " << LayerMode(eCALPAR(NET, UDP_UC_REC_ENABLED))  << std::endl;
-      sstream << "Layer Mode LCM     (GOOGLE)   : " << LayerMode(eCALPAR(NET, LCM_REC_ENABLED))     << std::endl;
-      sstream << "Layer Mode RTPS    (eProsima) : " << LayerMode(eCALPAR(NET, RTPS_REC_ENABLED))    << std::endl;
       sstream << "Layer Mode ICEORYX (Bosch)    : " << LayerMode(eCALPAR(NET, ICEORYX_REC_ENABLED)) << std::endl;
       sstream << "Npcap UDP Reciever            : " << LayerMode(eCALPAR(NET, NPCAP_ENABLED));
 #ifdef ECAL_NPCAP_SUPPORT
diff --git a/ecal/core/src/ecal_register.cpp b/ecal/core/src/ecal_register.cpp
index c14d94dab1..89f2b94a5c 100644
--- a/ecal/core/src/ecal_register.cpp
+++ b/ecal/core/src/ecal_register.cpp
@@ -25,6 +25,7 @@
 
 #include "ecal_def.h"
 #include "ecal_config_hlp.h"
+#include "ecal_globals.h"
 #include "ecal_register.h"
 #include "ecal_servgate.h"
 #include "ecal_timegate.h"
@@ -193,31 +194,45 @@ namespace eCAL
     process_sample_mutable_process->mutable_state()->set_info(g_process_info);
     if (!g_timegate())
     {
-      process_sample_mutable_process->set_tsync_mode(eCAL::pb::eTSyncState::tsync_none);
+      process_sample_mutable_process->set_tsync_state(eCAL::pb::eTSyncState::tsync_none);
     }
     else
     {
       if (!g_timegate()->IsSynchronized())
       {
-        process_sample_mutable_process->set_tsync_mode(eCAL::pb::eTSyncState::tsync_none);
+        process_sample_mutable_process->set_tsync_state(eCAL::pb::eTSyncState::tsync_none);
       }
       else
       {
         switch (g_timegate()->GetSyncMode())
         {
         case CTimeGate::eTimeSyncMode::realtime:
-          process_sample_mutable_process->set_tsync_mode(eCAL::pb::eTSyncState::tsync_realtime);
+          process_sample_mutable_process->set_tsync_state(eCAL::pb::eTSyncState::tsync_realtime);
           break;
         case CTimeGate::eTimeSyncMode::replay:
-          process_sample_mutable_process->set_tsync_mode(eCAL::pb::eTSyncState::tsync_replay);
+          process_sample_mutable_process->set_tsync_state(eCAL::pb::eTSyncState::tsync_replay);
           break;
         default:
-          process_sample_mutable_process->set_tsync_mode(eCAL::pb::eTSyncState::tsync_none);
+          process_sample_mutable_process->set_tsync_state(eCAL::pb::eTSyncState::tsync_none);
           break;
         }
       }
+      process_sample_mutable_process->set_tsync_mod_name(g_timegate()->GetName());
     }
 
+    // eCAL initialization state
+    unsigned int comp_state(g_globals()->GetComponents());
+    process_sample_mutable_process->set_component_init_state(google::protobuf::int32(comp_state));
+    std::string component_info;
+    if (comp_state & Init::Publisher)   component_info += "|pub";
+    if (comp_state & Init::Subscriber)  component_info += "|sub";
+    if (comp_state & Init::Service)     component_info += "|srv";
+    if (comp_state & Init::Monitoring)  component_info += "|mon";
+    if (comp_state & Init::Logging)     component_info += "|log";
+    if (comp_state & Init::TimeSync)    component_info += "|time";
+    if (!component_info.empty()) component_info = component_info.substr(1);
+    process_sample_mutable_process->set_component_init_info(component_info);
+
     // register sample
     size_t sent_sum = RegisterSample(Process::GetHostName(), process_sample);
     std::this_thread::sleep_for(std::chrono::milliseconds(1));
diff --git a/ecal/core/src/ecal_time.cpp b/ecal/core/src/ecal_time.cpp
index f802aac287..dd5d3ac32a 100644
--- a/ecal/core/src/ecal_time.cpp
+++ b/ecal/core/src/ecal_time.cpp
@@ -42,7 +42,7 @@ namespace eCAL
     {
       if (!g_timegate() || !g_timegate()->IsValid())
       {
-        std::chrono::steady_clock::time_point now = std::chrono::steady_clock::now();
+        std::chrono::system_clock::time_point now = std::chrono::system_clock::now();
         return(std::chrono::duration_cast<std::chrono::microseconds>(now.time_since_epoch()).count());
       }
       return(g_timegate()->GetMicroSeconds());
@@ -52,7 +52,7 @@ namespace eCAL
     {
       if (!g_timegate() || !g_timegate()->IsValid())
       {
-        std::chrono::steady_clock::time_point now = std::chrono::steady_clock::now();
+        std::chrono::system_clock::time_point now = std::chrono::system_clock::now();
         return(std::chrono::duration_cast<std::chrono::nanoseconds>(now.time_since_epoch()).count());
       }
       return(g_timegate()->GetNanoSeconds());
diff --git a/ecal/core/src/ecal_timer.cpp b/ecal/core/src/ecal_timer.cpp
index 3ba7cf8d45..30da3569cf 100644
--- a/ecal/core/src/ecal_timer.cpp
+++ b/ecal/core/src/ecal_timer.cpp
@@ -67,29 +67,65 @@ namespace eCAL
       if (delay_ > 0) eCAL::Time::sleep_for(std::chrono::milliseconds(delay_));
 
       std::chrono::nanoseconds loop_duration((long long)timeout_ * 1000LL * 1000LL);
+      m_last_error = std::chrono::nanoseconds(0);
 
       while (!m_stop)
       {
+        // Execute callback and measure it's execution time
         auto start = eCAL::Time::ecal_clock::now();
         (callback_)();
         auto end = eCAL::Time::ecal_clock::now();
 
-        if (end < start) {
-          // If the time jumped backwards, we do not know how long the function took to complete. Thus, we will assume it was "fast" and wait for the maximum time.
+        // If the time jumped backwards, we do not know how long the function took to complete. 
+        // Thus, we will assume it was "fast" and wait for the maximum time.
+        if (end < start)
+        {
           eCAL::Time::sleep_for(loop_duration);
         }
-        else {
-          // Sleep for the remaining time
-          auto sleep_duration = loop_duration - (end - start);
-          eCAL::Time::sleep_for(sleep_duration);
+        else
+        {
+          // Correct loop duration by last duration error
+          auto loop_duration_corr = loop_duration - m_last_error;
+          auto sleep_remaining    = loop_duration_corr - (end - start);
+#if _WIN32
+          // Sleep for the remaining time in multiple loops of smaller sleeps
+
+          // Minimum sleep resolution
+          // Lower values will increase the precision but also the CPU usage !
+          const auto sleep_resolution_min = std::chrono::microseconds(1);
+
+          // Sleep threshold for switching to minimal sleep intervalls
+          const auto sleep_precision_thr  = std::chrono::milliseconds(5);
+
+          while (sleep_remaining.count() > 0)
+          {
+            // We start with half of the remaining time
+            sleep_remaining = sleep_remaining / 2;
+            
+            // If we reach the system clock sleep precision
+            // we reduce the sleep time to the minimum resolution
+            if (sleep_remaining < sleep_precision_thr) sleep_remaining = sleep_resolution_min;
+
+            // Sleep and recalculate the remaining time
+            eCAL::Time::sleep_for(sleep_remaining);
+            sleep_remaining = loop_duration_corr - (eCAL::Time::ecal_clock::now() - start);
+          }
+#else // _WIN32
+          // Sleep for the remaining time in one sleep
+          eCAL::Time::sleep_for(sleep_remaining);
+#endif //_WIN32
+
+          // Store loop error to correct the next timer run
+          m_last_error = (eCAL::Time::ecal_clock::now() - start) - loop_duration_corr;
         }
       }
       m_stop = false;
     }
 
-    std::atomic<bool> m_stop;
-    std::atomic<bool> m_running;
-    std::thread       m_thread;
+    std::atomic<bool>        m_stop;
+    std::atomic<bool>        m_running;
+    std::thread              m_thread;
+    std::chrono::nanoseconds m_last_error;
   };
 
 
diff --git a/ecal/core/src/mon/ecal_monitoring_impl.cpp b/ecal/core/src/mon/ecal_monitoring_impl.cpp
index 5ad1b080ca..d6dd383f19 100644
--- a/ecal/core/src/mon/ecal_monitoring_impl.cpp
+++ b/ecal/core/src/mon/ecal_monitoring_impl.cpp
@@ -214,21 +214,13 @@ namespace eCAL
     std::string  topic_name      = sample_topic.tname();
     size_t       topic_size      = static_cast<size_t>(sample_topic.tsize());
     bool         topic_tlayer_ecal_udp_mc(false);
-    bool         topic_tlayer_ecal_udp_uc(false);
-    bool         topic_tlayer_ecal_udp_metal(false);
     bool         topic_tlayer_ecal_shm(false);
-    bool         topic_tlayer_lcm(false);
-    bool         topic_tlayer_rtps(false);
     bool         topic_tlayer_iceoryx(false);
     bool         topic_tlayer_inproc(false);
     for (auto layer : sample_topic.tlayer())
     {
       topic_tlayer_ecal_udp_mc    |= (layer.type() == eCAL::pb::tl_ecal_udp_mc)    && layer.confirmed();
-      topic_tlayer_ecal_udp_uc    |= (layer.type() == eCAL::pb::tl_ecal_udp_uc)    && layer.confirmed();
-      topic_tlayer_ecal_udp_metal |= (layer.type() == eCAL::pb::tl_ecal_udp_metal) && layer.confirmed();
       topic_tlayer_ecal_shm       |= (layer.type() == eCAL::pb::tl_ecal_shm)       && layer.confirmed();
-      topic_tlayer_lcm            |= (layer.type() == eCAL::pb::tl_lcm)            && layer.confirmed();
-      topic_tlayer_rtps           |= (layer.type() == eCAL::pb::tl_rtps)           && layer.confirmed();
       topic_tlayer_iceoryx        |= (layer.type() == eCAL::pb::tl_iceoryx)        && layer.confirmed();
       topic_tlayer_inproc         |= (layer.type() == eCAL::pb::tl_inproc)         && layer.confirmed();
     }
@@ -304,11 +296,7 @@ namespace eCAL
       TopicInfo.ttype                 = std::move(topic_type);
       TopicInfo.tdesc                 = std::move(topic_desc);
       TopicInfo.tlayer_ecal_udp_mc    = topic_tlayer_ecal_udp_mc;
-      TopicInfo.tlayer_ecal_udp_uc    = topic_tlayer_ecal_udp_uc;
-      TopicInfo.tlayer_ecal_udp_metal = topic_tlayer_ecal_udp_metal;
       TopicInfo.tlayer_ecal_shm       = topic_tlayer_ecal_shm;
-      TopicInfo.tlayer_lcm            = topic_tlayer_lcm;
-      TopicInfo.tlayer_rtps           = topic_tlayer_rtps;
       TopicInfo.tlayer_iceoryx        = topic_tlayer_iceoryx;
       TopicInfo.tlayer_inproc         = topic_tlayer_inproc;
       TopicInfo.tsize                 = static_cast<int>(topic_size);
@@ -344,7 +332,10 @@ namespace eCAL
     int             process_state_severity       = sample_process_state.severity();
     int             process_state_severity_level = sample_process_state.severity_level();
     std::string     process_state_info           = sample_process_state.info();
-    int             process_tsync_mode           = sample_process.tsync_mode();
+    int             process_tsync_state          = sample_process.tsync_state();
+    std::string     process_tsync_mod_name       = sample_process.tsync_mod_name();
+    int             component_init_state         = sample_process.component_init_state();
+    std::string     component_init_info          = sample_process.component_init_info();
 
     std::stringstream process_id_ss;
     process_id_ss << process_id;
@@ -373,7 +364,10 @@ namespace eCAL
     ProcessInfo.state_severity       = process_state_severity;
     ProcessInfo.state_severity_level = process_state_severity_level;
     ProcessInfo.state_info           = std::move(process_state_info);
-    ProcessInfo.tsync_mode           = process_tsync_mode;
+    ProcessInfo.tsync_state          = process_tsync_state;
+    ProcessInfo.tsync_mod_name       = process_tsync_mod_name;
+    ProcessInfo.component_init_state = component_init_state;
+    ProcessInfo.component_init_info  = component_init_info;
 
     return(true);
   }
@@ -551,8 +545,17 @@ namespace eCAL
       // severity info
       state->set_info(process.second.state_info);
 
-      // time synchronization mode
-      pMonProcs->set_tsync_mode(eCAL::pb::eTSyncState(process.second.tsync_mode));
+      // time synchronization state
+      pMonProcs->set_tsync_state(eCAL::pb::eTSyncState(process.second.tsync_state));
+
+      // time synchronization module name
+      pMonProcs->set_tsync_mod_name(process.second.tsync_mod_name);
+
+      // eCAL component initialization state
+      pMonProcs->set_component_init_state(process.second.component_init_state);
+
+      // eCAL component initialization info
+      pMonProcs->set_component_init_info(process.second.component_init_info);
     }
   }
 
@@ -647,36 +650,12 @@ namespace eCAL
         tlayer->set_type(eCAL::pb::tl_ecal_udp_mc);
         tlayer->set_confirmed(true);
       }
-      if (topic.second.tlayer_ecal_udp_uc)
-      {
-        auto tlayer = pMonTopic->add_tlayer();
-        tlayer->set_type(eCAL::pb::tl_ecal_udp_uc);
-        tlayer->set_confirmed(true);
-      }
-      if (topic.second.tlayer_ecal_udp_metal)
-      {
-        auto tlayer = pMonTopic->add_tlayer();
-        tlayer->set_type(eCAL::pb::tl_ecal_udp_metal);
-        tlayer->set_confirmed(true);
-      }
       if (topic.second.tlayer_ecal_shm)
       {
         auto tlayer = pMonTopic->add_tlayer();
         tlayer->set_type(eCAL::pb::tl_ecal_shm);
         tlayer->set_confirmed(true);
       }
-      if (topic.second.tlayer_lcm)
-      {
-        auto tlayer = pMonTopic->add_tlayer();
-        tlayer->set_type(eCAL::pb::tl_lcm);
-        tlayer->set_confirmed(true);
-      }
-      if (topic.second.tlayer_rtps)
-      {
-        auto tlayer = pMonTopic->add_tlayer();
-        tlayer->set_type(eCAL::pb::tl_rtps);
-        tlayer->set_confirmed(true);
-      }
       if (topic.second.tlayer_iceoryx)
       {
         auto tlayer = pMonTopic->add_tlayer();
diff --git a/ecal/core/src/mon/ecal_monitoring_impl.h b/ecal/core/src/mon/ecal_monitoring_impl.h
index 93eebde80a..1ed7edf795 100644
--- a/ecal/core/src/mon/ecal_monitoring_impl.h
+++ b/ecal/core/src/mon/ecal_monitoring_impl.h
@@ -78,11 +78,7 @@ namespace eCAL
         rclock                = 0;
         pid                   = 0;
         tlayer_ecal_udp_mc    = false;
-        tlayer_ecal_udp_uc    = false;
-        tlayer_ecal_udp_metal = false;
         tlayer_ecal_shm       = false;
-        tlayer_lcm            = false;
-        tlayer_rtps           = false;
         tlayer_iceoryx        = false;
         tlayer_inproc         = false;
         tsize                 = 0;
@@ -109,11 +105,7 @@ namespace eCAL
       std::string  ttype;
       std::string  tdesc;
       bool         tlayer_ecal_udp_mc;
-      bool         tlayer_ecal_udp_uc;
-      bool         tlayer_ecal_udp_metal;
       bool         tlayer_ecal_shm;
-      bool         tlayer_lcm;
-      bool         tlayer_rtps;
       bool         tlayer_iceoryx;
       bool         tlayer_inproc;
       int          tsize;
@@ -153,7 +145,8 @@ namespace eCAL
         dataread = 0;
         state_severity = 0;
         state_severity_level = 0;
-        tsync_mode = 0;
+        tsync_state = 0;
+        component_init_state = 0;
       };
 
       int            rclock;
@@ -170,7 +163,10 @@ namespace eCAL
       int            state_severity;
       int            state_severity_level;
       std::string    state_info;
-      int            tsync_mode;
+      int            tsync_state;
+      std::string    tsync_mod_name;
+      int            component_init_state;
+      std::string    component_init_info;
     };
     typedef eCAL::Util::CExpMap<std::string, SProcessMon> ProcessMonMapT;
 
diff --git a/ecal/core/src/pubsub/ecal_publisher.cpp b/ecal/core/src/pubsub/ecal_publisher.cpp
index c9ce755f34..75e4dd44a6 100644
--- a/ecal/core/src/pubsub/ecal_publisher.cpp
+++ b/ecal/core/src/pubsub/ecal_publisher.cpp
@@ -120,10 +120,7 @@ namespace eCAL
     // to construct befor eCAL::Initialize and so global config is not
     // existing while construction
     if (m_tlayer.sm_udp_mc  == TLayer::smode_none) m_tlayer.sm_udp_mc = TLayer::eSendMode(eCALPAR(PUB, USE_UDP_MC));
-    if (m_tlayer.sm_udp_uc  == TLayer::smode_none) m_tlayer.sm_udp_uc = TLayer::eSendMode(eCALPAR(PUB, USE_UDP_UC));
     if (m_tlayer.sm_shm     == TLayer::smode_none) m_tlayer.sm_shm    = TLayer::eSendMode(eCALPAR(PUB, USE_SHM));
-    if (m_tlayer.sm_lcm     == TLayer::smode_none) m_tlayer.sm_lcm    = TLayer::eSendMode(eCALPAR(PUB, USE_LCM));
-    if (m_tlayer.sm_rtps    == TLayer::smode_none) m_tlayer.sm_rtps   = TLayer::eSendMode(eCALPAR(PUB, USE_RTPS));
     if (m_tlayer.sm_inproc  == TLayer::smode_none) m_tlayer.sm_inproc = TLayer::eSendMode(eCALPAR(PUB, USE_INPROC));
 
     // create data writer
@@ -132,10 +129,7 @@ namespace eCAL
     m_datawriter->SetQOS(m_qos);
     // set transport layer
     m_datawriter->SetLayerMode(TLayer::tlayer_udp_mc,  m_tlayer.sm_udp_mc);
-    m_datawriter->SetLayerMode(TLayer::tlayer_udp_uc,  m_tlayer.sm_udp_uc);
     m_datawriter->SetLayerMode(TLayer::tlayer_shm,     m_tlayer.sm_shm);
-    m_datawriter->SetLayerMode(TLayer::tlayer_lcm,     m_tlayer.sm_lcm);
-    m_datawriter->SetLayerMode(TLayer::tlayer_rtps,    m_tlayer.sm_rtps);
     m_datawriter->SetLayerMode(TLayer::tlayer_inproc,  m_tlayer.sm_inproc);
     // create it
     if (!m_datawriter->Create(topic_name_, topic_type_, topic_desc_))
@@ -235,28 +229,24 @@ namespace eCAL
     case TLayer::tlayer_udp_mc:
       m_tlayer.sm_udp_mc = mode_;
       break;
-    case TLayer::tlayer_udp_uc:
-      m_tlayer.sm_udp_uc = mode_;
-      break;
     case TLayer::tlayer_shm:
       m_tlayer.sm_shm = mode_;
       break;
-    case TLayer::tlayer_lcm:
-      m_tlayer.sm_lcm = mode_;
-      break;
-    case TLayer::tlayer_rtps:
-      m_tlayer.sm_rtps = mode_;
+#ifdef ECAL_LAYER_ICEORYX
+    case TLayer::tlayer_iceoryx:
+      m_tlayer.sm_iceoryx = mode_;
       break;
+#endif /* ECAL_LAYER_ICEORYX */
     case TLayer::tlayer_inproc:
       m_tlayer.sm_inproc = mode_;
       break;
     case TLayer::tlayer_all:
-      m_tlayer.sm_udp_mc = mode_;
-      m_tlayer.sm_udp_uc = mode_;
-      m_tlayer.sm_shm    = mode_;
-      m_tlayer.sm_lcm    = mode_;
-      m_tlayer.sm_rtps   = mode_;
-      m_tlayer.sm_inproc = mode_;
+      m_tlayer.sm_udp_mc  = mode_;
+      m_tlayer.sm_shm     = mode_;
+#ifdef ECAL_LAYER_ICEORYX
+      m_tlayer.sm_iceoryx = mode_;
+#endif /* ECAL_LAYER_ICEORYX */
+      m_tlayer.sm_inproc  = mode_;
       break;
     default:
       break;
diff --git a/ecal/core/src/readwrite/ecal_reader.cpp b/ecal/core/src/readwrite/ecal_reader.cpp
index bad66d1645..4579d7e098 100644
--- a/ecal/core/src/readwrite/ecal_reader.cpp
+++ b/ecal/core/src/readwrite/ecal_reader.cpp
@@ -29,13 +29,7 @@
 #include "ecal_reader.h"
 
 #include "readwrite/ecal_reader_udp_mc.h"
-#include "readwrite/ecal_reader_udp_uc.h"
 #include "readwrite/ecal_reader_shm.h"
-#include "readwrite/ecal_reader_metal.h"
-#include "readwrite/ecal_reader_lcm.h"
-#ifdef ECAL_LAYER_FASTRTPS
-#include "readwrite/ecal_reader_rtps.h"
-#endif /* ECAL_LAYER_FASTRTPS */
 #ifdef ECAL_LAYER_ICEORYX
 #include "readwrite/ecal_reader_iceoryx.h"
 #endif /* ECAL_LAYER_ICEORYX */
@@ -81,11 +75,7 @@ namespace eCAL
                  m_use_ttype(true),
                  m_use_tdesc(true),
                  m_use_udp_mc_confirmed(false),
-                 m_use_udp_uc_confirmed(false),
-                 m_use_udp_metal_confirmed(false),
                  m_use_shm_confirmed(false),
-                 m_use_lcm_confirmed(false),
-                 m_use_rtps_confirmed(false),
                  m_use_iceoryx_confirmed(false),
                  m_use_inproc_confirmed(false),
                  m_created(false)
@@ -195,11 +185,7 @@ namespace eCAL
     m_rec_time                = std::chrono::steady_clock::time_point();
 
     m_use_udp_mc_confirmed    = false;
-    m_use_udp_uc_confirmed    = false;
-    m_use_udp_metal_confirmed = false;
     m_use_shm_confirmed       = false;
-    m_use_lcm_confirmed       = false;
-    m_use_rtps_confirmed      = false;
     m_use_iceoryx_confirmed   = false;
     m_use_inproc_confirmed    = false;
 
@@ -214,38 +200,12 @@ namespace eCAL
       CMulticastLayer::Get()->InitializeLayer();
     }
 
-    // start ecal udp unicast layer
-    if (eCALPAR(NET, UDP_UC_REC_ENABLED))
-    {
-      CUnicastLayer::Get()->InitializeLayer();
-    }
-
     // start ecal shared memory layer
     if (eCALPAR(NET, SHM_REC_ENABLED))
     {
       CSHMLayer::Get()->InitializeLayer();
     }
 
-    // start ecal udp metal layer
-    if (eCALPAR(NET, METAL_REC_ENABLED))
-    {
-      CMetalLayer::Get()->InitializeLayer();
-    }
-
-    // start udp lcm layer
-    if (eCALPAR(NET, LCM_REC_ENABLED))
-    {
-      CLcmLayer::Get()->InitializeLayer();
-    }
-
-#ifdef ECAL_LAYER_FASTRTPS
-    // start rtps layer
-    if (eCALPAR(NET, RTPS_REC_ENABLED))
-    {
-      CRtpsLayer::Get()->InitializeLayer();
-    }
-#endif /*ECAL_LAYER_FASTRTPS*/
-
 #ifdef ECAL_LAYER_ICEORYX
     // start iceoryx layer
     if (eCALPAR(NET, ICEORYX_REC_ENABLED))
@@ -269,38 +229,12 @@ namespace eCAL
       CMulticastLayer::Get()->StartLayer(m_topic_name, m_qos);
     }
 
-    // start ecal udp unicast layer
-    if (eCALPAR(NET, UDP_UC_REC_ENABLED))
-    {
-      CUnicastLayer::Get()->StartLayer(m_topic_name, m_qos);
-    }
-
     // start ecal shared memory layer
     if (eCALPAR(NET, SHM_REC_ENABLED))
     {
       CSHMLayer::Get()->StartLayer(m_topic_name, m_qos);
     }
 
-    // start ecal udp metal layer
-    if (eCALPAR(NET, METAL_REC_ENABLED))
-    {
-      CMetalLayer::Get()->StartLayer(m_topic_name, m_qos);
-    }
-
-    // start udp lcm layer
-    if (eCALPAR(NET, LCM_REC_ENABLED))
-    {
-      CLcmLayer::Get()->StartLayer(m_topic_name, m_qos);
-    }
-
-#ifdef ECAL_LAYER_FASTRTPS
-    // start rtps layer
-    if (eCALPAR(NET, RTPS_REC_ENABLED))
-    {
-      CRtpsLayer::Get()->StartLayer(m_topic_name, m_qos);
-    }
-#endif /*ECAL_LAYER_FASTRTPS*/
-
 #ifdef ECAL_LAYER_ICEORYX
     // start iceoryx layer
     if (eCALPAR(NET, ICEORYX_REC_ENABLED))
@@ -324,38 +258,12 @@ namespace eCAL
       CMulticastLayer::Get()->StopLayer(m_topic_name);
     }
 
-    // stop ecal udp unicast layer
-    if (eCALPAR(NET, UDP_UC_REC_ENABLED))
-    {
-      CUnicastLayer::Get()->StopLayer(m_topic_name);
-    }
-
     // stop ecal shared memory layer
     if (eCALPAR(NET, SHM_REC_ENABLED))
     {
       CSHMLayer::Get()->StopLayer(m_topic_name);
     }
 
-    // stop ecal udp metal layer
-    if (eCALPAR(NET, METAL_REC_ENABLED))
-    {
-      CMetalLayer::Get()->StopLayer(m_topic_name);
-    }
-
-    // stop udp lcm layer
-    if (eCALPAR(NET, LCM_REC_ENABLED))
-    {
-      CLcmLayer::Get()->StopLayer(m_topic_name);
-    }
-
-#ifdef ECAL_LAYER_FASTRTPS
-    // stop rtps layer
-    if (eCALPAR(NET, RTPS_REC_ENABLED))
-    {
-      CRtpsLayer::Get()->StopLayer(m_topic_name);
-    }
-#endif /*ECAL_LAYER_FASTRTPS*/
-
 #ifdef ECAL_LAYER_ICEORYX
     // stop iceoryx layer
     if (eCALPAR(NET, ICEORYX_REC_ENABLED))
@@ -395,14 +303,6 @@ namespace eCAL
       tlayer->set_confirmed(m_use_udp_mc_confirmed);
       tlayer->set_par("");
     }
-    // udp unicast layer
-    {
-      auto tlayer = ecal_reg_sample_mutable_topic->add_tlayer();
-      tlayer->set_type(eCAL::pb::tl_ecal_udp_uc);
-      tlayer->set_version(1);
-      tlayer->set_confirmed(m_use_udp_uc_confirmed);
-      tlayer->set_par("");
-    }
     // shm layer
     {
       auto tlayer = ecal_reg_sample_mutable_topic->add_tlayer();
@@ -411,22 +311,6 @@ namespace eCAL
       tlayer->set_confirmed(m_use_shm_confirmed);
       tlayer->set_par("");
     }
-    // lcm layer
-    {
-      auto tlayer = ecal_reg_sample_mutable_topic->add_tlayer();
-      tlayer->set_type(eCAL::pb::tl_lcm);
-      tlayer->set_version(1);
-      tlayer->set_confirmed(m_use_lcm_confirmed);
-      tlayer->set_par("");
-    }
-    // rtps layer
-    {
-      auto tlayer = ecal_reg_sample_mutable_topic->add_tlayer();
-      tlayer->set_type(eCAL::pb::tl_rtps);
-      tlayer->set_version(1);
-      tlayer->set_confirmed(m_use_rtps_confirmed);
-      tlayer->set_par("");
-    }
     // iceoryx layer
     {
       auto tlayer = ecal_reg_sample_mutable_topic->add_tlayer();
@@ -533,11 +417,7 @@ namespace eCAL
 
     // store receive layer
     m_use_udp_mc_confirmed    |= layer_ == eCAL::pb::tl_ecal_udp_mc;
-    m_use_udp_uc_confirmed    |= layer_ == eCAL::pb::tl_ecal_udp_uc;
-    m_use_udp_metal_confirmed |= layer_ == eCAL::pb::tl_ecal_udp_metal;
     m_use_shm_confirmed       |= layer_ == eCAL::pb::tl_ecal_shm;
-    m_use_lcm_confirmed       |= layer_ == eCAL::pb::tl_lcm;
-    m_use_rtps_confirmed      |= layer_ == eCAL::pb::tl_rtps;
     m_use_iceoryx_confirmed   |= layer_ == eCAL::pb::tl_iceoryx;
     m_use_inproc_confirmed    |= layer_ == eCAL::pb::tl_inproc;
 
@@ -752,33 +632,11 @@ namespace eCAL
       CMulticastLayer::Get()->ApplyLayerParameter(par);
       break;
     }
-    case eCAL::pb::tl_ecal_udp_uc:
-    {
-      CUnicastLayer::Get()->ApplyLayerParameter(par);
-      break;
-    }
-    case eCAL::pb::tl_ecal_udp_metal:
-    {
-      CMetalLayer::Get()->ApplyLayerParameter(par);
-      break;
-    }
     case eCAL::pb::tl_ecal_shm:
     {
       CSHMLayer::Get()->ApplyLayerParameter(par);
       break;
     }
-    case eCAL::pb::tl_lcm:
-    {
-      CLcmLayer::Get()->ApplyLayerParameter(par);
-      break;
-    }
-#ifdef ECAL_LAYER_FASTRTPS
-    case eCAL::pb::tl_rtps:
-    {
-      CRtpsLayer::Get()->ApplyLayerParameter(par);
-      break;
-    }
-#endif /* ECAL_LAYER_FASTRTPS */
 #ifdef ECAL_LAYER_ICEORYX
     case eCAL::pb::tl_iceoryx:
     {
diff --git a/ecal/core/src/readwrite/ecal_reader.h b/ecal/core/src/readwrite/ecal_reader.h
index 3833a436eb..1744847b15 100644
--- a/ecal/core/src/readwrite/ecal_reader.h
+++ b/ecal/core/src/readwrite/ecal_reader.h
@@ -159,11 +159,7 @@ namespace eCAL
     bool                                      m_use_tdesc;
 
     bool                                      m_use_udp_mc_confirmed;
-    bool                                      m_use_udp_uc_confirmed;
-    bool                                      m_use_udp_metal_confirmed;
     bool                                      m_use_shm_confirmed;
-    bool                                      m_use_lcm_confirmed;
-    bool                                      m_use_rtps_confirmed;
     bool                                      m_use_iceoryx_confirmed;
     bool                                      m_use_inproc_confirmed;
 
diff --git a/ecal/core/src/readwrite/ecal_reader_lcm.cpp b/ecal/core/src/readwrite/ecal_reader_lcm.cpp
deleted file mode 100644
index 6fd08d4aa9..0000000000
--- a/ecal/core/src/readwrite/ecal_reader_lcm.cpp
+++ /dev/null
@@ -1,193 +0,0 @@
-/* ========================= eCAL LICENSE =================================
- *
- * Copyright (C) 2016 - 2019 Continental Corporation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * ========================= eCAL LICENSE =================================
-*/
-
-/**
- * @brief  eCAL lcm reader
-**/
-
-#include "ecal_config_hlp.h"
-#include "ecal_global_accessors.h"
-#include "mon/ecal_monitoring_def.h"
-
-#include "pubsub/ecal_subgate.h"
-#include "readwrite/ecal_reader_lcm.h"
-
-namespace eCAL
-{
-  template<> std::shared_ptr<CLcmLayer> CReaderLayer<CLcmLayer>::layer(nullptr);
-
-  //////////////////////////////////////////////////////////////////
-  // CLcmSampleReceiver
-  //////////////////////////////////////////////////////////////////
-  static void lcm_subscriber(lcmlite_sub_t* /*lcm_*/, const char* channel_, const void* buf_, int len_, void* user_)
-  {
-    eCAL::pb::Sample ecal_sample;
-    auto ecal_sample_mutable_topic = ecal_sample.mutable_topic();
-
-    // create new sample
-    ecal_sample.set_cmd_type(eCAL::pb::bct_set_sample);
-    ecal_sample_mutable_topic->set_hname("");
-    ecal_sample_mutable_topic->set_tname(channel_);
-
-    // set layer
-    auto layer = ecal_sample_mutable_topic->add_tlayer();
-    layer->set_type(eCAL::pb::eTLayerType::tl_ecal_udp_mc);
-    layer->set_confirmed(true);
-
-    // append content
-    auto ecal_sample_mutable_content = ecal_sample.mutable_content();
-    ecal_sample_mutable_content->set_clock(0);
-    ecal_sample_mutable_content->set_time(Time::GetMicroSeconds());
-    ecal_sample_mutable_content->set_size(static_cast<google::protobuf::int32>(len_));
-    ecal_sample_mutable_content->set_payload(buf_, static_cast<size_t>(len_));
-
-    if (g_subgate()) g_subgate()->ApplySample(ecal_sample, eCAL::pb::eTLayerType::tl_lcm);
-    static_cast<CDataReaderLCM*>(user_)->ApplyLcmPublisher(std::string(channel_), static_cast<size_t>(len_));
-  }
-
-  CDataReaderLCM::CDataReaderLCM()
-  {
-    SReceiverAttr attr;
-    attr.ipaddr     = NET_UDP_MULTICAST_GROUP_LCM;
-    attr.port       = NET_UDP_MULTICAST_PORT_LCM;
-    attr.loopback   = true;
-    attr.rcvbuf     = eCALPAR(NET, UDP_MULTICAST_RCVBUF);
-    attr.local_only = false;
-    m_receiver.Create(attr);
-
-    m_msg_buffer.resize(LCM3_MAX_PACKET_SIZE);
-
-    m_lcm = std::make_shared<lcmlite_sub_t>();
-    lcmlite_sub_init(m_lcm.get());
-
-    static char wcard[]         = ".*";
-    m_lcm_subscription.channel  = wcard;
-    m_lcm_subscription.callback = lcm_subscriber;
-    m_lcm_subscription.user     = this;
-    lcmlite_subscribe(m_lcm.get(), &m_lcm_subscription);
-  }
-
-  int CDataReaderLCM::ApplyLcmPublisher(const std::string & topic_name_, size_t topic_size_)
-  {
-    std::lock_guard<std::mutex> lock(m_lcm_pub_map_sync);
-    auto topic_iter = m_lcm_pub_map.find(topic_name_);
-    if (topic_iter == m_lcm_pub_map.end())
-    {
-      ExtTopic topic;
-      topic.direction = ExtTopic::publisher;
-      topic.tsize = static_cast<int>(topic_size_);
-      m_lcm_pub_map[topic_name_] = topic;
-    }
-    else
-    {
-      auto ttime = std::chrono::steady_clock::now();
-      auto ttime_old = topic_iter->second.ttime;
-
-      topic_iter->second.tsize = static_cast<int>(topic_size_);
-      topic_iter->second.tclock = topic_iter->second.tclock++;
-      topic_iter->second.ttime = ttime;
-      topic_iter->second.dtime = ttime - ttime_old;
-      if ((ttime_old != std::chrono::steady_clock::time_point(std::chrono::nanoseconds(0)))
-        && ((ttime - ttime_old) > std::chrono::nanoseconds(0)))
-      {
-        topic_iter->second.dfreq = static_cast<int>(1000000000 / std::chrono::duration_cast<std::chrono::microseconds>(ttime - ttime_old).count());
-      }
-      topic_iter->second.updated = true;
-    }
-    return 0;
-  }
-
-  int CDataReaderLCM::Monitor()
-  {
-    auto time = std::chrono::steady_clock::now();
-
-    // remove outdated topics
-    ExtMapT topic_map;
-    {
-      std::lock_guard<std::mutex> lock(m_lcm_pub_map_sync);
-      auto iter = m_lcm_pub_map.begin();
-      while (iter != m_lcm_pub_map.end())
-      {
-        if (iter->second.updated)
-        {
-          iter->second.updated = false;
-          topic_map[iter->first] = iter->second;
-        }
-
-        if (iter->second.ttime > std::chrono::steady_clock::time_point(std::chrono::microseconds(0)))
-        {
-          std::chrono::nanoseconds timeout = time - iter->second.ttime;
-          if (timeout > std::chrono::milliseconds(CMN_REGISTRATION_TO))
-          {
-            iter = m_lcm_pub_map.erase(iter);
-            if (iter == m_lcm_pub_map.end()) break;
-          }
-        }
-        iter++;
-      }
-    }
-
-    if (!g_monitoring()) return 0;
-
-    // register lcm process "Any (LCM)"
-    std::string host_name(eCAL::Process::GetHostName());
-//    if (!topic_map.empty())
-    {
-      eCAL::pb::Sample ecal_process;
-      auto ecal_process_mutable_process = ecal_process.mutable_process();
-      ecal_process.set_cmd_type(eCAL::pb::bct_reg_process);
-      ecal_process_mutable_process->set_hname(host_name);
-      ecal_process_mutable_process->set_pname("Any (LCM)");
-      ecal_process_mutable_process->set_uname("Any (LCM)");
-      g_monitoring()->ApplySample(ecal_process);
-    }
-
-    // register lcm publisher
-    eCAL::pb::Sample ecal_publisher;
-    for (auto iter : topic_map)
-    {
-      ecal_publisher.Clear();
-      ecal_publisher.set_cmd_type(eCAL::pb::bct_reg_publisher);
-      auto ecal_publisher_mutable_topic = ecal_publisher.mutable_topic();
-      ecal_publisher_mutable_topic->set_hname(host_name);
-      ecal_publisher_mutable_topic->set_pname("Any (LCM)");
-      ecal_publisher_mutable_topic->set_uname("Any (LCM)");
-      ecal_publisher_mutable_topic->set_tname(iter.first);
-      ecal_publisher_mutable_topic->set_tsize(iter.second.tsize);
-      ecal_publisher_mutable_topic->set_ttype("lcm:binary");
-      ecal_publisher_mutable_topic->set_dclock(iter.second.tclock);
-      ecal_publisher_mutable_topic->set_dfreq(iter.second.dfreq);
-      g_monitoring()->ApplySample(ecal_publisher);
-    }
-
-    return 0;
-  }
-
-  int CDataReaderLCM::Receive()
-  {
-    // wait for any incoming message
-    struct sockaddr_in src_addr;
-    size_t recv_len = m_receiver.Receive(m_msg_buffer.data(), m_msg_buffer.size(), 10, &src_addr);
-    if (recv_len > 0)
-    {
-      lcmlite_receive_packet(m_lcm.get(), m_msg_buffer.data(), static_cast<int>(recv_len), src_addr.sin_addr.s_addr | ((uint64_t)src_addr.sin_port << 32)); //-V112
-    }
-    return 0;
-  }
-};
diff --git a/ecal/core/src/readwrite/ecal_reader_lcm.h b/ecal/core/src/readwrite/ecal_reader_lcm.h
deleted file mode 100644
index 99bc4015e3..0000000000
--- a/ecal/core/src/readwrite/ecal_reader_lcm.h
+++ /dev/null
@@ -1,103 +0,0 @@
-/* ========================= eCAL LICENSE =================================
- *
- * Copyright (C) 2016 - 2019 Continental Corporation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * ========================= eCAL LICENSE =================================
-*/
-
-/**
- * @brief  eCAL lcm reader
-**/
-
-#pragma once
-
-#include "io/rcv_sample.h"
-#include "io/udp_receiver.h"
-#include "readwrite/exttopic.h"
-#include "readwrite/ecal_reader_layer.h"
-
-#include "ecal_thread.h"
-
-#include "lcm/lcmlite.h"
-
-#include <mutex>
-#include <unordered_map>
-
-namespace eCAL
-{
-  // ecal udp lcm reader
-  class CDataReaderLCM
-  {
-  public:
-    CDataReaderLCM();
-
-    int ApplyLcmPublisher(const std::string& topic_name_, size_t topic_size_);
-
-    int Monitor();
-    int Receive();
-
-  protected:
-    std::shared_ptr<lcmlite_sub_t>  m_lcm;
-    lcmlite_subscription            m_lcm_subscription;
-    std::vector<char>               m_msg_buffer;
-    std::mutex                      m_lcm_pub_map_sync;
-    ExtMapT                         m_lcm_pub_map;
-    CUDPReceiver                    m_receiver;
-  };
-
-  // ecal udp lcm data layer
-  class CLcmLayer : public CReaderLayer<CLcmLayer>
-  {
-  public:
-    CLcmLayer() : initialzed(false), started(false) {};
-    ~CLcmLayer()
-    {
-      mon_thread.Stop();
-      rec_thread.Stop();
-    };
-
-    void InitializeLayer()
-    {
-      if (initialzed) return;
-      // we need to start monitoring and data layer thread
-      // because the monitoring information is on the data
-      // layer in lcm
-      mon_thread.Start(1000, std::bind(&CDataReaderLCM::Monitor, &reader));
-      rec_thread.Start(0, std::bind(&CDataReaderLCM::Receive, &reader));
-      initialzed = true;
-    }
-
-    void StartLayer(std::string& /*topic_name_*/, QOS::SReaderQOS /*qos_*/)
-    {
-      if (started) return;
-      started = true;
-    }
-
-    void StopLayer(std::string& /*topic_name_*/)
-    {
-    }
-
-    void ApplyLayerParameter(SReaderLayerPar& /*par_*/)
-    {
-    }
-
-  private:
-    bool            initialzed;
-    bool            started;
-    CThread         mon_thread;
-    CThread         rec_thread;
-    CDataReaderLCM  reader;
-  };
-};
diff --git a/ecal/core/src/readwrite/ecal_reader_metal.cpp b/ecal/core/src/readwrite/ecal_reader_metal.cpp
deleted file mode 100644
index dbcabf58a8..0000000000
--- a/ecal/core/src/readwrite/ecal_reader_metal.cpp
+++ /dev/null
@@ -1,92 +0,0 @@
-/* ========================= eCAL LICENSE =================================
- *
- * Copyright (C) 2016 - 2019 Continental Corporation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * ========================= eCAL LICENSE =================================
-*/
-
-/**
- * @brief  eCAL metal reader
-**/
-
-#include "ecal_def.h"
-#include "ecal_config_hlp.h"
-#include "ecal_reggate.h"
-
-#include "mon/ecal_monitoring_def.h"
-#include "pubsub/ecal_subgate.h"
-#include "readwrite/ecal_reader_metal.h"
-
-namespace eCAL
-{
-  template<> std::shared_ptr<CMetalLayer> CReaderLayer<CMetalLayer>::layer(nullptr);
-
-  //////////////////////////////////////////////////////////////////
-  // CMetalSampleReceiver
-  //////////////////////////////////////////////////////////////////
-  CDataReaderMetal::CDataReaderMetal()
-  {
-    // set expiration time for the metal publisher map
-    // we use refresh registration time to "emulate" a metal
-    // registration if the metal publisher is not using
-    // eCAL metal RefreshRegistration API
-    std::chrono::milliseconds registration_timeout(eCALPAR(CMN, REGISTRATION_REFRESH));
-    m_pub_map.set_expiration(registration_timeout);
-  }
-
-  size_t CDataReaderMetal::ApplySample(const eCAL::pb::Sample& ecal_sample_, eCAL::pb::eTLayerType /*layer_*/)
-  {
-    switch (ecal_sample_.cmd_type())
-    {
-    case eCAL::pb::bct_reg_process:
-    case eCAL::pb::bct_reg_publisher:
-    case eCAL::pb::bct_reg_subscriber:
-    {
-      // okay the user decided to send registering informations
-      // on the data layer, maybe there is a requirement to use
-      // one socket for registration and data only
-      // so we forward this sample to the registration and
-      // monitoring gate
-      if (g_reggate()) g_reggate()->ApplySample(ecal_sample_);
-      if (g_monitoring()) g_monitoring()->ApplySample(ecal_sample_);
-    }
-    break;
-    case eCAL::pb::bct_set_sample:
-    {
-      // (re)register external metal publication to activate data reader
-      // this is needed if eCALMetal publishing application is not
-      // serving registration layer
-      // we use the expiration map because we do not have an
-      // expiration set container available currently
-      auto tname = ecal_sample_.topic().tname();
-      auto iter = m_pub_map.find(tname);
-      if (iter == m_pub_map.end())
-      {
-        m_pub_map[tname].clear();
-        if (g_subgate()) g_subgate()->ApplyExtPubRegistration(ecal_sample_);
-      }
-      // remove timeout publications
-      m_pub_map.remove_deprecated();
-
-      // forward sample to common udp sample receiver
-      return(CDataReaderUDP::ApplySample(ecal_sample_, eCAL::pb::eTLayerType::tl_ecal_udp_metal));
-    }
-    break;
-    default:
-      break;
-    }
-    return 0;
-  }
-};
diff --git a/ecal/core/src/readwrite/ecal_reader_metal.h b/ecal/core/src/readwrite/ecal_reader_metal.h
deleted file mode 100644
index bfdb5359ca..0000000000
--- a/ecal/core/src/readwrite/ecal_reader_metal.h
+++ /dev/null
@@ -1,96 +0,0 @@
-/* ========================= eCAL LICENSE =================================
- *
- * Copyright (C) 2016 - 2019 Continental Corporation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * ========================= eCAL LICENSE =================================
-*/
-
-/**
- * @brief  eCAL metal reader
-**/
-
-#pragma once
-
-#include "ecal_expmap.h"
-
-#include "io/rcv_sample.h"
-#include "io/udp_receiver.h"
-
-#include "ecal_config_hlp.h"
-#include "ecal_thread.h"
-
-#include "readwrite/ecal_reader_layer.h"
-#include "readwrite/ecal_reader_udp.h"
-
-#include <string>
-
-namespace eCAL
-{
-  // ecal udp metal reader
-  class CDataReaderMetal : public CDataReaderUDP
-  {
-  public:
-    CDataReaderMetal();
-
-    bool HasSample(const std::string& /* sample_name_ */) { return(true); };
-    size_t ApplySample(const eCAL::pb::Sample& ecal_sample_, eCAL::pb::eTLayerType layer_);
-
-  private:
-    Util::CExpMap<std::string, std::string> m_pub_map;
-  };
-
-  // ecal udp metal data layer
-  class CMetalLayer : public CReaderLayer<CMetalLayer>
-  {
-  public:
-    CMetalLayer() : started(false) {};
-    ~CMetalLayer()
-    {
-      thread.Stop();
-    };
-
-    void InitializeLayer()
-    {
-      SReceiverAttr attr;
-      attr.ipaddr     = eCALPAR(NET, UDP_MULTICAST_GROUP_METAL);
-      attr.port       = eCALPAR(NET, UDP_MULTICAST_PORT_METAL);
-      attr.loopback   = true;
-      attr.rcvbuf     = eCALPAR(NET, UDP_MULTICAST_RCVBUF);
-      attr.local_only = false;
-      rcv.Create(attr);
-    }
-
-    void StartLayer(std::string& /*topic_name_*/, QOS::SReaderQOS /*qos_*/)
-    {
-      if (started) return;
-      thread.Start(0, std::bind(&CDataReaderUDP::Receive, &reader, &rcv));
-      started = true;
-    }
-
-    void StopLayer(std::string& /*topic_name_*/)
-    {
-    }
-
-    void ApplyLayerParameter(SReaderLayerPar& /*par_*/)
-    {
-    }
-
-  private:
-    bool              started;
-    CUDPReceiver      rcv;
-    CThread           thread;
-    CDataReaderMetal  reader;
-  };
-};
diff --git a/ecal/core/src/readwrite/ecal_reader_rtps.cpp b/ecal/core/src/readwrite/ecal_reader_rtps.cpp
deleted file mode 100644
index 79224a40dc..0000000000
--- a/ecal/core/src/readwrite/ecal_reader_rtps.cpp
+++ /dev/null
@@ -1,162 +0,0 @@
-/* ========================= eCAL LICENSE =================================
- *
- * Copyright (C) 2016 - 2019 Continental Corporation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * ========================= eCAL LICENSE =================================
-*/
-
-/**
- * @brief  eCAL rtps reader
-**/
-
-#include "ecal_global_accessors.h"
-
-#include "pubsub/ecal_subgate.h"
-#include "readwrite/ecal_reader_rtps.h"
-
-#include <fastrtps/Domain.h>
-#include <fastrtps/participant/Participant.h>
-#include <fastrtps/subscriber/Subscriber.h>
-
-eprosima::fastrtps::Participant* GetRTPSParticipant();
-
-namespace eCAL
-{
-  template<> std::shared_ptr<CRtpsLayer> CReaderLayer<CRtpsLayer>::layer(nullptr);
-
-  //////////////////////////////////////////////////////////////////
-  // CDataReaderRtps
-  //////////////////////////////////////////////////////////////////
-  CDataReaderRtps::CDataReaderRtps()
-  {
-  }
-
-  bool CDataReaderRtps::CreateRtpsSub(const std::string& topic_name_, const QOS::SReaderQOS& qos_)
-  {
-    std::lock_guard<std::mutex> lock(m_sub_map_sync);
-
-    auto iter = m_sub_map.find(topic_name_);
-    if (iter != m_sub_map.end()) return false;
-
-    auto sub = new CSubscriberRtps(topic_name_, qos_);
-    m_sub_map[topic_name_] = sub;
-
-    return true;
-  }
-
-  bool CDataReaderRtps::DestroyRtpsSub(const std::string& topic_name_)
-  {
-    std::lock_guard<std::mutex> lock(m_sub_map_sync);
-
-    auto iter = m_sub_map.find(topic_name_);
-    if (iter != m_sub_map.end()) return false;
-
-    delete iter->second;
-    m_sub_map.erase(iter);
-
-    return true;
-  }
-
-  //////////////////////////////////////////////////////////////////
-  // CSubscriberRtps
-  //////////////////////////////////////////////////////////////////
-  CDataReaderRtps::CSubscriberRtps::CSubscriberRtps(const std::string& topic_name_, QOS::SReaderQOS qos_)
-  {
-    if (GetRTPSParticipant() == nullptr) return;
-
-    // rtps reader default attributes
-    m_attr.topic.topicName                           = topic_name_;
-    m_attr.topic.topicKind                           = eprosima::fastrtps::rtps::NO_KEY;
-    m_attr.topic.topicDataType                       = m_string_type.getName();
-    m_attr.topic.historyQos.kind                     = eprosima::fastrtps::KEEP_LAST_HISTORY_QOS;
-    m_attr.topic.historyQos.depth                    = 8;
-    m_attr.topic.resourceLimitsQos.max_samples       = 32; //-V112
-    m_attr.topic.resourceLimitsQos.allocated_samples = 16;
-    m_attr.qos.m_reliability.kind                    = eprosima::fastrtps::BEST_EFFORT_RELIABILITY_QOS;
-    m_attr.historyMemoryPolicy                       = eprosima::fastrtps::rtps::PREALLOCATED_WITH_REALLOC_MEMORY_MODE;
-    m_attr.qos.m_partition.push_back("rt");
-
-    // store qos
-    m_qos = qos_;
-
-    // qos HistroryKind
-    switch (m_qos.history_kind)
-    {
-    case QOS::keep_last_history_qos:
-      m_attr.topic.historyQos.kind  = eprosima::fastrtps::KEEP_LAST_HISTORY_QOS;
-      m_attr.topic.historyQos.depth = m_qos.history_kind_depth;
-      break;
-    case QOS::keep_all_history_qos:
-      m_attr.topic.historyQos.kind  = eprosima::fastrtps::KEEP_ALL_HISTORY_QOS;
-      break;
-    default:
-      break;
-    }
-
-    // qos Reliability
-    switch (m_qos.reliability)
-    {
-    case QOS::reliable_reliability_qos:
-      m_attr.qos.m_reliability.kind = eprosima::fastrtps::RELIABLE_RELIABILITY_QOS;
-      break;
-    case QOS::best_effort_reliability_qos:
-      m_attr.qos.m_reliability.kind = eprosima::fastrtps::BEST_EFFORT_RELIABILITY_QOS;
-      break;
-    default:
-      break;
-    }
-
-    // create subscriber
-    m_subscriber = eprosima::fastrtps::Domain::createSubscriber(GetRTPSParticipant(), m_attr, (eprosima::fastrtps::SubscriberListener*)&m_listener);
-  }
-
-  CDataReaderRtps::CSubscriberRtps::~CSubscriberRtps()
-  {
-    if (!m_subscriber) return;
-
-    // destroy subscriber
-    eprosima::fastrtps::Domain::removeSubscriber(m_subscriber);
-    m_subscriber = nullptr;
-  }
-
-  void CDataReaderRtps::CSubscriberRtps::SubListener::onSubscriptionMatched(eprosima::fastrtps::Subscriber* /*sub_*/, eprosima::fastrtps::rtps::MatchingInfo& info_)
-  {
-    if (info_.status == eprosima::fastrtps::rtps::MATCHED_MATCHING)
-    {
-      n_matched++;
-      Logging::Log(log_level_debug1, "CDataReaderRTPS::Subscriber matched.");
-    }
-    else
-    {
-      n_matched--;
-      Logging::Log(log_level_debug1, "CDataReaderRTPS::Subscriber unmatched.");
-    }
-  }
-
-  void CDataReaderRtps::CSubscriberRtps::SubListener::onNewDataMessage(eprosima::fastrtps::Subscriber* sub_)
-  {
-    if (sub_->takeNextData((void*)&m_string_msg, &m_info))
-    {
-      if (m_info.sampleKind == eprosima::fastrtps::rtps::ALIVE)
-      {
-        // count received samples
-        this->n_samples++;
-
-        // apply data to subscriber gate
-        if (g_subgate()) g_subgate()->ApplySample(sub_->getAttributes().topic.topicName, m_string_msg.tid(), m_string_msg.payload().data(), m_string_msg.payload().size(), m_string_msg.id(), m_string_msg.clock(), m_string_msg.time(), static_cast<size_t>(m_string_msg.hash()), eCAL::pb::eTLayerType::tl_rtps);
-      }
-    }
-  }
-};
diff --git a/ecal/core/src/readwrite/ecal_reader_rtps.h b/ecal/core/src/readwrite/ecal_reader_rtps.h
deleted file mode 100644
index 29cafe1357..0000000000
--- a/ecal/core/src/readwrite/ecal_reader_rtps.h
+++ /dev/null
@@ -1,114 +0,0 @@
-/* ========================= eCAL LICENSE =================================
- *
- * Copyright (C) 2016 - 2019 Continental Corporation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * ========================= eCAL LICENSE =================================
-*/
-
-/**
- * @brief  eCAL rtps reader
-**/
-
-#pragma once
-
-#include <ecal/ecal.h>
-
-#include <fastrtps/attributes/SubscriberAttributes.h>
-#include <fastrtps/subscriber/SubscriberListener.h>
-#include <fastrtps/subscriber/SampleInfo.h>
-
-#include "readwrite/ecal_reader_layer.h"
-#include "readwrite/fastrtps/string_message_PubSubTypes.h"
-
-#include <memory>
-#include <string>
-#include <unordered_map>
-
-namespace eCAL
-{
-  // ecal rtps reader
-  class CDataReaderRtps
-  {
-  public:
-    CDataReaderRtps();
-
-    bool CreateRtpsSub(const std::string& topic_name_, const QOS::SReaderQOS& qos_);
-    bool DestroyRtpsSub(const std::string& topic_name_);
-
-  protected:
-    // rtps subscriber
-    class CSubscriberRtps
-    {
-    public:
-      CSubscriberRtps(const std::string& topic_name_, QOS::SReaderQOS qos_);
-      ~CSubscriberRtps();
-
-      // rtps listener
-      class SubListener :public eprosima::fastrtps::SubscriberListener
-      {
-      public:
-        SubListener() : n_matched(0), n_samples(0) {};
-        ~SubListener() {};
-
-        void onSubscriptionMatched(eprosima::fastrtps::Subscriber* sub_, eprosima::fastrtps::rtps::MatchingInfo& info_);
-        void onNewDataMessage(eprosima::fastrtps::Subscriber* sub_);
-
-        string_message_                   m_string_msg;
-        eprosima::fastrtps::SampleInfo_t  m_info;
-        int                               n_matched;
-        uint32_t                          n_samples;
-      };
-
-    protected:
-      QOS::SReaderQOS                           m_qos;
-      eprosima::fastrtps::Subscriber*           m_subscriber;
-      class SubListener                         m_listener;
-      string_message_PubSubType                 m_string_type;
-      string_message_                           m_string_msg;
-      eprosima::fastrtps::SubscriberAttributes  m_attr;
-    };
-
-    std::mutex                                         m_sub_map_sync;
-    std::unordered_map<std::string, CSubscriberRtps*>  m_sub_map;
-  };
-
-  // ecal rtps data layer
-  class CRtpsLayer : public CReaderLayer<CRtpsLayer>
-  {
-  public:
-    CRtpsLayer() {};
-
-    void InitializeLayer()
-    {
-    }
-
-    void StartLayer(std::string& topic_name_, QOS::SReaderQOS qos_)
-    {
-      reader.CreateRtpsSub(topic_name_, qos_);
-    }
-
-    void StopLayer(std::string& topic_name_)
-    {
-      reader.DestroyRtpsSub(topic_name_);
-    }
-
-    void ApplyLayerParameter(SReaderLayerPar& /*par_*/)
-    {
-    }
-
-  private:
-    CDataReaderRtps reader;
-  };
-};
diff --git a/ecal/core/src/readwrite/ecal_reader_udp_uc.h b/ecal/core/src/readwrite/ecal_reader_udp_uc.h
deleted file mode 100644
index 8a0045d05e..0000000000
--- a/ecal/core/src/readwrite/ecal_reader_udp_uc.h
+++ /dev/null
@@ -1,80 +0,0 @@
-/* ========================= eCAL LICENSE =================================
- *
- * Copyright (C) 2016 - 2019 Continental Corporation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * ========================= eCAL LICENSE =================================
-*/
-
-/**
- * @brief  eCAL udp unicast reader
-**/
-
-#pragma once
-
-#include "readwrite/ecal_reader_udp.h"
-#include "readwrite/ecal_reader_layer.h"
-
-#include "ecal_config_hlp.h"
-#include "ecal_thread.h"
-
-#include <memory>
-#include <string>
-
-namespace eCAL
-{
-  // ecal udp unicast data layer
-  class CUnicastLayer : public CReaderLayer<CUnicastLayer>
-  {
-  public:
-    CUnicastLayer() : started(false) {};
-    ~CUnicastLayer()
-    {
-      thread.Stop();
-    };
-
-    void InitializeLayer()
-    {
-      SReceiverAttr attr;
-      attr.ipaddr     = eCALPAR(NET, UDP_UNICAST_IPADDR);
-      attr.port       = eCALPAR(NET, UDP_UNICAST_PORT);
-      attr.unicast    = true;
-      attr.loopback   = true;
-      attr.rcvbuf     = eCALPAR(NET, UDP_MULTICAST_RCVBUF);
-      attr.local_only = false;
-      rcv.Create(attr);
-    }
-
-    void StartLayer(std::string& /*topic_name_*/, QOS::SReaderQOS /*qos_*/)
-    {
-      if (started) return;
-      thread.Start(0, std::bind(&CDataReaderUDP::Receive, &reader, &rcv));
-      started = true;
-    }
-
-    void StopLayer(std::string& /*topic_name_*/)
-    {
-    }
-
-    void ApplyLayerParameter(SReaderLayerPar& /*par_*/)
-    {
-    }
-
-  private:
-    bool           started;
-    CUDPReceiver   rcv;
-    CThread        thread;
-    CDataReaderUDP reader;
-  };
-};
diff --git a/ecal/core/src/readwrite/ecal_writer.cpp b/ecal/core/src/readwrite/ecal_writer.cpp
index c5c92d55d3..d18f8cc1e4 100644
--- a/ecal/core/src/readwrite/ecal_writer.cpp
+++ b/ecal/core/src/readwrite/ecal_writer.cpp
@@ -100,16 +100,8 @@ namespace eCAL
     m_ext_subscribed(false),
     m_use_udp_mc(TLayer::eSendMode(eCALPAR(PUB, USE_UDP_MC))),
     m_use_udp_mc_confirmed(false),
-    m_use_udp_uc(TLayer::eSendMode(eCALPAR(PUB, USE_UDP_UC))),
-    m_use_udp_uc_confirmed(false),
     m_use_shm(TLayer::eSendMode(eCALPAR(PUB, USE_SHM))),
     m_use_shm_confirmed(false),
-    m_use_lcm(TLayer::eSendMode(eCALPAR(PUB, USE_LCM))),
-    m_use_lcm_confirmed(false),
-#ifdef ECAL_LAYER_FASTRTPS
-    m_use_rtps(TLayer::eSendMode(eCALPAR(PUB, USE_RTPS))),
-    m_use_rtps_confirmed(false),
-#endif /* ECAL_LAYER_FASTRTPS */
 #ifdef ECAL_LAYER_ICEORYX
     m_use_iceoryx(TLayer::eSendMode(eCALPAR(PUB, USE_ICEORYX))),
     m_use_iceoryx_confirmed(false),
@@ -176,20 +168,9 @@ namespace eCAL
     // create udp multicast layer
     SetUseUdpMC(m_use_udp_mc);
 
-    // create udp unicast layer
-    SetUseUdpUC(m_use_udp_uc);
-
     // create shm layer
     SetUseShm(m_use_shm);
 
-    // create lcm layer
-    SetUseLcm(m_use_lcm);
-
-#ifdef ECAL_LAYER_FASTRTPS
-    // create rtps layer
-    SetUseRtps(m_use_rtps);
-#endif /* ECAL_LAYER_FASTRTPS */
-
 #ifdef ECAL_LAYER_ICEORYX
     // create iceoryx layer
     SetUseIceoryx(m_use_iceoryx);
@@ -218,20 +199,9 @@ namespace eCAL
     // destroy udp multicast writer
     m_writer_udp_mc.Destroy();
 
-    // destroy udp unicast writer
-    m_writer_udp_uc.Destroy();
-
     // destroy memory file writer
     m_writer_shm.Destroy();
 
-    // destroy lcm writer
-    m_writer_lcm.Destroy();
-
-#ifdef ECAL_LAYER_FASTRTPS
-    // destroy rtps writer
-    m_writer_rtps.Destroy();
-#endif /*  ECAL_LAYER_FASTRTPS */
-
 #ifdef ECAL_LAYER_ICEORYX
     // destroy iceoryx writer
     m_writer_iceoryx.Destroy();
@@ -301,9 +271,6 @@ namespace eCAL
     m_qos = qos_;
     bool ret = true;
     ret &= m_writer_shm.SetQOS(qos_);
-#ifdef ECAL_LAYER_FASTRTPS
-    ret &= m_writer_rtps.SetQOS(qos_);
-#endif /* ECAL_LAYER_FASTRTPS */
     return ret;
   }
 
@@ -314,20 +281,9 @@ namespace eCAL
     case TLayer::tlayer_udp_mc:
       SetUseUdpMC(mode_);
       break;
-    case TLayer::tlayer_udp_uc:
-      SetUseUdpUC(mode_);
-      break;
     case TLayer::tlayer_shm:
       SetUseShm(mode_);
       break;
-    case TLayer::tlayer_lcm:
-      SetUseLcm(mode_);
-      break;
-#ifdef ECAL_LAYER_FASTRTPS
-    case TLayer::tlayer_rtps:
-      SetUseRtps(mode_);
-      break;
-#endif /* ECAL_LAYER_FASTRTPS */
 #ifdef ECAL_LAYER_ICEORYX
     case TLayer::tlayer_iceoryx:
       SetUseIceoryx(mode_);
@@ -338,12 +294,7 @@ namespace eCAL
       break;
     case TLayer::tlayer_all:
       SetUseUdpMC   (mode_);
-      SetUseUdpUC   (mode_);
       SetUseShm     (mode_);
-      SetUseLcm     (mode_);
-#ifdef ECAL_LAYER_FASTRTPS
-      SetUseRtps    (mode_);
-#endif /* ECAL_LAYER_FASTRTPS */
 #ifdef ECAL_LAYER_ICEORYX
       SetUseIceoryx (mode_);
 #endif /* ECAL_LAYER_ICEORYX */
@@ -428,23 +379,13 @@ namespace eCAL
 
     // check send modes
     TLayer::eSendMode use_udp_mc(m_use_udp_mc);
-    TLayer::eSendMode use_udp_uc(m_use_udp_uc);
     TLayer::eSendMode use_shm(m_use_shm);
-    TLayer::eSendMode use_lcm(m_use_lcm);
-#ifdef ECAL_LAYER_FASTRTPS
-    TLayer::eSendMode use_rtps(m_use_rtps);
-#endif /* ECAL_LAYER_FASTRTPS */
 #ifdef ECAL_LAYER_ICEORYX
     TLayer::eSendMode use_iceoryx(m_use_iceoryx);
 #endif /* ECAL_LAYER_ICEORYX */
     TLayer::eSendMode use_inproc(m_use_inproc);
     if ( (use_udp_mc  == TLayer::smode_off)
-      && (use_udp_uc  == TLayer::smode_off)
       && (use_shm     == TLayer::smode_off)
-      && (use_lcm     == TLayer::smode_off)
-#ifdef ECAL_LAYER_FASTRTPS
-      && (use_rtps    == TLayer::smode_off)
-#endif /* ECAL_LAYER_FASTRTPS */
 #ifdef ECAL_LAYER_ICEORYX
       && (use_iceoryx == TLayer::smode_off)
 #endif /* ECAL_LAYER_ICEORYX */
@@ -651,158 +592,6 @@ namespace eCAL
 #endif
     }
 
-    ////////////////////////////////////////////////////////////////////////////
-    // LAYER 4 : UDP (UC)
-    ////////////////////////////////////////////////////////////////////////////
-    if (use_udp_uc == TLayer::smode_on)
-    {
-#ifndef NDEBUG
-      // log it
-      Logging::Log(log_level_debug3, m_topic_name + "::CDataWriter::Send::UDP_UC");
-#endif
-
-      // prepare send
-      bool prepared(false);
-      prepared = m_writer_udp_uc.PrepareSend(len_);
-
-      if (prepared)
-      {
-        // register new to update listening subscribers
-        DoRegister(true);
-        // let's rematch writer / reader
-        Process::SleepMS(5);
-      }
-
-      // send it
-      size_t udp_uc_sent(0);
-      {
-        // if shared memory layer for local communication is switched off
-        // we activate udp message loopback to communicate with local processes too
-        bool loopback = use_shm == TLayer::smode_off;
-
-        struct CDataWriterBase::SWriterData wdata;
-        wdata.buf       = buf_;
-        wdata.len       = len_;
-        wdata.id        = m_id;
-        wdata.clock     = m_clock;
-        wdata.hash      = snd_hash;
-        wdata.time      = time_;
-        wdata.bandwidth = m_bandwidth_max_udp;
-        wdata.loopback  = loopback;
-        udp_uc_sent     = m_writer_udp_uc.Send(wdata);
-        m_use_udp_uc_confirmed = true;
-      }
-      written |= udp_uc_sent > 0;
-
-#ifndef NDEBUG
-      // log it
-      if (udp_uc_sent > 0)
-      {
-        Logging::Log(log_level_debug3, m_topic_name + "::CDataWriter::Send::UDP_UC - SUCCESS");
-      }
-      else
-      {
-        Logging::Log(log_level_error, m_topic_name + "::CDataWriter::Send::UDP_UC - FAILED");
-      }
-#endif
-    }
-
-    ////////////////////////////////////////////////////////////////////////////
-    // LAYER 5 : LCM
-    ////////////////////////////////////////////////////////////////////////////
-    if (use_lcm == TLayer::smode_on)
-    {
-#ifndef NDEBUG
-      // log it
-      Logging::Log(log_level_debug3, m_topic_name + "::CDataWriter::Send::LCM");
-#endif
-
-      // prepare send
-      if (m_writer_lcm.PrepareSend(len_))
-      {
-        // register new to update listening subscribers
-        DoRegister(true);
-        // let's rematch writer / reader
-        Process::SleepMS(5);
-      }
-
-      // send it
-      size_t lcm_sent(0);
-      {
-        struct CDataWriterBase::SWriterData wdata;
-        wdata.buf   = buf_;
-        wdata.len   = len_;
-        wdata.id    = m_id;
-        wdata.clock = m_clock;
-        wdata.hash  = snd_hash;
-        wdata.time  = time_;
-        lcm_sent    = m_writer_lcm.Send(wdata) > 0;
-        m_use_lcm_confirmed = true;
-      }
-      written |= lcm_sent > 0;
-
-#ifndef NDEBUG
-      // log it
-      if (lcm_sent > 0)
-      {
-        Logging::Log(log_level_debug3, m_topic_name + "::CDataWriter::Send::LCM - SUCCESS");
-      }
-      else
-      {
-        Logging::Log(log_level_error, m_topic_name + "::CDataWriter::Send::LCM - FAILED");
-      }
-#endif
-    }
-
-#ifdef ECAL_LAYER_FASTRTPS 
-    ////////////////////////////////////////////////////////////////////////////
-    // LAYER 6 : FASTRTPS 
-    ////////////////////////////////////////////////////////////////////////////
-    if (use_rtps == TLayer::smode_on)
-    {
-#ifndef NDEBUG
-      // log it
-      Logging::Log(log_level_debug3, m_topic_name + "::CDataWriter::Send::RTPS");
-#endif
-
-      // prepare send
-      if (m_writer_rtps.PrepareSend(len_))
-      {
-        // register new to update listening subscribers
-        DoRegister(true);
-        // let's rematch writer / reader
-        Process::SleepMS(5);
-      }
-
-      // send it
-      size_t rtps_sent(0);
-      {
-        struct CDataWriterBase::SWriterData wdata;
-        wdata.buf   = buf_;
-        wdata.len   = len_;
-        wdata.id    = m_id;
-        wdata.clock = m_clock;
-        wdata.hash  = snd_hash;
-        wdata.time  = time_;
-        rtps_sent   = m_writer_rtps.Send(wdata) > 0;
-        m_use_rtps_confirmed = true;
-      }
-      written |= rtps_sent > 0;
-
-#ifndef NDEBUG
-      // log it
-      if (rtps_sent > 0)
-      {
-        Logging::Log(log_level_debug3, m_topic_name + "::CDataWriter::Send::RTPS - SUCCESS");
-      }
-      else
-      {
-        Logging::Log(log_level_error, m_topic_name + "::CDataWriter::Send::RTPS - FAILED");
-      }
-#endif
-    }
-#endif /* ECAL_LAYER_FASTRTPS */
-
 #ifdef ECAL_LAYER_ICEORYX
     ////////////////////////////////////////////////////////////////////////////
     // LAYER 7 : ICEORYX
@@ -868,12 +657,7 @@ namespace eCAL
 
     // add a new local subscription
     m_writer_udp_mc.AddLocConnection  (process_id_, reader_par_);
-    m_writer_udp_uc.AddLocConnection  (process_id_, reader_par_);
     m_writer_shm.AddLocConnection     (process_id_, reader_par_);
-    m_writer_lcm.AddLocConnection     (process_id_, reader_par_);
-#ifdef ECAL_LAYER_FASTRTPS
-    m_writer_rtps.AddLocConnection    (process_id_, reader_par_);
-#endif /* ECAL_LAYER_FASTRTPS */
 #ifdef ECAL_LAYER_ICEORYX
     m_writer_iceoryx.AddLocConnection (process_id_, reader_par_);
 #endif /* ECAL_LAYER_ICEORYX */
@@ -888,12 +672,7 @@ namespace eCAL
   {
     // remove a local subscription
     m_writer_udp_mc.RemLocConnection  (process_id_);
-    m_writer_udp_uc.RemLocConnection  (process_id_);
     m_writer_shm.RemLocConnection     (process_id_);
-    m_writer_lcm.RemLocConnection     (process_id_);
-#ifdef ECAL_LAYER_FASTRTPS
-    m_writer_rtps.RemLocConnection    (process_id_);
-#endif /* ECAL_LAYER_FASTRTPS */
 #ifdef ECAL_LAYER_ICEORYX
     m_writer_iceoryx.RemLocConnection (process_id_);
 #endif /* ECAL_LAYER_ICEORYX */
@@ -915,12 +694,7 @@ namespace eCAL
 
     // add a new external subscription
     m_writer_udp_mc.AddExtConnection  (host_name_, process_id_, reader_par_);
-    m_writer_udp_uc.AddExtConnection  (host_name_, process_id_, reader_par_);
     m_writer_shm.AddExtConnection     (host_name_, process_id_, reader_par_);
-    m_writer_lcm.AddExtConnection     (host_name_, process_id_, reader_par_);
-#ifdef ECAL_LAYER_FASTRTPS
-    m_writer_rtps.AddExtConnection    (host_name_, process_id_, reader_par_);
-#endif /* ECAL_LAYER_FASTRTPS */
 #ifdef ECAL_LAYER_ICEORYX
     m_writer_iceoryx.AddExtConnection (host_name_, process_id_, reader_par_);
 #endif /* ECAL_LAYER_ICEORYX */
@@ -935,12 +709,7 @@ namespace eCAL
   {
     // remove external subscription
     m_writer_udp_mc.RemExtConnection  (host_name_, process_id_);
-    m_writer_udp_uc.RemExtConnection  (host_name_, process_id_);
     m_writer_shm.RemExtConnection     (host_name_, process_id_);
-    m_writer_lcm.RemExtConnection     (host_name_, process_id_);
-#ifdef ECAL_LAYER_FASTRTPS
-    m_writer_rtps.RemExtConnection    (host_name_, process_id_);
-#endif /* ECAL_LAYER_FASTRTPS */
 #ifdef ECAL_LAYER_ICEORYX
     m_writer_iceoryx.RemExtConnection (host_name_, process_id_);
 #endif /* ECAL_LAYER_ICEORYX */
@@ -1081,14 +850,6 @@ namespace eCAL
       tlayer->set_confirmed(m_use_udp_mc_confirmed);
       tlayer->set_par("");
     }
-    // udp unicast layer
-    {
-      auto tlayer = ecal_reg_sample_mutable_topic->add_tlayer();
-      tlayer->set_type(eCAL::pb::tl_ecal_udp_uc);
-      tlayer->set_version(1);
-      tlayer->set_confirmed(m_use_udp_uc_confirmed);
-      tlayer->set_par("");
-    }
     // shm layer
     {
       auto tlayer = ecal_reg_sample_mutable_topic->add_tlayer();
@@ -1097,24 +858,6 @@ namespace eCAL
       tlayer->set_confirmed(m_use_shm_confirmed);
       tlayer->set_par(m_writer_shm.GetConectionPar());
     }
-    // lcm layer
-    {
-      auto tlayer = ecal_reg_sample_mutable_topic->add_tlayer();
-      tlayer->set_type(eCAL::pb::tl_lcm);
-      tlayer->set_version(1);
-      tlayer->set_confirmed(m_use_lcm_confirmed);
-      tlayer->set_par("");
-    }
-#ifdef ECAL_LAYER_FASTRTPS
-    // rtps layer
-    {
-      auto tlayer = ecal_reg_sample_mutable_topic->add_tlayer();
-      tlayer->set_type(eCAL::pb::tl_rtps);
-      tlayer->set_version(1);
-      tlayer->set_confirmed(m_use_rtps_confirmed);
-      tlayer->set_par("");
-    }
-#endif /* ECAL_LAYER_FASTRTPS */
 #ifdef ECAL_LAYER_ICEORYX
     // iceoryx layer
     {
@@ -1246,32 +989,6 @@ namespace eCAL
     return(true);
   }
 
-  bool CDataWriter::SetUseUdpUC(TLayer::eSendMode mode_)
-  {
-    m_use_udp_uc = mode_;
-    if (!m_created) return true;
-
-    // log send mode
-    LogSendMode(m_use_udp_uc, m_topic_name + "::CDataWriter::Create::UDP_UC_SENDMODE::");
-
-    switch (m_use_udp_uc)
-    {
-    case TLayer::eSendMode::smode_auto:
-    case TLayer::eSendMode::smode_on:
-      m_writer_udp_uc.Create(m_host_name, m_topic_name, m_topic_id);
-#ifndef NDEBUG
-      Logging::Log(log_level_debug4, m_topic_name + "::CDataWriter::Create::UDP_UC_WRITER");
-#endif
-      break;
-    case TLayer::eSendMode::smode_none:
-    case TLayer::eSendMode::smode_off:
-      m_writer_udp_uc.Destroy();
-      break;
-    }
-
-    return(true);
-  }
-
   bool CDataWriter::SetUseShm(TLayer::eSendMode mode_)
   {
     m_use_shm = mode_;
@@ -1298,56 +1015,6 @@ namespace eCAL
     return(true);
   }
 
-  bool CDataWriter::SetUseLcm(TLayer::eSendMode mode_)
-  {
-    m_use_lcm = mode_;
-    if (!m_created) return true;
-
-    // log send mode
-    LogSendMode(m_use_lcm, m_topic_name + "::CDataWriter::Create::LCM_SENDMODE::");
-
-    switch (m_use_lcm)
-    {
-    case TLayer::eSendMode::smode_on:
-      m_writer_lcm.Create(m_host_name, m_topic_name, m_topic_id);
-#ifndef NDEBUG
-      Logging::Log(log_level_debug4, m_topic_name + "::CDataWriter::Create::LCM_WRITER");
-#endif
-      break;
-    default:
-      m_writer_lcm.Destroy();
-      break;
-    }
-
-    return(true);
-  }
-
-#ifdef ECAL_LAYER_FASTRTPS
-  bool CDataWriter::SetUseRtps(TLayer::eSendMode mode_)
-  {
-    m_use_rtps = mode_;
-    if (!m_created) return true;
-
-    // log send mode
-    LogSendMode(m_use_rtps, m_topic_name + "::CDataWriter::Create::RTPS_SENDMODE::");
-
-    switch (m_use_rtps)
-    {
-    case TLayer::eSendMode::smode_on:
-      m_writer_rtps.Create(m_host_name, m_topic_name, m_topic_id);
-#ifndef NDEBUG
-      Logging::Log(log_level_debug4, m_topic_name + "::CDataWriter::Create::RTPS_WRITER");
-#endif
-      break;
-    default:
-      m_writer_rtps.Destroy();
-      break;
-    }
-
-    return(true);
-  }
-#endif /* ECAL_LAYER_FASTRTPS */
-
 #ifdef ECAL_LAYER_ICEORYX
   bool CDataWriter::SetUseIceoryx(TLayer::eSendMode mode_)
   {
diff --git a/ecal/core/src/readwrite/ecal_writer.h b/ecal/core/src/readwrite/ecal_writer.h
index 170bf0cc78..f38c6d0dbc 100644
--- a/ecal/core/src/readwrite/ecal_writer.h
+++ b/ecal/core/src/readwrite/ecal_writer.h
@@ -30,12 +30,7 @@
 #include "ecal_expmap.h"
 
 #include "ecal_writer_udp_mc.h"
-#include "ecal_writer_udp_uc.h"
 #include "ecal_writer_shm.h"
-#include "ecal_writer_lcm.h"
-#ifdef ECAL_LAYER_FASTRTPS
-#include "ecal_writer_rtps.h"
-#endif /* ECAL_LAYER_FASTRTPS */
 #ifdef ECAL_LAYER_ICEORYX
 #include "ecal_writer_iceoryx.h"
 #endif /* ECAL_LAYER_ICEORYX */
@@ -102,12 +97,7 @@ namespace eCAL
     void SetConnected(bool state_);
 
     bool SetUseUdpMC(TLayer::eSendMode mode_);
-    bool SetUseUdpUC(TLayer::eSendMode mode_);
     bool SetUseShm(TLayer::eSendMode mode_);
-    bool SetUseLcm(TLayer::eSendMode mode_);
-#ifdef ECAL_LAYER_FASTRTPS
-    bool SetUseRtps(TLayer::eSendMode mode_);
-#endif /* ECAL_LAYER_FASTRTPS */
 #ifdef ECAL_LAYER_ICEORYX
     bool SetUseIceoryx(TLayer::eSendMode mode_);
 #endif /* ECAL_LAYER_ICEORYX */
@@ -158,24 +148,10 @@ namespace eCAL
     CDataWriterUdpMC   m_writer_udp_mc;
     bool               m_use_udp_mc_confirmed;
 
-    TLayer::eSendMode  m_use_udp_uc;
-    CDataWriterUdpUC   m_writer_udp_uc;
-    bool               m_use_udp_uc_confirmed;
-
     TLayer::eSendMode  m_use_shm;
     CDataWriterSHM     m_writer_shm;
     bool               m_use_shm_confirmed;
 
-    TLayer::eSendMode  m_use_lcm;
-    CDataWriterLCM     m_writer_lcm;
-    bool               m_use_lcm_confirmed;
-
-#ifdef ECAL_LAYER_FASTRTPS
-    TLayer::eSendMode  m_use_rtps;
-    CDataWriterRTPS    m_writer_rtps;
-    bool               m_use_rtps_confirmed;
-#endif /*ECAL_LAYER_FASTRTPS*/
-
 #ifdef ECAL_LAYER_ICEORYX
     TLayer::eSendMode  m_use_iceoryx;
     CDataWriterIceoryx m_writer_iceoryx;
diff --git a/ecal/core/src/readwrite/ecal_writer_lcm.cpp b/ecal/core/src/readwrite/ecal_writer_lcm.cpp
deleted file mode 100644
index f0c12c54f8..0000000000
--- a/ecal/core/src/readwrite/ecal_writer_lcm.cpp
+++ /dev/null
@@ -1,119 +0,0 @@
-/* ========================= eCAL LICENSE =================================
- *
- * Copyright (C) 2016 - 2019 Continental Corporation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * ========================= eCAL LICENSE =================================
-*/
-
-/**
- * @brief  lcm data writer
-**/
-
-#include <ecal/ecal.h>
-
-#include "ecal_def.h"
-#include "ecal_config_hlp.h"
-#include "ecal_writer_lcm.h"
-
-#include "ecal_def.h"
-#include "ecal_global_accessors.h"
-
-#include "lcm/lcmlite.h"
-
-static void transmit_packet(const void* buf_, int len_, void* user)
-{
-  static_cast<eCAL::CUDPSender*>(user)->Send(buf_, static_cast<size_t>(len_));
-}
-
-namespace eCAL
-{
-  CDataWriterLCM::CDataWriterLCM() : m_initialized(false)
-  {
-  }
-
-  CDataWriterLCM::~CDataWriterLCM()
-  {
-    Destroy();
-  }
-
-  void CDataWriterLCM::GetInfo(SWriterInfo info_)
-  {
-    info_.name                 = "lcm";
-    info_.description          = "Google LCM data writer";
-
-    info_.has_mode_local       = true;
-    info_.has_mode_cloud       = true;
-
-    info_.has_qos_history_kind = false;
-    info_.has_qos_reliability  = false;
-
-    info_.send_size_max        = LCM3_MAX_PACKET_SIZE;
-  }
-
-  bool CDataWriterLCM::Create(const std::string& /*host_name_*/, const std::string& topic_name_, const std::string& /*topic_id_*/)
-  {
-    if (m_created) return false;
-
-    m_topic_name = topic_name_;
-
-    m_created = true;
-    return true;
-  }
-
-  bool CDataWriterLCM::Destroy()
-  {
-    if (!m_created) return false;
-
-    if (m_initialized)
-    {
-      m_lcm = nullptr;
-      m_udp_sender.Destroy();
-      m_initialized = false;
-    }
-
-    m_created = false;
-    return true;
-  }
-
-  size_t CDataWriterLCM::Send(const SWriterData& data_)
-  {
-    if (!m_created) return 0;
-
-    // let's initialize it on first send, to not waste memory per default
-    if (!m_initialized)
-    {
-      int ttl(0);
-      if (eCALPAR(NET, ENABLED)) ttl = eCALPAR(NET, UDP_MULTICAST_TTL);
-
-      SSenderAttr attr;
-      attr.ipaddr     = NET_UDP_MULTICAST_GROUP_LCM;
-      attr.port       = NET_UDP_MULTICAST_PORT_LCM;
-      attr.loopback   = true;
-      attr.ttl        = ttl;
-      attr.sndbuf     = eCALPAR(NET, UDP_MULTICAST_SNDBUF);
-      attr.local_only = false;
-      m_udp_sender.Create(attr);
-
-      m_lcm = std::make_shared<lcmlite_pub_t>();
-      lcmlite_pub_init(m_lcm.get(), transmit_packet, &m_udp_sender);
-
-      m_initialized = true;
-    }
-
-    int res = lcmlite_publish(m_lcm.get(), m_topic_name.c_str(), data_.buf, static_cast<int>(data_.len));
-    if (res == 0) return(data_.len);
-    else          return(0);
-  }
-}
diff --git a/ecal/core/src/readwrite/ecal_writer_rtps.cpp b/ecal/core/src/readwrite/ecal_writer_rtps.cpp
deleted file mode 100644
index 759eca6a29..0000000000
--- a/ecal/core/src/readwrite/ecal_writer_rtps.cpp
+++ /dev/null
@@ -1,228 +0,0 @@
-/* ========================= eCAL LICENSE =================================
- *
- * Copyright (C) 2016 - 2019 Continental Corporation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * ========================= eCAL LICENSE =================================
-*/
-
-/**
- * @brief  rtps data writer
-**/
-
-#include <ecal/ecal_log.h>
-
-#include "ecal_def.h"
-#include "ecal_config_hlp.h"
-#include "ecal_writer_rtps.h"
-
-#include <fastrtps/Domain.h>
-#include <fastrtps/participant/Participant.h>
-#include <fastrtps/publisher/Publisher.h>
-#include <fastrtps/publisher/PublisherHistory.h>
-
-eprosima::fastrtps::Participant* GetRTPSParticipant()
-{
-  static eprosima::fastrtps::Participant* pparticipant(nullptr);
-  static string_message_PubSubType        stype;
-  if (pparticipant == nullptr)
-  {
-    eprosima::fastrtps::ParticipantAttributes PParam;
-    PParam.rtps.defaultSendPort                                                = 11511;
-    PParam.rtps.use_IP6_to_send                                                = true;
-    PParam.rtps.builtin.use_SIMPLE_RTPSParticipantDiscoveryProtocol            = true;
-    PParam.rtps.builtin.use_SIMPLE_EndpointDiscoveryProtocol                   = true;
-    PParam.rtps.builtin.m_simpleEDP.use_PublicationReaderANDSubscriptionWriter = true;
-    PParam.rtps.builtin.m_simpleEDP.use_PublicationWriterANDSubscriptionReader = true;
-    PParam.rtps.builtin.domainId                                               = 0;
-    PParam.rtps.builtin.leaseDuration                                          = eprosima::fastrtps::rtps::c_TimeInfinite;
-    PParam.rtps.setName(eCALPAR(RTPS, DOMAIN).c_str());
-    pparticipant = eprosima::fastrtps::Domain::createParticipant(PParam);
-    eprosima::fastrtps::Domain::registerType(pparticipant, &stype);
-  }
-  return pparticipant;
-}
-
-namespace eCAL
-{
-  CDataWriterRTPS::CDataWriterRTPS() : 
-    m_publisher(nullptr)
-  {
-    // rtps writer default attributes
-    m_attr.topic.topicKind                           = eprosima::fastrtps::rtps::NO_KEY;
-    m_attr.topic.topicDataType                       = m_string_type.getName();
-    m_attr.topic.topicName.clear();
-    m_attr.topic.historyQos.kind                     = eprosima::fastrtps::KEEP_LAST_HISTORY_QOS;
-    m_attr.topic.historyQos.depth                    = 8;
-    m_attr.topic.resourceLimitsQos.max_samples       = 32; //-V112
-    m_attr.topic.resourceLimitsQos.allocated_samples = 16;
-    m_attr.times.heartbeatPeriod.seconds             = 2;
-    m_attr.times.heartbeatPeriod.fraction            = 200 * 1000 * 1000;
-    m_attr.qos.m_reliability.kind                    = eprosima::fastrtps::RELIABLE_RELIABILITY_QOS;
-    m_attr.historyMemoryPolicy                       = eprosima::fastrtps::rtps::PREALLOCATED_WITH_REALLOC_MEMORY_MODE;
-    m_attr.qos.m_publishMode.kind                    = eprosima::fastrtps::ASYNCHRONOUS_PUBLISH_MODE;
-    m_attr.qos.m_partition.push_back("rt");
-  }
-
-  CDataWriterRTPS::~CDataWriterRTPS()
-  {
-    Destroy();
-  }
-
-  void CDataWriterRTPS::GetInfo(SWriterInfo info_)
-  {
-    info_.name                 = "rtps";
-    info_.description          = "fastRTPS data writer";
-
-    info_.has_mode_local       = true;
-    info_.has_mode_cloud       = true;
-
-    info_.has_qos_history_kind = true;
-    info_.has_qos_reliability  = true;
-
-    info_.send_size_max        = -1;
-  }
-
-  bool CDataWriterRTPS::Create(const std::string & host_name_, const std::string & topic_name_, const std::string & topic_id_)
-  {
-    if (m_created) return false;
-
-    m_host_name  = host_name_;
-    m_topic_name = topic_name_;
-    m_topic_id   = topic_id_;
-
-    // create participant
-    if (GetRTPSParticipant() == nullptr) return false;
-
-    // create publisher
-    if (!CreateRtpsPub(topic_name_)) return false;
-
-    m_created = true;
-    return true;
-  }
-
-  bool CDataWriterRTPS::Destroy()
-  {
-    if (!m_created) return false;
-
-    // destroy publisher
-    DestroyRtpsPub();
-
-    m_created = false;
-    return true;
-  }
-
-  bool CDataWriterRTPS::SetQOS(const QOS::SWriterQOS & qos_)
-  {
-    if (m_created) return false;
-    m_qos = qos_;
-
-    switch (qos_.history_kind)
-    {
-    case QOS::keep_last_history_qos:
-      m_attr.topic.historyQos.kind = eprosima::fastrtps::KEEP_LAST_HISTORY_QOS;
-      m_attr.topic.historyQos.depth = qos_.history_kind_depth;
-      break;
-    case QOS::keep_all_history_qos:
-      m_attr.topic.historyQos.kind = eprosima::fastrtps::KEEP_ALL_HISTORY_QOS;
-      break;
-    default:
-      break;
-    }
-
-    switch (qos_.reliability)
-    {
-    case QOS::reliable_reliability_qos:
-      m_attr.qos.m_reliability.kind = eprosima::fastrtps::RELIABLE_RELIABILITY_QOS;
-      break;
-    case QOS::best_effort_reliability_qos:
-      m_attr.qos.m_reliability.kind = eprosima::fastrtps::BEST_EFFORT_RELIABILITY_QOS;
-      break;
-    default:
-      break;
-    }
-
-    return true;
-  }
-
-  size_t CDataWriterRTPS::Send(const SWriterData& data_)
-  {
-    if (!m_created) return 0;
-
-    // send it
-    bool sent(false);
-    if (m_listener.n_matched > 0)
-    {
-      // fill rtps message
-      m_string_msg.tid(m_topic_id);
-      m_string_msg.id(data_.id);
-      m_string_msg.clock(data_.clock);
-      m_string_msg.time(data_.time);
-      m_string_msg.compressed(0);
-      m_string_msg.size(data_.len);
-      m_string_msg.hash(data_.hash);
-      m_string_msg.payload().resize(data_.len);
-      memcpy(&m_string_msg.payload()[0], data_.buf, data_.len);
-
-      // send it
-      sent = m_publisher->write((void*)&m_string_msg);
-
-      // log it
-      if (sent == false)
-      {
-        Logging::Log(log_level_fatal, "CDataWriterRTPS::Send failed to send message !");
-        return(0);
-      }
-    }
-
-    return(data_.len);
-  }
-
-  bool CDataWriterRTPS::CreateRtpsPub(const std::string& topic_name_)
-  {
-    if (m_publisher) return false;
-
-    // create publisher
-    m_attr.topic.topicName = topic_name_;
-    m_publisher = eprosima::fastrtps::Domain::createPublisher(GetRTPSParticipant(), m_attr, (eprosima::fastrtps::PublisherListener*)&m_listener);
-    if (m_publisher == nullptr) return false;
-
-    return true;
-  }
-
-  bool CDataWriterRTPS::DestroyRtpsPub()
-  {
-    if (m_publisher == nullptr) return false;
-
-    // destroy publisher
-    eprosima::fastrtps::Domain::removePublisher(m_publisher);
-    m_publisher = nullptr;
-
-    return true;
-  }
-
-  void CDataWriterRTPS::PubListener::onPublicationMatched(eprosima::fastrtps::Publisher* /*pub_*/, eprosima::fastrtps::rtps::MatchingInfo& info_)
-  {
-    if (info_.status == eprosima::fastrtps::rtps::MATCHED_MATCHING)
-    {
-      n_matched++;
-      Logging::Log(log_level_debug1, "CDataWriterRTPS::Publisher matched.");
-    }
-    else
-    {
-      n_matched--;
-      Logging::Log(log_level_debug1, "CDataWriterRTPS::Publisher unmatched.");
-    }
-  }
-}
diff --git a/ecal/core/src/readwrite/ecal_writer_rtps.h b/ecal/core/src/readwrite/ecal_writer_rtps.h
deleted file mode 100644
index 0ac93e702c..0000000000
--- a/ecal/core/src/readwrite/ecal_writer_rtps.h
+++ /dev/null
@@ -1,83 +0,0 @@
-/* ========================= eCAL LICENSE =================================
- *
- * Copyright (C) 2016 - 2019 Continental Corporation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * ========================= eCAL LICENSE =================================
-*/
-
-/**
- * @brief  rtps data writer
-**/
-
-#pragma once
-
-#include <string>
-
-#include <ecal/ecal_qos.h>
-
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable: 4146 4800)
-#endif
-#include "ecal/pb/ecal.pb.h"
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-#include "readwrite/ecal_writer_base.h"
-
-#include <fastrtps/fastrtps_fwd.h>
-#include <fastrtps/attributes/PublisherAttributes.h>
-#include <fastrtps/publisher/PublisherListener.h>
-
-#include "readwrite/fastrtps/string_message_PubSubTypes.h"
-
-namespace eCAL
-{
-  class CDataWriterRTPS : public CDataWriterBase
-  {
-  public:
-    CDataWriterRTPS();
-    ~CDataWriterRTPS();
-
-    void GetInfo(SWriterInfo info_) override;
-
-    bool Create(const std::string& host_name_, const std::string& topic_name_, const std::string & topic_id_) override;
-    bool Destroy() override;
-
-    bool SetQOS(const QOS::SWriterQOS& qos_) override;
-
-    size_t Send(const SWriterData& data_) override;
-
-  protected:
-    bool CreateRtpsPub(const std::string& topic_name_);
-    bool DestroyRtpsPub();
-
-    class PubListener :public eprosima::fastrtps::PublisherListener
-    {
-    public:
-      PubListener() :n_matched(0) {};
-      ~PubListener() {};
-      void onPublicationMatched(eprosima::fastrtps::Publisher* pub_, eprosima::fastrtps::rtps::MatchingInfo& info_);
-      int n_matched;
-    };
-
-    eprosima::fastrtps::Publisher*           m_publisher;
-    class PubListener                        m_listener;
-    string_message_PubSubType                m_string_type;
-    string_message_                          m_string_msg;
-    eprosima::fastrtps::PublisherAttributes  m_attr;
-  };
-}
diff --git a/ecal/core/src/readwrite/ecal_writer_udp_uc.cpp b/ecal/core/src/readwrite/ecal_writer_udp_uc.cpp
deleted file mode 100644
index a8d80f56dc..0000000000
--- a/ecal/core/src/readwrite/ecal_writer_udp_uc.cpp
+++ /dev/null
@@ -1,142 +0,0 @@
-/* ========================= eCAL LICENSE =================================
- *
- * Copyright (C) 2016 - 2019 Continental Corporation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * ========================= eCAL LICENSE =================================
-*/
-
-/**
- * @brief  udp data writer
-**/
-
-#include <ecal/ecal.h>
-#include <ecal/ecal_log.h>
-
-#include "ecal_def.h"
-#include "ecal_config_hlp.h"
-#include "ecal_writer_udp_uc.h"
-
-#include "topic2mcast.h"
-#include "io/snd_sample.h"
-
-namespace eCAL
-{
-  CDataWriterUdpUC::~CDataWriterUdpUC()
-  {
-    Destroy();
-  }
-
-  void CDataWriterUdpUC::GetInfo(SWriterInfo info_)
-  {
-    info_.name                 = "udp";
-    info_.description          = "UDP unicast data writer";
-
-    info_.has_mode_local       = true;
-    info_.has_mode_cloud       = true;
-
-    info_.has_qos_history_kind = false;
-    info_.has_qos_reliability  = false;
-
-    info_.send_size_max        = -1;
-  }
-
-  bool CDataWriterUdpUC::Create(const std::string & host_name_, const std::string & topic_name_, const std::string & topic_id_)
-  {
-    if (m_created) return false;
-
-    m_host_name   = host_name_;
-    m_topic_name  = topic_name_;
-    m_topic_id    = topic_id_;
-
-    m_udp_ipaddr  = eCALPAR(NET, UDP_UNICAST_IPADDR);
-
-    SSenderAttr attr;
-    attr.ipaddr     = m_udp_ipaddr;
-    attr.port       = eCALPAR(NET, UDP_UNICAST_PORT);
-    attr.unicast    = true;
-    attr.sndbuf     = eCALPAR(NET, UDP_MULTICAST_SNDBUF);
-
-    // create sample sender without activated loopback
-    attr.loopback   = false;
-    attr.ttl        = eCALPAR(NET, UDP_MULTICAST_TTL);
-    attr.local_only = !eCALPAR(NET, ENABLED);
-    m_sample_snd_no_loopback.Create(attr);
-
-    // create sample sender with activated loopback
-    int ttl(0);
-    if (eCALPAR(NET, ENABLED)) ttl = eCALPAR(NET, UDP_MULTICAST_TTL);
-    attr.loopback   = true;
-    attr.ttl        = ttl;
-    attr.local_only = false;
-    m_sample_snd_loopback.Create(attr);
-
-    m_created = true;
-    return true;
-  }
-
-  bool CDataWriterUdpUC::Destroy()
-  {
-    if (!m_created) return false;
-
-    m_created = false;
-    return true;
-  }
-
-  size_t CDataWriterUdpUC::Send(const SWriterData& data_)
-  {
-    if (!m_created) return 0;
-
-    // create new sample
-    m_ecal_sample.Clear();
-    m_ecal_sample.set_cmd_type(eCAL::pb::bct_set_sample);
-    auto ecal_sample_mutable_topic = m_ecal_sample.mutable_topic();
-    ecal_sample_mutable_topic->set_hname(m_host_name);
-    ecal_sample_mutable_topic->set_tname(m_topic_name);
-    ecal_sample_mutable_topic->set_tid(m_topic_id);
-
-    // set layer
-    auto layer = ecal_sample_mutable_topic->add_tlayer();
-    layer->set_type(eCAL::pb::eTLayerType::tl_ecal_udp_uc);
-    layer->set_confirmed(true);
-
-    // append content
-    auto ecal_sample_mutable_content = m_ecal_sample.mutable_content();
-    ecal_sample_mutable_content->set_id(data_.id);
-    ecal_sample_mutable_content->set_clock(data_.clock);
-    ecal_sample_mutable_content->set_time(data_.time);
-    ecal_sample_mutable_content->set_hash(data_.hash);
-    ecal_sample_mutable_content->set_size((google::protobuf::int32)data_.len);
-    ecal_sample_mutable_content->set_payload(data_.buf, data_.len);
-
-    // send it
-    size_t sent = 0;
-    if (data_.loopback)
-    {
-      sent = eCAL::SendSample(&m_sample_snd_loopback, m_ecal_sample.topic().tname(), m_ecal_sample, m_udp_ipaddr, data_.bandwidth);
-    }
-    else
-    {
-      sent = eCAL::SendSample(&m_sample_snd_no_loopback, m_ecal_sample.topic().tname(), m_ecal_sample, m_udp_ipaddr, data_.bandwidth);
-    }
-
-    // log it
-    if (sent == 0)
-    {
-      Logging::Log(log_level_fatal, "CDataWriterUDP::Send failed to send message !");
-    }
-
-    return(sent);
-  }
-}
diff --git a/ecal/core/src/readwrite/ecal_writer_udp_uc.h b/ecal/core/src/readwrite/ecal_writer_udp_uc.h
deleted file mode 100644
index 8d712adbca..0000000000
--- a/ecal/core/src/readwrite/ecal_writer_udp_uc.h
+++ /dev/null
@@ -1,63 +0,0 @@
-/* ========================= eCAL LICENSE =================================
- *
- * Copyright (C) 2016 - 2019 Continental Corporation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * ========================= eCAL LICENSE =================================
-*/
-
-/**
- * @brief  udp data writer
-**/
-
-#pragma once
-
-#include "ecal_def.h"
-
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable: 4146 4800)
-#endif
-#include "ecal/pb/ecal.pb.h"
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-#include "io/udp_sender.h"
-#include "readwrite/ecal_writer_base.h"
-
-#include <string>
-
-namespace eCAL
-{
-  class CDataWriterUdpUC : public CDataWriterBase
-  {
-  public:
-    ~CDataWriterUdpUC();
-
-    void GetInfo(SWriterInfo info_) override;
-
-    bool Create(const std::string& host_name_, const std::string& topic_name_, const std::string & topic_id_) override;
-    bool Destroy() override;
-
-    size_t Send(const SWriterData& data_) override;
-
-  protected:
-    std::string       m_udp_ipaddr;
-    eCAL::pb::Sample  m_ecal_sample;
-
-    CUDPSender        m_sample_snd_loopback;
-    CUDPSender        m_sample_snd_no_loopback;
-  };
-}
diff --git a/ecal/core/src/readwrite/fastrtps/compile_idl.bat b/ecal/core/src/readwrite/fastrtps/compile_idl.bat
deleted file mode 100644
index 1c5f63a195..0000000000
--- a/ecal/core/src/readwrite/fastrtps/compile_idl.bat
+++ /dev/null
@@ -1,2 +0,0 @@
-call %VS140COMNTOOLS%\vsvars32.bat
-fastrtpsgen.bat string_message_.idl
diff --git a/ecal/core/src/readwrite/fastrtps/string_message_.cxx b/ecal/core/src/readwrite/fastrtps/string_message_.cxx
deleted file mode 100644
index 75250bb8a4..0000000000
--- a/ecal/core/src/readwrite/fastrtps/string_message_.cxx
+++ /dev/null
@@ -1,212 +0,0 @@
-// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima).
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-/*! 
- * @file string_message_.cpp
- * This source file contains the definition of the described types in the IDL file.
- *
- * This file was generated by the tool gen.
- */
-
-#ifdef _WIN32
-// Remove linker warning LNK4221 on Visual Studio
-namespace { char dummy; }
-#endif
-
-#include "string_message_.h"
-
-#include <fastcdr/Cdr.h>
-
-#include <fastcdr/exceptions/BadParamException.h>
-using namespace eprosima::fastcdr::exception;
-
-#include <utility>
-
-string_message_::string_message_()
-{
-
-    m_id = 0;
-    m_clock = 0;
-    m_time = 0;
-    m_compressed = 0;
-    m_size = 0;
-    m_hash = 0;
-
-}
-
-string_message_::~string_message_()
-{
-}
-
-string_message_::string_message_(const string_message_ &x)
-{
-    m_tid = x.m_tid;
-    m_id = x.m_id;
-    m_clock = x.m_clock;
-    m_time = x.m_time;
-    m_compressed = x.m_compressed;
-    m_size = x.m_size;
-    m_hash = x.m_hash;
-    m_payload = x.m_payload;
-}
-
-string_message_::string_message_(string_message_ &&x)
-{
-    m_tid = std::move(x.m_tid);
-    m_id = x.m_id;
-    m_clock = x.m_clock;
-    m_time = x.m_time;
-    m_compressed = x.m_compressed;
-    m_size = x.m_size;
-    m_hash = x.m_hash;
-    m_payload = std::move(x.m_payload);
-}
-
-string_message_& string_message_::operator=(const string_message_ &x)
-{
-    m_tid = x.m_tid;
-    m_id = x.m_id;
-    m_clock = x.m_clock;
-    m_time = x.m_time;
-    m_compressed = x.m_compressed;
-    m_size = x.m_size;
-    m_hash = x.m_hash;
-    m_payload = x.m_payload;
-    
-    return *this;
-}
-
-string_message_& string_message_::operator=(string_message_ &&x)
-{
-    m_tid = std::move(x.m_tid);
-    m_id = x.m_id;
-    m_clock = x.m_clock;
-    m_time = x.m_time;
-    m_compressed = x.m_compressed;
-    m_size = x.m_size;
-    m_hash = x.m_hash;
-    m_payload = std::move(x.m_payload);
-    
-    return *this;
-}
-
-size_t string_message_::getMaxCdrSerializedSize(size_t current_alignment)
-{
-    size_t initial_alignment = current_alignment;
-            
-    current_alignment += 4 + eprosima::fastcdr::Cdr::alignment(current_alignment, 4) + 255 + 1;
-
-    current_alignment += 8 + eprosima::fastcdr::Cdr::alignment(current_alignment, 8);
-
-    current_alignment += 8 + eprosima::fastcdr::Cdr::alignment(current_alignment, 8);
-
-    current_alignment += 8 + eprosima::fastcdr::Cdr::alignment(current_alignment, 8);
-
-    current_alignment += 1 + eprosima::fastcdr::Cdr::alignment(current_alignment, 1);
-
-    current_alignment += 8 + eprosima::fastcdr::Cdr::alignment(current_alignment, 8);
-
-    current_alignment += 8 + eprosima::fastcdr::Cdr::alignment(current_alignment, 8);
-
-    current_alignment += 4 + eprosima::fastcdr::Cdr::alignment(current_alignment, 4);
-    current_alignment += (100 * 1) + eprosima::fastcdr::Cdr::alignment(current_alignment, 1);
-
-
-
-    return current_alignment - initial_alignment;
-}
-
-size_t string_message_::getCdrSerializedSize(const string_message_& data, size_t current_alignment)
-{
-    size_t initial_alignment = current_alignment;
-            
-    current_alignment += 4 + eprosima::fastcdr::Cdr::alignment(current_alignment, 4) + data.tid().size() + 1;
-
-    current_alignment += 8 + eprosima::fastcdr::Cdr::alignment(current_alignment, 8);
-
-    current_alignment += 8 + eprosima::fastcdr::Cdr::alignment(current_alignment, 8);
-
-    current_alignment += 8 + eprosima::fastcdr::Cdr::alignment(current_alignment, 8);
-
-    current_alignment += 1 + eprosima::fastcdr::Cdr::alignment(current_alignment, 1);
-
-    current_alignment += 8 + eprosima::fastcdr::Cdr::alignment(current_alignment, 8);
-
-    current_alignment += 8 + eprosima::fastcdr::Cdr::alignment(current_alignment, 8);
-
-    current_alignment += 4 + eprosima::fastcdr::Cdr::alignment(current_alignment, 4);
-    current_alignment += (data.payload().size() * 1) + eprosima::fastcdr::Cdr::alignment(current_alignment, 1);
-
-
-
-    return current_alignment - initial_alignment;
-}
-
-void string_message_::serialize(eprosima::fastcdr::Cdr &scdr) const
-{
-    scdr << m_tid;
-    scdr << m_id;
-    scdr << m_clock;
-    scdr << m_time;
-    scdr << m_compressed;
-    scdr << m_size;
-    scdr << m_hash;
-    scdr << m_payload;
-}
-
-void string_message_::deserialize(eprosima::fastcdr::Cdr &dcdr)
-{
-    dcdr >> m_tid;
-    dcdr >> m_id;
-    dcdr >> m_clock;
-    dcdr >> m_time;
-    dcdr >> m_compressed;
-    dcdr >> m_size;
-    dcdr >> m_hash;
-    dcdr >> m_payload;
-}
-
-size_t string_message_::getKeyMaxCdrSerializedSize(size_t current_alignment)
-{
-	size_t current_align = current_alignment;
-            
-
-
-
-
-
-
-
-
-
-    return current_align;
-}
-
-bool string_message_::isKeyDefined()
-{
-    return false;
-}
-
-void string_message_::serializeKey(eprosima::fastcdr::Cdr &scdr) const
-{
-	(void) scdr;
-	 
-	 
-	 
-	 
-	 
-	 
-	 
-	 
-}
\ No newline at end of file
diff --git a/ecal/core/src/readwrite/fastrtps/string_message_.h b/ecal/core/src/readwrite/fastrtps/string_message_.h
deleted file mode 100644
index d970f31a11..0000000000
--- a/ecal/core/src/readwrite/fastrtps/string_message_.h
+++ /dev/null
@@ -1,394 +0,0 @@
-// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima).
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-/*! 
- * @file string_message_.h
- * This header file contains the declaration of the described types in the IDL file.
- *
- * This file was generated by the tool gen.
- */
-
-#ifndef _STRING_MESSAGE__H_
-#define _STRING_MESSAGE__H_
-
-// TODO Poner en el contexto.
-
-#include <stdint.h>
-#include <array>
-#include <string>
-#include <vector>
-
-#if defined(_WIN32)
-#if defined(EPROSIMA_USER_DLL_EXPORT)
-#define eProsima_user_DllExport __declspec( dllexport )
-#else
-#define eProsima_user_DllExport
-#endif
-#else
-#define eProsima_user_DllExport
-#endif
-
-#if defined(_WIN32)
-#if defined(EPROSIMA_USER_DLL_EXPORT)
-#if defined(string_message__SOURCE)
-#define string_message__DllAPI __declspec( dllexport )
-#else
-#define string_message__DllAPI __declspec( dllimport )
-#endif // string_message__SOURCE
-#else
-#define string_message__DllAPI
-#endif
-#else
-#define string_message__DllAPI
-#endif // _WIN32
-
-namespace eprosima
-{
-    namespace fastcdr
-    {
-        class Cdr;
-    }
-}
-
-/*!
- * @brief This class represents the structure string_message_ defined by the user in the IDL file.
- * @ingroup STRING_MESSAGE_
- */
-class string_message_
-{
-public:
-
-    /*!
-     * @brief Default constructor.
-     */
-    eProsima_user_DllExport string_message_();
-    
-    /*!
-     * @brief Default destructor.
-     */
-    eProsima_user_DllExport ~string_message_();
-    
-    /*!
-     * @brief Copy constructor.
-     * @param x Reference to the object string_message_ that will be copied.
-     */
-    eProsima_user_DllExport string_message_(const string_message_ &x);
-    
-    /*!
-     * @brief Move constructor.
-     * @param x Reference to the object string_message_ that will be copied.
-     */
-    eProsima_user_DllExport string_message_(string_message_ &&x);
-    
-    /*!
-     * @brief Copy assignment.
-     * @param x Reference to the object string_message_ that will be copied.
-     */
-    eProsima_user_DllExport string_message_& operator=(const string_message_ &x);
-    
-    /*!
-     * @brief Move assignment.
-     * @param x Reference to the object string_message_ that will be copied.
-     */
-    eProsima_user_DllExport string_message_& operator=(string_message_ &&x);
-    
-    /*!
-     * @brief This function copies the value in member tid
-     * @param _tid New value to be copied in member tid
-     */
-    inline eProsima_user_DllExport void tid(const std::string &_tid)
-    {
-        m_tid = _tid;
-    }
-
-    /*!
-     * @brief This function moves the value in member tid
-     * @param _tid New value to be moved in member tid
-     */
-    inline eProsima_user_DllExport void tid(std::string &&_tid)
-    {
-        m_tid = std::move(_tid);
-    }
-
-    /*!
-     * @brief This function returns a constant reference to member tid
-     * @return Constant reference to member tid
-     */
-    inline eProsima_user_DllExport const std::string& tid() const
-    {
-        return m_tid;
-    }
-
-    /*!
-     * @brief This function returns a reference to member tid
-     * @return Reference to member tid
-     */
-    inline eProsima_user_DllExport std::string& tid()
-    {
-        return m_tid;
-    }
-    /*!
-     * @brief This function sets a value in member id
-     * @param _id New value for member id
-     */
-    inline eProsima_user_DllExport void id(int64_t _id)
-    {
-        m_id = _id;
-    }
-
-    /*!
-     * @brief This function returns the value of member id
-     * @return Value of member id
-     */
-    inline eProsima_user_DllExport int64_t id() const
-    {
-        return m_id;
-    }
-
-    /*!
-     * @brief This function returns a reference to member id
-     * @return Reference to member id
-     */
-    inline eProsima_user_DllExport int64_t& id()
-    {
-        return m_id;
-    }
-    /*!
-     * @brief This function sets a value in member clock
-     * @param _clock New value for member clock
-     */
-    inline eProsima_user_DllExport void clock(int64_t _clock)
-    {
-        m_clock = _clock;
-    }
-
-    /*!
-     * @brief This function returns the value of member clock
-     * @return Value of member clock
-     */
-    inline eProsima_user_DllExport int64_t clock() const
-    {
-        return m_clock;
-    }
-
-    /*!
-     * @brief This function returns a reference to member clock
-     * @return Reference to member clock
-     */
-    inline eProsima_user_DllExport int64_t& clock()
-    {
-        return m_clock;
-    }
-    /*!
-     * @brief This function sets a value in member time
-     * @param _time New value for member time
-     */
-    inline eProsima_user_DllExport void time(int64_t _time)
-    {
-        m_time = _time;
-    }
-
-    /*!
-     * @brief This function returns the value of member time
-     * @return Value of member time
-     */
-    inline eProsima_user_DllExport int64_t time() const
-    {
-        return m_time;
-    }
-
-    /*!
-     * @brief This function returns a reference to member time
-     * @return Reference to member time
-     */
-    inline eProsima_user_DllExport int64_t& time()
-    {
-        return m_time;
-    }
-    /*!
-     * @brief This function sets a value in member compressed
-     * @param _compressed New value for member compressed
-     */
-    inline eProsima_user_DllExport void compressed(char _compressed)
-    {
-        m_compressed = _compressed;
-    }
-
-    /*!
-     * @brief This function returns the value of member compressed
-     * @return Value of member compressed
-     */
-    inline eProsima_user_DllExport char compressed() const
-    {
-        return m_compressed;
-    }
-
-    /*!
-     * @brief This function returns a reference to member compressed
-     * @return Reference to member compressed
-     */
-    inline eProsima_user_DllExport char& compressed()
-    {
-        return m_compressed;
-    }
-    /*!
-     * @brief This function sets a value in member size
-     * @param _size New value for member size
-     */
-    inline eProsima_user_DllExport void size(int64_t _size)
-    {
-        m_size = _size;
-    }
-
-    /*!
-     * @brief This function returns the value of member size
-     * @return Value of member size
-     */
-    inline eProsima_user_DllExport int64_t size() const
-    {
-        return m_size;
-    }
-
-    /*!
-     * @brief This function returns a reference to member size
-     * @return Reference to member size
-     */
-    inline eProsima_user_DllExport int64_t& size()
-    {
-        return m_size;
-    }
-    /*!
-     * @brief This function sets a value in member hash
-     * @param _hash New value for member hash
-     */
-    inline eProsima_user_DllExport void hash(uint64_t _hash)
-    {
-        m_hash = _hash;
-    }
-
-    /*!
-     * @brief This function returns the value of member hash
-     * @return Value of member hash
-     */
-    inline eProsima_user_DllExport uint64_t hash() const
-    {
-        return m_hash;
-    }
-
-    /*!
-     * @brief This function returns a reference to member hash
-     * @return Reference to member hash
-     */
-    inline eProsima_user_DllExport uint64_t& hash()
-    {
-        return m_hash;
-    }
-    /*!
-     * @brief This function copies the value in member payload
-     * @param _payload New value to be copied in member payload
-     */
-    inline eProsima_user_DllExport void payload(const std::vector<char> &_payload)
-    {
-        m_payload = _payload;
-    }
-
-    /*!
-     * @brief This function moves the value in member payload
-     * @param _payload New value to be moved in member payload
-     */
-    inline eProsima_user_DllExport void payload(std::vector<char> &&_payload)
-    {
-        m_payload = std::move(_payload);
-    }
-
-    /*!
-     * @brief This function returns a constant reference to member payload
-     * @return Constant reference to member payload
-     */
-    inline eProsima_user_DllExport const std::vector<char>& payload() const
-    {
-        return m_payload;
-    }
-
-    /*!
-     * @brief This function returns a reference to member payload
-     * @return Reference to member payload
-     */
-    inline eProsima_user_DllExport std::vector<char>& payload()
-    {
-        return m_payload;
-    }
-    
-    /*!
-     * @brief This function returns the maximum serialized size of an object
-     * depending on the buffer alignment.
-     * @param current_alignment Buffer alignment.
-     * @return Maximum serialized size.
-     */
-    eProsima_user_DllExport static size_t getMaxCdrSerializedSize(size_t current_alignment = 0);
-
-    /*!
-     * @brief This function returns the serialized size of a data depending on the buffer alignment.
-     * @param data Data which is calculated its serialized size.
-     * @param current_alignment Buffer alignment.
-     * @return Serialized size.
-     */
-    eProsima_user_DllExport static size_t getCdrSerializedSize(const string_message_& data, size_t current_alignment = 0);
-
-
-    /*!
-     * @brief This function serializes an object using CDR serialization.
-     * @param cdr CDR serialization object.
-     */
-    eProsima_user_DllExport void serialize(eprosima::fastcdr::Cdr &cdr) const;
-
-    /*!
-     * @brief This function deserializes an object using CDR serialization.
-     * @param cdr CDR serialization object.
-     */
-    eProsima_user_DllExport void deserialize(eprosima::fastcdr::Cdr &cdr);
-
-
-
-    /*!
-     * @brief This function returns the maximum serialized size of the Key of an object
-     * depending on the buffer alignment.
-     * @param current_alignment Buffer alignment.
-     * @return Maximum serialized size.
-     */
-    eProsima_user_DllExport static size_t getKeyMaxCdrSerializedSize(size_t current_alignment = 0);
-
-    /*!
-     * @brief This function tells you if the Key has been defined for this type
-     */
-    eProsima_user_DllExport static bool isKeyDefined();
-
-    /*!
-     * @brief This function serializes the key members of an object using CDR serialization.
-     * @param cdr CDR serialization object.
-     */
-    eProsima_user_DllExport void serializeKey(eprosima::fastcdr::Cdr &cdr) const;
-    
-private:
-    std::string m_tid;
-    int64_t m_id;
-    int64_t m_clock;
-    int64_t m_time;
-    char m_compressed;
-    int64_t m_size;
-    uint64_t m_hash;
-    std::vector<char> m_payload;
-};
-
-#endif // _STRING_MESSAGE__H_
\ No newline at end of file
diff --git a/ecal/core/src/readwrite/fastrtps/string_message_.idl b/ecal/core/src/readwrite/fastrtps/string_message_.idl
deleted file mode 100644
index cfe60d321a..0000000000
--- a/ecal/core/src/readwrite/fastrtps/string_message_.idl
+++ /dev/null
@@ -1,11 +0,0 @@
-struct string_message_
-{
-  string              tid;         // unique topic id (internally)
-  long long           id;          // topic user id (Publisher::SetID() for subscriber side filtering)
-  long long           clock;       // topic clock
-  long long           time;        // topic time stamp
-  char                compressed;  // payload compression mode
-  long long           size;        // uncompressed size
-  unsigned long long  hash;        // unique hash for that sample
-  sequence<char>      payload;     // octet stream
-};
diff --git a/ecal/core/src/readwrite/fastrtps/string_message_PubSubTypes.cxx b/ecal/core/src/readwrite/fastrtps/string_message_PubSubTypes.cxx
deleted file mode 100644
index ad5d9cda34..0000000000
--- a/ecal/core/src/readwrite/fastrtps/string_message_PubSubTypes.cxx
+++ /dev/null
@@ -1,123 +0,0 @@
-// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima).
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-/*! 
- * @file string_message_PubSubTypes.cpp
- * This header file contains the implementation of the serialization functions.
- *
- * This file was generated by the tool fastcdrgen.
- */
-
-
-#include <fastcdr/FastBuffer.h>
-#include <fastcdr/Cdr.h>
-
-#include "string_message_PubSubTypes.h"
-
-using namespace eprosima::fastrtps;
-using namespace eprosima::fastrtps::rtps;
-
-string_message_PubSubType::string_message_PubSubType() {
-    setName("string_message_");
-    m_typeSize = (uint32_t)string_message_::getMaxCdrSerializedSize() + 4 /*encapsulation*/;
-    m_isGetKeyDefined = string_message_::isKeyDefined();
-    m_keyBuffer = (unsigned char*)malloc(string_message_::getKeyMaxCdrSerializedSize()>16 ? string_message_::getKeyMaxCdrSerializedSize() : 16);
-}
-
-string_message_PubSubType::~string_message_PubSubType() {
-    if(m_keyBuffer!=nullptr)
-        free(m_keyBuffer);
-}
-
-bool string_message_PubSubType::serialize(void *data, SerializedPayload_t *payload) {
-    string_message_ *p_type = (string_message_*) data;
-    eprosima::fastcdr::FastBuffer fastbuffer((char*) payload->data, payload->max_size); // Object that manages the raw buffer.
-    eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN,
-            eprosima::fastcdr::Cdr::DDS_CDR); // Object that serializes the data.
-    payload->encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE;
-    // Serialize encapsulation
-    ser.serialize_encapsulation();
-
-    try
-    {
-        p_type->serialize(ser); // Serialize the object:
-    }
-    catch(eprosima::fastcdr::exception::NotEnoughMemoryException& /*exception*/)
-    {
-        return false;
-    }
-
-    payload->length = (uint32_t)ser.getSerializedDataLength(); //Get the serialized length
-    return true;
-}
-
-bool string_message_PubSubType::deserialize(SerializedPayload_t* payload, void* data) {
-    string_message_* p_type = (string_message_*) data; 	//Convert DATA to pointer of your type
-    eprosima::fastcdr::FastBuffer fastbuffer((char*)payload->data, payload->length); // Object that manages the raw buffer.
-    eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN,
-            eprosima::fastcdr::Cdr::DDS_CDR); // Object that deserializes the data.
-    // Deserialize encapsulation.
-    deser.read_encapsulation();
-    payload->encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE;
-
-    try
-    {
-        p_type->deserialize(deser); //Deserialize the object:
-    }
-    catch(eprosima::fastcdr::exception::NotEnoughMemoryException& /*exception*/)
-    {
-        return false;
-    }
-
-    return true;
-}
-
-std::function<uint32_t()> string_message_PubSubType::getSerializedSizeProvider(void* data) {
-    return [data]() -> uint32_t
-    {
-        return (uint32_t)type::getCdrSerializedSize(*static_cast<string_message_*>(data)) + 4 /*encapsulation*/;
-    };
-}
-
-void* string_message_PubSubType::createData() {
-    return (void*)new string_message_();
-}
-
-void string_message_PubSubType::deleteData(void* data) {
-    delete((string_message_*)data);
-}
-
-bool string_message_PubSubType::getKey(void *data, InstanceHandle_t* handle) {
-    if(!m_isGetKeyDefined)
-        return false;
-    string_message_* p_type = (string_message_*) data;
-    eprosima::fastcdr::FastBuffer fastbuffer((char*)m_keyBuffer,string_message_::getKeyMaxCdrSerializedSize()); 	// Object that manages the raw buffer.
-    eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS); 	// Object that serializes the data.
-    p_type->serializeKey(ser);
-    if(string_message_::getKeyMaxCdrSerializedSize()>16)	{
-        m_md5.init();
-        m_md5.update(m_keyBuffer,(unsigned int)ser.getSerializedDataLength());
-        m_md5.finalize();
-        for(uint8_t i = 0;i<16;++i)    	{
-            handle->value[i] = m_md5.digest[i];
-        }
-    }
-    else    {
-        for(uint8_t i = 0;i<16;++i)    	{
-            handle->value[i] = m_keyBuffer[i];
-        }
-    }
-    return true;
-}
-
diff --git a/ecal/core/src/readwrite/fastrtps/string_message_PubSubTypes.h b/ecal/core/src/readwrite/fastrtps/string_message_PubSubTypes.h
deleted file mode 100644
index 2b3346e586..0000000000
--- a/ecal/core/src/readwrite/fastrtps/string_message_PubSubTypes.h
+++ /dev/null
@@ -1,50 +0,0 @@
-// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima).
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-/*! 
- * @file string_message_PubSubTypes.h
- * This header file contains the declaration of the serialization functions.
- *
- * This file was generated by the tool fastcdrgen.
- */
-
-
-#ifndef _STRING_MESSAGE__PUBSUBTYPES_H_
-#define _STRING_MESSAGE__PUBSUBTYPES_H_
-
-#include <fastrtps/TopicDataType.h>
-
-#include "string_message_.h"
-
-/*!
- * @brief This class represents the TopicDataType of the type string_message_ defined by the user in the IDL file.
- * @ingroup STRING_MESSAGE_
- */
-class string_message_PubSubType : public eprosima::fastrtps::TopicDataType {
-public:
-        typedef string_message_ type;
-
-	string_message_PubSubType();
-	virtual ~string_message_PubSubType();
-	bool serialize(void *data, eprosima::fastrtps::rtps::SerializedPayload_t *payload);
-	bool deserialize(eprosima::fastrtps::rtps::SerializedPayload_t *payload, void *data);
-        std::function<uint32_t()> getSerializedSizeProvider(void* data);
-	bool getKey(void *data, eprosima::fastrtps::rtps::InstanceHandle_t *ihandle);
-	void* createData();
-	void deleteData(void * data);
-	MD5 m_md5;
-	unsigned char* m_keyBuffer;
-};
-
-#endif // _STRING_MESSAGE__PUBSUBTYPES_H_
\ No newline at end of file
diff --git a/ecal/core/src/readwrite/lcm/lcmlite.cpp b/ecal/core/src/readwrite/lcm/lcmlite.cpp
deleted file mode 100644
index ef40d0b5bb..0000000000
--- a/ecal/core/src/readwrite/lcm/lcmlite.cpp
+++ /dev/null
@@ -1,333 +0,0 @@
-#include <stdint.h>
-#include <string.h>
-#include <stdio.h>
-
-#include "lcmlite.h"
-
-#define MAGIC_LCM2 0x4c433032
-#define MAGIC_LCM3 0x4c433033
-
-// header can contain a channel plus our usual header.
-#define MAXIMUM_HEADER_LENGTH 300
-
-static inline void encode_u32(uint8_t *p, uint32_t v)
-{
-    // big endian. p[3] gets lowest 8 bits.
-    p[3] = v & 0xff;
-    v >>= 8;
-    p[2] = v & 0xff;
-    v >>= 8;
-    p[1] = v & 0xff;
-    v >>= 8;
-    p[0] = v & 0xff;
-}
-
-static inline uint32_t decode_u32(const uint8_t *p)
-{
-    uint32_t v = 0;
-
-    // big endian. p[0] gets most significant bits.
-    v |= p[0];
-    v <<= 8;
-    v |= p[1];
-    v <<= 8;
-    v |= p[2];
-    v <<= 8;
-    v |= p[3];
-
-    return v;
-}
-
-static inline void encode_u16(uint8_t *p, uint16_t v)
-{
-    // big endian. p[1] gets lowest 8 bits.
-    p[1] = v & 0xff;
-    v >>= 8;
-    p[0] = v & 0xff;
-}
-
-static inline uint16_t decode_u16(const uint8_t *p)
-{
-    uint16_t v = 0;
-
-    // big endian. p[0] gets most significant bits.
-    v |= p[0];
-    v <<= 8;
-    v |= p[1];
-
-    return v;
-}
-
-// Called by lcmlite internally when a packet is decoded. (Provides a
-// common delivery code path for fragmented and non-fragmented
-// packets.)
-static void deliver_packet(lcmlite_sub_t *lcm, const char *channel, const void *buf, int buf_len)
-{
-//    printf("deliver packet, channel %-30s, size %10d\n", channel, buflen);
-
-    for (lcmlite_subscription_t *sub = lcm->first_subscription; sub != NULL; sub = sub->next) {
-
-        int good = 1;
-
-        for (int pos = 0; 1; pos++) {
-
-            // special case: does the channel have a wildcard-like expression in it?
-            if (sub->channel[pos] == '.' && sub->channel[pos+1] == '*')
-                break;
-
-            if (sub->channel[pos] == channel[pos]) {
-                // end of both strings? if so, we're done.
-                if (channel[pos] == 0)
-                    break;
-
-                // proceed to the next letter
-                continue;
-            }
-
-            // not a match.
-            good = 0;
-            break;
-        }
-
-        if (good)
-            sub->callback(lcm, channel, buf, buf_len, sub->user);
-    }
-}
-
-// The caller allocates permanent storage for LCMLite. This initializes
-int lcmlite_sub_init(lcmlite_sub_t *lcm)
-{
-    memset(lcm, 0, sizeof(lcmlite_sub_t));
-    return 0;
-}
-
-// The caller allocates permanent storage for LCMLite. This initializes
-int lcmlite_pub_init(lcmlite_pub_t *lcm, void(*transmit_packet)(const void *_buf, int buf_len, void *user), void *transmit_user)
-{
-  memset(lcm, 0, sizeof(lcmlite_pub_t));
-  lcm->transmit_packet = transmit_packet;
-  lcm->transmit_user = transmit_user;
-  return 0;
-}
-
-/** Call this function whenever an LCM UDP packet is
- * received. Registered LCM handlers will be called
- * synchronously. When the function returns, the buffer can be safely
- * reused. Returns non-zero if the packet was not decoded properly,
- * but no special action is required by the caller.
- *
- * from_addr is opaque, but should uniquely identify the sender's IP
- * address and port.
- **/
-int lcmlite_receive_packet(lcmlite_sub_t *lcm, const void *_buf, int buf_len, uint64_t from_addr)
-{
-    uint8_t *buf = (uint8_t*) _buf;
-    int buf_pos = 0;
-
-    // not even a header's length
-    if (buf_len < 4)
-        return -1;
-
-    uint32_t magic = decode_u32(&buf[buf_pos]);  buf_pos += 4;
-
-    if (magic == MAGIC_LCM2) {
-
-        uint32_t msg_seq = decode_u32(&buf[buf_pos]);  buf_pos += 4;
-        (void) msg_seq; // quiet unused variable warning.
-
-        // copy out zero-terminated string holding the channel #.
-        char channel[LCM_MAX_CHANNEL_LENGTH];
-        int channel_len = 0;
-
-        while (buf[buf_pos] != 0) {
-            // malformed packet.
-            if (buf_pos >= buf_len || channel_len >= LCM_MAX_CHANNEL_LENGTH)
-                return -2;
-
-            channel[channel_len++] = buf[buf_pos++];
-        }
-        channel[channel_len] = 0;
-        buf_pos++; // skip the zero.
-
-        deliver_packet(lcm, channel, &buf[buf_pos], buf_len - buf_pos);
-
-    } else if (magic == MAGIC_LCM3) {
-
-#if LCM3_NUM_BUFFERS == 0
-        return -3;
-#endif
-
-        uint32_t msg_seq = decode_u32(&buf[buf_pos]);           buf_pos += 4;
-        uint32_t msg_size = decode_u32(&buf[buf_pos]);          buf_pos += 4;
-        uint32_t fragment_offset = decode_u32(&buf[buf_pos]);   buf_pos += 4;
-        uint32_t fragment_id = decode_u16(&buf[buf_pos]);       buf_pos += 2;
-        uint32_t fragments_in_msg = decode_u16(&buf[buf_pos]);  buf_pos += 2;
-
-        int payload_len = buf_len - buf_pos;
-
-        // printf("%08x:%08x %d / %d\n", from_addr, msg_seq, fragment_id, fragments_in_msg);
-
-        // validate packet metadata
-        if (msg_size > LCM3_MAX_PACKET_SIZE)
-            return -4;
-
-        if (fragments_in_msg > LCM3_MAX_FRAGMENTS)
-            return -5;
-
-        if (fragment_id >= fragments_in_msg || fragment_offset + payload_len > msg_size)
-            return -6;
-
-        // find the fragment. Use a simple linear search; this is
-        // cheap in comparison to how much work we're spending to
-        // decode the large packet...
-        struct fragment_buffer *fbuf = NULL;
-
-        // try to find a reassembly buffer for this from_addr that's already in progress
-        for (int idx = 0; idx < LCM3_NUM_BUFFERS; idx++) {
-
-            if (lcm->fragment_buffers[idx].from_addr == from_addr &&
-                lcm->fragment_buffers[idx].msg_seq == msg_seq) {
-                fbuf = &lcm->fragment_buffers[idx];
-                break;
-            }
-        }
-
-        if (fbuf == NULL) {
-            // didn't find one. Pick a new buffer to use.
-
-            // Priorities:
-            //   1) an idle (complete) buffer
-            //   2) the incomplete buffer that received a valid fragment the longest time ago.
-            int32_t max_age = -1; // low scores are good.
-            for (int idx = 0; idx < LCM3_NUM_BUFFERS; idx++) {
-                if (lcm->fragment_buffers[idx].fragments_remaining == 0) {
-                    fbuf = &lcm->fragment_buffers[idx];
-                    break;
-                } else {
-                    int32_t age = lcm->last_fragment_count - lcm->fragment_buffers[idx].last_fragment_count;
-                    if (age > max_age) {
-                        fbuf = &lcm->fragment_buffers[idx];
-                        max_age = age;
-                    }
-                }
-            }
-
-            if (fbuf == NULL)
-                return -7; // this should never happen
-
-            // initialize the fragment buffer
-            for (uint32_t i = 0; i < fragments_in_msg; i++) {
-                fbuf->frag_received[i] = 0;
-            }
-
-            fbuf->from_addr = from_addr;
-            fbuf->msg_seq = msg_seq;
-            fbuf->fragments_remaining = fragments_in_msg;
-        }
-
-        // now, handle this fragment
-        fbuf->last_fragment_count = lcm->last_fragment_count;
-        lcm->last_fragment_count++;
-
-        if (fragment_id == 0) {
-            // this fragment contains the channel name plus data
-            int channel_len = 0;
-            while (buf[buf_pos] != 0) {
-                if (buf_pos >= buf_len || channel_len >= LCM_MAX_CHANNEL_LENGTH)
-                    return -8;
-                fbuf->channel[channel_len++] = buf[buf_pos++];
-            }
-            fbuf->channel[channel_len] = 0;
-            buf_pos++; // skip the zero.
-        }
-
-        if (buf_pos < buf_len)
-            memcpy(&fbuf->buf[fragment_offset], &buf[buf_pos], buf_len - buf_pos);
-
-        // record reception of this packet
-        if (fbuf->frag_received[fragment_id] == 0) {
-            fbuf->frag_received[fragment_id] = 1;
-            fbuf->fragments_remaining--;
-
-            if (fbuf->fragments_remaining == 0) {
-                deliver_packet(lcm, fbuf->channel, fbuf->buf, msg_size);
-            }
-        }
-    }
-
-    return 0;
-}
-
-void lcmlite_subscribe(lcmlite_sub_t *lcm, lcmlite_subscription_t *sub)
-{
-    sub->next = lcm->first_subscription;
-    lcm->first_subscription = sub;
-}
-
-int lcmlite_publish(lcmlite_pub *lcm, const char *channel, const void *_buf, int buf_len)
-{
-    if (buf_len < LCM_PUBLISH_BUFFER_SIZE - MAXIMUM_HEADER_LENGTH) {
-        // publish non-fragmented message
-        uint32_t buf_pos = 0;
-
-        encode_u32(&lcm->publish_buffer[buf_pos], MAGIC_LCM2);      buf_pos += 4;
-        encode_u32(&lcm->publish_buffer[buf_pos], lcm->msg_seq);    buf_pos += 4;
-        lcm->msg_seq++;
-
-        // copy channel
-        while (*channel != 0) {
-            lcm->publish_buffer[buf_pos++] = *channel;
-            channel++;
-        }
-        lcm->publish_buffer[buf_pos++] =0 ;
-
-        memcpy(&lcm->publish_buffer[buf_pos], _buf, buf_len);       buf_pos += buf_len;
-
-        lcm->transmit_packet(lcm->publish_buffer, buf_pos, lcm->transmit_user);
-
-        return 0;
-    } else {
-        // send fragmented message
-        uint32_t msg_seq = lcm->msg_seq;
-        lcm->msg_seq++;
-
-        uint32_t fragment_offset = 0;
-        uint32_t max_fragment_size = LCM_PUBLISH_BUFFER_SIZE - MAXIMUM_HEADER_LENGTH;
-        uint32_t fragment_id = 0;
-        uint32_t fragments_in_msg = (buf_len + max_fragment_size - 1) / max_fragment_size;
-
-        while (fragment_offset < (uint32_t)buf_len) {
-            uint32_t buf_pos = 0;
-
-            encode_u32(&lcm->publish_buffer[buf_pos], MAGIC_LCM3);                 buf_pos += 4;
-            encode_u32(&lcm->publish_buffer[buf_pos], msg_seq);                    buf_pos += 4;
-            encode_u32(&lcm->publish_buffer[buf_pos], buf_len);                    buf_pos += 4;
-            encode_u32(&lcm->publish_buffer[buf_pos], fragment_offset);            buf_pos += 4;
-            encode_u16(&lcm->publish_buffer[buf_pos], (uint16_t)fragment_id);      buf_pos += 2;
-            encode_u16(&lcm->publish_buffer[buf_pos], (uint16_t)fragments_in_msg); buf_pos += 2;
-
-            // copy channel
-            if (fragment_id == 0) {
-                while (*channel != 0) {
-                    lcm->publish_buffer[buf_pos++] = *channel;
-                    channel++;
-                }
-                lcm->publish_buffer[buf_pos++] =0 ;
-            }
-
-            uint32_t this_fragment_size = buf_len - fragment_offset;
-            if (this_fragment_size > max_fragment_size)
-                this_fragment_size = max_fragment_size;
-
-            memcpy(&lcm->publish_buffer[buf_pos], &((char*) _buf)[fragment_offset], this_fragment_size);
-            buf_pos += this_fragment_size;
-
-            lcm->transmit_packet(lcm->publish_buffer, buf_pos, lcm->transmit_user);
-
-            fragment_offset += this_fragment_size;
-            fragment_id++;
-        }
-    }
-
-    return 0;
-}
diff --git a/ecal/core/src/readwrite/lcm/lcmlite.h b/ecal/core/src/readwrite/lcm/lcmlite.h
deleted file mode 100644
index 5626d03bf4..0000000000
--- a/ecal/core/src/readwrite/lcm/lcmlite.h
+++ /dev/null
@@ -1,127 +0,0 @@
-#ifndef _LCMLITE_H
-#define _LCMLITE_H
-
-#include <stdint.h>
-
-/** LCM Lite is a minimalist implementation of LCM designed to
- * minimize external dependencies and memory usage, making it the
- * easiest way to port LCM to a new platform, particularly
- * resource-limited embedded platforms.
- *
- * There are two main differences between LCM-Lite and the standard
- * LCM:
- *
- * 1) The actual communications code must be provided by the
- * user. (However, see lcmlite_posix for an example of how to provide
- * this functionality for most POSIX systems). In short, you call an
- * lcmlite function whenever an LCM UDP packet arrives, and you
- * provide a function pointer that will transmit packets (which
- * LCMLite will call as necessary).
- *
- * 2) LCMLite itself does no runtime memory allocation; all memory
- * structures are allocated either at compile time or by the
- * caller. This means that the system does not need an implementation
- * of malloc(), and that issues of memory fragmentation are avoided.
- *
- * Most of the memory is allocated with the lcmlite_t object. This can
- * be too large for many stacks, so it is recommended to declare this
- * as a static global variable. The memory footprint is determined by
- * the defines below.
- **/
-
-// Disable long packet reception by setting NUM BUFFERS to zero.
-// Total memory allocated is roughly:
-//
-// NUM_BUFFERS*(MAX_PACKET_SIZE + MAX_FRAGMENTS + CHANNEL_LENGTH) + PUBLISH_BUFFER_SIZE
-//
-// Note that for full LCM compatibility, CHANNEL_LENGTH must be 256.
-//
-#define LCM3_NUM_BUFFERS         8              // increased from 4 to 8
-#define LCM3_MAX_PACKET_SIZE    (4*1024*1024)   // increased from ca. 300 kB to 4 MB
-#define LCM3_MAX_FRAGMENTS       512            // increased from 256 to 512
-
-#define LCM_MAX_CHANNEL_LENGTH   256
-
-// LCMLite will allocate a single buffer of the size below for
-// publishing messages. The LCM3 fragmentation option will be used to
-// send messages larger than this.
-#define LCM_PUBLISH_BUFFER_SIZE  8192
-
-typedef struct lcmlite_subscription lcmlite_subscription_t;
-typedef struct lcmlite_sub lcmlite_sub_t;
-typedef struct lcmlite_pub lcmlite_pub_t;
-
-struct fragment_buffer
-{
-    int32_t last_fragment_count;
-
-    uint64_t from_addr;
-    uint32_t msg_seq;
-
-    char channel[LCM_MAX_CHANNEL_LENGTH];
-    int fragments_remaining;
-    char buf[LCM3_MAX_PACKET_SIZE];
-    uint8_t frag_received[LCM3_MAX_FRAGMENTS];
-};
-
-struct lcmlite_subscription
-{
-    char *channel;
-
-    void (*callback)(lcmlite_sub_t *lcm, const char *channel, const void *buf, int buf_len, void *user);
-    void *user;
-
-    // 'next' field is for lcmlite internal use.
-    lcmlite_subscription_t *next;
-};
-
-struct lcmlite_sub
-{
-    /** Buffers for reassembling multi-fragment messages. **/
-    struct fragment_buffer fragment_buffers[LCM3_NUM_BUFFERS];
-
-    /** every time we receive a fragment, we increment this counter
-        and write the value to the corresponding fragment buffer. This
-        allows us to measure how "stale" a fragment is (how long it's
-        been since we received a fragment for it).
-    **/
-    int32_t last_fragment_count;
-
-    lcmlite_subscription_t *first_subscription;
-};
-
-struct lcmlite_pub
-{
-  void(*transmit_packet)(const void *_buf, int buf_len, void *user);
-  void *transmit_user;
-
-  uint8_t publish_buffer[LCM_PUBLISH_BUFFER_SIZE];
-  uint32_t msg_seq;
-};
-
-// Caller allocates the lcmlite_t object, which we initialize.
-int lcmlite_sub_init(lcmlite_sub_t *lcm);
-
-// Caller allocates the lcmlite_t object, which we initialize.
-int lcmlite_pub_init(lcmlite_pub_t *lcm, void(*transmit_packet)(const void *_buf, int buf_len, void *user), void *transmit_user);
-
-// The user is responsible for creating and listening on a UDP
-// multicast socket. When a packet is received, call this function. Do
-// not call this function from more than one thread at a time. Returns
-// zero if the packet was successfully handled by LCM, however no
-// special action is required by the caller when an error occurs.
-int lcmlite_receive_packet(lcmlite_sub_t *lcm, const void *_buf, int buf_len, uint64_t from_addr);
-
-// Publish a message. Will call transmit_packet function one or more
-// times synchronously. Returns 0 on success. This function should not
-// be called concurrently with itself, but can be called concurrently
-// with _receive_packet.
-int lcmlite_publish(lcmlite_pub *lcm, const char *channel, const void *_buf, int buf_len);
-
-// not thread safe WRT lcmlite_receive_packet. Caller allocates
-// subscription record and initializes its fields.  Note that the
-// "channel" field does not support regular expressions, but ending
-// with ".*" is supported as a special case.
-void lcmlite_subscribe(lcmlite_sub_t *lcm, lcmlite_subscription_t *sub);
-
-#endif
diff --git a/ecal/pb/src/ecal/pb/play/service.proto b/ecal/pb/src/ecal/pb/play/service.proto
index 283e5fc2f8..3cadc6f5ee 100644
--- a/ecal/pb/src/ecal/pb/play/service.proto
+++ b/ecal/pb/src/ecal/pb/play/service.proto
@@ -70,7 +70,7 @@ message CommandRequest                   // Request for sending a command to the
   {
     none          = 0;                    // Undefined command (do nothing)
     initialize    = 1;                    // Connect to eCAL (create publishers)
-	de_initialize = 2;                    // Disconnect from eCAL (remove all publishers)
+    de_initialize = 2;                    // Disconnect from eCAL (remove all publishers)
     jump_to       = 3;                    // jump to the rel_time_secs
     play          = 4;                    // Start playback
     pause         = 5;                    // Pause playback
diff --git a/ecal/pb/src/ecal/pb/process.proto b/ecal/pb/src/ecal/pb/process.proto
index d18e449c77..394b0d0cf0 100644
--- a/ecal/pb/src/ecal/pb/process.proto
+++ b/ecal/pb/src/ecal/pb/process.proto
@@ -68,5 +68,8 @@ message Process                                           // process
   int64                     datawrite            = 10;    // data write bytes per sec
   int64                     dataread             = 11;    // data read bytes per sec
   ProcessState              state                = 12;    // process state info
-  eTSyncState               tsync_mode           = 13;    // time sychronisation mode
+  eTSyncState               tsync_state          = 13;    // time sychronisation state
+  string                    tsync_mod_name       = 14;    // time sychronisation module name
+  int32                     component_init_state = 15;    // eCAL component initilization state (eCAL::Initialize(..))
+  string                    component_init_info  = 16;    // like comp_init_state as human readable string (pub|sub|srv|mon|log|time|proc)
 }
diff --git a/ecal/pb/src/ecal/pb/rec/service.proto b/ecal/pb/src/ecal/pb/rec/service.proto
index f41d775eb5..8c33213298 100644
--- a/ecal/pb/src/ecal/pb/rec/service.proto
+++ b/ecal/pb/src/ecal/pb/rec/service.proto
@@ -44,17 +44,17 @@ message Configuration
                                           // max_pre_buffer_length_secs  [float]                   The maximum amount of time to keep in the pre-buffer
                                           // pre_buffering_enabled       [bool]                    Whether pre-buffering is enabled
                                           // host_filter                 [string-list]             List of hosts (\n separated). The recorder will only record channels published by these hosts. If empty, all hosts are allowed.
-										  // record_mode                 [all/blacklist/whitelist] Whether to record all topics or use a blacklist / whitelist to only record some topics. Changing the mode will clear the listed_topics, so it is advisable to also provide a new listed_topics list.
+                                          // record_mode                 [all/blacklist/whitelist] Whether to record all topics or use a blacklist / whitelist to only record some topics. Changing the mode will clear the listed_topics, so it is advisable to also provide a new listed_topics list.
                                           // listed_topics               [string-list]             Whitelist / blacklist, when topic_mode is set accordingly (\n separated). If topic_mode is "all", this setting will be ignored.
-										  
-										  // ==== Job (Start Recording / Save pre buffer) ====
+
+                                          // ==== Job (Start Recording / Save pre buffer) ====
                                           // meas_root_dir               [string]                  The root directory to save the measurement to (un-evaluated format)
                                           // meas_name                   [string]                  The name of the measurement (un-evaluated format)
                                           // description                 [string]                  The description that will be saved to the measurement's doc folder (un-evaluated format)
                                           // max_file_size_mib           [int]                     The maximum HDF5 file size (When exceeding the file size, the measurement will be splitted into multiple files).
-										  
-										  // ==== Add Scenario config ====
-										  // scenario_name               [string]                  The name of the new time point
+
+                                          // ==== Add Scenario config ====
+                                          // scenario_name               [string]                  The name of the new time point
 }
 
 message GetConfigRequest {}
@@ -84,11 +84,11 @@ message CommandRequest                    // request recorder state
     // 
     // In eCALRec 1, the following fields were the "prepare" and "unprepare"
     // state, which meant something like "start pre-buffering" and
-	// "stop pre-buffering". These commands do not exist any more, as the
-	// "pre_buffering_enabled" option is now a configuration item. We can reuse
-	// the prepare and unprepare number, the initialization behaves like the old
-	// prepare commands, as long as the "pre_buffering_enabled" config element
-	// is set.
+    // "stop pre-buffering". These commands do not exist any more, as the
+    // "pre_buffering_enabled" option is now a configuration item. We can reuse
+    // the prepare and unprepare number, the initialization behaves like the old
+    // prepare commands, as long as the "pre_buffering_enabled" config element
+    // is set.
     
     initialize      = 1;                  // Connect to eCAL (create subscribers)                
     de_initialize   = 2;                  // Disconnect from eCAL (remove all subscribers)
diff --git a/ecal/pb/src/ecal/pb/topic.proto b/ecal/pb/src/ecal/pb/topic.proto
index ea967af789..41e2ce424b 100644
--- a/ecal/pb/src/ecal/pb/topic.proto
+++ b/ecal/pb/src/ecal/pb/topic.proto
@@ -25,11 +25,7 @@ enum eTLayerType                                // transport layer
 {
   tl_none            =   0;                     // undefined
   tl_ecal_udp_mc     =   1;                     // ecal udp multicast
-  tl_ecal_udp_uc     =   2;                     // ecal udp unicast
-  tl_ecal_udp_metal  =   3;                     // ecal udp metal
   tl_ecal_shm        =   4;                     // ecal shared memory
-  tl_lcm             =   5;                     // google lcm
-  tl_rtps            =   6;                     // fast rtps
   tl_iceoryx         =   7;                     // iceoryx
   tl_inproc          =  42;                     // inproc (inner process)
   tl_all             = 255;                     // all layer
@@ -91,7 +87,4 @@ message Topic                                   // eCAL topic
   int32            dfreq_max             = 23;  // data frequency reference maximum [mHz]
   int32            dfreq_min_err         = 24;  // data frequency minimum violation error counter
   int32            dfreq_max_err         = 25;  // data frequency maximum violation error counter
-
-  string           mcast_address         = 40;  // the udp multicast group used for that topic (eCALMetal only)
-  int32            mcast_port            = 41;  // the udp multicast port used for that topic  (eCALMetal only)
 }
diff --git a/lang/python/core/ecal/core/core.py b/lang/python/core/ecal/core/core.py
index ac46595944..3029928320 100644
--- a/lang/python/core/ecal/core/core.py
+++ b/lang/python/core/ecal/core/core.py
@@ -217,7 +217,7 @@ def pub_set_layer_mode(topic_handle, layer, mode):
   """ set send mode for specific transport layer
 
   :param topic_handle: the topic handle
-  :param layer: 0 = udp, 1 = shm, 2 = lcm, 3 = not supported, 4 = rtps
+  :param layer: 0 = udp, 1 = shm, 42 = inproc
   :type layer: int
   :param mode: 0 = off, 1 = on,  2 = auto
   :type mode: int
@@ -627,7 +627,7 @@ def set_qos_reliability(self, qpolicy):
   def set_layer_mode(self, layer, mode):
     """ set send mode for specific transport layer
 
-    :param layer: 0 = udp, 1 = shm, 2 = lcm, 3 = not supported, 4 = rtps
+    :param layer: 0 = udp, 1 = shm, 42 = inproc
     :type layer:  int
     :param mode:  0 = off, 1 = on,  2 = auto
     :type layer:  int
diff --git a/lang/python/core/ecal_core_py.pyproj b/lang/python/core/ecal_core_py.pyproj
index 6b8149077f..010a8ba01d 100644
--- a/lang/python/core/ecal_core_py.pyproj
+++ b/lang/python/core/ecal_core_py.pyproj
@@ -9,6 +9,7 @@
     <OutputPath>.</OutputPath>
     <Name>ecal_core_py</Name>
     <RootNamespace>ecal_core_py</RootNamespace>
+    <ProjectGuid>{5edaf79b-03b5-317a-b954-9dba8f0b9b9f}</ProjectGuid>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
     <DebugSymbols>true</DebugSymbols>
diff --git a/lang/python/core/src/README.md b/lang/python/core/src/README.md
deleted file mode 100644
index ca4d113d3a..0000000000
--- a/lang/python/core/src/README.md
+++ /dev/null
@@ -1,136 +0,0 @@
-# This is the eCAL python API
-
-
-Below you have some general ideas on how to use the API and retrieve documentation
-
-### eCALSys
-
-
-        import ecal_sys_python
-        import os
-        
-###### Usage of help -> module[.class[.function]]
-
-        help(ecal_sys_python.eCALSys.restart_task_list)
-        
-###### Can also work with enums
-
-        help(ecal_sys_python.eCAL_Process_eStartMode)
-
-###### This for-loop lists each class in the module
-###### Can also be used to show each function from a specified class
-
-        for function in dir(ecal_sys_python):
-            print function
-
-###### Constructor / Initializer of eCALSys application or any other class
-
-        sys_app = ecal_sys_python.eCALSys() 
-        options = ecal_sys_python.Options()
-        sys_app.set_options(options) # options are empty in this case
-        sys_app.save_config(os.getcwd()+r"\config") #save configuration to file "config" under current working directory
-
-###### Initializer of enum with value
-
-        enum_example = ecal_sys_python.eCAL_Process_eStartMode.proc_smode_normal
-        print enum_example
-
-###### Adding values to a list
-        sys_task = ecal_sys_python.eCALSysTask()
-
-###### Always use such functions in order to make changes to local variabiles if possbile
-        sys_app.add_task(sys_task)
-        print len(sys_app.get_task_list()) 
-###### This will not add the new intance to the list  
-        sys_app.get_task_list().append(ecal_sys_python.eCALSysTask()) 
-        task_list = sys_app.get_task_list()
-        task_list.append(ecal_sys_python.eCALSysTask())
-        print len(sys_app.get_task_list())
-        print len(task_list)
-        
-Reason why this does not work its due to implementation of get_task_list which returns a copy of the list inside the object
-
-
-#### Sample
-
-        import ecal_sys_python
-        import os
-        sys_app = ecal_sys_python.eCALSys() 
-
-        success = sys_app.load_config(r"C:\CTZS_Framework\bin\TestConfig.ecalsys")
-
-        print "Current task list"
-        print "Name\tID\tTarget"
-        for task in sys_app.get_task_list():
-          print task.get_name() + "\t"+str(task.get_id()) + "\t" + task.get_target()
-
-
-        print "\nRunners"
-        print "Name\tID"
-        for runner in sys_app.get_runner_list():
-          print runner.get_name() + "\t"+str(runner.get_id())
-
-        new_task = ecal_sys_python.eCALSysTask()
-        new_task.set_name("Task "+str(len(sys_app.get_task_list())+1))
-        new_task.set_target(sys_app.get_task(1).get_target());
-
-        runner = ecal_sys_python.eCALSysRunner(5,"Notepad Launcher", r"C:\Windows\notepad.exe","","");
-        new_task.set_runner(runner) 
-
-        sys_app.add_task(new_task) 
-        sys_app.add_runner(runner)
-        print "\nAdding runner"
-        print "\nRunners"
-        print "Name\tID"
-        for runner in sys_app.get_runner_list():
-          print runner.get_name() + "\t"+str(runner.get_id())
-
-        print "\nConfiguration after adding a new task"
-        print "Name\tID\tTarget"
-        for task in sys_app.get_task_list():
-          print task.get_name() + "\t"+str(task.get_id()) + "\t" + task.get_target()
-
-        sys_app.get_task(len(sys_app.get_task_list())).start()
-
-        sys_app.remove_runner(runner,False)
-        print "\nRemoving the runnner"
-        print "\nRunners"
-        print "Name\tID"
-        for runner in sys_app.get_runner_list():
-          print runner.get_name() + "\t"+str(runner.get_id())
-
-
-        print "Saving configuration"
-        sys_app.save_config(r"C:\CTZS_Framework\bin\TestConfig.ecalsys")
-        
-
-In order to load a configuration we suggest that you open eCALSys application and save any configuration. 
-For this sample it is for the best if you create at least one empty task and change the path to the configuration file accordingly.
-
-
-### eCALConv
-
-        import ecal_conv_python
-        
-        converter = ecal_conv_python.eCALConv()
-        converter.get_importer_plugins();
-        raw_input("Press Enter to continue...")
-        converter.get_exporter_plugins();
-        raw_input("Press Enter to continue...")
-        converter.set_importer_name("HDF5 Importer")
-        converter.set_input_path("D:\eCAL_TSR_MFCImage_rec\measurement_2018-04-17-16-50-13-466\TMDF831G\measurement_2018-04-17-16-50-13-466.hdf5")
-        converter.set_exporter_name("HDF5 Exporter")
-        converter.set_output_path("D:\eCAL_TSR_MFCImage_rec\measurement_2018-04-17-16-50-13-466\TMDF831fG")
-        converter.set_quite_and_verbose(False,True)
-        converter.set_absolute_timespan(True)
-        converter.set_trim_timespan("1s:10s")
-        converter.set_offset_time("0s")
-        channels_name_map = list()
-        channels_name_map.append("MFCImageRightPb:MFCImageLeftPb")
-        converter.set_channel_name_mapping(channels_name_map)
-        converter.set_exporter_options("splitsize = '1024'")
-
-        
-        converter.run()
-    
-    
diff --git a/lang/python/core/src/ecal_wrap.cxx b/lang/python/core/src/ecal_wrap.cxx
index 7fec89249b..dc8e2134d4 100644
--- a/lang/python/core/src/ecal_wrap.cxx
+++ b/lang/python/core/src/ecal_wrap.cxx
@@ -1051,9 +1051,7 @@ PyObject* client_call_method(PyObject* /*self*/, PyObject* args)   // (client_ha
   PyArg_ParseTuple(args, "nsy#", &client_handle, &method_name, &request, &request_len);
 
   bool called_method{ false };
-  Py_BEGIN_ALLOW_THREADS
-    called_method = client_call_method(client_handle, method_name, request, request_len);
-  Py_END_ALLOW_THREADS
+  called_method = client_call_method(client_handle, method_name, request, request_len);
 
   return(Py_BuildValue("i", called_method));
 }
@@ -1335,8 +1333,17 @@ PyObject* mon_monitoring(PyObject* /*self*/, PyObject* /*args*/)
       val = Py_BuildValue("s", process.state().info().c_str());
       PyDict_SetItemString(processDict, "state_info", val); Py_DECREF(val);
 
-      val = Py_BuildValue("i", process.tsync_mode());
-      PyDict_SetItemString(processDict, "tsync_mode", val); Py_DECREF(val);
+      val = Py_BuildValue("i", process.tsync_state());
+      PyDict_SetItemString(processDict, "tsync_state", val); Py_DECREF(val);
+
+      val = Py_BuildValue("s", process.tsync_mod_name().c_str());
+      PyDict_SetItemString(processDict, "tsync_mod_name", val); Py_DECREF(val);
+
+      val = Py_BuildValue("i", process.component_init_state());
+      PyDict_SetItemString(processDict, "component_init_state", val); Py_DECREF(val);
+
+      val = Py_BuildValue("s", process.component_init_info().c_str());
+      PyDict_SetItemString(processDict, "component_init_info", val); Py_DECREF(val);
     }
 
     // collect service infos
diff --git a/lang/python/ecalhdf5/ecal_hdf5_py.pyproj b/lang/python/ecalhdf5/ecal_hdf5_py.pyproj
index 6bbde5fb49..4230262ad6 100644
--- a/lang/python/ecalhdf5/ecal_hdf5_py.pyproj
+++ b/lang/python/ecalhdf5/ecal_hdf5_py.pyproj
@@ -9,6 +9,7 @@
     <OutputPath>.</OutputPath>
     <Name>ecal_hdf5_py</Name>
     <RootNamespace>ecal_hdf5_py</RootNamespace>
+    <ProjectGuid>{29601a25-64ad-3697-8cf8-39ba154e66ee}</ProjectGuid>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
     <DebugSymbols>true</DebugSymbols>
diff --git a/lib/CustomTclap/CMakeLists.txt b/lib/CustomTclap/CMakeLists.txt
new file mode 100644
index 0000000000..68a9f48a95
--- /dev/null
+++ b/lib/CustomTclap/CMakeLists.txt
@@ -0,0 +1,54 @@
+# ========================= eCAL LICENSE =================================
+#
+# Copyright (C) 2016 - 2019 Continental Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#      http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# ========================= eCAL LICENSE =================================
+
+project(CustomTclap)
+
+find_package(tclap REQUIRED)
+
+set(include_files
+  include/custom_tclap/advanced_tclap_output.h
+  include/custom_tclap/fuzzy_value_switch_arg.h
+)
+
+
+set(src_files
+  src/advanced_tclap_output.cpp
+  src/fuzzy_value_switch_arg.cpp
+)
+
+add_library (${PROJECT_NAME} 
+  ${include_files}
+  ${src_files}
+)
+
+target_link_libraries(${PROJECT_NAME}
+	PUBLIC 
+	    tclap::tclap
+)
+
+target_include_directories(${PROJECT_NAME}
+  PUBLIC include/
+  PRIVATE src/)
+
+if(MSVC)
+  # Create a source tree that mirrors the filesystem
+  msvc_source_tree(${include_files} ${src_files})
+endif()
+
+set_property(TARGET ${PROJECT_NAME} PROPERTY POSITION_INDEPENDENT_CODE ON)
+set_property(TARGET ${PROJECT_NAME} PROPERTY FOLDER lib/)
diff --git a/lib/CustomTclap/include/custom_tclap/advanced_tclap_output.h b/lib/CustomTclap/include/custom_tclap/advanced_tclap_output.h
new file mode 100644
index 0000000000..5415eb4fa0
--- /dev/null
+++ b/lib/CustomTclap/include/custom_tclap/advanced_tclap_output.h
@@ -0,0 +1,98 @@
+/* ========================= eCAL LICENSE =================================
+ *
+ * Copyright (C) 2016 - 2019 Continental Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * ========================= eCAL LICENSE =================================
+*/
+
+#pragma once
+
+#include <tclap/StdOutput.h>
+
+#include <ostream>
+#include <vector>
+#include <set>
+
+namespace CustomTclap
+{
+  /**
+   * @brief The AdvancedTclapOutput is similar to the TCLAP::StdOutput but provides some additional options.
+   *
+   * The AdvancedTclapOutput generates output similar to the TCLAP::StdOutput.
+   * It however exposes some internal parameters to make them user-defined and
+   * adds additional functionality.
+   *
+   * The features are:
+   *
+   *     - The maximum line-width can be set instead of being fixed to 75
+   *
+   *     - The output stream (or multiple streams) can be set. When just
+   *       providing &std::cout, it behaves similar to the TCLAP::StdOutput.
+   *       When providing e.g. an std::stringstream, the string output of this
+   *       class (when printing help or version) can be used by the user code
+   *       and e.g. displayed in a GUI.
+   *
+   *     - When printing the --help or --version, the programm is not killed any
+   *       more but continues running. Of course the user code can still kill
+   *       the program if desired.
+   *
+   *     - Arguments can be hidden from the output, e.g. in cases where
+   *       dreprecated parameters are still supposed to exist but shall not
+   *       appear in the help any more.
+   */
+  class AdvancedTclapOutput : public TCLAP::StdOutput
+  {
+  public:
+    /**
+     * @brief Creates an AdvancedTclapOutput that will publish its output on multiple streams
+     * @param output_streams A vector of streams to publish the output to
+     * @param max_width      The maximum line width of the output
+     */
+    AdvancedTclapOutput(const std::vector<std::ostream*>& output_streams, int max_width);
+
+    /**
+     * @brief Creates an AdvancedTclapOutput that will publish its output to the given stream
+     * @param output_stream The stream to publish the output to (e.g. &std::cout)
+     * @param max_width     The maximum line width of the output
+     */
+    AdvancedTclapOutput(std::ostream* output_stream, int max_width);
+
+    virtual void version(TCLAP::CmdLineInterface &cmd) override;
+    virtual void usage(TCLAP::CmdLineInterface &cmd) override;
+    virtual void failure(TCLAP::CmdLineInterface &cmd, TCLAP::ArgException &e) override;
+
+    /**
+     * @brief Hides / un-hides an argument
+     *
+     * Hidden arguments do not appear in the help or usage output.
+     *
+     * @param argument The argument to hide
+     * @param hidden   Whether the argument shall be hidden
+     */
+    void setArgumentHidden(TCLAP::Arg* argument, bool hidden);
+
+  protected:
+    virtual void shortUsage(TCLAP::CmdLineInterface& cmd, std::ostream& os) const;
+    virtual void longUsage(TCLAP::CmdLineInterface& cmd, std::ostream& os) const;
+
+  private:
+    std::vector<std::vector<TCLAP::Arg*>> createXorListWithoutHiddenArgs(const std::vector<std::vector<TCLAP::Arg*>>& xor_list) const;
+
+  private:
+    std::vector<std::ostream*> output_streams_;
+    int max_width_;
+    std::set<TCLAP::Arg*> hidden_arguments_;
+  };
+}
diff --git a/lib/CustomTclap/include/custom_tclap/fuzzy_value_switch_arg.h b/lib/CustomTclap/include/custom_tclap/fuzzy_value_switch_arg.h
new file mode 100644
index 0000000000..88e5f4c1a5
--- /dev/null
+++ b/lib/CustomTclap/include/custom_tclap/fuzzy_value_switch_arg.h
@@ -0,0 +1,67 @@
+/* ========================= eCAL LICENSE =================================
+ *
+ * Copyright (C) 2016 - 2019 Continental Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * ========================= eCAL LICENSE =================================
+*/
+
+#pragma once
+
+#include <tclap/ValueArg.h>
+#include <string>
+
+namespace CustomTclap
+{
+  /**
+   * @brief A Combination of a SwitchArg and a ValueArg<bool> with auto-detection
+   *
+   * The FuzzyValueSwitchArg aims to combine the advantages of the
+   * TCLAP::SwitchArg and the TCLAP::ValueArg. It is autodetected whether the
+   * parameter becomes a SwitchArg (no following value) or a ValueArg (The user
+   * specified the value on command line):
+   *
+   *     - VALUE MODE: The user can manually turn the switch on or off:
+   *         - {true  | on  | 1} result in true
+   *         - {false | off | 0} result in false
+   *         - Parsing is case-insensitive (i.e. true, TRUE, True, TrUe, ON will
+   *           all result in true)
+   *
+   *         Example: my_prog --setting1 true -a false -b ON -c on
+   *
+   *     - SWITCH MODE: The user does not have to provide true|false
+   *         - When encountering the parameter without any boolean-parsable
+   *           value, it is assumed that the user wants to turn the switch on,
+   *           just like a normal SwitchArg (Why else would he provide the
+   *           parameter)
+   *         - The short version of the argument can be combined with other
+   *           switches. In that case, manuelly providing true/false is not
+   *           supported.
+   *
+   *         Example: my_prog --setting1 -bc
+   *
+   */
+  class FuzzyValueSwitchArg : public TCLAP::ValueArg<bool>
+  {
+  public:
+    FuzzyValueSwitchArg(const std::string &flag, const std::string &name, const std::string &desc, bool req, bool value, const std::string &typeDesc, TCLAP::Visitor *v = NULL);
+    FuzzyValueSwitchArg(const std::string &flag, const std::string &name, const std::string &desc, bool req, bool value, const std::string &typeDesc, TCLAP::CmdLineInterface &parser, TCLAP::Visitor *v = NULL);
+
+    virtual bool processArg(int *i, std::vector<std::string> &args) override;
+
+  private:
+    bool combinedSwitchesMatch(std::string& combinedSwitches);
+    bool lastCombined(std::string& combinedSwitches);
+  };
+}
diff --git a/lib/CustomTclap/src/advanced_tclap_output.cpp b/lib/CustomTclap/src/advanced_tclap_output.cpp
new file mode 100644
index 0000000000..b2b26aca0d
--- /dev/null
+++ b/lib/CustomTclap/src/advanced_tclap_output.cpp
@@ -0,0 +1,223 @@
+/* ========================= eCAL LICENSE =================================
+ *
+ * Copyright (C) 2016 - 2019 Continental Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * ========================= eCAL LICENSE =================================
+*/
+
+#include <custom_tclap/advanced_tclap_output.h>
+
+#include <sstream>
+
+namespace CustomTclap
+{
+  AdvancedTclapOutput::AdvancedTclapOutput(const std::vector<std::ostream*>& output_streams, int max_width)
+    : output_streams_(output_streams)
+    , max_width_(max_width)
+  {}
+
+  AdvancedTclapOutput::AdvancedTclapOutput(std::ostream* output_stream, int max_width)
+    : AdvancedTclapOutput(std::vector<std::ostream*>{output_stream}, max_width)
+  {}
+
+  void AdvancedTclapOutput::version(TCLAP::CmdLineInterface &cmd)
+  {
+    std::string progName = cmd.getProgramName();
+    std::string xversion = cmd.getVersion();
+
+    std::stringstream ss;
+
+    // Create string
+    ss << std::endl << progName << "  version: "
+      << xversion << std::endl << std::endl;
+
+
+    // publish string to all output streams
+    for (std::ostream* output_stream : output_streams_)
+    {
+      (*output_stream) << ss.str();
+    }
+  }
+
+  void AdvancedTclapOutput::usage(TCLAP::CmdLineInterface &cmd)
+  {
+    std::stringstream ss;
+
+    // Create string
+    ss << std::endl << "USAGE: " << std::endl << std::endl;
+    shortUsage(cmd, ss);
+    ss << std::endl << std::endl << "Where: " << std::endl << std::endl;
+    longUsage(cmd, ss);
+    ss << std::endl;
+
+    // publish string to all output streams
+    for (std::ostream* output_stream : output_streams_)
+    {
+      (*output_stream) << ss.str();
+    }
+  }
+
+  void AdvancedTclapOutput::failure(TCLAP::CmdLineInterface &cmd, TCLAP::ArgException &e)
+  {
+    std::stringstream ss;
+
+    // Create string
+
+    std::string progName = cmd.getProgramName();
+
+    ss << "PARSE ERROR: " << e.argId() << std::endl
+      << "             " << e.error() << std::endl << std::endl;
+
+    if (cmd.hasHelpAndVersion())
+    {
+      ss << "Brief USAGE: " << std::endl;
+
+      shortUsage(cmd, ss);
+
+      ss << std::endl << "For complete USAGE and HELP type: "
+        << std::endl << "   " << progName << " --help"
+        << std::endl << std::endl;
+    }
+    else
+    {
+      usage(cmd);
+    }
+
+    // publish string to all output streams
+    for (std::ostream* output_stream : output_streams_)
+    {
+      (*output_stream) << ss.str();
+    }
+
+
+    //throw TCLAP::ExitException(1);
+
+  }
+
+  void AdvancedTclapOutput::setArgumentHidden(TCLAP::Arg* argument, bool hidden)
+  {
+    if (hidden)
+      hidden_arguments_.emplace(argument);
+    else
+      hidden_arguments_.erase(argument);
+  }
+
+  void AdvancedTclapOutput::shortUsage(TCLAP::CmdLineInterface& cmd, std::ostream& os) const
+  {
+    std::list<TCLAP::Arg*>                arg_list = cmd.getArgList();
+    std::string                           prog_name = cmd.getProgramName();
+    TCLAP::XorHandler                     xor_handler = cmd.getXorHandler();
+    std::vector<std::vector<TCLAP::Arg*>> xor_list = xor_handler.getXorList();
+
+    std::string s = prog_name + " ";
+
+    // first the xor
+    xor_list = createXorListWithoutHiddenArgs(xor_list);
+    for (int i = 0; static_cast<size_t>(i) < xor_list.size(); i++)
+    {
+      s += " {";
+      for (TCLAP::ArgVectorIterator it = xor_list[i].begin(); it != xor_list[i].end(); it++)
+      {
+        s += (*it)->shortID() + "|";
+      }
+
+      s[s.length() - 1] = '}';
+    }
+
+    // then the rest
+    for (TCLAP::ArgListIterator it = arg_list.begin(); it != arg_list.end(); it++)
+    {
+      if (!xor_handler.contains((*it))
+        && (hidden_arguments_.find(*it) == hidden_arguments_.end()))
+      {
+        s += " " + (*it)->shortID();
+      }
+    }
+
+    // if the program name is too long, then adjust the second line offset 
+    int second_line_offset = static_cast<int>(prog_name.length()) + 2;
+    if (second_line_offset > max_width_ / 3)
+    {
+      second_line_offset = static_cast<int>(max_width_ / 3);
+    }
+
+    spacePrint(os, s, max_width_, 3, second_line_offset);
+  }
+
+  void AdvancedTclapOutput::longUsage(TCLAP::CmdLineInterface& cmd, std::ostream& os) const
+  {
+    std::list<TCLAP::Arg*>                arg_list = cmd.getArgList();
+    std::string                           message = cmd.getMessage();
+    TCLAP::XorHandler                     xor_handler = cmd.getXorHandler();
+    std::vector<std::vector<TCLAP::Arg*>> xor_list = xor_handler.getXorList();
+
+    xor_list = createXorListWithoutHiddenArgs(xor_list);
+
+    // first the xor 
+    for (int i = 0; static_cast<unsigned int>(i) < xor_list.size(); i++)
+    {
+      for (TCLAP::ArgVectorIterator it = xor_list[i].begin(); it != xor_list[i].end(); it++)
+      {
+        spacePrint(os, (*it)->longID(), max_width_, 3, 3);
+        spacePrint(os, (*it)->getDescription(), max_width_, 5, 0);
+
+        if (it + 1 != xor_list[i].end())
+          spacePrint(os, "-- OR --", max_width_, 9, 0);
+      }
+      os << std::endl << std::endl;
+    }
+
+    // then the rest
+    for (TCLAP::ArgListIterator it = arg_list.begin(); it != arg_list.end(); it++)
+    {
+      if (!xor_handler.contains((*it))
+        && (hidden_arguments_.find(*it) == hidden_arguments_.end()))
+      {
+        spacePrint(os, (*it)->longID(), max_width_, 3, 3);
+        spacePrint(os, (*it)->getDescription(), max_width_, 5, 0);
+        os << std::endl;
+      }
+    }
+
+    os << std::endl;
+
+    spacePrint(os, message, max_width_, 3, 0);
+  }
+
+  std::vector<std::vector<TCLAP::Arg*>> AdvancedTclapOutput::createXorListWithoutHiddenArgs(const std::vector<std::vector<TCLAP::Arg*>>& xor_list) const
+  {
+    std::vector<std::vector<TCLAP::Arg*>> cleaned_xor_list;
+
+    // Remove hidden arguments from XOR list
+    for (size_t i = 0; i < xor_list.size(); i++)
+    {
+      std::vector<TCLAP::Arg*> arg_list;
+      for (size_t j = 0; j < xor_list[i].size(); j++)
+      {
+        if (hidden_arguments_.find(xor_list[i][j]) == hidden_arguments_.end())
+        {
+          arg_list.push_back(xor_list[i][j]);
+        }
+      }
+
+      if (!arg_list.empty())
+      {
+        cleaned_xor_list.push_back(std::move(arg_list));
+      }
+    }
+
+    return cleaned_xor_list;
+  }
+}
\ No newline at end of file
diff --git a/lib/CustomTclap/src/fuzzy_value_switch_arg.cpp b/lib/CustomTclap/src/fuzzy_value_switch_arg.cpp
new file mode 100644
index 0000000000..3e293799ac
--- /dev/null
+++ b/lib/CustomTclap/src/fuzzy_value_switch_arg.cpp
@@ -0,0 +1,168 @@
+/* ========================= eCAL LICENSE =================================
+ *
+ * Copyright (C) 2016 - 2019 Continental Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * ========================= eCAL LICENSE =================================
+*/
+
+#include <custom_tclap/fuzzy_value_switch_arg.h>
+
+#include <algorithm>
+#include <cctype>
+
+namespace CustomTclap
+{
+  FuzzyValueSwitchArg::FuzzyValueSwitchArg(const std::string &flag, const std::string &name, const std::string &desc, bool req, bool value, const std::string &typeDesc, TCLAP::Visitor *v)
+    : TCLAP::ValueArg<bool>(flag, name, desc, req, value, typeDesc, v)
+  {}
+
+  FuzzyValueSwitchArg::FuzzyValueSwitchArg(const std::string &flag, const std::string &name, const std::string &desc, bool req, bool value, const std::string &typeDesc, TCLAP::CmdLineInterface &parser, TCLAP::Visitor *v)
+    : TCLAP::ValueArg<bool>(flag, name, desc, req, value, typeDesc, parser, v)
+  {}
+
+  bool FuzzyValueSwitchArg::processArg(int *i, std::vector<std::string> &args)
+  {
+    if ((_ignoreable && Arg::ignoreRest()))
+    {
+      return false;
+    }
+
+    // A direct arg match can have a TRUE / FALSE toggle
+    if (argMatches(args[*i]))
+    {
+      if (_alreadySet)
+      {
+        if (_xorSet)
+        {
+          throw(TCLAP::CmdLineParseException("Mutually exclusive argument already set!", toString()));
+        }
+        else
+        {
+          throw(TCLAP::CmdLineParseException("Argument already set!", toString()));
+        }
+      }
+
+      if ((*i + 1) >= (int)args.size())
+      {
+        // Implicit TRUE if there are no following parameters
+        _value = true;
+      }
+      else
+      {
+        // Evaluate the next parameter
+        std::string bool_string = args[*i + 1];
+        std::transform(bool_string.begin(), bool_string.end(), bool_string.begin(), [](unsigned char c) { return std::tolower(c); });
+
+        // If the user manually specified 0|1|false|true|off|on, we use that value.
+        if (bool_string == "1" || bool_string == "true" || bool_string == "on")
+        {
+          // TRUE
+          (*i)++;
+          _value = true;
+        }
+        else if (bool_string == "0" || bool_string == "false" || bool_string == "off")
+        {
+          // FALSE
+          (*i)++;
+          _value = false;
+        }
+        else
+        {
+          // If the user did not specify 0|1|false|true|off|on, we assume TRUE
+          _value = true;
+        }
+      }
+
+      _alreadySet = true;
+      _checkWithVisitor();
+      return true;
+    }
+    // A match in a combination cannot have TRUE/FALSE applied. So we will assume it being true.
+    else if (combinedSwitchesMatch(args[*i]))
+    {
+      // check again to ensure we don't misinterpret 
+      // this as a MultiSwitchArg 
+      if (combinedSwitchesMatch(args[*i]))
+        throw(TCLAP::CmdLineParseException("Argument already set!", toString()));
+
+      if (_alreadySet)
+      {
+        if (_xorSet)
+        {
+          throw(TCLAP::CmdLineParseException("Mutually exclusive argument already set!", toString()));
+        }
+        else
+        {
+          throw(TCLAP::CmdLineParseException("Argument already set!", toString()));
+        }
+      }
+
+      _alreadySet = true;
+      _value = true;
+      _checkWithVisitor();
+      return lastCombined(args[*i]);
+    }
+    else
+    {
+      return false;
+    }
+  }
+
+  // Taken from TCLAP::SwitchArg
+  bool FuzzyValueSwitchArg::combinedSwitchesMatch(std::string& combinedSwitches)
+  {
+    // make sure this is actually a combined switch
+    if (combinedSwitches.length() > 0 &&
+      combinedSwitches[0] != Arg::flagStartString()[0])
+      return false;
+
+    // make sure it isn't a long name 
+    if (combinedSwitches.substr(0, Arg::nameStartString().length()) ==
+      Arg::nameStartString())
+      return false;
+
+    // make sure the delimiter isn't in the string 
+    if (combinedSwitches.find_first_of(Arg::delimiter()) != std::string::npos)
+      return false;
+
+    // ok, we're not specifying a ValueArg, so we know that we have
+    // a combined switch list.  
+    for (unsigned int i = 1; i < combinedSwitches.length(); i++)
+      if (_flag.length() > 0 &&
+        combinedSwitches[i] == _flag[0] &&
+        _flag[0] != Arg::flagStartString()[0])
+      {
+        // update the combined switches so this one is no longer present
+        // this is necessary so that no unlabeled args are matched
+        // later in the processing.
+        //combinedSwitches.erase(i,1);
+        combinedSwitches[i] = Arg::blankChar();
+        return true;
+      }
+
+    // none of the switches passed in the list match. 
+    return false;
+  }
+
+  // Taken from TCLAP::SwitchArg
+  bool FuzzyValueSwitchArg::lastCombined(std::string& combinedSwitches)
+  {
+    for (unsigned int i = 1; i < combinedSwitches.length(); i++)
+      if (combinedSwitches[i] != Arg::blankChar())
+        return false;
+
+    return true;
+  }
+}
diff --git a/licenses/fastrtps/LICENSE b/licenses/fastrtps/LICENSE
deleted file mode 100644
index d645695673..0000000000
--- a/licenses/fastrtps/LICENSE
+++ /dev/null
@@ -1,202 +0,0 @@
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
diff --git a/licenses/google-test/LICENSE b/licenses/google-test/LICENSE
new file mode 100644
index 0000000000..1941a11f8c
--- /dev/null
+++ b/licenses/google-test/LICENSE
@@ -0,0 +1,28 @@
+Copyright 2008, Google Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+    * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+    * Neither the name of Google Inc. nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/licenses/lcm-lite/COPYING b/licenses/lcm-lite/COPYING
deleted file mode 100644
index 60ae5865a6..0000000000
--- a/licenses/lcm-lite/COPYING
+++ /dev/null
@@ -1,506 +0,0 @@
-		  GNU LESSER GENERAL PUBLIC LICENSE
-		       Version 2.1, February 1999
-
- Copyright (C) 1991, 1999 Free Software Foundation, Inc.
- 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-[This is the first released version of the Lesser GPL.  It also counts
- as the successor of the GNU Library Public License, version 2, hence
- the version number 2.1.]
-
-			    Preamble
-
-  The licenses for most software are designed to take away your
-freedom to share and change it.  By contrast, the GNU General Public
-Licenses are intended to guarantee your freedom to share and change
-free software--to make sure the software is free for all its users.
-
-  This license, the Lesser General Public License, applies to some
-specially designated software packages--typically libraries--of the
-Free Software Foundation and other authors who decide to use it.  You
-can use it too, but we suggest you first think carefully about whether
-this license or the ordinary General Public License is the better
-strategy to use in any particular case, based on the explanations below.
-
-  When we speak of free software, we are referring to freedom of use,
-not price.  Our General Public Licenses are designed to make sure that
-you have the freedom to distribute copies of free software (and charge
-for this service if you wish); that you receive source code or can get
-it if you want it; that you can change the software and use pieces of
-it in new free programs; and that you are informed that you can do
-these things.
-
-  To protect your rights, we need to make restrictions that forbid
-distributors to deny you these rights or to ask you to surrender these
-rights.  These restrictions translate to certain responsibilities for
-you if you distribute copies of the library or if you modify it.
-
-  For example, if you distribute copies of the library, whether gratis
-or for a fee, you must give the recipients all the rights that we gave
-you.  You must make sure that they, too, receive or can get the source
-code.  If you link other code with the library, you must provide
-complete object files to the recipients, so that they can relink them
-with the library after making changes to the library and recompiling
-it.  And you must show them these terms so they know their rights.
-
-  We protect your rights with a two-step method: (1) we copyright the
-library, and (2) we offer you this license, which gives you legal
-permission to copy, distribute and/or modify the library.
-
-  To protect each distributor, we want to make it very clear that
-there is no warranty for the free library.  Also, if the library is
-modified by someone else and passed on, the recipients should know
-that what they have is not the original version, so that the original
-author's reputation will not be affected by problems that might be
-introduced by others.
-
-  Finally, software patents pose a constant threat to the existence of
-any free program.  We wish to make sure that a company cannot
-effectively restrict the users of a free program by obtaining a
-restrictive license from a patent holder.  Therefore, we insist that
-any patent license obtained for a version of the library must be
-consistent with the full freedom of use specified in this license.
-
-  Most GNU software, including some libraries, is covered by the
-ordinary GNU General Public License.  This license, the GNU Lesser
-General Public License, applies to certain designated libraries, and
-is quite different from the ordinary General Public License.  We use
-this license for certain libraries in order to permit linking those
-libraries into non-free programs.
-
-  When a program is linked with a library, whether statically or using
-a shared library, the combination of the two is legally speaking a
-combined work, a derivative of the original library.  The ordinary
-General Public License therefore permits such linking only if the
-entire combination fits its criteria of freedom.  The Lesser General
-Public License permits more lax criteria for linking other code with
-the library.
-
-  We call this license the "Lesser" General Public License because it
-does Less to protect the user's freedom than the ordinary General
-Public License.  It also provides other free software developers Less
-of an advantage over competing non-free programs.  These disadvantages
-are the reason we use the ordinary General Public License for many
-libraries.  However, the Lesser license provides advantages in certain
-special circumstances.
-
-  For example, on rare occasions, there may be a special need to
-encourage the widest possible use of a certain library, so that it becomes
-a de-facto standard.  To achieve this, non-free programs must be
-allowed to use the library.  A more frequent case is that a free
-library does the same job as widely used non-free libraries.  In this
-case, there is little to gain by limiting the free library to free
-software only, so we use the Lesser General Public License.
-
-  In other cases, permission to use a particular library in non-free
-programs enables a greater number of people to use a large body of
-free software.  For example, permission to use the GNU C Library in
-non-free programs enables many more people to use the whole GNU
-operating system, as well as its variant, the GNU/Linux operating
-system.
-
-  Although the Lesser General Public License is Less protective of the
-users' freedom, it does ensure that the user of a program that is
-linked with the Library has the freedom and the wherewithal to run
-that program using a modified version of the Library.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.  Pay close attention to the difference between a
-"work based on the library" and a "work that uses the library".  The
-former contains code derived from the library, whereas the latter must
-be combined with the library in order to run.
-
-		  GNU LESSER GENERAL PUBLIC LICENSE
-   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-
-  0. This License Agreement applies to any software library or other
-program which contains a notice placed by the copyright holder or
-other authorized party saying it may be distributed under the terms of
-this Lesser General Public License (also called "this License").
-Each licensee is addressed as "you".
-
-  A "library" means a collection of software functions and/or data
-prepared so as to be conveniently linked with application programs
-(which use some of those functions and data) to form executables.
-
-  The "Library", below, refers to any such software library or work
-which has been distributed under these terms.  A "work based on the
-Library" means either the Library or any derivative work under
-copyright law: that is to say, a work containing the Library or a
-portion of it, either verbatim or with modifications and/or translated
-straightforwardly into another language.  (Hereinafter, translation is
-included without limitation in the term "modification".)
-
-  "Source code" for a work means the preferred form of the work for
-making modifications to it.  For a library, complete source code means
-all the source code for all modules it contains, plus any associated
-interface definition files, plus the scripts used to control compilation
-and installation of the library.
-
-  Activities other than copying, distribution and modification are not
-covered by this License; they are outside its scope.  The act of
-running a program using the Library is not restricted, and output from
-such a program is covered only if its contents constitute a work based
-on the Library (independent of the use of the Library in a tool for
-writing it).  Whether that is true depends on what the Library does
-and what the program that uses the Library does.
-  
-  1. You may copy and distribute verbatim copies of the Library's
-complete source code as you receive it, in any medium, provided that
-you conspicuously and appropriately publish on each copy an
-appropriate copyright notice and disclaimer of warranty; keep intact
-all the notices that refer to this License and to the absence of any
-warranty; and distribute a copy of this License along with the
-Library.
-
-  You may charge a fee for the physical act of transferring a copy,
-and you may at your option offer warranty protection in exchange for a
-fee.
-
-  2. You may modify your copy or copies of the Library or any portion
-of it, thus forming a work based on the Library, and copy and
-distribute such modifications or work under the terms of Section 1
-above, provided that you also meet all of these conditions:
-
-    a) The modified work must itself be a software library.
-
-    b) You must cause the files modified to carry prominent notices
-    stating that you changed the files and the date of any change.
-
-    c) You must cause the whole of the work to be licensed at no
-    charge to all third parties under the terms of this License.
-
-    d) If a facility in the modified Library refers to a function or a
-    table of data to be supplied by an application program that uses
-    the facility, other than as an argument passed when the facility
-    is invoked, then you must make a good faith effort to ensure that,
-    in the event an application does not supply such function or
-    table, the facility still operates, and performs whatever part of
-    its purpose remains meaningful.
-
-    (For example, a function in a library to compute square roots has
-    a purpose that is entirely well-defined independent of the
-    application.  Therefore, Subsection 2d requires that any
-    application-supplied function or table used by this function must
-    be optional: if the application does not supply it, the square
-    root function must still compute square roots.)
-
-These requirements apply to the modified work as a whole.  If
-identifiable sections of that work are not derived from the Library,
-and can be reasonably considered independent and separate works in
-themselves, then this License, and its terms, do not apply to those
-sections when you distribute them as separate works.  But when you
-distribute the same sections as part of a whole which is a work based
-on the Library, the distribution of the whole must be on the terms of
-this License, whose permissions for other licensees extend to the
-entire whole, and thus to each and every part regardless of who wrote
-it.
-
-Thus, it is not the intent of this section to claim rights or contest
-your rights to work written entirely by you; rather, the intent is to
-exercise the right to control the distribution of derivative or
-collective works based on the Library.
-
-In addition, mere aggregation of another work not based on the Library
-with the Library (or with a work based on the Library) on a volume of
-a storage or distribution medium does not bring the other work under
-the scope of this License.
-
-  3. You may opt to apply the terms of the ordinary GNU General Public
-License instead of this License to a given copy of the Library.  To do
-this, you must alter all the notices that refer to this License, so
-that they refer to the ordinary GNU General Public License, version 2,
-instead of to this License.  (If a newer version than version 2 of the
-ordinary GNU General Public License has appeared, then you can specify
-that version instead if you wish.)  Do not make any other change in
-these notices.
-
-  Once this change is made in a given copy, it is irreversible for
-that copy, so the ordinary GNU General Public License applies to all
-subsequent copies and derivative works made from that copy.
-
-  This option is useful when you wish to copy part of the code of
-the Library into a program that is not a library.
-
-  4. You may copy and distribute the Library (or a portion or
-derivative of it, under Section 2) in object code or executable form
-under the terms of Sections 1 and 2 above provided that you accompany
-it with the complete corresponding machine-readable source code, which
-must be distributed under the terms of Sections 1 and 2 above on a
-medium customarily used for software interchange.
-
-  If distribution of object code is made by offering access to copy
-from a designated place, then offering equivalent access to copy the
-source code from the same place satisfies the requirement to
-distribute the source code, even though third parties are not
-compelled to copy the source along with the object code.
-
-  5. A program that contains no derivative of any portion of the
-Library, but is designed to work with the Library by being compiled or
-linked with it, is called a "work that uses the Library".  Such a
-work, in isolation, is not a derivative work of the Library, and
-therefore falls outside the scope of this License.
-
-  However, linking a "work that uses the Library" with the Library
-creates an executable that is a derivative of the Library (because it
-contains portions of the Library), rather than a "work that uses the
-library".  The executable is therefore covered by this License.
-Section 6 states terms for distribution of such executables.
-
-  When a "work that uses the Library" uses material from a header file
-that is part of the Library, the object code for the work may be a
-derivative work of the Library even though the source code is not.
-Whether this is true is especially significant if the work can be
-linked without the Library, or if the work is itself a library.  The
-threshold for this to be true is not precisely defined by law.
-
-  If such an object file uses only numerical parameters, data
-structure layouts and accessors, and small macros and small inline
-functions (ten lines or less in length), then the use of the object
-file is unrestricted, regardless of whether it is legally a derivative
-work.  (Executables containing this object code plus portions of the
-Library will still fall under Section 6.)
-
-  Otherwise, if the work is a derivative of the Library, you may
-distribute the object code for the work under the terms of Section 6.
-Any executables containing that work also fall under Section 6,
-whether or not they are linked directly with the Library itself.
-
-  6. As an exception to the Sections above, you may also combine or
-link a "work that uses the Library" with the Library to produce a
-work containing portions of the Library, and distribute that work
-under terms of your choice, provided that the terms permit
-modification of the work for the customer's own use and reverse
-engineering for debugging such modifications.
-
-  You must give prominent notice with each copy of the work that the
-Library is used in it and that the Library and its use are covered by
-this License.  You must supply a copy of this License.  If the work
-during execution displays copyright notices, you must include the
-copyright notice for the Library among them, as well as a reference
-directing the user to the copy of this License.  Also, you must do one
-of these things:
-
-    a) Accompany the work with the complete corresponding
-    machine-readable source code for the Library including whatever
-    changes were used in the work (which must be distributed under
-    Sections 1 and 2 above); and, if the work is an executable linked
-    with the Library, with the complete machine-readable "work that
-    uses the Library", as object code and/or source code, so that the
-    user can modify the Library and then relink to produce a modified
-    executable containing the modified Library.  (It is understood
-    that the user who changes the contents of definitions files in the
-    Library will not necessarily be able to recompile the application
-    to use the modified definitions.)
-
-    b) Use a suitable shared library mechanism for linking with the
-    Library.  A suitable mechanism is one that (1) uses at run time a
-    copy of the library already present on the user's computer system,
-    rather than copying library functions into the executable, and (2)
-    will operate properly with a modified version of the library, if
-    the user installs one, as long as the modified version is
-    interface-compatible with the version that the work was made with.
-
-    c) Accompany the work with a written offer, valid for at
-    least three years, to give the same user the materials
-    specified in Subsection 6a, above, for a charge no more
-    than the cost of performing this distribution.
-
-    d) If distribution of the work is made by offering access to copy
-    from a designated place, offer equivalent access to copy the above
-    specified materials from the same place.
-
-    e) Verify that the user has already received a copy of these
-    materials or that you have already sent this user a copy.
-
-  For an executable, the required form of the "work that uses the
-Library" must include any data and utility programs needed for
-reproducing the executable from it.  However, as a special exception,
-the materials to be distributed need not include anything that is
-normally distributed (in either source or binary form) with the major
-components (compiler, kernel, and so on) of the operating system on
-which the executable runs, unless that component itself accompanies
-the executable.
-
-  It may happen that this requirement contradicts the license
-restrictions of other proprietary libraries that do not normally
-accompany the operating system.  Such a contradiction means you cannot
-use both them and the Library together in an executable that you
-distribute.
-
-  7. You may place library facilities that are a work based on the
-Library side-by-side in a single library together with other library
-facilities not covered by this License, and distribute such a combined
-library, provided that the separate distribution of the work based on
-the Library and of the other library facilities is otherwise
-permitted, and provided that you do these two things:
-
-    a) Accompany the combined library with a copy of the same work
-    based on the Library, uncombined with any other library
-    facilities.  This must be distributed under the terms of the
-    Sections above.
-
-    b) Give prominent notice with the combined library of the fact
-    that part of it is a work based on the Library, and explaining
-    where to find the accompanying uncombined form of the same work.
-
-  8. You may not copy, modify, sublicense, link with, or distribute
-the Library except as expressly provided under this License.  Any
-attempt otherwise to copy, modify, sublicense, link with, or
-distribute the Library is void, and will automatically terminate your
-rights under this License.  However, parties who have received copies,
-or rights, from you under this License will not have their licenses
-terminated so long as such parties remain in full compliance.
-
-  9. You are not required to accept this License, since you have not
-signed it.  However, nothing else grants you permission to modify or
-distribute the Library or its derivative works.  These actions are
-prohibited by law if you do not accept this License.  Therefore, by
-modifying or distributing the Library (or any work based on the
-Library), you indicate your acceptance of this License to do so, and
-all its terms and conditions for copying, distributing or modifying
-the Library or works based on it.
-
-  10. Each time you redistribute the Library (or any work based on the
-Library), the recipient automatically receives a license from the
-original licensor to copy, distribute, link with or modify the Library
-subject to these terms and conditions.  You may not impose any further
-restrictions on the recipients' exercise of the rights granted herein.
-You are not responsible for enforcing compliance by third parties with
-this License.
-
-  11. If, as a consequence of a court judgment or allegation of patent
-infringement or for any other reason (not limited to patent issues),
-conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot
-distribute so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you
-may not distribute the Library at all.  For example, if a patent
-license would not permit royalty-free redistribution of the Library by
-all those who receive copies directly or indirectly through you, then
-the only way you could satisfy both it and this License would be to
-refrain entirely from distribution of the Library.
-
-If any portion of this section is held invalid or unenforceable under any
-particular circumstance, the balance of the section is intended to apply,
-and the section as a whole is intended to apply in other circumstances.
-
-It is not the purpose of this section to induce you to infringe any
-patents or other property right claims or to contest validity of any
-such claims; this section has the sole purpose of protecting the
-integrity of the free software distribution system which is
-implemented by public license practices.  Many people have made
-generous contributions to the wide range of software distributed
-through that system in reliance on consistent application of that
-system; it is up to the author/donor to decide if he or she is willing
-to distribute software through any other system and a licensee cannot
-impose that choice.
-
-This section is intended to make thoroughly clear what is believed to
-be a consequence of the rest of this License.
-
-  12. If the distribution and/or use of the Library is restricted in
-certain countries either by patents or by copyrighted interfaces, the
-original copyright holder who places the Library under this License may add
-an explicit geographical distribution limitation excluding those countries,
-so that distribution is permitted only in or among countries not thus
-excluded.  In such case, this License incorporates the limitation as if
-written in the body of this License.
-
-  13. The Free Software Foundation may publish revised and/or new
-versions of the Lesser General Public License from time to time.
-Such new versions will be similar in spirit to the present version,
-but may differ in detail to address new problems or concerns.
-
-Each version is given a distinguishing version number.  If the Library
-specifies a version number of this License which applies to it and
-"any later version", you have the option of following the terms and
-conditions either of that version or of any later version published by
-the Free Software Foundation.  If the Library does not specify a
-license version number, you may choose any version ever published by
-the Free Software Foundation.
-
-  14. If you wish to incorporate parts of the Library into other free
-programs whose distribution conditions are incompatible with these,
-write to the author to ask for permission.  For software which is
-copyrighted by the Free Software Foundation, write to the Free
-Software Foundation; we sometimes make exceptions for this.  Our
-decision will be guided by the two goals of preserving the free status
-of all derivatives of our free software and of promoting the sharing
-and reuse of software generally.
-
-			    NO WARRANTY
-
-  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
-WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
-EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
-OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
-KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
-LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
-THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
-  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
-WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
-AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
-FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
-CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
-LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
-RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
-FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
-SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
-DAMAGES.
-
-		     END OF TERMS AND CONDITIONS
-
-           How to Apply These Terms to Your New Libraries
-
-  If you develop a new library, and you want it to be of the greatest
-possible use to the public, we recommend making it free software that
-everyone can redistribute and change.  You can do so by permitting
-redistribution under these terms (or, alternatively, under the terms of the
-ordinary General Public License).
-
-  To apply these terms, attach the following notices to the library.  It is
-safest to attach them to the start of each source file to most effectively
-convey the exclusion of warranty; and each file should have at least the
-"copyright" line and a pointer to where the full notice is found.
-
-    <one line to give the library's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    This library is free software; you can redistribute it and/or
-    modify it under the terms of the GNU Lesser General Public
-    License as published by the Free Software Foundation; either
-    version 2.1 of the License, or (at your option) any later version.
-
-    This library 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
-    Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with this library; if not, write to the Free
-    Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
-    Boston, MA 02110-1301 USA
-
-Also add information on how to contact you by electronic and paper mail.
-
-You should also get your employer (if you work as a programmer) or
-your school, if any, to sign a "copyright disclaimer" for the library,
-if necessary.  Here is a sample; alter the names:
-
-  Yoyodyne, Inc., hereby disclaims all copyright interest in the
-  library `Frob' (a library for tweaking knobs) written by James
-  Random Hacker.
-
-  <signature of Ty Coon>, 1 April 1990
-  Ty Coon, President of Vice
-
-That's all there is to it!
-
-
diff --git a/samples/CMakeLists.txt b/samples/CMakeLists.txt
index 4f379478b6..bc8b7f248b 100644
--- a/samples/CMakeLists.txt
+++ b/samples/CMakeLists.txt
@@ -59,6 +59,7 @@ add_subdirectory(cpp/misc/process/src)
 add_subdirectory(cpp/misc/proto_dyn/src)
 add_subdirectory(cpp/misc/proto_dyn_json/src)
 add_subdirectory(cpp/misc/time/src)
+add_subdirectory(cpp/misc/timer/src)
 add_subdirectory(cpp/monitoring/monitoring_rec/src)
 add_subdirectory(cpp/monitoring/monitoring_reg/src)
 add_subdirectory(cpp/multiple/multiple_rec_cb/src)
@@ -73,15 +74,10 @@ add_subdirectory(cpp/person/person_rec_events/src)
 add_subdirectory(cpp/person/person_snd/src)
 add_subdirectory(cpp/person/person_snd_events/src)
 add_subdirectory(cpp/person/person_snd_inproc/src)
-add_subdirectory(cpp/person/person_snd_lcm/src)
 add_subdirectory(cpp/person/person_snd_multicast/src)
-if(ECAL_LAYER_FASTRTPS)
-add_subdirectory(cpp/person/person_snd_rtps/src)
-endif(ECAL_LAYER_FASTRTPS)
 if(ECAL_LAYER_ICEORYX)
 add_subdirectory(cpp/person/person_snd_iceoryx/src)
 endif(ECAL_LAYER_ICEORYX)
-add_subdirectory(cpp/person/person_snd_unicast/src)
 add_subdirectory(cpp/pingpong/ping/src)
 add_subdirectory(cpp/pingpong/pong/src)
 add_subdirectory(cpp/services/ecalplayer_client/src)
diff --git a/samples/cpp/person/person_snd_lcm/src/CMakeLists.txt b/samples/cpp/misc/timer/src/CMakeLists.txt
similarity index 66%
rename from samples/cpp/person/person_snd_lcm/src/CMakeLists.txt
rename to samples/cpp/misc/timer/src/CMakeLists.txt
index 34c6e9ce97..cb2b7da496 100644
--- a/samples/cpp/person/person_snd_lcm/src/CMakeLists.txt
+++ b/samples/cpp/misc/timer/src/CMakeLists.txt
@@ -16,29 +16,23 @@
 #
 # ========================= eCAL LICENSE =================================
 
-project(person_snd_lcm)
+project(timer)
 
 find_package(eCAL REQUIRED)
 find_package(Protobuf REQUIRED)
 
-set(person_snd_lcm_src
-  person_snd_lcm.cpp
+create_targets_protobuf()
+set(timer_src
+  timer.cpp
 )
 
-set(person_snd_lcm_proto
-  ${CMAKE_CURRENT_SOURCE_DIR}/protobuf/animal.proto
-  ${CMAKE_CURRENT_SOURCE_DIR}/protobuf/house.proto
-  ${CMAKE_CURRENT_SOURCE_DIR}/protobuf/person.proto    
-)
-ecal_add_sample(${PROJECT_NAME} ${person_snd_lcm_src})
-PROTOBUF_TARGET_CPP(${PROJECT_NAME} ${CMAKE_CURRENT_SOURCE_DIR}/protobuf ${person_snd_lcm_proto})
-
-target_include_directories(${PROJECT_NAME} PRIVATE .)
+ecal_add_sample(${PROJECT_NAME} ${timer_src})
 
 target_link_libraries(${PROJECT_NAME}
   eCAL::core
-  protobuf::libprotobuf)
-  
+  protobuf::libprotobuf
+)
+
 ecal_install_sample(${PROJECT_NAME})
 
-set_property(TARGET ${PROJECT_NAME} PROPERTY FOLDER samples/cpp/person)
+set_property(TARGET ${PROJECT_NAME} PROPERTY FOLDER samples/cpp/misc)
diff --git a/samples/cpp/misc/timer/src/timer.cpp b/samples/cpp/misc/timer/src/timer.cpp
new file mode 100644
index 0000000000..0fa23b69af
--- /dev/null
+++ b/samples/cpp/misc/timer/src/timer.cpp
@@ -0,0 +1,55 @@
+/* ========================= eCAL LICENSE =================================
+ *
+ * Copyright (C) 2016 - 2019 Continental Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * ========================= eCAL LICENSE =================================
+*/
+
+#include <ecal/ecal.h>
+#include <ecal/msg/string/publisher.h>
+
+#include <iostream>
+#include <functional>
+
+const int timout_ms = 10;
+
+int main(int argc, char **argv)
+{
+  // initialize eCAL API
+  eCAL::Initialize(argc, argv, "person publisher");
+  // set process state
+  eCAL::Process::SetState(proc_sev_healthy, proc_sev_level1, "I feel good !");
+
+  eCAL::string::CPublisher<std::string> pub("hello");
+  eCAL::CTimer timer;
+
+  timer.Start(timout_ms, [&pub](){
+    pub.Send("Hello world");
+    std::cout << "Sent: Hello world" << std::endl;
+  });
+
+  // enter main loop
+  while(eCAL::Ok())
+  {
+    // sleep 500 ms
+    eCAL::Process::SleepMS(500);
+  }
+
+  timer.Stop();
+  // finalize eCAL API
+  eCAL::Finalize();
+
+  return(0);
+}
diff --git a/samples/cpp/monitoring/monitoring_rec/src/monitoring_rec.cpp b/samples/cpp/monitoring/monitoring_rec/src/monitoring_rec.cpp
index 58f9e31c61..1521e8db06 100644
--- a/samples/cpp/monitoring/monitoring_rec/src/monitoring_rec.cpp
+++ b/samples/cpp/monitoring/monitoring_rec/src/monitoring_rec.cpp
@@ -115,6 +115,8 @@ int main(int argc, char **argv)
         std::cout << "dataread        : " << process.dataread()          << std::endl;   // date read bytes per sec
         std::cout << "severity        : " << process.state().severity()  << std::endl;   // process state severity
         std::cout << "info            : " << process.state().info()      << std::endl;   // process state info
+        std::cout << "tsync state     : " << process.tsync_state()       << std::endl;   // time sync state
+        std::cout << "tsync mod name  : " << process.tsync_mod_name()    << std::endl;   // time sync mod name
         std::cout << std::endl;
       }
     }
@@ -185,21 +187,9 @@ int main(int argc, char **argv)
           case eCAL::TLayer::tlayer_udp_mc:
             layer_type = "tlayer_udp_mc";
             break;
-          case eCAL::TLayer::tlayer_udp_uc:
-            layer_type = "tlayer_udp_uc";
-            break;
-          case eCAL::TLayer::tlayer_udp_metal:
-            layer_type = "tlayer_udp_metal";
-            break;
           case eCAL::TLayer::tlayer_shm:
             layer_type = "tlayer_shm";
             break;
-          case eCAL::TLayer::tlayer_lcm:
-            layer_type = "tlayer_lcm";
-            break;
-          case eCAL::TLayer::tlayer_rtps:
-            layer_type = "tlayer_rtps";
-            break;
           case eCAL::TLayer::tlayer_inproc:
             layer_type = "tlayer_inproc";
             break;
@@ -231,9 +221,6 @@ int main(int argc, char **argv)
         std::cout << "dfreq_min_err   : " << topic.dfreq_min_err()   << std::endl;   // data frequency minimum violation error counter
         std::cout << "dfreq_max_err   : " << topic.dfreq_max_err()   << std::endl;   // data frequency maximum violation error counter
 
-        std::cout << "mcast_address   : " << topic.mcast_address()   << std::endl;   // the udp multicast group used for that topic (eCALMetal only)
-        std::cout << "mcast_port      : " << topic.mcast_port()      << std::endl;   // the udp multicast port used for that topic  (eCALMetal only)
-
         std::cout << std::endl;
       }
     }
diff --git a/samples/cpp/performance/pubsub_throughput/src/pubsub_throughput.cpp b/samples/cpp/performance/pubsub_throughput/src/pubsub_throughput.cpp
index 07c3d56319..e13c3c3b88 100644
--- a/samples/cpp/performance/pubsub_throughput/src/pubsub_throughput.cpp
+++ b/samples/cpp/performance/pubsub_throughput/src/pubsub_throughput.cpp
@@ -29,8 +29,6 @@
 
 #define TEST_UDP         0
 #define TEST_SHM         1
-#define TEST_LCM         0
-#define TEST_RTPS        0
 #define TEST_INPROC      0
 
 auto g_snd_size (1000 * 1024);
@@ -168,18 +166,6 @@ int main(int argc, char **argv)
   std::cout << "RESULT       : " << success << std::endl << std::endl;
 #endif
 
-#if TEST_LCM
-  std::cout << "RELIABLE     : LCM" << std::endl;
-  success = test_throughput(g_snd_size, g_snd_loops, eCAL::TLayer::tlayer_lcm, true);
-  std::cout << "RESULT       : " << success << std::endl << std::endl;
-#endif
-
-#if TEST_RTPS
-  std::cout << "RELIABLE     : RTPS" << std::endl;
-  success = test_throughput(g_snd_size, g_snd_loops, eCAL::TLayer::tlayer_rtps, true);
-  std::cout << "RESULT       : " << success << std::endl << std::endl;
-#endif
-
 #if TEST_INPROC
   std::cout << "RELIABLE     : INPROC" << std::endl;
   success = test_throughput(4000, g_snd_loops, eCAL::TLayer::tlayer_inproc, true);
@@ -202,18 +188,6 @@ int main(int argc, char **argv)
   std::cout << "RESULT       : " << success << std::endl << std::endl;
 #endif
 
-#if TEST_LCM
-  std::cout << "BEST EFFORT : LCM" << std::endl;
-  success = test_throughput(g_snd_size, g_snd_loops, eCAL::TLayer::tlayer_lcm, false);
-  std::cout << "RESULT       : " << success << std::endl << std::endl;
-#endif
-
-#if TEST_RTPS
-  std::cout << "BEST EFFORT : RTPS" << std::endl;
-  success = test_throughput(g_snd_size, g_snd_loops, eCAL::TLayer::tlayer_rtps, false);
-  std::cout << "RESULT       : " << success << std::endl << std::endl;
-#endif
-
 #if TEST_INPROC
   std::cout << "BEST EFFORT : INPROC" << std::endl;
   success = test_throughput(4000, g_snd_loops, eCAL::TLayer::tlayer_inproc, false);
diff --git a/samples/cpp/person/person_snd_lcm/src/person_snd_lcm.cpp b/samples/cpp/person/person_snd_lcm/src/person_snd_lcm.cpp
deleted file mode 100644
index f2c76df9ba..0000000000
--- a/samples/cpp/person/person_snd_lcm/src/person_snd_lcm.cpp
+++ /dev/null
@@ -1,79 +0,0 @@
-/* ========================= eCAL LICENSE =================================
- *
- * Copyright (C) 2016 - 2019 Continental Corporation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * ========================= eCAL LICENSE =================================
-*/
-
-#include <ecal/ecal.h>
-#include <ecal/msg/protobuf/publisher.h>
-
-#include <iostream>
-
-#include "person.pb.h"
-
-int main(int argc, char **argv)
-{
-  // initialize eCAL API
-  eCAL::Initialize(argc, argv, "person publisher to lcm");
-
-  // set process state
-  eCAL::Process::SetState(proc_sev_healthy, proc_sev_level1, "I feel good !");
-
-  // create a publisher (topic name "person")
-  eCAL::protobuf::CPublisher<pb::People::Person> pub("person");
-
-  // switch all layer off
-  pub.SetLayerMode(eCAL::TLayer::tlayer_all, eCAL::TLayer::smode_off);
-
-  // set lcm write mode on
-  pub.SetLayerMode(eCAL::TLayer::tlayer_lcm, eCAL::TLayer::smode_on);
-
-  // generate a class instance of Person
-  pb::People::Person person;
-
-  // enter main loop
-  auto cnt(0);
-  while(eCAL::Ok())
-  {
-    // set person object content
-    person.set_id(++cnt);
-    person.set_name("Max");
-    person.set_stype(pb::People::Person_SType_MALE);
-    person.set_email("max@mail.net");
-    person.mutable_dog()->set_name("Brandy");
-    person.mutable_house()->set_rooms(4);
-
-    // send the person object
-    pub.Send(person);
-
-    // print content
-    std::cout << "person id    : " << person.id()            << std::endl;
-    std::cout << "person name  : " << person.name()          << std::endl;
-    std::cout << "person stype : " << person.stype()         << std::endl;
-    std::cout << "person email : " << person.email()         << std::endl;
-    std::cout << "dog.name     : " << person.dog().name()    << std::endl;
-    std::cout << "house.rooms  : " << person.house().rooms() << std::endl;
-    std::cout                                                << std::endl;
-
-    // sleep 500 ms
-    eCAL::Process::SleepMS(500);
-  }
-
-  // finalize eCAL API
-  eCAL::Finalize();
-
-  return(0);
-}
diff --git a/samples/cpp/person/person_snd_rtps/src/person_snd_rtps.cpp b/samples/cpp/person/person_snd_rtps/src/person_snd_rtps.cpp
deleted file mode 100644
index b3d4f9ccd4..0000000000
--- a/samples/cpp/person/person_snd_rtps/src/person_snd_rtps.cpp
+++ /dev/null
@@ -1,81 +0,0 @@
-/* ========================= eCAL LICENSE =================================
- *
- * Copyright (C) 2016 - 2019 Continental Corporation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * ========================= eCAL LICENSE =================================
-*/
-
-#include <ecal/ecal.h>
-#include <ecal/msg/protobuf/publisher.h>
-
-#include <iostream>
-#include <chrono>
-#include <thread>
-
-#include "person.pb.h"
-
-int main(int argc, char **argv)
-{
-  // initialize eCAL API
-  eCAL::Initialize(argc, argv, "person publisher to rtps");
-
-  // set process state
-  eCAL::Process::SetState(proc_sev_healthy, proc_sev_level1, "I feel good !");
-
-  // create a publisher (topic name "person")
-  eCAL::protobuf::CPublisher<pb::People::Person> pub("person");
-
-  // switch all layer off
-  pub.SetLayerMode(eCAL::TLayer::tlayer_all,  eCAL::TLayer::smode_off);
-
-  // set rtps write mode on
-  pub.SetLayerMode(eCAL::TLayer::tlayer_rtps, eCAL::TLayer::smode_on);
-
-  // generate a class instance of Person
-  pb::People::Person person;
-
-  // enter main loop
-  auto cnt = 0;
-  while (eCAL::Ok())
-  {
-    // set person object content
-    person.set_id(++cnt);
-    person.set_name("Max");
-    person.set_stype(pb::People::Person_SType_MALE);
-    person.set_email("max@mail.net");
-    person.mutable_dog()->set_name("Brandy");
-    person.mutable_house()->set_rooms(4);
-
-    // send the person object
-    pub.Send(person);
-
-    // print content
-    std::cout << "person id    : " << person.id()            << std::endl;
-    std::cout << "person name  : " << person.name()          << std::endl;
-    std::cout << "person stype : " << person.stype()         << std::endl;
-    std::cout << "person email : " << person.email()         << std::endl;
-    std::cout << "dog.name     : " << person.dog().name()    << std::endl;
-    std::cout << "house.rooms  : " << person.house().rooms() << std::endl;
-    std::cout                                                << std::endl;
-
-    // sleep 500 ms
-    std::this_thread::sleep_for(std::chrono::milliseconds(500));
-  }
-
-  // finalize eCAL API
-  eCAL::Finalize();
-  
-  return(0);
-}
diff --git a/samples/cpp/person/person_snd_unicast/src/person_snd_unicast.cpp b/samples/cpp/person/person_snd_unicast/src/person_snd_unicast.cpp
deleted file mode 100644
index f8c565600e..0000000000
--- a/samples/cpp/person/person_snd_unicast/src/person_snd_unicast.cpp
+++ /dev/null
@@ -1,79 +0,0 @@
-/* ========================= eCAL LICENSE =================================
- *
- * Copyright (C) 2016 - 2019 Continental Corporation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * ========================= eCAL LICENSE =================================
-*/
-
-#include <ecal/ecal.h>
-#include <ecal/msg/protobuf/publisher.h>
-
-#include <iostream>
-
-#include "person.pb.h"
-
-int main(int argc, char **argv)
-{
-  // initialize eCAL API
-  eCAL::Initialize(argc, argv, "person publisher to unicast");
-
-  // set process state
-  eCAL::Process::SetState(proc_sev_healthy, proc_sev_level1, "I feel good !");
-
-  // create a publisher (topic name "person")
-  eCAL::protobuf::CPublisher<pb::People::Person> pub("person");
-
-  // switch all layer off
-  pub.SetLayerMode(eCAL::TLayer::tlayer_all, eCAL::TLayer::smode_off);
-
-  // switch unicast layer on
-  pub.SetLayerMode(eCAL::TLayer::tlayer_udp_uc, eCAL::TLayer::smode_on);
-
-  // generate a class instance of Person
-  pb::People::Person person;
-
-  // enter main loop
-  auto cnt(0);
-  while (eCAL::Ok())
-  {
-    // set person object content
-    person.set_id(++cnt);
-    person.set_name("Max");
-    person.set_stype(pb::People::Person_SType_MALE);
-    person.set_email("max@mail.net");
-    person.mutable_dog()->set_name("Brandy");
-    person.mutable_house()->set_rooms(4);
-
-    // send the person object
-    pub.Send(person);
-
-    // print content
-    std::cout << "person id    : " << person.id()            << std::endl;
-    std::cout << "person name  : " << person.name()          << std::endl;
-    std::cout << "person stype : " << person.stype()         << std::endl;
-    std::cout << "person email : " << person.email()         << std::endl;
-    std::cout << "dog.name     : " << person.dog().name()    << std::endl;
-    std::cout << "house.rooms  : " << person.house().rooms() << std::endl;
-    std::cout                                                << std::endl;
-
-    // sleep 500 ms
-    eCAL::Process::SleepMS(500);
-  }
-
-  // finalize eCAL API
-  eCAL::Finalize();
-  
-  return(0);
-}
diff --git a/samples/python/ecalhdf5_rw/ecalhdf5_rw.pyproj b/samples/python/ecalhdf5_rw/ecalhdf5_rw.pyproj
index 08245f34f5..6e7abe612a 100644
--- a/samples/python/ecalhdf5_rw/ecalhdf5_rw.pyproj
+++ b/samples/python/ecalhdf5_rw/ecalhdf5_rw.pyproj
@@ -10,6 +10,7 @@
     <OutputPath>.</OutputPath>
     <Name>ecalhdf5_rw</Name>
     <RootNamespace>ecalhdf5_rw</RootNamespace>
+    <ProjectGuid>{ff2de1ed-4c2e-39b0-9370-e52b97bce0b5}</ProjectGuid>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
     <DebugSymbols>true</DebugSymbols>
@@ -33,4 +34,4 @@
   </Target>
   <Target Name="AfterBuild">
   </Target>
-</Project>
+</Project>
\ No newline at end of file
diff --git a/samples/python/latency_rec/latency_rec.pyproj b/samples/python/latency_rec/latency_rec.pyproj
index 0fd37c6ed3..d179202e5c 100644
--- a/samples/python/latency_rec/latency_rec.pyproj
+++ b/samples/python/latency_rec/latency_rec.pyproj
@@ -10,6 +10,7 @@
     <OutputPath>.</OutputPath>
     <Name>latency_rec</Name>
     <RootNamespace>latency_rec</RootNamespace>
+    <ProjectGuid>{d6fc0687-be86-3f15-a401-e34fcd08fa2a}</ProjectGuid>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
     <DebugSymbols>true</DebugSymbols>
@@ -33,4 +34,4 @@
   </Target>
   <Target Name="AfterBuild">
   </Target>
-</Project>
+</Project>
\ No newline at end of file
diff --git a/samples/python/latency_rec_cb/latency_rec_cb.pyproj b/samples/python/latency_rec_cb/latency_rec_cb.pyproj
index 6c2cb13e5f..3f317907e4 100644
--- a/samples/python/latency_rec_cb/latency_rec_cb.pyproj
+++ b/samples/python/latency_rec_cb/latency_rec_cb.pyproj
@@ -10,6 +10,7 @@
     <OutputPath>.</OutputPath>
     <Name>latency_rec_cb</Name>
     <RootNamespace>latency_rec_cb</RootNamespace>
+    <ProjectGuid>{4d0f63dd-6004-3fea-b069-a8ec371a9e6b}</ProjectGuid>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
     <DebugSymbols>true</DebugSymbols>
@@ -33,4 +34,4 @@
   </Target>
   <Target Name="AfterBuild">
   </Target>
-</Project>
+</Project>
\ No newline at end of file
diff --git a/samples/python/latency_snd/latency_snd.pyproj b/samples/python/latency_snd/latency_snd.pyproj
index b41d479d2f..7ffabea9e8 100644
--- a/samples/python/latency_snd/latency_snd.pyproj
+++ b/samples/python/latency_snd/latency_snd.pyproj
@@ -10,6 +10,7 @@
     <OutputPath>.</OutputPath>
     <Name>latency_snd</Name>
     <RootNamespace>latency_snd</RootNamespace>
+    <ProjectGuid>{c0ae785d-6480-3dc3-b9d3-7999f556ec4e}</ProjectGuid>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
     <DebugSymbols>true</DebugSymbols>
@@ -33,4 +34,4 @@
   </Target>
   <Target Name="AfterBuild">
   </Target>
-</Project>
+</Project>
\ No newline at end of file
diff --git a/samples/python/measurement_read/measurement_read.pyproj b/samples/python/measurement_read/measurement_read.pyproj
index 468c0a4c46..356fc08254 100644
--- a/samples/python/measurement_read/measurement_read.pyproj
+++ b/samples/python/measurement_read/measurement_read.pyproj
@@ -10,6 +10,7 @@
     <OutputPath>.</OutputPath>
     <Name>measurement_read</Name>
     <RootNamespace>measurement_read</RootNamespace>
+    <ProjectGuid>{2b37f456-c807-3a24-9ba7-d4757cf4ca23}</ProjectGuid>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
     <DebugSymbols>true</DebugSymbols>
@@ -33,4 +34,4 @@
   </Target>
   <Target Name="AfterBuild">
   </Target>
-</Project>
+</Project>
\ No newline at end of file
diff --git a/samples/python/minimal_rec/minimal_rec.pyproj b/samples/python/minimal_rec/minimal_rec.pyproj
index 08b75cb6c6..d66a7a735b 100644
--- a/samples/python/minimal_rec/minimal_rec.pyproj
+++ b/samples/python/minimal_rec/minimal_rec.pyproj
@@ -10,6 +10,7 @@
     <OutputPath>.</OutputPath>
     <Name>minimal_rec</Name>
     <RootNamespace>minimal_rec</RootNamespace>
+    <ProjectGuid>{093990a3-9395-3bb2-b625-473f1bba2ce6}</ProjectGuid>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
     <DebugSymbols>true</DebugSymbols>
@@ -33,4 +34,4 @@
   </Target>
   <Target Name="AfterBuild">
   </Target>
-</Project>
+</Project>
\ No newline at end of file
diff --git a/samples/python/minimal_rec_cb/minimal_rec_cb.pyproj b/samples/python/minimal_rec_cb/minimal_rec_cb.pyproj
index 3690f51998..daeefd5892 100644
--- a/samples/python/minimal_rec_cb/minimal_rec_cb.pyproj
+++ b/samples/python/minimal_rec_cb/minimal_rec_cb.pyproj
@@ -10,6 +10,7 @@
     <OutputPath>.</OutputPath>
     <Name>minimal_rec_cb</Name>
     <RootNamespace>minimal_rec_cb</RootNamespace>
+    <ProjectGuid>{a38cc1fc-76f7-3172-81ac-b754dc0f9d60}</ProjectGuid>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
     <DebugSymbols>true</DebugSymbols>
@@ -33,4 +34,4 @@
   </Target>
   <Target Name="AfterBuild">
   </Target>
-</Project>
+</Project>
\ No newline at end of file
diff --git a/samples/python/minimal_service/minimal_service.pyproj b/samples/python/minimal_service/minimal_service.pyproj
index 4adf6da16b..f4c93a98aa 100644
--- a/samples/python/minimal_service/minimal_service.pyproj
+++ b/samples/python/minimal_service/minimal_service.pyproj
@@ -10,6 +10,7 @@
     <OutputPath>.</OutputPath>
     <Name>minimal_service</Name>
     <RootNamespace>minimal_service</RootNamespace>
+    <ProjectGuid>{97a07ce9-60dd-3a70-a2b0-1ccf564743a7}</ProjectGuid>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
     <DebugSymbols>true</DebugSymbols>
@@ -33,4 +34,4 @@
   </Target>
   <Target Name="AfterBuild">
   </Target>
-</Project>
+</Project>
\ No newline at end of file
diff --git a/samples/python/minimal_snd/minimal_snd.pyproj b/samples/python/minimal_snd/minimal_snd.pyproj
index b25bdaa698..ac006eae89 100644
--- a/samples/python/minimal_snd/minimal_snd.pyproj
+++ b/samples/python/minimal_snd/minimal_snd.pyproj
@@ -10,6 +10,7 @@
     <OutputPath>.</OutputPath>
     <Name>minimal_snd</Name>
     <RootNamespace>minimal_snd</RootNamespace>
+    <ProjectGuid>{5ebed1e0-8867-3120-bbfe-6d6db73e8077}</ProjectGuid>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
     <DebugSymbols>true</DebugSymbols>
@@ -33,4 +34,4 @@
   </Target>
   <Target Name="AfterBuild">
   </Target>
-</Project>
+</Project>
\ No newline at end of file
diff --git a/samples/python/monitoring/monitoring.pyproj b/samples/python/monitoring/monitoring.pyproj
index 65ac97dc04..561757cec6 100644
--- a/samples/python/monitoring/monitoring.pyproj
+++ b/samples/python/monitoring/monitoring.pyproj
@@ -10,6 +10,7 @@
     <OutputPath>.</OutputPath>
     <Name>monitoring</Name>
     <RootNamespace>monitoring</RootNamespace>
+    <ProjectGuid>{001d5f80-2090-3459-959b-58a5111532c6}</ProjectGuid>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
     <DebugSymbols>true</DebugSymbols>
@@ -33,4 +34,4 @@
   </Target>
   <Target Name="AfterBuild">
   </Target>
-</Project>
+</Project>
\ No newline at end of file
diff --git a/samples/python/person_rec/person_rec.pyproj b/samples/python/person_rec/person_rec.pyproj
index 3df87d71ab..b6cc346f06 100644
--- a/samples/python/person_rec/person_rec.pyproj
+++ b/samples/python/person_rec/person_rec.pyproj
@@ -10,6 +10,7 @@
     <OutputPath>.</OutputPath>
     <Name>person_rec</Name>
     <RootNamespace>person_rec</RootNamespace>
+    <ProjectGuid>{299dfe00-c6ff-3496-baa9-f0b2dd2172b4}</ProjectGuid>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
     <DebugSymbols>true</DebugSymbols>
@@ -33,4 +34,4 @@
   </Target>
   <Target Name="AfterBuild">
   </Target>
-</Project>
+</Project>
\ No newline at end of file
diff --git a/samples/python/person_rec_cb/person_rec_cb.pyproj b/samples/python/person_rec_cb/person_rec_cb.pyproj
index c442eb702f..727ab200b8 100644
--- a/samples/python/person_rec_cb/person_rec_cb.pyproj
+++ b/samples/python/person_rec_cb/person_rec_cb.pyproj
@@ -10,6 +10,7 @@
     <OutputPath>.</OutputPath>
     <Name>person_rec_cb</Name>
     <RootNamespace>person_rec_cb</RootNamespace>
+    <ProjectGuid>{4adc1f65-2c6b-3bb4-94dc-59a3ede188ac}</ProjectGuid>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
     <DebugSymbols>true</DebugSymbols>
@@ -33,4 +34,4 @@
   </Target>
   <Target Name="AfterBuild">
   </Target>
-</Project>
+</Project>
\ No newline at end of file
diff --git a/samples/python/person_rec_json/person_rec_json.pyproj b/samples/python/person_rec_json/person_rec_json.pyproj
index e9c6a20328..0bfc26c48b 100644
--- a/samples/python/person_rec_json/person_rec_json.pyproj
+++ b/samples/python/person_rec_json/person_rec_json.pyproj
@@ -10,6 +10,7 @@
     <OutputPath>.</OutputPath>
     <Name>person_rec_json</Name>
     <RootNamespace>person_rec_json</RootNamespace>
+    <ProjectGuid>{d55e30a0-4680-3450-802f-a63216f10007}</ProjectGuid>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
     <DebugSymbols>true</DebugSymbols>
@@ -33,4 +34,4 @@
   </Target>
   <Target Name="AfterBuild">
   </Target>
-</Project>
+</Project>
\ No newline at end of file
diff --git a/samples/python/person_snd/person_snd.pyproj b/samples/python/person_snd/person_snd.pyproj
index 4a0ee2631e..eb00152748 100644
--- a/samples/python/person_snd/person_snd.pyproj
+++ b/samples/python/person_snd/person_snd.pyproj
@@ -10,6 +10,7 @@
     <OutputPath>.</OutputPath>
     <Name>person_snd</Name>
     <RootNamespace>person_snd</RootNamespace>
+    <ProjectGuid>{f304b7ca-4d61-3f73-b77f-821c6f806695}</ProjectGuid>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
     <DebugSymbols>true</DebugSymbols>
@@ -33,4 +34,4 @@
   </Target>
   <Target Name="AfterBuild">
   </Target>
-</Project>
+</Project>
\ No newline at end of file
diff --git a/testing/contrib/ecalhdf5/hdf5_test/src/CMakeLists.txt b/testing/contrib/ecalhdf5/hdf5_test/src/CMakeLists.txt
new file mode 100644
index 0000000000..557c48c71d
--- /dev/null
+++ b/testing/contrib/ecalhdf5/hdf5_test/src/CMakeLists.txt
@@ -0,0 +1,37 @@
+# ========================= eCAL LICENSE =================================
+#
+# Copyright (C) 2016 - 2019 Continental Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#      http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# ========================= eCAL LICENSE =================================
+
+project(test_hdf5)
+
+find_package(Threads REQUIRED)
+find_package(GTest REQUIRED)
+
+set(hdf5_test_src
+  hdf5_test.cpp
+)
+
+ecal_add_gtest(${PROJECT_NAME} ${hdf5_test_src})
+
+target_link_libraries(${PROJECT_NAME}
+  PRIVATE
+    eCAL::hdf5
+    Threads::Threads)
+
+ecal_install_gtest(${PROJECT_NAME})
+
+set_property(TARGET ${PROJECT_NAME} PROPERTY FOLDER testing/contrib/ecalhdf5)
diff --git a/testing/contrib/ecalhdf5/hdf5_test/src/hdf5_test.cpp b/testing/contrib/ecalhdf5/hdf5_test/src/hdf5_test.cpp
new file mode 100644
index 0000000000..20faa99703
--- /dev/null
+++ b/testing/contrib/ecalhdf5/hdf5_test/src/hdf5_test.cpp
@@ -0,0 +1,184 @@
+/* ========================= eCAL LICENSE =================================
+ *
+ * Copyright (C) 2016 - 2019 Continental Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * ========================= eCAL LICENSE =================================
+*/
+
+#include <ecalhdf5/eh5_meas.h>
+
+#include <chrono>
+#include <fstream>
+#include <thread>
+
+#include <gtest/gtest.h>
+
+#define TEST_RAW_PERF      1
+#define TEST_HDF5_PERF     1
+
+#define USE_OFSTREAM       0
+#define TEST_POST_SLEEP    2               // seconds
+
+#define TEST_SIZE_1        1
+#define DATA_SET_SIZE_1    (1024)          // 1 kB
+#define DATA_SET_NUMBER_1  (64*1024)
+
+#define TEST_SIZE_2        1
+#define DATA_SET_SIZE_2    (128*1024)      // 128 kB
+#define DATA_SET_NUMBER_2  (8*1024)
+
+#define TEST_SIZE_3        1
+#define DATA_SET_SIZE_3    (1024*1024)     // 1 MB
+#define DATA_SET_NUMBER_3  (1024)
+
+#define TEST_SIZE_4        1
+#define DATA_SET_SIZE_4    (4096*1024)     // 4 MB
+#define DATA_SET_NUMBER_4  (256)
+
+namespace
+{
+  // properties
+  std::string output_dir         = "measurement_dir";
+  const size_t max_size_per_file = 500;  // MB
+  std::vector<char> data;
+}
+
+TEST(HDF5, ReadWrite)
+{
+  std::string file_name = "meas_readwrite";
+
+  // Create writer instance
+  eCAL::eh5::HDF5Meas writer(output_dir, eCAL::eh5::CREATE);
+  writer.SetFileBaseName(file_name);
+  writer.SetMaxSizePerFile(max_size_per_file);
+
+  data.resize(DATA_SET_SIZE_1);
+  EXPECT_TRUE(writer.AddEntryToFile(static_cast<void*>(data.data()), data.size(), 0, 0, "myChannel", 0, 0));
+
+  EXPECT_TRUE(writer.Close());
+}
+
+void MeasPerf(const std::string& file_name, const size_t pkg_size, const size_t pkg_num)
+{
+  data.resize(pkg_size);
+  const size_t write_loops(pkg_num);
+
+#if TEST_RAW_PERF
+  // Test raw performance
+  {
+    // start time
+    auto start = std::chrono::high_resolution_clock::now();
+
+#if USE_OFSTREAM
+
+    std::ofstream rfile(file_name + "_raw", std::ios::trunc | std::ios::out | std::ios::binary);
+    if (rfile)
+    {
+      for (size_t loops = 0; loops < write_loops; ++loops)
+      {
+        rfile.write(data.data(), data.size());
+      }
+    }
+    rfile.close();
+
+#else // USE_OFSTREAM
+
+    FILE* pFile(nullptr);
+    std::string fname = file_name + "_raw";
+    pFile = fopen(fname.c_str(), "wb");
+    if (pFile)
+    {
+      for (size_t loops = 0; loops < write_loops; ++loops)
+      {
+        fwrite(data.data(), 1, data.size(), pFile);
+      }
+      fclose(pFile);
+    }
+
+#endif // USE_OFSTREAM
+
+    // end time
+    auto finish = std::chrono::high_resolution_clock::now();
+    std::chrono::duration<double> elapsed = finish - start;
+    size_t sum_data = data.size() * write_loops;
+    std::cout << std::endl;
+    std::cout << "Packages number : " << write_loops << std::endl;
+    std::cout << "Packages size   : " << data.size()/1024 << " kB" << std::endl;
+    std::cout << "Sum payload     : " << sum_data / (1024*1024) << " MB" << std::endl;
+    std::cout << "Throughput RAW  : " << int((sum_data / (1024.0 * 1024.0)) / elapsed.count()) << " MB/s " << std::endl;
+    std::cout << std::endl;
+
+    std::this_thread::sleep_for(std::chrono::seconds(TEST_POST_SLEEP));
+  }
+#endif
+
+#if TEST_HDF5_PERF
+  // Test HDF5 performance
+  {
+    // start time
+    auto start = std::chrono::high_resolution_clock::now();
+
+    eCAL::eh5::HDF5Meas writer(output_dir, eCAL::eh5::CREATE);
+    writer.SetFileBaseName(file_name + "_hdf5");
+    writer.SetMaxSizePerFile(max_size_per_file);
+    for (size_t loop = 0; loop < write_loops; ++loop)
+    {
+      EXPECT_TRUE(writer.AddEntryToFile(static_cast<void*>(data.data()), data.size(), 0, 0, "myChannel", 0, loop));
+    }
+    EXPECT_TRUE(writer.Close());
+
+    // end time
+    auto finish = std::chrono::high_resolution_clock::now();
+    std::chrono::duration<double> elapsed = finish - start;
+    size_t sum_data = data.size() * write_loops;
+    std::cout << std::endl;
+    std::cout << "Packages number : " << write_loops << std::endl;
+    std::cout << "Packages size   : " << data.size() / 1024 << " kB" << std::endl;
+    std::cout << "Sum payload     : " << sum_data / (1024 * 1024) << " MB" << std::endl;
+    std::cout << "Throughput HDF5 : " << int((sum_data / (1024.0 * 1024.0)) / elapsed.count()) << " MB/s " << std::endl;
+    std::cout << std::endl;
+
+    std::this_thread::sleep_for(std::chrono::seconds(TEST_POST_SLEEP));
+  }
+#endif
+}
+
+#if TEST_SIZE_1
+TEST(HDF5, Performance_1kb)
+{
+  MeasPerf("meas_1_pkg",    DATA_SET_SIZE_1, DATA_SET_NUMBER_1);
+}
+#endif // TEST_SIZE_1
+
+#if TEST_SIZE_2
+TEST(HDF5, Performance_128kb)
+{
+  MeasPerf("meas_128_pkg",  DATA_SET_SIZE_2, DATA_SET_NUMBER_2);
+}
+#endif // TEST_SIZE_2
+
+#if TEST_SIZE_3
+TEST(HDF5, Performance_1024kb)
+{
+  MeasPerf("meas_1024_pkg", DATA_SET_SIZE_3, DATA_SET_NUMBER_3);
+}
+#endif // TEST_SIZE_3
+
+#if TEST_SIZE_4
+TEST(HDF5, Performance_4096kb)
+{
+  MeasPerf("meas_4096_pkg", DATA_SET_SIZE_4, DATA_SET_NUMBER_4);
+}
+#endif // TEST_SIZE_4
diff --git a/testing/contrib/ecalproto/dynproto_test/src/CMakeLists.txt b/testing/contrib/ecalproto/dynproto_test/src/CMakeLists.txt
new file mode 100644
index 0000000000..8836db8773
--- /dev/null
+++ b/testing/contrib/ecalproto/dynproto_test/src/CMakeLists.txt
@@ -0,0 +1,49 @@
+# ========================= eCAL LICENSE =================================
+#
+# Copyright (C) 2016 - 2019 Continental Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#      http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# ========================= eCAL LICENSE =================================
+
+project(test_dynproto)
+
+find_package(Threads REQUIRED)
+find_package(GTest REQUIRED)
+find_package(Protobuf REQUIRED)
+
+create_targets_protobuf()
+
+set(dynproto_test_src
+  dynproto_test.cpp
+)
+
+set(test_dynproto_proto
+  ${CMAKE_CURRENT_SOURCE_DIR}/protobuf/animal.proto
+  ${CMAKE_CURRENT_SOURCE_DIR}/protobuf/attitude.proto
+  ${CMAKE_CURRENT_SOURCE_DIR}/protobuf/house.proto
+  ${CMAKE_CURRENT_SOURCE_DIR}/protobuf/person.proto
+)
+
+ecal_add_gtest(${PROJECT_NAME} ${dynproto_test_src})
+PROTOBUF_TARGET_CPP(${PROJECT_NAME} ${CMAKE_CURRENT_SOURCE_DIR}/protobuf ${${PROJECT_NAME}_proto})
+
+target_link_libraries(${PROJECT_NAME}
+  PRIVATE
+    Threads::Threads
+    eCAL::proto
+    protobuf::libprotobuf)
+
+ecal_install_gtest(${PROJECT_NAME})
+
+set_property(TARGET ${PROJECT_NAME} PROPERTY FOLDER testing/contrib/ecalproto)
diff --git a/testing/contrib/ecalproto/dynproto_test/src/dynproto_test.cpp b/testing/contrib/ecalproto/dynproto_test/src/dynproto_test.cpp
new file mode 100644
index 0000000000..322dcd8969
--- /dev/null
+++ b/testing/contrib/ecalproto/dynproto_test/src/dynproto_test.cpp
@@ -0,0 +1,328 @@
+/* ========================= eCAL LICENSE =================================
+ *
+ * Copyright (C) 2016 - 2019 Continental Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * ========================= eCAL LICENSE =================================
+*/
+
+#include <ecal/protobuf/ecal_proto_dyn.h>
+
+#include <gtest/gtest.h>
+
+#include <cstdio>
+
+#include "person.pb.h"
+
+// message processor
+void ProcProtoMsg(const google::protobuf::Message& msg_, const std::string& prefix_ /* = "" */);
+
+// google test
+TEST(IO, dynproto)
+{ 
+  // generate a class instance of Person
+  pb::People::Person person;
+
+  // set person object content
+  person.set_id(42);
+  person.set_name("Max");
+  person.set_stype(pb::People::Person_SType_MALE);
+  person.set_email("max@mail.net");
+  person.set_attitude(pb::People::NICE);
+  person.mutable_dog()->set_name("Brandy");
+  person.mutable_house()->set_rooms(4);
+
+  ///////////////////////////////////////////////
+  // this is the message type string
+  ///////////////////////////////////////////////
+  std::string topic_type = person.GetTypeName();
+  EXPECT_NE(0, static_cast<int>(topic_type.size()));
+
+  // kill namespace and proto: prefix
+  topic_type = topic_type.substr(topic_type.find_first_of(':')+1, topic_type.size());
+  topic_type = topic_type.substr(topic_type.find_last_of('.')+1, topic_type.size());
+
+  ////////////////////////////////////////////////////
+  // this is the message description string
+  ////////////////////////////////////////////////////
+  std::string topic_desc = eCAL::protobuf::GetProtoMessageDescription(person);
+  EXPECT_NE(0, static_cast<int>(topic_desc.size()));
+
+  ////////////////////////////////////////////////////
+  // this is the message payload string
+  ////////////////////////////////////////////////////
+  std::string msg_s = person.SerializeAsString();
+  EXPECT_NE(0, static_cast<int>(msg_s.size()));
+
+  // create a message decoder
+  eCAL::protobuf::CProtoDynDecoder decoder;
+
+  // create google::protobuf::Message pointer
+  std::string error_s;
+  google::protobuf::FileDescriptorSet proto_desc;
+  proto_desc.ParseFromString(topic_desc);
+  google::protobuf::Message* msg_ptr = decoder.GetProtoMessageFromDescriptorSet(proto_desc, topic_type, error_s);
+  if(msg_ptr == nullptr)
+  {
+    std::cout << error_s << std::endl;
+  }
+  EXPECT_NE(nullptr, msg_ptr);
+
+  //std::FILE* f = std::fopen("d:\\temp.log", "w");
+  //std::fwrite(topic_desc.c_str(), 1, topic_desc.size(), f);
+  //std::fclose(f);
+
+  if (msg_ptr)
+  {
+    // fill message with received string
+    msg_ptr->ParseFromString(msg_s);
+
+    // and dynamic decode it
+    ProcProtoMsg(*msg_ptr, "");
+  }
+}
+
+// message processor
+void ProcValue(const std::string& group_, const std::string& name_, const double value_, size_t index_)
+{
+  std::string var_name;
+  if(!group_.empty()) var_name += group_ + ".";
+  var_name += name_;
+  if(index_ > 0) var_name += "[" + std::to_string(index_) + "]";
+  std::cout << var_name << " : " << value_ << std::endl;
+}
+
+void ProcString(const std::string& group_, const std::string& name_, const std::string& value_, size_t index_)
+{
+  std::string var_name;
+  if(!group_.empty()) var_name += group_ + ".";
+  var_name += name_;
+  if(index_ > 0) var_name += "[" + std::to_string(index_) + "]";
+  std::cout << var_name << " : " << value_ << std::endl;
+}
+
+void ProcProtoType(const std::string& group_, const std::string& name_, google::protobuf::int32 value_, size_t index_)
+{
+  ProcValue(group_, name_, double(value_), index_);
+}
+
+void ProcProtoType(const std::string& group_, const std::string& name_, google::protobuf::int64 value_, size_t index_)
+{
+  ProcValue(group_, name_, double(value_), index_);
+}
+
+void ProcProtoType(const std::string& group_, const std::string& name_, google::protobuf::uint32 value_, size_t index_)
+{
+  ProcValue(group_, name_, double(value_), index_);
+}
+
+void ProcProtoType(const std::string& group_, const std::string& name_, google::protobuf::uint64 value_, size_t index_)
+{
+  ProcValue(group_, name_, double(value_), index_);
+}
+
+void ProcProtoType(const std::string& group_, const std::string& name_, float value_, size_t index_)
+{
+  ProcValue(group_, name_, double(value_), index_);
+}
+
+void ProcProtoType(const std::string& group_, const std::string& name_, double value_, size_t index_)
+{
+  ProcValue(group_, name_, double(value_), index_);
+}
+
+void ProcProtoType(const std::string& group_, const std::string& name_, bool value_, size_t index_)
+{
+  ProcValue(group_, name_, double(value_), index_);
+}
+
+void ProcProtoType(const std::string& group_, const std::string& name_, google::protobuf::string value_, size_t index_)
+{
+  ProcString(group_, name_, value_, index_);
+}
+
+void ProcProtoType(const std::string& group_, const std::string& name_, const google::protobuf::EnumValueDescriptor* value_, size_t index_)
+{
+  ProcValue(group_, name_, double(value_->number()), index_);
+}
+
+void ProcProtoMsg(const google::protobuf::Message& msg_, const std::string& prefix_ /* = "" */)
+{
+  const google::protobuf::Reflection* ref_ptr = msg_.GetReflection();
+  if(ref_ptr)
+  {
+    std::vector<const google::protobuf::FieldDescriptor*> field_v;
+    ref_ptr->ListFields(msg_, &field_v);
+    for(auto field : field_v)
+    {
+      const google::protobuf::FieldDescriptor::CppType fdt = field->cpp_type();
+      switch(fdt)
+      {
+      case google::protobuf::FieldDescriptor::CPPTYPE_INT32:      // TYPE_INT32, TYPE_SINT32, TYPE_SFIXED32
+        if(field->is_repeated())
+        {
+          int fsize = ref_ptr->FieldSize(msg_, field);
+          for(int fnum = 0; fnum < fsize; ++fnum)
+          {
+            ProcProtoType(prefix_, field->name(), ref_ptr->GetRepeatedInt32(msg_, field, fnum), fnum);
+          }
+        }
+        else
+        {
+          ProcProtoType(prefix_, field->name(), ref_ptr->GetInt32(msg_, field), 0);
+        }
+        break;
+      case google::protobuf::FieldDescriptor::CPPTYPE_INT64:      // TYPE_INT64, TYPE_SINT64, TYPE_SFIXED64
+        if(field->is_repeated())
+        {
+          int fsize = ref_ptr->FieldSize(msg_, field);
+          for(int fnum = 0; fnum < fsize; ++fnum)
+          {
+            ProcProtoType(prefix_, field->name(), ref_ptr->GetRepeatedInt64(msg_, field, fnum), fnum);
+          }
+        }
+        else
+        {
+          ProcProtoType(prefix_, field->name(), ref_ptr->GetInt64(msg_, field), 0);
+        }
+        break;
+      case google::protobuf::FieldDescriptor::CPPTYPE_UINT32:     // TYPE_UINT32, TYPE_FIXED32
+        if(field->is_repeated())
+        {
+          int fsize = ref_ptr->FieldSize(msg_, field);
+          for(int fnum = 0; fnum < fsize; ++fnum)
+          {
+            ProcProtoType(prefix_, field->name(), ref_ptr->GetRepeatedUInt32(msg_, field, fnum), fnum);
+          }
+        }
+        else
+        {
+          ProcProtoType(prefix_, field->name(), ref_ptr->GetUInt32(msg_, field), 0);
+        }
+        break;
+      case google::protobuf::FieldDescriptor::CPPTYPE_UINT64:     // TYPE_UINT64, TYPE_FIXED64
+        if(field->is_repeated())
+        {
+          int fsize = ref_ptr->FieldSize(msg_, field);
+          for(int fnum = 0; fnum < fsize; ++fnum)
+          {
+            ProcProtoType(prefix_, field->name(), ref_ptr->GetRepeatedUInt64(msg_, field, fnum), fnum);
+          }
+        }
+        else
+        {
+          ProcProtoType(prefix_, field->name(), ref_ptr->GetUInt64(msg_, field), 0);
+        }
+        break;
+      case google::protobuf::FieldDescriptor::CPPTYPE_DOUBLE:     // TYPE_DOUBLE
+        if(field->is_repeated())
+        {
+          int fsize = ref_ptr->FieldSize(msg_, field);
+          for(int fnum = 0; fnum < fsize; ++fnum)
+          {
+            ProcProtoType(prefix_, field->name(), ref_ptr->GetRepeatedDouble(msg_, field, fnum), fnum);
+          }
+        }
+        else
+        {
+          ProcProtoType(prefix_, field->name(), ref_ptr->GetDouble(msg_, field), 0);
+        }
+        break;
+      case google::protobuf::FieldDescriptor::CPPTYPE_FLOAT:      // TYPE_FLOAT
+        if(field->is_repeated())
+        {
+          int fsize = ref_ptr->FieldSize(msg_, field);
+          for(int fnum = 0; fnum < fsize; ++fnum)
+          {
+            ProcProtoType(prefix_, field->name(), ref_ptr->GetRepeatedFloat(msg_, field, fnum), fnum);
+          }
+        }
+        else
+        {
+          ProcProtoType(prefix_, field->name(), ref_ptr->GetFloat(msg_, field), 0);
+        }
+        break;
+      case google::protobuf::FieldDescriptor::CPPTYPE_BOOL:       // TYPE_BOOL
+        if(field->is_repeated())
+        {
+          int fsize = ref_ptr->FieldSize(msg_, field);
+          for(int fnum = 0; fnum < fsize; ++fnum)
+          {
+            ProcProtoType(prefix_, field->name(), ref_ptr->GetRepeatedBool(msg_, field, fnum), fnum);
+          }
+        }
+        else
+        {
+          ProcProtoType(prefix_, field->name(), ref_ptr->GetBool(msg_, field), 0);
+        }
+        break;
+      case google::protobuf::FieldDescriptor::CPPTYPE_ENUM:       // TYPE_ENUM
+        if(field->is_repeated())
+        {
+          int fsize = ref_ptr->FieldSize(msg_, field);
+          for(int fnum = 0; fnum < fsize; ++fnum)
+          {
+            ProcProtoType(prefix_, field->name(), ref_ptr->GetRepeatedEnum(msg_, field, fnum), fnum);
+          }
+        }
+        else
+        {
+          ProcProtoType(prefix_, field->name(), ref_ptr->GetEnum(msg_, field), 0);
+        }
+        break;
+      case google::protobuf::FieldDescriptor::CPPTYPE_STRING:     // TYPE_STRING, TYPE_BYTES
+        if(field->is_repeated())
+        {
+          int fsize = ref_ptr->FieldSize(msg_, field);
+          for(int fnum = 0; fnum < fsize; ++fnum)
+          {
+            ProcProtoType(prefix_, field->name(), ref_ptr->GetRepeatedString(msg_, field, fnum), fnum);
+          }
+        }
+        else
+        {
+          ProcProtoType(prefix_, field->name(), ref_ptr->GetString(msg_, field), 0);
+        }
+        break;
+      case google::protobuf::FieldDescriptor::CPPTYPE_MESSAGE:    // TYPE_MESSAGE, TYPE_GROUP
+        {
+          if(field->is_repeated())
+          {
+            int fsize = ref_ptr->FieldSize(msg_, field);
+            for(int fnum = 0; fnum < fsize; ++fnum)
+            {
+              const google::protobuf::Message& msg = ref_ptr->GetRepeatedMessage(msg_, field, fnum);
+              std::string prefix = field->name();
+              prefix += "[";
+              prefix += std::to_string(fnum);
+              prefix += "]";
+              if(!prefix_.empty()) prefix = prefix_ + "." + prefix;
+              ProcProtoMsg(msg, prefix);
+            }
+          }
+          else
+          {
+            const google::protobuf::Message& msg = ref_ptr->GetMessage(msg_, field);
+            std::string prefix = field->name();
+            if(!prefix_.empty()) prefix = prefix_ + "." + prefix;
+            ProcProtoMsg(msg, prefix);
+          }
+        }
+        break;
+      default:
+        break;
+      }
+    }
+  }
+}
diff --git a/samples/cpp/person/person_snd_lcm/src/protobuf/animal.proto b/testing/contrib/ecalproto/dynproto_test/src/protobuf/animal.proto
similarity index 100%
rename from samples/cpp/person/person_snd_lcm/src/protobuf/animal.proto
rename to testing/contrib/ecalproto/dynproto_test/src/protobuf/animal.proto
diff --git a/ecal/core/src/readwrite/ecal_reader_udp_uc.cpp b/testing/contrib/ecalproto/dynproto_test/src/protobuf/attitude.proto
similarity index 80%
rename from ecal/core/src/readwrite/ecal_reader_udp_uc.cpp
rename to testing/contrib/ecalproto/dynproto_test/src/protobuf/attitude.proto
index f754880ee2..a36e43e805 100644
--- a/ecal/core/src/readwrite/ecal_reader_udp_uc.cpp
+++ b/testing/contrib/ecalproto/dynproto_test/src/protobuf/attitude.proto
@@ -17,13 +17,12 @@
  * ========================= eCAL LICENSE =================================
 */
 
-/**
- * @brief  eCAL udp unicast reader
-**/
+syntax = "proto3";
 
-#include "readwrite/ecal_reader_udp_uc.h"
+package pb.People;
 
-namespace eCAL
+enum Attitude
 {
-  template<> std::shared_ptr<CUnicastLayer> CReaderLayer<CUnicastLayer>::layer(nullptr);
-};
+  NICE = 0;
+  BAD  = 1;
+}
diff --git a/samples/cpp/person/person_snd_lcm/src/protobuf/house.proto b/testing/contrib/ecalproto/dynproto_test/src/protobuf/house.proto
similarity index 100%
rename from samples/cpp/person/person_snd_lcm/src/protobuf/house.proto
rename to testing/contrib/ecalproto/dynproto_test/src/protobuf/house.proto
diff --git a/samples/cpp/person/person_snd_unicast/src/protobuf/person.proto b/testing/contrib/ecalproto/dynproto_test/src/protobuf/person.proto
similarity index 79%
rename from samples/cpp/person/person_snd_unicast/src/protobuf/person.proto
rename to testing/contrib/ecalproto/dynproto_test/src/protobuf/person.proto
index 4200a433f0..2313e22ce0 100644
--- a/samples/cpp/person/person_snd_unicast/src/protobuf/person.proto
+++ b/testing/contrib/ecalproto/dynproto_test/src/protobuf/person.proto
@@ -21,6 +21,7 @@ syntax = "proto3";
 
 import "animal.proto";
 import "house.proto";
+import "attitude.proto";
 
 package pb.People;
 
@@ -32,11 +33,12 @@ message Person
     FEMALE = 1;
   }
 
-  int32  id               = 1;
-  string name             = 2;
-  SType  stype            = 3;
-  string email            = 4;
+  int32    id             = 1;
+  string   name           = 2;
+  SType    stype          = 3;
+  string   email          = 4;
+  Attitude attitude       = 5;
 
-  Animal.Dog        dog   = 5;
-  Environment.House house = 6;
+  Animal.Dog        dog   = 6;
+  Environment.House house = 7;
 }
diff --git a/samples/cpp/person/person_snd_rtps/src/CMakeLists.txt b/testing/contrib/ecalproto/ecal_proto_test/src/CMakeLists.txt
similarity index 65%
rename from samples/cpp/person/person_snd_rtps/src/CMakeLists.txt
rename to testing/contrib/ecalproto/ecal_proto_test/src/CMakeLists.txt
index e3a940fa71..181b6fd58c 100644
--- a/samples/cpp/person/person_snd_rtps/src/CMakeLists.txt
+++ b/testing/contrib/ecalproto/ecal_proto_test/src/CMakeLists.txt
@@ -16,29 +16,33 @@
 #
 # ========================= eCAL LICENSE =================================
 
-project(person_snd_rtps)
+project(test_ecal_proto)
 
-find_package(eCAL REQUIRED)
+find_package(Threads REQUIRED)
+find_package(GTest REQUIRED)
 find_package(Protobuf REQUIRED)
 
-set(person_snd_rtps_src
-  person_snd_rtps.cpp
+create_targets_protobuf()
+
+set(ecal_proto_test_src
+  test_filters.cpp
 )
 
-set(person_snd_rtps_proto
+set(${PROJECT_NAME}_proto
   ${CMAKE_CURRENT_SOURCE_DIR}/protobuf/animal.proto
   ${CMAKE_CURRENT_SOURCE_DIR}/protobuf/house.proto
-  ${CMAKE_CURRENT_SOURCE_DIR}/protobuf/person.proto    
+  ${CMAKE_CURRENT_SOURCE_DIR}/protobuf/person.proto
 )
-ecal_add_sample(${PROJECT_NAME} ${person_snd_rtps_src})
-PROTOBUF_TARGET_CPP(${PROJECT_NAME} ${CMAKE_CURRENT_SOURCE_DIR}/protobuf ${person_snd_rtps_proto})
 
-target_include_directories(${PROJECT_NAME} PRIVATE .)
+ecal_add_gtest(${PROJECT_NAME} ${ecal_proto_test_src})
+PROTOBUF_TARGET_CPP(${PROJECT_NAME} ${CMAKE_CURRENT_SOURCE_DIR}/protobuf ${${PROJECT_NAME}_proto})
 
 target_link_libraries(${PROJECT_NAME}
-  eCAL::core
-  protobuf::libprotobuf)
+  PRIVATE
+    Threads::Threads
+    eCAL::proto
+    protobuf::libprotobuf)
 
-ecal_install_sample(${PROJECT_NAME})
+ecal_install_gtest(${PROJECT_NAME} ${PROJECT_NAME})
 
-set_property(TARGET ${PROJECT_NAME} PROPERTY FOLDER samples/cpp/person)
+set_property(TARGET ${PROJECT_NAME} PROPERTY FOLDER testing/contrib/ecalproto)
diff --git a/samples/cpp/person/person_snd_rtps/src/protobuf/animal.proto b/testing/contrib/ecalproto/ecal_proto_test/src/protobuf/animal.proto
similarity index 100%
rename from samples/cpp/person/person_snd_rtps/src/protobuf/animal.proto
rename to testing/contrib/ecalproto/ecal_proto_test/src/protobuf/animal.proto
diff --git a/samples/cpp/person/person_snd_rtps/src/protobuf/house.proto b/testing/contrib/ecalproto/ecal_proto_test/src/protobuf/house.proto
similarity index 100%
rename from samples/cpp/person/person_snd_rtps/src/protobuf/house.proto
rename to testing/contrib/ecalproto/ecal_proto_test/src/protobuf/house.proto
diff --git a/samples/cpp/person/person_snd_lcm/src/protobuf/person.proto b/testing/contrib/ecalproto/ecal_proto_test/src/protobuf/person.proto
similarity index 100%
rename from samples/cpp/person/person_snd_lcm/src/protobuf/person.proto
rename to testing/contrib/ecalproto/ecal_proto_test/src/protobuf/person.proto
diff --git a/testing/contrib/ecalproto/ecal_proto_test/src/test_filters.cpp b/testing/contrib/ecalproto/ecal_proto_test/src/test_filters.cpp
new file mode 100644
index 0000000000..61c2822270
--- /dev/null
+++ b/testing/contrib/ecalproto/ecal_proto_test/src/test_filters.cpp
@@ -0,0 +1,194 @@
+/* ========================= eCAL LICENSE =================================
+ *
+ * Copyright (C) 2016 - 2019 Continental Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * ========================= eCAL LICENSE =================================
+*/
+
+/**
+ * Tests eCALHDF5 reader w/o input file (single channel)
+**/
+
+#include <string>
+
+#include "ecal/protobuf/ecal_proto_message_filter.h"
+
+#include "gtest/gtest.h"
+
+using namespace eCAL::protobuf;
+
+TEST(filter, nofilter)
+{
+  NoFilter filter;
+  bool result = filter.Filter("abc");
+  EXPECT_EQ(true, result);
+}
+
+TEST(filter, include_filter_clear)
+{
+  SimpleIncludeFilter filter;
+  std::string a("a");
+  filter.Insert(a);
+  EXPECT_EQ(true, filter.Filter(a));
+
+  filter.Clear();
+  EXPECT_EQ(false, filter.Filter(a));
+}
+
+void test_regular_includes(BaseIncludeFilter& filter)
+{
+  std::string abc("a.b.c");
+  std::string ab("a.b");
+  std::string a("a");
+  std::string ad("a.d");
+  std::string ade("a.d.e");
+  std::string adf("a.d.f");
+  EXPECT_EQ(false, filter.Filter(abc));
+  filter.Insert(abc);
+  EXPECT_EQ(true, filter.Filter(a));
+  EXPECT_EQ(true, filter.Filter(ab));
+  EXPECT_EQ(true, filter.Filter(abc));
+  filter.Erase(abc);
+  EXPECT_EQ(false, filter.Filter(a));
+  EXPECT_EQ(false, filter.Filter(ab));
+  EXPECT_EQ(false, filter.Filter(abc));
+  filter.Insert(ade);
+  filter.Insert(abc);
+  filter.Insert(adf);
+  filter.Erase(ade);
+  EXPECT_EQ(true, filter.Filter(a));
+  EXPECT_EQ(true, filter.Filter(ab));
+  EXPECT_EQ(true, filter.Filter(abc));
+  EXPECT_EQ(true, filter.Filter(ad));
+  EXPECT_EQ(false, filter.Filter(ade));
+  EXPECT_EQ(true, filter.Filter(adf));
+  filter.Erase(abc);
+  EXPECT_EQ(true, filter.Filter(a));
+  EXPECT_EQ(false, filter.Filter(ab));
+  EXPECT_EQ(false, filter.Filter(abc));
+  EXPECT_EQ(true, filter.Filter(ad));
+  EXPECT_EQ(false, filter.Filter(ade));
+  EXPECT_EQ(true, filter.Filter(adf));
+  filter.Erase(adf);
+  EXPECT_EQ(false, filter.Filter(a));
+  EXPECT_EQ(false, filter.Filter(ab));
+  EXPECT_EQ(false, filter.Filter(abc));
+  EXPECT_EQ(false, filter.Filter(ad));
+  EXPECT_EQ(false, filter.Filter(ade));
+  EXPECT_EQ(false, filter.Filter(adf));
+}
+
+TEST(filter, include_filter)
+{
+  SimpleIncludeFilter simple_filter;
+  test_regular_includes(simple_filter);
+  ComplexIncludeFilter complex_filter;
+  test_regular_includes(complex_filter);
+}
+
+TEST(filter, include_filter_array_simple)
+{
+  const std::string a("a");
+  const std::string a1("a[1]");
+  const std::string a2("a[2]");
+  const std::string a1b("a[1].b");
+  const std::string a2b("a[2].b");
+  const std::string a1bc1("a[1].b.c[1]");
+
+  ComplexIncludeFilter filter;
+  filter.Insert(a1);                   // Add a[1]
+  EXPECT_EQ(true, filter.Filter(a));  // should accept a
+  EXPECT_EQ(true, filter.Filter(a1)); // should accept a[1]
+  EXPECT_EQ(false, filter.Filter(a2)); // should not accept a[2]
+
+                                        // Test subsequently, all combinations to that point are included
+  filter.Clear();
+  filter.Insert(a1bc1);
+  EXPECT_EQ(true, filter.Filter(a));
+  EXPECT_EQ(true, filter.Filter(a1));
+  EXPECT_EQ(true, filter.Filter(a1b));
+  EXPECT_EQ(true, filter.Filter(a1bc1));
+
+  filter.Clear();
+  filter.Insert(a1b);                   // add a[1].b
+  EXPECT_EQ(true, filter.Filter(a));   // should accept a
+  EXPECT_EQ(true, filter.Filter(a1));  // should accept a[1]
+  EXPECT_EQ(true, filter.Filter(a1b)); // should accept a[1].b
+  EXPECT_EQ(false, filter.Filter(a2));  // should not accept a[2]
+  EXPECT_EQ(false, filter.Filter(a2b)); // should not accept a[2].b
+}
+
+TEST(filter, include_filter_array_complex)
+{
+  const std::string a    ("a"          );
+  const std::string a1   ("a[1]"       );
+  const std::string a2   ("a[2]"       );
+  const std::string a_   ("a[*]"       );
+  const std::string a1b  ("a[1].b"     );
+  const std::string a2b  ("a[2].b"     );
+  const std::string a_b  ("a[*].b"     );
+  const std::string a1bc_("a[1].b.c[*]");
+  const std::string a1bc1("a[1].b.c[1]");
+
+  ComplexIncludeFilter filter;
+  filter.Insert(a1);                   // Add a[1]
+  EXPECT_EQ(true,  filter.Filter(a));  // should accept a
+  EXPECT_EQ(true,  filter.Filter(a1)); // should accept a[1]
+  EXPECT_EQ(false, filter.Filter(a2)); // should not accept a[2]
+  EXPECT_EQ(false, filter.Filter(a_)); // should not accept a[*]
+
+  filter.Clear();
+  filter.Insert(a_);                   // Add a[*]
+  EXPECT_EQ(true, filter.Filter(a));   // should accept a
+  EXPECT_EQ(true, filter.Filter(a1));  // should accept a[1]
+  EXPECT_EQ(true, filter.Filter(a2));  // should accept a[2]
+  EXPECT_EQ(true, filter.Filter(a_));  // should accept a[*]
+
+  filter.Clear();
+  filter.Insert(a_b);                   // Add a[*].b
+  EXPECT_EQ(true, filter.Filter(a1b));  // should accept a[1].b
+  EXPECT_EQ(true, filter.Filter(a_b));  // should accept a[*].b
+
+  // Test subsequently, all combinations to that point are included
+  filter.Clear();
+  filter.Insert(a1bc1); 
+  EXPECT_EQ(true, filter.Filter(a));
+  EXPECT_EQ(true, filter.Filter(a1));
+  EXPECT_EQ(true, filter.Filter(a1b));
+  EXPECT_EQ(true, filter.Filter(a1bc1));
+
+  filter.Clear();
+  filter.Insert(a1bc_);
+  EXPECT_EQ(true, filter.Filter(a));
+  EXPECT_EQ(true, filter.Filter(a1));
+  EXPECT_EQ(true, filter.Filter(a1b));
+  EXPECT_EQ(true, filter.Filter(a1bc1));
+
+  filter.Clear();
+  filter.Insert(a_b);                  // add a[*].b
+  EXPECT_EQ(true, filter.Filter(a1));  // should accept a[1]
+  EXPECT_EQ(true, filter.Filter(a2));  // should accept a[2]
+  EXPECT_EQ(true, filter.Filter(a_));  // should accept a[*]
+
+  filter.Clear();
+  filter.Insert(a1b);                   // add a[1].b
+  EXPECT_EQ(true,  filter.Filter(a));   // should accept a
+  EXPECT_EQ(true,  filter.Filter(a1));  // should accept a[1]
+  EXPECT_EQ(true,  filter.Filter(a1b)); // should accept a[1].b
+  EXPECT_EQ(false, filter.Filter(a2));  // should not accept a[2]
+  EXPECT_EQ(false, filter.Filter(a2b)); // should not accept a[2].b
+  EXPECT_EQ(false, filter.Filter(a_));  // should not accept a[*]
+  EXPECT_EQ(false, filter.Filter(a_b)); // should not accept a[*].b
+}
\ No newline at end of file
diff --git a/testing/contrib/ecalproto/ecal_proto_test/src/test_maximum_array_dimensions.cpp b/testing/contrib/ecalproto/ecal_proto_test/src/test_maximum_array_dimensions.cpp
new file mode 100644
index 0000000000..e13b6b6738
--- /dev/null
+++ b/testing/contrib/ecalproto/ecal_proto_test/src/test_maximum_array_dimensions.cpp
@@ -0,0 +1,68 @@
+/* ========================= eCAL LICENSE =================================
+ *
+ * Copyright (C) 2016 - 2019 Continental Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * ========================= eCAL LICENSE =================================
+*/
+
+/**
+ * Tests eCALHDF5 reader w/o input file (single channel)
+**/
+
+#include <ecal/protobuf/ecal_proto_decoder.h>
+#include <ecal/protobuf/ecal_proto_maximum_array_dimensions.h>
+
+#include <gtest/gtest.h>
+
+#include <cstdio>
+#include <memory>
+
+#include "person.pb.h"
+
+using namespace eCAL::protobuf;
+
+TEST(MaximumArrayDimensions, Standard)
+{
+  pb::People::Person person;
+
+  // set person object content
+  person.set_id(42);
+  person.set_name("Max");
+  person.set_stype(pb::People::Person_SType_MALE);
+  person.set_email("max@mail.net");
+  person.mutable_dog()->set_name("Brandy");
+  person.mutable_house()->set_rooms(4);
+
+  // We want to test, if the 
+  CProtoDecoder decoder;
+  auto visitor = std::make_shared<MaximumArrayDimensionsVisitor>();
+  decoder.SetVisitor(visitor);
+
+  // Add a different number of favorite numbers and then Test what the maximum was.
+  ASSERT_EQ(0, visitor->MaxSize("favorite_numbers"));
+
+  person.mutable_favorite_numbers()->Resize(1, 0);
+  decoder.ProcProtoMsg(person);
+  ASSERT_EQ(1, visitor->MaxSize("favorite_numbers"));
+
+  person.mutable_favorite_numbers()->Resize(7, 0);
+  decoder.ProcProtoMsg(person);
+  ASSERT_EQ(7, visitor->MaxSize("favorite_numbers"));
+
+  person.mutable_favorite_numbers()->Resize(5, 0);
+  decoder.ProcProtoMsg(person);
+  ASSERT_EQ(7, visitor->MaxSize("favorite_numbers"));
+}
+
diff --git a/testing/contrib/ecalproto/ecal_proto_test/src/test_proto_dyn_decoder.cpp b/testing/contrib/ecalproto/ecal_proto_test/src/test_proto_dyn_decoder.cpp
new file mode 100644
index 0000000000..b4c11abcea
--- /dev/null
+++ b/testing/contrib/ecalproto/ecal_proto_test/src/test_proto_dyn_decoder.cpp
@@ -0,0 +1,134 @@
+/* ========================= eCAL LICENSE =================================
+ *
+ * Copyright (C) 2016 - 2019 Continental Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * ========================= eCAL LICENSE =================================
+*/
+
+#include <ecal/protobuf/ecal_proto_decoder.h>
+#include <ecal/protobuf/ecal_proto_message_filter.h>
+#include <ecal/protobuf/ecal_proto_visitor.h>
+
+#include <gtest/gtest.h>
+
+#include <cstdio>
+
+#include "person.pb.h"
+
+using namespace eCAL::protobuf;
+
+std::vector<std::string> elems;
+std::vector<size_t> values;
+
+void clear_output()
+{
+  elems.clear();
+  values.clear();
+}
+
+class TestVisitor : public eCAL::protobuf::MessageVisitorDoubleIntegral
+{
+public:
+  TestVisitor() :filter(std::make_shared<eCAL::protobuf::NoFilter>()) {};
+  std::shared_ptr<eCAL::protobuf::MessageFilter> filter;
+
+protected:
+  using eCAL::protobuf::MessageVisitorDoubleIntegral::ScalarValueIntegral;
+  virtual void ScalarValueIntegral(const std::string& field_, const std::string& /*group_*/, double /*value_*/) override
+  {
+    elems.push_back(field_);
+  };
+  virtual void ScalarValueEnum(const std::string& field_, const std::string& group_, int value_) override
+  {
+    ScalarValueIntegral(field_, group_, static_cast<double>(value_));
+  };
+  virtual void ArrayValueIntegral(size_t index_, double /*value_*/) override
+  {
+    values.push_back(index_);
+  };
+
+  virtual bool AcceptMessage(const std::string& message) override
+  {
+    return filter->Filter(message);
+  };
+};
+
+void add_favorite_numbers(pb::People::Person& person)
+{
+  person.mutable_favorite_numbers()->Resize(5, 0);
+  for (int num = 0; num < 5; num++)
+  {
+    person.mutable_favorite_numbers()->Set(num, num);
+  }
+}
+
+
+TEST(protodecoder, no_filter)
+{
+  // generate a class instance of Person
+  pb::People::Person person;
+
+  // set person object content
+  person.set_id(42);
+  person.set_name("Max");
+  person.set_stype(pb::People::Person_SType_MALE);
+  person.set_email("max@mail.net");
+  person.mutable_dog()->set_name("Brandy");
+  person.mutable_house()->set_rooms(4);
+
+  CProtoDecoder decoder;
+  auto visitor = std::make_shared<TestVisitor>();
+  decoder.SetVisitor(visitor);
+
+  clear_output();
+  decoder.ProcProtoMsg(person);
+  std::vector<std::string> expected_all{ "id", "stype", "rooms" };
+  EXPECT_EQ(expected_all, elems);
+
+  clear_output();
+  auto filter = std::make_shared<ComplexIncludeFilter>();
+  filter->Insert("id");
+  visitor->filter= filter;
+
+  decoder.ProcProtoMsg(person);
+  std::vector<std::string> expected_id{ "id" };
+  EXPECT_EQ(expected_id, elems);
+
+  clear_output();
+  filter->Insert("house.rooms");
+  decoder.ProcProtoMsg(person);
+  std::vector<std::string> expected_id_rooms{ "id", "rooms" };
+  EXPECT_EQ(expected_id_rooms, elems);
+
+  // Now lets add some array members, and see how it performs with the filter.
+  add_favorite_numbers(person);
+
+  // Test case, assert the array callback was called only once
+  clear_output();
+  filter->Clear();
+  filter->Insert("favorite_numbers[1]");
+  decoder.ProcProtoMsg(person);
+  std::vector<size_t> expected_values_numbers{ 1 };
+  EXPECT_EQ(expected_values_numbers, values);
+  
+  // Test case, assert the array callback was called for each element
+  clear_output();
+  filter->Clear();
+  filter->Insert("favorite_numbers[*]");
+  decoder.ProcProtoMsg(person);
+  std::vector<size_t> expected_values_all_numbers{ 0, 1, 2, 3, 4 };
+  EXPECT_EQ(expected_values_all_numbers, values);
+
+}
\ No newline at end of file
diff --git a/testing/ecal/clientserver_test/src/CMakeLists.txt b/testing/ecal/clientserver_test/src/CMakeLists.txt
new file mode 100644
index 0000000000..092240a79d
--- /dev/null
+++ b/testing/ecal/clientserver_test/src/CMakeLists.txt
@@ -0,0 +1,54 @@
+# ========================= eCAL LICENSE =================================
+#
+# Copyright (C) 2016 - 2019 Continental Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#      http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# ========================= eCAL LICENSE =================================
+
+project(test_clientserver)
+
+find_package(Threads REQUIRED)
+find_package(GTest REQUIRED)
+find_package(Protobuf REQUIRED)
+
+create_targets_protobuf()
+
+set(clientserver_test_src
+  clientserver_test.cpp
+)
+
+set(clientserver_test_proto
+  ${CMAKE_CURRENT_SOURCE_DIR}/protobuf/math.proto
+  ${CMAKE_CURRENT_SOURCE_DIR}/protobuf/ping.proto
+)
+
+ecal_add_static_library(clientserver_proto dummy.cpp)
+PROTOBUF_TARGET_CPP(clientserver_proto ${CMAKE_CURRENT_SOURCE_DIR}/protobuf ${clientserver_test_proto})
+target_link_libraries(clientserver_proto PRIVATE protobuf::libprotobuf)
+set_property(TARGET clientserver_proto PROPERTY FOLDER testing/ecal/service)
+
+ecal_add_gtest(${PROJECT_NAME}_cpp ${clientserver_test_src})
+target_link_libraries(${PROJECT_NAME}_cpp
+  PRIVATE eCAL::core clientserver_proto Threads::Threads)
+
+  ecal_install_gtest(${PROJECT_NAME}_cpp)
+set_property(TARGET ${PROJECT_NAME}_cpp PROPERTY FOLDER testing/ecal/service)
+
+if(WIN32)
+  ecal_add_gtest(${PROJECT_NAME}_c   ${clientserver_test_src})
+  target_link_libraries(${PROJECT_NAME}_c PRIVATE
+    eCAL::core_c clientserver_proto Threads::Threads)
+  ecal_install_gtest(${PROJECT_NAME}_c)
+  set_property(TARGET ${PROJECT_NAME}_c   PROPERTY FOLDER testing/ecal/service)
+endif()
diff --git a/testing/ecal/clientserver_test/src/clientserver_test.cpp b/testing/ecal/clientserver_test/src/clientserver_test.cpp
new file mode 100644
index 0000000000..fd9d6e8fe9
--- /dev/null
+++ b/testing/ecal/clientserver_test/src/clientserver_test.cpp
@@ -0,0 +1,548 @@
+/* ========================= eCAL LICENSE =================================
+ *
+ * Copyright (C) 2016 - 2019 Continental Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * ========================= eCAL LICENSE =================================
+*/
+
+#include <ecal/ecal.h>
+#include <ecal/msg/protobuf/client.h>
+#include <ecal/msg/protobuf/server.h>
+
+#include <iostream>
+#include <chrono>
+#include <thread>
+#include <cmath>
+
+#include <gtest/gtest.h>
+
+#include "math.pb.h"
+#include "ping.pb.h"
+
+#define ClientServerBaseCallbackTest    1
+#define ClientServerBaseBlockingTest    1
+#define ClientServerProtoCallbackTest   1
+#define ClientServerProtoBlockingTest   1
+#define MultipleServerTest              1
+#define NestedRPCCallTest               1
+
+namespace
+{
+  void PrintRequest(const std::string& method_, const std::string& req_type_, const std::string& resp_type_, const std::string& request_)
+  {
+    std::cout << "------ REQUEST -------" << std::endl;
+    std::cout << "Method name           : " << method_    << std::endl;
+    std::cout << "Method request type   : " << req_type_  << std::endl;
+    std::cout << "Method response type  : " << resp_type_ << std::endl;
+    std::cout << "Method request type   : " << resp_type_ << std::endl;
+    std::cout << "Method request        : " << request_   << std::endl;
+    std::cout << std::endl;
+  }
+
+  void PrintResponse(const struct eCAL::SServiceInfo& service_info_, const std::string& response_)
+  {
+    std::cout << "------ RESPONSE ------" << std::endl;
+    std::cout << "Executed on host name : " << service_info_.host_name    << std::endl;
+    std::cout << "Executed service name : " << service_info_.service_name << std::endl;
+    std::cout << "Executed method name  : " << service_info_.method_name  << std::endl;
+    std::cout << "Return value          : " << service_info_.ret_state    << std::endl;
+    std::cout << "Execution state       : ";
+    switch (service_info_.call_state)
+    {
+    case call_state_none:
+      std::cout << "call_state_none";
+      break;
+    case call_state_executed:
+      std::cout << "call_state_executed";
+      break;
+    case call_state_failed:
+      std::cout << "call_state_failed";
+      break;
+    }
+    std::cout << std::endl;
+    std::cout << "Execution error msg   : " << service_info_.error_msg << std::endl;
+    std::cout << "Response              : " << response_ << std::endl  << std::endl;
+    std::cout << std::endl;
+  };
+}
+
+#if ClientServerBaseCallbackTest
+
+TEST(IO, ClientServerBaseCallback)
+{
+  const int calls(2);
+  const int sleep(0);
+
+  // initialize eCAL API
+  eCAL::Initialize(0, nullptr, "clientserver base callback test");
+
+  // create service server
+  eCAL::CServiceServer server("service1");
+
+  // request callback function
+  int requests_executed(0);
+  auto request_callback = [&](const std::string& method_, const std::string& req_type_, const std::string& resp_type_, const std::string& request_, std::string& response_) -> int
+  {
+    PrintRequest(method_, req_type_, resp_type_, request_);
+    response_ = "I answer on " + request_;
+    requests_executed++;
+    return 42;
+  };
+
+  // add callback for client request
+  server.AddMethodCallback("foo::method1", "foo::req_type1", "foo::resp_type1", request_callback);
+  server.AddMethodCallback("foo::method2", "foo::req_type2", "foo::resp_type2", request_callback);
+
+  // create service client
+  eCAL::CServiceClient client("service1");
+
+  // response callback function
+  int responses_executed(0);
+  auto response_callback = [&](const struct eCAL::SServiceInfo& service_info_, const std::string& response_)
+  {
+    PrintResponse(service_info_, response_);
+    responses_executed++;
+  };
+
+  // add callback for server response
+  client.AddResponseCallback(response_callback);
+
+  // let's match them -> wait 2*REGISTRATION_REFRESH_CYCLE (ecal_def.h)
+  eCAL::Process::SleepMS(2000);
+  
+  // call service
+  int requests_called(0);
+  bool success(true);
+  for (auto i = 0; i < calls; ++i)
+  {
+    // call a method1
+    success &= client.Call("foo::method1", "my request for method 1");
+    eCAL::Process::SleepMS(sleep);
+    requests_called++;
+
+    // call a method2
+    success &= client.Call("foo::method2", "my request for method 2");
+    eCAL::Process::SleepMS(sleep);
+    requests_called++;
+  }
+
+  EXPECT_EQ(true, success);
+  EXPECT_EQ(requests_called, requests_executed);
+  EXPECT_EQ(requests_called, responses_executed);
+
+  // finalize eCAL API
+  eCAL::Finalize();
+}
+
+#endif /* ClientServerBaseCallbackTest */
+
+#if ClientServerBaseBlockingTest
+
+TEST(IO, ClientServerBaseBlocking)
+{
+  const int calls(2);
+  const int sleep(0);
+
+  // initialize eCAL API
+  eCAL::Initialize(0, nullptr, "clientserver base blocking test");
+
+  // create service server
+  eCAL::CServiceServer server("service1");
+
+  // request callback function
+  int requests_executed(0);
+  auto request_callback = [&](const std::string& method_, const std::string& req_type_, const std::string& resp_type_, const std::string& request_, std::string& response_) -> int
+  {
+    PrintRequest(method_, req_type_, resp_type_, request_);
+    response_ = "I answer on " + request_;
+    requests_executed++;
+    return 24;
+  };
+
+  // add callback for client request
+  server.AddMethodCallback("foo::method1", "foo::req_type1", "foo::resp_type1", request_callback);
+  server.AddMethodCallback("foo::method2", "foo::req_type2", "foo::resp_type2", request_callback);
+
+  // create service client
+  eCAL::CServiceClient client("service1");
+
+  // let's match them -> wait 2*REGISTRATION_REFRESH_CYCLE (ecal_def.h)
+  eCAL::Process::SleepMS(2000);
+
+  // call service
+  int requests_called(0);
+  int responses_executed(0);
+  for (auto i = 0; i < calls; ++i)
+  {
+    eCAL::SServiceInfo service_info;
+    std::string        response;
+    // call a method1
+    if (client.Call("", "foo::method1", "my request for method 1", service_info, response))
+    {
+      PrintResponse(service_info, response);
+      responses_executed++;
+    }
+    eCAL::Process::SleepMS(sleep);
+    requests_called++;
+
+    // call a method2
+    if (client.Call("", "foo::method2", "my request for method 2", service_info, response))
+    {
+      PrintResponse(service_info, response);
+      responses_executed++;
+    }
+    eCAL::Process::SleepMS(sleep);
+    requests_called++;
+  }
+
+  EXPECT_EQ(requests_called, requests_executed);
+  EXPECT_EQ(requests_called, responses_executed);
+
+  // remove server request callback
+  server.RemMethodCallback("foo::method1");
+  server.RemMethodCallback("foo::method2");
+
+  // finalize eCAL API
+  eCAL::Finalize();
+}
+
+#endif /* ClientServerBaseBlockingTest */
+
+#if ClientServerProtoCallbackTest
+
+///////////////////////////////////////////////
+// Math Service
+///////////////////////////////////////////////
+class MathServiceImpl : public MathService
+{
+public:
+  virtual void Add(::google::protobuf::RpcController* /* controller_ */, const ::SFloatTuple* request_, ::SFloat* response_, ::google::protobuf::Closure* /* done_ */)
+  {
+    // print request and
+    std::cout << "Received request MathService / Add      : " << request_->inp1() << " and " << request_->inp2() << std::endl << std::endl;
+    // create response
+    response_->set_out(request_->inp1() + request_->inp2());
+  }
+
+  virtual void Multiply(::google::protobuf::RpcController* /* controller_ */, const ::SFloatTuple* request_, ::SFloat* response_, ::google::protobuf::Closure* /* done_ */)
+  {
+    // print request and
+    std::cout << "Received request MathService / Multiply : " << request_->inp1() << " and " << request_->inp2() << std::endl << std::endl;
+    // create response
+    response_->set_out(request_->inp1() * request_->inp2());
+  }
+
+  virtual void Divide(::google::protobuf::RpcController* /* controller_ */, const ::SFloatTuple* request_, ::SFloat* response_, ::google::protobuf::Closure* /* done_ */)
+  {
+    // print request and
+    std::cout << "Received request MathService / Divide   : " << request_->inp1() << " and " << request_->inp2() << std::endl << std::endl;
+    // create response
+    if (std::fabs(request_->inp2()) > DBL_EPSILON) response_->set_out(request_->inp1() / request_->inp2());
+    else                                           response_->set_out(0.0);
+  }
+};
+
+TEST(IO, ClientServerProtoCallback)
+{
+  // initialize eCAL API
+  eCAL::Initialize(0, nullptr, "clientserver proto callback test");
+
+  // create MathService server
+  std::shared_ptr<MathServiceImpl> math_service_impl = std::make_shared<MathServiceImpl>();
+  eCAL::protobuf::CServiceServer<MathService> math_server(math_service_impl);
+
+  // create MathService client
+  eCAL::protobuf::CServiceClient<MathService> math_client;
+
+  // response callback function
+  double math_response(0.0);
+  auto response_callback = [&](const struct eCAL::SServiceInfo& service_info_, const std::string& response_)
+  {
+    math_response = 0.0;
+    switch (service_info_.call_state)
+    {
+    // service successful executed
+    case call_state_executed:
+    {
+      SFloat response;
+      response.ParseFromString(response_);
+      std::cout << "Received response MathService / " << service_info_.method_name << " : " << response.out() << " from host " << service_info_.host_name << std::endl;
+      math_response = response.out();
+    }
+    break;
+    // service execution failed
+    case call_state_failed:
+      std::cout << "Received error MathService / " << service_info_.method_name << " : " << service_info_.error_msg << " from host " << service_info_.host_name << std::endl;
+      break;
+    default:
+      break;
+    }
+  };
+
+  // add callback for server response
+  math_client.AddResponseCallback(response_callback);
+
+  // let's match them -> wait 2*REGISTRATION_REFRESH_CYCLE (ecal_def.h)
+  eCAL::Process::SleepMS(2000);
+
+  // test math service
+  SFloatTuple math_request;
+  double inp1 = 20.0;
+  double inp2 = 22.0;
+  math_request.set_inp1(inp1);
+  math_request.set_inp2(inp2);
+  std::string math_request_s = math_request.SerializeAsString();
+
+  math_response = 0.0;
+  math_client.Call("Add", math_request_s);
+  std::cout << std::endl << "Add method called with : " << math_request.inp1() << " and " << math_request.inp1() << std::endl;
+  EXPECT_EQ(inp1 + inp2, static_cast<double>(math_response));
+
+  math_response = 0.0;
+  math_client.Call("Multiply", math_request_s);
+  std::cout << std::endl << "Multiply method called with : " << math_request.inp1() << " and " << math_request.inp1() << std::endl;
+  EXPECT_EQ(inp1*inp2, static_cast<double>(math_response));
+
+  math_response = 0.0;
+  math_client.Call("Divide", math_request_s);
+  std::cout << std::endl << "Divide method called with : " << math_request.inp1() << " and " << math_request.inp1() << std::endl;
+  EXPECT_EQ(inp1 / inp2, static_cast<double>(math_response));
+
+  // finalize eCAL API
+  eCAL::Finalize();
+}
+
+#endif /* ClientServerProtoCallbackTest */
+
+#if ClientServerProtoBlockingTest
+
+///////////////////////////////////////////////
+// Ping Service
+///////////////////////////////////////////////
+class PingServiceImpl : public PingService
+{
+public:
+  void Ping(::google::protobuf::RpcController* /* controller_ */, const ::PingRequest* request_, ::PingResponse* response_, ::google::protobuf::Closure* /* done_ */)
+  {
+    // print request and
+    std::cout << "Received request PingService / Ping     : " << request_->message() << std::endl << std::endl;
+    // create response
+    response_->set_answer("PONG");
+  }
+};
+
+TEST(IO, ClientServerProtoBlocking)
+{
+  // initialize eCAL API
+  eCAL::Initialize(0, nullptr, "clientserver proto blocking test");
+
+  // create PingService server
+  std::shared_ptr<PingServiceImpl> ping_service_impl = std::make_shared<PingServiceImpl>();
+  eCAL::protobuf::CServiceServer<PingService> ping_server(ping_service_impl);
+
+  // create PingService client
+  eCAL::protobuf::CServiceClient<PingService> ping_client;
+
+  // let's match them -> wait 2*REGISTRATION_REFRESH_CYCLE (ecal_def.h)
+  eCAL::Process::SleepMS(2000);
+
+  // test ping service
+  eCAL::SServiceInfo service_info;
+  PingRequest ping_request;
+  ping_request.set_message("PING");
+  std::string ping_request_s = ping_request.SerializeAsString();
+  std::string ping_response_s;
+  std::cout << std::endl << "Ping method called with message : " << ping_request.message() << std::endl;
+  ping_client.Call("", "Ping", ping_request_s, service_info, ping_response_s);
+  EXPECT_EQ(service_info.call_state, call_state_executed);
+  switch (service_info.call_state)
+  {
+  // service successful executed
+  case call_state_executed:
+  {
+    PingResponse response;
+    response.ParseFromString(ping_response_s);
+    std::cout << "Received response PingService / Ping : " << response.answer() << " from host " << service_info.host_name << std::endl;
+    EXPECT_STREQ(response.answer().c_str(), "PONG");
+  }
+  break;
+  // service execution failed
+  case call_state_failed:
+    std::cout << "Received error PingService / Ping : " << service_info.error_msg << " from host " << service_info.host_name << std::endl;
+    break;
+  default:
+    break;
+  }
+
+  // finalize eCAL API
+  eCAL::Finalize();
+}
+
+#endif /* ClientServerProtoBlockingTest */
+
+#if MultipleServerTest
+
+TEST(IO, MultipleServerTest)
+{
+  const int calls(2);
+  const int sleep(0);
+
+  // initialize eCAL API
+  eCAL::Initialize(0, nullptr, "multiple server test");
+
+  // create service server
+  eCAL::CServiceServer server1("service1");
+  eCAL::CServiceServer server2("service2");
+
+  // request callback function
+  int requests_executed(0);
+  auto request_callback = [&](const std::string& method_, const std::string& req_type_, const std::string& resp_type_, const std::string& request_, std::string& response_) -> int
+  {
+    PrintRequest(method_, req_type_, resp_type_, request_);
+    response_ = "I answer on " + request_;
+    requests_executed++;
+    return 42;
+  };
+
+  // add callback for client request
+  server1.AddMethodCallback("foo::method1", "foo::req_type1", "foo::resp_type1", request_callback);
+  server2.AddMethodCallback("foo::method2", "foo::req_type2", "foo::resp_type2", request_callback);
+
+  // create service clients
+  eCAL::CServiceClient client1("service1");
+  eCAL::CServiceClient client2("service2");
+
+  // response callback function
+  int responses_executed(0);
+  auto response_callback = [&](const struct eCAL::SServiceInfo& service_info_, const std::string& response_)
+  {
+    PrintResponse(service_info_, response_);
+    responses_executed++;
+  };
+
+  // add callback for server response
+  client1.AddResponseCallback(response_callback);
+  client2.AddResponseCallback(response_callback);
+
+  // let's match them -> wait 2*REGISTRATION_REFRESH_CYCLE (ecal_def.h)
+  eCAL::Process::SleepMS(2000);
+
+  // call service
+  int requests_called(0);
+  bool success(true);
+  for (auto i = 0; i < calls; ++i)
+  {
+    // call a method1
+    success &= client1.Call("foo::method1", "my request for method 1");
+    eCAL::Process::SleepMS(sleep);
+    requests_called++;
+
+    // call a method2
+    success &= client2.Call("foo::method2", "my request for method 2");
+    eCAL::Process::SleepMS(sleep);
+    requests_called++;
+  }
+
+  EXPECT_EQ(true, success);
+  EXPECT_EQ(requests_called, requests_executed);
+  EXPECT_EQ(requests_called, responses_executed);
+
+  // remove server request callback
+  server1.RemMethodCallback("foo::method1");
+  server2.RemMethodCallback("foo::method2");
+
+  // finalize eCAL API
+  eCAL::Finalize();
+}
+
+#endif /* MultipleServerTest */
+
+#if NestedRPCCallTest
+
+TEST(IO, NestedRPCCall)
+{
+  const int calls(2);
+  const int sleep(0);
+
+  // initialize eCAL API
+  eCAL::Initialize(0, nullptr, "nested rpc call test");
+
+  // create service server
+  eCAL::CServiceServer server("service1");
+
+  // request callback function
+  int requests_executed(0);
+  auto request_callback = [&](const std::string& method_, const std::string& req_type_, const std::string& resp_type_, const std::string& request_, std::string& response_) -> int
+  {
+    PrintRequest(method_, req_type_, resp_type_, request_);
+    response_ = "I answer on " + request_;
+    requests_executed++;
+    return 42;
+  };
+
+  // add callback for client request
+  server.AddMethodCallback("foo::method1", "foo::req_type1", "foo::resp_type1", request_callback);
+  server.AddMethodCallback("foo::method2", "foo::req_type2", "foo::resp_type2", request_callback);
+
+  // create service client
+  eCAL::CServiceClient client1("service1");
+  eCAL::CServiceClient client2("service1");
+
+  // response callback function
+  int requests_called(0);
+  int responses_executed(0);
+  bool success(true);
+  auto response_callback1 = [&](const struct eCAL::SServiceInfo& service_info_, const std::string& response_)
+  {
+    PrintResponse(service_info_, response_);
+    success &= client2.Call("foo::method2", "my request for method 2");
+    requests_called++;
+    responses_executed++;
+  };
+  auto response_callback2 = [&](const struct eCAL::SServiceInfo& service_info_, const std::string& response_)
+  {
+    PrintResponse(service_info_, response_);
+    responses_executed++;
+  };
+
+  // add callback for server response
+  client1.AddResponseCallback(response_callback1);
+  client2.AddResponseCallback(response_callback2);
+
+  // let's match them -> wait 2*REGISTRATION_REFRESH_CYCLE (ecal_def.h)
+  eCAL::Process::SleepMS(2000);
+
+  // call service
+  for (auto i = 0; i < calls; ++i)
+  {
+    // call a method1
+    success &= client1.Call("foo::method1", "my request for method 1");
+    eCAL::Process::SleepMS(sleep);
+    requests_called++;
+  }
+
+  EXPECT_EQ(true, success);
+  EXPECT_EQ(requests_called, requests_executed);
+  EXPECT_EQ(requests_called, responses_executed);
+
+  // remove server request callback
+  server.RemMethodCallback("foo::method1");
+  server.RemMethodCallback("foo::method2");
+
+  // finalize eCAL API
+  eCAL::Finalize();
+}
+
+#endif /* NestedRPCCallTest */
diff --git a/testing/ecal/clientserver_test/src/dummy.cpp b/testing/ecal/clientserver_test/src/dummy.cpp
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/testing/ecal/clientserver_test/src/protobuf/math.proto b/testing/ecal/clientserver_test/src/protobuf/math.proto
new file mode 100644
index 0000000000..e943799647
--- /dev/null
+++ b/testing/ecal/clientserver_test/src/protobuf/math.proto
@@ -0,0 +1,43 @@
+/* ========================= eCAL LICENSE =================================
+ *
+ * Copyright (C) 2016 - 2019 Continental Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * ========================= eCAL LICENSE =================================
+*/
+
+syntax = "proto3";
+
+option cc_generic_services = true;
+
+///////////////////////////////////////////////////////
+// Math Service
+///////////////////////////////////////////////////////
+message SFloatTuple
+{
+  double inp1 = 1;
+  double inp2 = 2;
+}
+
+message SFloat
+{
+  double out  = 1;
+}
+
+service MathService
+{
+  rpc Add      (SFloatTuple) returns (SFloat);
+  rpc Multiply (SFloatTuple) returns (SFloat);
+  rpc Divide   (SFloatTuple) returns (SFloat);
+}
diff --git a/testing/ecal/clientserver_test/src/protobuf/ping.proto b/testing/ecal/clientserver_test/src/protobuf/ping.proto
new file mode 100644
index 0000000000..d8d045a204
--- /dev/null
+++ b/testing/ecal/clientserver_test/src/protobuf/ping.proto
@@ -0,0 +1,40 @@
+/* ========================= eCAL LICENSE =================================
+ *
+ * Copyright (C) 2016 - 2019 Continental Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * ========================= eCAL LICENSE =================================
+*/
+
+syntax = "proto3";
+
+option cc_generic_services = true;
+
+///////////////////////////////////////////////////////
+// Ping Service
+///////////////////////////////////////////////////////
+message PingRequest
+{
+  string message = 1;
+}
+
+message PingResponse
+{
+  string answer  = 1;
+}
+
+service PingService
+{
+  rpc Ping (PingRequest) returns (PingResponse);
+}
diff --git a/testing/ecal/core_test/src/CMakeLists.txt b/testing/ecal/core_test/src/CMakeLists.txt
new file mode 100644
index 0000000000..9b5be6d1c4
--- /dev/null
+++ b/testing/ecal/core_test/src/CMakeLists.txt
@@ -0,0 +1,41 @@
+# ========================= eCAL LICENSE =================================
+#
+# Copyright (C) 2016 - 2019 Continental Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#      http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# ========================= eCAL LICENSE =================================
+
+project(test_core)
+
+find_package(Threads REQUIRED)
+find_package(GTest REQUIRED)
+
+set(core_test_src
+  core_test.cpp
+)
+
+ecal_add_gtest(${PROJECT_NAME}_cpp ${core_test_src})
+target_include_directories(${PROJECT_NAME}_cpp PRIVATE $<TARGET_PROPERTY:eCAL::core,INCLUDE_DIRECTORIES>)
+target_link_libraries(${PROJECT_NAME}_cpp
+  PRIVATE eCAL::core Threads::Threads)
+ecal_install_gtest(${PROJECT_NAME}_cpp)
+set_property(TARGET ${PROJECT_NAME}_cpp PROPERTY FOLDER testing/ecal/core)
+
+if(WIN32)
+  ecal_add_gtest(${PROJECT_NAME}_c   ${core_test_src})
+  target_include_directories(${PROJECT_NAME}_c   PRIVATE $<TARGET_PROPERTY:eCAL::core,INCLUDE_DIRECTORIES>)
+  target_link_libraries(${PROJECT_NAME}_c PRIVATE eCAL::core_c Threads::Threads)
+  ecal_install_gtest(${PROJECT_NAME}_c)
+  set_property(TARGET ${PROJECT_NAME}_c   PROPERTY FOLDER testing/ecal/core)
+endif()
diff --git a/testing/ecal/core_test/src/core_test.cpp b/testing/ecal/core_test/src/core_test.cpp
new file mode 100644
index 0000000000..43611daeec
--- /dev/null
+++ b/testing/ecal/core_test/src/core_test.cpp
@@ -0,0 +1,148 @@
+/* ========================= eCAL LICENSE =================================
+ *
+ * Copyright (C) 2016 - 2019 Continental Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * ========================= eCAL LICENSE =================================
+*/
+
+#include <ecal/ecal.h>
+#include <ecal/msg/string/publisher.h>
+#include <ecal/msg/string/subscriber.h>
+#include <algorithm>
+#include <atomic>
+#include <thread>
+#include <vector>
+#include <gtest/gtest.h>
+
+// subscriber callback function
+void OnReceive(const std::string& data_, long long clock_)
+{
+  std::cout << clock_ << " : " << data_ << std::endl;
+}
+
+// timer callback function
+std::atomic_size_t     g_callback_received{ 0 };
+std::vector<long long> g_timer_vec(100);
+void OnTimer()
+{
+  if(g_callback_received < g_timer_vec.size()) g_timer_vec[g_callback_received] = eCAL::Time::GetMicroSeconds();
+  g_callback_received += 1;
+}
+
+TEST(Core, MultipleInitializeFinalize)
+{
+  // try to initialize / finalize multiple times
+  for (auto i = 0; i < 4; ++i)
+  {
+    // initialize eCAL API
+    EXPECT_EQ(0, eCAL::Initialize(0, nullptr, "multiple initialize/finalize"));
+
+    // finalize eCAL API
+    EXPECT_EQ(0, eCAL::Finalize());
+  }
+}
+
+TEST(Core, LeakedPubSub)
+{
+  // initialize eCAL API
+  EXPECT_EQ(0, eCAL::Initialize(0, nullptr, "leaked pub/sub"));
+
+  // enable loop back communication in the same thread
+  eCAL::Util::EnableLoopback(true);
+
+  // create subscriber and register a callback
+  eCAL::string::CSubscriber<std::string> sub("foo");
+  sub.AddReceiveCallback(std::bind(OnReceive, std::placeholders::_2, std::placeholders::_4));
+
+  // start publishing thread
+  eCAL::string::CPublisher<std::string> pub("foo");
+  std::atomic<bool> pub_stop(false);
+  std::thread pub_t([&]() {
+    while (!pub_stop)
+    {
+      pub.Send("Hello World");
+      std::this_thread::sleep_for(std::chrono::milliseconds(100));
+    }
+  });
+
+  // let them work together
+  std::this_thread::sleep_for(std::chrono::seconds(2));
+
+  // finalize eCAL API
+  // without destroying any pub / sub
+  EXPECT_EQ(0, eCAL::Finalize());
+
+  // stop publishing thread
+  pub_stop = true; pub_t.join();
+}
+
+TEST(Core, TimerCallback)
+{ 
+  // initialize eCAL API
+  EXPECT_EQ(0, eCAL::Initialize(0, nullptr, "initialize/finalize"));
+
+  // Is eCAL API initialized ?
+  EXPECT_EQ(1, eCAL::IsInitialized());
+
+  std::this_thread::sleep_for(std::chrono::seconds(1));
+
+  eCAL::CTimer timer;
+  const int tloop(10);
+  timer.Start(tloop, &OnTimer);
+
+  std::this_thread::sleep_for(std::chrono::seconds(1));
+
+  // Expect that the timer callback was called a hundred times +/-1
+  EXPECT_TRUE((g_callback_received >= 99) && (g_callback_received <= 101));
+  std::cout << std::endl;
+  std::cout << "Timer called " << g_callback_received << " times." << std::endl;
+  std::cout << std::endl;
+
+  // Calculate loop jitter
+  std::vector<long long> timer_vec_diff;
+  long long last_time(0);
+  for (auto time : g_timer_vec)
+  {
+    if (last_time) timer_vec_diff.push_back(time - last_time);
+    last_time = time;
+  }
+
+  // Print out loop times
+  //for (auto time : timer_vec_diff) std::cout << static_cast<double>(time) / 1000.0 << " ms" << std::endl;
+
+  // Print out min / max loop times
+  auto tmin = *min_element(std::begin(timer_vec_diff), std::end(timer_vec_diff));
+  auto tmax = *max_element(std::begin(timer_vec_diff), std::end(timer_vec_diff));
+  std::cout << "Min loop time [ms]: " << tmin / 1000.0 << std::endl;
+  std::cout << "Max loop time [ms]: " << tmax / 1000.0 << std::endl;
+  std::cout << std::endl;
+
+  // check precision loop time +/- 2 ms
+  const int max_jitter_ms(2);
+  EXPECT_TRUE(tmin > (tloop - max_jitter_ms) * 1000);
+  EXPECT_TRUE(tmax < (tloop + max_jitter_ms) * 1000);
+
+  // this is an issue !
+  // we need to stop timer before we finalize eCAL API
+  // otherwise it will hang forever
+  timer.Stop();
+
+  // finalize second time eCAL API we still expect 0 because 
+  // but now reference counter is 0 and destruction should be succeeded
+  EXPECT_EQ(0, eCAL::Finalize());
+
+  // finalize eCAL API again we expect 1 because yet finalized
+  EXPECT_EQ(1, eCAL::Finalize());
+}
diff --git a/testing/ecal/event_test/src/CMakeLists.txt b/testing/ecal/event_test/src/CMakeLists.txt
new file mode 100644
index 0000000000..9927afc985
--- /dev/null
+++ b/testing/ecal/event_test/src/CMakeLists.txt
@@ -0,0 +1,37 @@
+# ========================= eCAL LICENSE =================================
+#
+# Copyright (C) 2016 - 2019 Continental Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#      http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# ========================= eCAL LICENSE =================================
+
+project(test_event)
+
+find_package(Threads REQUIRED)
+find_package(GTest REQUIRED)
+
+set(event_test_src
+  event_test.cpp
+)
+
+ecal_add_gtest(${PROJECT_NAME} ${event_test_src})
+
+target_link_libraries(${PROJECT_NAME}
+  PRIVATE
+    eCAL::core
+    Threads::Threads)
+
+ecal_install_gtest(${PROJECT_NAME})
+
+set_property(TARGET ${PROJECT_NAME} PROPERTY FOLDER testing/ecal/io)
diff --git a/testing/ecal/event_test/src/event_test.cpp b/testing/ecal/event_test/src/event_test.cpp
new file mode 100644
index 0000000000..6e02acc94f
--- /dev/null
+++ b/testing/ecal/event_test/src/event_test.cpp
@@ -0,0 +1,41 @@
+/* ========================= eCAL LICENSE =================================
+ *
+ * Copyright (C) 2016 - 2019 Continental Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * ========================= eCAL LICENSE =================================
+*/
+
+#include <ecal/ecal.h>
+
+#include <gtest/gtest.h>
+
+TEST(Event, EventSetGet)
+{ 
+  // global parameter
+  const std::string event_name = "my_event";
+
+  // create named event
+  eCAL::EventHandleT event_handle;
+  EXPECT_EQ(true, eCAL::gOpenEvent(&event_handle, event_name));
+
+  // get none set event
+  EXPECT_EQ(false, gWaitForEvent(event_handle, 10));
+
+  // set event
+  EXPECT_EQ(true, gSetEvent(event_handle));
+
+  // get set event
+  EXPECT_EQ(true, gWaitForEvent(event_handle, 100));
+}
diff --git a/testing/ecal/expmap_test/src/CMakeLists.txt b/testing/ecal/expmap_test/src/CMakeLists.txt
new file mode 100644
index 0000000000..36ec9c173e
--- /dev/null
+++ b/testing/ecal/expmap_test/src/CMakeLists.txt
@@ -0,0 +1,40 @@
+# ========================= eCAL LICENSE =================================
+#
+# Copyright (C) 2016 - 2019 Continental Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#      http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# ========================= eCAL LICENSE =================================
+
+project(test_expmap)
+
+find_package(Threads REQUIRED)
+find_package(GTest REQUIRED)
+
+set(expmap_test_src
+  expmap_test.cpp
+)
+
+ecal_add_gtest(${PROJECT_NAME} ${expmap_test_src})
+
+target_include_directories(${PROJECT_NAME} PRIVATE $<TARGET_PROPERTY:eCAL::core,INCLUDE_DIRECTORIES>)
+
+target_link_libraries(${PROJECT_NAME}
+  PRIVATE
+    eCAL::core
+    Threads::Threads
+)
+
+ecal_install_gtest(${PROJECT_NAME})
+
+set_property(TARGET ${PROJECT_NAME} PROPERTY FOLDER testing/ecal/core)
diff --git a/testing/ecal/expmap_test/src/expmap_test.cpp b/testing/ecal/expmap_test/src/expmap_test.cpp
new file mode 100644
index 0000000000..1d0451574e
--- /dev/null
+++ b/testing/ecal/expmap_test/src/expmap_test.cpp
@@ -0,0 +1,161 @@
+/* ========================= eCAL LICENSE =================================
+ *
+ * Copyright (C) 2016 - 2019 Continental Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * ========================= eCAL LICENSE =================================
+*/
+
+#include <ecal/ecal.h>
+#include "ecal_expmap.h"
+
+#include <string>
+#include <chrono>
+#include <thread>
+
+#include <gtest/gtest.h>
+
+#include <iostream>
+
+TEST(ExpMap, ExpMapSetGet)
+{ 
+  // create the map with 2500 ms expiration
+  eCAL::Util::CExpMap<std::string, int> expmap(std::chrono::milliseconds(200));
+
+  // set "A"
+  expmap["A"] = 1;
+
+  // get "A"
+  EXPECT_EQ(1, expmap["A"]);
+
+  // check size
+  //std::map<std::string, int> content = expmap.clone();
+  EXPECT_EQ(1, expmap.size());
+
+  // sleep
+  std::this_thread::sleep_for(std::chrono::milliseconds(150));
+
+  // access and reset timer
+  EXPECT_EQ(1, expmap["A"]);
+
+  // check size
+  //content = expmap.clone();
+  expmap.remove_deprecated();
+  EXPECT_EQ(1, expmap.size());
+
+  // sleep
+  std::this_thread::sleep_for(std::chrono::milliseconds(150));
+
+  // check size
+  //content = expmap.clone();
+  expmap.remove_deprecated();
+  EXPECT_EQ(1, expmap.size());
+
+  // sleep
+  std::this_thread::sleep_for(std::chrono::milliseconds(150));
+
+  // check size
+  //content = expmap.clone();
+  expmap.remove_deprecated();
+  EXPECT_EQ(0, expmap.size());
+
+  expmap["A"] = 1;
+  std::this_thread::sleep_for(std::chrono::milliseconds(150));
+  expmap["B"] = 2;
+  expmap["C"] = 3;
+  expmap.remove_deprecated();
+  EXPECT_EQ(3, expmap.size());
+  std::this_thread::sleep_for(std::chrono::milliseconds(150));
+  expmap["B"] = 4;
+  expmap.remove_deprecated();
+  EXPECT_EQ(2, expmap.size());
+  std::this_thread::sleep_for(std::chrono::milliseconds(150));
+  expmap.remove_deprecated();
+  EXPECT_EQ(1, expmap.size());
+  // sleep
+  std::this_thread::sleep_for(std::chrono::milliseconds(150));
+}
+
+TEST(ExpMap, ExpMapInsert)
+{
+  eCAL::Util::CExpMap<std::string, int> expmap(std::chrono::milliseconds(200));
+  auto ret = expmap.insert(std::make_pair("A", 1));
+
+  auto key = (*ret.first).first;
+  auto value = (*ret.first).second;
+  EXPECT_EQ(std::string("A"), key);
+  EXPECT_EQ(1, value);
+
+  int i = expmap["A"];
+
+  EXPECT_EQ(i, 1);
+
+  std::this_thread::sleep_for(std::chrono::milliseconds(300));
+  expmap.remove_deprecated();
+  EXPECT_EQ(0, expmap.size());
+}
+
+// This tests uses find to find an element
+TEST(ExpMap, ExpMapFind)
+{
+  eCAL::Util::CExpMap<std::string, int> expmap(std::chrono::milliseconds(200));
+
+  auto it = expmap.find("A");
+  EXPECT_EQ(expmap.end(), it);
+
+
+  expmap["A"] = 1;
+  it = expmap.find("A");
+  int i = (*it).second;
+  EXPECT_EQ(i, 1);
+
+  std::this_thread::sleep_for(std::chrono::milliseconds(300));
+  expmap.remove_deprecated();
+  EXPECT_EQ(0, expmap.size());
+}
+
+TEST(ExpMap, ExpMapIterate)
+{
+  // create the map with 2500 ms expiration
+  eCAL::Util::CExpMap<std::string, int> expmap(std::chrono::milliseconds(200));
+  expmap["A"] = 1;
+
+  std::string key;
+  int value;
+
+  for (auto&& entry : expmap)
+  {
+    key   = entry.first;
+    value = entry.second;
+  }
+
+  EXPECT_EQ(std::string("A"), key);
+  EXPECT_EQ(1, value);
+}
+
+TEST(ExpMap, ExpMapEmpty)
+{
+  eCAL::Util::CExpMap<std::string, int> expmap(std::chrono::milliseconds(200));
+  EXPECT_EQ(true, expmap.empty());
+  expmap["A"] = 1;
+  EXPECT_EQ(false, expmap.empty());
+}
+
+TEST(ExpMap, ExpMapSize)
+{
+  eCAL::Util::CExpMap<std::string, int> expmap(std::chrono::milliseconds(200));
+  EXPECT_EQ(0, expmap.size());
+  expmap["A"] = 1;
+  EXPECT_EQ(1, expmap.size());
+}
\ No newline at end of file
diff --git a/testing/ecal/io_memfile_test/src/CMakeLists.txt b/testing/ecal/io_memfile_test/src/CMakeLists.txt
new file mode 100644
index 0000000000..4742889982
--- /dev/null
+++ b/testing/ecal/io_memfile_test/src/CMakeLists.txt
@@ -0,0 +1,50 @@
+# ========================= eCAL LICENSE =================================
+#
+# Copyright (C) 2016 - 2019 Continental Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#      http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# ========================= eCAL LICENSE =================================
+
+project(test_memfile)
+
+find_package(GTest REQUIRED)
+
+set(memfile_test_src
+    memfile_test.cpp
+    ../../../../ecal/core/src/io/ecal_memfile.cpp
+)
+
+if(UNIX)
+set(memfile_test_linux_src
+    ../../../../ecal/core/src/io/linux/ecal_memfile_linux.cpp
+)
+endif()
+
+if(WIN32)
+set(memfile_test_linux_src
+    ../../../../ecal/core/src/io/win32/ecal_memfile_win32.cpp
+)
+endif()
+
+ecal_add_gtest(${PROJECT_NAME} ${memfile_test_src} ${memfile_test_linux_src} ${memfile_test_win32_src})
+
+target_include_directories(${PROJECT_NAME} PRIVATE $<TARGET_PROPERTY:eCAL::core,INCLUDE_DIRECTORIES>)
+
+if(UNIX)
+  target_link_libraries(${PROJECT_NAME} PRIVATE rt dl pthread)
+endif()
+
+ecal_install_gtest(${PROJECT_NAME})
+
+set_property(TARGET ${PROJECT_NAME} PROPERTY FOLDER testing/ecal/io)
diff --git a/testing/ecal/io_memfile_test/src/memfile_test.cpp b/testing/ecal/io_memfile_test/src/memfile_test.cpp
new file mode 100644
index 0000000000..745c7b927f
--- /dev/null
+++ b/testing/ecal/io_memfile_test/src/memfile_test.cpp
@@ -0,0 +1,157 @@
+/* ========================= eCAL LICENSE =================================
+ *
+ * Copyright (C) 2016 - 2019 Continental Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * ========================= eCAL LICENSE =================================
+*/
+
+#include <ecal/ecal.h>
+#include "io/ecal_memfile.h"
+
+#include <atomic>
+#include <chrono>
+#include <memory>
+
+#include <gtest/gtest.h>
+
+namespace eCAL
+{
+  SMemFileMap* g_memfile_map()
+  {
+    static std::shared_ptr<SMemFileMap> m(new SMemFileMap);
+    return(m.get());
+  }
+}
+
+TEST(IO, MemfileReadWrite)
+{
+  eCAL::CMemoryFile mem_file;
+
+  // global parameter
+  const std::string memfile_name = "my_memory_file";
+
+  // default send string
+  std::string send_s = "Hello World ";
+  for (int i = 0; i < 10; i++)
+  {
+    send_s += send_s;
+  }
+  size_t slen = send_s.size();
+
+  // check creation state
+  EXPECT_EQ(false, mem_file.IsCreated());
+
+  // create memory file
+  EXPECT_EQ(true, mem_file.Create(memfile_name.c_str(), true, slen));
+
+  // check creation state
+  EXPECT_EQ(true, mem_file.IsCreated());
+
+  // check open state
+  EXPECT_EQ(false, mem_file.IsOpened());
+
+  // write content to memory file before open
+  EXPECT_EQ(0, mem_file.Write((void*)send_s.c_str(), slen, 0));
+
+  // open memory file with timeout 100 ms
+  EXPECT_EQ(true, mem_file.Open(100));
+
+  // check open state
+  EXPECT_EQ(true, mem_file.IsOpened());
+
+  // write content to memory file
+  EXPECT_EQ(slen, mem_file.Write((void*)send_s.c_str(), slen, 0));
+
+  // write double sized content to memory file
+  std::string double_send_s = send_s + send_s;
+  EXPECT_EQ(0, mem_file.Write((void*)double_send_s.c_str(), double_send_s.size(), 0));
+
+  // close memory file
+  EXPECT_EQ(true, mem_file.Close());
+
+  // check open state
+  EXPECT_EQ(false, mem_file.IsOpened());
+
+  // write content to closed memory file
+  EXPECT_EQ(0, mem_file.Write((void*)send_s.c_str(), slen, 0));
+
+  // open memory file with timeout 100 ms
+  EXPECT_EQ(true, mem_file.Open(100));
+
+  // read content from memory file
+  std::vector<char> read_buf;
+  read_buf.resize(slen);
+  EXPECT_EQ(slen, mem_file.Read((void*)read_buf.data(), read_buf.size(), 0));
+
+  // close memory file
+  EXPECT_EQ(true, mem_file.Close());
+
+  // destroy memory file
+  EXPECT_EQ(true, mem_file.Destroy(true));
+}
+
+TEST(IO, MemfilePerf)
+{
+  eCAL::CMemoryFile mem_file;
+
+  // global parameter
+  const std::string memfile_name = "my_memory_file";
+
+  // default send string
+  std::string send_s = "Hello World ";
+  for (int i = 0; i < 10; i++)
+  {
+    send_s += send_s;
+  }
+  size_t slen = send_s.size();
+
+  // create memory file
+  EXPECT_EQ(true, mem_file.Create(memfile_name.c_str(), true, slen));
+
+  // open memory file with timeout 100 ms
+  EXPECT_EQ(true, mem_file.Open(100));
+
+  // start time
+  auto start = std::chrono::high_resolution_clock::now();
+
+  // do work
+  std::vector<char> read_buf;
+  read_buf.resize(slen);
+  const size_t write_loops(1000000);
+  for (size_t loops = 0; loops < write_loops; ++loops)
+  {
+    // write content to memory file
+    EXPECT_EQ(slen, mem_file.Write((void*)send_s.c_str(), slen, 0));
+
+    // read content from memory file
+    EXPECT_EQ(slen, mem_file.Read((void*)read_buf.data(), read_buf.size(), 0));
+  }
+
+  // end time
+  auto finish = std::chrono::high_resolution_clock::now();
+  std::chrono::duration<double> elapsed = finish - start;
+  std::cout << "Elapsed time : " << elapsed.count() << " s" << std::endl;
+
+  size_t sum_snd_bytes = send_s.size() * write_loops;
+  std::cout << "Sent         : " << sum_snd_bytes << " bytes";
+  std::cout << " (" << sum_snd_bytes / (1024 * 1024) << " MB)" << std::endl;
+  std::cout << "Throughput   : " << int((sum_snd_bytes / (1024.0 * 1024.0)) / elapsed.count()) << " MB/s " << std::endl;
+
+  // close memory file
+  EXPECT_EQ(true, mem_file.Close());
+
+  // destroy memory file
+  EXPECT_EQ(true, mem_file.Destroy(true));
+}
diff --git a/testing/ecal/pubsub_inproc_test/src/CMakeLists.txt b/testing/ecal/pubsub_inproc_test/src/CMakeLists.txt
new file mode 100644
index 0000000000..9ff34510ac
--- /dev/null
+++ b/testing/ecal/pubsub_inproc_test/src/CMakeLists.txt
@@ -0,0 +1,44 @@
+# ========================= eCAL LICENSE =================================
+#
+# Copyright (C) 2016 - 2019 Continental Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#      http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# ========================= eCAL LICENSE =================================
+
+project(test_pubsub_inproc)
+
+find_package(Threads REQUIRED)
+find_package(GTest REQUIRED)
+
+set(pubsub_inproc_test_src
+  pubsub_inproc_test.cpp
+)
+
+ecal_add_gtest(${PROJECT_NAME}_cpp ${pubsub_inproc_test_src})
+target_link_libraries(${PROJECT_NAME}_cpp
+  PRIVATE
+   eCAL::core
+   Threads::Threads)
+ecal_install_gtest(${PROJECT_NAME}_cpp)
+set_property(TARGET ${PROJECT_NAME}_cpp PROPERTY FOLDER testing/ecal/pubsub)
+
+if(WIN32)
+  ecal_add_gtest(${PROJECT_NAME}_c   ${pubsub_inproc_test_src})
+  target_link_libraries(${PROJECT_NAME}_c
+    PRIVATE
+      eCAL::core_c
+      Threads::Threads)
+  ecal_install_gtest(${PROJECT_NAME}_c)
+  set_property(TARGET ${PROJECT_NAME}_c PROPERTY FOLDER testing/ecal/pubsub)
+endif()
diff --git a/testing/ecal/pubsub_inproc_test/src/pubsub_inproc_test.cpp b/testing/ecal/pubsub_inproc_test/src/pubsub_inproc_test.cpp
new file mode 100644
index 0000000000..0f20da17fe
--- /dev/null
+++ b/testing/ecal/pubsub_inproc_test/src/pubsub_inproc_test.cpp
@@ -0,0 +1,101 @@
+/* ========================= eCAL LICENSE =================================
+ *
+ * Copyright (C) 2016 - 2019 Continental Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * ========================= eCAL LICENSE =================================
+*/
+
+#include <ecal/ecal.h>
+#include <ecal/msg/string/publisher.h>
+#include <ecal/msg/string/subscriber.h>
+
+#include <sstream>
+#include <gtest/gtest.h>
+
+#define CMN_REGISTRATION_REFRESH 1000
+
+// callback function 1
+size_t sub_clock1(0);
+void OnReceive1(const std::string& msg_)
+{
+  std::cout << "PubClock    : " << msg_       << std::endl;
+  std::cout << "SubClock  1 : " << sub_clock1 << std::endl;
+  sub_clock1++;
+}
+
+// callback function 2
+size_t sub_clock2(0);
+void OnReceive2()
+{
+  std::cout << "SubClock  2 : " << sub_clock2 << std::endl;
+  sub_clock2++;
+}
+
+// callback function 3
+size_t sub_clock3(0);
+void OnReceive3()
+{
+  std::cout << "SubClock  3 : " << sub_clock3 << std::endl;
+  std::cout                                   << std::endl;
+  sub_clock3++;
+}
+
+TEST(INPROC, CLOCKS)
+{ 
+  // initialize eCAL API
+  EXPECT_EQ(0, eCAL::Initialize(0, nullptr, "inproc_clock_test"));
+
+  // publish / subscribe match in the same process
+  eCAL::Util::EnableLoopback(true);
+
+  // create simple string publisher
+  // and force him to send on all layers in parallel
+  eCAL::string::CPublisher<std::string> pub("CLOCK");
+  pub.SetLayerMode(eCAL::TLayer::tlayer_all, eCAL::TLayer::smode_on);
+
+  // create subscriber number 1
+  eCAL::string::CSubscriber<std::string> sub1("CLOCK");
+  EXPECT_EQ(true, sub1.AddReceiveCallback(std::bind(OnReceive1, std::placeholders::_2)));
+
+  // create subscriber number 2
+  eCAL::string::CSubscriber<std::string> sub2("CLOCK");
+  EXPECT_EQ(true, sub2.AddReceiveCallback(std::bind(OnReceive2)));
+
+  // create subscriber number 3
+  eCAL::string::CSubscriber<std::string> sub3("CLOCK");
+  EXPECT_EQ(true, sub3.AddReceiveCallback(std::bind(OnReceive3)));
+
+  // let's match them
+  eCAL::Process::SleepMS(2 * CMN_REGISTRATION_REFRESH);
+
+  std::cout << std::endl;
+  for (size_t count = 0; count <= 10; ++count)
+  {
+    // check all clocks
+    // they should always count with
+    // the publishing one
+    EXPECT_EQ(count, sub_clock1);
+    EXPECT_EQ(count, sub_clock2);
+    EXPECT_EQ(count, sub_clock3);
+
+    // create a clock string
+    std::stringstream ss; ss << count;
+    // and fire on the three layers
+    pub.Send(ss.str());
+  }
+
+  // finalize eCAL API
+  EXPECT_EQ(0, eCAL::Finalize());
+}
diff --git a/samples/cpp/person/person_snd_unicast/src/CMakeLists.txt b/testing/ecal/pubsub_proto_test/src/CMakeLists.txt
similarity index 64%
rename from samples/cpp/person/person_snd_unicast/src/CMakeLists.txt
rename to testing/ecal/pubsub_proto_test/src/CMakeLists.txt
index a03fc3a6ea..172163d125 100644
--- a/samples/cpp/person/person_snd_unicast/src/CMakeLists.txt
+++ b/testing/ecal/pubsub_proto_test/src/CMakeLists.txt
@@ -16,28 +16,34 @@
 #
 # ========================= eCAL LICENSE =================================
 
-project(person_snd_unicast)
+project(test_pubsub_proto)
 
-find_package(eCAL REQUIRED)
+find_package(Threads REQUIRED)
+find_package(GTest REQUIRED)
 find_package(Protobuf REQUIRED)
 
-set(person_snd_unicast_src
-  person_snd_unicast.cpp
+create_targets_protobuf()
+
+set(${PROJECT_NAME}_src
+  proto_publisher_test.cpp
+  proto_subscriber_test.cpp
 )
 
-set(person_snd_unicast_proto
+set(pubsub_proto_test_proto
   ${CMAKE_CURRENT_SOURCE_DIR}/protobuf/animal.proto
   ${CMAKE_CURRENT_SOURCE_DIR}/protobuf/house.proto
-  ${CMAKE_CURRENT_SOURCE_DIR}/protobuf/person.proto    
+  ${CMAKE_CURRENT_SOURCE_DIR}/protobuf/person.proto
 )
-ecal_add_sample(${PROJECT_NAME} ${person_snd_unicast_src})
-PROTOBUF_TARGET_CPP(${PROJECT_NAME} ${CMAKE_CURRENT_SOURCE_DIR}/protobuf ${person_snd_unicast_proto})
-target_include_directories(${PROJECT_NAME} PRIVATE .)
+
+ecal_add_gtest(${PROJECT_NAME} ${${PROJECT_NAME}_src})
+PROTOBUF_TARGET_CPP(${PROJECT_NAME} ${CMAKE_CURRENT_SOURCE_DIR}/protobuf ${pubsub_proto_test_proto})
 
 target_link_libraries(${PROJECT_NAME}
-  eCAL::core
-  protobuf::libprotobuf)
+  PRIVATE
+    eCAL::core
+    protobuf::libprotobuf
+    Threads::Threads)
 
-ecal_install_sample(${PROJECT_NAME})
+ecal_install_gtest(${PROJECT_NAME})
 
-set_property(TARGET ${PROJECT_NAME} PROPERTY FOLDER samples/cpp/person)
+set_property(TARGET ${PROJECT_NAME} PROPERTY FOLDER testing/ecal/pubsub)
diff --git a/testing/ecal/pubsub_proto_test/src/proto_publisher_test.cpp b/testing/ecal/pubsub_proto_test/src/proto_publisher_test.cpp
new file mode 100644
index 0000000000..0b312b2768
--- /dev/null
+++ b/testing/ecal/pubsub_proto_test/src/proto_publisher_test.cpp
@@ -0,0 +1,76 @@
+/* ========================= eCAL LICENSE =================================
+ *
+ * Copyright (C) 2016 - 2019 Continental Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * ========================= eCAL LICENSE =================================
+*/
+
+// std headers
+#include <chrono>
+#include <thread>
+// used libraries
+#include <gtest/gtest.h>
+// own project
+#include <ecal/ecal.h>
+#include <ecal/msg/protobuf/publisher.h>
+
+#include <person.pb.h>
+
+
+// subscriber callback function
+
+
+class ProtoPublisherTest : public ::testing::Test {
+public:
+
+  ProtoPublisherTest() {
+    eCAL::Initialize();
+  }
+
+  virtual ~ProtoPublisherTest() {
+    eCAL::Finalize();
+  }
+
+};
+
+TEST_F(ProtoPublisherTest, MoveAssignment)
+{
+  eCAL::protobuf::CPublisher<pb::People::Person> person_pub("ProtoPublisherTest");
+
+  ASSERT_TRUE(person_pub.IsCreated());
+
+  eCAL::protobuf::CPublisher<pb::People::Person>person_moved;
+
+  ASSERT_FALSE(person_moved.IsCreated());
+
+  person_moved = std::move(person_pub);
+
+  // New Subscriber must be initialized
+  ASSERT_TRUE(person_moved.IsCreated());
+  // Old subscriber is not initialized
+  ASSERT_FALSE(person_pub.IsCreated());
+}
+
+TEST_F(ProtoPublisherTest, MoveConstruction)
+{
+  eCAL::protobuf::CPublisher<pb::People::Person> person_pub("ProtoPublisherTest");
+
+  ASSERT_TRUE(person_pub.IsCreated());
+
+  eCAL::protobuf::CPublisher<pb::People::Person>person_moved{ std::move(person_pub) };
+
+  ASSERT_TRUE(person_moved.IsCreated());
+  ASSERT_FALSE(person_pub.IsCreated());
+}
diff --git a/testing/ecal/pubsub_proto_test/src/proto_subscriber_test.cpp b/testing/ecal/pubsub_proto_test/src/proto_subscriber_test.cpp
new file mode 100644
index 0000000000..20732f51c6
--- /dev/null
+++ b/testing/ecal/pubsub_proto_test/src/proto_subscriber_test.cpp
@@ -0,0 +1,145 @@
+/* ========================= eCAL LICENSE =================================
+ *
+ * Copyright (C) 2016 - 2019 Continental Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * ========================= eCAL LICENSE =================================
+*/
+
+// std headers
+#include <atomic>
+#include <chrono>
+#include <thread>
+// used libraries
+#include <gtest/gtest.h>
+// own project
+#include <ecal/ecal.h>
+#include <ecal/msg/protobuf/publisher.h>
+#include <ecal/msg/protobuf/subscriber.h>
+
+#include <person.pb.h>
+
+// subscriber callback function
+
+#define REGISTRATION_REFRESH_CYCLE 1000
+
+class ProtoSubscriberTest : public ::testing::Test {
+public:
+  ProtoSubscriberTest() 
+  : received_callbacks(0)
+  {
+    // Initialize eCAL
+    eCAL::Initialize();
+    // publish / subscribe match in the same process
+    eCAL::Util::EnableLoopback(true);
+  }
+
+  virtual ~ProtoSubscriberTest() {
+    // Finalize eCAL
+    eCAL::Finalize();
+  }
+
+  void SendPerson(eCAL::protobuf::CPublisher<pb::People::Person>& pub)
+  {
+    pb::People::Person p;
+    p.set_id(1);
+    p.set_name("Max");
+    pub.Send(p);
+  }
+  
+  void OnPerson(const char*, const pb::People::Person&, long long, long long)
+  {
+    received_callbacks++;
+  }
+
+  std::atomic<int> received_callbacks;
+};
+
+TEST_F(ProtoSubscriberTest, SendReceive)
+{
+  // Assert that the Subscriber can be move constructed.
+  eCAL::protobuf::CSubscriber<pb::People::Person> person_rec("ProtoSubscriberTest");
+  auto person_callback = std::bind(&ProtoSubscriberTest::OnPerson, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4);
+  person_rec.AddReceiveCallback(person_callback);
+  ASSERT_TRUE(person_rec.IsCreated());
+
+  eCAL::protobuf::CPublisher<pb::People::Person> person_pub("ProtoSubscriberTest");
+
+  std::this_thread::sleep_for(std::chrono::milliseconds(2000));
+
+  SendPerson(person_pub);
+  std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+  // assert that the OnPerson callback has been called once.
+  ASSERT_EQ(1, received_callbacks);
+
+}
+
+
+TEST_F(ProtoSubscriberTest, MoveAssignment)
+{
+  eCAL::protobuf::CSubscriber<pb::People::Person> person_rec("ProtoSubscriberTest");
+  auto person_callback = std::bind(&ProtoSubscriberTest::OnPerson, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4);
+  person_rec.AddReceiveCallback(person_callback);
+
+  ASSERT_TRUE(person_rec.IsCreated());
+
+  eCAL::protobuf::CSubscriber<pb::People::Person>person_moved;
+
+  ASSERT_FALSE(person_moved.IsCreated());
+
+  person_moved = std::move(person_rec);
+
+  // New Subscriber must be initialized
+  ASSERT_TRUE(person_moved.IsCreated());
+  // Old subscriber is not initialized
+  ASSERT_FALSE(person_rec.IsCreated());
+  ASSERT_EQ("ProtoSubscriberTest", person_moved.GetTopicName());
+
+  // Assert that the move constructed object can receive something
+  eCAL::protobuf::CPublisher<pb::People::Person> person_pub("ProtoSubscriberTest");
+
+  std::this_thread::sleep_for(std::chrono::milliseconds(2000));
+
+  SendPerson(person_pub);
+  std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+  // assert that the OnPerson callback has been called once.
+  ASSERT_EQ(1, received_callbacks);
+}
+
+TEST_F(ProtoSubscriberTest, MoveConstruction)
+{
+  // Assert that the Subscriber can be move constructed.
+  eCAL::protobuf::CSubscriber<pb::People::Person> person_rec("ProtoSubscriberTest");
+  auto person_callback = std::bind(&ProtoSubscriberTest::OnPerson, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4);
+  person_rec.AddReceiveCallback(person_callback);
+
+  ASSERT_TRUE(person_rec.IsCreated());
+
+  eCAL::protobuf::CSubscriber<pb::People::Person>person_moved{ std::move(person_rec) };
+
+  ASSERT_TRUE(person_moved.IsCreated());
+  ASSERT_FALSE(person_rec.IsCreated());
+  ASSERT_EQ("ProtoSubscriberTest", person_moved.GetTopicName());
+
+  // Assert that the move constructed object can receive something
+  eCAL::protobuf::CPublisher<pb::People::Person> person_pub("ProtoSubscriberTest");
+
+  std::this_thread::sleep_for(std::chrono::milliseconds(2000));
+
+  SendPerson(person_pub);
+  std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+  // assert that the OnPerson callback has been called once.
+  ASSERT_EQ(1, received_callbacks);
+
+}
diff --git a/samples/cpp/person/person_snd_unicast/src/protobuf/animal.proto b/testing/ecal/pubsub_proto_test/src/protobuf/animal.proto
similarity index 100%
rename from samples/cpp/person/person_snd_unicast/src/protobuf/animal.proto
rename to testing/ecal/pubsub_proto_test/src/protobuf/animal.proto
diff --git a/samples/cpp/person/person_snd_unicast/src/protobuf/house.proto b/testing/ecal/pubsub_proto_test/src/protobuf/house.proto
similarity index 100%
rename from samples/cpp/person/person_snd_unicast/src/protobuf/house.proto
rename to testing/ecal/pubsub_proto_test/src/protobuf/house.proto
diff --git a/samples/cpp/person/person_snd_rtps/src/protobuf/person.proto b/testing/ecal/pubsub_proto_test/src/protobuf/person.proto
similarity index 100%
rename from samples/cpp/person/person_snd_rtps/src/protobuf/person.proto
rename to testing/ecal/pubsub_proto_test/src/protobuf/person.proto
diff --git a/testing/ecal/pubsub_test/src/CMakeLists.txt b/testing/ecal/pubsub_test/src/CMakeLists.txt
new file mode 100644
index 0000000000..3307d91137
--- /dev/null
+++ b/testing/ecal/pubsub_test/src/CMakeLists.txt
@@ -0,0 +1,44 @@
+# ========================= eCAL LICENSE =================================
+#
+# Copyright (C) 2016 - 2019 Continental Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#      http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# ========================= eCAL LICENSE =================================
+
+project(test_pubsub)
+
+find_package(Threads REQUIRED)
+find_package(GTest REQUIRED)
+
+set(pubsub_test_src
+  pubsub_test.cpp
+)
+
+ecal_add_gtest(${PROJECT_NAME}_cpp ${pubsub_test_src})
+target_link_libraries(${PROJECT_NAME}_cpp
+  PRIVATE
+    eCAL::core
+    Threads::Threads)
+ecal_install_gtest(${PROJECT_NAME}_cpp)
+set_property(TARGET ${PROJECT_NAME}_cpp PROPERTY FOLDER testing/ecal/pubsub)
+
+if(WIN32)
+  ecal_add_gtest(${PROJECT_NAME}_c   ${pubsub_test_src})
+  target_link_libraries(${PROJECT_NAME}_c
+    PRIVATE
+      eCAL::core_c
+      Threads::Threads)
+  ecal_install_gtest(${PROJECT_NAME}_c)
+  set_property(TARGET ${PROJECT_NAME}_c PROPERTY FOLDER testing/ecal/pubsub)
+endif()
diff --git a/testing/ecal/pubsub_test/src/pubsub_test.cpp b/testing/ecal/pubsub_test/src/pubsub_test.cpp
new file mode 100644
index 0000000000..6a59bd3361
--- /dev/null
+++ b/testing/ecal/pubsub_test/src/pubsub_test.cpp
@@ -0,0 +1,428 @@
+/* ========================= eCAL LICENSE =================================
+ *
+ * Copyright (C) 2016 - 2019 Continental Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * ========================= eCAL LICENSE =================================
+*/
+
+#include <ecal/ecal.h>
+
+#include <atomic>
+
+#include <gtest/gtest.h>
+
+#define CMN_REGISTRATION_REFRESH   1000
+#define DATA_FLOW_TIME               50
+#define PAYLOAD_SIZE               1024
+
+// subscriber callback function
+std::atomic<size_t> g_callback_received;
+void OnReceive(const char* /*topic_name_*/, const struct eCAL::SReceiveCallbackData* data_)
+{
+  g_callback_received += data_->size;
+}
+
+static std::string CreatePayLoad(size_t payload_size_)
+{
+  std::string s = "Hello World ";
+  while(s.size() < payload_size_)
+  {
+    s += s;
+  }
+  s.resize(payload_size_);
+  return(s);
+}
+
+TEST(IO, InitializeFinalize)
+{ 
+  // Is eCAL API initialized ?
+  EXPECT_EQ(0, eCAL::IsInitialized());
+
+  // initialize eCAL API
+  EXPECT_EQ(0, eCAL::Initialize(0, nullptr, "initialize_test"));
+
+  // Is eCAL API initialized ?
+  EXPECT_EQ(1, eCAL::IsInitialized());
+
+  // initialize eCAL API again we expect return value 1 for yet initialized
+  EXPECT_EQ(1, eCAL::Initialize(0, nullptr, "initialize_test"));
+
+  // post initialize eCAL API monitoring API we expect return value 0 for success
+  EXPECT_EQ(0, eCAL::Initialize(0, nullptr, "initialize_test", eCAL::Init::Monitoring));
+
+  // post initialize eCAL API monitoring API again we expect return value 1 for yet initialized
+  EXPECT_EQ(1, eCAL::Initialize(0, nullptr, "initialize_test", eCAL::Init::Monitoring));
+
+  // finalize eCAL API 2 times for the two monitoring post calls, so we decrease the reference
+  // counter and expect 0 for success
+  EXPECT_EQ(0, eCAL::Finalize());
+  EXPECT_EQ(0, eCAL::Finalize());
+
+  // Is eCAL API initialized ? yes ..
+  EXPECT_EQ(1, eCAL::IsInitialized());
+
+  // finalize first time eCAL API we still expect 0 because 
+  // reference counter still greater 0
+  EXPECT_EQ(0, eCAL::Finalize());
+
+  // finalize second time eCAL API we still expect 0 
+  // but now reference counter is 0 and destruction should be succeeded
+  EXPECT_EQ(0, eCAL::Finalize());
+
+  // finalize eCAL API again we expect 1 because yet finalized
+  EXPECT_EQ(1, eCAL::Finalize());
+}
+
+TEST(IO, CreateDestroy)
+{ 
+  // initialize eCAL API
+  eCAL::Initialize(0, nullptr, "pubsub_test");
+
+  // create publisher for topic "A"
+  eCAL::CPublisher pub;
+
+  // check state
+  EXPECT_EQ(false, pub.IsCreated());
+
+  // create
+  EXPECT_EQ(true, pub.Create("A"));
+
+  // check state
+  EXPECT_EQ(true, pub.IsCreated());
+
+  // create subscriber for topic "A"
+  eCAL::CSubscriber sub;
+
+  // check state
+  EXPECT_EQ(false, sub.IsCreated());
+
+  // create
+  EXPECT_EQ(true, sub.Create("A"));
+
+  // check state
+  EXPECT_EQ(true, sub.IsCreated());
+
+  // destroy publisher
+  EXPECT_EQ(true, pub.Destroy());
+
+  // destroy subscriber
+  EXPECT_EQ(true, sub.Destroy());
+
+  // finalize eCAL API
+  eCAL::Finalize();
+}
+
+TEST(IO, SimpleMessage1)
+{ 
+  // default send string
+  std::string send_s = CreatePayLoad(PAYLOAD_SIZE);
+
+  // initialize eCAL API
+  eCAL::Initialize(0, nullptr, "pubsub_test");
+
+  // publish / subscribe match in the same process
+  eCAL::Util::EnableLoopback(true);
+
+  // create publisher for topic "A"
+  eCAL::CPublisher pub("A");
+
+  // create subscriber for topic "A"
+  eCAL::CSubscriber sub("A");
+
+  // let's match them
+  eCAL::Process::SleepMS(2 * CMN_REGISTRATION_REFRESH);
+
+  // send content
+  EXPECT_EQ(send_s.size(), pub.Send(send_s));
+
+  // receive content with DATA_FLOW_TIME ms timeout
+  EXPECT_EQ(send_s.size(), sub.Receive(send_s, nullptr, DATA_FLOW_TIME));
+
+  // receive content with DATA_FLOW_TIME ms timeout
+  // should return because no new publishing
+  EXPECT_EQ(0, sub.Receive(send_s, nullptr, DATA_FLOW_TIME));
+
+  // destroy publisher
+  pub.Destroy();
+
+  // destroy subscriber
+  sub.Destroy();
+
+  // finalize eCAL API
+  eCAL::Finalize();
+}
+
+TEST(IO, SimpleMessage2)
+{ 
+  // default send string
+  std::string send_s = CreatePayLoad(PAYLOAD_SIZE);
+
+  // initialize eCAL API
+  eCAL::Initialize(0, nullptr, "pubsub_test");
+
+  // publish / subscribe match in the same process
+  eCAL::Util::EnableLoopback(true);
+
+  // create subscriber for topic "A"
+  eCAL::CSubscriber sub("A");
+
+  // create publisher for topic "A"
+  eCAL::CPublisher pub("A");
+
+  // let's match them
+  eCAL::Process::SleepMS(2 * CMN_REGISTRATION_REFRESH);
+
+  // send content
+  EXPECT_EQ(send_s.size(), pub.Send(send_s));
+
+  // receive content with DATA_FLOW_TIME ms timeout
+  EXPECT_EQ(send_s.size(), sub.Receive(send_s, nullptr, DATA_FLOW_TIME));
+
+  // destroy publisher
+  pub.Destroy();
+
+  // destroy subscriber
+  sub.Destroy();
+
+  // finalize eCAL API
+  eCAL::Finalize();
+}
+
+TEST(IO, SimpleMessageCB)
+{ 
+  // default send string
+  std::string send_s = CreatePayLoad(PAYLOAD_SIZE);
+
+  // initialize eCAL API
+  eCAL::Initialize(0, nullptr, "pubsub_test");
+
+  // publish / subscribe match in the same process
+  eCAL::Util::EnableLoopback(true);
+
+  // create subscriber for topic "A"
+  eCAL::CSubscriber sub("A");
+
+  // create publisher for topic "A"
+  eCAL::CPublisher pub("A");
+
+  // add callback
+  EXPECT_EQ(true, sub.AddReceiveCallback(std::bind(OnReceive, std::placeholders::_1, std::placeholders::_2)));
+
+  // let's match them
+  eCAL::Process::SleepMS(2 * CMN_REGISTRATION_REFRESH);
+
+  // send content
+  g_callback_received = 0;
+  EXPECT_EQ(send_s.size(), pub.Send(send_s));
+
+  // let the data flow
+  eCAL::Process::SleepMS(DATA_FLOW_TIME);
+
+  // check callback receive
+  EXPECT_EQ(send_s.size(), g_callback_received);
+
+  // remove receive callback
+  sub.RemReceiveCallback();
+
+  // send content
+  g_callback_received = 0;
+  EXPECT_EQ(send_s.size(), pub.Send(send_s));
+
+  // let the data flow
+  eCAL::Process::SleepMS(DATA_FLOW_TIME);
+
+  // check callback receive
+  EXPECT_EQ(0, g_callback_received);
+
+  // add callback again
+  EXPECT_EQ(true, sub.AddReceiveCallback(std::bind(OnReceive, std::placeholders::_1, std::placeholders::_2)));
+
+  // send content
+  g_callback_received = 0;
+  EXPECT_EQ(send_s.size(), pub.Send(send_s));
+
+  // let the data flow
+  eCAL::Process::SleepMS(DATA_FLOW_TIME);
+
+  // check callback receive
+  EXPECT_EQ(send_s.size(), g_callback_received);
+
+  // destroy subscriber
+  sub.Destroy();
+
+  // send content
+  g_callback_received = 0;
+  EXPECT_EQ(send_s.size(), pub.Send(send_s));
+
+  // let the data flow
+  eCAL::Process::SleepMS(DATA_FLOW_TIME);
+
+  // check callback receive
+  EXPECT_EQ(0, g_callback_received);
+
+  // destroy publisher
+  pub.Destroy();
+
+  // finalize eCAL API
+  eCAL::Finalize();
+}
+
+TEST(IO, DynamicSizeCB)
+{ 
+  // default send string
+  std::string send_s = CreatePayLoad(PAYLOAD_SIZE);
+
+  // initialize eCAL API
+  eCAL::Initialize(0, nullptr, "pubsub_test");
+
+  // publish / subscribe match in the same process
+  eCAL::Util::EnableLoopback(true);
+
+  // create subscriber for topic "A"
+  eCAL::CSubscriber sub("A");
+
+  // create publisher for topic "A"
+  eCAL::CPublisher pub("A");
+
+  // add callback
+  EXPECT_EQ(true, sub.AddReceiveCallback(std::bind(OnReceive, std::placeholders::_1, std::placeholders::_2)));
+
+  // let's match them
+  eCAL::Process::SleepMS(2 * CMN_REGISTRATION_REFRESH);
+
+  // send content
+  g_callback_received = 0;
+  EXPECT_EQ(send_s.size(), pub.Send(send_s));
+
+  // let the data flow
+  eCAL::Process::SleepMS(DATA_FLOW_TIME);
+
+  // check callback receive
+  EXPECT_EQ(send_s.size(), g_callback_received);
+
+  // increase payload size
+  send_s = CreatePayLoad(PAYLOAD_SIZE*10);
+
+  // send content
+  g_callback_received = 0;
+  EXPECT_EQ(send_s.size(), pub.Send(send_s));
+
+  // let the data flow
+  eCAL::Process::SleepMS(DATA_FLOW_TIME);
+
+  // check callback receive
+  EXPECT_EQ(send_s.size(), g_callback_received);
+
+  // destroy publisher
+  pub.Destroy();
+
+  // destroy subscriber
+  sub.Destroy();
+
+  // finalize eCAL API
+  eCAL::Finalize();
+}
+
+TEST(IO, DynamicCreate)
+{ 
+  // default send string
+  std::string send_s = CreatePayLoad(PAYLOAD_SIZE);
+
+  // initialize eCAL API
+  eCAL::Initialize(0, nullptr, "pubsub_test");
+
+  // publish / subscribe match in the same process
+  eCAL::Util::EnableLoopback(true);
+
+  // create subscriber for topic "A"
+  eCAL::CSubscriber* sub;
+  sub = new eCAL::CSubscriber("A");
+
+  // create publisher for topic "A"
+  eCAL::CPublisher* pub;
+  pub = new eCAL::CPublisher("A");
+
+  // add callback
+  EXPECT_EQ(true, sub->AddReceiveCallback(std::bind(OnReceive, std::placeholders::_1, std::placeholders::_2)));
+
+  // let's match them
+  eCAL::Process::SleepMS(2 * CMN_REGISTRATION_REFRESH);
+
+  // send content
+  g_callback_received = 0;
+  EXPECT_EQ(send_s.size(), pub->Send(send_s));
+
+  // let the data flow
+  eCAL::Process::SleepMS(DATA_FLOW_TIME);
+
+  // check callback receive
+  EXPECT_EQ(send_s.size(), g_callback_received);
+
+  // destroy subscriber
+  delete sub;
+  sub = nullptr;
+
+  // create subscriber for topic "A"
+  sub = new eCAL::CSubscriber("A");
+
+  // add callback
+  EXPECT_EQ(true, sub->AddReceiveCallback(std::bind(OnReceive, std::placeholders::_1, std::placeholders::_2)));
+
+  // let's match them
+  eCAL::Process::SleepMS(2 * CMN_REGISTRATION_REFRESH);
+
+  // send content
+  g_callback_received = 0;
+  EXPECT_EQ(send_s.size(), pub->Send(send_s));
+
+  // let the data flow
+  eCAL::Process::SleepMS(DATA_FLOW_TIME);
+
+  // check callback receive
+  EXPECT_EQ(send_s.size(), g_callback_received);
+
+  // destroy subscriber
+  sub->Destroy();
+
+  // create subscriber for topic "A"
+  sub->Create("A");
+
+  // add callback
+  EXPECT_EQ(true, sub->AddReceiveCallback(std::bind(OnReceive, std::placeholders::_1, std::placeholders::_2)));
+
+  // let's match them
+  eCAL::Process::SleepMS(2 * CMN_REGISTRATION_REFRESH);
+
+  // send content
+  g_callback_received = 0;
+  EXPECT_EQ(send_s.size(), pub->Send(send_s));
+
+  // let the data flow
+  eCAL::Process::SleepMS(DATA_FLOW_TIME);
+
+  // check callback receive
+  EXPECT_EQ(send_s.size(), g_callback_received);
+
+  // destroy publisher
+  delete pub;
+  pub = nullptr;
+
+  // destroy subscriber
+  delete sub;
+  sub = nullptr;
+
+  // finalize eCAL API
+  eCAL::Finalize();
+}
diff --git a/thirdparty/cmake_functions/.gitrepo b/thirdparty/cmake_functions/.gitrepo
deleted file mode 100644
index fa040114a5..0000000000
--- a/thirdparty/cmake_functions/.gitrepo
+++ /dev/null
@@ -1,11 +0,0 @@
-; DO NOT EDIT (unless you know what you are doing)
-;
-; This subdirectory is a git "subrepo", and this file is maintained by the
-; git-subrepo command. See https://github.com/git-commands/git-subrepo#readme
-;
-[subrepo]
-	remote = http://github.conti.de/CTZS/cmake_functions.git
-	branch = v0.2.0
-	commit = 8727e8ae0eac442835540771a58bd7a7007ea8e1
-	parent = cee780a727b9ec43c2d21ee201ee0291e84446c6
-	cmdver = 0.3.1
diff --git a/thirdparty/googletest b/thirdparty/googletest
new file mode 160000
index 0000000000..703bd9caab
--- /dev/null
+++ b/thirdparty/googletest
@@ -0,0 +1 @@
+Subproject commit 703bd9caab50b139428cea1aaff9974ebee5742e