diff --git a/CMake/mitkInstallRules.cmake b/CMake/mitkInstallRules.cmake
index ec850c1efc..d63fd4bdfd 100644
--- a/CMake/mitkInstallRules.cmake
+++ b/CMake/mitkInstallRules.cmake
@@ -1,152 +1,156 @@
 # Install MITK icon and logo
 
 MITK_INSTALL(FILES
   "${MITK_SOURCE_DIR}/mitk.ico"
   "${MITK_SOURCE_DIR}/mitk.bmp")
 
 # Helper vars
 
 if(WIN32)
   set(_prefix "")
   set(_ext ".dll")
 elseif(UNIX)
   set(_prefix "lib")
   if(APPLE)
     set(_ext ".dylib")
   else()
     set(_ext ".so")
   endif()
 endif()
 
 # Install MITK executables including auto-load modules
 
 get_property(_mitk_executable_targets GLOBAL PROPERTY MITK_EXECUTABLE_TARGETS)
 if(_mitk_executable_targets)
   get_property(_mitk_module_targets GLOBAL PROPERTY MITK_MODULE_TARGETS)
   foreach(_mitk_module_target ${_mitk_module_targets})
     if(TARGET ${_mitk_module_target})
       get_target_property(_mitk_autoload_targets ${_mitk_module_target} MITK_AUTOLOAD_TARGETS)
       if (_mitk_autoload_targets)
         foreach(_mitk_autoload_target ${_mitk_autoload_targets})
           get_target_property(_mitk_autoload_directory ${_mitk_autoload_target} MITK_AUTOLOAD_DIRECTORY)
           if (_mitk_autoload_directory)
             if(WIN32)
               get_target_property(_target_location ${_mitk_autoload_target} RUNTIME_OUTPUT_DIRECTORY)
             else()
               get_target_property(_target_location ${_mitk_autoload_target} LIBRARY_OUTPUT_DIRECTORY)
             endif()
             if(NOT CMAKE_CFG_INTDIR STREQUAL ".")
               set(_target_location "${_target_location}/Release")
             endif()
             set(_mitk_autoload_target_filename "${_prefix}${_mitk_autoload_target}${_ext}")
             set(_mitk_autoload_target_filepath "${_target_location}/${_mitk_autoload_target_filename}")
             set(_install_DESTINATION "${_mitk_autoload_directory}")
             MITK_INSTALL(FILES ${_mitk_autoload_target_filepath})
             if(UNIX AND NOT APPLE)
               install(CODE "file(RPATH_REMOVE FILE \"\${CMAKE_INSTALL_PREFIX}/bin/${_mitk_autoload_directory}/${_mitk_autoload_target_filename}\")")
             endif()
           endif()
         endforeach()
       endif()
     endif()
   endforeach()
 
   set(_install_DESTINATION "")
 
   foreach(_mitk_executable_target ${_mitk_executable_targets})
