diff --git a/.gitignore b/.gitignore
index ec55176..8787297 100644
--- a/.gitignore
+++ b/.gitignore
@@ -34,4 +34,6 @@
 
 # Project
 /.idea/
-/build/
\ No newline at end of file
+/build/
+.cache
+.vscode
\ No newline at end of file
diff --git a/CMake/cpp-logger-config.cmake.build.in b/CMake/cpp-logger-config.cmake.build.in
deleted file mode 100644
index eb3582a..0000000
--- a/CMake/cpp-logger-config.cmake.build.in
+++ /dev/null
@@ -1,22 +0,0 @@
-set(CPP_LOGGER_FOUND TRUE)
-
-# Include directories
-set(CPP_LOGGER_INCLUDE_DIRS "@CMAKE_INCLUDE_OUTPUT_DIRECTORY@")
-if (NOT IS_DIRECTORY "${CPP_LOGGER_INCLUDE_DIRS}")
-    set(CPP_LOGGER_FOUND FALSE)
-endif ()
-#message(STATUS "CPP_LOGGER_INCLUDE_DIRS: " ${CPP_LOGGER_INCLUDE_DIRS})
-get_filename_component(CPP_LOGGER_ROOT_DIR ${CPP_LOGGER_INCLUDE_DIRS}/.. ABSOLUTE)
-#message(STATUS "CPP_LOGGER_ROOT_DIR: " ${CPP_LOGGER_ROOT_DIR})
-set(CPP_LOGGER_LIBRARY_PATH "@CMAKE_LIBRARY_OUTPUT_DIRECTORY@")
-link_directories(${CPP_LOGGER_LIBRARY_PATH})
-set(CPP_LOGGER_LIBRARIES cpp-logger)
-#message(STATUS "CPP_LOGGER_LIBRARIES: " ${CPP_LOGGER_LIBRARIES})
-set(CPP_LOGGER_DEFINITIONS "")
-
-if (NOT TARGET cpp-logger)
-  include(${CMAKE_CURRENT_LIST_DIR}/cpp-logger-targets.cmake)
-endif()
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(cpp-logger
-            REQUIRED_VARS CPP_LOGGER_FOUND CPP_LOGGER_INCLUDE_DIRS CPP_LOGGER_LIBRARIES)
diff --git a/CMake/cpp-logger-config.cmake.install.in b/CMake/cpp-logger-config.cmake.install.in
deleted file mode 100644
index 0ccb8f4..0000000
--- a/CMake/cpp-logger-config.cmake.install.in
+++ /dev/null
@@ -1,21 +0,0 @@
-set(CPP_LOGGER_FOUND TRUE)
-
-# Include directories
-set(CPP_LOGGER_INCLUDE_DIRS "@CPP_LOGGER_INSTALL_INCLUDE_DIR@")
-if (NOT IS_DIRECTORY "${CPP_LOGGER_INCLUDE_DIRS}")
-    set(CPP_LOGGER_FOUND FALSE)
-endif ()
-#message(STATUS "CPP_LOGGER_INCLUDE_DIRS: " ${CPP_LOGGER_INCLUDE_DIRS})
-get_filename_component(CPP_LOGGER_ROOT_DIR ${CPP_LOGGER_INCLUDE_DIRS}/.. ABSOLUTE)
-#message(STATUS "CPP_LOGGER_ROOT_DIR: " ${CPP_LOGGER_ROOT_DIR})
-set(CPP_LOGGER_LIBRARY_PATH "@CPP_LOGGER_INSTALL_LIB_DIR@")
-link_directories(${CPP_LOGGER_LIBRARY_PATH})
-#message(STATUS "CPP_LOGGER_LIBRARY_PATH: " ${CPP_LOGGER_LIBRARY_PATH})
-set(CPP_LOGGER_LIBRARIES cpp-logger)
-set(CPP_LOGGER_DEFINITIONS "")
-if (NOT TARGET cpp-logger)
-  include(${CMAKE_CURRENT_LIST_DIR}/cpp-logger-targets.cmake)
-endif()
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(cpp-logger
-        REQUIRED_VARS CPP_LOGGER_FOUND CPP_LOGGER_INCLUDE_DIRS CPP_LOGGER_LIBRARIES)
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 47a416e..d9dce53 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,11 +1,11 @@
-cmake_minimum_required(VERSION 3.0)
-project(cpp-logger)
+cmake_minimum_required(VERSION 3.10.2)
 #------------------------------------------------------------------------------
 # Version information
 #------------------------------------------------------------------------------
-set(CPP_LOGGER_VERSION_MAJOR "0")
+
+set(CPP_LOGGER_VERSION_MAJOR "1")
 set(CPP_LOGGER_VERSION_MINOR "0")
-set(CPP_LOGGER_VERSION_PATCH "1")
+set(CPP_LOGGER_VERSION_PATCH "0")
 set(CPP_LOGGER_PACKAGE ${PROJECT_NAME})
 set(CPP_LOGGER_PACKAGE_NAME ${PROJECT_NAME})
 set(CPP_LOGGER_PACKAGE_VERSION "${CPP_LOGGER_VERSION_MAJOR}.${CPP_LOGGER_VERSION_MINOR}.${CPP_LOGGER_VERSION_PATCH}")
@@ -13,74 +13,108 @@ set(CPP_LOGGER_PACKAGE_VERSION_MAJOR "${CPP_LOGGER_VERSION_MAJOR}.${CPP_LOGGER_V
 set(CPP_LOGGER_PACKAGE_VERSION_MINOR "${CPP_LOGGER_VERSION_PATCH}")
 set(CPP_LOGGER_PACKAGE_STRING "${CPP_LOGGER_PACKAGE_NAME} ${CPP_LOGGER_PACKAGE_VERSION}")
 set(CPP_LOGGER_PACKAGE_TARNAME "${CPP_LOGGER_PACKAGE}")
-if (DEFINED CMAKE_BUILD_DIR)
-    set(CMAKE_BINARY_DIR ${CMAKE_BUILD_DIR})
-endif()
 
-set(CPP_LOGGER_SRC ${CMAKE_CURRENT_SOURCE_DIR}/src/cpp-logger/logger.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/src/cpp-logger/clogger.cpp)
-set(CPP_LOGGER_PRIVATE_INCLUDE)
-set(CPP_LOGGER_PUBLIC_INCLUDE ${CMAKE_CURRENT_SOURCE_DIR}/include/cpp-logger/logger.h
-        ${CMAKE_CURRENT_SOURCE_DIR}/include/cpp-logger/clogger.h)
-include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include)
-add_library(${PROJECT_NAME} SHARED)
-
-target_sources(${PROJECT_NAME}
-        PRIVATE
-        ${CPP_LOGGER_SRC}
-        )
-target_include_directories(${PROJECT_NAME}
-        PRIVATE
-        # where the library itself will look for its internal headers
-        ${CMAKE_CURRENT_SOURCE_DIR}/src
-        PUBLIC
-        # where top-level project will look for the library's public headers
-        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
-        # where external projects will look for the library's public headers
-        $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
-        )
+set(CPP_LOGGER_VERSION "(1, 0, 4)")
+
+project(cpp-logger LANGUAGES C CXX)
+
+# Convenience defines
+string(TOUPPER "${PROJECT_NAME}" UPPER_PROJECT_NAME)
+string(TOLOWER "${PROJECT_NAME}" LOWER_PROJECT_NAME)
 
 #------------------------------------------------------------------------------
-# Setup install and output Directories
+# Internal Includes for header and libraries
 #------------------------------------------------------------------------------
-if (NOT CPP_LOGGER_INSTALL_BIN_DIR)
-    set(CPP_LOGGER_INSTALL_BIN_DIR ${CMAKE_INSTALL_PREFIX}/bin)
-    message(STATUS ${CPP_LOGGER_INSTALL_BIN_DIR})
+# Get installation directories -- these get used in various places;
+# best to just make them available
+option (CPP_LOGGER_LIBDIR_AS_LIB OFF)
+if (NOT CPP_LOGGER_LIBDIR_AS_LIB)
+    include(GNUInstallDirs)
 endif ()
