diff --git a/CMake/mitkMacroCreateModule.cmake b/CMake/mitkMacroCreateModule.cmake
index ff3ae2c99e..b7e78b1cff 100644
--- a/CMake/mitkMacroCreateModule.cmake
+++ b/CMake/mitkMacroCreateModule.cmake
@@ -1,215 +1,216 @@
 ##################################################################
 #
 # MITK_CREATE_MODULE 
 #
 #! Creates a module for the automatic module dependency system within MITK.
 #! Configurations are generated in the moduleConf directory. 
 #!
 #! USAGE:
 #!
 #! \code
 #! MITK_CREATE_MODULE( <moduleName>
 #!     [INCLUDE_DIRS <include directories>]
 #!     [INTERNAL_INCLUDE_DIRS <internally used include directories>]
 #!     [DEPENDS <modules we need>]
-#!     [PROVIDES <library name which is built>]
 #!     [PACKAGE_DEPENDS <packages we need, like ITK, VTK, QT>]
 #!     [TARGET_DEPENDS <list of additional dependencies>
 #!     [EXPORT_DEFINE <declspec macro name for dll exports>]
 #!     [QT_MODULE]
 #! \endcode
 #!
 #! \param MODULE_NAME_IN The name for the new module
 #
 ##################################################################
 MACRO(MITK_CREATE_MODULE MODULE_NAME_IN)
   MACRO_PARSE_ARGUMENTS(MODULE
-                        "SUBPROJECTS;INCLUDE_DIRS;INTERNAL_INCLUDE_DIRS;DEPENDS;DEPENDS_INTERNAL;PROVIDES;PACKAGE_DEPENDS;TARGET_DEPENDS;EXPORT_DEFINE;ADDITIONAL_LIBS;GENERATED_CPP"
+                        "SUBPROJECTS;INCLUDE_DIRS;INTERNAL_INCLUDE_DIRS;DEPENDS;DEPENDS_INTERNAL;PACKAGE_DEPENDS;TARGET_DEPENDS;EXPORT_DEFINE;ADDITIONAL_LIBS;GENERATED_CPP"
                         "QT_MODULE;FORCE_STATIC;HEADERS_ONLY"
                         ${ARGN})
                         
   SET(MODULE_NAME ${MODULE_NAME_IN})
