diff --git a/Applications/CoreApp/CMakeLists.txt b/Applications/CoreApp/CMakeLists.txt
index fee4eb37b2..c8dc45a0f0 100644
--- a/Applications/CoreApp/CMakeLists.txt
+++ b/Applications/CoreApp/CMakeLists.txt
@@ -1,37 +1,33 @@
 project(CoreApp)
 
 set(_app_options)
 if(MITK_SHOW_CONSOLE_WINDOW)
   list(APPEND _app_options SHOW_CONSOLE)
 endif()
 
 # Create a cache entry for the provisioning file which is used to export
 # the file name in the MITKConfig.cmake file. This will keep external projects
 # which rely on this file happy.
 set(MITK_COREAPP_PROVISIONING_FILE "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/MitkCoreApp.provisioning" CACHE INTERNAL "CoreApp provisioning file" FORCE)
 
 set(_plugins
   org.mitk.gui.qt.coreapplication
   org.mitk.gui.qt.stdmultiwidgeteditor
 )
 
 # Plug-ins listed below will not be
 #  - added as a build-time dependency to the executable
 #  - listed in the provisioning file for the executable
 #  - installed if they are external plug-ins
 
 set(_exclude_plugins )
 
 mitkFunctionCreateBlueBerryApplication(
   NAME MitkCoreApp
   DESCRIPTION "MITK - CoreApp Application"
   PLUGINS ${_plugins}
   ${_app_options}
 )
 
-mitk_use_modules(TARGET MitkCoreApp
-  MODULES MitkAppUtil
-)
-
 # subproject support
 add_dependencies(MITK-CoreUI MitkCoreApp)
diff --git a/Applications/Diffusion/CMakeLists.txt b/Applications/Diffusion/CMakeLists.txt
index f6af42f8ae..ba489bb2ed 100644
--- a/Applications/Diffusion/CMakeLists.txt
+++ b/Applications/Diffusion/CMakeLists.txt
@@ -1,103 +1,101 @@
 #if(MITK_USE_Python)
 
 project(MitkDiffusion)
 
 set(DIFFUSIONAPP_NAME MitkDiffusion)
 
 set(_app_options)
 if(MITK_SHOW_CONSOLE_WINDOW)
   list(APPEND _app_options SHOW_CONSOLE)
 endif()
 
 # Create a cache entry for the provisioning file which is used to export
 # the file name in the MITKConfig.cmake file. This will keep external projects
 # which rely on this file happy.
 set(DIFFUSIONIMAGINGAPP_PROVISIONING_FILE "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${DIFFUSIONAPP_NAME}.provisioning" CACHE INTERNAL "${DIFFUSIONAPP_NAME} provisioning file" FORCE)
 
 # should be identical to the list in /CMake/mitkBuildConfigurationmitkDiffusion.cmake
 # remember to set plugins which should be automatically toggled in target_libraries.cmake
 set(_plugins
   org.commontk.configadmin
   org.commontk.eventadmin
   org.blueberry.core.runtime
   org.blueberry.core.expressions
   org.blueberry.core.commands
   org.blueberry.ui.qt
   org.blueberry.ui.qt.log
   org.blueberry.ui.qt.help
   org.mitk.core.services
   org.mitk.gui.common
   org.mitk.planarfigure
   org.mitk.core.ext
   org.mitk.gui.qt.application
   org.mitk.gui.qt.ext
   org.mitk.gui.qt.diffusionimagingapp
   org.mitk.gui.qt.common
   org.mitk.gui.qt.stdmultiwidgeteditor
   org.mitk.gui.qt.datamanager
   org.mitk.gui.qt.measurementtoolbox
   org.mitk.gui.qt.segmentation
   org.mitk.gui_qt.multilabelsegmentation
   org.mitk.gui.qt.volumevisualization
   org.mitk.gui.qt.diffusionimaging
   org.mitk.gui.qt.diffusionimaging.connectomics
   org.mitk.gui.qt.diffusionimaging.fiberfox
   org.mitk.gui.qt.diffusionimaging.fiberprocessing
   org.mitk.gui.qt.diffusionimaging.ivim
   org.mitk.gui.qt.diffusionimaging.odfpeaks
   org.mitk.gui.qt.diffusionimaging.preprocessing
   org.mitk.gui.qt.diffusionimaging.reconstruction
   org.mitk.gui.qt.diffusionimaging.tractography
   org.mitk.gui.qt.diffusionimaging.registration
 #  org.mitk.gui.qt.diffusionimaging.python
   org.mitk.gui.qt.diffusionimaging.denoising
 #  org.mitk.gui.qt.matchpoint.algorithm.browser
 #  org.mitk.gui.qt.matchpoint.algorithm.control
 #  org.mitk.gui.qt.matchpoint.mapper
   org.mitk.gui.qt.imagenavigator
   org.mitk.gui.qt.moviemaker
   org.mitk.gui.qt.basicimageprocessing
   org.mitk.gui.qt.properties
   org.mitk.gui.qt.viewnavigator
 )
 
 # Plug-ins listed below will not be
 #  - added as a build-time dependency to the executable
 #  - listed in the provisioning file for the executable
 #  - installed if they are external plug-ins
 
 set(_exclude_plugins
   org.blueberry.test
   org.blueberry.uitest
   org.mitk.gui.qt.coreapplication
   org.mitk.gui.qt.extapplication
 )
 
 set(_src_files
   MitkDiffusion.cpp
 )
 
 qt5_add_resources(_src_files splashscreen.qrc)
 
 mitkFunctionCreateBlueBerryApplication(
   NAME ${DIFFUSIONAPP_NAME}
   DESCRIPTION "MITK Diffusion"
   PLUGINS ${_plugins}
   EXCLUDE_PLUGINS ${_exclude_plugins}
   SOURCES ${_src_files}
   ${_app_options}
 )
 
