diff --git a/cmake/AkantuMacros.cmake b/cmake/AkantuMacros.cmake
index bcb92d031..43007b49e 100644
--- a/cmake/AkantuMacros.cmake
+++ b/cmake/AkantuMacros.cmake
@@ -1,240 +1,245 @@
 #===============================================================================
 # @file   AkantuMacros.cmake
 #
 # @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
 # @author Nicolas Richart <nicolas.richart@epfl.ch>
 #
 # @date creation: Fri Oct 22 2010
 # @date last modification: Tue Jan 19 2016
 #
 # @brief  Set of macros used by akantu cmake files
 #
 # @section LICENSE
 #
 # Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
 # Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
 # Solides)
 #
 # Akantu 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 3 of the License, or (at your option) any
 # later version.
 #
 # Akantu 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 Akantu. If not, see <http://www.gnu.org/licenses/>.
 #
 #===============================================================================
 
 #===============================================================================
 function(set_third_party_shared_libirary_name _var _lib)
   set(${_var}
     ${PROJECT_BINARY_DIR}/third-party/lib/${CMAKE_SHARED_LIBRARY_PREFIX}${_lib}${CMAKE_SHARED_LIBRARY_SUFFIX}
     CACHE FILEPATH "" FORCE)
 endfunction()
 
 # ==============================================================================
 function(get_target_list_of_associated_files tgt files)
   if(TARGET ${tgt})
     get_target_property(_type ${tgt} TYPE)
   else()
     set(_type ${tgt}-NOTFOUND)
   endif()
 
   if(_type STREQUAL "SHARED_LIBRARY"
       OR _type STREQUAL "STATIC_LIBRARY"
       OR _type STREQUAL "MODULE_LIBRARY"
       OR _type STREQUAL "EXECUTABLE")
     get_target_property(_srcs ${tgt} SOURCES)
     set(_dep_ressources)
     foreach(_file ${_srcs})
       list(APPEND _dep_ressources ${CMAKE_CURRENT_SOURCE_DIR}/${_file})
     endforeach()
   elseif(_type)
     get_target_property(_dep_ressources ${tgt} RESSOURCES)
   endif()
 
   set(${files} ${_dep_ressources} PARENT_SCOPE)
 endfunction()
 
 #===============================================================================
 # Generate the list of currently loaded materials
 function(generate_material_list)
   message(STATUS "Determining the list of recognized materials...")
 
   package_get_all_include_directories(
     AKANTU_LIBRARY_INCLUDE_DIRS
     )
 
   package_get_all_external_informations(
-    AKANTU_EXTERNAL_INCLUDE_DIR
-    AKANTU_EXTERNAL_LIBRARIES
+    PRIVATE_INCLUDE AKANTU_PRIVATE_EXTERNAL_INCLUDE_DIR
+    INTERFACE_INCLUDE AKANTU_INTERFACE_EXTERNAL_INCLUDE_DIR
+    LIBRARIES AKANTU_EXTERNAL_LIBRARIES
     )
 
-  set(_include_dirs ${AKANTU_INCLUDE_DIRS} ${AKANTU_EXTERNAL_INCLUDE_DIR})
+  set(_include_dirs
+    ${AKANTU_INCLUDE_DIRS}
+    ${AKANTU_PRIVATE_EXTERNAL_INCLUDE_DIR}
+    ${AKANTU_INTERFACE_EXTERNAL_INCLUDE_DIR}
+    )
 
   try_run(_material_list_run _material_list_compile
     ${CMAKE_BINARY_DIR}
     ${PROJECT_SOURCE_DIR}/cmake/material_lister.cc
     CMAKE_FLAGS "-DINCLUDE_DIRECTORIES:STRING=${_include_dirs}" "-DCMAKE_CXX_STANDARD=14"
     COMPILE_DEFINITIONS "-DAKANTU_CMAKE_LIST_MATERIALS"
     COMPILE_OUTPUT_VARIABLE _compile_results
     RUN_OUTPUT_VARIABLE _result_material_list)
 
   if(_material_list_compile AND "${_material_list_run}" EQUAL 0)
     message(STATUS "Materials included in Akantu:")
     string(REPLACE "\n" ";" _material_list "${_result_material_list}")
     foreach(_mat ${_material_list})
       string(REPLACE ":" ";" _mat_key "${_mat}")
       list(GET _mat_key 0 _key)
       list(GET _mat_key 1 _class)
       list(LENGTH _mat_key _l)
 
       if("${_l}" GREATER 2)
         list(REMOVE_AT _mat_key 0 1)
         set(_opt " -- options: [")
         foreach(_o ${_mat_key})
           set(_opt "${_opt} ${_o}")
         endforeach()
         set(_opt "${_opt} ]")
       else()
         set(_opt "")
       endif()
 
       message(STATUS "   ${_class} -- key: ${_key}${_opt}")
     endforeach()
   else()
     message(STATUS "Could not determine the list of materials.")
     message("${_compile_results}")
   endif()
 endfunction()
 
 #===============================================================================
 # Declare the options for the types and defines the approriate typedefs
 function(declare_akantu_types)
   set(AKANTU_TYPE_FLOAT "double (64bit)" CACHE STRING "Precision force floating point types")
   mark_as_advanced(AKANTU_TYPE_FLOAT)
   set_property(CACHE AKANTU_TYPE_FLOAT PROPERTY STRINGS
     "quadruple (128bit)"
     "double (64bit)"
     "float (32bit)"
     )
 
   set(AKANTU_TYPE_INTEGER "int (32bit)" CACHE STRING "Size of the integer types")
   mark_as_advanced(AKANTU_TYPE_INTEGER)
   set_property(CACHE AKANTU_TYPE_INTEGER PROPERTY STRINGS
     "int (32bit)"
     "long int (64bit)"
     )
 
   include(CheckTypeSize)
 
   # ----------------------------------------------------------------------------
   # Floating point types
   # ----------------------------------------------------------------------------
   if(AKANTU_TYPE_FLOAT STREQUAL "float (32bit)")
         set(AKANTU_FLOAT_TYPE "float" CACHE INTERNAL "")
         set(AKANTU_FLOAT_SIZE 4 CACHE INTERNAL "")
   elseif(AKANTU_TYPE_FLOAT STREQUAL "double (64bit)")
     set(AKANTU_FLOAT_TYPE "double" CACHE INTERNAL "")
     set(AKANTU_FLOAT_SIZE 8 CACHE INTERNAL "")
   elseif(AKANTU_TYPE_FLOAT STREQUAL "quadruple (128bit)")
     check_type_size("long double" LONG_DOUBLE)
     if(HAVE_LONG_DOUBLE)
       set(AKANTU_FLOAT_TYPE "long double" CACHE INTERNAL "")
       set(AKANTU_FLOAT_SIZE 16 CACHE INTERNAL "")
       message("This feature is not tested and will most probably not compile")
     else()
       message(FATAL_ERROR "The type long double is not defined on your system")
     endif()
   else()
     message(FATAL_ERROR "The float type is not defined")
   endif()
 
   include(CheckIncludeFileCXX)
   include(CheckCXXSourceCompiles)
 
   # ----------------------------------------------------------------------------
   # Integer types
   # ----------------------------------------------------------------------------
   check_include_file_cxx(cstdint HAVE_CSTDINT)
   if(NOT HAVE_CSTDINT)
     check_include_file_cxx(stdint.h HAVE_STDINT_H)
     if(HAVE_STDINT_H)
       list(APPEND _int_include stdint.h)
     endif()
   else()
     list(APPEND _int_include cstdint)
   endif()
 
 
   check_include_file_cxx(cstddef HAVE_CSTDDEF)
   if(NOT HAVE_CSTDINT)
     check_include_file_cxx(stddef.h HAVE_STDDEF_H)
     if(HAVE_STDINT_H)
       list(APPEND _int_include stddef.h)
     endif()
   else()
     list(APPEND _int_include cstddef)
   endif()
 
   if(AKANTU_TYPE_INTEGER STREQUAL "int (32bit)")
     set(AKANTU_INTEGER_SIZE 4 CACHE INTERNAL "")
     check_type_size("int" INT)
     if(INT EQUAL 4)
       set(AKANTU_SIGNED_INTEGER_TYPE "int" CACHE INTERNAL "")
       set(AKANTU_UNSIGNED_INTEGER_TYPE "unsigned int" CACHE INTERNAL "")
     else()
       check_type_size("int32_t" INT32_T LANGUAGE CXX)
       if(HAVE_INT32_T)
         set(AKANTU_SIGNED_INTEGER_TYPE "int32_t" CACHE INTERNAL "")
         set(AKANTU_UNSIGNED_INTEGER_TYPE "uint32_t" CACHE INTERNAL "")
         list(APPEND _extra_includes ${_int_include})
       endif()
     endif()
   elseif(AKANTU_TYPE_INTEGER STREQUAL "long int (64bit)")
     set(AKANTU_INTEGER_SIZE 8 CACHE INTERNAL "")
     check_type_size("long int" LONG_INT)
     if(LONG_INT EQUAL 8)
       set(AKANTU_SIGNED_INTEGER_TYPE "long int" CACHE INTERNAL "")
       set(AKANTU_UNSIGNED_INTEGER_TYPE "unsigned long int" CACHE INTERNAL "")
     else()
       check_type_size("long long int" LONG_LONG_INT)
       if(HAVE_LONG_LONG_INT AND LONG_LONG_INT EQUAL 8)
         set(AKANTU_SIGNED_INTEGER_TYPE "long long int" CACHE INTERNAL "")
         set(AKANTU_UNSIGNED_INTEGER_TYPE "unsigned long long int" CACHE INTERNAL "")
       else()
         check_type_size("int64_t" INT64_T)
         if(HAVE_INT64_T)
           set(AKANTU_SIGNED_INTEGER_TYPE "int64_t" CACHE INTERNAL "")
           set(AKANTU_UNSIGNED_INTEGER_TYPE "uint64_t" CACHE INTERNAL "")
           list(APPEND _extra_includes ${_int_include})
         endif()
       endif()
     endif()
   else()
     message(FATAL_ERROR "The integer type is not defined")
   endif()
 
   # ----------------------------------------------------------------------------
   # includes
   # ----------------------------------------------------------------------------
   foreach(_inc ${_extra_includes})
     set(_incs "#include <${_inc}>\n${_incs}")
   endforeach()
   set(AKANTU_TYPES_EXTRA_INCLUDES ${_incs} CACHE INTERNAL "")
 endfunction()
 
 
 function(mask_package_options prefix)
   get_property(_list DIRECTORY PROPERTY VARIABLES)
   foreach(_var ${_list})
     if("${_var}" MATCHES "^${prefix}.*")
       mark_as_advanced(${_var})
     endif()
   endforeach()
 endfunction()
diff --git a/cmake/Modules/CMakePackagesSystem.cmake b/cmake/Modules/CMakePackagesSystem.cmake
index 101e9f3ae..ff7313457 100644
--- a/cmake/Modules/CMakePackagesSystem.cmake
+++ b/cmake/Modules/CMakePackagesSystem.cmake
@@ -1,1064 +1,1092 @@
 #===============================================================================
 # @file   CMakePackagesSystem.cmake
 #
 # @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
 # @author Nicolas Richart <nicolas.richart@epfl.ch>
 #
 # @date creation: Wed Nov 05 2014
 # @date last modification: Wed Jan 20 2016
 #
 # @brief  Set of macros used by akantu to handle the package system
 #
 # @section LICENSE
 #
 # Copyright (©) 2015 EPFL (Ecole Polytechnique Fédérale de Lausanne) Laboratory
 # (LSMS - Laboratoire de Simulation en Mécanique des Solides)
 #
 # Akantu 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 3 of the License, or (at your option) any
 # later version.
 #
 # Akantu 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 Akantu. If not, see <http://www.gnu.org/licenses/>.
 #
 #===============================================================================
 
 #[=======================================================================[.rst:
 #CMakePackagesSystem
 #-------------------
 #
 #This package defines multiple function to handle packages. This packages can
 #be of two kinds regular ones and extra_packages (ex: in akantu the LGPL part
 #is regular packages and extra packages are on Propetary license)
 #
 #Package are loaded with the help of the command:
 #
 #.. command:: package_list_packages
 #
 #     package_list_packages(<regular_package_folder>
 #       [ EXTRA_PACKAGE_FOLDER <extra_package_folder> ]
 #       [ SOURCE_FOLDER <source_folder>]
 #       [ TEST_FOLDER <test_folder> ]
 #       [ MANUAL_FOLDER <manual_folder> ]
 #       )
 #
 #     This command will look for packages name like ``<regular_package_folder>/<package>.cmake``
 #     OR ``<extra_package_folder>/<package>/package.cmake``
 #
 #A package is a cmake script that should contain at list the declaration of a
 #package
 #
 #.. command:: package_declare
 #
 #     package_declare(<package real name>
 #       [EXTERNAL] [META] [ADVANCED] [NOT_OPTIONAL]
 #       [DESCRIPTION <description>] [DEFAULT <default_value>]
 #       [DEPENDS <pkg> ...]
 #       [BOOST_COMPONENTS <pkg> ...]
 #       [EXTRA_PACKAGE_OPTIONS <opt> ...]
 #       [COMPILE_FLAGS <lang> <flags>]
 #       [SYSTEM <ON|OFF|AUTO> [ <script_to_compile> ]]
 #       [FEATURES_PUBLIC <feature> ...]
 #       [FEATURES_PRIVATE <feature> ...]
 #       [EXCLUDE_FROM_ALL]
 #       )
 #
 #.. command:: package_declare_sources
 #
 #     It can also declare multiple informations:
 #     source files:
 #
 #     package_declare_sources(<package real name>
 #       <src1> <src2> ... <srcn>)
 #
 #.. command:: package_declare_documentation
 #
 #     a LaTeX documentation
 #     package_declare_documentation(<package real name>
 #       <line1> <line2> ...<linen>)
 #
 #.. command:: package_declare_documentation_files
 #
 #     LaTeX documentation files
 #     package_declare_documentation_files(<package real name>
 #       <file1> <file2> ... <filen>)
 #
 #Different function can also be retrieved from the package system by using the
 #different accessors
 #
 #.. command:: package_get_name
 #     package_get_name(<pkg> <retval>)
 #
 #.. command:: package_get_real_name
 #    package_get_real_name(<pkg> <retval>)
 #
 #.. command:: package_get_option_name
 #     package_get_option_name(<pkg> <retval>)
 #
 #.. command:: package_use_system
 #     package_use_system(<pkg> <retval>)
 #
 #.. command:: package_get_nature
 #     package_get_nature(<pkg> <retval>)
 #
 #.. command:: package_get_description
 #     package_get_description(<pkg> <retval>)
 #
 #.. command:: package_get_filename
 #     package_get_filename(<pkg> <retval>)
 #
 #.. command:: package_get_sources_folder
 #     package_get_sources_folder(<pkg> <retval>)
 #.. command:: package_get_tests_folder
 #     package_get_tests_folder(<pkg> <retval>)
 #.. command:: package_get_manual_folder
 #     package_get_manual_folder(<pkg> <retval>)
 #
 #.. command:: package_get_find_package_extra_options
 #     package_get_find_package_extra_options(<pkg> <retval>)
 #
 #.. command:: package_get_compile_flags
 #     package_get_compile_flags(<pkg> <lang> <retval>)
 #.. command:: package_set_compile_flags
 #     package_set_compile_flags(<pkg> <lang> <flag1> <flag2> ... <flagn>)
 #
 #.. command:: package_get_include_dir
 #     package_get_include_dir(<pkg> <retval>)
 #.. command:: package_set_include_dir
 #     package_set_include_dir(<pkg> <inc1> <inc2> ... <incn>)
 #.. command:: package_add_include_dir
 #     package_add_include_dir(<pkg> <inc1> <inc2> ... <incn>)
 #
 #.. command:: package_get_libraries
 #     package_get_libraries(<pkg> <retval>)
 #.. command:: package_set_libraries
 #     package_set_libraries(<pkg> <lib1> <lib2> ... <libn>)
 #
 #.. command:: package_add_extra_dependency
 #     package_add_extra_dependency(pkg <dep1> <dep2> ... <depn>)
 #.. command:: package_rm_extra_dependency
 #     package_rm_extra_dependency(<pkg> <dep>)
 #.. command:: package_get_extra_dependencies
 #     package_get_extra_dependencies(<pkg> <retval>)
 #
 #.. command:: package_is_activated
 #     package_is_activated(<pkg> <retval>)
 #.. command:: package_is_deactivated
 #     package_is_deactivated(<pkg> <retval>)
 #
 #.. command:: package_get_dependencies
-#     package_get_dependencies(<pkg> <retval>)
+#     package_get_dependencies(<pkg> <PRIVATE|INTERFACE> <retval>)
 #.. command:: package_add_dependencies
