diff --git a/Applications/CLI/ogs.cpp b/Applications/CLI/ogs.cpp
index e875ed3e242869f8465b165fa9a52a49f5ecd2c9..7cca4ec752a274ebe447086984ca20ddf40f4935 100644
--- a/Applications/CLI/ogs.cpp
+++ b/Applications/CLI/ogs.cpp
@@ -57,7 +57,9 @@ int main(int argc, char* argv[])
         "See accompanying file LICENSE.txt or "
         "http://www.opengeosys.org/project/license\n"
         "version: " +
-            BaseLib::BuildInfo::git_describe,
+            BaseLib::BuildInfo::git_describe + "\n" +
+        "CMake arguments: " +
+            BaseLib::BuildInfo::cmake_args,
         ' ',
         BaseLib::BuildInfo::git_describe);
 
diff --git a/BaseLib/BuildInfo.cpp.in b/BaseLib/BuildInfo.cpp.in
index 0be2b3e0f4faa2c593b043d8b36919e3826068c5..f3b5b2059f6e62e94070fddd13b80a1ae699e2f1 100644
--- a/BaseLib/BuildInfo.cpp.in
+++ b/BaseLib/BuildInfo.cpp.in
@@ -29,6 +29,7 @@ namespace BuildInfo
 
     const std::string git_describe("@GIT_DESCRIBE@");
     const std::string ogs_version("@OGS_VERSION@");
+    const std::string cmake_args("@CMAKE_ARGS_ESCAPED@");
 
     const std::string source_path("@CMAKE_CURRENT_SOURCE_DIR@");
     const std::string data_path("@Data_SOURCE_DIR@");
diff --git a/BaseLib/BuildInfo.h b/BaseLib/BuildInfo.h
index b8b66a396ef463c2d300e7a7fc9f250915a70a26..7a9560081efb05babd0d6d877d9836cd5bd19421 100644
--- a/BaseLib/BuildInfo.h
+++ b/BaseLib/BuildInfo.h
@@ -32,6 +32,7 @@ namespace BuildInfo
 
     extern BASELIB_EXPORT const std::string git_describe;
     extern BASELIB_EXPORT const std::string ogs_version;
+    extern BASELIB_EXPORT const std::string cmake_args;
 
     extern BASELIB_EXPORT const std::string source_path;
     extern BASELIB_EXPORT const std::string data_path;
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 39e3716c5d06ecdcd714be0091ae797d3ec2072d..16dda92348caf45faa2d8855d8b6cf3ed48ed990 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -22,10 +22,8 @@ endif()
 # Project name
 project( OGS-6 )
 
-list(APPEND CMAKE_PREFIX_PATH
-    $ENV{HOMEBREW_ROOT}             # Homebrew package manager on Mac OS
-    $ENV{CMAKE_LIBRARY_SEARCH_PATH} # Environment variable, Windows
-    ${CMAKE_LIBRARY_SEARCH_PATH})   # CMake option, Windows
+include(scripts/cmake/CMakeSetup.cmake)
+include(ParseCMakeArgs)
 
 ###########################
 ### Preliminary Options ###
@@ -49,22 +47,21 @@ if(OGS_USE_PETSC)
 endif()
 
 ### CMake includes ###
-include(scripts/cmake/PreFind.cmake)
-include(scripts/cmake/CheckTypeSizes.cmake)
-include(scripts/cmake/Functions.cmake)
-include(scripts/cmake/SubmoduleSetup.cmake)
-include(scripts/cmake/CMakeSetup.cmake)
-include(scripts/cmake/ConanSetup.cmake)
-include(scripts/cmake/CompilerSetup.cmake)
-include(scripts/cmake/Find.cmake)
-include(scripts/cmake/CCacheSetup.cmake)
-include(scripts/cmake/ProjectSetup.cmake)
-include(scripts/cmake/DocumentationSetup.cmake)
-include(scripts/cmake/test/Test.cmake)
+include(PreFind)
+include(CheckTypeSizes)
+include(Functions)
+include(SubmoduleSetup)
+include(ConanSetup)
+include(CompilerSetup)
+include(Find)
+include(CCacheSetup)
+include(ProjectSetup)
+include(DocumentationSetup)
+include(test/Test)
 if(OGS_COVERAGE AND NOT IS_SUBPROJECT)
-    include(scripts/cmake/Coverage.cmake)
+    include(Coverage)
 endif()
-include(scripts/cmake/Web.cmake)
+include(Web)
 
 ####################
 ### More Options ###