+    get_target_property(_no_install ${_mitk_executable_target} NO_INSTALL)
+    if(_no_install)
+      continue()
+    endif()
     MITK_INSTALL_TARGETS(EXECUTABLES ${_mitk_executable_target} GLOB_PLUGINS)
     if(UNIX AND NOT APPLE)
       install(PROGRAMS "${MITK_SOURCE_DIR}/CMake/RunInstalledApp.sh" DESTINATION "." RENAME ${_mitk_executable_target}.sh)
     endif()
   endforeach()
 endif()
 
 # Install PythonQt
 
 if(MITK_USE_Python3 AND PythonQt_DIR)
   set(_python_qt_lib "${PythonQt_DIR}/")
   if(WIN32)
     set(_python_qt_lib "${_python_qt_lib}bin")
   else()
     set(_python_qt_lib "${_python_qt_lib}lib")
   endif()
   set(_python_qt_lib "${_python_qt_lib}/${_prefix}PythonQt${_ext}")
   MITK_INSTALL(FILES ${_python_qt_lib})
 endif()
 
 # Install Qt plugins
 
 if(MITK_USE_Qt5)
   get_property(_qmake_location TARGET ${Qt5Core_QMAKE_EXECUTABLE} PROPERTY IMPORT_LOCATION)
   get_filename_component(_qmake_path ${_qmake_location} DIRECTORY)
 
   set(_install_DESTINATION "plugins/sqldrivers")
   MITK_INSTALL(FILES "${_qmake_path}/../plugins/sqldrivers/${_prefix}qsqlite${_ext}")
 
   set(_install_DESTINATION "plugins/imageformats")
   MITK_INSTALL(FILES "${_qmake_path}/../plugins/imageformats/${_prefix}qsvg${_ext}")
 
   set(_install_DESTINATION "plugins/iconengines")
   MITK_INSTALL(FILES "${_qmake_path}/../plugins/iconengines/${_prefix}qsvgicon${_ext}")
 
   # Install platform-specific Qt plugins
 
   set(_install_DESTINATION "plugins/platforms")
 
   if(WIN32)
     MITK_INSTALL(FILES "${_qmake_path}/../plugins/platforms/qwindows.dll")
   elseif(APPLE)
     MITK_INSTALL(FILES "${_qmake_path}/../plugins/platforms/libqcocoa.dylib")
   elseif(UNIX)
     MITK_INSTALL(FILES "${_qmake_path}/../plugins/platforms/libqxcb.so")
 
     set(_install_DESTINATION "plugins/xcbglintegrations")
     MITK_INSTALL(FILES "${_qmake_path}/../plugins/xcbglintegrations/libqxcb-glx-integration.so")
   endif()
 
   # Install platform-specific Qt styles
 
   set(_install_DESTINATION "plugins/styles")
 
   if(WIN32)
     MITK_INSTALL(FILES "${_qmake_path}/../plugins/styles/qwindowsvistastyle.dll")
   elseif(APPLE)
     MITK_INSTALL(FILES "${_qmake_path}/../plugins/styles/libqmacstyle.dylib")
   endif()
 
   # Install Qt WebEngine
 
   if(APPLE)
     set(_install_DESTINATION "../Frameworks/QtWebEngineCore.framework")
 
     get_filename_component(_real_path "${_qmake_path}/../lib/QtWebEngineCore.framework/Helpers" REALPATH)
     MITK_INSTALL(DIRECTORY ${_real_path} USE_SOURCE_PERMISSIONS)
 
     # Translations are included in the Resources directory of
     # QtWebEngineCore.framework and are installed by default.
   else()
     set(_install_DESTINATION "")
 
     if(WIN32)
       MITK_INSTALL(PROGRAMS "${_qmake_path}/QtWebEngineProcess.exe")
     elseif(UNIX)
       MITK_INSTALL(PROGRAMS "${_qmake_path}/../libexec/QtWebEngineProcess")
     endif()
 
     MITK_INSTALL(DIRECTORY "${_qmake_path}/../resources")
 
     set(_install_DESTINATION "translations")
     MITK_INSTALL(DIRECTORY "${_qmake_path}/../translations/qtwebengine_locales")
   endif()
 endif()
 
 set(_install_DESTINATION "")
 
 # Install MatchPoint binaries that are not auto-detected
 if(MITK_USE_MatchPoint)
   MITK_INSTALL(DIRECTORY "${MITK_EXTERNAL_PROJECT_PREFIX}/bin/" FILES_MATCHING PATTERN "MapUtilities*")
   MITK_INSTALL(DIRECTORY "${MITK_EXTERNAL_PROJECT_PREFIX}/bin/" FILES_MATCHING PATTERN "MapAlgorithms*")
 endif()
 
 # IMPORTANT: Restore default install destination! Do not edit this file beyond this line!
 set(_install_DESTINATION "")