-mitk_use_modules(TARGET ${DIFFUSIONAPP_NAME} MODULES MitkAppUtil)
-
 # Add meta dependencies (e.g. on auto-load modules from depending modules)
 if(TARGET ${CMAKE_PROJECT_NAME}-autoload)
   add_dependencies(${DIFFUSIONAPP_NAME} ${CMAKE_PROJECT_NAME}-autoload)
 endif()
 
 # Add a build time dependency to legacy BlueBerry bundles.
 if(MITK_MODULES_ENABLED_PLUGINS)
   add_dependencies(${DIFFUSIONAPP_NAME} ${MITK_MODULES_ENABLED_PLUGINS})
 endif()
 
 # endif() # MITK_USE_PYTHON
diff --git a/Applications/PluginGenerator/ProjectTemplate/Apps/TemplateApp/CMakeLists.txt b/Applications/PluginGenerator/ProjectTemplate/Apps/TemplateApp/CMakeLists.txt
index fc1a393c38..94c529feb2 100644
--- a/Applications/PluginGenerator/ProjectTemplate/Apps/TemplateApp/CMakeLists.txt
+++ b/Applications/PluginGenerator/ProjectTemplate/Apps/TemplateApp/CMakeLists.txt
@@ -1,26 +1,21 @@
 
 set(_app_options)
 if(${MY_PROJECT_NAME}_SHOW_CONSOLE_WINDOW)
   list(APPEND _app_options SHOW_CONSOLE)
 endif()
 
 # Plug-ins listed below will not be
 #  - added as a build-time dependency to the executable
 #  - listed in the provisioning file for the executable
 #  - installed if they are external plug-ins
 
 set(_exclude_plugins
 
 )
 
 mitkFunctionCreateBlueBerryApplication(
   NAME ${MY_APP_NAME}
   DESCRIPTION "MITK - ${MY_APP_NAME} Application"
   EXCLUDE_PLUGINS ${_exclude_plugins}
   ${_app_options}
 )