-if (NOT CPP_LOGGER_INSTALL_LIB_DIR)
-    set(CPP_LOGGER_INSTALL_LIB_DIR ${CMAKE_INSTALL_PREFIX}/lib)
+#
+if (CMAKE_INSTALL_LIBDIR)
+   message(STATUS "CMAKE_INSTALL_LIBDIR ${CMAKE_INSTALL_LIBDIR}")
+   set(CPP_LOGGER_LIBDIR ${CMAKE_INSTALL_LIBDIR})
+   set(CPP_LOGGER_INSTALL_INCLUDE_DIR
+       ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_INCLUDEDIR})
+   set(CPP_LOGGER_INSTALL_DOCDIR
+       ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_DOCDIR})
+   set(CPP_LOGGER_INSTALL_SYSCONFDIR
+       ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_SYSCONFDIR}/modulefiles)
+else ()
+   set(CPP_LOGGER_LIBDIR "lib")
+   set(CPP_LOGGER_INSTALL_INCLUDE_DIR "${CMAKE_INSTALL_PREFIX}/include")
+   set(CPP_LOGGER_INSTALL_DOCDIR "${CMAKE_INSTALL_PREFIX}/doc")
+   set(CPP_LOGGER_INSTALL_SYSCONFDIR "${CMAKE_INSTALL_PREFIX}/etc/modulefiles")
+   message(STATUS "CPP_LOGGER_LIBDIR set to ${CPP_LOGGER_LIBDIR}")
 endif ()
-if (NOT CPP_LOGGER_INSTALL_INCLUDE_DIR)
-    set(CPP_LOGGER_INSTALL_INCLUDE_DIR ${CMAKE_INSTALL_PREFIX}/include)
-endif ()
-if (NOT CPP_LOGGER_INSTALL_DATA_DIR)
-    set(CPP_LOGGER_INSTALL_DATA_DIR ${CMAKE_INSTALL_PREFIX}/share)
+
+#------------------------------------------------------------------------------
+# Internal Paths for cmake libraries and Setup install and output Directories
+#------------------------------------------------------------------------------
+# This sets where to look for dependent libraries
+set(CMAKE_PREFIX_PATH ${CMAKE_PREFIX_PATH} ${CMAKE_BINARY_DIR} ${CMAKE_INSTALL_PREFIX})
+# This sets where to look for dependent library's cmake files
+list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules)
+list(APPEND CMAKE_MODULE_PATH ${CMAKE_BINARY_DIR}/${CPP_LOGGER_LIBDIR}/cmake)
+list(APPEND CMAKE_MODULE_PATH ${CMAKE_BINARY_DIR}/share/cmake)
+
+#------------------------------------------------------------------------------
+if (NOT CPP_LOGGER_EXTERNALLY_CONFIGURED)
+    set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin CACHE PATH "Single Directory for all Executables.")
+    set(CMAKE_INCLUDE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/include CACHE PATH "Store the headers.")
+    set(EXECUTABLE_OUTPUT_PATH ${CMAKE_RUNTIME_OUTPUT_DIRECTORY})
+    set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/${CPP_LOGGER_LIBDIR} CACHE PATH "Single Directory for all Libraries")
+    set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/${CPP_LOGGER_LIBDIR} CACHE PATH "Single Directory for all static libraries.")
 endif ()
 
-if (NOT CMAKE_INSTALL_RPATH)
-    set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib")
-    set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
+#-----------------------------------------------------------------------------
+# Targets built within this project are exported at Install time for use
+# by other projects.
+#-----------------------------------------------------------------------------
+if (NOT CPP_LOGGER_EXPORTED_TARGETS)
+    set(CPP_LOGGER_EXPORTED_TARGETS "cpp-logger-targets")
 endif ()
+#------------------------------------------------------------------------------
+# Build options
+#------------------------------------------------------------------------------
+# option(ENABLE_CPP_LOGGER_DEBUG "Include debugging prints and logging" OFF) # This is not needed as we have CMAKE_BUILD_TYPE
+# This is verbose, maybe an alternate might help simplify
+#option(BUILD_URPC "Build CPP_LOGGER's URPC code" OFF)
+#option(ENABLE_PERFFLOW "Build with PerfFlow Aspect support" OFF)
+#option(ENABLE_UCX_DTL "Build CPP_LOGGER's UCX data transport layer" OFF)
+
+# This option is off by default because non-developers should not use
+# this option under normal circumstances.
+option(CPP_LOGGER_WARNINGS_AS_ERRORS "Build with warnings promoted to errors." OFF)
+mark_as_advanced(CPP_LOGGER_WARNINGS_AS_ERRORS)
 
+option (CPP_LOGGER_USE_CLANG_LIBCXX OFF)
+if (CPP_LOGGER_USE_CLANG_LIBCXX)
+    set (GCC_TOOLCHAIN "")
+endif (CPP_LOGGER_USE_CLANG_LIBCXX)
+
+# Testing
+option (CPP_LOGGER_ENABLE_TESTING "Enable tests for CPP_LOGGER." OFF)
+
+#------------------------------------------------------------------------------
+# Compiler setup
 #------------------------------------------------------------------------------
+include(ExternalProject)
+# It requires include(GNUInstallDirs) before if that is needed
+include(SetupCompiler)
 
-set(CMAKE_RUNTIME_OUTPUT_DIRECTORY
-        ${CMAKE_BINARY_DIR}/bin CACHE PATH "Single Directory for all Executables."
-        )
+#------------------------------------------------------------------------------
+# Build Type based configurations
+#------------------------------------------------------------------------------
 
-set(CMAKE_INCLUDE_OUTPUT_DIRECTORY
-        ${CMAKE_BINARY_DIR}/include CACHE PATH "Store the headers."
-        )
-set(EXECUTABLE_OUTPUT_PATH ${CMAKE_RUNTIME_OUTPUT_DIRECTORY})
-set(CMAKE_LIBRARY_OUTPUT_DIRECTORY
-        ${CMAKE_BINARY_DIR}/lib CACHE PATH "Single Directory for all Libraries"
-        )
-set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY
-        ${CMAKE_BINARY_DIR}/lib CACHE PATH "Single Directory for all static libraries."
-        )
+if(CMAKE_BUILD_TYPE STREQUAL "")
+    set(CMAKE_BUILD_TYPE "Release") # Setting default as Release
+endif()
 
-set_target_properties(${PROJECT_NAME} PROPERTIES
-        LIBRARY_OUTPUT_DIRECTORY ${CMAKE_LIBRARY_OUTPUT_DIRECTORY})
+if (NOT DEFINED BUILD_SHARED_LIBS)
+    set(BUILD_SHARED_LIBS ON)
+endif ()
 #------------------------------------------------------------------------------
 # Disallow in-source build
 #------------------------------------------------------------------------------
@@ -89,7 +123,6 @@ if ("${CMAKE_CURRENT_SOURCE_DIR}" STREQUAL "${CMAKE_BINARY_DIR}")
             "${PROJECT_NAME} requires an out of source Build. "
             "Please create a separate binary directory and run CMake there.")
 endif ()
-
 #------------------------------------------------------------------------------
 # Set a default build type if none was specified
 #------------------------------------------------------------------------------
@@ -102,71 +135,107 @@ if (NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
             "MinSizeRel" "RelWithDebInfo")
 endif ()
 
-if (NOT "${CMAKE_CXX_STANDARD}")
-    set(CMAKE_CXX_STANDARD 17)
-    set(CMAKE_CXX_STANDARD_REQUIRED ON)
-    set(CMAKE_CXX_EXTENSIONS OFF)
-endif ()
+
+function(cpp_logger_install_headers public_headers current_dir)
+    #message("-- [${PROJECT_NAME}] " "installing headers ${public_headers}")
+    foreach (header ${public_headers})
+        file(RELATIVE_PATH header_file_path "${PROJECT_SOURCE_DIR}/src" "${header}")
+        #message("-- [${PROJECT_NAME}] " "installing header ${header_file_path}")
+        get_filename_component(header_directory_path "${header_file_path}" DIRECTORY)
+        install(
+                FILES ${header}
+                DESTINATION "include/${header_directory_path}"
+        )
+        file(COPY ${header}
+                DESTINATION "${CMAKE_INCLUDE_OUTPUT_DIRECTORY}/${header_directory_path}")
+    endforeach ()
+    set(INCLUDE_INSTALL_DIRS ${public_headers})
+endfunction()
+
+
+#------------------------------------------------------------------------------
+# Dependencies
+#------------------------------------------------------------------------------
+
+
+
 
 #-----------------------------------------------------------------------------
-# Targets built within this project are exported at Install time for use
-# by other projects.
+# Source for CPP_LOGGER
 #-----------------------------------------------------------------------------