diff --git a/CMake/mitkMacroCreateExecutable.cmake b/CMake/mitkMacroCreateExecutable.cmake
index 6f3a3048b0..c9c9d130ed 100644
--- a/CMake/mitkMacroCreateExecutable.cmake
+++ b/CMake/mitkMacroCreateExecutable.cmake
@@ -1,112 +1,117 @@
 ##################################################################
 #
 # MITK_CREATE_EXECUTABLE
 #
 #! Creates an executable with MITK dependencies and batch files
 #! for proper application start-up.
 #!
 #! USAGE:
 #!
 #! \code
 #! MITK_CREATE_EXECUTABLE( [<exectuableName>]
 #!     [DEPENDS <modules we need>]
 #!     [PACKAGE_DEPENDS <packages we need, like ITK, VTK, QT>]
 #!     [INCLUDE_DIRS <list of additional include directories>]
 #!     [TARGET_DEPENDS <list of additional dependencies>
 #!     [WARNINGS_NO_ERRORS]
+#!     [NO_INSTALL]
 #! \endcode
 #!
 #! \param EXECUTABLE_NAME The name for the new executable target
 ##################################################################
 macro(mitk_create_executable)
 
   set(_macro_params
       VERSION                # version number, e.g. "1.2.0"
       FILES_CMAKE            # file name of a CMake file setting source list variables
                              # (defaults to files.cmake)
       DESCRIPTION            # a description for the executable
      )
 
   set(_macro_multiparams
       SUBPROJECTS            # list of CDash labels
       INCLUDE_DIRS           # additional include dirs
       DEPENDS                # list of modules this module depends on
       PACKAGE_DEPENDS        # list of "packages" this module depends on (e.g. Qt, VTK, etc.)
       TARGET_DEPENDS         # list of CMake targets this executable should depend on
       ADDITIONAL_LIBS        # list of additional libraries linked to this executable
       CPP_FILES              # (optional) list of cpp files
      )
 
   set(_macro_options
       NO_INIT                # do not create CppMicroServices initialization code
       NO_FEATURE_INFO        # do not create a feature info by calling add_feature_info()
       NO_BATCH_FILE          # do not create batch files on Windows
       WARNINGS_NO_ERRORS     # do not treat compiler warnings as errors
+      NO_INSTALL
      )
 
   cmake_parse_arguments(EXEC "${_macro_options}" "${_macro_params}" "${_macro_multiparams}" ${ARGN})
 
   set(_EXEC_OPTIONS EXECUTABLE)
   if(EXEC_NO_INIT)
     list(APPEND _EXEC_OPTIONS NO_INIT)
   endif()
   if(EXEC_WARNINGS_NO_ERRORS)
     list(APPEND _EXEC_OPTIONS WARNINGS_NO_ERRORS)
   endif()
   if(EXEC_NO_FEATURE_INFO)
     list(APPEND _EXEC_OPTIONS NO_FEATURE_INFO)
   endif()
 
   mitk_create_module(${EXEC_UNPARSED_ARGUMENTS}
                      SUBPROJECTS ${EXEC_SUBPROJECTS}
                      VERSION ${EXEC_VERSION}
                      INCLUDE_DIRS ${EXEC_INCLUDE_DIRS}
                      DEPENDS ${EXEC_DEPENDS}
                      PACKAGE_DEPENDS ${EXEC_PACKAGE_DEPENDS}
                      TARGET_DEPENDS ${EXEC_TARGET_DEPENDS}
                      ADDITIONAL_LIBS ${EXEC_ADDITIONAL_LIBS}
                      FILES_CMAKE ${EXEC_FILES_CMAKE}
                      CPP_FILES ${EXEC_CPP_FILES}
                      DESCRIPTION "${DESCRIPTION}"
                      ${_EXEC_OPTIONS}
                     )
 
   set(EXECUTABLE_IS_ENABLED ${MODULE_IS_ENABLED})
   set(EXECUTABLE_TARGET ${MODULE_TARGET})
   if(EXECUTABLE_IS_ENABLED)
     set_property(GLOBAL APPEND PROPERTY MITK_EXECUTABLE_TARGETS ${EXECUTABLE_TARGET})