-
-mitk_use_modules(TARGET ${MY_APP_NAME}
-  MODULES MitkAppUtil
-  PACKAGES Qt5|Widgets
-)
diff --git a/Applications/Workbench/CMakeLists.txt b/Applications/Workbench/CMakeLists.txt
index c2ad329f0f..2a1ed548ae 100644
--- a/Applications/Workbench/CMakeLists.txt
+++ b/Applications/Workbench/CMakeLists.txt
@@ -1,57 +1,56 @@
 project(Workbench)
 
 set(_app_options)
 if(MITK_SHOW_CONSOLE_WINDOW)
   list(APPEND _app_options SHOW_CONSOLE)
 endif()
 
 # Create a cache entry for the provisioning file which is used to export
 # the file name in the MITKConfig.cmake file. This will keep external projects
 # which rely on this file happy.
 set(MITK_EXTAPP_PROVISIONING_FILE "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/MitkWorkbench.provisioning" CACHE INTERNAL "MitkWorkbench provisioning file" FORCE)
 
 # Plug-ins listed below will not be
 #  - added as a build-time dependency to the executable
 #  - listed in the provisioning file for the executable
 #  - installed if they are external plug-ins
 
 set(_exclude_plugins
   org.blueberry.test
   org.blueberry.uitest
   org.mitk.gui.qt.coreapplication
   org.mitk.gui.qt.diffusionimagingapp
   org.mitk.example.gui.customviewer
   org.mitk.example.gui.customviewer.views
   org.mitk.example.gui.selectionservicemitk
   org.mitk.example.gui.selectionservicemitk.views
   org.mitk.example.gui.selectionserviceqt
   org.mitk.example.gui.extensionpointcontribution
   org.mitk.example.gui.extensionpointdefinition
   org.mitk.example.gui.minimalapplication
   org.mitk.example.gui.multipleperspectives
 )
 
 mitkFunctionCreateBlueBerryApplication(
   NAME MitkWorkbench
   DESCRIPTION "MITK Workbench"
   EXCLUDE_PLUGINS ${_exclude_plugins}
   ${_app_options}
 )
-mitk_use_modules(TARGET MitkWorkbench MODULES MitkAppUtil)
 
 # Add meta dependencies (e.g. on auto-load modules from depending modules)
 if(TARGET ${CMAKE_PROJECT_NAME}-autoload)
   add_dependencies(MitkWorkbench ${CMAKE_PROJECT_NAME}-autoload)
 endif()
 
 #Setting application icon for macOS systems
 set_target_properties(MitkWorkbench PROPERTIES MACOSX_BUNDLE_ICON_FILE "icon.icns")
 
 if(APPLE)
   install(FILES "icons/icon.icns" DESTINATION "MitkWorkbench.app/Contents/Resources")
 endif(APPLE)
 
 # Add a build time dependency to legacy BlueBerry bundles.
 if(MITK_MODULES_ENABLED_PLUGINS)
   add_dependencies(MitkWorkbench ${MITK_MODULES_ENABLED_PLUGINS})
 endif()