-#     package_add_dependencies(<pkg> <dep1> <dep2> ... <depn>)
+#     package_add_dependencies(<pkg> <PRIVATE|INTERFACE> <dep1> <dep2> ... <depn>)
 #     package_remove_dependencies(<pkg> <dep1> <dep2> ... <depn>)
 #     package_remove_dependency(<pkg> <dep>)
 #
 #.. command:: package_on_enabled_script
 #     package_on_enabled_script(<pkg> <script>)
 #
 #.. command:: package_get_all_source_files
 #     package_get_all_source_files(<srcs> <public_headers> <private_headers>)
 #.. command:: package_get_all_include_directories
 #     package_get_all_include_directories(<inc_dirs>)
 #.. command:: package_get_all_external_informations
 #     package_get_all_external_informations(<include_dir> <libraries>)
 #.. command:: package_get_all_definitions
 #     package_get_all_definitions(<definitions>)
 #.. command:: package_get_all_extra_dependencies
 #     package_get_all_extra_dependencies(<dependencies>)
 #.. command:: package_get_all_test_folders
 #     package_get_all_test_folders(<test_dirs>)
 #.. command:: package_get_all_documentation_files
 #     package_get_all_documentation_files(<doc_files>)
 #.. command:: package_get_all_activated_packages
 #     package_get_all_activated_packages(<activated_list>)
 #.. command:: package_get_all_deactivated_packages
 #     package_get_all_deactivated_packages(<deactivated_list>)
 #.. command:: package_get_all_packages
 #     package_get_all_packages(<packages_list>)
 #.. command:: package_get_all_features_public
 #     package_get_all_features_public(<features>)
 #.. command:: package_get_all_features_private
 #     package_get_all_features_private(<features>)
 #
 #
 #     .. command:: package_set_package_system_dependency
 #
 #     package_set_package_system_dependency(<pkg> <system> <dep1>
 #                                           <dep2> ... <depn>)
 #
 #                                       .. command:: package_get_package_system_dependency
 #
 #     package_get_package_system_dependency(<pkg> <var>)
 #
 #
 #]=======================================================================]
 
 
 include(CMakeParseArguments)
 
 #===============================================================================
 # Package Management
 #===============================================================================
 if(__CMAKE_PACKAGES_SYSTEM)
   return()
 endif()
 set(__CMAKE_PACKAGES_SYSTEM TRUE)
 
 if(CMAKE_VERSION VERSION_GREATER 3.1.2)
   cmake_policy(SET CMP0054 NEW)
 endif()
 
 #===============================================================================
 option(AUTO_MOVE_UNKNOWN_FILES
   "Give to cmake the permission to move the unregistered files to the ${PROJECT_SOURCE_DIR}/tmp directory" FALSE)
 mark_as_advanced(AUTO_MOVE_UNKNOWN_FILES)
 
 
 include(CMakePackagesSystemGlobalFunctions)
 include(CMakePackagesSystemPrivateFunctions)
 
 # ==============================================================================
 # "Public" Accessors
 # ==============================================================================
 # ------------------------------------------------------------------------------
 # Package name
 # ------------------------------------------------------------------------------
 function(package_get_name pkg pkg_name)
   string(TOUPPER ${PROJECT_NAME} _project)
   string(REPLACE "-" "_" _str_pkg "${pkg}")
   string(TOUPPER ${_str_pkg} _u_package)
   set(${pkg_name} ${_project}_PKG_${_u_package} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Real name
 # ------------------------------------------------------------------------------
 function(package_get_real_name pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_get_real_name(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Option name
 # ------------------------------------------------------------------------------
 function(package_get_option_name pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_get_option_name(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Set if system package or compile external lib
 # ------------------------------------------------------------------------------
 function(package_use_system pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_use_system(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 function(package_add_third_party_script_variable pkg var)
   package_get_name(${pkg} _pkg_name)
   _package_add_third_party_script_variable(${_pkg_name} ${var} ${ARGN})
   set(${var} ${ARGN} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Set if system package or compile external lib
 # ------------------------------------------------------------------------------
 function(package_add_to_export_list pkg)
   package_get_name(${pkg} _pkg_name)
   _package_add_to_export_list(${_pkg_name} ${ARGN})
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Nature
 # ------------------------------------------------------------------------------
 function(package_get_nature pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_get_nature(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Description
 # ------------------------------------------------------------------------------
 function(package_get_description pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_get_description(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Package file name
 # ------------------------------------------------------------------------------
 function(package_get_filename pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_get_filename(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Source files
 # ------------------------------------------------------------------------------
 function(package_get_source_files pkg ret_srcs ret_pub ret_priv)
   package_get_name(${pkg} _pkg_name)
   _package_get_source_files(${_pkg_name} _tmp_srcs _tmp_pub _tmp_priv)
   set(${ret_srcs} ${_tmp_srcs} PARENT_SCOPE)
   set(${ret_pub}  ${_tmp_pub}  PARENT_SCOPE)
   set(${ret_priv} ${_tmp_pric} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Source folder
 # ------------------------------------------------------------------------------
 function(package_get_sources_folder pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_get_sources_folder(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Test folder
 # ------------------------------------------------------------------------------
 function(package_get_tests_folder pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_get_tests_folder(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Manual folder
 # ------------------------------------------------------------------------------
 function(package_get_manual_folder pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_get_manual_folder(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Extra option for the find_package
 # ------------------------------------------------------------------------------
 function(package_get_find_package_extra_options pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_get_find_package_extra_options(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 function(package_set_find_package_extra_options pkg)
   package_get_name(${pkg} _pkg_name)
   _package_set_find_package_extra_options(${_pkg_name} ${ARGN})
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Compilation flags
 # ------------------------------------------------------------------------------
 function(package_get_compile_flags pkg lang ret)
   package_get_name(${pkg} _pkg_name)
   _package_get_compile_flags(${_pkg_name} ${lang} _tmp)
   set(${ret} "${_tmp}" PARENT_SCOPE)
 endfunction()
 
 function(package_set_compile_flags pkg lang)
   package_get_name(${pkg} _pkg_name)
   _package_set_compile_flags(${_pkg_name} ${lang} ${ARGN})
 endfunction()
 
 function(package_unset_compile_flags pkg lang)
   package_get_name(${pkg} _pkg_name)
   _package_unset_compile_flags(${_pkg_name} ${lang})
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Include dir
 # ------------------------------------------------------------------------------
 function(package_get_include_dir pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_get_include_dir(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 function(package_set_include_dir pkg)
   package_get_name(${pkg} _pkg_name)
   _package_set_include_dir(${_pkg_name} ${ARGN})
 endfunction()
 
 function(package_add_include_dir pkg)
   package_get_name(${pkg} _pkg_name)
   _package_add_include_dir(${_pkg_name} ${ARGN})
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Libraries
 # ------------------------------------------------------------------------------
 function(package_get_libraries pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_get_libraries(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 function(package_set_libraries pkg)
   package_get_name(${pkg} _pkg_name)
   _package_set_libraries(${_pkg_name} ${ARGN})
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Extra dependencies like custom commands of ExternalProject
 # ------------------------------------------------------------------------------
 function(package_add_extra_dependency pkg)
   package_get_name(${pkg} _pkg_name)
   _package_add_extra_dependency(${_pkg_name} ${ARGN})
 endfunction()
 
 function(package_rm_extra_dependency pkg dep)
   package_get_name(${pkg} _pkg_name)
   _package_rm_extra_dependency(${_pkg_name} ${dep})
 endfunction()
 
 function(package_get_extra_dependencies pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_get_extra_dependencies(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Activate/deactivate
 # ------------------------------------------------------------------------------
 function(package_is_activated pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_is_activated(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 function(package_is_deactivated pkg ret)
   package_get_name(${pkg} _pkg_name)
   _package_is_deactivated(${_pkg_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Direct dependencies
 # ------------------------------------------------------------------------------
-function(package_get_dependencies pkg ret)
+function(package_get_dependencies pkg type ret)
   package_get_name(${pkg} _pkg_name)
-  _package_get_dependencies(${_pkg_name} _tmp_name)
+  _package_get_dependencies(${_pkg_name} ${type} _tmp_name)
   _package_get_real_name(${_tmp_name} _tmp)
   set(${ret} ${_tmp} PARENT_SCOPE)
 endfunction()
 
-function(package_add_dependencies pkg)
+function(package_add_dependencies pkg type)
   package_get_name(${pkg} _pkg_name)
   foreach(_dep ${ARGN})
     package_get_name(${_dep} _dep_pkg_name)
     list(APPEND _tmp_deps ${_dep_pkg_name})
   endforeach()
 
-  _package_add_dependencies(${_pkg_name} ${_tmp_deps})
+  _package_add_dependencies(${_pkg_name} ${type} ${_tmp_deps})
 endfunction()
 
-function(package_remove_dependencies pkg)
+function(package_remove_dependencies pkg type)
   foreach(_dep ${ARGN})
     package_remove_dependency(${pkg} _dep)
   endforeach()
 endfunction()
 
 function(package_remove_dependency pkg dep)
   package_get_name(${pkg} _pkg_name)
   package_get_name(${dep} _dep_pkg_name)
-  _package_remove_dependency(${_pkg_name} ${_dep_pkg_name})
+  _package_remove_dependency(${_pkg_name} PRIVATE ${_dep_pkg_name})
+  _package_remove_dependency(${_pkg_name} INTERFACE ${_dep_pkg_name})
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Documentation related functions
 # ------------------------------------------------------------------------------
 function(package_declare_documentation pkg)
   package_get_name(${pkg} _pkg_name)
   _package_set_documentation(${_pkg_name} ${ARGN})
 endfunction()
 
 function(package_declare_documentation_files pkg)
   package_get_name(${pkg} _pkg_name)
   _package_set_documentation_files(${_pkg_name} ${ARGN})
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Set any user variables needed
 # ------------------------------------------------------------------------------
 function(package_set_variable variable pkg)
   package_get_name(${pkg} _pkg_name)
   _package_set_variable(${variable} ${_pkg_name} ${ARGN})
 endfunction()
 
 function(package_add_to_variable variable pkg)
   package_get_name(${pkg} _pkg_name)
   _package_add_to_variable(${variable} ${_pkg_name} ${ARGN})
 endfunction()
 
 function(package_get_variable variable pkg value)
   package_get_name(${pkg} _pkg_name)
   _package_get_variable(${variable} ${_pkg_name} _value_tmp)
   if(_value_tmp)
     set(${value} ${_value_tmp} PARENT_SCOPE)
   else()
     unset(${value} PARENT_SCOPE)
   endif()
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Exteral package system as apt rpm dependencies
 # ------------------------------------------------------------------------------
 function(package_set_package_system_dependency pkg system)
   package_get_name(${pkg} _pkg_name)
   _package_set_package_system_dependency(${_pkg_name} ${system} ${ARGN})
 endfunction()
 
 function(package_get_package_system_dependency pkg system var)
   package_get_name(${pkg} _pkg_name)
   _package_set_package_system_dependency(${_pkg_name} ${sytem} _tmp)
   set(${var} ${_tmp} PARENT_SCOPE)
 endfunction()
 # ------------------------------------------------------------------------------
 
 # ==============================================================================
 # Global accessors
 # ==============================================================================
 # ------------------------------------------------------------------------------
 # get the list of source files
 # ------------------------------------------------------------------------------
 function(package_get_all_source_files SRCS PUBLIC_HEADERS PRIVATE_HEADERS)
   string(TOUPPER ${PROJECT_NAME} _project)
 
   unset(_tmp_srcs)
   unset(_tmp_public_headers)
   unset(_tmp_private_headers)
 
   package_get_all_activated_packages(_activated_list)
   foreach(_pkg_name ${_activated_list})
     _package_get_source_files(${_pkg_name}
       _pkg_srcs
       _pkg_public_headers
       _pkg_private_headers
       )
     list(APPEND _tmp_srcs ${_pkg_srcs})
     list(APPEND _tmp_public_headers ${_pkg_public_headers})
     list(APPEND _tmp_private_headers ${_pkg_private_headers})
   endforeach()
 
   set(${SRCS}            ${_tmp_srcs}            PARENT_SCOPE)
   set(${PUBLIC_HEADERS}  ${_tmp_public_headers}  PARENT_SCOPE)
   set(${PRIVATE_HEADERS} ${_tmp_private_headers} PARENT_SCOPE)
 endfunction()
 
 
 # ------------------------------------------------------------------------------
 # Get include directories
 # ------------------------------------------------------------------------------
 function(package_get_all_include_directories inc_dirs)
   set(_tmp)
   package_get_all_activated_packages(_activated_list)
 
   foreach(_pkg_name ${_activated_list})
     foreach(_type SRCS PUBLIC_HEADERS PRIVATE_HEADERS)
       foreach(_file ${${_pkg_name}_${_type}})
         get_filename_component(_path "${_file}" PATH)
         list(APPEND _tmp "${_path}")
       endforeach()
     endforeach()
   endforeach()
 
   if(_tmp)
     list(REMOVE_DUPLICATES _tmp)
   endif()
 
   set(${inc_dirs} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Get external libraries informations
 # ------------------------------------------------------------------------------
-function(package_get_all_external_informations INCLUDE_DIR LIBRARIES)
-  _package_get_variable_for_activated(INCLUDE_DIR tmp_INCLUDE_DIR)
-  _package_get_variable_for_activated(LIBRARIES tmp_LIBRARIES)
+function(package_get_all_external_informations)
+  cmake_parse_arguments(_opt "" "PRIVATE_INCLUDE;INTERFACE_INCLUDE;LIBRARIES" "" ${ARGN})
+
+  foreach(_type PRIVATE INTERFACE)
+    if(_opt_${_type}_INCLUDE)
+      _package_get_variable_for_external_dependencies(INCLUDE_DIR ${_type} tmp_INCLUDE_DIR)
+      foreach(_dir ${tmp_INCLUDE_DIR})
+	string(FIND "${_dir}" "${CMAKE_CURRENT_SOURCE_DIR}" _pos)
+	if(NOT _pos EQUAL -1)
+	  list(REMOVE_ITEM tmp_INCLUDE_DIR ${_dir})
+	endif()
+      endforeach()
+
+      set(${_opt_${_type}_INCLUDE} ${tmp_INCLUDE_DIR} PARENT_SCOPE)
+    endif()
+  endforeach()
 
-  set(${INCLUDE_DIR} ${tmp_INCLUDE_DIR} PARENT_SCOPE)
-  set(${LIBRARIES}   ${tmp_LIBRARIES}   PARENT_SCOPE)
+  if(_opt_LIBRARIES)
+    _package_get_variable_for_external_dependencies(LIBRARIES PRIVATE tmp_LIBRARIES)
+    _package_get_variable_for_external_dependencies(LIBRARIES INTERFACE tmp_LIBRARIES_INTERFACE)
+    set(${_opt_LIBRARIES} ${tmp_LIBRARIES} ${tmp_LIBRARIES_INTERFACE} PARENT_SCOPE)
+  endif()
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Get export list for all activated packages
 # ------------------------------------------------------------------------------
 function(package_get_all_export_list export_list)
   _package_get_variable_for_activated(EXPORT_LIST _tmp)
   set(${export_list} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Get definitions like external projects
 # ------------------------------------------------------------------------------
 function(package_get_all_definitions definitions)
   _package_get_variable_for_activated(OPTION_NAME _tmp)
   set(${definitions} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Get extra dependencies like external projects
 # ------------------------------------------------------------------------------
 function(package_get_all_extra_dependencies deps)
   _package_get_variable_for_activated(EXTRA_DEPENDENCY _tmp)
   set(${deps} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Get extra infos
 # ------------------------------------------------------------------------------
 function(package_get_all_test_folders TEST_DIRS)
   _package_get_variable_for_activated(TEST_FOLDER _tmp)
   set(${TEST_DIRS} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Get compilation flags
 # ------------------------------------------------------------------------------
 function(package_get_all_compilation_flags LANG FLAGS)
   _package_get_variable_for_activated(COMPILE_${LANG}_FLAGS _tmp_flags)
   string(REPLACE ";" " " _flags "${_tmp_flags}")
   set(${FLAGS} ${_flags} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Documentation informations
 # ------------------------------------------------------------------------------
 function(package_get_all_documentation_files doc_files)
   set(_tmp_DOC_FILES)
 
   package_get_all_activated_packages(_activated_list)
   foreach(_pkg_name ${_activated_list})
     _package_get_manual_folder(${_pkg_name} _doc_dir)
     _package_get_documentation_files(${_pkg_name} _doc_files)
 
     foreach(_doc_file ${_doc_files})
       list(APPEND _tmp_DOC_FILES ${_doc_dir}/${_doc_file})
     endforeach()
   endforeach()
 
   if(_tmp_DOC_FILES)
     list(REMOVE_DUPLICATES _tmp_DOC_FILES)
   endif()
 
   set(${doc_files} ${_tmp_DOC_FILES} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Get package systems dependencies
 # ------------------------------------------------------------------------------
 function(package_get_all_package_system_dependency system deps)
   string(TOUPPER ${system} _u_system)
   _package_get_variable_for_activated(PACKAGE_SYSTEM_${_u_system} _tmp)
   set(${deps} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # List packages
 # ------------------------------------------------------------------------------
 function(package_get_all_activated_packages activated_list)
   package_get_project_variable(ACTIVATED_PACKAGE_LIST _activated_list)
   set(${activated_list} ${_activated_list} PARENT_SCOPE)
 endfunction()
 
 function(package_get_all_deactivated_packages deactivated_list)
   package_get_project_variable(DEACTIVATED_PACKAGE_LIST _deactivated_list)
   set(${deactivated_list} ${_deactivated_list} PARENT_SCOPE)
 endfunction()
 
 function(package_get_all_packages packages_list)
   package_get_project_variable(ALL_PACKAGES_LIST _packages_list)
   set(${packages_list} ${_packages_list} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # List all the needed features
 # ------------------------------------------------------------------------------
 function(package_get_all_features_public features)
   _package_get_variable_for_activated(FEATURES_PUBLIC _tmp)
   set(${features} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 function(package_get_all_features_private features)
   _package_get_variable_for_activated(FEATURES_PRIVATE _tmp)
   set(${features} ${_tmp} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Callbacks
 # ------------------------------------------------------------------------------
 function(package_on_enabled_script pkg script)
   package_get_name(${pkg} _pkg_name)
   _package_on_enable_script(${_pkg_name} "${script}")
 endfunction()
 
 # ------------------------------------------------------------------------------
 # list all the packages in the PACKAGE_FOLDER
 # extra packages can be given with an EXTRA_PACKAGE_FOLDER
 # <package_folder>/<package>.cmake
 #
 # Extra packages folder structure
 # <extra_package_folder>/<package>/package.cmake
 #                                 /src
 #                                 /test
 #                                 /manual
 #
 # ------------------------------------------------------------------------------
 function(package_list_packages PACKAGE_FOLDER)
   cmake_parse_arguments(_opt_pkg
     "NO_AUTO_COMPILE_FLAGS"
     "SOURCE_FOLDER;EXTRA_PACKAGES_FOLDER;TEST_FOLDER;MANUAL_FOLDER"
     ""
     ${ARGN})
 
   string(TOUPPER ${PROJECT_NAME} _project)
 
   # Cleaning some states to start correctly
   package_get_all_packages(_already_loaded_pkg)
   foreach(_pkg_name ${_already_loaded_pkg})
     _package_unset_extra_dependencies(${_pkg_name})
-    _package_unset_dependencies(${_pkg_name})
+    _package_unset_dependencies(${_pkg_name} PRIVATE)
+    _package_unset_dependencies(${_pkg_name} INTERFACE)
     _package_unset_activated(${_pkg_name})
   endforeach()
 
 
   if(_opt_pkg_SOURCE_FOLDER)
     set(_src_folder "${_opt_pkg_SOURCE_FOLDER}")
   else()
     set(_src_folder "src/")
   endif()
 
   get_filename_component(_abs_src_folder ${_src_folder} ABSOLUTE)
 
   if(_opt_pkg_TEST_FOLDER)
     set(_test_folder "${_opt_pkg_TEST_FOLDER}")
   else()
     set(_test_folder "test/")
   endif()
 
   if(_opt_pkg_MANUAL_FOLDER)
     set(_manual_folder "${_opt_pkg_MANUAL_FOLDER}")
   else()
     set(_manual_folder "doc/manual")
   endif()
 
   if(_opt_pkg_NO_AUTO_COMPILE_FLAGS)
     package_set_project_variable(NO_AUTO_COMPILE_FLAGS TRUE)
   else()
     package_set_project_variable(NO_AUTO_COMPILE_FLAGS FALSE)
   endif()
 
 
   get_filename_component(_abs_test_folder ${_test_folder} ABSOLUTE)
   get_filename_component(_abs_manual_folder ${_manual_folder} ABSOLUTE)
 
   # check all the packages in the <package_folder>
   file(GLOB _package_list "${PACKAGE_FOLDER}/*.cmake")
 
   set(_package_files)
   foreach(_pkg ${_package_list})
     get_filename_component(_basename ${_pkg} NAME)
     if(NOT _basename MATCHES "^\\.#.*")
       list(APPEND _package_files ${_basename})
     endif()
   endforeach()
 
   if(_package_files)
     list(SORT _package_files)
   endif()
 
   # check all packages
   set(_packages_list_all)
   foreach(_pkg_file ${_package_files})
     string(REGEX REPLACE "[0-9]+_" "" _pkg_file_stripped ${_pkg_file})
     string(REGEX REPLACE "\\.cmake" "" _pkg ${_pkg_file_stripped})
 
     set(_current_src_folder "${_abs_src_folder}" CACHE INTERNAL "" FORCE)
     set(_current_test_folder "${_abs_test_folder}" CACHE INTERNAL "" FORCE)
     set(_current_manual_folder "${_abs_manual_folder}" CACHE INTERNAL "" FORCE)
 
     include("${PACKAGE_FOLDER}/${_pkg_file}")
 
     unset(_current_src_folder CACHE)
     unset(_current_test_folder CACHE)
     unset(_current_manual_folder CACHE)
   endforeach()
 
   # check the extra_packages if they exists
   if(_opt_pkg_EXTRA_PACKAGES_FOLDER)
     file(GLOB _extra_package_list RELATIVE
       "${_opt_pkg_EXTRA_PACKAGES_FOLDER}" "${_opt_pkg_EXTRA_PACKAGES_FOLDER}/*")
     foreach(_pkg ${_extra_package_list})
       if(EXISTS "${_opt_pkg_EXTRA_PACKAGES_FOLDER}/${_pkg}/package.cmake")
 
         package_get_name(${_pkg} _pkg_name)
 
         _package_set_filename(${_pkg_name}
           "${_opt_pkg_EXTRA_PACKAGES_FOLDER}/${_pkg}/package.cmake")
 
         set(_current_src_folder "${_opt_pkg_EXTRA_PACKAGES_FOLDER}/${_pkg}/src" CACHE INTERNAL "" FORCE)
 
         if(EXISTS "${_opt_pkg_EXTRA_PACKAGES_FOLDER}/${_pkg}/test")
           set(_current_test_folder "${_opt_pkg_EXTRA_PACKAGES_FOLDER}/${_pkg}/test" CACHE INTERNAL "" FORCE)
         endif()
 
         if(EXISTS "${_opt_pkg_EXTRA_PACKAGES_FOLDER}/${_pkg}/manual")
           set(_current_manual_folder "${_opt_pkg_EXTRA_PACKAGES_FOLDER}/${_pkg}/manual" CACHE INTERNAL "" FORCE)
         endif()
 
         list(APPEND _extra_pkg_src_folders "${_opt_pkg_EXTRA_PACKAGES_FOLDER}/${_pkg}/src")
 
         include("${_opt_pkg_EXTRA_PACKAGES_FOLDER}/${_pkg}/package.cmake")
 
         unset(_current_src_folder CACHE)
         unset(_current_test_folder CACHE)
         unset(_current_manual_folder CACHE)
       endif()
     endforeach()
   endif()
 
   _package_build_rdependencies()
   _package_load_packages()
   _package_check_files_exists()
   _package_check_files_registered(${_abs_src_folder} ${_extra_pkg_src_folders})
 
   # Load boost components if boost was loaded
   package_is_activated(Boost _ret)
   if(_ret)
     _package_load_boost_components()
   endif()
 endfunction()
 
 # ------------------------------------------------------------------------------
 # macro to include internal/external packages packages
 # package_declare(<package real name>
 #                 [EXTERNAL] [META] [ADVANCED] [NOT_OPTIONAL]
 #                 [DESCRIPTION <description>] [DEFAULT <default_value>]
 #                 [DEPENDS <pkg> ...]
 #                 [BOOST_COMPONENTS <pkg> ...]
 #                 [EXTRA_PACKAGE_OPTIONS <opt> ...]
 #                 [COMPILE_FLAGS <lang> <flags>]
 #                 [SYSTEM <bool> [ <script_to_compile> ]]
 #                 [FEATURES_PUBLIC <feature> ...]
 #                 [FEATURES_PRIVATE <feature> ...])
 # ------------------------------------------------------------------------------
 function(package_declare pkg)
   package_get_name(${pkg} _pkg_name)
   _package_set_real_name(${_pkg_name} ${pkg})
   _package_set_filename(${_pkg_name} "${CMAKE_CURRENT_LIST_FILE}")
 
   _package_set_sources_folder(${_pkg_name} "${_current_src_folder}")
 
   _package_variable_unset(SRCS ${_pkg_name})
   _package_variable_unset(PUBLIC_HEADERS ${_pkg_name})
   _package_variable_unset(PRIVATE_HEADERS ${_pkg_name})
 
   if(_current_test_folder)
     _package_set_tests_folder(${_pkg_name} "${_current_test_folder}")
   endif()
 
   if(_current_manual_folder)
     _package_set_manual_folder(${_pkg_name} "${_current_manual_folder}")
   endif()
 
   package_get_project_variable(ALL_PACKAGES_LIST _tmp_pkg_list)
   list(APPEND _tmp_pkg_list ${_pkg_name})
   list(REMOVE_DUPLICATES _tmp_pkg_list)
   package_set_project_variable(ALL_PACKAGES_LIST ${_tmp_pkg_list})
 
   set(_options
     EXTERNAL
     NOT_OPTIONAL
     META
     ADVANCED
     EXCLUDE_FROM_ALL)
   set(_one_valued_options
     DEFAULT
     DESCRIPTION)
   set(_multi_valued_options
     DEPENDS
     EXTRA_PACKAGE_OPTIONS
     COMPILE_FLAGS
     BOOST_COMPONENTS
     SYSTEM
     FEATURES_PUBLIC
     FEATURES_PRIVATE)
 
   cmake_parse_arguments(_opt_pkg
     "${_options}"
     "${_one_valued_options}"
     "${_multi_valued_options}"
     ${ARGN})
 
   if(_opt_pkg_UNPARSED_ARGUMENTS)
     message("You gave to many arguments while registering the package ${pkg} \"${_opt_pkg_UNPARSED_ARGUMENTS}\"")
   endif()
 
   # set the nature
   if(_opt_pkg_EXTERNAL)
     _package_set_nature(${_pkg_name} "external")
   elseif(_opt_pkg_META)
     _package_set_nature(${_pkg_name} "meta")
   else()
     _package_set_nature(${_pkg_name} "internal")
   endif()
 
   _package_declare_option(${_pkg_name})
 
   # set description
   if(_opt_pkg_DESCRIPTION)
     _package_set_description(${_pkg_name} ${_opt_pkg_DESCRIPTION})
   else()
     _package_set_description(${_pkg_name} "")
   endif()
 
   _package_get_option_name(${_pkg_name} _option_name)
   _package_get_description(${_pkg_name} _description)
 
   # get the default value
   if(DEFINED _opt_pkg_DEFAULT)
     set(_default ${_opt_pkg_DEFAULT})
   else()
     if(_opt_pkg_NOT_OPTIONAL)
       set(_default ON)
     else()
       set(_default OFF)
     endif()
   endif()
 
   # set the option if needed
   if(_opt_pkg_NOT_OPTIONAL)
     _package_get_nature(${_pkg_name} _nature)
     _package_set_nature(${_pkg_name} "${_nature}_not_optional")
     set(${_option_name} ${_default} CACHE INTERNAL "${_description}" FORCE)
   else()
     option(${_option_name} "${_description}" ${_default})
     if(_opt_pkg_ADVANCED OR _opt_pkg_EXTERNAL)
       mark_as_advanced(${_option_name})
     endif()
   endif()
 
   # Set the option for third-partie that can be compiled as an ExternalProject
   if(DEFINED _opt_pkg_SYSTEM)
     list(LENGTH _opt_pkg_SYSTEM _length)
     list(GET _opt_pkg_SYSTEM 0 _bool)
     _package_set_system_option(${_pkg_name} ${_bool})
     if(_length GREATER 1)
       list(GET _opt_pkg_SYSTEM 1 _script)
       _package_set_system_script(${_pkg_name} ${_script})
     endif()
   endif()
 
   # set the dependecies
   if(_opt_pkg_DEPENDS)
-    set(_depends)
-    foreach(_dep ${_opt_pkg_DEPENDS})
-      package_get_name(${_dep} _dep_pkg_name)
-      list(APPEND _depends ${_dep_pkg_name})
+    set(_deps_types PRIVATE INTERFACE)
+    cmake_parse_arguments(_pkg_deps
+      ""
+      ""
+      "${_deps_types}"
+      ${_opt_pkg_DEPENDS})
+
+    list(APPEND _pkg_deps_PRIVATE ${_pkg_deps_UNPARSED_ARGUMENTS})
+    foreach(_type ${_deps_types})
+      set(_depends)
+      foreach(_dep ${_pkg_deps_${_type}})
+	package_get_name(${_dep} _dep_pkg_name)
+	list(APPEND _depends ${_dep_pkg_name})
+      endforeach()
+      _package_add_dependencies(${_pkg_name} ${_type} ${_depends})
     endforeach()
-    _package_add_dependencies(${_pkg_name} ${_depends})
   endif()
 
   # keep the extra option for the future find package
   if(_opt_pkg_EXTRA_PACKAGE_OPTIONS)
     _package_set_find_package_extra_options(${_pkg_name} "${_opt_pkg_EXTRA_PACKAGE_OPTIONS}")
   endif()
 
   # register the compilation flags
   if(_opt_pkg_COMPILE_FLAGS)
     set(_languages C CXX Fortran)
     cmake_parse_arguments(_compile_flags
       "" "" "${_languages}"
       ${_opt_pkg_COMPILE_FLAGS}
       )
 
 
     # this is done to maintain backward compatibility
     if(_compile_flags_UNPARSED_ARGUMENTS)
       set(_compile_flags_CXX ${_compile_flags_UNPARSED_ARGUMENTS})
     endif()
 
     foreach(_lang ${_languages})
       if(_compile_flags_${_lang})
         _package_set_compile_flags(${_pkg_name} ${_lang} ${_compile_flags_${_lang}})
       else()
         _package_unset_compile_flags(${_pkg_name} ${_lang})
       endif()
     endforeach()
   endif()
 
   # set the boost dependencies
   if(_opt_pkg_BOOST_COMPONENTS)
     _package_set_boost_component_needed(${_pkg_name} "${_opt_pkg_BOOST_COMPONENTS}")
   endif()
 
   set(_variables FEATURES_PUBLIC FEATURES_PRIVATE EXCLUDE_FROM_ALL)
   foreach(_variable ${_variables})
     if(_opt_pkg_${_variable})
       _package_set_variable(${_variable} ${_pkg_name} "${_opt_pkg_${_variable}}")
     endif()
   endforeach()
 endfunction()
 
 # ------------------------------------------------------------------------------
 # declare the source files of a given package
 #
 # package_declare_sources(<package> <list of sources>
 #                         SOURCES <source file> ...
 #                         PUBLIC_HEADER <header file> ...
 #                         PRIVATE_HEADER <header file> ...)
 # ------------------------------------------------------------------------------
 function(package_declare_sources pkg)
   package_get_name(${pkg} _pkg_name)
 
   # get 3 lists, if none of the options given try to distinguish the different lists
   cmake_parse_arguments(_opt_pkg
     ""
     ""
     "SOURCES;PUBLIC_HEADERS;PRIVATE_HEADERS"
     ${ARGN})
 
   set(_tmp_srcs     ${_opt_pkg_SOURCES})
   set(_tmp_pub_hdrs ${_opt_pkg_PUBLIC_HEADER})
   set(_tmp_pri_hdrs ${_opt_pkg_PRIVATE_HEADERS})
 
   foreach(_file ${_opt_pkg_UNPARSED_ARGUMENTS})
     if(${_file} MATCHES ".*inline.*\\.cc")
       list(APPEND _tmp_pub_hdrs ${_file})
     elseif(${_file} MATCHES ".*\\.h+")
       list(APPEND _tmp_pub_hdrs ${_file})
     else()
       list(APPEND _tmp_srcs ${_file})
     endif()
   endforeach()
 
   _package_get_sources_folder(${_pkg_name} _src_folder)
 
   foreach(_type _srcs _pub_hdrs _pri_hdrs)
     set(${_type})
     foreach(_file ${_tmp${_type}})
       # get the full name
       list(APPEND ${_type} "${_src_folder}/${_file}")
     endforeach()
   endforeach()
 
   set(${_pkg_name}_SRCS "${_srcs}"
     CACHE INTERNAL "List of sources files" FORCE)
   set(${_pkg_name}_PUBLIC_HEADERS  "${_pub_hdrs}"
     CACHE INTERNAL "List of public header files" FORCE)
   set(${_pkg_name}_PRIVATE_HEADERS "${_pri_hdrs}"
     CACHE INTERNAL "List of private header files" FORCE)
 endfunction()
 
 # ------------------------------------------------------------------------------
diff --git a/cmake/Modules/CMakePackagesSystemGlobalFunctions.cmake b/cmake/Modules/CMakePackagesSystemGlobalFunctions.cmake
index 268bb3999..2d7c20acf 100644
--- a/cmake/Modules/CMakePackagesSystemGlobalFunctions.cmake
+++ b/cmake/Modules/CMakePackagesSystemGlobalFunctions.cmake
@@ -1,109 +1,139 @@
 #===============================================================================
 # @file   CMakePackagesSystemGlobalFunctions.cmake
 #
 # @author Nicolas Richart <nicolas.richart@epfl.ch>
 #
 # @date creation: Sat Jul 18 2015
 # @date last modification: Mon Jan 18 2016
 #
 # @brief  Set of macros used by the package system to set internal variables
 #
 # @section LICENSE
 #
 # Copyright (©) 2015 EPFL (Ecole Polytechnique Fédérale de Lausanne) Laboratory
 # (LSMS - Laboratoire de Simulation en Mécanique des Solides)
 #
 # Akantu 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 3 of the License, or (at your option) any
 # later version.
 #
 # Akantu 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 Akantu. If not, see <http://www.gnu.org/licenses/>.
 #
 #===============================================================================
 
 # ==============================================================================
 # Package system meta functions
 # ==============================================================================
 function(package_set_project_variable variable)
   string(TOUPPER ${PROJECT_NAME} _u_project)
   set(${_u_project}_${variable} "${ARGN}" CACHE INTERNAL "" FORCE)
 endfunction()
 
 function(package_get_project_variable variable value_out)
   string(TOUPPER ${PROJECT_NAME} _u_project)
   set(${value_out} ${${_u_project}_${variable}} PARENT_SCOPE)
 endfunction()
 
 function(package_add_to_project_variable variable)
   package_get_project_variable(${variable} _tmp_list)
   list(APPEND _tmp_list ${ARGN})
   if(_tmp_list)
     list(REMOVE_DUPLICATES _tmp_list)
   endif()
   package_set_project_variable(${variable} ${_tmp_list})
 endfunction()
 
 # ==============================================================================
 function(_package_set_variable variable pkg_name)
   set(${pkg_name}_${variable} ${ARGN} CACHE INTERNAL "" FORCE)
 endfunction()
 
 function(_package_get_variable variable pkg_name value)
   #unset(${value} PARENT_SCOPE)
   if(DEFINED ${pkg_name}_${variable})
     set(${value} ${${pkg_name}_${variable}} PARENT_SCOPE)
   elseif(DEFINED ARGN)
     set(${value} ${ARGN} PARENT_SCOPE)
   else()
     set(${value} PARENT_SCOPE)
   endif()
 endfunction()
 
 # ==============================================================================
 function(_package_variable_unset variable pkg_name)
   unset(${pkg_name}_${variable} CACHE)
 endfunction()
 
 # ==============================================================================
 function(_package_add_to_variable variable pkg_name)
   _package_get_variable(${variable} ${pkg_name} _tmp_list)
   list(APPEND _tmp_list ${ARGN})
   if(_tmp_list)
     list(REMOVE_DUPLICATES _tmp_list)
   endif()
   _package_set_variable(${variable} ${pkg_name} ${_tmp_list})
 endfunction()
 
 function(_package_remove_from_variable variable pkg_name value)
   _package_get_variable(${variable} ${pkg_name} _tmp_list)
   list(LENGTH _tmp_list _length)
   if(_length GREATER 0)
     list(REMOVE_ITEM _tmp_list ${value})
     _package_set_variable(${variable} ${pkg_name} ${_tmp_list})
   endif()
 endfunction()
 
 # ==============================================================================
-function(_package_get_variable_for_activated variable values)
+function(_package_get_variable_for_packages variable values)
   set(_list_values)
-  package_get_all_activated_packages(_activated_list)
-  foreach(_pkg_name ${_activated_list})
+  foreach(_pkg_name ${ARGN})
     _package_get_variable(${variable} ${_pkg_name} _value)
     list(APPEND _list_values ${_value})
   endforeach()
 
   if (_list_values)
     list(REMOVE_DUPLICATES _list_values)
   endif()
 
   set(${values} ${_list_values} PARENT_SCOPE)
 endfunction()
 
 # ==============================================================================
+function(_package_get_variable_for_activated variable values)
+  package_get_all_activated_packages(_activated_list)
+  _package_get_variable_for_packages(${variable} _list_values ${_activated_list})
+  set(${values} ${_list_values} PARENT_SCOPE)
+endfunction()
+
+# ==============================================================================
+function(_package_get_variable_for_external_dependencies variable type values)
+  set(_list_packages)
+  package_get_all_activated_packages(_activated_list)
+  foreach(_pkg_name ${_activated_list})
+    _package_get_nature(${_pkg_name} _nature)
+    if(NOT _nature MATCHES "^external.*")
+      _package_get_dependencies(${_pkg_name} ${type} _deps)
+      foreach(_dep ${_deps})
+	_package_get_nature(${_dep} _nature)
+	if(_nature MATCHES "^external.*")
+	  message("${_pkg_name} ${_dep} -> ${_nature}")
+	  list(APPEND _list_packages ${_dep})
+	endif()
+      endforeach()
+    endif()
+  endforeach()
+
+  if (_list_packages)
+    list(REMOVE_DUPLICATES _list_packages)
+    _package_get_variable_for_packages(${variable} _list_values_deps ${_list_packages})
+    set(${values} ${_list_values_deps} PARENT_SCOPE)
+  endif()
+endfunction()
+# ==============================================================================
diff --git a/cmake/Modules/CMakePackagesSystemPrivateFunctions.cmake b/cmake/Modules/CMakePackagesSystemPrivateFunctions.cmake
index f27a54312..a26454a1d 100644
--- a/cmake/Modules/CMakePackagesSystemPrivateFunctions.cmake
+++ b/cmake/Modules/CMakePackagesSystemPrivateFunctions.cmake
@@ -1,959 +1,962 @@
 #===============================================================================
 # @file   CMakePackagesSystemPrivateFunctions.cmake
 #
 # @author Nicolas Richart <nicolas.richart@epfl.ch>
 #
 # @date creation: Sat Jul 18 2015
 # @date last modification: Wed Jan 20 2016
 #
 # @brief  Set of macros used by the package system, internal functions
 #
 # @section LICENSE
 #
 # Copyright (©) 2015 EPFL (Ecole Polytechnique Fédérale de Lausanne) Laboratory
 # (LSMS - Laboratoire de Simulation en Mécanique des Solides)
 #
 # Akantu 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 3 of the License, or (at your option) any
 # later version.
 #
 # Akantu 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 Akantu. If not, see <http://www.gnu.org/licenses/>.
 #
 #===============================================================================
 
 # ==============================================================================
 # "Private" Accessors
 # ==============================================================================
 # ------------------------------------------------------------------------------
 # Real name
 # ------------------------------------------------------------------------------
 function(_package_get_real_name pkg_name real_name)
   set(${real_name} ${${pkg_name}} PARENT_SCOPE)
 endfunction()
 
 function(_package_set_real_name pkg_name real_name)
   set(${pkg_name} ${real_name} CACHE INTERNAL "" FORCE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Option name
 # ------------------------------------------------------------------------------
 function(_package_declare_option pkg_name)
   string(TOUPPER "${PROJECT_NAME}" _project)
   _package_get_real_name(${pkg_name} _real_name)
   string(TOUPPER "${_real_name}" _u_package)
 
   _package_get_nature(${pkg_name} _nature)
 
   if(${_nature} MATCHES "internal" OR ${_nature} MATCHES "meta")
     set(_opt_name ${_project}_${_u_package})
   elseif(${_nature} MATCHES "external")
     set(_opt_name ${_project}_USE_${_u_package})
   else()
     set(_opt_name UNKNOWN_NATURE_${_project}_${_u_package})
   endif()
 
   _package_set_variable(OPTION_NAME ${pkg_name} ${_opt_name})
 endfunction()
 
 function(_package_get_option_name pkg_name opt_name)
   _package_get_variable(OPTION_NAME ${pkg_name} _opt_name)
   set(${opt_name} ${_opt_name} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Set if system package or compile external lib
 # ------------------------------------------------------------------------------
 function(_package_set_system_option pkg_name default)
   string(TOUPPER "${PROJECT_NAME}" _project)
   _package_get_real_name(${pkg_name} _real_name)
   string(TOUPPER "${_real_name}" _u_package)
 
   set(${_project}_USE_SYSTEM_${_u_package} ${default} CACHE STRING
     "Should akantu compile the third-party: \"${_real_name}\"")
   mark_as_advanced(${_project}_USE_SYSTEM_${_u_package})
   set_property(CACHE ${_project}_USE_SYSTEM_${_u_package} PROPERTY STRINGS ON OFF AUTO)
 endfunction()
 
 function(_package_use_system pkg_name use)
   string(TOUPPER "${PROJECT_NAME}" _project)
   _package_get_real_name(${pkg_name} _real_name)
   string(TOUPPER "${_real_name}" _u_package)
   if(DEFINED ${_project}_USE_SYSTEM_${_u_package})
     if(${${_project}_USE_SYSTEM_${_u_package}} MATCHES "(ON|AUTO)")
       set(${use} TRUE PARENT_SCOPE)
     else()
       set(${use} FALSE PARENT_SCOPE)
     endif()
   else()
     set(${use} TRUE PARENT_SCOPE)
   endif()
 endfunction()
 
 function(_package_has_system_fallback pkg_name fallback)
   string(TOUPPER "${PROJECT_NAME}" _project)
   _package_get_real_name(${pkg_name} _real_name)
   string(TOUPPER "${_real_name}" _u_package)
 
   if(DEFINED ${_project}_USE_SYSTEM_${_u_package})
     if(${${_project}_USE_SYSTEM_${_u_package}} MATCHES "AUTO")
       set(${fallback} TRUE PARENT_SCOPE)
     else()
       set(${fallback} FALSE PARENT_SCOPE)
     endif()
   else()
     set(${fallback} FALSE PARENT_SCOPE)
   endif()
 endfunction()
 
 function(_package_set_system_script pkg_name script)
   _package_set_variable(COMPILE_SCRIPT ${pkg_name} "${script}")
 endfunction()
 
 function(_package_add_third_party_script_variable pkg_name var)
   _package_set_variable(VARIABLE_${var} ${pkg_name} "${ARGN}")
   set(${var} ${ARGN} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 function(_package_load_third_party_script pkg_name)
   if(${pkg_name}_COMPILE_SCRIPT)
     # set the stored variable
     get_cmake_property(_all_vars VARIABLES)
     foreach(_var ${_all_vars})
       if(_var MATCHES "^${pkg_name}_VARIABLE_.*")
         string(REPLACE "${pkg_name}_VARIABLE_" "" _orig_var "${_var}")
         set(${_orig_var} ${${_var}})
       endif()
     endforeach()
 
     _package_get_real_name(${pkg_name} _name)
     string(TOUPPER "${_name}" _u_name)
 
     _package_get_option_name(${pkg_name} _opt_name)
     if(${_opt_name}_VERSION)
       set(_version "${${_opt_name}_VERSION}")
       set(${_u_name}_VERSION "${_version}" CACHE INTERNAL "" FORCE)
     elseif(${_u_name}_VERSION)
       set(_version "${${_u_name}_VERSION}")
     endif()
 
     # load the script
     include(ExternalProject)
     include(${${pkg_name}_COMPILE_SCRIPT})
 
     if(${_u_name}_LIBRARIES)
       _package_set_libraries(${pkg_name} ${${_u_name}_LIBRARIES})
       list(APPEND _required_vars ${_u_name}_LIBRARIES)
     endif()
     if(${_u_name}_INCLUDE_DIR)
       _package_set_include_dir(${pkg_name} ${${_u_name}_INCLUDE_DIR})
       list(APPEND _required_vars ${_u_name}_INCLUDE_DIR)
     endif()
 
     include(FindPackageHandleStandardArgs)
     if(CMAKE_VERSION VERSION_GREATER 2.8.12)
       find_package_handle_standard_args(${_name}
         REQUIRED_VARS ${_required_vars}
         VERSION_VAR _version
         FAIL_MESSAGE "Something was not configured by a the third-party script for ${_name}"
         )
     else()
       find_package_handle_standard_args(${_name}
         "Something was not configured by a the third-party script for ${_name}"
         ${_required_vars}
         )
     endif()
   endif()
   set(${pkg_name}_USE_SYSTEM_PREVIOUS FALSE CACHE INTERNAL "" FORCE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Nature
 # ------------------------------------------------------------------------------
 function(_package_set_nature pkg_name nature)
   _package_set_variable(NATURE ${pkg_name} ${nature})
 endfunction()
 
 function(_package_get_nature pkg_name nature)
   _package_get_variable(NATURE ${pkg_name} _nature "unknown")
   set(${nature} ${_nature} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Description
 # ------------------------------------------------------------------------------
 function(_package_set_description pkg_name desc)
   _package_set_variable(DESC ${pkg_name} ${desc})
 endfunction()
 
 function(_package_get_description pkg_name desc)
   _package_get_variable(DESC ${pkg_name} _desc "No description set for the package ${${pkg_name}} (${pkg_name})")
   set(${desc} ${_desc} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Package file name
 # ------------------------------------------------------------------------------
 function(_package_set_filename pkg_name file)
   _package_set_variable(FILE ${pkg_name} ${file})
 endfunction()
 
 function(_package_get_filename pkg_name file)
   _package_get_variable(FILE ${pkg_name} _file "No filename set for the package ${${pkg_name}}")
   set(${file} ${_file} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Source folder
 # ------------------------------------------------------------------------------
 function(_package_set_sources_folder pkg_name src_folder)
   _package_set_variable(SRC_FOLDER ${pkg_name} ${src_folder})
 endfunction()
 
 function(_package_get_sources_folder pkg_name src_folder)
   _package_get_variable(SRC_FOLDER ${pkg_name} _src_folder)
   set(${src_folder} ${_src_folder} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Test folder
 # ------------------------------------------------------------------------------
 function(_package_set_tests_folder pkg_name test_folder)
   _package_set_variable(TEST_FOLDER ${pkg_name} ${test_folder})
 endfunction()
 
 function(_package_get_tests_folder pkg_name test_folder)
   _package_get_variable(TEST_FOLDER ${pkg_name} _test_folder)
   set(${test_folder} ${_test_folder} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Manual folder
 # ------------------------------------------------------------------------------
 function(_package_set_manual_folder pkg_name manual_folder)
   _package_set_variable(MANUAL_FOLDER ${pkg_name} ${manual_folder})
 endfunction()
 
 function(_package_get_manual_folder pkg_name manual_folder)
   _package_get_variable(MANUAL_FOLDER ${pkg_name} _manual_folder)
   set(${manual_folder} ${_manual_folder} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Extra option for the find_package
 # ------------------------------------------------------------------------------
 function(_package_set_find_package_extra_options pkg_name)
   _package_set_variable(FIND_PKG_OPTIONS ${pkg_name} ${ARGN})
 endfunction()
 
 function(_package_get_find_package_extra_options pkg_name options)
   _package_get_variable(FIND_PKG_OPTIONS ${pkg_name} _options)
   set(${options} ${_options} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Compilation flags
 # ------------------------------------------------------------------------------
 function(_package_set_compile_flags pkg_name lang)
   _package_set_variable(COMPILE_${lang}_FLAGS ${pkg_name} ${ARGN})
 endfunction()
 
 function(_package_unset_compile_flags pkg_name lang)
   _package_variable_unset(COMPILE_${lang}_FLAGS ${pkg_name})
 endfunction()
 
 function(_package_get_compile_flags pkg_name lang flags)
   _package_get_variable(COMPILE_${lang}_FLAGS ${pkg_name} _tmp_flags)
   string(REPLACE ";" " " _flags "${_tmp_flags}")
   set(${flags} "${_flags}" PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Include dir
 # ------------------------------------------------------------------------------
 function(_package_set_include_dir pkg_name)
   _package_set_variable(INCLUDE_DIR ${pkg_name} ${ARGN})
 endfunction()
 
 function(_package_get_include_dir pkg_name include_dir)
   _package_get_variable(INCLUDE_DIR ${pkg_name} _include_dir "")
   set(${include_dir} ${_include_dir} PARENT_SCOPE)
 endfunction()
 
 function(_package_add_include_dir pkg_name)
   _package_add_to_variable(INCLUDE_DIR ${pkg_name} ${ARGN})
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Libraries
 # ------------------------------------------------------------------------------
 function(_package_set_libraries pkg_name)
   _package_set_variable(LIBRARIES ${pkg_name} ${ARGN})
 endfunction()
 
 function(_package_get_libraries pkg_name libraries)
   _package_get_variable(LIBRARIES ${pkg_name} _libraries "")
   set(${libraries} ${_libraries} PARENT_SCOPE)
 endfunction()
 
 function(_package_add_libraries pkg_name)
   _package_add_to_variable(LIBRARIES ${pkg_name} ${ARGN})
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Extra dependencies like custom commands of ExternalProject
 # ------------------------------------------------------------------------------
 function(_package_add_extra_dependency pkg_name)
   _package_add_to_variable(EXTRA_DEPENDENCY ${pkg_name} ${ARGN})
 endfunction()
 
 function(_package_rm_extra_dependency pkg_name dep)
   _package_remove_from_variable(EXTRA_DEPENDENCY ${pkg_name} ${dep})
 endfunction()
 
 function(_package_set_extra_dependencies pkg)
   _package_set_variable(EXTRA_DEPENDENCY ${pkg_name} ${ARGN})
 endfunction()
 
 function(_package_get_extra_dependencies pkg deps)
   _package_get_variable(EXTRA_DEPENDENCY ${pkg_name} _deps "")
   set(${deps} ${_deps} PARENT_SCOPE)
 endfunction()
 
 function(_package_unset_extra_dependencies pkg_name)
   _package_variable_unset(EXTRA_DEPENDENCY ${pkg_name})
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Activate/deactivate
 # ------------------------------------------------------------------------------
 function(_package_activate pkg_name)
   _package_set_variable(STATE ${pkg_name} ON)
 endfunction()
 
 function(_package_deactivate pkg_name)
   _package_set_variable(STATE ${pkg_name} OFF)
 endfunction()
 
 function(_package_is_activated pkg_name act)
   _package_get_variable(STATE ${pkg_name} _state OFF)
   if(_state)
     set(${act} TRUE PARENT_SCOPE)
   else()
     set(${act} FALSE PARENT_SCOPE)
   endif()
 endfunction()
 
 function(_package_is_deactivated pkg_name act)
   _package_get_variable(STATE ${pkg_name} _state OFF)
   if(NOT _state)
     set(${act} TRUE PARENT_SCOPE)
   else()
     set(${act} FALSE PARENT_SCOPE)
   endif()
 endfunction()
 
 function(_package_unset_activated pkg_name)
   _package_variable_unset(STATE ${pkg_name})
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Callbacks
 # ------------------------------------------------------------------------------
 function(_package_on_enable_script pkg_name script)
   string(TOLOWER "${pkg_name}" _l_pkg_name)
   set(_output_file "${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/${_l_pkg_name}.cmake")
   file(WRITE "${_output_file}"
     "${script}")
   _package_set_variable(CALLBACK_SCRIPT ${pkg_name} "${_output_file}")
 endfunction()
 
 function(_package_get_callback_script pkg_name filename)
   _package_get_variable(CALLBACK_SCRIPT ${pkg_name} _filename NOTFOUND)
   set(${filename} ${_filename} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Export list
 # ------------------------------------------------------------------------------
 function(_package_add_to_export_list pkg_name)
   _package_add_to_variable(EXPORT_LIST ${pkg_name} ${ARGN})
 endfunction()
 
 function(_package_get_export_list pkg_name export_list)
   _package_get_variable(EXPORT_LIST ${pkg_name} _export_list)
   set(${export_list} ${_export_list} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Direct dependencies
 # ------------------------------------------------------------------------------
-function(_package_add_dependencies pkg_name)
-  _package_add_to_variable(DEPENDENCIES ${pkg_name} ${ARGN})
+function(_package_add_dependencies pkg_name type)
+  _package_add_to_variable(DEPENDENCIES_${type} ${pkg_name} ${ARGN})
 endfunction()
 
-function(_package_get_dependencies pkg_name dependencies)
-  _package_get_variable(DEPENDENCIES ${pkg_name} _dependencies)
+function(_package_get_dependencies pkg_name type dependencies)
+  _package_get_variable(DEPENDENCIES_${type} ${pkg_name} _dependencies)
   set(${dependencies} ${_dependencies} PARENT_SCOPE)
 endfunction()
 
-function(_package_unset_dependencies pkg_name)
-  _package_variable_unset(DEPENDENCIES ${pkg_name})
+function(_package_unset_dependencies pkg_name type)
+  _package_variable_unset(DEPENDENCIES_${type} ${pkg_name})
 endfunction()
 
-function(_package_remove_dependency pkg_name dep)
-  set(_deps ${${pkg_name}_DEPENDENCIES})
+function(_package_remove_dependency pkg_name type dep)
+  set(_deps ${${pkg_name}_DEPENDENCIES_${type}})
 
   _package_get_fdependencies(${dep} _fdeps)
 
   # check if this is the last reverse dependency
   list(LENGTH _fdeps len)
   list(FIND _fdeps ${pkg_name} pos)
   if((len EQUAL 1) AND (NOT pos EQUAL -1))
     _package_get_description(${dep} _dep_desc)
     _package_get_option_name(${dep} _dep_option_name)
     set(${_dep_option_name} ${${dep}_OLD} CACHE BOOL "${_dep_desc}" FORCE)
     unset(${dep}_OLD CACHE)
   endif()
 
   # remove the pkg_name form the reverse dependency
   _package_remove_fdependency(${dep} ${pkg_name})
 
   list(FIND _deps ${dep} pos)
   if(NOT pos EQUAL -1)
     list(REMOVE_AT _deps ${pos})
-    _package_set_variable(DEPENDENCIES ${pkg_name} ${_deps})
+    _package_set_variable(DEPENDENCIES_${type} ${pkg_name} ${_deps})
   endif()
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Functions to handle reverse dependencies
 # ------------------------------------------------------------------------------
 function(_package_set_rdependencies pkg_name)
   _package_set_variable(RDEPENDENCIES ${pkg_name} ${ARGN})
 endfunction()
 
 function(_package_get_rdependencies pkg_name rdependencies)
   _package_get_variable(RDEPENDENCIES ${pkg_name} _rdependencies)
   set(${rdependencies} ${_rdependencies} PARENT_SCOPE)
 endfunction()
 
 function(_package_add_rdependency pkg_name rdep)
   # store the reverse dependency
   _package_add_to_variable(RDEPENDENCIES ${pkg_name} ${rdep})
 endfunction()
 
 function(_package_remove_rdependency pkg_name rdep)
   _package_remove_from_variable(RDEPENDENCIES ${pkg_name} ${rdep})
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Function to handle forcing dependencies (Package turn ON that enforce their
 # dependencies ON)
 # ------------------------------------------------------------------------------
 function(_package_set_fdependencies pkg_name)
   _package_set_variable(FDEPENDENCIES ${pkg_name} ${ARGN})
 endfunction()
 
 function(_package_get_fdependencies pkg_name fdependencies)
   _package_get_variable(FDEPENDENCIES ${pkg_name} _fdependencies)
   set(${fdependencies} ${_fdependencies} PARENT_SCOPE)
 endfunction()
 
 function(_package_add_fdependency pkg_name fdep)
   # store the reverse dependency
   _package_add_to_variable(FDEPENDENCIES ${pkg_name} ${fdep})
 endfunction()
 
 function(_package_remove_fdependency pkg_name fdep)
   _package_remove_from_variable(FDEPENDENCIES ${pkg_name} ${fdep})
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Exteral package system as apt rpm dependencies
 # ------------------------------------------------------------------------------
 function(_package_set_package_system_dependency pkg system)
   string(TOUPPER "${_system}" _u_system)
   _package_set_variable(PACKAGE_SYSTEM_${_u_system} ${_pkg_name} ${ARGN})
 endfunction()
 
 
 function(_package_get_package_system_dependency pkg system var)
   string(TOUPPER "${_system}" _u_system)
   _package_get_variable(PACKAGE_SYSTEM_${_u_system} ${_pkg_name} ${_deps})
   set(${var} ${_deps} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Documentation related functions
 # ------------------------------------------------------------------------------
 function(_package_set_documentation_files pkg_name)
   _package_set_variable(DOCUMENTATION_FILES ${pkg_name} ${ARGN})
 endfunction()
 
 function(_package_get_documentation_files pkg_name doc_files)
   _package_get_variable(DOCUMENTATION_FILES ${pkg_name} _doc_files "")
   set(${doc_files} ${_doc_files} PARENT_SCOPE)
 endfunction()
 
 function(_package_set_documentation pkg_name)
   # \n replaced by && and \\ by ££ to avoid cache problems
   set(_doc_str "")
   foreach(_str ${ARGN})
     set(_doc_str "${_doc_str}&&${_str}")
   endforeach()
 
   string(REPLACE "\\" "££" _doc_escaped "${_doc_str}")
 
   _package_set_variable(DOCUMENTATION ${pkg_name} "${_doc_str}")
 endfunction()
 
 function(_package_get_documentation pkg_name _doc)
   # \n replaced by && and \\ by ££ to avoid cache problems
   _package_get_variable(DOCUMENTATION ${pkg_name} _doc_tmp "")
 
   string(REPLACE "££" "\\" _doc_escaped "${_doc_tmp}")
   string(REPLACE "&&" "\n" _doc_newlines "${_doc_escaped}")
   set(${_doc} "${_doc_newlines}" PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Special boost thingy
 # ------------------------------------------------------------------------------
 function(_package_set_boost_component_needed pkg_name)
   _package_add_to_variable(BOOST_COMPONENTS_NEEDED ${pkg_name} ${ARGN})
   package_get_name(Boost _boost_pkg_name)
-  _package_add_dependencies(${pkg_name} ${_boost_pkg_name})
+  _package_add_dependencies(${pkg_name} PRIVATE ${_boost_pkg_name})
 endfunction()
 
 function(_package_get_boost_component_needed pkg_name needed)
   _package_get_variable(BOOST_COMPONENTS_NEEDED ${pkg_name} _needed)
   set(${needed} ${_needed} PARENT_SCOPE)
 endfunction()
 
 function(_package_load_boost_components)
   string(TOUPPER ${PROJECT_NAME} _project)
 
   _package_get_variable_for_activated(BOOST_COMPONENTS_NEEDED _boost_needed_components)
   package_get_name(Boost _pkg_name)
 
   if(_boost_needed_components)
     message(STATUS "Looking for Boost liraries: ${_boost_needed_components}")
     foreach(_comp ${_boost_needed_components})
       find_package(Boost COMPONENTS ${_comp} QUIET)
       string(TOUPPER ${_comp} _u_comp)
       if(Boost_${_u_comp}_FOUND)
         message(STATUS "   ${_comp}: FOUND")
         package_set_project_variable(BOOST_${_u_comp} TRUE)
 
         # Generate the libraries for the package
         _package_add_libraries(${_pkg_name} ${Boost_${_u_comp}_LIBRARY})
       else()
         message(STATUS "   ${_comp}: NOT FOUND")
       endif()
     endforeach()
   endif()
 endfunction()
 
 # ------------------------------------------------------------------------------
 # get the list of source files for a given package
 # ------------------------------------------------------------------------------
 function(_package_get_source_files pkg_name SRCS PUBLIC_HEADERS PRIVATE_HEADERS)
   string(TOUPPER ${PROJECT_NAME} _project)
 
   set(tmp_SRCS)
   set(tmp_PUBLIC_HEADERS)
   set(tmp_PRIVATE_HEADERS)
 
   foreach(_type SRCS PUBLIC_HEADERS PRIVATE_HEADERS)
     foreach(_file ${${pkg_name}_${_type}})
       string(REPLACE "${CMAKE_CURRENT_SOURCE_DIR}/" "" _rel_file "${_file}")
       list(APPEND tmp_${_type} "${_rel_file}")
     endforeach()
   endforeach()
 
   set(${SRCS}            ${tmp_SRCS}            PARENT_SCOPE)
   set(${PUBLIC_HEADERS}  ${tmp_PUBLIC_HEADERS}  PARENT_SCOPE)
   set(${PRIVATE_HEADERS} ${tmp_PRIVATE_HEADERS} PARENT_SCOPE)
 endfunction()
 
 # ==============================================================================
 # Internal functions
 # ==============================================================================
 # ------------------------------------------------------------------------------
 # Build the reverse dependencies from the dependencies
 # ------------------------------------------------------------------------------
 function(_package_build_rdependencies)
   package_get_all_packages(_pkg_list)
 
   # set empty lists
   foreach(_pkg_name ${_pkg_list})
     set(${_pkg_name}_rdeps)
   endforeach()
 
   # fill the dependencies list
   foreach(_pkg_name ${_pkg_list})
-    _package_get_dependencies(${_pkg_name} _deps)
-    foreach(_dep_name ${_deps})
+    _package_get_dependencies(${_pkg_name} PRIVATE _deps_priv)
+    _package_get_dependencies(${_pkg_name} INTERFACE _deps_interface)
+    foreach(_dep_name ${_deps_priv} ${_deps_interface})
       list(APPEND ${_dep_name}_rdeps ${_pkg_name})
     endforeach()
   endforeach()
 
   # clean and set the reverse dependencies
   foreach(_pkg_name ${_pkg_list})
     if(${_pkg_name}_rdeps)
       list(REMOVE_DUPLICATES ${_pkg_name}_rdeps)
       _package_set_rdependencies(${_pkg_name} ${${_pkg_name}_rdeps})
     endif()
   endforeach()
 endfunction()
 
 # ------------------------------------------------------------------------------
 # This function resolve the dependance order run the needed find_packages
 # ------------------------------------------------------------------------------
 function(_package_load_packages)
   package_get_all_packages(_pkg_list)
 
   # Activate the dependencies of activated package and generate an ordered list
   # of dependencies
   set(ordered_loading_list)
   foreach(_pkg_name ${_pkg_list})
     _package_load_dependencies_package(${_pkg_name} ordered_loading_list)
   endforeach()
 
   # Load the packages in the propoer order
   foreach(_pkg_name ${ordered_loading_list})
     _package_get_option_name(${_pkg_name} _option_name)
 
     if(${_option_name})
       _package_load_package(${_pkg_name})
     else()
       # deactivate the packages than can already be deactivated
       _package_deactivate(${_pkg_name})
     endif()
   endforeach()
 
   # generates the activated and unactivated lists of packages
   set(_packages_activated)
   set(_packages_deactivated)
   foreach(_pkg_name ${_pkg_list})
     _package_is_activated(${_pkg_name} _active)
     set(_exclude FALSE)
     _package_get_variable(EXCLUDE_FROM_ALL ${_pkg_name} _exclude)
     if(_active AND NOT _exclude)
       list(APPEND _packages_activated ${_pkg_name})
     else()
       list(APPEND _packages_deactivated ${_pkg_name})
     endif()
   endforeach()
 
   # generate the list usable by the calling code
   package_set_project_variable(ACTIVATED_PACKAGE_LIST "${_packages_activated}")
   package_set_project_variable(DEACTIVATED_PACKAGE_LIST "${_packages_deactivated}")
 endfunction()
 
 
 
 # ------------------------------------------------------------------------------
 # This load an external package and recursively all its dependencies
 # ------------------------------------------------------------------------------
 function(_package_load_dependencies_package pkg_name loading_list)
   # Get packages informations
   _package_get_option_name(${pkg_name} _pkg_option_name)
-  _package_get_dependencies(${pkg_name} _dependencies)
+  _package_get_dependencies(${pkg_name} PRIVATE _deps_private)
+  _package_get_dependencies(${pkg_name} INTERFACE _deps_interface)
+  set(_dependencies ${_deps_private} ${_deps_interface})
 
   # handle the dependencies
   foreach(_dep_name ${_dependencies})
     _package_get_description(${_dep_name} _dep_desc)
     _package_get_option_name(${_dep_name} _dep_option_name)
 
     _package_get_fdependencies(${_dep_name} _fdeps)
     if(${_pkg_option_name})
       if("${_fdeps}" STREQUAL "")
         set(${_dep_name}_OLD ${${_dep_option_name}} CACHE INTERNAL "" FORCE)
       endif()
 
       # set the option to on
       set(${_dep_option_name} ON CACHE BOOL "${_dep_desc}" FORCE)
 
       # store the reverse dependency
       _package_add_fdependency(${_dep_name} ${pkg_name})
     else()
       # check if this is the last reverse dependency
       list(LENGTH _fdeps len)
       list(FIND _fdeps ${pkg_name} pos)
       if((len EQUAL 1) AND (NOT pos EQUAL -1))
         set(${_dep_option_name} ${${_dep_name}_OLD} CACHE BOOL "${_dep_desc}" FORCE)
         unset(${_dep_name}_OLD CACHE)
       endif()
 
       # remove the pkg_name form the reverse dependency
       _package_remove_fdependency(${_dep_name} ${pkg_name})
     endif()
 
     # recusively load the dependencies
     _package_load_dependencies_package(${_dep_name} ${loading_list})
   endforeach()
 
   # get the compile flags
   _package_get_compile_flags(${pkg_name} CXX _pkg_compile_flags)
   package_get_project_variable(NO_AUTO_COMPILE_FLAGS _no_auto_compile_flags)
 
   # if package option is on add it in the list
   if(${_pkg_option_name})
     list(FIND ${loading_list} ${pkg_name} _pos)
     if(_pos EQUAL -1)
       set(_tmp_loading_list ${${loading_list}})
       list(APPEND _tmp_loading_list ${pkg_name})
       set(${loading_list} "${_tmp_loading_list}" PARENT_SCOPE)
     endif()
 
     #add the comilation flags if needed
     if(_pkg_compile_flags AND NOT _no_auto_compile_flags)
       add_flags(cxx ${_pkg_compile_flags})
     endif()
   else()
     #remove the comilation flags if needed
     if(_pkg_comile_flags AND NOT _no_auto_compile_flags)
       remove_flags(cxx ${_pkg_compile_flags})
     endif()
   endif()
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Load the package if it is an external one
 # ------------------------------------------------------------------------------
 function(_package_load_package pkg_name)
   # load the package if it is an external
   _package_get_nature(${pkg_name} _nature)
   if(${_nature} MATCHES "external")
     _package_use_system(${pkg_name} _use_system)
 
     set(_activated TRUE)
     if(_use_system)
       _package_load_external_package(${pkg_name} _activated)
     endif()
 
     _package_has_system_fallback(${pkg_name} _fallback)
     if((NOT _use_system) OR (_fallback AND (NOT _activated)))
       _package_load_third_party_script(${pkg_name})
       set(_activated TRUE)
     endif()
 
     if(_activated)
       _package_activate(${pkg_name})
     elseif()
       _package_deactivate(${pkg_name})
     endif()
   else()
     _package_activate(${pkg_name})
   endif()
 endfunction()
 
 
 # ------------------------------------------------------------------------------
 # Load external packages
 # ------------------------------------------------------------------------------
 function(_package_load_external_package pkg_name activate)
   _package_get_real_name(${pkg_name} _real_name)
   string(TOUPPER ${_real_name} _u_package)
 
   if(NOT ${pkg_name}_USE_SYSTEM_PREVIOUS)
     #if system was off before clear the cache of preset variables
     get_cmake_property(_all_vars VARIABLES)
     foreach(_var ${_all_vars})
       if(_var MATCHES "^${_u_package}_.*")
         unset(${_var} CACHE)
       endif()
     endforeach()
     set(${pkg_name}_USE_SYSTEM_PREVIOUS TRUE CACHE INTERNAL "" FORCE)
   endif()
 
   _package_get_find_package_extra_options(${pkg_name} _options)
   if(_options)
     cmake_parse_arguments(_opt_pkg "" "LANGUAGE" "LINK_LIBRARIES;PREFIX;FOUND;ARGS" ${_options})
     if(_opt_pkg_UNPARSED_ARGUMENTS)
       message("You passed too many options for the find_package related to ${${pkg_name}} \"${_opt_pkg_UNPARSED_ARGUMENTS}\"")
     endif()
   endif()
 
   if(_opt_pkg_LANGUAGE)
     foreach(_language ${_opt_pkg_LANGUAGE})
       enable_language(${_language})
     endforeach()
   endif()
 
   # find the package
   set(_required REQUIRED)
   _package_has_system_fallback(${pkg_name} _fallback)
   if(_fallback)
     set(_required QUIET)
   endif()
 
   find_package(${_real_name} ${_required} ${_opt_pkg_ARGS})
 
   # check if the package is found
   if(_opt_pkg_PREFIX)
     set(_package_prefix ${_opt_pkg_PREFIX})
   else()
     set(_package_prefix ${_u_package})
   endif()
 
   set(_act FALSE)
   set(_prefix_to_consider)
   if(DEFINED _opt_pkg_FOUND)
     if(${_opt_pkg_FOUND})
       set(_act TRUE)
       set(_prefix_to_consider ${_package_prefix})
     endif()
   else()
     foreach(_prefix ${_package_prefix})
       if(${_prefix}_FOUND)
         set(_act TRUE)
         list(APPEND _prefix_to_consider ${_prefix})
       endif()
     endforeach()
   endif()
 
   if(_act)
     foreach(_prefix ${_prefix_to_consider})
       # Generate the include dir for the package
       if(DEFINED ${_prefix}_INCLUDE_DIRS)
         _package_set_include_dir(${pkg_name} ${${_prefix}_INCLUDE_DIRS})
       elseif(DEFINED ${_prefix}_INCLUDE_DIR)
         _package_set_include_dir(${pkg_name} ${${_prefix}_INCLUDE_DIR})
       elseif(DEFINED ${_prefix}_INCLUDE_PATH)
         _package_set_include_dir(${pkg_name} ${${_prefix}_INCLUDE_PATH})
       endif()
 
       # Generate the libraries for the package
       if(_opt_pkg_LINK_LIBRARIES)
         _package_set_libraries(${pkg_name} ${_opt_pkg_LINK_LIBRARIES})
       elseif(DEFINED ${_prefix}_LIBRARIES)
         _package_set_libraries(${pkg_name} ${${_prefix}_LIBRARIES})
       elseif(DEFINED ${_prefix}_LIBRARY)
         _package_set_libraries(${pkg_name} ${${_prefix}_LIBRARY})
       endif()
     endforeach()
 
     _package_get_callback_script(${pkg_name} _script_file)
     if(_script_file)
       include("${_script_file}")
     endif()
   endif()
   set(${activate} ${_act} PARENT_SCOPE)
 endfunction()
 
 # ------------------------------------------------------------------------------
 # Sanity check functions
 # ------------------------------------------------------------------------------
 function(_package_check_files_exists)
   set(_message FALSE)
 
   package_get_all_packages(_pkg_list)
   foreach(_pkg_name ${_pkg_list})
     set(_pkg_files
       ${${_pkg_name}_SRCS}
       ${${_pkg_name}_PUBLIC_HEADERS}
       ${${_pkg_name}_PRIVATE_HEADERS}
       )
 
     _package_get_real_name(${_pkg_name} _real_name)
 
     foreach(_file ${_pkg_files})
       if(NOT EXISTS "${_file}")
         if(NOT _message)
           set(_message TRUE)
           message("This file(s) is(are) present in a package but are not present on disk.")
         endif()
 
         message(" PACKAGE ${_real_name} FILE ${_file}")
       endif()
     endforeach()
   endforeach()
 
   if(_message)
     message(SEND_ERROR "Please check the content of your packages to correct this warnings")
   endif()
 endfunction()
 
 # ------------------------------------------------------------------------------
 function(_package_check_files_registered)
   set(_pkg_files)
   package_get_all_packages(_pkg_list)
   # generates a file list of registered files
   foreach(_pkg_name ${_pkg_list})
     list(APPEND _pkg_files
       ${${_pkg_name}_SRCS}
       ${${_pkg_name}_PUBLIC_HEADERS}
       ${${_pkg_name}_PRIVATE_HEADERS}
       )
   endforeach()
 
   # generates the list of files in the source folders
   set(_all_src_files)
   foreach(_src_folder ${ARGN})
     foreach(_ext "cc" "hh" "c" "h" "hpp")
       file(GLOB_RECURSE _src_files "${_src_folder}/*.${_ext}")
       list(APPEND _all_src_files ${_src_files})
     endforeach()
   endforeach()
 
   if(_all_src_files)
     list(REMOVE_DUPLICATES _all_src_files)
   endif()
 
   set(_not_registerd_files)
   # check only sources files in the source folders
   foreach(_src_folder ${ARGN})
     foreach(_file ${_all_src_files})
       if("${_file}" MATCHES  "${_src_folder}")
         list(FIND _pkg_files "${_file}" _index)
         if (_index EQUAL -1)
           list(APPEND _not_registerd_files ${_file})
         endif()
       endif()
     endforeach()
   endforeach()
 
   if(AUTO_MOVE_UNKNOWN_FILES)
     file(MAKE_DIRECTORY ${PROJECT_BINARY_DIR}/unknown_files)
   endif()
 
   # warn the user and move the files if needed
   if(_not_registerd_files)
     if(EXISTS ${PROJECT_BINARY_DIR}/missing_files_in_packages)
       file(REMOVE ${PROJECT_BINARY_DIR}/missing_files_in_packages)
     endif()
 
     message("This files are present in the source folders but are not registered in any package")
     foreach(_file ${_not_registerd_files})
       message(" ${_file}")
       if(AUTO_MOVE_UNKNOWN_FILES)
         get_filename_component(_file_name ${_file} NAME)
         file(RENAME ${_file} ${PROJECT_BINARY_DIR}/unknown_files/${_file_name})
       endif()
 
       file(APPEND ${PROJECT_BINARY_DIR}/missing_files_in_packages "${_file}
 ")
     endforeach()
 
     if(AUTO_MOVE_UNKNOWN_FILES)
       message(SEND_ERROR "The files where moved in the followinf folder ${PROJECT_BINARY_DIR}/unknown_files\n
 Please register them in the good package or clean the sources")
     else()
       message(SEND_ERROR "Please register them in the good package or clean the sources")
     endif()
 
   endif()
 endfunction()
 
 # ------------------------------------------------------------------------------
diff --git a/packages/boost.cmake b/packages/boost.cmake
index 7d5470574..2f2da6745 100644
--- a/packages/boost.cmake
+++ b/packages/boost.cmake
@@ -1,68 +1,67 @@
 #===============================================================================
 # @file   boost.cmake
 #
 # @author Nicolas Richart <nicolas.richart@epfl.ch>
 #
 # @date creation: Fri Sep 03 2010
 # @date last modification: Wed Jan 20 2016
 #
 # @brief  package handling the dependencies to boost
 #
 # @section LICENSE
 #
 # Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
 # Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
 # Solides)
 #
 # Akantu 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 3 of the License, or (at your option) any
 # later version.
 #
 # Akantu 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 Akantu. If not, see <http://www.gnu.org/licenses/>.
 #
 #===============================================================================
-
 set(Boost_NO_BOOST_CMAKE ON CACHE BOOL "" FORCE)
 
 package_declare(Boost EXTERNAL
   NOT_OPTIONAL
   DESCRIPTION "Package handling boost components"
   EXTRA_PACKAGE_OPTIONS PREFIX Boost
   )
 
 mark_as_advanced(Boost_DIR)
 
 package_on_enabled_script(Boost
   "if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER \"4.8\")
   set(_boost_version \${Boost_MAJOR_VERSION}.\${Boost_MINOR_VERSION})
   if(_boost_version VERSION_LESS 1.58 AND _boost_version VERSION_GREATER 1.53)
     package_set_compile_flags(Boost CXX -DBOOST_SPIRIT_USE_PHOENIX_V3)
   else()
     package_unset_compile_flags(Boost CXX)
   endif()
 endif()
 ")
 
 
 package_declare_documentation(Boost
   "Akantu uses Boost header only for preprocessor and Spirit"
   ""
   "Under Ubuntu (14.04 LTS) the installation can be performed using the commands:"
   "\\begin{command}"
   "  > sudo apt-get install libboost"
   "\\end{command}"
   ""
 )
 
 package_set_package_system_dependency(Boost deb-src libboost-dev)
 
 # only build dependency
 # package_set_package_system_dependency(Boost deb libboost)
 # package_set_package_system_dependency(Boost rmp boost)
diff --git a/packages/core.cmake b/packages/core.cmake
index 6f07cadbf..5acfb41bd 100644
--- a/packages/core.cmake
+++ b/packages/core.cmake
@@ -1,516 +1,517 @@
 #===============================================================================
 # @file   core.cmake
 #
 # @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
 # @author Nicolas Richart <nicolas.richart@epfl.ch>
 #
 # @date creation: Mon Nov 21 2011
 # @date last modification: Mon Jan 18 2016
 #
 # @brief  package description for core
 #
 # @section LICENSE
 #
 # Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
 # Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
 # Solides)
 #
 # Akantu 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 3 of the License, or (at your option) any
 # later version.
 #
 # Akantu 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 Akantu. If not, see <http://www.gnu.org/licenses/>.
 #
 #===============================================================================
 package_declare(core NOT_OPTIONAL
   DESCRIPTION "core package for Akantu"
-  FEATURES_PUBLIC cxx_strong_enums cxx_defaulted_functions cxx_deleted_functions
-  cxx_auto_type cxx_decltype_auto
-  FEATURES_PRIVATE cxx_lambdas cxx_nullptr cxx_delegated_constructors
-  cxx_range_for )
+  FEATURES_PUBLIC cxx_strong_enums cxx_defaulted_functions
+                  cxx_deleted_functions cxx_auto_type cxx_decltype_auto
+  FEATURES_PRIVATE cxx_lambdas cxx_nullptr cxx_range_for
+		   cxx_delegating_constructors
+  DEPENDS INTERFACE Boost)
 
 package_declare_sources(core
   common/aka_array.cc
   common/aka_array.hh
   common/aka_array_tmpl.hh
   common/aka_blas_lapack.hh
   common/aka_circular_array.hh
   common/aka_circular_array_inline_impl.cc
   common/aka_common.cc
   common/aka_common.hh
   common/aka_common_inline_impl.cc
   common/aka_csr.hh
   common/aka_element_classes_info_inline_impl.cc
   common/aka_error.cc
   common/aka_error.hh
   common/aka_event_handler_manager.hh
   common/aka_extern.cc
   common/aka_factory.hh
   common/aka_fwd.hh
   common/aka_grid_dynamic.hh
   common/aka_math.cc
   common/aka_math.hh
   common/aka_math_tmpl.hh
   common/aka_memory.cc
   common/aka_memory.hh
   common/aka_memory_inline_impl.cc
   common/aka_named_argument.hh
   common/aka_random_generator.hh
   common/aka_safe_enum.hh
   common/aka_static_memory.cc
   common/aka_static_memory.hh
   common/aka_static_memory_inline_impl.cc
   common/aka_static_memory_tmpl.hh
   common/aka_typelist.hh
   common/aka_types.hh
   common/aka_visitor.hh
   common/aka_voigthelper.hh
   common/aka_voigthelper_tmpl.hh
   common/aka_voigthelper.cc
   common/aka_warning.hh
   common/aka_warning_restore.hh
   common/aka_iterators.hh
   common/aka_static_if.hh
   common/aka_compatibilty_with_cpp_standard.hh
 
   fe_engine/element_class.hh
   fe_engine/element_class_tmpl.hh
   fe_engine/element_classes/element_class_hexahedron_8_inline_impl.cc
   fe_engine/element_classes/element_class_hexahedron_20_inline_impl.cc
   fe_engine/element_classes/element_class_pentahedron_6_inline_impl.cc
   fe_engine/element_classes/element_class_pentahedron_15_inline_impl.cc
   fe_engine/element_classes/element_class_point_1_inline_impl.cc
   fe_engine/element_classes/element_class_quadrangle_4_inline_impl.cc
   fe_engine/element_classes/element_class_quadrangle_8_inline_impl.cc
   fe_engine/element_classes/element_class_segment_2_inline_impl.cc
   fe_engine/element_classes/element_class_segment_3_inline_impl.cc
   fe_engine/element_classes/element_class_tetrahedron_10_inline_impl.cc
   fe_engine/element_classes/element_class_tetrahedron_4_inline_impl.cc
   fe_engine/element_classes/element_class_triangle_3_inline_impl.cc
   fe_engine/element_classes/element_class_triangle_6_inline_impl.cc
   fe_engine/element_type_conversion.hh
 
   fe_engine/fe_engine.cc
   fe_engine/fe_engine.hh
   fe_engine/fe_engine_inline_impl.cc
   fe_engine/fe_engine_template.hh
   fe_engine/fe_engine_template_tmpl_field.hh
   fe_engine/fe_engine_template_tmpl.hh
   fe_engine/geometrical_element_property.hh
   fe_engine/geometrical_element_property.cc
   fe_engine/gauss_integration.cc
   fe_engine/gauss_integration_tmpl.hh
   fe_engine/integrator.hh
   fe_engine/integrator_gauss.hh
   fe_engine/integrator_gauss_inline_impl.cc
   fe_engine/interpolation_element_tmpl.hh
   fe_engine/integration_point.hh
   fe_engine/shape_functions.hh
   fe_engine/shape_functions.cc
   fe_engine/shape_functions_inline_impl.cc
   fe_engine/shape_lagrange_base.cc
   fe_engine/shape_lagrange_base.hh
   fe_engine/shape_lagrange_base_inline_impl.cc
   fe_engine/shape_lagrange.hh
   fe_engine/shape_lagrange_inline_impl.cc
   fe_engine/element.hh
 
   io/dumper/dumpable.hh
   io/dumper/dumpable.cc
   io/dumper/dumpable_dummy.hh
   io/dumper/dumpable_inline_impl.hh
   io/dumper/dumper_field.hh
   io/dumper/dumper_material_padders.hh
   io/dumper/dumper_filtered_connectivity.hh
   io/dumper/dumper_element_partition.hh
 
   io/mesh_io.cc
   io/mesh_io.hh
   io/mesh_io/mesh_io_abaqus.cc
   io/mesh_io/mesh_io_abaqus.hh
   io/mesh_io/mesh_io_diana.cc
   io/mesh_io/mesh_io_diana.hh
   io/mesh_io/mesh_io_msh.cc
   io/mesh_io/mesh_io_msh.hh
   #io/model_io.cc
   #io/model_io.hh
 
   io/parser/algebraic_parser.hh
   io/parser/input_file_parser.hh
   io/parser/parsable.cc
   io/parser/parsable.hh
   io/parser/parser.cc
   io/parser/parser_real.cc
   io/parser/parser_random.cc
   io/parser/parser_types.cc
   io/parser/parser_input_files.cc
   io/parser/parser.hh
   io/parser/parser_tmpl.hh
   io/parser/parser_grammar_tmpl.hh
   io/parser/cppargparse/cppargparse.hh
   io/parser/cppargparse/cppargparse.cc
   io/parser/cppargparse/cppargparse_tmpl.hh
 
   io/parser/parameter_registry.cc
   io/parser/parameter_registry.hh
   io/parser/parameter_registry_tmpl.hh
 
   mesh/element_group.cc
   mesh/element_group.hh
   mesh/element_group_inline_impl.cc
   mesh/element_type_map.cc
   mesh/element_type_map.hh
   mesh/element_type_map_tmpl.hh
   mesh/element_type_map_filter.hh
   mesh/group_manager.cc
   mesh/group_manager.hh
   mesh/group_manager_inline_impl.cc
   mesh/mesh.cc
   mesh/mesh.hh
   mesh/mesh_accessor.hh
   mesh/mesh_events.hh
   mesh/mesh_filter.hh
   mesh/mesh_data.cc
   mesh/mesh_data.hh
   mesh/mesh_data_tmpl.hh
   mesh/mesh_inline_impl.cc
   mesh/node_group.cc
   mesh/node_group.hh
   mesh/node_group_inline_impl.cc
   mesh/mesh_iterators.hh
 
   mesh_utils/mesh_partition.cc
   mesh_utils/mesh_partition.hh
   mesh_utils/mesh_partition/mesh_partition_mesh_data.cc
   mesh_utils/mesh_partition/mesh_partition_mesh_data.hh
   mesh_utils/mesh_partition/mesh_partition_scotch.hh
   mesh_utils/mesh_utils_pbc.cc
   mesh_utils/mesh_utils.cc
   mesh_utils/mesh_utils.hh
   mesh_utils/mesh_utils_distribution.cc
   mesh_utils/mesh_utils_distribution.hh
   mesh_utils/mesh_utils.hh
   mesh_utils/mesh_utils_inline_impl.cc
   mesh_utils/global_ids_updater.hh
   mesh_utils/global_ids_updater.cc
   mesh_utils/global_ids_updater_inline_impl.cc
 
   model/boundary_condition.hh
   model/boundary_condition_functor.hh
   model/boundary_condition_functor_inline_impl.cc
   model/boundary_condition_tmpl.hh
 
   model/common/neighborhood_base.hh
   model/common/neighborhood_base.cc
   model/common/neighborhood_base_inline_impl.cc
   model/common/neighborhoods_criterion_evaluation/neighborhood_max_criterion.hh
   model/common/neighborhoods_criterion_evaluation/neighborhood_max_criterion.cc
   model/common/neighborhoods_criterion_evaluation/neighborhood_max_criterion_inline_impl.cc
   model/common/non_local_toolbox/non_local_manager.hh
   model/common/non_local_toolbox/non_local_manager.cc
   model/common/non_local_toolbox/non_local_manager_inline_impl.cc
   model/common/non_local_toolbox/non_local_manager_callback.hh
   model/common/non_local_toolbox/non_local_neighborhood_base.hh
   model/common/non_local_toolbox/non_local_neighborhood_base.cc
   model/common/non_local_toolbox/non_local_neighborhood.hh
   model/common/non_local_toolbox/non_local_neighborhood_tmpl.hh
   model/common/non_local_toolbox/non_local_neighborhood_inline_impl.cc
   model/common/non_local_toolbox/base_weight_function.hh
   model/common/non_local_toolbox/base_weight_function_inline_impl.cc
 
   model/dof_manager.cc
   model/dof_manager.hh
   model/dof_manager_default.cc
   model/dof_manager_default.hh
   model/dof_manager_default_inline_impl.cc
   model/dof_manager_inline_impl.cc
   model/model_solver.cc
   model/model_solver.hh
   model/model_solver_tmpl.hh
   model/non_linear_solver.cc
   model/non_linear_solver.hh
   model/non_linear_solver_default.hh
   model/non_linear_solver_lumped.cc
   model/non_linear_solver_lumped.hh
   model/solver_callback.hh
   model/solver_callback.cc
   model/time_step_solver.hh
   model/time_step_solvers/time_step_solver.cc
   model/time_step_solvers/time_step_solver_default.cc
   model/time_step_solvers/time_step_solver_default.hh
   model/time_step_solvers/time_step_solver_default_explicit.hh
   model/non_linear_solver_callback.hh
   model/time_step_solvers/time_step_solver_default_solver_callback.hh
 
   model/integration_scheme/generalized_trapezoidal.cc
   model/integration_scheme/generalized_trapezoidal.hh
   model/integration_scheme/integration_scheme.cc
   model/integration_scheme/integration_scheme.hh
   model/integration_scheme/integration_scheme_1st_order.cc
   model/integration_scheme/integration_scheme_1st_order.hh
   model/integration_scheme/integration_scheme_2nd_order.cc
   model/integration_scheme/integration_scheme_2nd_order.hh
   model/integration_scheme/newmark-beta.cc
   model/integration_scheme/newmark-beta.hh
   model/integration_scheme/pseudo_time.cc
   model/integration_scheme/pseudo_time.hh
   model/model.cc
   model/model.hh
   model/model_inline_impl.cc
   model/model_options.hh
 
   solver/sparse_solver.cc
   solver/sparse_solver.hh
   solver/sparse_solver_inline_impl.cc
   solver/sparse_matrix.cc
   solver/sparse_matrix.hh
   solver/sparse_matrix_inline_impl.cc
   solver/sparse_matrix_aij.cc
   solver/sparse_matrix_aij.hh
   solver/sparse_matrix_aij_inline_impl.cc
   solver/terms_to_assemble.hh
 
   synchronizer/communication_buffer_inline_impl.cc
   synchronizer/communication_descriptor.hh
   synchronizer/communication_descriptor_tmpl.hh
   synchronizer/communication_request.hh
   synchronizer/communication_tag.hh
   synchronizer/communications.hh
   synchronizer/communications_tmpl.hh
   synchronizer/communicator.cc
   synchronizer/communicator.hh
   synchronizer/communicator_dummy_inline_impl.cc
   synchronizer/communicator_event_handler.hh
   synchronizer/communicator_inline_impl.hh
   synchronizer/data_accessor.cc
   synchronizer/data_accessor.hh
   synchronizer/dof_synchronizer.cc
   synchronizer/dof_synchronizer.hh
   synchronizer/dof_synchronizer_inline_impl.cc
   synchronizer/element_info_per_processor.cc
   synchronizer/element_info_per_processor.hh
   synchronizer/element_info_per_processor_tmpl.hh
   synchronizer/element_synchronizer.cc
   synchronizer/element_synchronizer.hh
   synchronizer/facet_synchronizer.cc
   synchronizer/facet_synchronizer.hh
   synchronizer/facet_synchronizer_inline_impl.cc
   synchronizer/grid_synchronizer.cc
   synchronizer/grid_synchronizer.hh
   synchronizer/grid_synchronizer_tmpl.hh
   synchronizer/master_element_info_per_processor.cc
   synchronizer/node_info_per_processor.cc
   synchronizer/node_info_per_processor.hh
   synchronizer/node_synchronizer.cc
   synchronizer/node_synchronizer.hh
   synchronizer/slave_element_info_per_processor.cc
   synchronizer/synchronizer.cc
   synchronizer/synchronizer.hh
   synchronizer/synchronizer_impl.hh
   synchronizer/synchronizer_impl_tmpl.hh
   synchronizer/synchronizer_registry.cc
   synchronizer/synchronizer_registry.hh
   synchronizer/synchronizer_tmpl.hh
   synchronizer/communication_buffer.hh
   )
 
 set(AKANTU_SPIRIT_SOURCES
   io/mesh_io/mesh_io_abaqus.cc
   io/parser/parser_real.cc
   io/parser/parser_random.cc
   io/parser/parser_types.cc
   io/parser/parser_input_files.cc
   PARENT_SCOPE
   )
 
 package_declare_elements(core
   ELEMENT_TYPES
   _point_1
   _segment_2
   _segment_3
   _triangle_3
   _triangle_6
   _quadrangle_4
   _quadrangle_8
   _tetrahedron_4
   _tetrahedron_10
   _pentahedron_6
   _pentahedron_15
   _hexahedron_8
   _hexahedron_20
   KIND regular
   GEOMETRICAL_TYPES
   _gt_point
   _gt_segment_2
   _gt_segment_3
   _gt_triangle_3
   _gt_triangle_6
   _gt_quadrangle_4
   _gt_quadrangle_8
   _gt_tetrahedron_4
   _gt_tetrahedron_10
   _gt_hexahedron_8
   _gt_hexahedron_20
   _gt_pentahedron_6
   _gt_pentahedron_15
   INTERPOLATION_TYPES
   _itp_lagrange_point_1
   _itp_lagrange_segment_2
   _itp_lagrange_segment_3
   _itp_lagrange_triangle_3
   _itp_lagrange_triangle_6
   _itp_lagrange_quadrangle_4
   _itp_serendip_quadrangle_8
   _itp_lagrange_tetrahedron_4
   _itp_lagrange_tetrahedron_10
   _itp_lagrange_hexahedron_8
   _itp_serendip_hexahedron_20
   _itp_lagrange_pentahedron_6
   _itp_lagrange_pentahedron_15
   GEOMETRICAL_SHAPES
   _gst_point
   _gst_triangle
   _gst_square
   _gst_prism
   GAUSS_INTEGRATION_TYPES
   _git_point
   _git_segment
   _git_triangle
   _git_tetrahedron
   _git_pentahedron
   INTERPOLATION_KIND _itk_lagrangian
   FE_ENGINE_LISTS
   gradient_on_integration_points
   interpolate_on_integration_points
   interpolate
   compute_normals_on_integration_points
   inverse_map
   contains
   compute_shapes
   compute_shapes_derivatives
   get_shapes_derivatives
   lagrange_base
   )
 
 package_declare_documentation_files(core
   manual.sty
   manual.cls
   manual.tex
   manual-macros.sty
   manual-titlepages.tex
   manual-authors.tex
   manual-introduction.tex
   manual-gettingstarted.tex
   manual-io.tex
   manual-feengine.tex
   manual-elements.tex
   manual-appendix-elements.tex
   manual-appendix-packages.tex
   manual-backmatter.tex
   manual-bibliography.bib
   manual-bibliographystyle.bst
 
   figures/bc_and_ic_example.pdf
   figures/boundary.pdf
   figures/boundary.svg
   figures/dirichlet.pdf
   figures/dirichlet.svg
 #  figures/doc_wheel.pdf
 #  figures/doc_wheel.svg
   figures/hot-point-1.png
   figures/hot-point-2.png
   figures/insertion.pdf
   figures/interpolate.pdf
   figures/interpolate.svg
   figures/vectors.pdf
   figures/vectors.svg
 
   figures/elements/hexahedron_8.pdf
   figures/elements/hexahedron_8.svg
   figures/elements/quadrangle_4.pdf
   figures/elements/quadrangle_4.svg
   figures/elements/quadrangle_8.pdf
   figures/elements/quadrangle_8.svg
   figures/elements/segment_2.pdf
   figures/elements/segment_2.svg
   figures/elements/segment_3.pdf
   figures/elements/segment_3.svg
   figures/elements/tetrahedron_10.pdf
   figures/elements/tetrahedron_10.svg
   figures/elements/tetrahedron_4.pdf
   figures/elements/tetrahedron_4.svg
   figures/elements/triangle_3.pdf
   figures/elements/triangle_3.svg
   figures/elements/triangle_6.pdf
   figures/elements/triangle_6.svg
   figures/elements/xtemp.pdf
   )
 
 package_declare_documentation(core
   "This package is the core engine of \\akantu. It depends on:"
   "\\begin{itemize}"
   "\\item A C++ compiler (\\href{http://gcc.gnu.org/}{GCC} >= 4, or \\href{https://software.intel.com/en-us/intel-compilers}{Intel})."
   "\\item The cross-platform, open-source \\href{http://www.cmake.org/}{CMake} build system."
   "\\item The \\href{http://www.boost.org/}{Boost} C++ portable libraries."
   "\\item The \\href{http://www.zlib.net/}{zlib} compression library."
   "\\end{itemize}"
   ""
   "Under Ubuntu (14.04 LTS) the installation can be performed using the commands:"
   "\\begin{command}"
   "  > sudo apt-get install cmake libboost-dev zlib1g-dev g++"
   "\\end{command}"
   ""
   "Under Mac OS X the installation requires the following steps:"
   "\\begin{itemize}"
   "\\item Install Xcode"
   "\\item Install the command line tools."
   "\\item Install the MacPorts project which allows to automatically"
   "download and install opensource packages."
   "\\end{itemize}"
   "Then the following commands should be typed in a terminal:"
   "\\begin{command}"
   "  > sudo port install cmake gcc48 boost"
   "\\end{command}"
   )
 
 find_program(READLINK_COMMAND readlink)
 find_program(ADDR2LINE_COMMAND addr2line)
 find_program(PATCH_COMMAND patch)
 mark_as_advanced(READLINK_COMMAND)
 mark_as_advanced(ADDR2LINE_COMMAND)
 
 package_declare_extra_files_to_package(core
   SOURCES
     common/aka_element_classes_info.hh.in
     common/aka_config.hh.in
   )
 
 if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 3.9))
   package_set_compile_flags(core CXX "-Wno-undefined-var-template")
 endif()
 
 if(DEFINED AKANTU_CXX11_FLAGS)
   package_declare(core_cxx11 NOT_OPTIONAL
     DESCRIPTION "C++ 11 additions for Akantu core"
     COMPILE_FLAGS CXX "${AKANTU_CXX11_FLAGS}")
 
   if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
     if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "4.6")
       set(AKANTU_CORE_CXX11 OFF CACHE BOOL "C++ 11 additions for Akantu core - not supported by the selected compiler" FORCE)
     endif()
   endif()
 
   package_declare_documentation(core_cxx11
     "This option activates some features of the C++11 standard. This is usable with GCC>=4.7 or Intel>=13.")
 else()
   if(CMAKE_VERSION VERSION_LESS 3.1)
     message(FATAL_ERROR "Since version 3.0 Akantu requires at least c++11 capable compiler")
   endif()
 endif()
diff --git a/packages/dumpers.cmake b/packages/dumpers.cmake
new file mode 100644
index 000000000..d0c08d616
--- /dev/null
+++ b/packages/dumpers.cmake
@@ -0,0 +1,37 @@
+package_declare(dumpers
+  DEFAULT ON
+  DESCRIPTION "Dumpers for Akantu"
+  DEPENDS INTERFACE IOHelper)
+
+package_declare_sources(dumpers
+  io/dumper/dumpable_iohelper.hh
+  io/dumper/dumper_iohelper.hh
+  io/dumper/dumper_iohelper.cc
+  io/dumper/dumper_paraview.hh
+  io/dumper/dumper_text.cc
+  io/dumper/dumper_text.hh
+  io/dumper/dumper_paraview.cc
+  io/dumper/dumper_homogenizing_field.hh
+  io/dumper/dumper_type_traits.hh
+  io/dumper/dumper_compute.hh
+  io/dumper/dumper_nodal_field.hh
+  io/dumper/dumper_quadrature_point_iterator.hh
+  io/dumper/dumper_variable.hh
+  io/dumper/dumper_padding_helper.hh
+  io/dumper/dumper_elemental_field.hh
+  io/dumper/dumper_element_iterator.hh
+  io/dumper/dumper_internal_material_field.hh
+  io/dumper/dumper_generic_elemental_field.hh
+  io/dumper/dumper_generic_elemental_field_tmpl.hh
+  )
+
+package_declare_documentation(dumpers
+  "This package activates the IOHelper facilities withing Akantu. This is mandatory if you want to be able to output Paraview files"
+  "as well as any Dumper within Akantu."
+  )
+
+package_declare_extra_files_to_package(dumpers
+  PROJECT
+    third-party/cmake/iohelper.cmake
+    cmake/Modules/FindIOHelper.cmake
+  )
diff --git a/packages/iohelper.cmake b/packages/iohelper.cmake
index 68aa4feaa..7f084c665 100644
--- a/packages/iohelper.cmake
+++ b/packages/iohelper.cmake
@@ -1,76 +1,42 @@
 #===============================================================================
 # @file   iohelper.cmake
 #
 # @author Nicolas Richart <nicolas.richart@epfl.ch>
 #
 # @date creation: Tue Nov 29 2011
 # @date last modification: Mon Jan 18 2016
 #
 # @brief  package description for iohelper
 #
 # @section LICENSE
 #
 # Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
 # Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
 # Solides)
 #
 # Akantu 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 3 of the License, or (at your option) any
 # later version.
 #
 # Akantu 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 Akantu. If not, see <http://www.gnu.org/licenses/>.
 #
 #===============================================================================
-
 package_declare(IOHelper EXTERNAL
   DESCRIPTION "Add IOHelper support in akantu"
   SYSTEM OFF third-party/cmake/iohelper.cmake
   DEFAULT ON)
 
 set(_version "1.1.1")
 package_add_third_party_script_variable(IOHelper
   IOHELPER_VERSION ${_version})
 package_add_third_party_script_variable(IOHelper
   IOHELPER_GIT "https://c4science.ch/source/iohelper.git")
 package_add_third_party_script_variable(IOHelper
   IOHELPER_ARCHIVE "iohelper_${_version}.tar.gz")
-
-package_declare_sources(IOHelper
-  io/dumper/dumpable_iohelper.hh
-  io/dumper/dumper_iohelper.hh
-  io/dumper/dumper_iohelper.cc
-  io/dumper/dumper_paraview.hh
-  io/dumper/dumper_text.cc
-  io/dumper/dumper_text.hh
-  io/dumper/dumper_paraview.cc
-  io/dumper/dumper_homogenizing_field.hh
-  io/dumper/dumper_type_traits.hh
-  io/dumper/dumper_compute.hh
-  io/dumper/dumper_nodal_field.hh
-  io/dumper/dumper_quadrature_point_iterator.hh
-  io/dumper/dumper_variable.hh
-  io/dumper/dumper_padding_helper.hh
-  io/dumper/dumper_elemental_field.hh
-  io/dumper/dumper_element_iterator.hh
-  io/dumper/dumper_internal_material_field.hh
-  io/dumper/dumper_generic_elemental_field.hh
-  io/dumper/dumper_generic_elemental_field_tmpl.hh
-  )
-
-package_declare_documentation(IOHelper
-  "This package activates the IOHelper facilities withing Akantu. This is mandatory if you want to be able to output Paraview files"
-  "as well as any Dumper within Akantu."
-  )
-
-package_declare_extra_files_to_package(IOHelper
-  PROJECT
-    third-party/cmake/iohelper.cmake
-    cmake/Modules/FindIOHelper.cmake
-  )
diff --git a/packages/mpi.cmake b/packages/mpi.cmake
index 9099da24d..aa5514fc9 100644
--- a/packages/mpi.cmake
+++ b/packages/mpi.cmake
@@ -1,167 +1,167 @@
 #===============================================================================
 # @file   mpi.cmake
 #
 # @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
 # @author Nicolas Richart <nicolas.richart@epfl.ch>
 #
 # @date creation: Mon Nov 21 2011
 # @date last modification: Wed Jan 20 2016
 #
 # @brief  package description for mpi
 #
 # @section LICENSE
 #
 # Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
 # Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
 # Solides)
 #
 # Akantu 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 3 of the License, or (at your option) any
 # later version.
 #
 # Akantu 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 Akantu. If not, see <http://www.gnu.org/licenses/>.
 #
 #===============================================================================
 
 package_declare(MPI EXTERNAL
   DESCRIPTION "Add MPI support in akantu"
   EXTRA_PACKAGE_OPTIONS PREFIX MPI_C MPI
-  DEPENDS scotch)
+  )
 
 package_declare_sources(MPI
   synchronizer/mpi_communicator_data.hh
   synchronizer/communicator_mpi_inline_impl.cc
   )
 
 
 function(add_extra_mpi_options)
   unset(MPI_ID CACHE)
   package_get_include_dir(MPI _include_dir)
   foreach(_inc_dir ${_include_dir})
     if(EXISTS "${_inc_dir}/mpi.h")
       if(NOT MPI_ID)
         file(STRINGS "${_inc_dir}/mpi.h" _mpi_version REGEX "#define MPI_(SUB)?VERSION .*")
         foreach(_ver ${_mpi_version})
           string(REGEX MATCH "MPI_(VERSION|SUBVERSION) *([0-9]+)" _tmp "${_ver}")
           set(_mpi_${CMAKE_MATCH_1} ${CMAKE_MATCH_2})
         endforeach()
         set(MPI_STD_VERSION "${_mpi_VERSION}.${_mpi_SUBVERSION}" CACHE INTERNAL "")
       endif()
 
       if(NOT MPI_ID)
         # check if openmpi
         file(STRINGS "${_inc_dir}/mpi.h" _ompi_version REGEX "#define OMPI_.*_VERSION .*")
         if(_ompi_version)
           set(MPI_ID "OpenMPI" CACHE INTERNAL "")
           foreach(_version ${_ompi_version})
             string(REGEX MATCH "OMPI_(.*)_VERSION (.*)" _tmp "${_version}")
             if(_tmp)
               set(MPI_VERSION_${CMAKE_MATCH_1} ${CMAKE_MATCH_2})
             endif()
           endforeach()
           set(MPI_ID_VERSION "${MPI_VERSION_MAJOR}.${MPI_VERSION_MINOR}.${MPI_VERSION_RELEASE}" CACHE INTERNAL "")
         endif()
       endif()
 
       if(NOT MPI_ID)
         # check if intelmpi
         file(STRINGS "${_inc_dir}/mpi.h" _impi_version REGEX "#define I_MPI_VERSION .*")
         if(_impi_version)
           set(MPI_ID "IntelMPI" CACHE INTERNAL "")
           string(REGEX MATCH "I_MPI_VERSION \"(.*)\"" _tmp "${_impi_version}")
           if(_tmp)
             set(MPI_ID_VERSION "${CMAKE_MATCH_1}" CACHE INTERNAL "")
           endif()
         endif()
       endif()
 
       if(NOT MPI_ID)
         # check if mvapich2
         file(STRINGS "${_inc_dir}/mpi.h" _mvapich2_version REGEX "#define MVAPICH2_VERSION .*")
         if(_mvapich2_version)
           set(MPI_ID "MPVAPICH2" CACHE INTERNAL "")
           string(REGEX MATCH "MVAPICH2_VERSION \"(.*)\"" _tmp "${_mvapich2_version}")
           if(_tmp)
             set(MPI_ID_VERSION "${CMAKE_MATCH_1}" CACHE INTERNAL "")
           endif()
         endif()
       endif()
 
       if(NOT MPI_ID)
         # check if mpich (mpich as to be checked after all the mpi that derives from it)
         file(STRINGS "${_inc_dir}/mpi.h" _mpich_version REGEX "#define MPICH_VERSION .*")
         if(_mpich_version)
           set(MPI_ID "MPICH" CACHE INTERNAL "")
           string(REGEX MATCH "I_MPI_VERSION \"(.*)\"" _tmp "${_mpich_version}")
           if(_tmp)
             set(MPI_ID_VERSION "${CMAKE_MATCH_1}" CACHE INTERNAL "")
           endif()
         endif()
       endif()
     endif()
   endforeach()
 
   if(MPI_ID STREQUAL "IntelMPI" OR
       MPI_ID STREQUAL "MPICH" OR
       MPI_ID STREQUAL "MVAPICH2")
     set(_flags "-DMPICH_IGNORE_CXX_SEEK")
   elseif(MPI_ID STREQUAL "OpenMPI")
     set(_flags "-DOMPI_SKIP_MPICXX")
 
 
     if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
       set( _flags "${_flags} -Wno-literal-suffix")
     endif()
   endif()
 
   include(FindPackageMessage)
   if(MPI_FOUND)
     find_package_message(MPI "MPI ID: ${MPI_ID} ${MPI_ID_VERSION} (MPI standard ${MPI_STD_VERSION})" "${MPI_STD_VERSION}")
   endif()
 
   set(MPI_EXTRA_COMPILE_FLAGS "${_flags}" CACHE STRING "Extra flags for MPI" FORCE)
   mark_as_advanced(MPI_EXTRA_COMPILE_FLAGS)
 
   #package_get_source_files(MPI _srcs _pub _priv)
   #list(APPEND _srcs "common/aka_error.cc")
 
   #set_property(SOURCE ${_srcs} PROPERTY COMPILE_FLAGS "${_flags}")
   package_set_compile_flags(MPI CXX ${_flags})
 endfunction()
 
 package_on_enabled_script(MPI
   "
 add_extra_mpi_options()
 
 get_cmake_property(_all_vars VARIABLES)
 foreach(_var \${_all_vars})
   if(_var MATCHES \"^MPI_.*\")
     mark_as_advanced(\${_var})
   endif()
 endforeach()
 "
 )
 
 package_declare_documentation(MPI
   "This is a meta package providing access to MPI."
   ""
   "Under Ubuntu (14.04 LTS) the installation can be performed using the commands:"
   "\\begin{command}"
   "  > sudo apt-get install libopenmpi-dev"
   "\\end{command}"
   ""
   "Under Mac OS X the installation requires the following steps:"
   "\\begin{command}"
   "  > sudo port install mpich-devel"
   "\\end{command}"
   )
 
 package_set_package_system_dependency(MPI deb mpi-default-bin)
 package_set_package_system_dependency(MPI deb-src mpi-default-dev)
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index f56516eeb..6d277b2d4 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,194 +1,208 @@
 #===============================================================================
 # @file   CMakeLists.txt
 #
 # @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
 # @author Nicolas Richart <nicolas.richart@epfl.ch>
 #
 # @date creation: Mon Jun 14 2010
 # @date last modification: Wed Jan 20 2016
 #
 # @brief  CMake file for the library
 #
 # @section LICENSE
 #
 # Copyright (©)  2010-2012, 2014,  2015 EPFL  (Ecole Polytechnique  Fédérale de
 # Lausanne)  Laboratory (LSMS  -  Laboratoire de  Simulation  en Mécanique  des
 # Solides)
 #
 # Akantu 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 3 of the License, or (at your option) any
 # later version.
 #
 # Akantu 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 Akantu. If not, see <http://www.gnu.org/licenses/>.
 #
 #===============================================================================
 
 #===============================================================================
 # Package Management
 #===============================================================================
 package_get_all_source_files(
   AKANTU_LIBRARY_SRCS
   AKANTU_LIBRARY_PUBLIC_HDRS
   AKANTU_LIBRARY_PRIVATE_HDRS
   )
 
 package_get_all_include_directories(
   AKANTU_LIBRARY_INCLUDE_DIRS
   )
 
 package_get_all_external_informations(
-  AKANTU_EXTERNAL_INCLUDE_DIR
-  AKANTU_EXTERNAL_LIBRARIES
-)
+  PRIVATE_INCLUDE AKANTU_PRIVATE_EXTERNAL_INCLUDE_DIR
+  INTERFACE_INCLUDE AKANTU_INTERFACE_EXTERNAL_INCLUDE_DIR
+  LIBRARIES AKANTU_EXTERNAL_LIBRARIES
+  )
 
 package_get_all_compilation_flags(CXX _cxx_flags)
 set(AKANTU_EXTRA_CXX_FLAGS
   "${_cxx_flags}" CACHE STRING "Extra flags defined by loaded packages" FORCE)
 mark_as_advanced(AKANTU_EXTRA_CXX_FLAGS)
 
 foreach(src_ ${AKANTU_SPIRIT_SOURCES})
   set_property(SOURCE ${src_} PROPERTY COMPILE_FLAGS "-g0 -Werror")
 endforeach()
 
 #===========================================================================
 # header for blas/lapack (any other fortran libraries)
 #===========================================================================
 package_is_activated(BLAS _blas_activated)
 package_is_activated(LAPACK _lapack_activated)
 
 if(_blas_activated OR _lapack_activated)
   if(CMAKE_Fortran_COMPILER)
     # ugly hack
     set(CMAKE_Fortran_COMPILER_LOADED TRUE)
   endif()
 
   include(FortranCInterface)
   FortranCInterface_HEADER(
     "${CMAKE_CURRENT_BINARY_DIR}/aka_fortran_mangling.hh"
     MACRO_NAMESPACE "AKA_FC_")
   mark_as_advanced(CDEFS)
 endif()
 
 list(APPEND AKANTU_LIBRARY_INCLUDE_DIRS "${CMAKE_CURRENT_BINARY_DIR}")
 set(AKANTU_INCLUDE_DIRS
   ${CMAKE_CURRENT_BINARY_DIR} ${AKANTU_LIBRARY_INCLUDE_DIRS}
   CACHE INTERNAL "Internal include directories to link with Akantu as a subproject")
 
 #===========================================================================
 # configurations
 #===========================================================================
 package_get_all_material_includes(AKANTU_MATERIAL_INCLUDES)
 package_get_all_material_lists(AKANTU_MATERIAL_LISTS)
 configure_file(model/solid_mechanics/material_list.hh.in
   "${CMAKE_CURRENT_BINARY_DIR}/material_list.hh" @ONLY)
 
 package_get_element_lists()
 configure_file(common/aka_element_classes_info.hh.in
   "${CMAKE_CURRENT_BINARY_DIR}/aka_element_classes_info.hh" @ONLY)
 
 configure_file(common/aka_config.hh.in
   "${CMAKE_CURRENT_BINARY_DIR}/aka_config.hh" @ONLY)
 
 #===============================================================================
 # Debug infos
 #===============================================================================
 set(AKANTU_GDB_DIR ${PROJECT_SOURCE_DIR}/cmake)
 if(UNIX)
   string(TOUPPER "${CMAKE_BUILD_TYPE}" _u_build_type)
   if(_u_build_type STREQUAL "DEBUG" OR _u_build_type STREQUAL "RELWITHDEBINFO")
     configure_file(${PROJECT_SOURCE_DIR}/cmake/libakantu-gdb.py.in
       "${PROJECT_BINARY_DIR}/libakantu-gdb.py"
       @ONLY)
     configure_file(${PROJECT_SOURCE_DIR}/cmake/akantu-debug.cc.in
       "${PROJECT_BINARY_DIR}/akantu-debug.cc" @ONLY)
 
     list(APPEND AKANTU_LIBRARY_SRCS ${PROJECT_BINARY_DIR}/akantu-debug.cc)
   endif()
 else()
   find_program(GDB_EXECUTABLE gdb)
 
   if(GDB_EXECUTABLE)
     execute_process(COMMAND
       ${GDB_EXECUTABLE} --batch -x "${PROJECT_SOURCE_DIR}/cmake/gdb_python_path"
       OUTPUT_VARIABLE AKANTU_PYTHON_GDB_DIR
       ERROR_QUIET
       RESULT_VARIABLE _res)
 
     if(_res EQUAL 0 AND UNIX)
       set(GDB_USER_CONFIG $ENV{HOME}/.gdb/auto-load)
       file(MAKE_DIRECTORY ${GDB_USER_CONFIG})
 
       configure_file(${PROJECT_SOURCE_DIR}/cmake/libakantu-gdb.py.in
         "${GDB_USER_CONFIG}/${CMAKE_SHARED_LIBRARY_PREFIX}akantu${CMAKE_SHARED_LIBRARY_SUFFIX}.${AKANTU_VERSION}-gdb.py"
         @ONLY)
     endif()
   endif()
 endif()
 
 #===============================================================================
 # Library generation
 #===============================================================================
 add_library(akantu ${AKANTU_LIBRARY_SRCS})
 
-target_include_directories(akantu PRIVATE $<BUILD_INTERFACE:${AKANTU_INCLUDE_DIRS}>
-                                  INTERFACE $<INSTALL_INTERFACE:include/akantu>)
-target_include_directories(akantu SYSTEM PRIVATE $<BUILD_INTERFACE:${AKANTU_EXTERNAL_INCLUDE_DIR}>)
+target_include_directories(akantu
+  PRIVATE $<BUILD_INTERFACE:${AKANTU_INCLUDE_DIRS}>
+  INTERFACE $<INSTALL_INTERFACE:include/akantu>
+  )
+target_include_directories(akantu SYSTEM BEFORE
+  PUBLIC $<BUILD_INTERFACE:${AKANTU_INTERFACE_EXTERNAL_INCLUDE_DIR}>
+  $<INSTALL_INTERFACE:${AKANTU_INTERFACE_EXTERNAL_INCLUDE_DIR}>
+  )
+
+target_include_directories(akantu SYSTEM BEFORE
+  PRIVATE ${AKANTU_PRIVATE_EXTERNAL_INCLUDE_DIR}
+  )
+
 target_link_libraries(akantu ${AKANTU_EXTERNAL_LIBRARIES})
 
 set_target_properties(akantu
   PROPERTIES
     ${AKANTU_LIBRARY_PROPERTIES} # this contains the version
     COMPILE_FLAGS "${_cxx_flags}"
-    CXX_STANDARD 14)
+    )
 
 if(NOT CMAKE_VERSION VERSION_LESS 3.1)
-  package_get_all_features_public(_public_features)
-  if(_public_features)
-    target_compile_features(akantu  PUBLIC ${_public_features})
-  endif()
-
-  package_get_all_features_public(_private_features)
-  if(_private_features)
-    target_compile_features(akantu PRIVATE ${_private_features})
-  endif()
+  package_get_all_features_public(_PUBLIC_features)
+  package_get_all_features_private(_PRIVATE_features)
+  foreach(_type PRIVATE PUBLIC)
+    if(_${_type}_features)
+      target_compile_features(akantu ${_type} ${_${_type}_features})
+    endif()
+  endforeach()
+else()
+  set_target_properties(akantu
+    PROPERTIES
+    CXX_STANDARD 14
+    )
 endif()
 
 package_get_all_extra_dependencies(_extra_target_dependencies)
 if(_extra_target_dependencies)
   # This only adding todo: find a solution for when a dependency was add the is removed...
   add_dependencies(akantu ${_extra_target_dependencies})
 endif()
 
 package_get_all_export_list(AKANTU_EXPORT_LIST)
 list(APPEND AKANTU_EXPORT_LIST akantu)
 
 # TODO separate public from private headers
 install(TARGETS akantu
   EXPORT ${AKANTU_TARGETS_EXPORT}
   LIBRARY DESTINATION lib COMPONENT lib
   ARCHIVE DESTINATION lib COMPONENT lib
   RUNTIME DESTINATION bin COMPONENT bin
   PUBLIC_HEADER DESTINATION include/akantu/ COMPONENT dev
   )
 
 if("${AKANTU_TARGETS_EXPORT}" STREQUAL "AkantuLibraryDepends")
   install(EXPORT AkantuLibraryDepends DESTINATION  lib/akantu
     COMPONENT dev)
 endif()
 
 #Export for build tree
 export(TARGETS ${AKANTU_EXPORT_LIST}
   FILE "${CMAKE_BINARY_DIR}/AkantuLibraryDepends.cmake")
 export(PACKAGE Akantu)
 
 # print out the list of materials
 generate_material_list()
 
 register_target_to_tidy(akantu)
diff --git a/third-party/cmake/iohelper.cmake b/third-party/cmake/iohelper.cmake
index 17f3ee111..53c56418a 100644
--- a/third-party/cmake/iohelper.cmake
+++ b/third-party/cmake/iohelper.cmake
@@ -1,97 +1,99 @@
 #===============================================================================
 # @file   iohelper.cmake
 #
 # @author Nicolas Richart <nicolas.richart@epfl.ch>
 #
 # @date creation: Mon Mar 30 2015
 # @date last modification: Tue Jan 19 2016
 #
 # @brief  build script for iohelper
 #
 # @section LICENSE
 #
 # Copyright (©) 2015 EPFL (Ecole Polytechnique Fédérale de Lausanne) Laboratory
 # (LSMS - Laboratoire de Simulation en Mécanique des Solides)
 #
 # Akantu 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 3 of the License, or (at your option) any
 # later version.
 #
 # Akantu 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 Akantu. If not, see <http://www.gnu.org/licenses/>.
 #
 #===============================================================================
 
 if(EXISTS ${PROJECT_SOURCE_DIR}/third-party/iohelper)
   set(IOHELPER_TARGETS_EXPORT ${AKANTU_TARGETS_EXPORT})
   add_subdirectory(${PROJECT_SOURCE_DIR}/third-party/iohelper)
 
   set(IOHELPER_SOURCE_TYPE "internal"
     CACHE INTERNAL "internal variable for clean export")
 
-  set(IOHELPER_INCLUDE_DIR "${PROJECT_SOURCE_DIR}/third-party/iohelper/src"
-    CACHE INTERNAL "IOHelper include directory")
+  #set(IOHELPER_INCLUDE_DIR "${PROJECT_SOURCE_DIR}/third-party/iohelper/src"
+  #  CACHE INTERNAL "IOHelper include directory")
 
   set(IOHELPER_LIBRARIES iohelper CACHE INTERNAL "IOHelper library")
   package_add_to_export_list(iohelper iohelper)
   return()
 endif()
 
+
+
 if(NOT EXISTS ${PROJECT_SOURCE_DIR}/third-party/${IOHELPER_ARCHIVE})
   set(_iohelper_download_command
     GIT_REPOSITORY ${IOHELPER_GIT}
     GIT_TAG ${IOHELPER_VERSION}
     )
 else()
   set(_iohelper_download_command
     URL ${PROJECT_SOURCE_DIR}/third-party/${IOHELPER_ARCHIVE}
     )
 endif()
 
 if(CMAKE_VERSION VERSION_GREATER 3.1)
   set(_extra_options 
     UPDATE_DISCONNECTED 1
     DOWNLOAD_NO_PROGRESS 1
     EXCLUDE_FROM_ALL 1
     )
 endif()
 
 ExternalProject_Add(iohelper
   PREFIX ${PROJECT_BINARY_DIR}/third-party
   ${_iohelper_download_command}
   ${_extra_options}
   CMAKE_ARGS <SOURCE_DIR>/
   CMAKE_CACHE_ARGS -DCMAKE_INSTALL_PREFIX:PATH=<INSTALL_DIR> -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE} -DCMAKE_CXX_COMPILER:PATH=${CMAKE_CXX_COMPILER}
   )
 
 find_library(IOHELPER_LIBRARIES iohelper HINTS ${PROJECT_BINARY_DIR}/third-party)
 if(CMAKE_SYSTEM_NAME STREQUAL "Windows")
   set(_tmp ${IOHELPER_LIBRARIES})
   set(IOHELPER_LIBRARIES "${_tmp}.a" CACHE FILEPATH "" FORCE)
 endif()
 
 find_path(IOHELPER_INCLUDE_DIR iohelper/io_helper.hh HINTS ${PROJECT_BINARY_DIR}/third-party)
 
 set(IOHELPER_SOURCE_TYPE "external" CACHE INTERNAL "internal variable for clean export")
 
 mark_as_advanced(
   IOHELPER_LIBRARIES
   IOHELPER_INCLUDE_DIR
   )
 
 package_add_extra_dependency(IOHelper iohelper)
 
 install(FILES ${IOHELPER_LIBRARIES}
   DESTINATION lib
   COMPONENT lib
   )
 
 install(DIRECTORY ${IOHELPER_INCLUDE_DIR}
   DESTINATION include
   COMPONENT dev)
diff --git a/third-party/iohelper/src/CMakeLists.txt b/third-party/iohelper/src/CMakeLists.txt
index b857c8629..783a7efe2 100644
--- a/third-party/iohelper/src/CMakeLists.txt
+++ b/third-party/iohelper/src/CMakeLists.txt
@@ -1,115 +1,111 @@
 #===============================================================================
 # @file   CMakeLists.txt
 #
 # @author Guillaume Anciaux <guillaume.anciaux@epfl.ch>
 #
 # @date creation: Thu Nov 24 2011
 # @date last modification: Wed Nov 13 2013
 #
 # @brief  main iohelper configuration
 #
 # @section LICENSE
 #
 # Copyright (©) 2010-2012, 2014 EPFL (Ecole Polytechnique Fédérale de Lausanne)
 # Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
 #
 # IOHelper 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 3 of the License, or (at your option) any
 # later version.
 #
 # IOHelper 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 IOHelper. If not, see <http://www.gnu.org/licenses/>.
 #
 #===============================================================================
 
 #===============================================================================
 # List of source files
 #===============================================================================
 set(IOHELPER_COMMON_SRC
   dumper_lammps.cc
   dumper.cc
-#  dumper_restart.cc
-#  src/reader_C_wrapper.cpp
-#  src/reader.cpp
-#  src/dumper_C_wrapper.cpp
   dumper_paraview.cc
   dumper_text.cc
   paraview_helper.cc
 #  src/reader_restart.cpp
 )
 
 set(IOHELPER_COMMON_HEADERS
   field_inline_impl.cc
   dumper_restart.hh
   field_interface.hh
   visitor.hh
   field.hh
   variable_inline_impl.cc
   variable_interface.hh
   variable.hh
   container_array.hh
   dumper_paraview.hh
   dumper_text.hh
   paraview_helper.tcc
   iohelper_common.hh
   io_helper.hh
   dumper.hh
   file_manager.hh
   paraview_helper.hh
   dumper_C_wrapper.h
   base64.hh
-#  src/reader_C_wrapper.h
-#  src/reader.hh
   dumper_lammps.hh
   base64_reader.hh
-#  src/reader_restart.hh
 )
 
 #===============================================================================
 # Library creation rule
 #===============================================================================
-include_directories(
-  ${IOHELPER_SOURCE_DIR}/src
-  )
-
 add_library(iohelper ${IOHELPER_COMMON_SRC})
 
 # link library with other libraries
-target_link_libraries (iohelper ${IOHELPER_EXTERNAL_LIBS})
+target_link_libraries(iohelper ${IOHELPER_EXTERNAL_LIBS})
+target_include_directories(iohelper
+  PRIVATE $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/src>
+  INTERFACE $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/src>
+            $<INSTALL_INTERFACE:include/iohelper>
+  )
+
+
 set_target_properties(iohelper PROPERTIES PUBLIC_HEADER "${IOHELPER_COMMON_HEADERS}")
 set_property(TARGET iohelper PROPERTY CXX_STANDARD 11)
 
 export(TARGETS iohelper
   FILE "${CMAKE_BINARY_DIR}/IOHelperLibraryDepends.cmake")
 export(PACKAGE IOHelper)
 
 #===============================================================================
 # Install rules
 #===============================================================================
 # Tweak for when IOHelper is a subproject
 if(NOT IOHELPER_TARGETS_EXPORT)
   set(IOHELPER_TARGETS_EXPORT IOHelperLibraryDepends)
 endif()
 
 install(TARGETS iohelper
   EXPORT ${IOHELPER_TARGETS_EXPORT}
   ARCHIVE DESTINATION lib COMPONENT lib
   LIBRARY DESTINATION lib COMPONENT lib
   RUNTIME DESTINATION lib COMPONENT lib
   PUBLIC_HEADER DESTINATION include/iohelper COMPONENT dev
   )
 
 # Install the export set for use with the install-tree
 if("${IOHELPER_TARGETS_EXPORT}" STREQUAL "IOHelperLibraryDepends")
   install(EXPORT IOHelperLibraryDepends DESTINATION  lib/iohelper
     COMPONENT dev)
 endif()
 
 
 set(IOHELPER_INCLUDE_DIRS ${IOHelper_SOURCE_DIR}/src CACHE INTERNAL "Internal include directorie to link with IOHelper as a subproject")