-  
+ 
+  SET(MODULE_PROVIDES ${MODULE_NAME})
+
   IF(NOT MODULE_SUBPROJECTS)
     IF(MITK_DEFAULT_SUBPROJECTS)
       SET(MODULE_SUBPROJECTS ${MITK_DEFAULT_SUBPROJECTS})
     ENDIF()
   ENDIF()
   
   # check if the subprojects exist as targets
   IF(MODULE_SUBPROJECTS)
     FOREACH(subproject ${MODULE_SUBPROJECTS})
       IF(NOT TARGET ${subproject})
         MESSAGE(SEND_ERROR "The subproject ${subproject} does not have a corresponding target")
       ENDIF()
     ENDFOREACH()
   ENDIF()  
 
     
   
   # assume worst case
   SET(MODULE_IS_ENABLED 0)
   # first we check if we have an explicit module build list
   IF(MITK_MODULES_TO_BUILD)
     LIST(FIND MITK_MODULES_TO_BUILD ${MODULE_NAME} _MOD_INDEX)
     IF(_MOD_INDEX EQUAL -1)
       SET(MODULE_IS_EXCLUDED 1)
     ENDIF()
   ENDIF()
   IF(NOT MODULE_IS_EXCLUDED)
     # first of all we check for the dependencies
     MITK_CHECK_MODULE(_MISSING_DEP ${MODULE_DEPENDS})
     IF(_MISSING_DEP)
       MESSAGE("Module ${MODULE_NAME} won't be built, missing dependency: ${_MISSING_DEP}") 
       SET(MODULE_IS_ENABLED 0)
     ELSE(_MISSING_DEP)
       SET(MODULE_IS_ENABLED 1)
       # now check for every package if it is enabled. This overlaps a bit with
       # MITK_CHECK_MODULE ... 
       FOREACH(_package ${MODULE_PACKAGE_DEPENDS})
 	IF((DEFINED MITK_USE_${_package}) AND NOT (MITK_USE_${_package}))
 	  MESSAGE("Module ${MODULE_NAME} won't be built. Turn on MITK_USE_${_package} if you want to use it.")
 	  SET(MODULE_IS_ENABLED 0)
 	ENDIF()  
       ENDFOREACH()
       IF(MODULE_IS_ENABLED)
 	IF(NOT MODULE_QT_MODULE OR MITK_USE_QT)
 	  SET(MODULE_IS_ENABLED 1)
 	  _MITK_CREATE_MODULE_CONF()
 	  IF(NOT MODULE_EXPORT_DEFINE)
 	    SET(MODULE_EXPORT_DEFINE ${MODULE_NAME}_EXPORT)
 	  ENDIF(NOT MODULE_EXPORT_DEFINE)
 	  CONFIGURE_FILE(${MITK_SOURCE_DIR}/CMake/moduleExports.h.in ${MITK_MODULES_CONF_DIR}/${MODULE_NAME}Exports.h @ONLY)
 	
 	  IF(MITK_GENERATE_MODULE_DOT)
 	    MESSAGE("MODULEDOTNAME ${MODULE_NAME}")
 	    FOREACH(dep ${MODULE_DEPENDS})
 	      MESSAGE("MODULEDOT \"${MODULE_NAME}\" -> \"${dep}\" ; ")
 	    ENDFOREACH(dep)
 	  ENDIF(MITK_GENERATE_MODULE_DOT)
        
 	  SET(DEPENDS "${MODULE_DEPENDS}") 
 	  SET(DEPENDS_BEFORE "not initialized")
 	  SET(PACKAGE_DEPENDS "${MODULE_PACKAGE_DEPENDS}")
 	  MITK_USE_MODULE("${MODULE_DEPENDS}") 
 	
 	  # ok, now create the module itself 
 	  INCLUDE_DIRECTORIES(. ${ALL_INCLUDE_DIRECTORIES})
 	  INCLUDE(files.cmake)
 	
 	  IF(NOT MODULE_QT_MODULE)
 	    ORGANIZE_SOURCES(SOURCE ${CPP_FILES}
 			     HEADER ${H_FILES}
 			     TXX ${TXX_FILES}
 			     DOC ${DOX_FILES}
 			     )
 
 	    IF(MODULE_FORCE_STATIC)
 	      SET(_STATIC ${MITK_WIN32_FORCE_STATIC})
 	    ENDIF(MODULE_FORCE_STATIC)
 	    
 	    SET(coverage_sources ${CPP_FILES} ${H_FILES} ${GLOBBED__H_FILES} ${CORRESPONDING__H_FILES} ${TXX_FILES} ${TOOL_CPPS}) 
 	    IF(MODULE_SUBPROJECTS)
 	      SET_PROPERTY(SOURCE ${coverage_sources} APPEND PROPERTY LABELS ${MODULE_SUBPROJECTS} MITK)
 	    ENDIF()
 
 	    IF(NOT MODULE_HEADERS_ONLY)
 	      IF(ALL_LIBRARY_DIRS)
 		# LINK_DIRECTORIES applies only to targets which are added after the call to LINK_DIRECTORIES
 		LINK_DIRECTORIES(${ALL_LIBRARY_DIRS})
 	      ENDIF(ALL_LIBRARY_DIRS)
 	      ADD_LIBRARY(${MODULE_PROVIDES} ${_STATIC} ${coverage_sources} ${CPP_FILES_GENERATED} ${DOX_FILES} ${UI_FILES})
         IF(MODULE_TARGET_DEPENDS)
           ADD_DEPENDENCIES(${MODULE_PROVIDES} ${MODULE_TARGET_DEPENDS})
         ENDIF()
 	      IF(MODULE_SUBPROJECTS)
 		SET_PROPERTY(TARGET ${MODULE_PROVIDES} PROPERTY LABELS ${MODULE_SUBPROJECTS} MITK)
 		FOREACH(subproject ${MODULE_SUBPROJECTS})
 		  ADD_DEPENDENCIES(${subproject} ${MODULE_PROVIDES})
 		ENDFOREACH()
 	      ENDIF()
 	      IF(ALL_LIBRARIES)
 		TARGET_LINK_LIBRARIES(${MODULE_PROVIDES} ${ALL_LIBRARIES})
 	      ENDIF(ALL_LIBRARIES)  
 
 	      IF(MINGW)
 		TARGET_LINK_LIBRARIES(${MODULE_PROVIDES} ssp) # add stack smash protection lib
 	      ENDIF()
 	    ENDIF()
 	
 	  ELSE(NOT MODULE_QT_MODULE)
 
 	    INCLUDE(files.cmake)
 	
 	    IF(UI_FILES)
 	      QT4_WRAP_UI(Q${KITNAME}_GENERATED_UI_CPP ${UI_FILES})
 	    ENDIF(UI_FILES)
 	
 	    IF(MOC_H_FILES)
 	      QT4_WRAP_CPP(Q${KITNAME}_GENERATED_MOC_CPP ${MOC_H_FILES})
 	    ENDIF(MOC_H_FILES)
 	
 	    IF(QRC_FILES)
 	      QT4_ADD_RESOURCES(Q${KITNAME}_GENERATED_QRC_CPP ${QRC_FILES})
 	    ENDIF(QRC_FILES)
 	
 	    SET(Q${KITNAME}_GENERATED_CPP ${Q${KITNAME}_GENERATED_CPP} ${Q${KITNAME}_GENERATED_UI_CPP} ${Q${KITNAME}_GENERATED_MOC_CPP} ${Q${KITNAME}_GENERATED_QRC_CPP})
 	
 	    ORGANIZE_SOURCES(SOURCE ${CPP_FILES} 
 			     HEADER ${H_FILES}
 			     TXX ${TXX_FILES}
 			     DOC ${DOX_FILES}
 			     UI ${UI_FILES}
 			     QRC ${QRC_FILES}
 			     MOC ${Q${KITNAME}_GENERATED_MOC_CPP}
 			     GEN_QRC ${Q${KITNAME}_GENERATED_QRC_CPP}
 			     GEN_UI ${Q${KITNAME}_GENERATED_UI_CPP})
 
 	    # MITK_GENERATE_TOOLS_LIBRARY(Qmitk${LIBPOSTFIX} "NO")
 
 	    SET(coverage_sources ${CPP_FILES} ${CORRESPONDING__H_FILES} ${GLOBBED__H_FILES} ${TXX_FILES} ${TOOL_GUI_CPPS})
 	    SET_PROPERTY(SOURCE ${coverage_sources} APPEND PROPERTY LABELS ${MODULE_SUBPROJECTS})
 	
 	    IF(NOT MODULE_HEADERS_ONLY)
 	      IF(ALL_LIBRARY_DIRS)
 		# LINK_DIRECTORIES applies only to targets which are added after the call to LINK_DIRECTORIES
 		LINK_DIRECTORIES(${ALL_LIBRARY_DIRS})
 	      ENDIF(ALL_LIBRARY_DIRS)
 	      ADD_LIBRARY(${MODULE_PROVIDES} ${coverage_sources} ${CPP_FILES_GENERATED} ${Q${KITNAME}_GENERATED_CPP} ${DOX_FILES} ${UI_FILES} ${QRC_FILES})
 	      TARGET_LINK_LIBRARIES(${MODULE_PROVIDES} ${QT_LIBRARIES} ${ALL_LIBRARIES} QVTK)
         IF(MODULE_TARGET_DEPENDS)
           ADD_DEPENDENCIES(${MODULE_PROVIDES} ${MODULE_TARGET_DEPENDS})
         ENDIF()
 	      IF(MINGW)
 		TARGET_LINK_LIBRARIES(${MODULE_PROVIDES} ssp) # add stack smash protection lib
 	      ENDIF()
 	      IF(MODULE_SUBPROJECTS)
 		SET_PROPERTY(TARGET ${MODULE_PROVIDES} PROPERTY LABELS ${MODULE_SUBPROJECTS} MITK)
 		FOREACH(subproject ${MODULE_SUBPROJECTS})
 		  ADD_DEPENDENCIES(${subproject} ${MODULE_PROVIDES})
 		ENDFOREACH()
 	      ENDIF()
 	    ENDIF()
 	
 	  ENDIF(NOT MODULE_QT_MODULE) 
 
 	  #IF(NOT MODULE_HEADERS_ONLY AND TARGET EP_MITK)
 	  #  ADD_DEPENDENCIES(${MODULE_PROVIDES} EP_MITK)
 	  #ENDIF()
 
 	  # install only if shared lib (for now)
 	  IF(NOT _STATIC OR MINGW)
 	    IF(NOT MODULE_HEADERS_ONLY)
 	     # # deprecated: MITK_INSTALL_TARGETS(${MODULE_PROVIDES})
 	    ENDIF()
 	  ENDIF(NOT _STATIC OR MINGW)
 	  
 	ENDIF(NOT MODULE_QT_MODULE OR MITK_USE_QT)
       ENDIF(MODULE_IS_ENABLED)
     ENDIF(_MISSING_DEP)
   ENDIF(NOT MODULE_IS_EXCLUDED)
     
   IF(NOT MODULE_IS_ENABLED)   
     _MITK_CREATE_MODULE_CONF()
   ENDIF(NOT MODULE_IS_ENABLED)   
 ENDMACRO(MITK_CREATE_MODULE)