diff --git a/CMake/mitkFunctionCreateBlueBerryApplication.cmake b/CMake/mitkFunctionCreateBlueBerryApplication.cmake
index f344380651..c7567ffcc2 100644
--- a/CMake/mitkFunctionCreateBlueBerryApplication.cmake
+++ b/CMake/mitkFunctionCreateBlueBerryApplication.cmake
@@ -1,218 +1,218 @@
 #!
 #! Create a BlueBerry application.
 #!
 #! \brief This function will create a BlueBerry application together with all
 #! necessary provisioning and configuration data and install support.
 #!
 #! \param NAME (required) The name of the executable.
 #! \param DESCRIPTION (optional) A human-readable description of your application.
 #!        The usage depends on the CPack generator (on Windows, this is a descriptive
 #!        text for the created shortcuts).
 #! \param SOURCES (optional) A list of source files to compile into your executable. Defaults
 #!        to <name>.cpp.
 #! \param PLUGINS (optional) A list of required plug-ins. Defaults to all known plug-ins.
 #! \param EXCLUDE_PLUGINS (optional) A list of plug-ins which should not be used. Mainly
 #!        useful if PLUGINS was not used.
 #! \param LINK_LIBRARIES A list of libraries to be linked with the executable.
 #! \param LIBRARY_DIRS A list of directories to pass through to MITK_INSTALL_TARGETS
 #! \param SHOW_CONSOLE (option) Show the console output window (on Windows).
 #! \param NO_PROVISIONING (option) Do not create provisioning files.
 #! \param NO_INSTALL (option) Do not install this executable
 #!
 #! Assuming that there exists a file called <code>MyApp.cpp</code>, an example call looks like:
 #! \code
 #! mitkFunctionCreateBlueBerryApplication(
 #!   NAME MyApp
 #!   DESCRIPTION "MyApp - New ways to explore medical data"
 #!   EXCLUDE_PLUGINS org.mitk.gui.qt.extapplication
 #!   SHOW_CONSOLE
 #! )
 #! \endcode
 #!
 function(mitkFunctionCreateBlueBerryApplication)
 
 cmake_parse_arguments(_APP "SHOW_CONSOLE;NO_PROVISIONING;NO_INSTALL" "NAME;DESCRIPTION" "SOURCES;PLUGINS;EXCLUDE_PLUGINS;LINK_LIBRARIES;LIBRARY_DIRS" ${ARGN})
 
 if(NOT _APP_NAME)
   message(FATAL_ERROR "NAME argument cannot be empty.")
 endif()
 
 if(NOT _APP_SOURCES)
   set(_APP_SOURCES ${_APP_NAME}.cpp)
 endif()
 
 if(NOT _APP_PLUGINS)
   ctkFunctionGetAllPluginTargets(_APP_PLUGINS)
 else()
   set(_plugins ${_APP_PLUGINS})
   set(_APP_PLUGINS)
   foreach(_plugin ${_plugins})
     string(REPLACE "." "_" _plugin_target ${_plugin})
     list(APPEND _APP_PLUGINS ${_plugin_target})
   endforeach()
 
   # get all plug-in dependencies
   ctkFunctionGetPluginDependencies(_plugin_deps PLUGINS ${_APP_PLUGINS} ALL)
   # add the dependencies to the list of application plug-ins
   list(APPEND _APP_PLUGINS ${_plugin_deps})
 endif()
 
 # -----------------------------------------------------------------------
 # Set up include and link dirs for the executable
 # -----------------------------------------------------------------------
 
 include_directories(
   ${org_blueberry_core_runtime_INCLUDE_DIRS}
 )
 
 # -----------------------------------------------------------------------
 # Add executable icon (Windows)
 # -----------------------------------------------------------------------
 set(WINDOWS_ICON_RESOURCE_FILE "")
 if(WIN32)
   if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/icons/${_APP_NAME}.rc")
     set(WINDOWS_ICON_RESOURCE_FILE "${CMAKE_CURRENT_SOURCE_DIR}/icons/${_APP_NAME}.rc")
   endif()
 endif()
 
 # -----------------------------------------------------------------------
 # Create the executable and link libraries
 # -----------------------------------------------------------------------
 
 set(_app_compile_flags )
 if(WIN32)
   set(_app_compile_flags "${_app_compile_flags} -DPOCO_NO_UNWINDOWS -DWIN32_LEAN_AND_MEAN")
 endif()
 
 if(_APP_SHOW_CONSOLE)
   add_executable(${_APP_NAME} MACOSX_BUNDLE ${_APP_SOURCES} ${WINDOWS_ICON_RESOURCE_FILE})
 else()
   add_executable(${_APP_NAME} MACOSX_BUNDLE WIN32 ${_APP_SOURCES} ${WINDOWS_ICON_RESOURCE_FILE})
 endif()