+    if(EXEC_NO_INSTALL)
+      set_target_properties(${EXECUTABLE_TARGET} PROPERTIES NO_INSTALL TRUE)
+    endif()
     # Add meta dependencies (e.g. on auto-load modules from depending modules)
     if(TARGET ${CMAKE_PROJECT_NAME}-autoload)
       add_dependencies(${MODULE_TARGET} ${CMAKE_PROJECT_NAME}-autoload)
     endif()
 
     # Create batch and VS user files for Windows platforms
     include(mitkFunctionCreateWindowsBatchScript)
     if(WIN32)
       set(_batch_file_in "${CMAKE_CURRENT_SOURCE_DIR}/${MODULE_TARGET}.bat.in")
       if(NOT EXISTS "${_batch_file_in}")
         set(_batch_file_in "${MITK_CMAKE_DIR}/StartApp.bat.in")
       endif()
       if(CMAKE_RUNTIME_OUTPUT_DIRECTORY)
         set(_batch_file_out_dir "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}")
       else()
         set(_batch_file_out_dir "${CMAKE_CURRENT_BINARY_DIR}")
       endif()
       if(NOT EXEC_NO_BATCH_FILE)
         if(NOT EXEC_NAME)
           set(EXEC_NAME ${MODULE_TARGET})
         endif()
         foreach(BUILD_TYPE debug release)
           mitkFunctionCreateWindowsBatchScript(
               ${_batch_file_in} ${_batch_file_out_dir}/${MODULE_TARGET}_${BUILD_TYPE}.bat
               ${BUILD_TYPE}
              )
         endforeach()
       endif()
       mitkFunctionConfigureVisualStudioUserProjectFile(
           NAME ${MODULE_TARGET}
         )
     endif()
   endif()
 
 endmacro()