diff --git a/CMake/mitkMacroCreateModuleConf.cmake b/CMake/mitkMacroCreateModuleConf.cmake
index 826659de85..38d79c2bb3 100644
--- a/CMake/mitkMacroCreateModuleConf.cmake
+++ b/CMake/mitkMacroCreateModuleConf.cmake
@@ -1,38 +1,38 @@
 ###################################################################
 #
 # MITK_CREATE_MODULE_CONF 
 # 
 # This can be called in a similar way like MITK_CREATE_MODULE
 # but it just creates the module configuration files without
 # actually building it. It is used for integration of legacy libraries
 # into the MITK module build system
 #
 ##################################################################
 MACRO(MITK_CREATE_MODULE_CONF MODULE_NAME_IN)
-  MACRO_PARSE_ARGUMENTS(MODULE "INCLUDE_DIRS;DEPENDS;PROVIDES" "QT_MODULE;HEADERS_ONLY" ${ARGN})
+  MACRO_PARSE_ARGUMENTS(MODULE "INCLUDE_DIRS;DEPENDS;" "QT_MODULE;HEADERS_ONLY" ${ARGN})
   SET(MODULE_NAME ${MODULE_NAME_IN})
   SET(MODULE_IS_ENABLED 1)
   _MITK_CREATE_MODULE_CONF()
 ENDMACRO(MITK_CREATE_MODULE_CONF)
 
 MACRO(_MITK_CREATE_MODULE_CONF)
   IF(NOT MODULE_QT_MODULE OR MITK_USE_QT)
-    IF(NOT MODULE_PROVIDES AND NOT MODULE_HEADERS_ONLY)
+    IF(NOT MODULE_HEADERS_ONLY)
       SET(MODULE_PROVIDES ${MODULE_NAME})