-mitk_use_modules(TARGET ${_APP_NAME} MODULES mbilog PACKAGES Poco Qt5|Core)
+mitk_use_modules(TARGET ${_APP_NAME} MODULES MitkAppUtil)
 
 set_target_properties(${_APP_NAME} PROPERTIES
                       COMPILE_FLAGS "${_app_compile_flags}")
 
 target_link_libraries(${_APP_NAME} PRIVATE org_blueberry_core_runtime ${_APP_LINK_LIBRARIES})
 if(WIN32)
   target_link_libraries(${_APP_NAME} PRIVATE ${QT_QTMAIN_LIBRARY})
 endif()
 
 # -----------------------------------------------------------------------
 # Add executable icon and bundle name (Mac)
 # -----------------------------------------------------------------------
 if(APPLE)
   if( _APP_DESCRIPTION)
     set_target_properties(${_APP_NAME} PROPERTIES MACOSX_BUNDLE_NAME "${_APP_DESCRIPTION}")
   else()
     set_target_properties(${_APP_NAME} PROPERTIES MACOSX_BUNDLE_NAME "${_APP_NAME}")
   endif()
   set(icon_name "icon.icns")
   set(icon_full_path "${CMAKE_CURRENT_SOURCE_DIR}/icons/${icon_name}")
   if(EXISTS "${icon_full_path}")
     set_target_properties(${_APP_NAME} PROPERTIES MACOSX_BUNDLE_ICON_FILE "${icon_name}")
     file(COPY ${icon_full_path} DESTINATION "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${_APP_NAME}.app/Contents/Resources/")
     INSTALL (FILES ${icon_full_path} DESTINATION "${_APP_NAME}.app/Contents/Resources/")
   endif()
 endif()
 
 # -----------------------------------------------------------------------
 # Set build time dependencies
 # -----------------------------------------------------------------------
 
 # This ensures that all enabled plug-ins are up-to-date when the
 # executable is build.
 if(_APP_PLUGINS)
   ctkMacroGetAllProjectTargetLibraries("${_APP_PLUGINS}" _project_plugins)
   if(_APP_EXCLUDE_PLUGINS AND _project_plugins)
     set(_exclude_targets)
     foreach(_exclude_plugin ${_APP_EXCLUDE_PLUGINS})
       string(REPLACE "." "_" _exclude_target ${_exclude_plugin})
       list(APPEND _exclude_targets ${_exclude_target})
     endforeach()
     list(REMOVE_ITEM _project_plugins ${_exclude_targets})
   endif()
   if(_project_plugins)
     add_dependencies(${_APP_NAME} ${_project_plugins})
   endif()
 endif()
 
 # -----------------------------------------------------------------------
 # Additional files needed for the executable
 # -----------------------------------------------------------------------
 
 if(NOT _APP_NO_PROVISIONING)
 
   # Create a provisioning file, listing all plug-ins
   set(_prov_file "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${_APP_NAME}.provisioning")
   mitkFunctionCreateProvisioningFile(FILE ${_prov_file}
                                      PLUGINS ${_APP_PLUGINS}
                                      EXCLUDE_PLUGINS ${_APP_EXCLUDE_PLUGINS}
                                     )
 
 endif()
 
 # Create a .ini file for initial parameters
 if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${_APP_NAME}.ini")
   configure_file(${_APP_NAME}.ini
                  ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${_APP_NAME}.ini)
 endif()
 
 # Create batch and VS user files for Windows platforms
 include(mitkFunctionCreateWindowsBatchScript)
 
 if(WIN32)
   set(template_name "start${_APP_NAME}.bat.in")
   if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${template_name}")
     foreach(BUILD_TYPE debug release)
       mitkFunctionCreateWindowsBatchScript(${template_name}
         ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/start${_APP_NAME}_${BUILD_TYPE}.bat
         ${BUILD_TYPE})
     endforeach()
   endif()
   mitkFunctionConfigureVisualStudioUserProjectFile(
     NAME ${_APP_NAME}
   )
 endif(WIN32)
 
 # -----------------------------------------------------------------------
 # Install support
 # -----------------------------------------------------------------------
 
 if(NOT _APP_NO_INSTALL)
 
   # This installs all third-party CTK plug-ins
   mitkFunctionInstallThirdPartyCTKPlugins(${_APP_PLUGINS} EXCLUDE ${_APP_EXCLUDE_PLUGINS})
 
   if(COMMAND BlueBerryApplicationInstallHook)
     set(_real_app_plugins ${_APP_PLUGINS})
     if(_APP_EXCLUDE_PLUGINS)
       list(REMOVE_ITEM _real_app_plugins ${_APP_EXCLUDE_PLUGINS})
     endif()
     BlueBerryApplicationInstallHook(APP_NAME ${_APP_NAME} PLUGINS ${_real_app_plugins})
   endif()
 
   # Install the executable
   MITK_INSTALL_TARGETS(EXECUTABLES ${_APP_NAME} LIBRARY_DIRS ${_APP_LIBRARY_DIRS} GLOB_PLUGINS )
 
   if(NOT _APP_NO_PROVISIONING)
     # Install the provisioning file
     mitkFunctionInstallProvisioningFiles(${_prov_file})
   endif()
 
   # On Linux, create a shell script to start a relocatable application
   if(UNIX AND NOT APPLE)
     install(PROGRAMS "${MITK_SOURCE_DIR}/CMake/RunInstalledApp.sh" DESTINATION "." RENAME ${_APP_NAME}.sh)
   endif()
 
   # Tell cpack the executables that you want in the start menu as links
   set(MITK_CPACK_PACKAGE_EXECUTABLES ${MITK_CPACK_PACKAGE_EXECUTABLES} "${_APP_NAME};${_APP_DESCRIPTION}" CACHE INTERNAL "Collecting windows shortcuts to executables")
 
 endif()
 
 endfunction()
 
 function(FunctionCreateBlueBerryApplication)
   message(SEND_ERROR "The function FunctionCreateBlueBerryApplication was renamed to mitkFunctionCreateBlueBerryApplication in MITK 2015.05")
 endfunction()