diff --git a/scripts/cmake/CMakeSetup.cmake b/scripts/cmake/CMakeSetup.cmake
index 0a52647c69a5c7214b59224b5cfecbcc3b0e97a7..685a07e37f1dd12768e3628cbc5c1f020fa8f3a2 100644
--- a/scripts/cmake/CMakeSetup.cmake
+++ b/scripts/cmake/CMakeSetup.cmake
@@ -1,14 +1,23 @@
+# Disallow in-source builds as the git project cluttered with generated files
+# probably confuses people. source/build* is still allowed!
+if("${PROJECT_SOURCE_DIR}" STREQUAL "${PROJECT_BINARY_DIR}")
+   message(FATAL_ERROR "In-source builds are not allowed!\n"
+    "Make sure to remove CMakeCache.txt and CMakeFiles/ "
+    "from the source directory!")
+endif()
+
 # Set additional CMake modules path
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH}
   "${CMAKE_CURRENT_SOURCE_DIR}/scripts/cmake"
   "${CMAKE_CURRENT_SOURCE_DIR}/ThirdParty/cmake-modules")
 
+list(APPEND CMAKE_PREFIX_PATH
+  $ENV{HOMEBREW_ROOT}             # Homebrew package manager on Mac OS
+  $ENV{CMAKE_LIBRARY_SEARCH_PATH} # Environment variable, Windows
+  ${CMAKE_LIBRARY_SEARCH_PATH})   # CMake option, Windows
+
 # Load addional modules
-include(UseBackportedModules)
-include(OptionRequires)
-include(CppcheckTargets)
 include(GNUInstallDirs)
-
 include(ProcessorCount)
 ProcessorCount(NUM_PROCESSORS)
 set(NUM_PROCESSORS ${NUM_PROCESSORS} CACHE STRING "Processor count")
diff --git a/scripts/cmake/ParseCMakeArgs.cmake b/scripts/cmake/ParseCMakeArgs.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..ed56906582e60b0ecd4d99fe28d64fb8e91108d8
--- /dev/null
+++ b/scripts/cmake/ParseCMakeArgs.cmake
@@ -0,0 +1,40 @@
+# Implementation from https://stackoverflow.com/questions/10205986
+#
+# Captures not-yet cached CMake variables.
+# On first CMake run via cmake-cli this works as expected.
+# Once the variables are cached this will not work anymore (and is
+# therefore skipped).
+#
+# When running CMake -D.. passed args can be retrieved with by the
+# CACHE_VARIABLES CMake property. On sub-sequent CMake runs it is
+# no longer possible to differentiate between variables already cached
+# by option()-calls and variables passed to the CMake call with -D..
+#
+# A (cached) map data structure would solve this.
+# Tried the following map implementations without luck:
+# - https://github.com/toeb/cmakepp (not cached)
+# - https://github.com/j3lamp/mcl (did not work at all)
+
+if(EXISTS ${PROJECT_BINARY_DIR}/CMakeCache.txt)
+    set(CMAKE_ARGS "Information not available.")
+    set(CMAKE_ARGS_ESCAPED ${CMAKE_ARGS})
+    file(REMOVE ${PROJECT_BINARY_DIR}/cmake-args)
+    return()
+endif()
+
+get_cmake_property(CACHE_VARS CACHE_VARIABLES)
+foreach(CACHE_VAR ${CACHE_VARS})
+  get_property(CACHE_VAR_HELPSTRING CACHE ${CACHE_VAR} PROPERTY HELPSTRING)
+  if(CACHE_VAR_HELPSTRING STREQUAL "No help, variable specified on the command line.")
+    get_property(CACHE_VAR_TYPE CACHE ${CACHE_VAR} PROPERTY TYPE)
+    if(CACHE_VAR_TYPE STREQUAL "UNINITIALIZED")
+      set(CACHE_VAR_TYPE)
+    else()
+      set(CACHE_VAR_TYPE :${CACHE_VAR_TYPE})
+    endif()
+    set(CMAKE_ARGS "${CMAKE_ARGS} -D${CACHE_VAR}${CACHE_VAR_TYPE}=\"${${CACHE_VAR}}\"")
+  endif()
+endforeach()
+
+string(REPLACE "\"" "\\\"" CMAKE_ARGS_ESCAPED ${CMAKE_ARGS})
+file(WRITE ${PROJECT_BINARY_DIR}/cmake-args "${CMAKE_ARGS}\n")
diff --git a/scripts/cmake/packaging/Pack.cmake b/scripts/cmake/packaging/Pack.cmake
index 3ef648bf2d41e0433cb2ce141fef26f944b95977..0ef317ec54a36b5f75b8be24d0dce1bae2142c42 100644
--- a/scripts/cmake/packaging/Pack.cmake
+++ b/scripts/cmake/packaging/Pack.cmake
@@ -126,3 +126,6 @@ endif()
 
 configure_file(Documentation/README.txt.in ${PROJECT_BINARY_DIR}/README.txt)
 install(FILES ${PROJECT_BINARY_DIR}/README.txt DESTINATION .)