-    ENDIF(NOT MODULE_PROVIDES AND NOT MODULE_HEADERS_ONLY)
+    ENDIF(NOT MODULE_HEADERS_ONLY)
     SET(MODULE_INCLUDE_DIRS_ABSOLUTE "")
     FOREACH(dir ${MODULE_INCLUDE_DIRS})
       GET_FILENAME_COMPONENT(abs_dir ${dir} ABSOLUTE)
       SET(MODULE_INCLUDE_DIRS_ABSOLUTE ${MODULE_INCLUDE_DIRS_ABSOLUTE} ${abs_dir})
     ENDFOREACH(dir)
 
     SET(MODULE_INCLUDE_DIRS ${MODULE_INCLUDE_DIRS_ABSOLUTE} ${CMAKE_CURRENT_SOURCE_DIR})
     
     # Qt generates headers in the binary tree
     IF(MODULE_QT_MODULE)
       SET(MODULE_INCLUDE_DIRS ${MODULE_INCLUDE_DIRS} ${CMAKE_CURRENT_BINARY_DIR})
     ENDIF(MODULE_QT_MODULE)
     
     CONFIGURE_FILE(${MITK_SOURCE_DIR}/CMake/moduleConf.cmake.in ${MITK_MODULES_CONF_DIR}/${MODULE_NAME}Config.cmake @ONLY)
   ENDIF(NOT MODULE_QT_MODULE OR MITK_USE_QT)
 ENDMACRO(_MITK_CREATE_MODULE_CONF)
diff --git a/Core/Code/CMakeLists.txt b/Core/Code/CMakeLists.txt
index 2600d7a628..323efcb47b 100644
--- a/Core/Code/CMakeLists.txt
+++ b/Core/Code/CMakeLists.txt
@@ -1,53 +1,53 @@
 FIND_PACKAGE(OpenGL)
 IF(NOT OPENGL_FOUND)
   MESSAGE("GL is required for MITK rendering")
 ENDIF(NOT OPENGL_FOUND )
 
 SET(TOOL_CPPS "")
 
 MITK_CREATE_MODULE( Mitk
   INCLUDE_DIRS Algorithms DataManagement Controllers Interactions IO Rendering ${MITK_BINARY_DIR}
   INTERNAL_INCLUDE_DIRS ${OPENGL_INCLUDE_DIR} ${IPSEGMENTATION_INCLUDE_DIR} ${ANN_INCLUDE_DIR}
-  PROVIDES mitkCore
   DEPENDS mitkIpFunc mbilog tinyxml 
   DEPENDS_INTERNAL IIL4MITK pic2vtk
   PACKAGE_DEPENDS ITK VTK
   EXPORT_DEFINE MITK_CORE_EXPORT
 )
 
 # this is needed for libraries which link to mitkCore and need
 # symbols from explicitly instantiated templates like
 # mitk::SurfaceVtkWriter<vtkSTLWriter> which is referenced in
 # QmitkCommonFunctionality in the QmitkExt library.
 IF(MINGW)
-  GET_TARGET_PROPERTY(_mitkCore_MINGW_linkflags mitkCore LINK_FLAGS)
+  GET_TARGET_PROPERTY(_mitkCore_MINGW_linkflags Mitk LINK_FLAGS)
   IF(NOT _mitkCore_MINGW_linkflags)
     SET(_mitkCore_MINGW_linkflags "")
   ENDIF(NOT _mitkCore_MINGW_linkflags)
-  SET_TARGET_PROPERTIES(mitkCore PROPERTIES LINK_FLAGS "${_mitkCore_MINGW_linkflags} -Wl,--export-all-symbols")
+  SET_TARGET_PROPERTIES(Mitk PROPERTIES LINK_FLAGS "${_mitkCore_MINGW_linkflags} -Wl,--export-all-symbols")
 ENDIF(MINGW)
 
-TARGET_LINK_LIBRARIES(mitkCore ${LIBRARIES_FOR_${KITNAME}_CORE}  ${IPFUNC_LIBRARY} ipSegmentation ann)
-TARGET_LINK_LIBRARIES(mitkCore ${OPENGL_LIBRARIES} )
+# replacing mitkCore by Mitk [due to removing the PROVIDES macro
+TARGET_LINK_LIBRARIES(Mitk ${LIBRARIES_FOR_${KITNAME}_CORE}  ${IPFUNC_LIBRARY} ipSegmentation ann)
+TARGET_LINK_LIBRARIES(Mitk ${OPENGL_LIBRARIES} )
 
 IF(MSVC_IDE OR MSVC_VERSION OR MINGW)
   TARGET_LINK_LIBRARIES(mitkCore psapi.lib)
 ENDIF(MSVC_IDE OR MSVC_VERSION OR MINGW)
 
 
 # verify ITK has been built with GDCM >= 2.0.14
 set(GDCM_FULL_VERSION "${GDCM_MAJOR_VERSION}.${GDCM_MINOR_VERSION}.${GDCM_BUILD_VERSION}")
 set(MITK_REQUIRED_GDCM_VERSION "2.0.14")
 if(GDCM_FULL_VERSION VERSION_LESS MITK_REQUIRED_GDCM_VERSION)
   message(SEND_ERROR "mitkCore: MITK requires ITK with at least GDCM version ${MITK_REQUIRED_GDCM_VERSION}.\nFound version ${GDCM_FULL_VERSION} (GDCM NOT found if you don't see a version here)")
 else(GDCM_FULL_VERSION VERSION_LESS MITK_REQUIRED_GDCM_VERSION)
   message(STATUS "mitkCore: Found GDCM version ${GDCM_FULL_VERSION}")
 endif(GDCM_FULL_VERSION VERSION_LESS MITK_REQUIRED_GDCM_VERSION)
 
 
 # build tests?
 OPTION(BUILD_TESTING "Build the MITK Core tests." ON)
 IF(BUILD_TESTING)
 ENABLE_TESTING()
 ADD_SUBDIRECTORY(Testing)
 ENDIF(BUILD_TESTING)