-if (NOT CPP_LOGGER_EXPORTED_TARGETS)
-    set(CPP_LOGGER_EXPORTED_TARGETS "${PROJECT_NAME}-targets")
-endif ()
+set(CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
+include_directories(${CMAKE_SOURCE_DIR}/include)  # public header
+include_directories(${CMAKE_SOURCE_DIR}/src)  # private header
+include_directories(${CMAKE_BINARY_DIR}/include)  # build header
 
-set(CPP_LOGGER_LIBTYPE SHARED)
-set_target_properties(${libtarget}
-        PROPERTIES
-        DEBUG_OUTPUT_NAME ${LIB_DEBUG_NAME}
-        RELEASE_OUTPUT_NAME ${LIB_RELEASE_NAME}
-        MINSIZEREL_OUTPUT_NAME ${LIB_RELEASE_NAME}
-        RELWITHDEBINFO_OUTPUT_NAME ${LIB_RELEASE_NAME}
-        VERSION ${LIB_VERSION}
-        SOVERSION ${LIB_VERSION}
-        )
+set(CPP_LOGGER_SRC      ${CMAKE_CURRENT_SOURCE_DIR}/src/cpp-logger/logger.cpp
+                        ${CMAKE_CURRENT_SOURCE_DIR}/src/cpp-logger/clogger.cpp)
+set(CPP_LOGGER_PRIVATE_INCLUDE)
+set(CPP_LOGGER_PUBLIC_INCLUDE   ${CMAKE_CURRENT_SOURCE_DIR}/include/cpp-logger/logger.h
+                                ${CMAKE_CURRENT_SOURCE_DIR}/include/cpp-logger/clogger.h)
+set(CPP_LOGGER_SRC_PRIVATE )
+
+add_library(${PROJECT_NAME} SHARED ${CPP_LOGGER_SRC} ${CPP_LOGGER_PUBLIC_HEADER} ${CPP_LOGGER_PRIVATE_HEADER})
+
+set_target_properties(${PROJECT_NAME} PROPERTIES
+    LINKER_LANGUAGE CXX
+    VERSION ${CPP_LOGGER_PACKAGE_VERSION}
+    SOVERSION 1
+    PUBLIC_HEADER ${CMAKE_CURRENT_SOURCE_DIR}/include/cpp-logger/logger.h)
+cpp_logger_install_headers("${CPP_LOGGER_PUBLIC_HEADER};${CPP_LOGGER_SRC_PRIVATE}" ${CMAKE_CURRENT_SOURCE_DIR})
+
+install(
+        TARGETS ${PROJECT_NAME}
+        EXPORT ${CPP_LOGGER_EXPORTED_TARGETS}
+        LIBRARY DESTINATION ${CPP_LOGGER_INSTALL_LIB_DIR}
+        ARCHIVE DESTINATION ${CPP_LOGGER_INSTALL_LIB_DIR}
+        RUNTIME DESTINATION ${CPP_LOGGER_INSTALL_BIN_DIR}
+)
+#-----------------------------------------------------------------------------
+# Testing
+#-----------------------------------------------------------------------------
+
+#cmake_policy(SET CMP0079 NEW) # In case that we need more control over the target building order
+
+if(CPP_LOGGER_ENABLE_TESTING)
+  enable_testing()
+  set(TEST_LIBS )
+  add_subdirectory(test)
+endif()
 
-include(GNUInstallDirs)
-# the variant with PUBLIC_HEADER property unfortunately does not preserve the folder structure
-#set_target_properties(${PROJECT_NAME} PROPERTIES PUBLIC_HEADER "${public_headers}")
-# so instead we iterate through public headers and install them "manually"
-foreach (header ${CPP_LOGGER_PUBLIC_INCLUDE})
-    file(RELATIVE_PATH header_file_path "${CMAKE_CURRENT_SOURCE_DIR}/${PROJECT_NAME}" "${header}")
-    get_filename_component(header_directory_path "${header_file_path}" DIRECTORY)
-    install(
-            FILES ${header}
-            DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/${header_directory_path}"
-    )
-    file(COPY ${header}
-            DESTINATION "${CMAKE_INCLUDE_OUTPUT_DIRECTORY}/${header_directory_path}")
-endforeach ()
 #-----------------------------------------------------------------------------
 # Configure the config.cmake file for the build directory
 #-----------------------------------------------------------------------------
-configure_file(
-        ${CMAKE_CURRENT_SOURCE_DIR}/CMake/${PROJECT_NAME}-config.cmake.build.in
-        ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/cmake/${PROJECT_NAME}/${PROJECT_NAME}-config.cmake @ONLY
+include(CMakePackageConfigHelpers)
+configure_package_config_file(
+        ${CMAKE_CURRENT_SOURCE_DIR}/cmake/configure_files/${PROJECT_NAME}-config.cmake.build.in
+        "${CMAKE_BINARY_DIR}/${PROJECT_NAME}-config.cmake"
+        INSTALL_DESTINATION  ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/cmake/${PROJECT_NAME}/${PROJECT_NAME}-config.cmake 
+        PATH_VARS CMAKE_BINARY_DIR
 )
-configure_file(
-        ${CMAKE_CURRENT_SOURCE_DIR}/CMake/${PROJECT_NAME}-config.cmake.install.in
-        ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/cmake/${PROJECT_NAME}/install/${PROJECT_NAME}-config.cmake @ONLY
+
+configure_package_config_file(
+  ${CMAKE_CURRENT_SOURCE_DIR}/cmake/configure_files/${PROJECT_NAME}-config.cmake.install.in
+        "${CMAKE_BINARY_DIR}/install/${PROJECT_NAME}-config.cmake"
+        INSTALL_DESTINATION  ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/cmake/${PROJECT_NAME}/install/${PROJECT_NAME}-config.cmake
+        PATH_VARS CMAKE_BINARY_DIR
 )
+
+# configure_file(
+#         ${CMAKE_CURRENT_SOURCE_DIR}/cmake/configure_files/${PROJECT_NAME}-config.cmake.install.in
+#         ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/cmake/${PROJECT_NAME}/install/${PROJECT_NAME}-config.cmake @ONLY
+# )
 install(
         FILES
-        ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/cmake/${PROJECT_NAME}/install/${PROJECT_NAME}-config.cmake
+        "${CMAKE_BINARY_DIR}/install/${PROJECT_NAME}-config.cmake"
         DESTINATION
-        ${CPP_LOGGER_INSTALL_LIB_DIR}/cmake/${PROJECT_NAME}
+        ${CPP_LOGGER_LIBDIR}/cmake/${PROJECT_NAME}
 )
-
-install(TARGETS ${PROJECT_NAME}
-        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-        PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
 #-----------------------------------------------------------------------------
 # Configure the ${PROJECT_NAME}-config-version .cmake file for the install directory
 #-----------------------------------------------------------------------------
 configure_file(
-        ${CMAKE_CURRENT_SOURCE_DIR}/CMake/${PROJECT_NAME}-config-version.cmake.in
+        ${CMAKE_CURRENT_SOURCE_DIR}/cmake/configure_files/${PROJECT_NAME}-config-version.cmake.in
         ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/cmake/${PROJECT_NAME}/${PROJECT_NAME}-config-version.cmake @ONLY
 )
 
@@ -174,23 +243,148 @@ install(
         FILES
         ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/cmake/${PROJECT_NAME}/${PROJECT_NAME}-config-version.cmake
         DESTINATION
-        ${CPP_LOGGER_INSTALL_LIB_DIR}/cmake/${PROJECT_NAME}
-)
-install(
-        TARGETS
-        ${PROJECT_NAME}
-        EXPORT
-        ${CPP_LOGGER_EXPORTED_TARGETS}
-        LIBRARY DESTINATION ${CPP_LOGGER_INSTALL_LIB_DIR}
-        ARCHIVE DESTINATION ${CPP_LOGGER_INSTALL_LIB_DIR}
-        RUNTIME DESTINATION ${CPP_LOGGER_INSTALL_BIN_DIR}
+        ${CPP_LOGGER_LIBDIR}/cmake/${PROJECT_NAME}
 )
+
 export(EXPORT ${CPP_LOGGER_EXPORTED_TARGETS}
         FILE "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/cmake/${PROJECT_NAME}/${PROJECT_NAME}Targets.cmake")
+
+# Write the configure file
+configure_file("${CMAKE_SOURCE_DIR}/cmake/configure_files/cpp_logger_config.hpp.in"
+               "${CMAKE_INCLUDE_OUTPUT_DIRECTORY}/cpp-logger/cpp_logger_config.hpp" @ONLY)
+
+
+################################################################
+# Install CPP_LOGGER
+################################################################
+
+include(CMakePackageConfigHelpers)
+
+# Write the version file. This is independent of build/install tree.
+write_basic_package_version_file(
+  Cpp_loggerConfigVersion.cmake
+  VERSION "${CPP_LOGGER_PACKAGE_VERSION}"
+  COMPATIBILITY SameMajorVersion)
+
+install(FILES
+        "${CMAKE_INCLUDE_OUTPUT_DIRECTORY}/cpp-logger/cpp_logger_config.hpp"
+        DESTINATION
+        ${CPP_LOGGER_INSTALL_INCLUDE_DIR}/cpp-logger)
+
 install(EXPORT
         ${CPP_LOGGER_EXPORTED_TARGETS}
         DESTINATION
-        ${CPP_LOGGER_INSTALL_LIB_DIR}/cmake/${PROJECT_NAME}
+        ${CPP_LOGGER_LIBDIR}/cmake/${PROJECT_NAME}
         FILE
         ${CPP_LOGGER_EXPORTED_TARGETS}.cmake
         )
+
+# Install export
+install(EXPORT ${CPP_LOGGER_EXPORTED_TARGETS}
+        NAMESPACE cpp-logger::
+        FILE Cpp_loggerTargets.cmake
+        DESTINATION "${CPP_LOGGER_LIBDIR}/cmake/cpp-logger")
+
+# Install license and readme
+install(FILES
+        "${PROJECT_SOURCE_DIR}/NOTICE"
+        "${PROJECT_SOURCE_DIR}/LICENSE"
+        "${PROJECT_SOURCE_DIR}/README.md"
+        DESTINATION
+        ${CPP_LOGGER_INSTALL_DOCDIR})
+
+install(FILES "${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules/cpp-logger-utils.cmake"
+        DESTINATION "${CPP_LOGGER_LIBDIR}/cmake/cpp-logger")
+
+
+###############################################################################
+#                      Print out configuration summary
+###############################################################################
+include(cpp-logger-utils)
+if (CMAKE_HOST_SYSTEM_NAME MATCHES "Linux")
+  set(CPP_LOGGER_GNU_LINUX TRUE)
+endif ()
+
+# NOTE: message() outputs to stderr by default. We now use a string to
+# maintain this information and then have cmake echo it to stdout. The
+# only side effects are that if you use the CMake GUI, you won't see
+# this output anymore (they only report stderr) and that if you add
+# something to the list, you must remember your newline!
+set(_str "\n== CPP_LOGGER Configuration Summary ==\n\n")
+string(APPEND _str "  PROJECT_SOURCE_DIR:   ${PROJECT_SOURCE_DIR}\n"
+  "  PROJECT_BINARY_DIR:   ${PROJECT_BINARY_DIR}\n\n"
+  "  CMAKE_INSTALL_PREFIX: ${CMAKE_INSTALL_PREFIX}\n"
+  "  CMAKE_BUILD_TYPE:     ${CMAKE_BUILD_TYPE}\n\n")
+if (CMAKE_BUILD_TYPE MATCHES None)
+  string(APPEND _str
+    "  CXX FLAGS:            ${CMAKE_CXX_FLAGS}\n")
+elseif (CMAKE_BUILD_TYPE MATCHES Release)
+  string(APPEND _str
+    "  CXX FLAGS:            ${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_RELEASE}\n")
+  string(APPEND _str
+    "  C FLAGS:              ${CMAKE_C_FLAGS} ${CMAKE_C_FLAGS_RELEASE}\n")
+elseif (CMAKE_BUILD_TYPE MATCHES RelWithDebInfo)
+  string(APPEND _str
+    "  CXX FLAGS:            ${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_RELWITHDEBINFO}\n")
+  string(APPEND _str
+    "  C FLAGS:              ${CMAKE_C_FLAGS} ${CMAKE_C_FLAGS_RELWITHDEBINFO}\n")
+elseif (CMAKE_BUILD_TYPE MATCHES Debug)
+  string(APPEND _str
+    "  CXX FLAGS:            ${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_DEBUG}\n")
+  string(APPEND _str
+    "  C FLAGS:              ${CMAKE_C_FLAGS} ${CMAKE_C_FLAGS_DEBUG}\n")
+endif ()
+string(APPEND _str
+  "  DEPENDENCY_LIB:              ${DEPENDENCY_LIB}\n")
+string(APPEND _str "\n")
+
+string(APPEND _str
+  "  CPP_LOGGER_PACKAGE_VERSION:        ${CPP_LOGGER_PACKAGE_VERSION}\n")
+string(APPEND _str
+  "  CPP_LOGGER_GIT_VERSION:            ${CPP_LOGGER_GIT_VERSION}\n")
+string(APPEND _str
+  "  GLIBC_VERSION:               ${GLIBC_VERSION}\n")
+string(APPEND _str
+  "  TEST_LIBS:               ${TEST_LIBS}\n")
+
+#Print the true/false variables
+append_str_tf(_str
+  CPP_LOGGER_GNU_LINUX
+  CPP_LOGGER_LIBDIR_AS_LIB
+  CPP_LOGGER_USE_CLANG_LIBCXX
+  CPP_LOGGER_WARNINGS_AS_ERRORS
+  CPP_LOGGER_ENABLE_TESTING
+  
+)
+string(APPEND _str
+  "\n== End CPP_LOGGER Configuration Summary ==\n")
+
+# Output to stdout
+execute_process(COMMAND ${CMAKE_COMMAND} -E echo "${_str}")
+set(_str)
+
+
+###############################################################################
+# Write a basic modulefile
+###############################################################################
+
+set(CPP_LOGGER_MODULEFILE_NAME "cpp-logger-${CPP_LOGGER_PACKAGE_VERSION}.lua")
+#  CACHE STRING
+#  "The name of the CPP_LOGGER modulefile to install. Must end in .lua.")
+
+if (NOT (CPP_LOGGER_MODULEFILE_NAME MATCHES ".+\.lua"))
+  message(WARNING
+    "CPP_LOGGER_MODULEFILE_NAME must have extension \".lua\". Appending.")
+  set(CPP_LOGGER_MODULEFILE_NAME "${CPP_LOGGER_MODULEFILE_NAME}.lua"
+    CACHE STRING "" FORCE)
+endif ()
+
+configure_file(
+  "${CMAKE_SOURCE_DIR}/cmake/configure_files/cpp_logger_module.lua.in"
+  "${CMAKE_BINARY_DIR}/cpp_logger_module.lua.install"
+  @ONLY)
+
+install(FILES "${CMAKE_BINARY_DIR}/cpp_logger_module.lua.install"
+  RENAME "${CPP_LOGGER_MODULEFILE_NAME}"
+  DESTINATION
+  "${CPP_LOGGER_INSTALL_SYSCONFDIR}")
\ No newline at end of file
diff --git a/NOTICE b/NOTICE
new file mode 100644
index 0000000..329b142
--- /dev/null
+++ b/NOTICE
@@ -0,0 +1,21 @@
+This work was produced under the auspices of the U.S. Department of
+Energy by Lawrence Livermore National Laboratory under Contract
+DE-AC52-07NA27344.
+
+This work was prepared as an account of work sponsored by an agency of
+the United States Government. Neither the United States Government nor
+Lawrence Livermore National Security, LLC, nor any of their employees
+makes any warranty, expressed or implied, or assumes any legal liability
+or responsibility for the accuracy, completeness, or usefulness of any
+information, apparatus, product, or process disclosed, or represents that
+its use would not infringe privately owned rights.
+
+Reference herein to any specific commercial product, process, or service
+by trade name, trademark, manufacturer, or otherwise does not necessarily
+constitute or imply its endorsement, recommendation, or favoring by the
+United States Government or Lawrence Livermore National Security, LLC.
+
+The views and opinions of authors expressed herein do not necessarily
+state or reflect those of the United States Government or Lawrence
+Livermore National Security, LLC, and shall not be used for advertising
+or product endorsement purposes.
\ No newline at end of file
diff --git a/README.md b/README.md
index 96e87b9..be9f53f 100644
--- a/README.md
+++ b/README.md
@@ -1,3 +1,3 @@
 # cpp-logger
 
-A simple C++ logger
+A simple C++ logger 0.0.4
diff --git a/CMake/cpp-logger-config-version.cmake.in b/cmake/configure_files/cpp-logger-config-version.cmake.in
similarity index 58%
rename from CMake/cpp-logger-config-version.cmake.in
rename to cmake/configure_files/cpp-logger-config-version.cmake.in
index 9af6f9c..218f52b 100644
--- a/CMake/cpp-logger-config-version.cmake.in
+++ b/cmake/configure_files/cpp-logger-config-version.cmake.in
@@ -3,9 +3,9 @@
 #-----------------------------------------------------------------------------
 set(PACKAGE_VERSION @CPP_LOGGER_PACKAGE_VERSION@)
 
-if("${PACKAGE_FIND_VERSION_MAJOR}" EQUAL @CPP_LOGGER_VERSION_MAJOR@)
+if ("${PACKAGE_FIND_VERSION_MAJOR}" EQUAL @CPP_LOGGER_VERSION_MAJOR@)
     set(PACKAGE_VERSION_COMPATIBLE 1)
-    if("${PACKAGE_FIND_VERSION_PATCH}" EQUAL @CPP_LOGGER_VERSION_PATCH@)
-      set(PACKAGE_VERSION_EXACT 1)
-    endif()
-endif()
\ No newline at end of file
+    if ("${PACKAGE_FIND_VERSION_PATCH}" EQUAL @CPP_LOGGER_VERSION_PATCH@)
+        set(PACKAGE_VERSION_EXACT 1)
+    endif ()
+endif ()
\ No newline at end of file
diff --git a/cmake/configure_files/cpp-logger-config.cmake.build.in b/cmake/configure_files/cpp-logger-config.cmake.build.in
new file mode 100644
index 0000000..50714d3
--- /dev/null
+++ b/cmake/configure_files/cpp-logger-config.cmake.build.in
@@ -0,0 +1,59 @@
+# This will create IMPORTED targets for cpp-logger. The executables will be
+# cpp-logger::<exe-name>-bin (e.g., cpp-logger::cpp-logger-bin) and the library will
+# be cpp-logger::cpp-logger.
+
+include("${CMAKE_CURRENT_LIST_DIR}/cpp-logger-config-version.cmake")
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}")
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/modules")
+list(APPEND CMAKE_MODULE_PATH "@EXTRA_CMAKE_MODULE_DIR@")
+
+#include(GNUInstallDirs)
+include(ExternalProject)
+include(cpp-logger-utils)
+include(CMakePackageConfigHelpers)
+
+
+set(CPP_LOGGER_VERSION ${PACKAGE_VERSION})
+
+# Record compiler information
+set(CPP_LOGGER_C_COMPILER "@CMAKE_C_COMPILER@")
+set(CPP_LOGGER_CXX_COMPILER "@CMAKE_CXX_COMPILER@")
+
+set(CPP_LOGGER_C_FLAGS "@CMAKE_C_FLAGS@")
+set(CPP_LOGGER_CXX_FLAGS "@CMAKE_CXX_FLAGS@")
+
+set(CPP_LOGGER_C_STANDARD "@CMAKE_C_STANDARD@")
+set(CPP_LOGGER_CXX_STANDARD "@CMAKE_CXX_STANDARD@")
+
+set(CMAKE_C_STANDARD_REQUIRED TRUE)
+set(CMAKE_CXX_STANDARD_REQUIRED TRUE)
+
+# Record the various flags and switches accumlated in CPP_LOGGER
+set(CPP_LOGGER_GNU_LINUX @CPP_LOGGER_GNU_LINUX@)
+
+# Setup dependencies
+
+
+@PACKAGE_INIT@
+
+# Now actually import the CPP_LOGGER target
+set(_TMP_INCLUDE_DIRS "@CMAKE_INCLUDE_OUTPUT_DIRECTORY@")
+foreach (_DIR ${_TMP_INCLUDE_DIRS})
+  set_and_check(_INCLUDE_DIR "${_DIR}")
+  list(APPEND CPP_LOGGER_INCLUDE_DIRS "${_INCLUDE_DIR}")
+endforeach (_DIR "${_TMP_INCLUDE_DIRS}")
+
+set(_TMP_LIBRARY_DIRS "@CMAKE_LIBRARY_OUTPUT_DIRECTORY@")
+foreach (_DIR ${_TMP_LIBRARY_DIRS})
+  set_and_check(_LIBRARY_DIR "${_DIR}")
+  list(APPEND CPP_LOGGER_LIBRARY_DIRS "${_LIBRARY_DIR}")
+endforeach (_DIR ${_TMP_LIBRARY_DIRS})
+
+if (NOT TARGET cpp-logger::cpp-logger)
+  include(${CMAKE_CURRENT_LIST_DIR}/cpp-logger-targets.cmake)
+endif (NOT TARGET cpp-logger::cpp-logger)
+
+check_required_components(cpp-logger)
+
+set(CPP_LOGGER_LIBRARIES cpp-logger)
\ No newline at end of file
diff --git a/cmake/configure_files/cpp-logger-config.cmake.install.in b/cmake/configure_files/cpp-logger-config.cmake.install.in
new file mode 100644
index 0000000..8674334
--- /dev/null
+++ b/cmake/configure_files/cpp-logger-config.cmake.install.in
@@ -0,0 +1,59 @@
+# This will create IMPORTED targets for Cpp_logger. The executables will be
+# cpp-logger::<exe-name>-bin (e.g., cpp-logger::cpp-logger-bin) and the library will
+# be cpp-logger::cpp-logger.
+
+include("${CMAKE_CURRENT_LIST_DIR}/cpp-logger-config-version.cmake")
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}")
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/modules")
+list(APPEND CMAKE_MODULE_PATH "@EXTRA_CMAKE_MODULE_DIR@")
+
+#include(GNUInstallDirs)
+include(ExternalProject)
+include(cpp-logger-utils)
+include(CMakePackageConfigHelpers)
+
+
+set(CPP_LOGGER_VERSION ${PACKAGE_VERSION})
+
+# Record compiler information
+set(CPP_LOGGER_C_COMPILER "@CMAKE_C_COMPILER@")
+set(CPP_LOGGER_CXX_COMPILER "@CMAKE_CXX_COMPILER@")
+
+set(CPP_LOGGER_C_FLAGS "@CMAKE_C_FLAGS@")
+set(CPP_LOGGER_CXX_FLAGS "@CMAKE_CXX_FLAGS@")
+
+set(CPP_LOGGER_C_STANDARD "@CMAKE_C_STANDARD@")
+set(CPP_LOGGER_CXX_STANDARD "@CMAKE_CXX_STANDARD@")
+
+set(CMAKE_C_STANDARD_REQUIRED TRUE)
+set(CMAKE_CXX_STANDARD_REQUIRED TRUE)
+
+# Record the various flags and switches accumlated in CPP_LOGGER
+set(CPP_LOGGER_GNU_LINUX @CPP_LOGGER_GNU_LINUX@)
+
+# Setup dependencies
+
+
+@PACKAGE_INIT@
+
+# Now actually import the CPP_LOGGER target
+set(_TMP_INCLUDE_DIRS "@CPP_LOGGER_INSTALL_INCLUDE_DIR@")
+foreach (_DIR ${_TMP_INCLUDE_DIRS})
+  set_and_check(_INCLUDE_DIR "${_DIR}")
+  list(APPEND CPP_LOGGER_INCLUDE_DIRS "${_INCLUDE_DIR}")
+endforeach (_DIR "${_TMP_INCLUDE_DIRS}")
+
+set(_TMP_LIBRARY_DIRS "@CPP_LOGGER_INSTALL_LIB_DIR@")
+foreach (_DIR ${_TMP_LIBRARY_DIRS})
+  set_and_check(_LIBRARY_DIR "${_DIR}")
+  list(APPEND CPP_LOGGER_LIBRARY_DIRS "${_LIBRARY_DIR}")
+endforeach (_DIR ${_TMP_LIBRARY_DIRS})
+
+if (NOT TARGET cpp-logger::cpp-logger)
+  include(${CMAKE_CURRENT_LIST_DIR}/cpp-logger-targets.cmake)
+endif (NOT TARGET cpp-logger::cpp-logger)
+
+check_required_components(cpp-logger)
+
+set(CPP_LOGGER_LIBRARIES cpp-logger)
\ No newline at end of file
diff --git a/cmake/configure_files/cpp_logger_config.hpp.in b/cmake/configure_files/cpp_logger_config.hpp.in
new file mode 100644
index 0000000..e17e476
--- /dev/null
+++ b/cmake/configure_files/cpp_logger_config.hpp.in
@@ -0,0 +1,34 @@
+#ifndef CPP_LOGGER_CONFIG_HPP
+#define CPP_LOGGER_CONFIG_HPP
+
+/* Version string for CPP_LOGGER */
+#define CPP_LOGGER_PACKAGE_VERSION @CPP_LOGGER_PACKAGE_VERSION @
+#cmakedefine CPP_LOGGER_GIT_VERSION @CPP_LOGGER_GIT_VERSION @
+
+/* Compiler used */
+#cmakedefine CMAKE_BUILD_TYPE "@CMAKE_BUILD_TYPE@"
+
+#cmakedefine CMAKE_C_COMPILER "@CMAKE_C_COMPILER@"
+#cmakedefine CMAKE_C_FLAGS "@CMAKE_C_FLAGS@"
+#cmakedefine CMAKE_C_FLAGS_DEBUG "@CMAKE_C_FLAGS_DEBUG@"
+#cmakedefine CMAKE_C_FLAGS_RELWITHDEBINFO "@CMAKE_C_FLAGS_RELWITHDEBINFO@"
+#cmakedefine CMAKE_C_FLAGS_RELEASE "@CMAKE_C_FLAGS@_RELEASE"
+
+#cmakedefine CMAKE_CXX_COMPILER "@CMAKE_CXX_COMPILER@"
+#cmakedefine CMAKE_CXX_FLAGS "@CMAKE_CXX_FLAGS@"
+#cmakedefine CMAKE_CXX_FLAGS_DEBUG "@CMAKE_CXX_FLAGS_DEBUG@"
+#cmakedefine CMAKE_CXX_FLAGS_RELWITHDEBINFO "@CMAKE_CXX_FLAGS_RELWITHDEBINFO@"
+#cmakedefine CMAKE_CXX_FLAGS_RELEASE "@CMAKE_CXX_FLAGS_RELEASE@"
+
+#cmakedefine CMAKE_C_SHARED_LIBRARY_FLAGS "@CMAKE_C_SHARED_LIBRARY_FLAGS@"
+#cmakedefine CMAKE_CXX_SHARED_LIBRARY_FLAGS "@CMAKE_CXX_SHARED_LIBRARY_FLAGS@"
+
+/* Macro flags */
+#cmakedefine CPP_LOGGER_GNU_LINUX 1
+#define CPP_LOGGER_GET_VERSION(MAJOR, MINOR, PATCH) (MAJOR * 100000 + MINOR * 100 + PATCH)
+#define CPP_LOGGER_VERSION (CPP_LOGGER_GET_VERSION @CPP_LOGGER_VERSION@)
+#define CPP_LOGGER_VERSION_MAJOR (CPP_LOGGER_VERSION / 100000)
+#define CPP_LOGGER_VERSION_MINOR ((CPP_LOGGER_VERSION / 100) % 1000)
+#define CPP_LOGGER_VERSION_PATCH (CPP_LOGGER_VERSION % 100)
+
+#endif /* CPP_LOGGER_CONFIG_H */
\ No newline at end of file
diff --git a/cmake/configure_files/cpp_logger_module.lua.in b/cmake/configure_files/cpp_logger_module.lua.in
new file mode 100644
index 0000000..ceba345
--- /dev/null
+++ b/cmake/configure_files/cpp_logger_module.lua.in
@@ -0,0 +1,45 @@
+-- LMod module file for CPP_LOGGER
+
+-- CMAKE_INSTALL_PREFIX: @CMAKE_INSTALL_PREFIX@
+-- CMAKE_BUILD_TYPE: @CMAKE_BUILD_TYPE@
+-- C Compiler: @CMAKE_C_COMPILER@
+-- C FLAGS: @CMAKE_C_FLAGS@
+-- C FLAGS_DEBUG: @CMAKE_C_FLAGS_DEBUG@
+-- C FLAGS_RELWITHDEBINFO: @CMAKE_C_FLAGS_RELWITHDEBINFO@
+-- C FLAGS_RELEASE: @CMAKE_C_FLAGS_RELEASE@
+-- CXX Compiler: @CMAKE_CXX_COMPILER@
+-- CXX FLAGS: @CMAKE_CXX_FLAGS@
+-- CXX FLAGS_DEBUG: @CMAKE_CXX_FLAGS_DEBUG@
+-- CXX FLAGS_RELWITHDEBINFO: @CMAKE_CXX_FLAGS_RELWITHDEBINFO@
+-- CXX FLAGS_RELEASE: @CMAKE_CXX_FLAGS_RELEASE@
+-- CPP_LOGGER_GNU_LINUX: @CPP_LOGGER_GNU_LINUX@
+-- CPP_LOGGER_HAS_DOXYGEN: @CPP_LOGGER_HAS_DOXYGEN@
+
+help(
+[[
+DYnamic and Asynchronous Data streamliner (CPP_LOGGER) version @CPP_LOGGER_VERSION@.
+]])
+
+whatis("Package: CPP_LOGGER")
+whatis("Version: @CPP_LOGGER_VERSION@")
+whatis("Description: DYnamic and Asynchronous Data streamliner (CPP_LOGGER).")
+whatis("URL: https://github.com/flux-framework/cpp_logger")
+whatis("CMAKE_INSTALL_PREFIX: @CMAKE_INSTALL_PREFIX@")
+whatis("CMAKE_BUILD_TYPE: @CMAKE_BUILD_TYPE@")
+whatis("C Compiler: @CMAKE_C_COMPILER@")
+whatis("C FLAGS: @CMAKE_C_FLAGS@")
+whatis("C FLAGS_DEBUG: @CMAKE_C_FLAGS_DEBUG@")
+whatis("C FLAGS_RELWITHDEBINFO: @CMAKE_C_FLAGS_RELWITHDEBINFO@")
+whatis("C FLAGS_RELEASE: @CMAKE_C_FLAGS_RELEASE@")
+whatis("CXX Compiler: @CMAKE_CXX_COMPILER@")
+whatis("CXX FLAGS: @CMAKE_CXX_FLAGS@")
+whatis("CXX FLAGS_DEBUG: @CMAKE_CXX_FLAGS_DEBUG@")
+whatis("CXX FLAGS_RELWITHDEBINFO: @CMAKE_CXX_FLAGS_RELWITHDEBINFO@")
+whatis("CXX FLAGS_RELEASE: @CMAKE_CXX_FLAGS_RELEASE@")
+whatis("CPP_LOGGER_GNU_LINUX: @CPP_LOGGER_GNU_LINUX@")
+whatis("CPP_LOGGER_HAS_DOXYGEN: @CPP_LOGGER_HAS_DOXYGEN@")
+
+prepend_path("PATH","@CMAKE_INSTALL_PREFIX@/@CMAKE_INSTALL_BINDIR@")
+prepend_path("LD_LIBRARY_PATH","@CMAKE_INSTALL_PREFIX@/@CMAKE_INSTALL_LIBDIR@")
+
+pushenv("CPP_LOGGER_DIR","@CMAKE_INSTALL_PREFIX@/@CMAKE_INSTALL_DIR@")
\ No newline at end of file
diff --git a/cmake/modules/SetupCompiler.cmake b/cmake/modules/SetupCompiler.cmake
new file mode 100644
index 0000000..6b6772e
--- /dev/null
+++ b/cmake/modules/SetupCompiler.cmake
@@ -0,0 +1,217 @@
+################################################################
+# Set compiler standard
+################################################################
+
+set(CMAKE_C_STANDARD 11)
+set(CMAKE_C_STANDARD_REQUIRED ON)
+# This is off to use -std=c11 instead of -std=gnu11
+set(CMAKE_C_EXTENSIONS OFF)
+# Add _POSIX_C_SOURCE to avoid warning on setenv() as C_EXTENSIONS is off
+add_definitions(-D_POSIX_C_SOURCE=200809L)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+#set(CMAKE_C_VISIBILITY_PRESET hidden)
+#set(CMAKE_CXX_VISIBILITY_PRESET hidden)
+
+
+################################################################
+# Check and add compiler flags
+################################################################
+
+include(CheckCCompilerFlag)
+include(CheckCXXCompilerFlag)
+include(CheckIncludeFileCXX)
+
+MACRO (CHECK_GLIBC_VERSION)
+    EXECUTE_PROCESS (
+        COMMAND ${CMAKE_C_COMPILER} -print-file-name=libc.so.6
+        OUTPUT_VARIABLE GLIBC
+        OUTPUT_STRIP_TRAILING_WHITESPACE)
+
+    GET_FILENAME_COMPONENT (GLIBC ${GLIBC} REALPATH)
+    GET_FILENAME_COMPONENT (GLIBC_VERSION ${GLIBC} NAME)
+    STRING (REPLACE "libc-" "" GLIBC_VERSION ${GLIBC_VERSION})
+    STRING (REPLACE "libc" "" GLIBC_VERSION ${GLIBC_VERSION})
+    STRING (REPLACE ".so" "" GLIBC_VERSION ${GLIBC_VERSION})
+    IF (NOT GLIBC_VERSION MATCHES "^[0-9.]+$")
+        MESSAGE (FATAL_ERROR "Unknown glibc version: ${GLIBC_VERSION}")
+    ENDIF (NOT GLIBC_VERSION MATCHES "^[0-9.]+$")
+ENDMACRO (CHECK_GLIBC_VERSION)
+
+CHECK_GLIBC_VERSION()
+
+# MACRO cpp_logger_add_c|cxx_flags
+#
+# Purpose: checks that all flags are valid and appends them to the
+#   given list. Valid means that the cxx compiler does not throw an
+#   error upon encountering the flag.
+#
+# Arguments:
+#   MY_FLAGS The list of current flags
+#   ARGN The flags to check
+#
+# Note: If flag is not valid, it is not appended.
+macro(cpp_logger_add_cxx_flags MY_FLAGS)
+  foreach(flag ${ARGN})
+    string(FIND "${${MY_FLAGS}}" "${flag}" flag_already_set)
+    if(flag_already_set EQUAL -1)
+      string(REPLACE "-" "_" _CLEAN_FLAG "${flag}")
+
+      set(CMAKE_REQUIRED_LIBRARIES "${flag}")
+      check_cxx_compiler_flag("${flag}" FLAG_${_CLEAN_FLAG}_OK)
+      unset(CMAKE_REQUIRED_LIBRARIES)
+
+      if (FLAG_${_CLEAN_FLAG}_OK)
+        set(${MY_FLAGS} "${${MY_FLAGS}} ${flag}")
+      endif ()
+      unset(FLAG_${_CLEAN_FLAG}_OK CACHE)
+    endif()
+  endforeach()
+endmacro()
+
+macro(cpp_logger_add_c_flags MY_FLAGS)
+  foreach(flag ${ARGN})
+    string(FIND "${${MY_FLAGS}}" "${flag}" flag_already_set)
+    if(flag_already_set EQUAL -1)
+      string(REPLACE "-" "_" _CLEAN_FLAG "${flag}")
+
+      set(CMAKE_REQUIRED_LIBRARIES "${flag}")
+      check_c_compiler_flag("${flag}" FLAG_${_CLEAN_FLAG}_OK)
+      unset(CMAKE_REQUIRED_LIBRARIES)
+
+      if (FLAG_${_CLEAN_FLAG}_OK)
+        set(${MY_FLAGS} "${${MY_FLAGS}} ${flag}")
+      endif ()
+      unset(FLAG_${_CLEAN_FLAG}_OK CACHE)
+    endif()
+  endforeach()
+endmacro()
+
+cpp_logger_add_cxx_flags(CMAKE_CXX_FLAGS
+  -fPIC -Wall -Wextra -pedantic -Wno-unused-parameter -Wnon-virtual-dtor
+  -Wno-deprecated-declarations)
+
+cpp_logger_add_c_flags(CMAKE_C_FLAGS
+  -fPIC -Wall -Wextra -pedantic -Wno-unused-parameter
+  -Wno-deprecated-declarations)
+
+if (${GLIBC_VERSION} VERSION_GREATER_EQUAL "2.19")
+  # to suppress usleep() warning
+  add_definitions(-D_DEFAULT_SOURCE)
+endif ()
+
+################################################################
+# Promote a compiler warning as an error for project targets
+################################################################
+
+if (CPP_LOGGER_WARNINGS_AS_ERRORS)
+  cpp_logger_add_cxx_flags(_WERROR_FLAGS -Werror)
+  separate_arguments(_WERROR_FLAGS NATIVE_COMMAND "${_WERROR_FLAGS}")
+  if (NOT TARGET CPP_LOGGER_CXX_FLAGS_werror)
+    add_library(CPP_LOGGER_CXX_FLAGS_werror INTERFACE)
+    set_property(TARGET CPP_LOGGER_CXX_FLAGS_werror PROPERTY
+      INTERFACE_COMPILE_OPTIONS $<$<COMPILE_LANGUAGE:CXX>:${_WERROR_FLAGS}>)
+
+    add_library(CPP_LOGGER_C_FLAGS_werror INTERFACE)
+    set_property(TARGET CPP_LOGGER_C_FLAGS_werror PROPERTY
+      INTERFACE_COMPILE_OPTIONS $<$<COMPILE_LANGUAGE:C>:${_WERROR_FLAGS}>)
+
+    # Add the "library" to the export
+    install(TARGETS CPP_LOGGER_C_FLAGS_werror EXPORT ${CPP_LOGGER_EXPORTED_TARGETS})
+    install(TARGETS CPP_LOGGER_CXX_FLAGS_werror EXPORT ${CPP_LOGGER_EXPORTED_TARGETS})
+  endif ()
+endif ()
+
+
+################################################################
+# Handle compiler dependent behaviors
+################################################################
+
+set(CMAKE_C_COMPILER_ID ${CMAKE_CXX_COMPILER_ID})
+
+# Some behavior is dependent on the compiler version.
+if (NOT CMAKE_CXX_COMPILER_VERSION)
+  execute_process(
+    COMMAND ${CMAKE_CXX_COMPILER} -dumpversion
+    OUTPUT_VARIABLE CXX_VERSION)
+else ()
+  set(CXX_VERSION "${CMAKE_CXX_COMPILER_VERSION}")
+endif ()
+
+# - Special handling if we're compiling with Clang's address sanitizer
+# - gcc toolchain handling for interoperability, especially with the exteral
+#   libraries pre-built using gcc
+if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+  if (USE_CLANG_LIBCXX)
+    cpp_logger_add_cxx_flags(CMAKE_CXX_FLAGS "--stdlib=libc++")
+  else (USE_CLANG_LIBCXX)
+    if (GCC_TOOLCHAIN)
+      cpp_logger_add_cxx_flags(CMAKE_CXX_FLAGS "--gcc-toolchain=${GCC_TOOLCHAIN}")
+    endif (GCC_TOOLCHAIN)
+  endif (USE_CLANG_LIBCXX)
+
+  if (CMAKE_BUILD_TYPE MATCHES Debug)
+    cpp_logger_add_cxx_flags(CMAKE_CXX_FLAGS
+      -fsanitize=address -fno-omit-frame-pointer -fsanitize-recover=address)
+    cpp_logger_add_c_flags(CMAKE_C_FLAGS
+      -fsanitize=address -fno-omit-frame-pointer -fsanitize-recover=address)
+    add_link_options(-fsanitize=address)
+  else()
+    cpp_logger_add_cxx_flags(CMAKE_CXX_FLAGS -fno-omit-frame-pointer)
+    cpp_logger_add_c_flags(CMAKE_C_FLAGS -fno-omit-frame-pointer)
+  endif ()
+endif ()
+
+# Turn off some annoying warnings
+if (CMAKE_CXX_COMPILER_ID MATCHES "Intel")
+  # Bugs with Intel compiler version 19
+  #https://community.intel.com/t5/Intel-C-Compiler/quot-if-constexpr-quot-and-quot-missing-return-statement-quot-in/td-p/1154551
+  #https://bitbucket.org/berkeleylab/upcxx/issues/286/icc-bug-bogus-warning-use-of-offsetof-with
+  if (GCC_PATH)
+    set(GCC_INTEROP "-gcc-name=${GCC_PATH}")
+  endif (GCC_PATH)
+  # -openmp_profile
+  cpp_logger_add_cxx_flags(CMAKE_CXX_FLAGS -diag-disable=2196 -wd1011 -wd1875 -diag-disable=11074 -diag-disable=11076 ${GCC_INTEROP})
+  cpp_logger_add_cxx_flags(CMAKE_C_FLAGS -diag-disable=2196 -wd1011 -wd1875 -diag-disable=11074 -diag-disable=11076 ${GCC_INTEROP})
+endif ()
+
+
+################################################################
+# Initialize RPATH
+################################################################
+
+# Use RPATH on OS X
+if (APPLE)
+  set(CMAKE_MACOSX_RPATH ON)
+endif ()
+
+# Use (i.e. don't skip) RPATH for build
+set(CMAKE_SKIP_BUILD_RPATH FALSE)
+
+# Use same RPATH for build and install
+set(CMAKE_BUILD_WITH_INSTALL_RPATH FALSE)
+
+# Add the automatically determined parts of the RPATH
+# which point to directories outside the build tree to the install RPATH
+set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
+
+if (NOT CPP_LOGGER_LIBDIR)
+  if (CMAKE_INSTALL_LIBDIR)
+    set(CPP_LOGGER_LIBDIR ${CMAKE_INSTALL_LIBDIR})
+  else ()
+    set(CPP_LOGGER_LIBDIR "lib")
+  endif ()
+endif ()
+
+set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/${CPP_LOGGER_LIBDIR}")
+
+list(FIND CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES
+    "${CMAKE_INSTALL_PREFIX}/${CPP_LOGGER_LIBDIR}" _IS_SYSTEM_DIR)
+
+if (${_IS_SYSTEM_DIR} STREQUAL "-1")
+    # Set the install RPATH correctly
+    list(APPEND CMAKE_INSTALL_RPATH
+      "${CMAKE_INSTALL_PREFIX}/${CPP_LOGGER_LIBDIR}")
+endif ()
\ No newline at end of file
diff --git a/cmake/modules/cpp-logger-utils.cmake b/cmake/modules/cpp-logger-utils.cmake
new file mode 100644
index 0000000..6ed9b54
--- /dev/null
+++ b/cmake/modules/cpp-logger-utils.cmake
@@ -0,0 +1,132 @@
+################################################################
+# Utilities
+################################################################
+
+# A handy macro to add the current source directory to a local
+# filename. To be used for creating a list of sources.
+macro(set_full_path VAR)
+  unset(__tmp_names)
+  foreach(filename ${ARGN})
+    list(APPEND __tmp_names "${CMAKE_CURRENT_SOURCE_DIR}/${filename}")
+  endforeach()
+  set(${VAR} "${__tmp_names}")
+endmacro()
+
+# A function to get a string of spaces. Useful for formatting output.
+function(cpp_logger_get_space_string OUTPUT_VAR LENGTH)
+  set(_curr_length 0)
+  set(_out_str "")
+  while (${_curr_length} LESS ${LENGTH})
+    string(APPEND _out_str " ")
+    math(EXPR _curr_length "${_curr_length} + 1")
+  endwhile ()
+
+  set(${OUTPUT_VAR} "${_out_str}" PARENT_SCOPE)
+endfunction ()
+
+# This computes the maximum length of the things given in "ARGN"
+# interpreted as simple strings.
+macro(cpp_logger_get_max_str_length OUTPUT_VAR)
+  set(${OUTPUT_VAR} 0)
+  foreach(var ${ARGN})
+    string(LENGTH "${var}" _var_length)
+    if (_var_length GREATER _max_length)
+      set(${OUTPUT_VAR} ${_var_length})
+    endif ()
+  endforeach ()
+endmacro ()
+
+# Check to see if we are in a git repo
+find_program(__GIT_EXECUTABLE git)
+mark_as_advanced(__GIT_EXECUTABLE)
+if (__GIT_EXECUTABLE)
+  execute_process(
+    COMMAND ${__GIT_EXECUTABLE} rev-parse --is-inside-work-tree
+    WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
+    OUTPUT_VARIABLE __BUILDING_FROM_GIT_SOURCES
+    OUTPUT_STRIP_TRAILING_WHITESPACE)
+
+  if (__BUILDING_FROM_GIT_SOURCES)
+    # Get the git version so that we can embed it into the executable
+    execute_process(
+      COMMAND ${__GIT_EXECUTABLE} rev-parse --show-toplevel
+      WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
+      OUTPUT_VARIABLE __GIT_TOPLEVEL_DIR
+      OUTPUT_STRIP_TRAILING_WHITESPACE)
+    execute_process(
+      COMMAND ${__GIT_EXECUTABLE} rev-parse --git-dir
+      WORKING_DIRECTORY "${__GIT_TOPLEVEL_DIR}"
+      OUTPUT_VARIABLE __GIT_GIT_DIR
+      OUTPUT_STRIP_TRAILING_WHITESPACE)
+    execute_process(
+      COMMAND ${__GIT_EXECUTABLE} --git-dir "${__GIT_GIT_DIR}" describe
+      --abbrev=7 --always --dirty --tags
+      WORKING_DIRECTORY "${__GIT_TOPLEVEL_DIR}"
+      OUTPUT_VARIABLE __GIT_DESCRIBE_VERSION
+      OUTPUT_STRIP_TRAILING_WHITESPACE)
+
+    set(CPP_LOGGER_GIT_VERSION "${__GIT_DESCRIBE_VERSION}"
+      CACHE STRING "CPP_LOGGER's version string as told by git.")
+  endif (__BUILDING_FROM_GIT_SOURCES)
+endif (__GIT_EXECUTABLE)
+
+################################################################
+# Configuration summary
+################################################################
+
+# This creates a formatted string that contains a list of variables,
+# one per line, with their values interpreted as TRUE or FALSE. The
+# purpose is to provide uniform output, rather than an odd mixture of
+# "1", "0", "ON", "OFF", "TRUE" and "FALSE".
+macro(append_str_tf STRING_VAR)
+  cpp_logger_get_max_str_length(_max_length ${ARGN})
+  math(EXPR _max_length "${_max_length} + 2")
+
+  foreach(var ${ARGN})
+    string(LENGTH "${var}" _var_length)
+    math(EXPR _num_spaces "${_max_length} - ${_var_length}")
+    cpp_logger_get_space_string(_spaces ${_num_spaces})
+    if (${var})
+      set(${var} "TRUE")
+      string(APPEND ${STRING_VAR} "  ${var}:" "${_spaces}" "TRUE\n")
+    else ()
+      set(${var} "FALSE")
+      string(APPEND ${STRING_VAR} "  ${var}:" "${_spaces}" "FALSE\n")
+    endif ()
+  endforeach()
+endmacro ()
+
+function(install_external_project name url tag)
+    find_package(${name})
+    set(found_var ${name}_FOUND)
+    if (${${found_var}})
+        set(include_var ${name}_INCLUDE_DIRS)
+        set(library_var ${name}_LIBRARY_DIR)
+        include_directories(${${include_var}})
+        link_directories(${${library_var}})
+        message(STATUS "[${PROJECT_NAME}] found dependency already installed ${name} with include ${${include_var}} and library ${${library_var}}")
+    else()
+    set (configure_args ${ARGN})
+    message(STATUS "[${PROJECT_NAME}] Got extra configure arguments for ${name} dependency as ${configure_args}")
+    ExternalProject_Add(
+            ${name}
+            PREFIX ${CMAKE_BINARY_DIR}
+            GIT_REPOSITORY ${url}
+            GIT_TAG ${tag}
+            TIMEOUT 10
+            GIT_SHALLOW 1
+            GIT_SUBMODULES ""
+            UPDATE_COMMAND ""
+            PATCH_COMMAND git submodule update --init
+            CMAKE_ARGS "-DCMAKE_INSTALL_PREFIX=${CMAKE_BINARY_DIR}" ${configure_args}
+            BUILD_COMMAND make -j
+            INSTALL_COMMAND make install  -j
+            LOG_DOWNLOAD ON
+    )
+    include_directories(${CMAKE_BINARY_DIR}/include)
+    link_directories(${CMAKE_BINARY_DIR}/lib)
+    link_directories(${CMAKE_BINARY_DIR}/lib64)
+    include_directories(${CMAKE_BINARY_DIR}/src/${name}/include)
+    endif()
+endfunction()
+
diff --git a/src/cpp-logger/clogger.cpp b/src/cpp-logger/clogger.cpp
index 8b04264..af67ab7 100644
--- a/src/cpp-logger/clogger.cpp
+++ b/src/cpp-logger/clogger.cpp
@@ -5,10 +5,11 @@ void cpp_logger_clog(int logger_level, const char *name, const char *string, ...
   va_list args;
   va_start(args, string);
   char buffer[4096];
-  int resu = vsprintf(buffer, string, args);
+  int result = vsprintf(buffer, string, args);
   cpplogger::Logger::Instance(name)->log(
       static_cast<cpplogger::LoggerType>(logger_level), buffer);
   va_end(args);
+  (void) result;
 }
 void cpp_logger_clog_level(const int logger_level, const char *name) {
   cpplogger::Logger::Instance(name)->level = static_cast<cpplogger::LoggerType>(logger_level);
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
new file mode 100644
index 0000000..e69de29