+
+install(FILES ${PROJECT_BINARY_DIR}/CMakeCache.txt DESTINATION ${CMAKE_INSTALL_INFODIR})
+install(FILES ${PROJECT_BINARY_DIR}/cmake-args DESTINATION ${CMAKE_INSTALL_INFODIR})
diff --git a/web/content/docs/devguide/getting-started/build-configuration.pandoc b/web/content/docs/devguide/getting-started/build-configuration.pandoc
index a57fbe649a945903cf6ee651879fa8c69d02ecf2..cc5a755c036d3081013eb6b35932fa6f504dc916 100644
--- a/web/content/docs/devguide/getting-started/build-configuration.pandoc
+++ b/web/content/docs/devguide/getting-started/build-configuration.pandoc
@@ -20,16 +20,35 @@ To separate source code from generated files such as compiled libraries, executa
 
 So just go ahead and create a build-directory along your source code directory.
 
+## Configure with CMake
 
-## Install required libraries with Conan
+For configuring a build the open source [CMake](http://www.cmake.org) tool is used. CMakeLists.txt files replace traditional Makefiles or IDE project files. The CMake tool is run inside the build-directory with a reference to the source code-directory of the project and user-chosen options. CMake then generates based on the chosen *Generator* either Makefiles or project files for IDE such as Visual Studio or Eclipse inside the build directory. Also all the compiled files will be generated in this directory. This keeps the actual source code clean from intermediate files which are generated from the source code. Nothing inside the build directory will ever be version controlled because its contents can be regenerated anytime from the source code.
 
-It is preferred to use Conan package manager to install required third-party libraries. If [Conan is installed]({{< ref "prerequisites" >}}#step-install-conan-package-manager) it will automatically download either prebuilt binaries of required libraries or build them locally if a binary for your setup (operating system, compiler, ..) is not available. [Check this]({{< ref "conan-package-manager.pandoc" >}}) for advanced Conan usage.
+Because of the separation of the source code and all stuff that is generated as a part of the build process it is no problem to have several build configurations (e.g. a serial configuration and a parallelized MPI-enabled configuration) all referring to the same source code.
 
-*Note:* Instead of using Conan you can optionally [install the required libraries manually]({{< ref "third-party-libraries.pandoc" >}}).
+When you want to start over with a new configuration simply delete the build-directory, create a new one and reconfigure.
+
+[See this]({{< ref "configuration-options" >}}) for a list of available options.
 
 ::: {.win}
 ::: {.note}
-### <i class="fas fa-exclamation-triangle"></i> Multi-configuration with Conan and Visual Studio
+### <i class="fas fa-exclamation-triangle"></i> Supported Visual Studio Generators
+
+- `Visual Studio 15 2017 Win64` (preferred)
+- `Visual Studio 14 2015 Win64`
+
+:::
+:::
+
+### Note: Installation of required libraries
+
+It is preferred to use the Conan package manager to install required third-party libraries. If [Conan is installed]({{< ref "prerequisites" >}}#step-install-conan-package-manager) it will automatically download either prebuilt binaries of required libraries or build them locally if a binary for your setup (operating system, compiler, ..) is not available. [Check this]({{< ref "conan-package-manager.pandoc" >}}) for advanced Conan usage.
+
+Instead of using Conan you can optionally [install the required libraries manually]({{< ref "third-party-libraries.pandoc" >}}) **before** running CMake.
+
+::: {.win}
+::: {.note}
+#### <i class="fas fa-exclamation-triangle"></i> Multi-configuration with Conan and Visual Studio
 
 With Conan one build directory corresponds to one configuration. If you want to have e.g. a release and a debug build you need to create two build directories. This is nothing new new to Linux / GCC user but differs to Visual Studios default behavior having just one build-folder / project with different configurations. A typical Visual Studio setup with both Release and Debug configs would be initialized as follows:
 
@@ -37,9 +56,9 @@ With Conan one build directory corresponds to one configuration. If you want to
 $ [assuming you are at the same directory where the source code directory is located]
 $ mkdir ogs-build && cd ogs-build
 $ mkdir debug && cd debug
-$ cmake ../../ogs -G "Visual Studio 14 2015 Win64" -DCMAKE_BUILD_TYPE=Debug
+$ cmake ../../ogs -G "Visual Studio 15 2017 Win64" -DCMAKE_BUILD_TYPE=Debug
 $ cd .. && mkdir release && cd release
-$ cmake ../../ogs -G "Visual Studio 14 2015 Win64" -DCMAKE_BUILD_TYPE=Release
+$ cmake ../../ogs -G "Visual Studio 15 2017 Win64" -DCMAKE_BUILD_TYPE=Release
 ```
 
 `..\..\ogs` represents the relative path to the source code (please adapt if you have a different directory layout).
@@ -48,23 +67,12 @@ Please also note that in Visual Studio you have to choose the correct configurat
 :::
 :::
 
-
-## Configure with CMake
-
-For configuring a build the open source [CMake](http://www.cmake.org) tool is used. CMakeLists.txt files replace traditional Makefiles or IDE project files. The CMake tool is run inside the build-directory with a reference to the source code-directory of the project and user-chosen options. CMake then generates either Makefiles or project files for IDE such as Visual Studio or Eclipse inside the build directory. Also all the compiled files will be generated in this directory. This keeps the actual source code clean from intermediate files which are generated from the source code. Nothing inside the build directory will ever be version controlled because its contents can be regenerated anytime from the source code.
-
-Because of the separation of the source code and all stuff that is generated as a part of the build process it is no problem to have several build configurations (e.g. a serial configuration and a parallelized MPI-enabled configuration) all referring to the same source code.
-
-When you want to start over with a new configuration simply delete the build-directory, create a new one and reconfigure.
-
-[See this]({{< ref "configuration-options" >}}) for a list of available options.
-
 ## Option: Configure from the command line
 
-CMake can be run from the shell by invoking the cmake command inside a build directory. You can pass any CMake variable or option with `-DVARIABLE_NAME=VALUE` (note the `-D` in front!). You can also pass the generator you want to use (e.g. `Unix Makefiles` or `Visual Studio 14 2015 Win64`-project files) with the `-G` parameter (to see all available generators just run `cmake --help`), although in most cases the appropriate generator will be chosen automatically. The last parameter to the CMake command is the path to the source code directory. A typical call would look like this:
+CMake can be run from the shell by invoking the cmake command inside a build directory. You can pass any CMake variable or option with `-DVARIABLE_NAME=VALUE` (note the `-D` in front!). You can also pass the generator you want to use (e.g. `Unix Makefiles` or `Visual Studio 15 2017 Win64`-project files) with the `-G` parameter (to see all available generators just run `cmake --help`), although in most cases the appropriate generator will be chosen automatically. The last parameter to the CMake command is the path to the source code directory. A typical call would look like this:
 
 ```bash
-$ cmake -G "Visual Studio 14 2015 Win64" -DCMAKE_BUILD_TYPE=Release ../ogs
+$ cmake -G "Visual Studio 15 2017 Win64 -DCMAKE_BUILD_TYPE=Release ../ogs
 ```
 
 CMake tries to autodetect your compiler so in most cases this should be enough:
@@ -76,7 +84,7 @@ $ cmake ../ogs
 ## Option: Configure with a visual tool
 
 ::: {.win}
-CMake comes with a graphical tool called **cmake-gui**. You can find it in the **Windows Start Menu**. First you need to set the source and build directory. Then click **Configure**. Now choose the generator to be used (e.g. **Visual Studio 14 2015 Win64** for Visual Studio 2015 64-bit). Now choose your desired configuration options by toggling the corresponding checkboxes. Click **Configure** again. Click **Configure** often enough until the **Generate**-button becomes visible. Pressing **Generate** will finally generate the project files inside the chosen build directory.
+CMake comes with a graphical tool called **cmake-gui**. You can find it in the **Windows Start Menu**. First you need to set the source and build directory. Then click **Configure**. Now choose the generator to be used (e.g. **Visual Studio 15 2017 Win64** for Visual Studio 2015 64-bit). Now choose your desired configuration options by toggling the corresponding checkboxes. Click **Configure** again. Click **Configure** often enough until the **Generate**-button becomes visible. Pressing **Generate** will finally generate the project files inside the chosen build directory.
 :::
 
 ::: {.linux}