diff --git a/Modules/CameraCalibration/CMakeLists.txt b/Modules/CameraCalibration/CMakeLists.txt
index 660bc72afb..c3ac2c38b7 100644
--- a/Modules/CameraCalibration/CMakeLists.txt
+++ b/Modules/CameraCalibration/CMakeLists.txt
@@ -1,8 +1,7 @@
 MITK_CREATE_MODULE(mitkCameraCalibration
   DEPENDS MitkIGT
   PACKAGE_DEPENDS OpenCV
-  PROVIDES mitkCameraCalibration
 )
 
 # add testing dir
 ADD_SUBDIRECTORY(Testing)
\ No newline at end of file
diff --git a/Modules/DeformableRegistration/CMakeLists.txt b/Modules/DeformableRegistration/CMakeLists.txt
index 3bba8ee0c0..1ed6daac9c 100644
--- a/Modules/DeformableRegistration/CMakeLists.txt
+++ b/Modules/DeformableRegistration/CMakeLists.txt
@@ -1,8 +1,7 @@
 MITK_CREATE_MODULE(MitkDeformableRegistration
   SUBPROJECTS MITK-Registration
   DEPENDS Mitk MitkRigidRegistration
-  PROVIDES MitkDeformableRegistration
   EXPORT_DEFINE MITK_DEFORMABLEREGISTRATION_EXPORT
 )
 
 ADD_SUBDIRECTORY(Testing)
diff --git a/Modules/DeformableRegistrationUI/CMakeLists.txt b/Modules/DeformableRegistrationUI/CMakeLists.txt
index f586ab68d0..89c824517c 100644
--- a/Modules/DeformableRegistrationUI/CMakeLists.txt
+++ b/Modules/DeformableRegistrationUI/CMakeLists.txt
@@ -1,7 +1,6 @@
 MITK_CREATE_MODULE(MitkDeformableRegistrationUI
   SUBPROJECTS MITK-Registration
   DEPENDS Qmitk MitkDeformableRegistration
   QT_MODULE
-  PROVIDES MitkDeformableRegistrationUI
   EXPORT_DEFINE MITK_DEFORMABLEREGISTRATION_UI_EXPORT
 )
diff --git a/Modules/IGT/CMakeLists.txt b/Modules/IGT/CMakeLists.txt
index f01dd52f60..978bd113cc 100644
--- a/Modules/IGT/CMakeLists.txt
+++ b/Modules/IGT/CMakeLists.txt
@@ -1,37 +1,35 @@
 INCLUDE(MITKIGTHardware.cmake)
 
 IF(MITK_USE_MICRON_TRACKER)
   SET(INCLUDE_DIRS_INTERNAL ${INCLUDE_DIRS_INTERNAL} ${MITK_MICRON_TRACKER_INCLUDE_DIR})
   SET(ADDITIONAL_LIBS ${ADDITIONAL_LIBS} ${MITK_MICRON_TRACKER_LIB})
 ENDIF(MITK_USE_MICRON_TRACKER)
 
 IF(MITK_USE_MICROBIRD_TRACKER)
   SET(INCLUDE_DIRS_INTERNAL ${INCLUDE_DIRS_INTERNAL} ${MITK_USE_MICROBIRD_TRACKER_INCLUDE_DIR})
   SET(ADDITIONAL_LIBS ${ADDITIONAL_LIBS} ${MITK_USE_MICROBIRD_TRACKER_LIB})
 ENDIF(MITK_USE_MICROBIRD_TRACKER)
 
 MITK_CREATE_MODULE(MitkIGT
   SUBPROJECTS MITK-IGT
   INCLUDE_DIRS IGTFilters IGTTrackingDevices IGTToolManagement
   INTERNAL_INCLUDE_DIRS ${INCLUDE_DIRS_INTERNAL}
   DEPENDS Mitk tinyxml SceneSerialization
-  PROVIDES mitkIGT
   ADDITIONAL_LIBS "${ADDITIONAL_LIBS}"
 )
 
 
 MITK_CHECK_MODULE(_RESULT MitkIGT)
 IF(_RESULT)
   MESSAGE(STATUS "IGTTutorialStep1 won't be built. Missing: ${_RESULT}")
 ELSE(_RESULT)
 ## create IGT config
 CONFIGURE_FILE(mitkIGTConfig.h.in ${PROJECT_BINARY_DIR}/mitkIGTConfig.h @ONLY)
 
 # add test programm for serial communication classADD_EXECUTABLE(SerialCommunicationTest IGTTrackingDevices/mitkSerialCommunicationTest.cpp)TARGET_LINK_LIBRARIES(SerialCommunicationTest mitkIGT mitkCore tinyxml PocoXML)
 