diff --git a/CMake/mitkMacroCreateModuleTests.cmake b/CMake/mitkMacroCreateModuleTests.cmake
index 9cd2e0a889..9c6c81a7f3 100644
--- a/CMake/mitkMacroCreateModuleTests.cmake
+++ b/CMake/mitkMacroCreateModuleTests.cmake
@@ -1,106 +1,109 @@
 #
 # Create tests and testdriver for this module
 #
 # Usage: MITK_CREATE_MODULE_TESTS( [EXTRA_DRIVER_INIT init_code]  )
 #
 # EXTRA_DRIVER_INIT is inserted as c++ code in the testdriver and will be executed before each test
 #
 macro(MITK_CREATE_MODULE_TESTS)
   cmake_parse_arguments(MODULE_TEST
                         "US_MODULE;NO_INIT" "EXTRA_DRIVER_INIT;EXTRA_DRIVER_INCLUDE" "EXTRA_DEPENDS;DEPENDS;PACKAGE_DEPENDS" ${ARGN})
 
   if(BUILD_TESTING AND MODULE_IS_ENABLED)
     include(files.cmake)
     include_directories(.)
 
     set(TESTDRIVER ${MODULE_NAME}TestDriver)
 
     set(MODULE_TEST_EXTRA_DRIVER_INIT "${MODULE_TEST_EXTRA_DRIVER_INIT}")
 
     if(MITK_XVFB_TESTING)
       set(xvfb_run "xvfb-run" "--auto-servernum")
     else()
       set(xvfb_run )
     endif()
 
     if(MODULE_TEST_US_MODULE)
       message(WARNING "The US_MODULE argument is deprecated and should be removed")
     endif()
 
     if(MODULE_TEST_US_MODULE AND MODULE_TEST_NO_INIT)
       message(WARNING "Conflicting arguments US_MODULE and NO_INIT: NO_INIT wins.")
     endif()
 
     set(_no_init)
     if(MODULE_TEST_NO_INIT)
       set(_no_init NO_INIT)
     endif()
 
     set(MITK_MODULE_NAME_REGEX_MATCH )
     set(MITK_MODULE_NAME_REGEX_NOT_MATCH )
 
     set(_testdriver_file_list ${CMAKE_CURRENT_BINARY_DIR}/testdriver_files.cmake)
     configure_file(${MITK_CMAKE_DIR}/mitkTestDriverFiles.cmake.in ${_testdriver_file_list} @ONLY)
     mitk_create_executable(${TESTDRIVER}
                            DEPENDS ${MODULE_NAME} ${MODULE_TEST_DEPENDS} ${MODULE_TEST_EXTRA_DEPENDS} MitkTestingHelper
                            PACKAGE_DEPENDS ${MODULE_TEST_PACKAGE_DEPENDS}
                            SUBPROJECTS ${MODULE_SUBPROJECTS}
                            FILES_CMAKE ${_testdriver_file_list}
-                           NO_FEATURE_INFO NO_BATCH_FILE ${_no_init})
+                           NO_FEATURE_INFO
+                           NO_BATCH_FILE
+                           NO_INSTALL
+                           ${_no_init})
     set_property(TARGET ${EXECUTABLE_TARGET} PROPERTY FOLDER "${MITK_ROOT_FOLDER}/Modules/Tests")
 
     #
     # Now tell CMake which tests should be run. This is done automatically
     # for all tests in ${KITNAME}_TESTS and ${KITNAME}_IMAGE_TESTS. The IMAGE_TESTS
     # are run for each image in the TESTIMAGES list.
     #
     include(files.cmake)
     foreach( test ${MODULE_TESTS} )
       get_filename_component(TName ${test} NAME_WE)
       add_test(NAME ${TName} COMMAND ${xvfb_run} ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${TESTDRIVER} ${TName})
       # Add labels for CDash subproject support
       if(MODULE_SUBPROJECTS)
         set_property(TEST ${TName} PROPERTY LABELS ${MODULE_SUBPROJECTS} MITK)
       endif()
       mitkFunctionGetLibrarySearchPaths(MITK_RUNTIME_PATH_RELEASE release RELEASE)
       mitkFunctionGetLibrarySearchPaths(MITK_RUNTIME_PATH_DEBUG debug DEBUG)
       set(test_env_path ${MITK_RUNTIME_PATH_RELEASE} ${MITK_RUNTIME_PATH_DEBUG} $ENV{PATH})
       list(REMOVE_DUPLICATES test_env_path)
       string (REGEX REPLACE "\;" "\\\;" test_env_path "${test_env_path}")
       set_property(TEST ${TName} PROPERTY ENVIRONMENT "PATH=${test_env_path}" APPEND)
       set_property(TEST ${TName} PROPERTY SKIP_RETURN_CODE 77)
     endforeach()
 
     set(TEST_TYPES IMAGE SURFACE POINTSET) # add other file types here
 
     foreach(test_type ${TEST_TYPES})
        foreach(test_data ${MODULE_TEST${test_type}} ${ADDITIONAL_TEST_${test_type}})
          if(EXISTS ${test_data})
            set(TEST_DATA_FULL_PATH ${test_data})
           else()
              # todo: maybe search other paths as well
              # yes, please in mitk/Testing/Data, too
              set(TEST_DATA_FULL_PATH ${MITK_DATA_DIR}/${test_data})
           endif()
 
            if(EXISTS ${TEST_DATA_FULL_PATH})
              foreach( test ${MODULE_${test_type}_TESTS})
                get_filename_component(TName ${test} NAME_WE)
                get_filename_component(DName ${TEST_DATA_FULL_PATH} NAME)
                add_test(NAME ${TName}_${DName} COMMAND ${xvfb_run} ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${TESTDRIVER} ${TName} ${TEST_DATA_FULL_PATH})
                # Add labels for CDash subproject support
                if(MODULE_SUBPROJECTS)
                  set_property(TEST ${TName}_${DName} PROPERTY LABELS ${MODULE_SUBPROJECTS} MITK)
                endif()
                set_property(TEST ${TName}_${DName} PROPERTY ENVIRONMENT "PATH=${test_env_path}" APPEND)
                set_property(TEST ${TName}_${DName} PROPERTY SKIP_RETURN_CODE 77)
              endforeach()
            else()
              message("!!!!! No such file: ${TEST_DATA_FULL_PATH} !!!!!")
            endif()
          endforeach()
     endforeach()
 
  endif()
 
 endmacro()