diff --git a/Examples/BlueBerryExampleLauncher/CMakeLists.txt b/Examples/BlueBerryExampleLauncher/CMakeLists.txt
index e74077fe11..be7a0d47b9 100644
--- a/Examples/BlueBerryExampleLauncher/CMakeLists.txt
+++ b/Examples/BlueBerryExampleLauncher/CMakeLists.txt
@@ -1,85 +1,83 @@
 project(BlueBerryExampleLauncher)
 
 set(_source_files
   BlueBerryExampleLauncher.cpp
   BlueBerryExampleLauncherDialog.cpp
 )
 
 set(_source_moc_h_files
   BlueBerryExampleLauncherDialog.h
 )
 
 set(_source_ui_files
   BlueBerryExampleLauncherDialog.ui
 )
 
 # this is a workaround for Visual Studio. The relative include paths in the generated
 # moc files can get very long and can't be resolved by the MSVC compiler.
 foreach(_moc_src ${_source_moc_h_files})
   qt5_wrap_cpp(_source_files ${_moc_src} OPTIONS -f${_moc_src})
 endforeach()
 
 qt5_wrap_ui(_source_files ${_source_ui_files})
 
 include_directories(${CMAKE_CURRENT_SOURCE_DIR}
                     ${CMAKE_CURRENT_BINARY_DIR}
                    )
 
 #-----------------------------------------------------------------------------
 # Create provisioning files
 #-----------------------------------------------------------------------------
 
 set(_plugins_for_all_demos
 )
 
 file(GLOB _demo_configurations Configurations/*.cmake)
 
 set(ALL_REQUIRED_PLUGINS ${_plugins_for_all_demos})
 foreach(_demo_config_file ${_demo_configurations})
   set(REQUIRED_PLUGINS )
   set(DESCRIPTION )
   include(${_demo_config_file})
   get_filename_component(_name ${_demo_config_file} NAME_WE)
   mitkFunctionCreateProvisioningFile(FILE ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${PROJECT_NAME}_${_name}.provisioning
                                      PLUGINS ${REQUIRED_PLUGINS} ${_plugins_for_all_demos}
                                      NO_INSTALL
                                     )
   if(DESCRIPTION)
     configure_file(${CMAKE_CURRENT_SOURCE_DIR}/BlueBerryExampleDescription.txt
                    ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${PROJECT_NAME}_${_name}.txt @ONLY)
   endif()
   list(APPEND ALL_REQUIRED_PLUGINS ${REQUIRED_PLUGINS})
 endforeach()
 
 list(REMOVE_DUPLICATES ALL_REQUIRED_PLUGINS)
 set(ALL_REQUIRED_PLUGIN_TARGETS )
 foreach(req_plugin ${ALL_REQUIRED_PLUGINS})
   string(REPLACE "." "_" _plugin_target ${req_plugin})
   if(TARGET ${_plugin_target})
     list(APPEND ALL_REQUIRED_PLUGIN_TARGETS ${_plugin_target})
   endif()
 endforeach()
 
 #-----------------------------------------------------------------------------
 # Create the example launcher
 #-----------------------------------------------------------------------------
 
 mitkFunctionCreateBlueBerryApplication(
   NAME ${PROJECT_NAME}
   DESCRIPTION "MITK Application Framework Demo"
   SOURCES ${_source_files}
 #  PLUGINS ${ALL_REQUIRED_PLUGIN_TARGETS}
   NO_PROVISIONING
   NO_INSTALL
   SHOW_CONSOLE
 )
 
-mitk_use_modules(TARGET ${PROJECT_NAME} MODULES MitkAppUtil PACKAGES Qt5|Widgets)
-
 add_dependencies(${PROJECT_NAME} ${ALL_REQUIRED_PLUGIN_TARGETS})
 
 # subproject support
 set_property(TARGET ${PROJECT_NAME} PROPERTY LABELS ${MITK_DEFAULT_SUBPROJECTS})
 foreach(subproject ${MITK_DEFAULT_SUBPROJECTS})
   add_dependencies(${subproject} ${PROJECT_NAME})
 endforeach()