-ADD_EXECUTABLE (IGTTutorialStep1 IGTTutorial/IGTTutorialStep1.cpp)
-TARGET_LINK_LIBRARIES(IGTTutorialStep1 mitkIGT mitkCore tinyxml PocoXML)
+ADD_SUBDIRECTORY(IGTTutorial)
 
 ADD_SUBDIRECTORY(Testing)
 ENDIF(_RESULT)
 
diff --git a/Modules/IGT/IGTTutorial/CMakeLists.txt b/Modules/IGT/IGTTutorial/CMakeLists.txt
index 8b13789179..60dde48726 100644
--- a/Modules/IGT/IGTTutorial/CMakeLists.txt
+++ b/Modules/IGT/IGTTutorial/CMakeLists.txt
@@ -1 +1,4 @@
+MITK_USE_MODULE(MitkIGT)
 
+ADD_EXECUTABLE(IGTTutorialStep1 IGTTutorialStep1.cpp)
+TARGET_LINK_LIBRARIES(IGTTutorialStep1 ${ALL_LIBRARIES})
diff --git a/Modules/IGTUI/CMakeLists.txt b/Modules/IGTUI/CMakeLists.txt
index a748a81d18..276cb54902 100644
--- a/Modules/IGTUI/CMakeLists.txt
+++ b/Modules/IGTUI/CMakeLists.txt
@@ -1,13 +1,12 @@
 MITK_CREATE_MODULE(MitkIGTUI
   SUBPROJECTS MITK-IGT
   INCLUDE_DIRS Qmitk
   DEPENDS MitkIGT Qmitk QmitkExt
-  PROVIDES mitkIGTUI
   QT_MODULE
   GENERATED_CPP ${TOOL_GUI_CPPS} ${TOOL_CPPS}
 )
 
 ## create IGTUI config
 CONFIGURE_FILE(mitkIGTUIConfig.h.in ${PROJECT_BINARY_DIR}/mitkIGTUIConfig.h @ONLY)
 
 
diff --git a/Modules/ImageExtraction/CMakeLists.txt b/Modules/ImageExtraction/CMakeLists.txt
index 0658e11e7b..c34d8d087e 100644
--- a/Modules/ImageExtraction/CMakeLists.txt
+++ b/Modules/ImageExtraction/CMakeLists.txt
@@ -1,11 +1,10 @@
 MITK_CREATE_MODULE( ImageExtraction
                DEPENDS Mitk PlanarFigure
                DEPENDS_INTERNAL pic2vtk
-               PROVIDES ImageExtraction
 )
 
 IF(BUILD_TESTING)
 
   ADD_SUBDIRECTORY(Testing)
 
 ENDIF(BUILD_TESTING)
diff --git a/Modules/ImageStatistics/CMakeLists.txt b/Modules/ImageStatistics/CMakeLists.txt
index 905447b0d9..e45492ad8b 100644
--- a/Modules/ImageStatistics/CMakeLists.txt
+++ b/Modules/ImageStatistics/CMakeLists.txt
@@ -1,10 +1,9 @@
 MITK_CREATE_MODULE( ImageStatistics
                DEPENDS Mitk ImageExtraction PlanarFigure
-               PROVIDES ImageStatistics
 )
 
 IF(BUILD_TESTING)
 
   ADD_SUBDIRECTORY(Testing)
 
 ENDIF(BUILD_TESTING)
diff --git a/Modules/MitkExt/CMakeLists.txt b/Modules/MitkExt/CMakeLists.txt
index 3a9e50c4ea..0183ebae65 100644
--- a/Modules/MitkExt/CMakeLists.txt
+++ b/Modules/MitkExt/CMakeLists.txt
@@ -1,29 +1,28 @@
 #IF(WIN32)
 #  OPTION(MITK_USE_TD_MOUSE "Enable support for 3D Connexion SpaceNavigator" OFF)
 #ENDIF(WIN32)
 
 CONFIGURE_FILE(${PROJECT_SOURCE_DIR}/CMake/ToolExtensionITKFactory.cpp.in ${PROJECT_BINARY_DIR}/ToolExtensionITKFactory.cpp.in COPYONLY)
 CONFIGURE_FILE(${PROJECT_SOURCE_DIR}/CMake/ToolExtensionITKFactoryLoader.cpp.in ${PROJECT_BINARY_DIR}/ToolExtensionITKFactoryLoader.cpp.in COPYONLY)
 CONFIGURE_FILE(${PROJECT_SOURCE_DIR}/CMake/ToolGUIExtensionITKFactory.cpp.in ${PROJECT_BINARY_DIR}/ToolGUIExtensionITKFactory.cpp.in COPYONLY)
 
 MITK_CREATE_MODULE( MitkExt
                INCLUDE_DIRS Algorithms Controllers DataManagement Interactions IO Rendering
                DEPENDS Mitk ipSegmentation PlanarFigure ImageStatistics
                DEPENDS_INTERNAL pic2vtk IIL4MITK
-               PROVIDES mitkCoreExt
 )
 
 # this is needed for libraries which link to mitkCoreExt and need
 # symbols from explicitly instantiated templates like
 # mitk::UnstructuredGridVtkWriter<vtkUnstructuredGridWriter> which is referenced in
 # mitk::UnstructuredGridVtkWriterTest in the MitkExtTestDriver executable.
 IF(MINGW)
   GET_TARGET_PROPERTY(_mitkCoreExt_MINGW_linkflags mitkCoreExt LINK_FLAGS)
   IF(NOT _mitkCoreExt_MINGW_linkflags)
     SET(_mitkCoreExt_MINGW_linkflags "")
   ENDIF(NOT _mitkCoreExt_MINGW_linkflags)
   SET_TARGET_PROPERTIES(mitkCoreExt PROPERTIES LINK_FLAGS "${_mitkCoreExt_MINGW_linkflags} -Wl,--export-all-symbols")
 ENDIF(MINGW)
 
 ADD_SUBDIRECTORY(Testing)
 
diff --git a/Modules/OpenCVVideoSupport/CMakeLists.txt b/Modules/OpenCVVideoSupport/CMakeLists.txt
index 73acfadb1d..3c134e5a21 100644
--- a/Modules/OpenCVVideoSupport/CMakeLists.txt
+++ b/Modules/OpenCVVideoSupport/CMakeLists.txt
@@ -1,26 +1,25 @@
 
 IF(MITK_USE_OpenCV)
 
   SET(dependencies OpenCV)
   IF(MITK_USE_videoInput)
     SET(dependencies ${dependencies} videoInput)  
   ENDIF(MITK_USE_videoInput)
 
   MITK_CREATE_MODULE(mitkOpenCVVideoSupport
     DEPENDS Mitk MitkExt
     PACKAGE_DEPENDS ${dependencies}
-    PROVIDES mitkOpenCVVideoSupport
     ADDITIONAL_LIBS ${OPENCVVIDEOSUPPORT_ADDITIONAL_LIBS}
     EXPORT_DEFINE MITK_OPENCVVIDEOSUPPORT_EXPORT
   )
   
   IF(MITK_USE_QT)
     ADD_SUBDIRECTORY(UI)
   ENDIF(MITK_USE_QT)  
     
   IF(BUILD_TESTING)
     ADD_SUBDIRECTORY(Testing)
   ENDIF(BUILD_TESTING)
 
 ENDIF(MITK_USE_OpenCV)
 
diff --git a/Modules/OpenCVVideoSupport/UI/CMakeLists.txt b/Modules/OpenCVVideoSupport/UI/CMakeLists.txt
index 64347d9f04..7e195e3ab2 100644
--- a/Modules/OpenCVVideoSupport/UI/CMakeLists.txt
+++ b/Modules/OpenCVVideoSupport/UI/CMakeLists.txt
@@ -1,12 +1,11 @@
 MITK_CREATE_MODULE(mitkOpenCVVideoSupportUI
   DEPENDS MitkExt QmitkExt mitkOpenCVVideoSupport
   PACKAGE_DEPENDS QT
   QT_MODULE
-  PROVIDES mitkOpenCVVideoSupportUI
   EXPORT_DEFINE MITK_OPENCVVIDEOSUPPORTUI_EXPORT
 )
 
 # no tests yet
 #IF(BUILD_TESTING)
 	#ADD_SUBDIRECTORY(Testing)
 #ENDIF(BUILD_TESTING)
\ No newline at end of file
diff --git a/Modules/RigidRegistration/CMakeLists.txt b/Modules/RigidRegistration/CMakeLists.txt
index 1618ef4b52..592908debc 100644
--- a/Modules/RigidRegistration/CMakeLists.txt
+++ b/Modules/RigidRegistration/CMakeLists.txt
@@ -1,8 +1,7 @@
 MITK_CREATE_MODULE(MitkRigidRegistration
   SUBPROJECTS MITK-Registration
   DEPENDS Mitk
-  PROVIDES MitkRigidRegistration
   EXPORT_DEFINE MITK_RIGIDREGISTRATION_EXPORT
 )
 
 ADD_SUBDIRECTORY(Testing)
diff --git a/Modules/RigidRegistrationUI/CMakeLists.txt b/Modules/RigidRegistrationUI/CMakeLists.txt
index 8eb8586bc6..7edd59da5c 100644
--- a/Modules/RigidRegistrationUI/CMakeLists.txt
+++ b/Modules/RigidRegistrationUI/CMakeLists.txt
@@ -1,8 +1,7 @@
 MITK_CREATE_MODULE(MitkRigidRegistrationUI
   SUBPROJECTS MITK-Registration
   INCLUDE_DIRS RigidRegistrationMetrics RigidRegistrationOptimizer RigidRegistrationTransforms
   DEPENDS Qmitk MitkRigidRegistration
   QT_MODULE
-  PROVIDES MitkRigidRegistrationUI
   EXPORT_DEFINE MITK_RIGIDREGISTRATION_UI_EXPORT
 )
diff --git a/Modules/ToFHardware/CMakeLists.txt b/Modules/ToFHardware/CMakeLists.txt
index f7e4fcf55a..89c55c41c3 100644
--- a/Modules/ToFHardware/CMakeLists.txt
+++ b/Modules/ToFHardware/CMakeLists.txt
@@ -1,35 +1,34 @@
 INCLUDE(mitkToFHardware.cmake)
 
 IF(MITK_USE_TOF_PMDCAMCUBE)
   SET(INCLUDE_DIRS_INTERNAL ${INCLUDE_DIRS_INTERNAL} ${MITK_PMD_SDK_DIR}/include)
   SET(ADDITIONAL_LIBS ${ADDITIONAL_LIBS} ${MITK_PMD_LIB})
 ENDIF(MITK_USE_TOF_PMDCAMCUBE)
 
 IF(MITK_USE_TOF_O3)
   SET(INCLUDE_DIRS_INTERNAL ${INCLUDE_DIRS_INTERNAL} ${MITK_PMD_SDK_DIR}/include)
   SET(ADDITIONAL_LIBS ${ADDITIONAL_LIBS} ${MITK_PMD_LIB})
 ENDIF(MITK_USE_TOF_O3)
 
 IF(MITK_USE_TOF_PMDCAMBOARD)
   SET(INCLUDE_DIRS_INTERNAL ${INCLUDE_DIRS_INTERNAL} ${MITK_PMD_SDK_DIR}/include)
   SET(ADDITIONAL_LIBS ${ADDITIONAL_LIBS} ${MITK_PMD_LIB})
 ENDIF(MITK_USE_TOF_PMDCAMBOARD)
 
 IF(MITK_USE_TOF_MESASR4000)
   SET(INCLUDE_DIRS_INTERNAL ${INCLUDE_DIRS_INTERNAL} ${MITK_MESA_SDK_DIR}/include)
   SET(ADDITIONAL_LIBS ${ADDITIONAL_LIBS} ${MITK_MESA_LIB})
 ENDIF(MITK_USE_TOF_MESASR4000)
 
 MITK_CREATE_MODULE(mitkToFHardware
   SUBPROJECTS MITK-ToF
   INCLUDE_DIRS ${MITK_BIN_DIR}
   INTERNAL_INCLUDE_DIRS ${INCLUDE_DIRS_INTERNAL}
   DEPENDS Mitk MitkExt mitkOpenCVVideoSupport MitkIGT 
-  PROVIDES mitkToFHardware
   EXPORT_DEFINE MITK_TOFHARDWARE_EXPORT
   ADDITIONAL_LIBS ${ADDITIONAL_LIBS}
 )
 
 ADD_SUBDIRECTORY(Testing)
 
  
diff --git a/Modules/ToFProcessing/CMakeLists.txt b/Modules/ToFProcessing/CMakeLists.txt
index d1df90e238..b33d161d55 100644
--- a/Modules/ToFProcessing/CMakeLists.txt
+++ b/Modules/ToFProcessing/CMakeLists.txt
@@ -1,13 +1,12 @@
 MITK_CREATE_MODULE(mitkToFProcessing
     SUBPROJECTS MITK-ToF
     DEPENDS Mitk MitkExt mitkCameraCalibration
     PACKAGE_DEPENDS OpenCV
-    PROVIDES mitkToFProcessing
   )
   
 IF(BUILD_TESTING)
 
   ADD_SUBDIRECTORY(Testing)
 
 ENDIF(BUILD_TESTING)
 
diff --git a/Modules/ToFUI/CMakeLists.txt b/Modules/ToFUI/CMakeLists.txt
index 1587a7c5a8..9f165e73c1 100644
--- a/Modules/ToFUI/CMakeLists.txt
+++ b/Modules/ToFUI/CMakeLists.txt
@@ -1,9 +1,8 @@
 MITK_CREATE_MODULE(mitkTOFUI
   SUBPROJECTS MITK-ToF
   INCLUDE_DIRS Qmitk
   DEPENDS mitkToFHardware mitkToFProcessing Qmitk QmitkExt
-  PROVIDES mitkTOFUI
   QT_MODULE
   GENERATED_CPP ${TOOL_GUI_CPPS} ${TOOL_CPPS}
 )
 
diff --git a/Utilities/glew/CMakeLists.txt b/Utilities/glew/CMakeLists.txt
index a90d8714d8..92772ef4d8 100644
--- a/Utilities/glew/CMakeLists.txt
+++ b/Utilities/glew/CMakeLists.txt
@@ -1,6 +1,5 @@
 MITK_CREATE_MODULE(glew
-  PROVIDES glew
   INCLUDE_DIRS external/include
   INTERNAL_INCLUDE_DIRS external/include
   PACKAGE_DEPENDS VTK
 )