diff --git a/.editorconfig b/.editorconfig
index dbd6ff49e76a040d5849d19e78fc711aba0a42b8..fc48fa2cb6e9b1fc31314641578ce3560739c427 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -5,7 +5,7 @@ trim_trailing_whitespace = true
insert_final_newline = true
indent_size = 4
-[*.md]
+[*.{md,pandoc}]
trim_trailing_whitespace = false
[*.{json,yml,toml}]
diff --git a/Jenkinsfile b/Jenkinsfile
index 09b1130fbf1643b6d6cce4ccabd9e7604600a112..58c8a89a9533ee2b4a4ca544166ef57671adaafd 100644
--- a/Jenkinsfile
+++ b/Jenkinsfile
@@ -13,7 +13,7 @@ pipeline {
agent any
steps {
sh "git config core.whitespace -blank-at-eof"
- sh "git diff --check `git merge-base origin/master HEAD` HEAD"
+ sh "git diff --check `git merge-base origin/master HEAD` HEAD -- . ':!*.md' ':!*.pandoc'"
}
}
stage('Build') {
diff --git a/scripts/cmake/Web.cmake b/scripts/cmake/Web.cmake
index 2acf42c9b718ed3a16976de1a222a546c7ccc966..5e0ae427e661a7fae5275f091dba4f4bda2e5b95 100644
--- a/scripts/cmake/Web.cmake
+++ b/scripts/cmake/Web.cmake
@@ -47,7 +47,7 @@ if(DEFINED ENV{JENKINS_URL})
else()
set(HUGO_BASE_URL "$ENV{JOB_URL}Web/")
endif()
- set(HUGO_ARGS ${HUGO_ARGS} --baseURL ${HUGO_BASE_URL} --canonifyURLs)
+ set(HUGO_ARGS ${HUGO_ARGS} --baseURL ${HUGO_BASE_URL})
endif()
add_custom_target(web
diff --git a/scripts/docker/Dockerfile.gcc.full b/scripts/docker/Dockerfile.gcc.full
index 1c280105ec8175f13cb8098d5200825453fc8384..ca68bce01ffbfa39d31cb50558e267668ec27929 100644
--- a/scripts/docker/Dockerfile.gcc.full
+++ b/scripts/docker/Dockerfile.gcc.full
@@ -57,8 +57,6 @@ RUN apt-get update \
graphviz \
libxml2-utils \
nodejs \
- pandoc \
- pandoc-citeproc \
yarn
RUN update-alternatives --install /usr/bin/node node /usr/bin/nodejs 10
@@ -69,6 +67,11 @@ RUN curl -L -o hugo.tar.gz https://github.com/gohugoio/hugo/releases/download/v0
&& mv hugo /usr/local/bin/hugo \
&& rm -rf hugo.tar.gz LICENSE.md README.md
+# Pandoc
+RUN curl -L -o pandoc.deb https://github.com/jgm/pandoc/releases/download/2.1.1/pandoc-2.1.1-1-amd64.deb \
+ && sudo dpkg -i pandoc.deb \
+ && rm pandoc.deb
+
# Include-what-you-use
RUN curl https://include-what-you-use.org/downloads/include-what-you-use-0.8-x86_64-linux-gnu-ubuntu-16.04.tar.gz -O \
&& tar xf include-what-you-use-0.8-x86_64-linux-gnu-ubuntu-16.04.tar.gz -C /usr/ --strip-components=1 \
diff --git a/web/config.toml b/web/config.toml
index 2377dca0e692f2b10232a3c37bfd95e3c6b13b72..9354cc76a32b2395591c5eccccf904a1f2f7821f 100644
--- a/web/config.toml
+++ b/web/config.toml
@@ -5,9 +5,10 @@ baseURL = "http://localhost:1313"
buildDrafts = true
pygmentsstyle = 'friendly'
enableGitInfo = true
+canonifyURLs = true
[params]
- alert = "Benchmarks only documentation; the Developer Guide can be found at <a href='https://docs.opengeosys.org'>docs.opengeosys.org</a>."
+ alert = "Documentation site under construction; more docs can be found at <a href='https://docs.opengeosys.org'>docs.opengeosys.org</a>."
[taxonomies]
news = "news"
@@ -28,6 +29,32 @@ news = "news"
[[menu.devguide]]
name = "Getting Started"
identifier = "getting-started"
+ weight = 1
+
+[[menu.devguide]]
+ name = "Development Workflows"
+ identifier = "development-workflows"
+ weight = 2
+
+[[menu.devguide]]
+ name = "Testing"
+ identifier = "testing"
+ weight = 3
+
+[[menu.devguide]]
+ name = "Advanced"
+ identifier = "advanced"
+ weight = 4
+
+[[menu.devguide]]
+ name = "Troubleshooting"
+ identifier = "troubleshooting"
+ weight = 5
+
+[[menu.devguide]]
+ name = "Procedures"
+ identifier = "procedures"
+ weight = 6
# Benchmarks sidebar top-level categories
[[menu.benchmarks]]
@@ -62,3 +89,9 @@ news = "news"
name = "Two-phase Flow"
identifier = "two-phase-flow"
weight = 8
+
+# Quickstart sidebar top-level categories
+[[menu.quickstart]]
+ name = "Basics"
+ identifier = "basics"
+ weight = 1
diff --git a/web/content/_index.pandoc b/web/content/_index.pandoc
new file mode 100644
index 0000000000000000000000000000000000000000..f0fed250c1f68cec615fbd263ccdcc46d07737a7
--- /dev/null
+++ b/web/content/_index.pandoc
@@ -0,0 +1,14 @@
++++
+title = "Documentation Site Under Construction"
+author = "Lars Bilke"
+date = "2017-01-13T14:24:23+01:00"
++++
+
+For the moment this site contains just the following documentations for [OpenGeoSys-6](https://github.com/ufz/ogs6):
+
+- [Quickstart](./docs/quickstart)
+- [Developer Guide](./docs/devguide)
+- [Benchmarks](./docs/benchmarks)
+- [Tools](./docs/tools)
+
+See [docs.opengeosys.org](https://docs.opengeosys.org/docs) for more documentation!
diff --git a/web/content/docs/_index.md b/web/content/docs/_index.md
index ba4e579d8bd8e9388023f0eacf6ae5e880e48cab..994ef9f15d27e5be1d4fc8178b12e1e857991f95 100644
--- a/web/content/docs/_index.md
+++ b/web/content/docs/_index.md
@@ -2,13 +2,18 @@
title = "Documentation"
[[sections]]
-name = "Selected Benchmarks"
-slug = "benchmarks"
-text = "Basic benchmarks are explained and input files are provided to get you started in using OGS."
+name = "Quickstart"
+slug = "quickstart"
+text = "Download, install and run an OGS benchmark in 5 minutes! No development setup required."
[[sections]]
name = "Developer Guide"
slug = "devguide"
text = "You want to contribute to the OpenGeoSys project or implement a custom feature? In the Developer Guide you will find everything to get you started into OpenGeoSys development. Experienced developers will find a comprehensive list of advanced development topics."
+[[sections]]
+name = "Selected Benchmarks"
+slug = "benchmarks"
+text = "Basic benchmarks are explained and input files are provided to get you started in using OGS."
+
+++
diff --git a/web/content/docs/benchmarks/elliptic/groundwater-flow-dirichlet-nodal-source-term.md b/web/content/docs/benchmarks/elliptic/groundwater-flow-dirichlet-nodal-source-term.md
index 663136f63649b7cd9111e1321d5eae2430eae4c3..0003eafc08648016a4477437091422340ba1a8f1 100644
--- a/web/content/docs/benchmarks/elliptic/groundwater-flow-dirichlet-nodal-source-term.md
+++ b/web/content/docs/benchmarks/elliptic/groundwater-flow-dirichlet-nodal-source-term.md
@@ -3,9 +3,7 @@ date = "2017-02-15T11:17:39+01:00"
title = "Groundwater Flow (Nodal Source Term)"
project = "Elliptic/circle_radius_1/circle_1e6_axi.prj"
author = "Thomas Fischer"
-weight = 101
-
-aliases = [ "/docs/benchmarks/" ] # First benchmark page
+weight = 104
[menu]
[menu.benchmarks]
diff --git a/web/content/docs/benchmarks/elliptic/groundwater-flow-robin.md b/web/content/docs/benchmarks/elliptic/groundwater-flow-robin.md
index 45b44a2ccc9cac5140ee72239e40fe46f8eea7c4..809203c355fd38331fd48ecb71c51686cfd9e20a 100644
--- a/web/content/docs/benchmarks/elliptic/groundwater-flow-robin.md
+++ b/web/content/docs/benchmarks/elliptic/groundwater-flow-robin.md
@@ -6,9 +6,7 @@ author = "Dmitri Naumov"
weight = 104
[menu]
-
[menu.benchmarks]
- #weight = 103
parent = "elliptic"
+++
diff --git a/web/content/docs/devguide/advanced/build-with-ninja.pandoc b/web/content/docs/devguide/advanced/build-with-ninja.pandoc
new file mode 100644
index 0000000000000000000000000000000000000000..3ffe49b3341a8aa72fb1a9b58f529650eca2b956
--- /dev/null
+++ b/web/content/docs/devguide/advanced/build-with-ninja.pandoc
@@ -0,0 +1,48 @@
++++
+date = "2018-02-26T11:00:13+01:00"
+title = "Build with ninja"
+author = "Lars Bilke"
+weight = 1031
+
+[menu]
+ [menu.devguide]
+ parent = "advanced"
++++
+
+## Install ninja
+
+::: {.win}
+Download *ninja.zip* from the [latest GitHub release](https://github.com/ninja-build/ninja/releases/latest). Unzip it and make sure that the directory containing the `ninja.exe` is the `PATH`-environment variable!
+:::
+
+::: {.linux}
+Install with your package manager:
+
+```bash
+$ sudo apt-get install ninja-build
+```
+:::
+
+::: {.mac}
+Install via Homebrew:
+
+```bash
+$ brew install ninja
+```
+:::
+
+
+## Configure for ninja and build
+
+Run CMake with the ninja-generator:
+
+```bash
+$ cmake ../source/dir -GNinja
+$ ninja
+```
+
+::: {.note}
+### <i class="fas fa-exclamation-triangle"></i> Visual Studio remarks
+
+When you configure with the Ninja generator you have to run CMake from the appropriate Visual Studio Command Prompt! From there you can both use `cmake` as well as `cmake-gui` which starts the GUI. In the GUI select the `Ninja` generator and leave the toggle `Use default native compilers` on.
+:::
diff --git a/web/content/docs/devguide/advanced/conan-package-manager.pandoc b/web/content/docs/devguide/advanced/conan-package-manager.pandoc
new file mode 100644
index 0000000000000000000000000000000000000000..bd682fb74f680065a268f0d463e2ba8f688b6753
--- /dev/null
+++ b/web/content/docs/devguide/advanced/conan-package-manager.pandoc
@@ -0,0 +1,27 @@
++++
+date = "2018-02-26T11:00:13+01:00"
+title = "Conan package manager"
+author = "Lars Bilke"
+weight = 1032
+
+[menu]
+ [menu.devguide]
+ parent = "advanced"
++++
+
+::: {.note}
+### <i class="fas fa-exclamation-triangle"></i> Conan 1.0.0 required
+
+As of OpenGeoSys 6.1.0 Conan version 1.0.0 is required! Please update Conan by running `pip install --upgrade conan` or by downloading the Windows installer.
+:::
+
+The [Conan package manager](https://www.conan.io) helps to install all required libraries in a convenient way on every platform. See [Setup pre-requisites](../../getting-started/prerequisites) for installation instructions. Set the CMake option `OGS_USE_CONAN=ON` to enable Conan.
+
+## Advanced usage
+
+Per default when Conan is enabled (`OGS_USE_CONAN=ON`) it will try to fetch prebuilt binaries from the [OGS Conan repository](https://ogs.jfrog.io/ogs/conan/) at https://ogs.jfrog.io/ogs/api/conan/conan. With the CMake option `OGS_CONAN_BUILD` you define what gets build locally. This option can be set to:
+
+- `missing` - Default, only builds packages which are not available as a prebuilt binary for the current configuration
+- `all` - Builds all packages locally
+- `never` - Builds no package locally
+- `[a list of libraries to build]`, e.g. `"Eigen3;Boost"`. For names see [ConanSetup.cmake](https://github.com/ufz/ogs/blob/master/scripts/cmake/ConanSetup.cmake). Make sure to set this back to 'never' after the libs have been built. Otherwise it would rebuild the libs on the next CMake run.
diff --git a/web/content/docs/devguide/advanced/configuration-options.pandoc b/web/content/docs/devguide/advanced/configuration-options.pandoc
new file mode 100644
index 0000000000000000000000000000000000000000..b56bed3220fd83f2ff568a6968dbbce559e672cf
--- /dev/null
+++ b/web/content/docs/devguide/advanced/configuration-options.pandoc
@@ -0,0 +1,53 @@
++++
+date = "2018-02-26T11:00:13+01:00"
+title = "Configuration options"
+author = "Lars Bilke"
+weight = 1033
+
+[menu]
+ [menu.devguide]
+ parent = "advanced"
++++
+
+## CMake options
+
+Some of these options are enabled by default ("*Defaults* to *ON*") otherwise they must be expicitly set to *ON*.
+
+#### General
+
+CMake switches to enable / disable parts of OGS.
+
+- `OGS_BUILD_CLI` - Builds the simulator. *Defaults* to *ON*.
+- `OGS_BUILD_GUI` - Builds the Data Explorer. *Defaults* to *OFF*.
+- `OGS_BUILD_TESTS` - Builds the test executables. *Defaults* to *ON*.
+- `OGS_BUILD_UTILS` - Builds several utilities.
+- `OGS_NO_EXTERNAL_LIBS` - Disables all external dependencies.
+
+#### Debugging
+
+- `CMAKE_BUILD_TYPE` - Defaults to `Debug` which builds with debugging infos, set to `Release` for an optimized build.
+- `OGS_PROFILE` - Builds with profiling flags (`-pg`).
+- `OGS_CMAKE_DEBUG` - Prints out the values of all defined CMake variables at CMake configuration time.
+
+#### Optimization
+
+- `CMAKE_BUILD_TYPE` - Set to `Release` to build with optimization flags, set to `Debug` for debugging.
+
+#### Logging
+
+- `OGS_DISABLE_LOGGING` - Disables all logog output messages. This really strips out all logog-code (useful for performance testing).
+
+#### Testing
+
+- `OGS_COVERAGE` - Enables code coverage measurements with gcov/lcov. TODO
+
+
+#### Advanced options
+
+- `Boost_USE_STATIC_LIBS` - Set this to ON to search for statically linked Boost libraries. Defaults to ON on Windows, to OFF otherwise.
+- `OGS_CXX_FLAGS` - Appends user-given compiler flags. Note that existing (CMake-given) flags are not replaced.
+- `OGS_ADDITIONAL_SUBMODULES_TO_CHECKOUT` - Specifies optional submodules which are checked out at CMake-time. This is intended to be used by Jenkins.
+- `OGS_PACKAGE_ADDITIONAL_BINARIES` - Package additional binaries (given as a `;`-separated list with relative paths to `CMAKE_BINARY_DIR`) into redistributables. Is used for bundling the OGS File Converter with the Data Explorer.
+- `OGS_USE_OPTIONAL_SUBMODULES` - Includes optional submodules into the build. The submodules have to be checked out before. Defaults to ON.
+- `OGS_CPU_ARCHITECTURE` - Optimizes for the given CPU architecture see [-march](https://gcc.gnu.org/onlinedocs/gcc-4.5.3/gcc/i386-and-x86_002d64-Options.html)-flag. Defaults to `native`. For redistributable binaries set to `generic` on Linux and `core2` on Mac OS.
+- `CMAKE_LIBRARY_SEARCH_PATH` - Additional library installation path, e.g. `/opt/local` or `C:/libs`
diff --git a/web/content/docs/devguide/advanced/docker.pandoc b/web/content/docs/devguide/advanced/docker.pandoc
new file mode 100644
index 0000000000000000000000000000000000000000..f61608f963fe9f30930976f0eb1f39e136c41ce4
--- /dev/null
+++ b/web/content/docs/devguide/advanced/docker.pandoc
@@ -0,0 +1,83 @@
++++
+date = "2018-02-26T11:00:13+01:00"
+title = "Docker"
+author = "Lars Bilke"
+weight = 1034
+
+[menu]
+ [menu.devguide]
+ parent = "advanced"
++++
+
+## Introduction
+
+> [Docker](https://www.docker.com/whatisdocker) containers wrap up a piece of software in a complete filesystem that contains everything it needs to run: code, runtime, system tools, system libraries – anything you can install on a server. This guarantees that it will always run the same, regardless of the environment it is running in.
+
+See the [docs](https://docs.docker.com) for installation instructions.
+
+## Images
+
+Docker images can be created by [Dockerfiles](https://docs.docker.com/reference/builder/) which can be stacked and thus form a directed graph. OGS-6 image definitions can be found at the [ufz/dockerfiles](https://github.com/ufz/dockerfiles)-repo. Built images can be found at [Docker Hub](https://registry.hub.docker.com/repos/ogs6/).
+
+To build an image by yourself create a Dockerfile:
+
+```
+FROM ubuntu:14.04
+MAINTAINER Jon Doe <jon.doe@foo.com>
+
+RUN ...
+```
+
+Run the `build` command:
+
+```bash
+$ docker build -t repo/image_name path/to/directory
+```
+
+- `-t` specifies a name for the image, can be arbitrary chosen (but should match the corresponding image on Docker Hub if there is one)
+- The path should specify the directory where the Dockerfile is located
+
+Now you can see your build image with `$ docker images`.
+
+## Run a container
+
+To run commands inside a container:
+
+```bash
+$ docker run -t image_name command_to_run
+```
+
+To run an interactive shell add the `-i`-switch:
+
+```bash
+$ docker run -i -t image_name /bin/bash
+```
+
+It is useful to mount folders from the host operating system in the Docker container, e.g. to edit source code on your host with your favorite editor:
+
+```bash
+$ docker run -i -t -v /host/directory:/container/directory image_name /bin/bash
+```
+
+## Prebuilt OGS-6 Docker images
+
+There are docker images provided on [Docker Hub](https://hub.docker.com/u/ogs6/) which include everything necessary to build OGS-6.
+
+There are images for `gcc`, `clang` and `mingw`. For every compiler there is one basic image with the compiler ready (`-dev-essentials`), one image with all dependencies for the OGS simulator (`-base`) and maybe an image for Data Explorer development (`-gui`).
+
+E.g. to start developing OGS:
+
+```bash
+docker pull ogs6/gcc-base
+docker run -t -i -v /path/to/ogs/source/on/host:/usr/src/ogs ogs6/gcc-base /bin/bash
+```
+
+You are now in the Docker container the ogs source code from your host computer mounted at `/usr/src/ogs`. Now you can build and run OGS:
+
+```bash
+mkdir build; cd build
+cmake ../ogs
+make ogs
+./bin/ogs
+```
+
diff --git a/web/content/docs/devguide/advanced/gitlab-login.png b/web/content/docs/devguide/advanced/gitlab-login.png
new file mode 100644
index 0000000000000000000000000000000000000000..43a7f67f052baf713e9c7a8861ab3d9c7d0b7886
--- /dev/null
+++ b/web/content/docs/devguide/advanced/gitlab-login.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5d47418ccb7ced67ccf3942491e486c5d234d0b034cab56ae5904f3a1e109221
+size 84946
diff --git a/web/content/docs/devguide/advanced/gitlab.pandoc b/web/content/docs/devguide/advanced/gitlab.pandoc
new file mode 100644
index 0000000000000000000000000000000000000000..35c7a325b6407d9629f65f7b7c4f9046eedd7909
--- /dev/null
+++ b/web/content/docs/devguide/advanced/gitlab.pandoc
@@ -0,0 +1,26 @@
++++
+date = "2018-02-26T11:00:13+01:00"
+title = "GitLab"
+author = "Lars Bilke"
+weight = 1038
+
+[menu]
+ [menu.devguide]
+ parent = "advanced"
++++
+
+## Introduction
+
+[GitLab](https://gitlab.com) is a web-based Git repository manager similar to [GitHub](https://github.com). GitLab can be self-hosted and we do just that with <https://gitlab.opengeosys.org>. For the moment all OGS repositories are still hosted at [github.com/ufz](https://github.com/ufz) but we store benchmark data files on our own GitLab because of storage limits on GitHub.
+
+To submit a PR containing also new benchmark files (or in general: containing files tracked by `git-lfs`) you need an account on our GitLab server.
+
+## Setup an account
+
+- Creating a GitLab account can be done by simply using your existing GitHub account: click the GitHub logo (octocat) on the [Gitlab sign-in page](https://gitlab.opengeosys.org/users/sign_in)
+ 
+ - You will be redirected to GitHub (please login there) and asked for authorization.
+ - Your new user account will be blocked at first, please let us know we will unblock it
+- Once unblocked, on the [ogs group page](https://gitlab.opengeosys.org/ogs) click the button `Request access`. We will then give access to the repo. If the button is not there we already gave you access.
+- Create a [GitLab personal access token](https://gitlab.opengeosys.org/profile/personal_access_tokens), enable the following scopes: `api`, `read_user`. This is the password you have to use when pushing a PR which also contains `git-lfs`-tracked files. Your user name is the same as your GitHub user name.
+- For caching credentials you may want to use a [git credential helper](https://docs.gitlab.com/ee/workflow/lfs/manage_large_binaries_with_git_lfs.html#credentials-are-always-required-when-pushing-an-object).
diff --git a/web/content/docs/devguide/advanced/log-and-debug-output.pandoc b/web/content/docs/devguide/advanced/log-and-debug-output.pandoc
new file mode 100644
index 0000000000000000000000000000000000000000..e69918e7c3cb6ddd5d3861c5378d0e1f76c10ca7
--- /dev/null
+++ b/web/content/docs/devguide/advanced/log-and-debug-output.pandoc
@@ -0,0 +1,33 @@
++++
+date = "2018-02-26T11:00:13+01:00"
+title = "Log and Debug Output"
+author = "Lars Bilke"
+weight = 1035
+
+[menu]
+ [menu.devguide]
+ parent = "advanced"
++++
+
+## Introduction
+
+For application output we use [Logog](http://johnwbyrd.github.com/logog) which is already integrated in OGS. Logog provides several verbosity levels which can be used with simple macro calls:
+
+```cpp
+ERR("An error message!")
+WARN("A warning message.")
+INFO("An information message...")
+```
+
+As arguments you can use the same functionality as in [sprintf](http://www.cplusplus.com/reference/cstdio/sprintf/):
+
+```cpp
+int foo = 9001;
+int maxfoo = 9000;
+if (foo > maxfoo)
+ WARN("Foo is over %d! Current value is %d.", maxfoo, foo );
+```
+
+For more information see the [Logog documentation](http://johnwbyrd.github.com/logog/quickstart.html).
+
+On release builds the log level is `LOGOG_LEVEL_INFO`, on debug it is `LOGOG_LEVEL_DEBUG` and it can be overriden with the CMake option `OGS_LOG_LEVEL`. You can completely disable logging with the CMake-option `OGS_DISABLE_LOGGING` set to `ON`.
diff --git a/web/content/docs/devguide/advanced/redistributable-builds.pandoc b/web/content/docs/devguide/advanced/redistributable-builds.pandoc
new file mode 100644
index 0000000000000000000000000000000000000000..cc0eff6ced5b0c3eb9d0f34eabb4e99adc7d0ca3
--- /dev/null
+++ b/web/content/docs/devguide/advanced/redistributable-builds.pandoc
@@ -0,0 +1,67 @@
++++
+date = "2018-02-26T11:00:13+01:00"
+title = "Redistributable builds"
+author = "Lars Bilke"
+weight = 1037
+
+[menu]
+ [menu.devguide]
+ parent = "advanced"
++++
+
+## Introduction
+
+If a binary runs on a different machine depends on a lot of factors. The following sections provide some tips to maximize portability. In general Windows binaries are more portable than *nix binaries.
+
+## CPU Architecture Optimization
+
+::: {.win}
+### Default compiler flags
+
+- `/favor:blend`: Optimizes for AMD **and** Intel architectures, see [MSDN docs](https://msdn.microsoft.com/en-us/library/ms173505.aspx)
+- `/arch:sse2` on [32-bit](https://msdn.microsoft.com/en-us//library/7t5yh4fd.aspx), `/arch` undefined on [64-bit](https://msdn.microsoft.com/en-us/library/jj620901.aspx)
+
+### Optimization CMake options
+
+- `OGS_CPU_ARCHITECTURE`: possible values `AMD64` or `INTEL64` (sets `/favor:{AMD64 | INTEL64}` flag)
+- `OGS_ENABLE_AVX2`: boolean (sets `/arch:AVX2` when set to true), requires at least [Intel Haswell or AMD Excavator-based processors](https://msdn.microsoft.com/en-us//library/7t5yh4fd.aspx)
+:::
+
+::: {.linux}
+### Default compiler flags
+
+- `-march=native`: Optimizes for current cpu
+
+### CMake options
+
+#### For redistribution
+
+- `OGS_CPU_ARCHITECTURE`: set to `generic` for good balance between optimization and portability; set to `core2` for maximum portability, more info on [gcc docs](https://gcc.gnu.org/onlinedocs/gcc/x86-Options.html#index-mtune-15)
+
+#### For optimization
+
+- `OGS_CPU_ARCHITECTURE`: tot to `native` for best optimization for your current cpu, possible values are [listed here](http:/bilityoverflow.com/a/25095818/80480), more info on [gcc docs](https://gcc.gnu.org/onlinedocs/gcc/x86-Options.html#index-mtune-15)
+- `OGS_ENABLE_AVX2`: boolean (sets `-march=core-avx2` when set to true), requires at least Haswell processors
+:::
+
+::: {.mac}
+See Linux-tab!
+:::
+
+
+## Shared vs. static libraries
+
+Try to use static libraries as much as possible. For OGS itself use `BUILD_SHARED_LIBS=OFF`, which already defaults to `OFF`.
+
+Third-party libraries installed via the systems package package manager are often provided as shared libraries. You may want to use [Conan]({entry:674:url}) which provides lots of libraries (e.g. VTK) as static libs.
+
+## Package the build
+
+Use the `package`-target which tries to gather all dependencies and fixes up shared library paths:
+
+```bash
+make package
+```
+
+This creates a zip- or tar-archive which should be redistributable.
+
diff --git a/web/content/docs/devguide/advanced/third-party-libraries.pandoc b/web/content/docs/devguide/advanced/third-party-libraries.pandoc
new file mode 100644
index 0000000000000000000000000000000000000000..5726f8cbcdd422046faaa32e9cb429f419db2920
--- /dev/null
+++ b/web/content/docs/devguide/advanced/third-party-libraries.pandoc
@@ -0,0 +1,32 @@
+---
+date: "2018-02-26T11:00:13+01:00"
+title: "Third-party libraries"
+author: "Lars Bilke"
+weight: 1049
+
+menu:
+ devguide:
+ parent: advanced
+---
+
+::: {.note}
+### <i class="fas fa-exclamation-triangle"></i> Attention!
+
+We strongly recommend to simply use [Conan]({{< relref "conan.pandoc" >}}) for handling required third-party libraries.
+:::
+
+## Introduction
+
+The following libraries are required:
+
+- [Boost](http://www.boost.org/) >= 1.56.0
+- [Eigen](http://eigen.tuxfamily.org/) >= 3.2.9
+- [VTK](https://www.vtk.org/) >= 7.1.0
+
+If you want to build the Data Explorer you need these too:
+
+- [Qt](https://www.qt.io/) >= 5.9.2
+- [Shapelib](http://shapelib.maptools.org) >= 1.3.0
+- [libgeotiff](https://trac.osgeo.org/geotiff/) >= 1.4.2
+
+Please refer to the library documentation on how to build. If you struggle consider using [Conan]({{< relref "conan.pandoc" >}})! Once built CMake tries its best to find the libraries.
diff --git a/web/content/docs/devguide/advanced/using-ccache.pandoc b/web/content/docs/devguide/advanced/using-ccache.pandoc
new file mode 100644
index 0000000000000000000000000000000000000000..459978a201dd8be7ac31fd03d92a676f1bc8c199
--- /dev/null
+++ b/web/content/docs/devguide/advanced/using-ccache.pandoc
@@ -0,0 +1,42 @@
++++
+date = "2018-02-26T11:00:13+01:00"
+title = "Using ccache"
+author = "Lars Bilke"
+weight = 1036
+
+[menu]
+ [menu.devguide]
+ parent = "advanced"
++++
+
+::: {.note}
+### <i class="fas fa-exclamation-triangle"></i> GCC-like compilers only
+
+Tested on GCC and Clang.
+:::
+
+## Introduction
+
+[ccache](https://ccache.samba.org) speeds up compilation times by caching object files and reusing them on subsequent builds. This even works for complete rebuilds (i.e. deleting the full build-directory). If ccache is found on the system it is automatically used.
+
+## Configuration
+
+Add the following line to your [ccache config file](https://ccache.samba.org/manual.html#_configuration) which is required for pre-compiled headers:
+
+```
+sloppiness = pch_defines,time_macros
+```
+
+See the [ccache docs](https://ccache.samba.org/manual.html#_configuration_settings) for other available options.
+
+### ccache and Clang
+
+Set the option `run_second_cpp = true` or `export CCACHE_CPP2=true` to suppress lots of [false positive compiler warnings](http://peter.eisentraut.org/blog/2014/12/01/ccache-and-clang-part-3/).
+
+## Usage on envinf1
+
+Just load the module:
+
+```
+module load /global/apps/modulefiles/ccache/3.3.3
+```
diff --git a/web/content/docs/devguide/advanced/working-on-envinf1.pandoc b/web/content/docs/devguide/advanced/working-on-envinf1.pandoc
new file mode 100644
index 0000000000000000000000000000000000000000..73c74947ff339c4cb6da5644cc6660ef6056fdbb
--- /dev/null
+++ b/web/content/docs/devguide/advanced/working-on-envinf1.pandoc
@@ -0,0 +1,76 @@
++++
+date = "2018-02-26T11:00:13+01:00"
+title = "Working on envinf1"
+author = "Lars Bilke"
+weight = 1036
+
+[menu]
+ [menu.devguide]
+ parent = "advanced"
++++
+
+## Introduction
+
+Members of the Department Environmental Informatics of the Helmholtz Centre for Environmental Research - UFZ can use the `envinf1`-machine which is tightly connected to the Eve cluster system.
+
+## Build OGS-6
+
+Load required modules by sourcing the environment script:
+
+```bash
+$ source scripts/env/envinf1/cli.sh
+```
+
+Then do the [build configuration]({{< relref "build-configuration.pandoc" >}}) and [build]({{< relref "build.pandoc" >}}) the project.
+
+## Build the Data Explorer
+
+Load required modules by sourcing the environment script:
+
+```bash
+$ source scripts/env/envinf1/gui.sh
+```
+
+Then do the [build configuration]({{< relref "build-configuration.pandoc" >}}) and [build]({{< relref "build.pandoc" >}}) the project.
+
+## Install and use Conan
+
+Follow the instructions on using Python's `virtualenv` [on the Eve-wiki](https://wiki.ufz.de/eve/index.php/Python#virtualenv) for setting up a local Python environment. Then you can `pip install conan` and use Conan.
+
+## Additional Features
+
+[Doxygen]({entry:devguide/generating-documentation:url}) documentation:
+
+```bash
+$ module load doxygen/1.8.7-1_gcc_4.8.1_CentOS6
+```
+
+You can {entry:devguide/build-with-ninja:link}:
+
+```bash
+$ module load ninja/1.4.0-1_gcc_4.8.1_CentOS6
+```
+
+## Build OGS-5
+
+```bash
+$ module load cmake/2.8.12.2-1_gcc_4.8.1_CentOS6
+$ module load gcc/4.8.1-3_CentOS6
+```
+
+## Use ParaView
+
+On `envinf1` start ParaView-server with e.g. 4 cores:
+
+```bash
+module load paraview/5.0.0-egl
+mpirun -np 4 pvserver
+```
+
+This starts the server on port 11111. If another user has already started the server you need to start your server on another port with e.g.:
+
+```bash
+mpirun -np 4 pvserver --server-port=11112
+```
+
+On your local PC start ParaView (you have to use the same version, 5.0.0 in this case). And connect to the server on `envinf1.eve.ufz.de:11111` (or specify another port here).
diff --git a/web/content/docs/devguide/development-workflows/GH_CI_screenshot.png b/web/content/docs/devguide/development-workflows/GH_CI_screenshot.png
new file mode 100644
index 0000000000000000000000000000000000000000..4d8d80a37d2fe8bc9367ee5f1e92ef3df2d67e14
--- /dev/null
+++ b/web/content/docs/devguide/development-workflows/GH_CI_screenshot.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0edff6eab4a8a474709ba352a10aad3aa0c08d5e1edac775eb46a781f3699602
+size 84598
diff --git a/web/content/docs/devguide/development-workflows/branching-model.pandoc b/web/content/docs/devguide/development-workflows/branching-model.pandoc
new file mode 100644
index 0000000000000000000000000000000000000000..02dac918a305a093d047361b115efdce10c49b23
--- /dev/null
+++ b/web/content/docs/devguide/development-workflows/branching-model.pandoc
@@ -0,0 +1,36 @@
++++
+date = "2018-02-23T15:28:13+01:00"
+title = "Branching model"
+author = "Lars Bilke"
+weight = 1011
+
+[menu]
+ [menu.devguide]
+ parent = "development-workflows"
++++
+
+## Forking workflow
+
+Git is very flexible in organizing a distributed development team. We use a so called **Forking workflow**.
+
+The following explanation is taken from an [in-depth article](https://www.atlassian.com/git/workflows#!workflow-forking) on that model:
+
+> Instead of using a single server-side repository to act as the *central* codebase, it gives every developer a server-side repository. This means that each contributor has not one, but two Git repositories: a private local one and a public server-side one.
+>
+> The main advantage of the Forking Workflow is that contributions can be integrated without the need for everybody to push to a single central repository. Developers push to their own server-side repositories, and only the project maintainer can push to the official repository. This allows the maintainer to accept commits from any developer without giving them write access to the official codebase.
+>
+> The result is a distributed workflow that provides a flexible way for large, organic teams (including untrusted third-parties) to collaborate securely. This also makes it an ideal workflow for open source projects.
+> <cite> https://www.atlassian.com/git/workflows#!workflow-forking </cite>
+>
+
+The workflow is summarized in the following image from the [GitHub blog](https://github.com/blog/2042-git-2-5-including-multiple-worktrees-and-triangular-workflows):
+
+
+
+You always **fetch** changes from official repository (called **upstream**), develop on your **local** repository and **push** changes to your server-side repository (called **origin**).
+
+First thing to do when you start working on your local repository is to create a topic branch (based on the current master branch of the official repository) specific to a well defined feature or bugfix you are about to implement. **Never** work on the **master**-branch (it is reserved for the official version)! See also [this tutorial](https://www.atlassian.com/git/tutorial/git-branches#!overview) on branching.
+
+Start committing changes in logical chunks. After you are happy with your implementation push your topic branch to your forked repository on GitHub.
+
+Open a *Pull Request* which will initiate the code review process.
diff --git a/web/content/docs/devguide/development-workflows/clion.png b/web/content/docs/devguide/development-workflows/clion.png
new file mode 100644
index 0000000000000000000000000000000000000000..95ba710747d2337f38ec325b9437aece951ee4bd
--- /dev/null
+++ b/web/content/docs/devguide/development-workflows/clion.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:26f3e038c06a3ff0e5a92588db1178d834e09aaa692da96da20bc7cf97aa685d
+size 547125
diff --git a/web/content/docs/devguide/development-workflows/code-reviews.pandoc b/web/content/docs/devguide/development-workflows/code-reviews.pandoc
new file mode 100644
index 0000000000000000000000000000000000000000..6dddcdac59e55ceb5ea9e5d99bd5861056b2e8bc
--- /dev/null
+++ b/web/content/docs/devguide/development-workflows/code-reviews.pandoc
@@ -0,0 +1,12 @@
++++
+date = "2018-02-26T11:00:13+01:00"
+title = "Code Reviews"
+author = "Lars Bilke"
+weight = 1012
+
+[menu]
+ [menu.devguide]
+ parent = "development-workflows"
++++
+
+TODO!
diff --git a/web/content/docs/devguide/development-workflows/codeblocks.png b/web/content/docs/devguide/development-workflows/codeblocks.png
new file mode 100644
index 0000000000000000000000000000000000000000..32acc3c683827e745d22cd28f9a27cf22af66822
--- /dev/null
+++ b/web/content/docs/devguide/development-workflows/codeblocks.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f7c6a0da37838c8a1e3054805026c3c93b75a758d5bc38fa9126a3d7ca11902f
+size 281656
diff --git a/web/content/docs/devguide/development-workflows/continuous-integration.pandoc b/web/content/docs/devguide/development-workflows/continuous-integration.pandoc
new file mode 100644
index 0000000000000000000000000000000000000000..4884b8780e1978405339a25b2c82f2ce13f095e5
--- /dev/null
+++ b/web/content/docs/devguide/development-workflows/continuous-integration.pandoc
@@ -0,0 +1,35 @@
++++
+date = "2018-02-26T11:00:13+01:00"
+title = "Continuous Integration"
+author = "Lars Bilke"
+weight = 1013
+
+[menu]
+ [menu.devguide]
+ parent = "development-workflows"
++++
+
+## Introduction
+
+> [Continuous Integration](https://en.wikipedia.org/wiki/Continuous_integration) (short **CI**) is the practice of merging all developer working copies to a shared mainline several times a day.
+
+So for every proposed change to the source code the following is done automatically:
+
+- Compilation of the changed code merged with the official source code is tested on a variety of platforms (Windows, Linux, Mac OS, different compilers)
+- A comprehensive [test suite]({{< relref "unit-testing.pandoc" >}}) checks validity of the proposed changes
+- Additional checks regarding code formatting and documentation help in maintaining a good software quality and structure
+
+After the system is done with all these tasks the developer can view build reports highlighting occurred errors and problems. We are using [Jenkins]({{< relref "jenkins.pandoc" >}}) as our CI system.
+
+## CI on OGS
+
+All of this automatically kicks in when you open a [Pull Request](../code-reviews) on GitHub. You will notice a checks block at the end of the pull request page:
+
+
+
+Click on the *Details* link to find out the reason for a failed check. If you add more commits to this pull request all checks are run again.
+
+# Enable CI on your fork
+
+You can have the CI system testing all your branches in your fork of OGS even before creating a pull request. See the page on [Jenkins]({{< relref "jenkins.pandoc#automatic-testing-for-own-repository" >}}) for further information.
+
diff --git a/web/content/docs/devguide/development-workflows/development-ides.pandoc b/web/content/docs/devguide/development-workflows/development-ides.pandoc
new file mode 100644
index 0000000000000000000000000000000000000000..0203b4bc236c83b967aabef1420af0cb3105f22e
--- /dev/null
+++ b/web/content/docs/devguide/development-workflows/development-ides.pandoc
@@ -0,0 +1,172 @@
++++
+date = "2018-02-26T11:00:13+01:00"
+title = "Development IDEs"
+author = "Marc Walther"
+weight = 1014
+
+[menu]
+ [menu.devguide]
+ parent = "development-workflows"
++++
+
+## Overview
+
+Here is a small compilation about **debugging tools** and how to **set them up** to start **developing** OGS. There are several development IDE's available, both open-source or commercial. Some are multi-platform, others are platform-specific.
+
+Here is a **link list** without specific order:
+
+- [Eclipse](http://www.eclipse.org/)
+- [Code::Blocks](http://www.codeblocks.org/)
+- [Netbeans](https://netbeans.org/)
+- [GDB](https://www.sourceware.org/gdb/)
+- [CLion](https://www.jetbrains.com/clion/)
+
+The steps to get things started with an IDE basically include **generating** the project files, **importing** them in the IDE and know where to **provide arguments** to the debugging binary.
+
+I will assume, that you have the sources (eg. checked out from github) and that they lie in the **source directory**
+```bash
+/home/user/ogs6/sources
+```
+Please, create a seperate **build directory** for your favorite IDE like
+```bash
+/home/user/ogs6/build_gdb
+```
+
+__________
+
+
+## GDB
+
+<https://www.sourceware.org/gdb/download>
+
+### Screenshot
+
+
+
+### Create project files
+
+1. CD to the build directory
+2. Generate project files with CMake:
+```bash
+cmake ../sources/
+```
+3. Start gdb in graphical mode, without license info (quiet) and with arguments:
+```bash
+gdb -tui -q --args ./bin/ogs ./path/to/BenchmarkName.prj
+```
+4. Have fun...
+
+Documentation: <https://sourceware.org/gdb/onlinedocs/gdb/index.html>
+
+__________
+
+## Eclipse
+
+<http://www.eclipse.org/downloads>
+
+Choose "Eclipse IDE for C/C++ Developers"
+
+### Screenshot
+
+
+
+### Import Code
+
+1. CD to the build directory
+2. Generate project files with CMake:
+```bash
+cmake -G "Eclipse CDT4 - Unix Makefiles" ../sources/
+```
+3. Open Eclipse and choose *File - Import - Existing Project into Workspace*
+4. Select the **build directory** and click Finish (***Attention:*** Make sure to **not** check the option *Copy projects into workspace*!)
+5. To provide arguments, you will have to run the project once: *Run - Debug* (running will start building first, if not already done).
+6. Then, give arguments via *Run - Debug Configuration - C/C++ Application - ogs*. Choose *Arguments* tab on right side and add your arguments to the line *C/C++ Application*, e.g.
+```bash
+./path/to/BenchmarkName.prj
+```
+7. Start debugging...
+
+Documentation: <http://wiki.eclipse.org/Main_Page>
+
+__________
+
+## Code::Blocks
+
+<http://www.codeblocks.org/downloads>
+or
+<https://code.google.com/p/fortranproject>
+
+The latter includes already plugins for Fortran, in case you want to cross-compile.
+
+### Screenshot
+
+
+
+### Import Code
+
+1. CD to the build directory
+2. Generate project files with CMake:
+```bash
+cmake -G "CodeBlocks - Unix Makefiles" ../sources/
+```
+3. *Open an existing project* and choose before created .cbp file
+4. Choose your compilation target
+5. Give arguments: *Project - Set Programs' Arguments*, select correct target and add *Program arguments* in the bottom
+```bash
+./path/to/BenchmarkName.prj
+```
+6. Rock the show...
+
+### Documentation:
+
+- <http://www.codeblocks.org/user-manual>
+- <http://wiki.codeblocks.org/index.php?title=Main_Page>
+
+__________
+
+## NetBeans
+
+<https://netbeans.org/downloads>
+
+### Screenshot
+
+
+
+### Import project files
+
+1. Open NetBeans
+2. Choose *File - New Project - C/C++ Project with Existing Sources* (Click *Next >*)
+3. Specify sources directory, select configuration mode *Custom*
+4. Check *Run Configure Script in Subfolder*
+5. Click *Next >* until *Finish*
+6. Give arguments via *Run - Set Project Configuration - Customize*
+7. Under *Run*, give *Run Command* on right side:
+```bash
+"${OUTPUT_PATH}" ./path/to/BenchmarkName.prj
+```
+7. When starting debugging, choose correct target
+8. Have a great time...
+
+Documentation: <https://netbeans.org/kb/index.html>
+
+__________
+
+## CLion
+
+Download: <https://www.jetbrains.com/clion/>
+
+### Screenshot
+
+
+
+### Import project
+
+You don't need a build-directory for CLion. It will create it by itself.
+
+1. *File / Import Project*
+2. Choose source-directory
+3. When prompted do not overwrite CMake file, instead choose *Open Project*
+4. Under *Run / Edit Configurations* choose the ogs-target and set the program working directory and arguments
+5. On the top right choose the ogs-target and click the green Debug-button
+
+Documentation: <https://www.jetbrains.com/clion/help/introduction.html>
diff --git a/web/content/docs/devguide/development-workflows/eclipse.png b/web/content/docs/devguide/development-workflows/eclipse.png
new file mode 100644
index 0000000000000000000000000000000000000000..ef052ec47b430597faa16985588d22e836426a1c
--- /dev/null
+++ b/web/content/docs/devguide/development-workflows/eclipse.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:55c976c796829e6aac8432f476ec594aa895da145effdd30776d2e8ff08eae1a
+size 323836
diff --git a/web/content/docs/devguide/development-workflows/gdb.png b/web/content/docs/devguide/development-workflows/gdb.png
new file mode 100644
index 0000000000000000000000000000000000000000..69e6c2128084f6113877f1f4bbb2485a38df5269
--- /dev/null
+++ b/web/content/docs/devguide/development-workflows/gdb.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:88a200fa2d3352884d090072b310b859ed230303b1504ebe7f81ad0c5a919607
+size 105090
diff --git a/web/content/docs/devguide/development-workflows/netbeans.png b/web/content/docs/devguide/development-workflows/netbeans.png
new file mode 100644
index 0000000000000000000000000000000000000000..d96defbc23e84da29dde1fe3b88fbf5c0afc7e86
--- /dev/null
+++ b/web/content/docs/devguide/development-workflows/netbeans.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:68167ce668588d5fbda86a87fd05f9c1f415439b9681d8c605aebb0652de2134
+size 185539
diff --git a/web/content/docs/devguide/getting-started/build-configuration.pandoc b/web/content/docs/devguide/getting-started/build-configuration.pandoc
new file mode 100644
index 0000000000000000000000000000000000000000..2be77d4b3ea7dc9ddc82aee2b231c45e48d6ef99
--- /dev/null
+++ b/web/content/docs/devguide/getting-started/build-configuration.pandoc
@@ -0,0 +1,106 @@
++++
+date = "2018-02-23T15:28:13+01:00"
+title = "Build configuration"
+author = "Lars Bilke"
+weight = 1004
+
+[menu]
+ [menu.devguide]
+ parent = "getting-started"
++++
+
+## Overview
+
+To separate source code from generated files such as compiled libraries, executables, test outputs and IDE projects we create build-directories. They can be placed arbitrarily but should **not** be placed inside the source code. You can have as many build-directories as you like for e.g. different configurations but they will all use one source code directory. A typically directory structure:
+
+- `ogs-source-code` (or simply `ogs`)
+- `build-release`
+- `build-debug`
+- `build-release-mpi`
+
+So just go ahead and create a build-directory along your source code directory.
+
+
+## Install required libraries with Conan
+
+It is preferred to use Conan package manager to install required third-party libraries. To use Conan add the CMake option `OGS_USE_CONAN=ON` to the CMake run (see below). This will run Conan automatically downloading either prebuilt binaries of required libraries or building them locally if a binary for your setup (operating system, compiler, ..) is not available. [Check this]({entry:674:url}) for advanced Conan usage.
+
+*Note:* Instead of using Conan you can optionally [install the required libraries manually]({entry:81:url}).
+
+::: {.win}
+Add `-DOGS_USE_CONAN=ON` to the CMake-run (see below).
+
+::: {.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:
+
+```bash
+$ [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" -DOGS_USE_CONAN=ON -DCMAKE_BUILD_TYPE=Debug
+$ cd .. && mkdir release && cd release
+$ cmake ../../ogs -G "Visual Studio 14 2015 Win64" -DOGS_USE_CONAN=ON -DCMAKE_BUILD_TYPE=Release
+```
+
+`..\..\ogs` represents the relative path to the source code (please adapt if you have a different directory layout).
+
+Please also note that in Visual Studio you have to choose the correct configuration (i.e. when opening the solution-file in the release-folder you have to switch the Visual Studio configuration to **Release**)!
+:::
+:::
+
+::: {.linux}
+Add `-DOGS_USE_CONAN=ON` to the CMake-run (see below).
+:::
+
+::: {.mac}
+Add `-DOGS_USE_CONAN=ON` to the CMake-run (see below).
+:::
+
+
+## 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.
+
+For a list of available options see the {entry:devguide/configuration-options:link}.
+
+## 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:
+
+```bash
+$ cmake -G "Visual Studio 14 2015 Win64" -DCMAKE_BUILD_TYPE=Release ../ogs
+```
+
+CMake tries to autodetect your compiler so in most cases this should be enough:
+
+```bash
+$ 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.
+:::
+
+::: {.linux}
+A more convenient way of running cmake on the command line is to use the `ccmake` tool. This is a shell tool but with some graphical user interface. To use it just run `ccmake` inside your build directory with the path to the source code (and optionally the generator you want to use) as parameter:
+
+```bash
+$ ccmake ../ogs
+```
+
+First press <kbd>C</kbd> to **Configure**. You are now presented the available configuration options. You can navigate in the list with the cursor keys and toggle / alter options with <kbd>Enter</kbd>. You may also press <kbd>T</kbd> to toggle (previously hidden) advanced options. Press <kbd>C</kbd> again until the **Generate**-option becomes visible. Press <kbd>G</kbd> to generate the project files and exit `ccmake`.
+
+There is also the tool `cmake-gui` available, please see the Win-Tab for a description.
+:::
+
+::: {.mac}
+Please see the Linux instructions!
+:::
diff --git a/web/content/docs/devguide/getting-started/build.pandoc b/web/content/docs/devguide/getting-started/build.pandoc
new file mode 100644
index 0000000000000000000000000000000000000000..74b3ce4e06eff259ad4e7dd277c225ade2c0a3b5
--- /dev/null
+++ b/web/content/docs/devguide/getting-started/build.pandoc
@@ -0,0 +1,112 @@
++++
+date = "2018-02-23T15:28:13+01:00"
+title = "Build"
+author = "Lars Bilke"
+weight = 1005
+
+[menu]
+ [menu.devguide]
+ parent = "getting-started"
++++
+
+## Build the project
+
+::: {.win}
+# Step: Build with Visual Studio
+
+Open the OGS.sln either by double-clicking it in the file browser or opening in Visual Studio via **File / Open / Project**.
+
+On the project explorer right-click on **ogs** or **ogs-gui** and choose **Set as startup project**. Then press <kbd>F5</kbd> or click the green arrow to build and start the project.
+
+## About Visual Studio startup projects
+
+The reason for this is that you can have only one sub-project of your Visual Studio Solution activated for debugging (e.g. by pressing <kbd>F5</kbd>). Per default this is the first sub-project (in the case of a CMake-generated project this is `ALL_BUILD`). This must be manually set to a sub-project which generates an executable (a library sub-project cannot be started). And because this setting is stored in user specific project file it cannot be set via CMake.
+
+# How to work with CMake and Visual Studio
+
+You can work normally in Visual Studio but remember that you have to make project changes in the `CMakeLists.txt`-file and not inside Visual Studio. So you can add a new source file within Visual Studios File menu but you have to add that file also to the CMake file. Every time you change a `CMakeLists.txt` and you build the project a new CMake run is automatically invoked. After that Visual Studio informs you that the project files were changed and it reloads them.
+:::
+
+::: {.linux}
+# Option: Make
+
+To build with the `make` tool on the shell go to your previously created build directory and type `make`:
+
+```bash
+$ cd build
+$ make
+```
+
+To speedup the compilation process append the number of cores of your cpu to the make command. E.g. for 8 cores:
+
+```bash
+$ make -j 8
+```
+
+# Option: Eclipse
+
+To let CMake generate the Eclipse project files change the generator argument to the CMake run:
+
+```bash
+$ cmake [your configuration options] -G"Eclipse CDT4 - Unix Makefiles" ../sources
+```
+
+Or with ccmake
+
+```bash
+$ ccmake -G"Eclipse CDT4 - Unix Makefiles" ../sources
+```
+
+Start the Eclipse ide. From the menu choose **File / Import**. In the import dialog choose **General / Existing projects into workspace** and click **Next**. In **Select root directory** select your build directory and make sure that **Copy project into workspace** is unchecked. Click **Finish**.
+:::
+
+::: {.mac}
+# Option: Make
+
+To build with the `make` tool on the shell go to your previously created build directory and type `make`:
+
+```bash
+$ cd build
+$ make
+```
+
+To speedup the compilation process append the number of cores of your cpu to the make command. E.g. for 8 cores:
+
+```bash
+$ make -j 8
+```
+
+# Option: Xcode
+
+To let CMake generate the Xcode project files change the generator argument on the CMake run:
+
+```bash
+$ cmake [your configuration options] -G Xcode ../sources
+```
+
+Or with ccmake
+
+```bash
+$ ccmake -G Xcode ../sources
+```
+
+Then load the generated project file by either clicking the **OGS.xcodeproj** or via
+
+```bash
+$ open OGS.xcodeproj
+```
+
+In Xcode choose `ogs` or `ogs-gui` from the drop-down menu on the top right and then hit the Run-button.
+:::
+
+
+## Waiting
+
+So now the build process is running... This can take some time because maybe there are external libraries which get automatically downloaded and compiled. This step is only done once per build directory, so subsequent builds will be much faster. See {entry:devguide/third-party-libraries:link} for more.
+
+
+## Finished!
+
+Congratulations you have finished the **Getting Started**-section!
+
+Have a look at the other sections of this guide. Maybe check out {entry:devguide/development-workflows:link} if you are interested in actively contributing to the project. The {entry:devguide/configuration-options:link}-page shows you all available build customizations. Or do you want to build the {entry:devguide/data-explorer:link}? Go ahead!
diff --git a/web/content/docs/devguide/getting-started/get-the-source-code.pandoc b/web/content/docs/devguide/getting-started/get-the-source-code.pandoc
new file mode 100644
index 0000000000000000000000000000000000000000..5d84accf76f8ed23c719056cd81bcd8ffb4173ab
--- /dev/null
+++ b/web/content/docs/devguide/getting-started/get-the-source-code.pandoc
@@ -0,0 +1,85 @@
++++
+date = "2018-02-23T15:28:13+01:00"
+title = "Get the source code"
+author = "Lars Bilke"
+weight = 1003
+
+[menu]
+ [menu.devguide]
+ parent = "getting-started"
++++
+
+::: {.note}
+### Attribution
+
+The content of this page is largely taken from the [GitHub-blog](https://github.com/blog/2042-git-2-5-including-multiple-worktrees-and-triangular-workflows).
+:::
+
+
+## Create a fork
+
+Go to the [official OGS-6 repository](https://github.com/ufz/ogs) and click the "Fork"-button. This creates a new fork under your account with the URL `https://github.com/YOUR-USERNAME/ogs`.
+
+
+## Setup your local clone
+
+You can use the git command line tool to clone the remote repository on GitHub to your PC:
+
+```bash
+$ git clone https://github.com/YOUR-USERNAME/ogs
+$ cd ogs
+$ git config remote.pushdefault origin
+$ git config push.default current
+```
+
+**Note:** We use `git lfs clone` instead of the regular `git clone` to significantly speed up the cloning of the repo and its test data files. See [this for more information](https://github.com/ufz/ogs/pull/1978).
+
+This creates a new folder `ogs` in your current working directory with the OGS source code. After this step, the remote called `origin` refers to your fork on GitHub. It also sets the default remote for pushes to be `origin` and the default push behavior to `current`. Together this means that if you just type `git push`, the current branch is pushed to the `origin` remote (git version >= 2.5 required).
+
+Create a second remote called `upstream` that points at the main OGS repository and fetch from it:
+
+```bash
+$ git remote add upstream https://github.com/ufz/ogs
+$ git [lfs] fetch upstream # The lfs-equivalent of the fetch command is more efficient
+```
+
+
+## Optional: Working on a new feature
+
+You only have to follow the above steps once. From then on, whenever you want to work on a new feature, you can more easily interact with the remote repositories.
+
+Make sure that your local repository is up-to-date with the upstream repository:
+
+```bash
+$ git fetch upstream
+```
+
+Create a branch `feature-name` off of upstream `master`-branch to work on a new feature, and check out the branch:
+
+```bash
+git checkout -b feature-name upstream/master
+```
+
+This automatically sets up your local `new-feature`-branch to track the upstream `master`-branch. This means that if more commits are added to `master` upstream, you can merge those commits into your `feature`-branch by typing
+
+```bash
+$ git pull
+```
+
+or rebase your branch on top of the new master by typing
+
+```bash
+$ git pull --rebase
+```
+
+Now after you implemented the feature and committed your work you can push the new commits to the `feature-name`-branch on your GitHub fork:
+
+```bash
+$ git push
+```
+
+If your work is done submit a pull request.
+
+This workflow is summarized with this picture:
+
+
diff --git a/web/content/docs/devguide/getting-started/prerequisites.md b/web/content/docs/devguide/getting-started/prerequisites.md
deleted file mode 100644
index ee4eca4ae4155351691818e4e1b0ce7844e6dff9..0000000000000000000000000000000000000000
--- a/web/content/docs/devguide/getting-started/prerequisites.md
+++ /dev/null
@@ -1,57 +0,0 @@
-+++
-date = "2017-01-14T22:56:13+01:00"
-title = "Set Up Prerequisites"
-author = "Lars Bilke"
-weight = 1002
-
-[menu]
- [menu.devguide]
- parent = "getting-started"
-+++
-
-## Minimum requirements
-
-The minimum prerequisites to build OGS are:
-
-- Git (version control tool, at least version 1.7.x)
-- CMake (build configuration tool, at least version 3.1)
-- A compiler with C++11-support
-- Conan package manager (TODO crossref) OR required libraries (TODO crossref)
-
-## Step: Install a compiler
-
-### Windows
-
-Because the C++11-standard is supported since **Visual C++ 2013** you will need at least **Windows 7** (64-bit recommended). It is perfectly fine to use the free Community Editions of Visual C++. We support the **2013 edition** and newer.
-
-Download Visual Studio and install it:
-
-- [Visual Studio Community 2015](https://go.microsoft.com/fwlink/?LinkId=532606&clcid=0x409)
-
-### Linux
-
-If you have a recent linux distribution you should also have a recent gcc. Please check that you have at least **gcc 4.9**:
-
-{{< highlight bash >}}
-$ gcc --version
-gcc (GCC) 4.6.1
-{{< /highlight >}}
-
-### Mac
-
-Please install Xcode from the App Store. Then please run the following command in the terminal to install the command line tools:
-
-{{< highlight bash >}}
-$ xcode-select --install
-{{< /highlight >}}
-
-Open Xcode one time to install some other Xcode stuff.
-
-Now also install the Homebrew package manager:
-
-{{< highlight bash >}}
-$ ruby -e "$(curl -fsSL https://raw.github.com/mxcl/homebrew/go/install)"
-$ brew doctor
-{{< /highlight >}}
-
-The Homebrew package manager is needed for installing other libraries and packages. It is just like a linux package manager.
diff --git a/web/content/docs/devguide/getting-started/prerequisites.pandoc b/web/content/docs/devguide/getting-started/prerequisites.pandoc
new file mode 100644
index 0000000000000000000000000000000000000000..edf9734fb35c998517c3fcb87e0524fc9f7afd14
--- /dev/null
+++ b/web/content/docs/devguide/getting-started/prerequisites.pandoc
@@ -0,0 +1,241 @@
++++
+date = "2017-01-14T22:56:13+01:00"
+title = "Set Up Prerequisites"
+author = "Lars Bilke"
+weight = 1002
+
+[menu]
+ [menu.devguide]
+ parent = "getting-started"
++++
+
+## Minimum requirements
+
+The minimum prerequisites to build OGS are:
+
+- An 64-bit operating system (Linux, Windows 7 and up, macOS)
+- Git (version control tool, at least version 1.7.x)
+- CMake (build configuration tool, at least version 3.1)
+- A compiler with [C++11](http://en.wikipedia.org/wiki/C%2B%2B11)-support
+- [Conan package manager](https://www.conan.io/) **OR** install [required libraries]({{< relref "third-party-libraries.pandoc" >}}) manually (for advanced users only!)
+
+## Step: Install a compiler
+
+::: {.win}
+As we use lots of features of the C++11-standard we support **Visual Studio 2015** and up. Therefore you will need at least **Windows 7** (64-bit recommended). It is perfectly fine to use the free Community Edition of Visual Studio.
+
+- Download and install [Visual Studio Community 2017](https://www.visualstudio.com/de/thank-you-downloading-visual-studio/?sku=Community&rel=15)
+ - Select the *workload* `Desktop Development with C++`
+ - You can uncheck everything else
+- When installation finished please start Visual Studio once (when asked for credentials enter your Microsoft account or click on **Skip for now**)
+:::
+
+::: {.linux}
+If you have a recent linux distribution you should also have a recent gcc. Please check that you have at least **gcc 4.9**:
+
+```bash
+$ gcc --version
+gcc (GCC) 4.9.1
+```
+:::
+
+::: {.mac}
+Please install Xcode from the App Store. Then please run the following command in the terminal to install the command line tools:
+
+```bash
+$ xcode-select --install
+```
+
+Open Xcode one time to install some other Xcode stuff.
+
+Now also install the [Homebrew](http://brew.sh) package manager:
+
+```bash
+$ /usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
+$ brew doctor
+```
+
+The Homebrew package manager is needed for installing other libraries and packages. It is just like a linux package manager.
+:::
+
+## Step: Install Git
+
+Git is a powerful and distributed version control system. OGS source code is hosted on [GitHub](https://github.com/ufz/ogs). See the developer guide page on {entry:devguide/github:link} for more info on how OGS uses GitHub for collaborative development.
+
+::: {.win}
+Download and install git from the [git homepage](http://git-scm.com/download/win). The default installer options are fine. This install a new command line called *Git Bash* which should be used for all git operations.
+
+Let Git know who you are:
+
+```bash
+$ git config --global user.name "Your Name Here"
+$ git config --global user.email "your_email@example.com"
+```
+
+In some corporate environments you may have to use a proxy server. In this case tell git about it:
+
+```bash
+git config --global http.proxy http://yourproxy.example.com
+```
+:::
+
+::: {.linux}
+Please check if Git is already installed:
+
+```bash
+$ git --version
+git version 1.7.4.1
+```
+
+Otherwise please install Git with your favourite package manager:
+
+```bash
+$ sudo yum install git // RPM-based systems
+$ sudo apt-get install git // Debian-based systems
+```
+
+Let Git know who you are:
+
+```bash
+$ git config --global user.name "Your Name Here"
+$ git config --global user.email "your_email@example.com"
+```
+
+Optionally enable password storing when interacting with a remote server:
+
+```bash
+$ git config --global credential.helper store
+```
+
+In some corporate environments you may have to use a proxy server. In this case tell git about it:
+
+```bash
+git config --global http.proxy http://yourproxy.example.com
+```
+:::
+
+::: {.mac}
+Install Git with Homebrew:
+
+```bash
+$ brew install git
+```
+
+Let Git know who you are:
+
+```bash
+$ git config --global user.name "Your Name Here"
+$ git config --global user.email "your_email@example.com"
+```
+
+The [graphical GitHub client](http://mac.github.com/) is also maybe worth a look. See the page on {entry:devguide/github:link} for more info on GitHub.
+
+In some corporate environments you may have to use a proxy server. In this case tell git about it:
+
+```bash
+git config --global http.proxy http://yourproxy.example.com
+```
+:::
+
+
+## Step: Install Git LFS
+
+[Git LFS](https://git-lfs.github.com/) (large file storage) is a git extension dealing with large binary files such as images and is used for the documentation. You don't need to worry about anything but you need to install the extension as it is not a part of standard git.
+
+::: {.win}
+- If you have at least Git version 2.14 you can skip the following step:
+ - Go to the [git-lfs release page](https://github.com/git-lfs/git-lfs/releases/latest) and download the file called **Windows Installer**. Install the file.
+- In the command line run: `git lfs install`
+:::
+
+::: {.linux}
+Install via [PackageCloud](https://packagecloud.io/):
+
+```bash
+$ curl -s https://packagecloud.io/install/repositories/github/git-lfs/script.deb.sh | sudo bash
+$ sudo apt-get install git-lfs
+$ git lfs install
+```
+:::
+
+::: {.mac}
+Install with Homebrew:
+
+```bash
+$ brew install git-lfs
+$ git lfs install
+```
+:::
+
+::: {.note}
+### <i class="fas fa-info-circle"></i> Git LFS installation without admin rights
+
+If you do not have rights to install a system package (e.g. on cluster systems) you can [download](https://github.com/git-lfs/git-lfs/releases/latest) a precompiled `git-lfs` executable. Simply put it into your `PATH` and everything should work (remember to run `git lfs install` once!). See also: <https://github.com/git-lfs/git-lfs/wiki/Installation#other>
+:::
+
+
+## Step: Install CMake
+
+::: {.win}
+- Download the installer, at the [CMake download page](http://www.cmake.org/cmake/resources/software.html) choose the **Windows (Win32 Installer)**.
+- Execute the installer, please check the **Add CMake to the system path for all users**-option
+:::
+
+::: {.linux}
+Install CMake with your favourite package manager (the two graphical user interfaces are optional):
+
+```bash
+$ sudo apt-get install cmake cmake-qt-gui cmake-curses-gui
+```
+:::
+
+::: {.mac}
+Install CMake with Homebrew:
+
+```bash
+$ brew install cmake
+```
+:::
+
+## Step: Install Conan package manager
+
+The [Conan package manager](https://www.conan.io) helps to install all required libraries in a convenient way on every platform. If you prefer you can also [install libraries manually]({entry:81:url}) instead.
+
+Go to [Conans download page](https://www.conan.io/downloads) and see platform-specific instructions:
+
+::: {.win}
+Just use the provided Windows installer and make sure to add conan to your path environment as asked by the installer.
+
+Check on a newly opened command line if Conan was installed succesfully:
+
+```
+$ conan --version
+Conan version 1.0.4
+```
+:::
+
+::: {.linux}
+Use either the provided deb-package or install via Pythons `pip`.
+
+Check on a newly opened command line if Conan was installed succesfully:
+
+```
+$ conan --version
+Conan version 1.0.4
+```
+:::
+
+::: {.mac}
+Use Homebrew:
+
+```
+brew install conan
+```
+
+Check on a newly opened command line if Conan was installed succesfully:
+
+```
+$ conan --version
+Conan version 1.0.4
+```
+:::
diff --git a/web/content/docs/devguide/procedures/publish-a-release.pandoc b/web/content/docs/devguide/procedures/publish-a-release.pandoc
new file mode 100644
index 0000000000000000000000000000000000000000..ca91764e2c62b134e2edd81383d3ccd962456803
--- /dev/null
+++ b/web/content/docs/devguide/procedures/publish-a-release.pandoc
@@ -0,0 +1,69 @@
+---
+date: "2018-02-26T11:00:13+01:00"
+title: "Publish a release"
+author: "Lars Bilke"
+weight: 1051
+
+menu:
+ devguide:
+ parent: procedures
+---
+
+## Write a changelog
+
+Update the [changelog](https://github.com/ufz/ogs/blob/master/CHANGELOG.md) with a short summary of your merged pull requests.
+
+To get a list of your PRs since the last tag:
+
+```bash
+$ git log --merges 6.0.5.. --oneline | grep bilke
+```
+
+where `6.0.5` is the last tag and `bilke` is to be substituted by your GitHub user name. This outputs:
+
+```
+0447b58 Merge pull request #1234 from bilke/remove-osg-converter
+a26da79 Merge pull request #1230 from bilke/disallow-win-32bit
+6db9bf6 Merge pull request #1231 from bilke/ctest-large
+...
+```
+
+To find out more about a PR use `git show`:
+
+```bash
+$ git show a26da79
+
+commit a26da79c84fe281a2f61a542d1fd18aa47b8d425
+Merge: 6db9bf6 5f78991
+Author: Lars Bilke <xxx>
+Date: Wed Jun 1 17:06:03 2016 +0200
+
+ Merge pull request #1230 from bilke/disallow-win-32bit
+
+ Disallow 32-bit Windows builds.
+```
+
+And use `git log` with the second hash after `Merge:`:
+
+```bash
+$ git log 5f78991
+ommit 5f78991528e240d75fd341e1915213e030d4d2a2
+Author: Lars Bilke <xxx>
+Date: Wed Jun 1 13:46:36 2016 +0200
+
+ Disallow 32-bit Windows builds.
+
+ Can be forced by setting OGS_32_BIT=ON
+...
+```
+
+## Publish to website
+
+- Tag the release commit as an annotated tag (`git tag -a 6.0.8 -m "OpenGeoSys Release 6.0.8"`)
+- Create a [new release on GitHub](https://github.com/ufz/ogs/releases)
+- Fill in the release notes
+- Start the `ufz/master` Jenkins job manually and check that it ran successfully! (Do not push to `master` until job ran successfully!)
+- Copy release binaries from Jenkins job to website
+- Create a new [release on the website](/admin/entries/releases/new)
+ - Use the git tag name for the entry title
+ - Add the binaries to the files table
diff --git a/web/content/docs/devguide/testing/Jenkins-PR-Overview.png b/web/content/docs/devguide/testing/Jenkins-PR-Overview.png
new file mode 100644
index 0000000000000000000000000000000000000000..742d3fad86d01b7adf99634637fb975286a4d2e3
--- /dev/null
+++ b/web/content/docs/devguide/testing/Jenkins-PR-Overview.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e99bed32907f2ea983ebd8fb3f135c185d1dd90b58767cbb67ac6c23a99d2eee
+size 182205
diff --git a/web/content/docs/devguide/testing/Jenkins-Pipeline.png b/web/content/docs/devguide/testing/Jenkins-Pipeline.png
new file mode 100644
index 0000000000000000000000000000000000000000..acf34907a10b4c7a9384847f026911743ed6e729
--- /dev/null
+++ b/web/content/docs/devguide/testing/Jenkins-Pipeline.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7a5901fa87718b8cde2020ec92296f8fb340f7816501273658a5eb3edc9e496a
+size 243218
diff --git a/web/content/docs/devguide/testing/jenkins.pandoc b/web/content/docs/devguide/testing/jenkins.pandoc
new file mode 100644
index 0000000000000000000000000000000000000000..84c05e89f990fde98ed572fe80a1a4e1f1a39fb9
--- /dev/null
+++ b/web/content/docs/devguide/testing/jenkins.pandoc
@@ -0,0 +1,78 @@
++++
+date = "2018-02-26T11:00:13+01:00"
+title = "Jenkins"
+author = "Lars Bilke"
+weight = 1022
+
+[menu]
+ [menu.devguide]
+ parent = "testing"
++++
+
+## Introduction
+
+[Jenkins](https://jenkins.io/) is a self-hosted powerful [Continuous Integration](../../development-workflows/continuous-integration) server. Our server is available at <https://jenkins.opengeosys.org>.
+
+To configure the tasks of the CI system we mainly use [Jenkins Pipeline](https://jenkins.io/doc/pipeline) jobs which are defined in a [script inside the OGS source code](https://github.com/ufz/ogs/tree/master/Jenkinsfile). Scripting and versioning the configuration together with the source code is very powerful, e.g. if you introduce a new OGS CMake configuration in a pull request even the change of the CI jobs configuration can be part of the pull request.
+
+## Jenkins Pipeline
+
+In the [Jenkinsfile](https://github.com/ufz/ogs/tree/master/Jenkinsfile) you can see lots of `stage`-blocks. Each stage is a test sub-job running on different test nodes. Inside each stage there are `steps` doing things such as configuring the build with CMake and building specific targets:
+
+```java
+stage('Win') {
+ agent {label 'win && conan' } // Runs on a Windows node with Conan installed
+ environment {
+ MSVC_VERSION = '2017' // Sets Visual Studio version
+ }
+ steps {
+ script {
+ configure { // Runs CMake with options
+ cmakeOptions = '-DOGS_USE_CONAN=ON '
+ }
+ build { } // Builds the project
+ build { target="tests" } // Runs unit tests
+ build { target="ctest" } // Runs benchmark tests
+ }
+ }
+}
+```
+
+Functions such as `configure` and `build` are defined in a separate [Pipeline library](https://github.com/ufz/jenkins-pipeline-library).
+
+Each pipeline run is visualized as follows:
+
+
+
+The status of all stages are shown. You can select one stage (e.g. *Win*) and you will see all steps inside that stage at the bottom list. You can expand the log output of a specific step by clicking the small arrow on the left.
+
+On the *Artefacts*-tab in the top navigation bar are links to the compiled binaries and generated websites (*Doxygen* code documentation and the *Web* site containing also the benchmark documentation).
+
+All of this is part of the modern Jenkins UI called *Blue Ocean*. You can always switch to the classic more comprehensive UI by clicking the arrow inside square button in the top navigation bar.
+
+## Automatic testing
+
+The master-branch of the the UFZ repository as well as all pull requests on that repo are automatically tested. See [this page](https://jenkins.opengeosys.org/blue/organizations/jenkins/ufz%2Fogs/pr) for all currently tested PRs:
+
+
+
+### Automatic testing for own repository
+
+This assumes you have your own clone/fork of OGS on GitHub.
+
+- Tell me your GitHub user name
+- I setup a *multibranch* project on Jenkins
+
+This project will test all branches ending with `_j` on your repository and will be available at `jenkins.opengeosys.org/job/User/job/[your account name]`
+
+To automatically trigger new Jenkins builds when you push changes to your repository you have to setup a GitHub trigger:
+
+- Go to `github.com/[your account name]/ogs/settings/hooks`
+- Click **Add webhook**
+- Under **Payload URL** enter `https://jenkins.opengeosys.org/github-webhook/`
+- Click green button **Add webhook**
+
+To optionally let Jenkins set the result of job as the the commit status (small icons on commit list view):
+
+- Go to `github.com/[your account name]/ogs/settings/collaboration`
+- Type in `ogsbot` and click **Add collaborator**
diff --git a/web/content/docs/devguide/testing/test-data.pandoc b/web/content/docs/devguide/testing/test-data.pandoc
new file mode 100644
index 0000000000000000000000000000000000000000..75f3e3418247d6919183abfd00a5ff4c4b681424
--- /dev/null
+++ b/web/content/docs/devguide/testing/test-data.pandoc
@@ -0,0 +1,42 @@
++++
+date = "2018-02-26T11:00:13+01:00"
+title = "Executable Testing / Test Data"
+author = "Lars Bilke"
+weight = 1023
+
+[menu]
+ [menu.devguide]
+ parent = "testing"
++++
+
+## Introduction
+
+An executable test can be run with several *wrappers*, e.g. with `valgrind`, `memcheck` or a simple `time`-measurement. Each wrapper run can then be validated (called *testers*), e.g. with file-`diff`s or -`grep`s. This can be configured in CMake:
+
+```cmake
+AddTest(
+ NAME GroundWaterFlowProcess
+ PATH ${ExternalData_SOURCE_ROOT}/Elliptic/quad_20x10_GroundWaterFlow
+ EXECUTABLE ogs # optional
+ EXECUTABLE_ARGS quad_20x10_GroundWaterFlow.prj
+ WRAPPER time # optional
+ TESTER diff # optional
+ DIFF_DATA quad_20x10_constMat0.mesh.vtu quad_20x10_left_right.gml # optional
+)
+```
+
+Tests are then run with `make ctest` or for more verbose output with `ctest -VV` (you may also use other [ctest options](https://cmake.org/cmake/help/v3.4/manual/ctest.1.html)). If the checker has some errors they are displayed.
+
+The functionality is very flexible and more wrappers and checker can be added later on. e.g. for running some statistics on output files and comparing them with statistics from reference files.
+
+## Test Data
+
+Test data is stored with git lfs in `Tests/Data`. Generated test output files should be found in `[build-dir]/Tests/Data`.
+
+In the OGS-cli outputting to `[build-dir]/Tests/Data` is already handled (via the `-o` parameter). For other executables you have to implement this, e.g. a with parameter specifying the output directory.
+
+In code `BaseLib::BuildInfo::data_path` (from `BuildInfo.h`) references the data source directory and `BaseLib::BuildInfo::data_binary_path` references the data output directory.
+
+For adding new data files make sure you have [setup git lfs](../../getting-started/prerequisites) already. Then simply commit the new files as usual. For pushing you need to have [setup an account]({{< relref "gitlab.pandoc" >}}) on our own GitLab server as the lfs files are stored there (due to bandwidth limitations on GitHub). When asked for GitLab credentials on pushing use your GitLab account name (should be the same as the GitHub account name) and your created GitLab personal access token ([see the GitLab Setup page]({{< relref "gitlab.pandoc" >}})).
+
+Check this [in-depth tutorial](https://www.atlassian.com/git/tutorials/git-lfs) to learn more about git lfs.
diff --git a/web/content/docs/devguide/testing/unit-testing.pandoc b/web/content/docs/devguide/testing/unit-testing.pandoc
new file mode 100644
index 0000000000000000000000000000000000000000..3eacd4e616a331109ba0c1709337ed453ebe7b39
--- /dev/null
+++ b/web/content/docs/devguide/testing/unit-testing.pandoc
@@ -0,0 +1,22 @@
++++
+date = "2018-02-26T11:00:13+01:00"
+title = "Unit Testing"
+author = "Lars Bilke"
+weight = 1021
+
+[menu]
+ [menu.devguide]
+ parent = "testing"
++++
+
+## Introdution
+
+[Unit testing](http://en.wikipedia.org/wiki/Unit_testing) can be used for testing small pieces of functionality. We use [googletest](https://code.google.com/p/googletest/wiki/V1_6_Primer) as our test framework.
+
+## Running Tests
+
+Googletest is already included in the OGS source code. Running tests is as simple as building the `tests`-target.
+
+## Writing Tests
+
+All tests are located inside the *Tests*-directory in library-specific subfolders. To write a new test you simply create a new *.cpp*-file and use the googletest macros.
diff --git a/web/content/docs/devguide/troubleshooting/build.pandoc b/web/content/docs/devguide/troubleshooting/build.pandoc
new file mode 100644
index 0000000000000000000000000000000000000000..75163402d4a19509dd1d52bb14d85abe5035d1f6
--- /dev/null
+++ b/web/content/docs/devguide/troubleshooting/build.pandoc
@@ -0,0 +1,21 @@
+---
+date: "2018-02-26T11:00:13+01:00"
+title: "Build"
+author: "Lars Bilke"
+weight: 1043
+
+menu:
+ devguide:
+ parent: troubleshooting
+ identifier: build-troubleshooting
+---
+
+## Cotire-related (pre-compiled headers)
+
+If you get some error during build which mentions `cotire` or `*.prefix.hxx.gch` you can try to clean the pre-compiled headers with:
+
+```bash
+make clean_cotire
+```
+
+This may occur after updating the compiler or system libraries. Related to configurations with `OGS_USE_PCH=ON` only.
diff --git a/web/content/docs/devguide/troubleshooting/cmake.pandoc b/web/content/docs/devguide/troubleshooting/cmake.pandoc
new file mode 100644
index 0000000000000000000000000000000000000000..e0d1a58c25962b7fdbbadf57b2de2becae7e2aa6
--- /dev/null
+++ b/web/content/docs/devguide/troubleshooting/cmake.pandoc
@@ -0,0 +1,18 @@
++++
+date = "2018-02-26T11:00:13+01:00"
+title = "CMake"
+author = "Lars Bilke"
+weight = 1041
+
+[menu]
+ [menu.devguide]
+ parent = "troubleshooting"
++++
+
+## <i class="fas fa-exclamation-triangle"></i> General advice
+
+If something goes wrong when running CMake please try again with an **empty** or newly created build-directory! This is very first thing you should try!
+
+Please read the CMake output carefully. Often it will tell you what went wrong.
+
+Check also [Conans troubleshooting page]({{< relref "conan.pandoc" >}}) if you use Conan for dependencies.
diff --git a/web/content/docs/devguide/troubleshooting/conan.pandoc b/web/content/docs/devguide/troubleshooting/conan.pandoc
new file mode 100644
index 0000000000000000000000000000000000000000..a4e9533826a86daa2b111fe5939489f4c4062260
--- /dev/null
+++ b/web/content/docs/devguide/troubleshooting/conan.pandoc
@@ -0,0 +1,33 @@
++++
+date = "2018-02-26T11:00:13+01:00"
+title = "Conan"
+author = "Lars Bilke"
+weight = 1042
+
+[menu]
+ [menu.devguide]
+ parent = "troubleshooting"
++++
+
+## Something went wrong during CMake run
+
+When CMake is run Conan will download library packages. You can see under `Requirements` in the CMake output from where the packages will be downloaded. Most packages will come `from ogs`:
+
+```bash
+$ cmake ../ogs -DOGS_USE_CONAN=ON
+...
+-- Conan executing: conan install . -g cmake -s build_type=Release -s os=Macos -s compiler=apple-clang -s compiler.version=9.0 -s compiler.libcxx=libc++ --build=missing --update
+PROJECT: Installing /Users/bilke/code/ogs6/build-n/conanfile.txt
+Requirements
+ Boost/1.64.0@conan/stable from conan-community
+ Eigen3/3.2.9@bilke/stable from ogs
+ Qt/5.9.2@osechet/stable from ogs
+ Shapelib/1.3.0@bilke/stable from ogs
+ VTK/7.1.0@bilke/stable from ogs
+ libgeotiff/1.4.2@bilke/stable from ogs
+ libtiff/4.0.6@bilke/stable from ogs
+ proj/4.9.2@bilke/stable from ogs
+ zlib/1.2.11@conan/stable from conan-center
+```
+
+You can always delete the Conan cache directory in `$HOME/.conan` to start fresh. This can fix errors.
diff --git a/web/content/docs/devguide/troubleshooting/git.pandoc b/web/content/docs/devguide/troubleshooting/git.pandoc
new file mode 100644
index 0000000000000000000000000000000000000000..8d12f275e7a10cc69fa71ebb421b797f959e8986
--- /dev/null
+++ b/web/content/docs/devguide/troubleshooting/git.pandoc
@@ -0,0 +1,16 @@
++++
+date = "2018-02-26T11:00:13+01:00"
+title = "Git"
+author = "Lars Bilke"
+weight = 1044
+
+[menu]
+ [menu.devguide]
+ parent = "troubleshooting"
++++
+
+## General Git Help
+
+If you have any Git-related questions first look at these links:
+
+- [Git Flight Rules](https://github.com/k88hudson/git-flight-rules)
diff --git a/web/content/docs/quickstart/basics/envinf1.pandoc b/web/content/docs/quickstart/basics/envinf1.pandoc
new file mode 100644
index 0000000000000000000000000000000000000000..8cded9034ef4a5f5844831af78612f492884998a
--- /dev/null
+++ b/web/content/docs/quickstart/basics/envinf1.pandoc
@@ -0,0 +1,31 @@
++++
+date = "2018-02-27T11:00:13+01:00"
+title = "Eve / envinf1"
+author = "Lars Bilke"
+weight = 2
+
+[menu]
+ [menu.quickstart]
+ parent = "basics"
++++
+
+## Introduction
+
+Members of the Department Environmental Informatics of the Helmholtz Centre for Environmental Research - UFZ can use the `envinf1`, `frontend1` and `frontend2`-machines which are tightly connected to the Eve cluster system.
+
+## Select OGS version
+
+You select an OGS version by loading a module:
+
+```bash
+export MODULEPATH=$MODULEPATH:/global/apps/modulefiles
+
+# Examples:
+module load ogs # Loads latest (maybe unstable) ogs in standard config
+module load ogs/head/petsc # Loads latest (maybe unstable) petsc config
+module load ogs/6.0.9 # Loads stable version 6.0.9 in standard config, not released yet
+```
+
+You can select only one version at a time. Run `module purge` to unload all previously loaded modules.
+
+See [Quickstart]({{< relref "introduction.pandoc" >}}) for running instructions.
diff --git a/web/content/docs/quickstart/basics/introduction.pandoc b/web/content/docs/quickstart/basics/introduction.pandoc
new file mode 100644
index 0000000000000000000000000000000000000000..46ca0951a39531a6a9a26f2abafdb620b5ca587b
--- /dev/null
+++ b/web/content/docs/quickstart/basics/introduction.pandoc
@@ -0,0 +1,82 @@
++++
+date = "2018-02-27T11:00:13+01:00"
+title = "Introduction"
+author = "Lars Bilke"
+weight = 1
+
+aliases = [ "/docs/quickstart/" ]
+
+[menu]
+ [menu.quickstart]
+ parent = "basics"
++++
+
+## Download
+
+Download the latest release of OpenGeoSys from the [Download](https://docs.opengeosys.org/download)-page. Be sure to pick the correct file for your operating system.
+
+## Installation
+
+OGS itself is a simple executable file so you can put it anywhere you like. For convenience you may put into a location which is in your `PATH`-environment variable which allows you to start the executable without specifying its full file path.
+
+## Download benchmarks
+
+Download the latest benchmark files from [GitHub as a .zip-package](https://github.com/ufz/ogs-data/archive/master.zip). Unzip it. See [the Benchmarks section](/docs/benchmarks/) for more information.
+
+## Running
+
+OGS is a command line application and requires the path to a `.prj`-file as an argument.
+
+::: {.win}
+To run it open a new command line shell (called *cmd.exe*). Now simply type `ogs` (if the executable is in your `PATH`-environment variable) or specify its full path (e.g.: `C:\Users\MyUserName\Downloads\ogs.exe`) and hit `ENTER`.
+
+OGS prints out its usage instructions:
+
+```
+PARSE ERROR:
+ Required argument missing: project-file
+
+Brief USAGE:
+ ogs [--] [--version] [-h] <PROJECT FILE>
+
+For complete USAGE and HELP type:
+ ogs --help
+```
+
+You can see that there is the project-file missing.
+
+Then simply supply the path to a project file as an argument to the OGS executable:
+
+```
+$ ogs .\Path\to\BenchmarkName.prj
+```
+:::
+
+::: {.linux}
+To run it open a new command line shell (*Terminal*). Now simply type `ogs` (if the executable is in your `PATH`-environment variable) or specify its full path (e.g.: `./path/to/ogs`) and hit `ENTER`.
+
+OGS prints out its usage instructions:
+
+```
+PARSE ERROR:
+ Required argument missing: project-file
+
+Brief USAGE:
+ ogs [--] [--version] [-h] <PROJECT FILE>
+
+For complete USAGE and HELP type:
+ ogs --help
+```
+
+You can see that there is the project-file missing.
+
+Then simply supply the path to a project file as an argument to the OGS executable:
+
+```
+$ ogs ./path/to/BenchmarkName.prj
+```
+:::
+
+::: {.mac}
+See Linux tab!
+:::
diff --git a/web/layouts/_default/baseof.html b/web/layouts/_default/baseof.html
index bd179093ca35ca261b01ec1f02a282a84158be34..0226ce11093aaa947380596191bbebd9550ec05f 100644
--- a/web/layouts/_default/baseof.html
+++ b/web/layouts/_default/baseof.html
@@ -4,4 +4,8 @@
{{ end }}
+{{ block "footer" . }}
+
+{{ end }}
+
{{ partial "footer.html" . }}
diff --git a/web/layouts/docs/single.html b/web/layouts/docs/single.html
index b0902af85c40557c8c0ca92abc2e6bd0cff49e53..47e26367bbea22b3135dad078059cf3bdfcb7afc 100644
--- a/web/layouts/docs/single.html
+++ b/web/layouts/docs/single.html
@@ -4,8 +4,11 @@
{{ $segments := split .RelPermalink "/" }}
{{ $subsection := index $segments 2 }}
<h3>
+ <a href="/docs/">Docs</a> / <span class="orange">
{{ if eq $subsection "devguide"}}Developer Guide{{ end }}
{{ if eq $subsection "benchmarks"}}Benchmarks{{ end }}
+ {{ if eq $subsection "quickstart"}}Quickstart{{ end }}
+ </span>
</h3>
<hr>
<ul class="sidenav">
@@ -23,13 +26,62 @@
</div>
<div class="col-xs-9">
<h1>{{ .Title }}</h1>
+ {{ if or (eq $subsection "devguide") (eq $subsection "quickstart") }}
+ <div id="os-selector">Select OS: <a id="btn-win"><i class="fab fa-windows"></i> Windows</a> <a id="btn-linux"><i class="fab fa-linux"></i> Linux</a> <a id="btn-mac"><i class="fab fa-apple"></i> macOS</a></div>
+ {{ end }}
{{ .Content }}
+ {{ partial "page-info" . }}
<hr>
{{ partial "footer-nav.html" . }}
</div>
- {{ partial "page-info" . }}
+
+{{ end }}
+
+{{ define "footer" }}
+
+ {{ $segments := split .RelPermalink "/" }}
+ {{ $subsection := index $segments 2 }}
+ {{ if or (eq $subsection "devguide") (eq $subsection "quickstart") }}
+ <script>
+ $("#btn-win").click(function(){
+ $(".win").show();
+ $(".linux").hide();
+ $(".mac").hide();
+ $("#btn-win").addClass("active");
+ $("#btn-linux").removeClass("active");
+ $("#btn-mac").removeClass("active");
+ });
+
+ $("#btn-linux").click(function(){
+ $(".win").hide();
+ $(".linux").show();
+ $(".mac").hide();
+ $("#btn-win").removeClass("active");
+ $("#btn-linux").addClass("active");
+ $("#btn-mac").removeClass("active");
+ });
+
+ $("#btn-mac").click(function(){
+ $(".win").hide();
+ $(".linux").hide();
+ $(".mac").show();
+ $("#btn-win").removeClass("active");
+ $("#btn-linux").removeClass("active");
+ $("#btn-mac").addClass("active");
+ });
+
+ $( document ).ready(function() {
+ if ($(".win").length == 0) {
+ $("#os-selector").hide();
+ }
+ else {
+ $("#btn-win").click();
+ }
+ });
+ </script>
+ {{ end }}
{{ end }}
diff --git a/web/layouts/index.html b/web/layouts/index.html
index dc49f9b253869299c5eee0677b0969805a5a1286..b2f8ea2ee50145a928b766ddf95f9c4d2bea1900 100644
--- a/web/layouts/index.html
+++ b/web/layouts/index.html
@@ -1,23 +1,5 @@
{{ define "main" }}
-
- <div class="col-xs-4">
- <h2>Content</h2>
- <ul>
- {{ range .Site.Sections }}
- <li><a href="{{ .Permalink }}">{{ .Title }}</a></li>
- {{ end }}
- {{ range .Data.Pages }}
- {{ if eq .Type "page" }}
- <li><a href="{{ .Permalink }}">{{ .Title }}</a></li>
- {{ end }}
- {{ end }}
- <li><a href="/news">News</a></li>
- </div>
-
- <div class="col-xs-8">
- <h1>Benchmark documentation site</h1>
- <p>For the moment this site contains just the <a href="/docs/benchmarks"><i class="fas fa-arrow-right"></i> benchmark documentation</a> for <a href="https://github.com/ufz/ogs6">OpenGeoSys-6</a>.
- </p>
- </div>
-
+<div class="col-xs-8">
+ {{.Content}}
+</div>
{{ end }}
diff --git a/web/layouts/partials/footer-nav.html b/web/layouts/partials/footer-nav.html
index 82d550922e7e7178c74b4e8293ee79917fa854c9..38ab39181f33043b6b2e7dd884636a0f958eeab1 100644
--- a/web/layouts/partials/footer-nav.html
+++ b/web/layouts/partials/footer-nav.html
@@ -35,4 +35,5 @@
</div>
</div>
</div>
+<br>
{{ end }}
diff --git a/web/layouts/partials/header.html b/web/layouts/partials/header.html
index d7481ce750ba1df8f4303ffbb6618f231b30f7e3..008a614b9f7c87813585c4fbc6c017f720e72a67 100644
--- a/web/layouts/partials/header.html
+++ b/web/layouts/partials/header.html
@@ -8,6 +8,7 @@
<meta name="author" content="OpenGeoSys Community">
<link rel="stylesheet" href="/css/main.css">
+ <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
<script type="text/x-mathjax-config">
MathJax.Hub.Config({
@@ -18,7 +19,7 @@
<script type="text/javascript" async
src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
- <script defer src="https://use.fontawesome.com/releases/v5.0.1/js/all.js"></script>
+ <script defer src="https://use.fontawesome.com/releases/v5.0.6/js/all.js"></script>
<title>{{ .Title }}</title>
</head>
diff --git a/web/layouts/partials/page-info.html b/web/layouts/partials/page-info.html
index 22acb8af6a783095fa7dbb570bdd8cdb09ff1894..d9e3f6f75413a3fef0f225be52bd775e402491ea 100644
--- a/web/layouts/partials/page-info.html
+++ b/web/layouts/partials/page-info.html
@@ -1,4 +1,13 @@
<div class="page-info">
- <p>This article was written by {{ .Params.Author }}. If you are missing something or you find an error please <a href="mailto:ogs-devs@googlegroups.com">let us know</a>. <br>
- Last revision: {{ .Lastmod.Format "January 2, 2006" }}{{ if .IsPage }}<em>{{ with .GitInfo }}| {{ .Subject }} | <a href="https://github.com/ufz/ogs/commit/{{ .AbbreviatedHash }}">{{ .AbbreviatedHash }}</a>{{end }}</em>{{ end }}</p>
+ <p>This article was written by {{ .Params.Author }}. If you are missing something or you find an error please <a href="mailto:ogs-devs@googlegroups.com">let us know</a>.
+ <br> Generated with <a href="https://gohugo.com">Hugo</a> {{ .Hugo.Version }}. Last revision: {{ .Lastmod.Format "January 2, 2006" }} {{ if .IsPage }}<em>
+ {{ with .GitInfo }}
+ <br>
+ Commit: {{ .Subject }} <a href="https://github.com/ufz/ogs/commit/{{ .AbbreviatedHash }}">{{ .AbbreviatedHash }}</a>
+ {{ end }}
+ {{if .GitInfo}}
+ | <a href="https://github.com/ufz/ogs/edit/master/web/content/{{ .File.Path }}">Edit this page on <i class="fab fa-github"></i></a>
+ {{ end }}
+ </em> {{ end }}
+ </p>
</div>
diff --git a/web/layouts/section/docs.html b/web/layouts/section/docs.html
index 063e2c0f8e739259bc1bffec70294e577156fed7..eaf5154e3886e926806ddfba87c976de4bd24e9d 100644
--- a/web/layouts/section/docs.html
+++ b/web/layouts/section/docs.html
@@ -2,17 +2,22 @@
<div class="col-xs-12">
<h1>OpenGeoSys Documentation</h1>
+ {{ .Content }}
<div class="row">
+ <div class="flex flex-wrap">
{{ range .Params.sections }}
- <article class="fl w-33 ma2 bg-white br3 pa4 pa4-ns mv3 ba b--black-10">
- <div class="tc">
- <h1 class="f4"><a href="/docs/{{ .slug }}">{{ .name }}</a></h1>
- <hr class="mw3 bb bw1 b--black-10">
+ <div class="w-third pa2 mv3">
+ <div class="pa2 ba br3 b--black-10">
+ <div class="tc">
+ <h1 class="f4"><a href="/docs/{{ .slug }}">{{ .name }}</a></h1>
+ <hr class="mw3 bb bw1 b--black-10">
+ </div>
+ <p class="1h-copy measure center f6 black-70">{{ .text }}</p>
</div>
- <p class="1h-copy measure center f6 black-70">{{ .text }}</p>
- </article>
+ </div>
{{ end }}
+ </div>
</div>
</div>
diff --git a/web/package.json b/web/package.json
index 26a26eddab074ddd7bb7957f5b0f7a2a966606c1..14e44771b24e4be08897910aa274384dbf3eb054 100644
--- a/web/package.json
+++ b/web/package.json
@@ -65,7 +65,8 @@
"globs": {
"distCss": [
"./node_modules/normalize.css/normalize.css",
- "./node_modules/flexboxgrid/dist/flexboxgrid.min.css"
+ "./node_modules/flexboxgrid/dist/flexboxgrid.min.css",
+ "./src/css/pandoc-highlighting.css"
],
"img": [
"./public/img/"
diff --git a/web/src/css/pandoc-highlighting.css b/web/src/css/pandoc-highlighting.css
new file mode 100644
index 0000000000000000000000000000000000000000..08f999a69d867d97950de8ca2b7984d91292f563
--- /dev/null
+++ b/web/src/css/pandoc-highlighting.css
@@ -0,0 +1,63 @@
+a.sourceLine { display: inline-block; line-height: 1.25; }
+a.sourceLine { pointer-events: none; color: inherit; text-decoration: inherit; }
+a.sourceLine:empty { height: 1.2em; position: absolute; }
+.sourceCode { overflow: visible; }
+code.sourceCode { white-space: pre; position: relative; }
+div.sourceCode { margin: 1em 0; }
+pre.sourceCode { margin: 0; }
+@media screen {
+div.sourceCode { overflow: auto; }
+}
+@media print {
+code.sourceCode { white-space: pre-wrap; }
+a.sourceLine { text-indent: -1em; padding-left: 1em; }
+}
+pre.numberSource a.sourceLine
+ { position: relative; }
+pre.numberSource a.sourceLine:empty
+ { position: absolute; }
+pre.numberSource a.sourceLine::before
+ { content: attr(data-line-number);
+ position: absolute; left: -5em; text-align: right; vertical-align: baseline;
+ border: none; pointer-events: all;
+ -webkit-touch-callout: none; -webkit-user-select: none;
+ -khtml-user-select: none; -moz-user-select: none;
+ -ms-user-select: none; user-select: none;
+ padding: 0 4px; width: 4em;
+ color: #aaaaaa;
+ }
+pre.numberSource { margin-left: 3em; border-left: 1px solid #aaaaaa; padding-left: 4px; }
+div.sourceCode
+ { }
+@media screen {
+a.sourceLine::before { text-decoration: underline; }
+}
+code span.al { color: #ff0000; font-weight: bold; } /* Alert */
+code span.an { color: #60a0b0; font-weight: bold; font-style: italic; } /* Annotation */
+code span.at { color: #7d9029; } /* Attribute */
+code span.bn { color: #40a070; } /* BaseN */
+code span.bu { } /* BuiltIn */
+code span.cf { color: #007020; font-weight: bold; } /* ControlFlow */
+code span.ch { color: #4070a0; } /* Char */
+code span.cn { color: #880000; } /* Constant */
+code span.co { color: #60a0b0; font-style: italic; } /* Comment */
+code span.cv { color: #60a0b0; font-weight: bold; font-style: italic; } /* CommentVar */
+code span.do { color: #ba2121; font-style: italic; } /* Documentation */
+code span.dt { color: #902000; } /* DataType */
+code span.dv { color: #40a070; } /* DecVal */
+code span.er { color: #ff0000; font-weight: bold; } /* Error */
+code span.ex { } /* Extension */
+code span.fl { color: #40a070; } /* Float */
+code span.fu { color: #06287e; } /* Function */
+code span.im { } /* Import */
+code span.in { color: #60a0b0; font-weight: bold; font-style: italic; } /* Information */
+code span.kw { color: #007020; font-weight: bold; } /* Keyword */
+code span.op { color: #666666; } /* Operator */
+code span.ot { color: #007020; } /* Other */
+code span.pp { color: #bc7a00; } /* Preprocessor */
+code span.sc { color: #4070a0; } /* SpecialChar */
+code span.ss { color: #bb6688; } /* SpecialString */
+code span.st { color: #4070a0; } /* String */
+code span.va { color: #19177c; } /* Variable */
+code span.vs { color: #4070a0; } /* VerbatimString */
+code span.wa { color: #60a0b0; font-weight: bold; font-style: italic; } /* Warning */
diff --git a/web/src/scss/main.scss b/web/src/scss/main.scss
index 8420e3f5aaf9c613bd5acbe9306785d452bd2c66..35ecec4cf20a214ba7392ef77766f08f77fbdb8d 100644
--- a/web/src/scss/main.scss
+++ b/web/src/scss/main.scss
@@ -6,7 +6,7 @@ $code-font-family: code;
// Fonts
h1, h2, h3, h4, h5, h6 { @extend .#{$header-font-family}; }
-body { @extend .#{$text-font-family}; }
+body, p { @extend .#{$text-font-family}; }
code, pre { @extend .#{$code-font-family}; }
// Header
@@ -21,7 +21,6 @@ a {
}
p, li {
- @extend .measure-wide;
@extend .lh-copy;
@extend .f5;
}
@@ -29,6 +28,12 @@ p, li {
// Code
code, pre {
@extend .lh-solid;
+ @extend .f6;
+}
+
+pre {
+ @extend .bg-near-white;
+ @extend .pa2;
}
// Nav
@@ -61,6 +66,34 @@ img {
// Docs
+// OS selector
+#btn-win, #btn-linux, #btn-mac {
+ @extend .f6;
+ @extend .link;
+ @extend .dim;
+ @extend .ba;
+ @extend .bw1;
+ @extend .ph3;
+ @extend .pv1;
+ @extend .mb2;
+ @extend .dib;
+ @extend .black;
+}
+
+#btn-win.active, #btn-linux.active, #btn-mac.active {
+ @extend .orange;
+}
+
+.note {
+ @extend .pv1;
+ @extend .ph4;
+ @extend .bg-washed-yellow;
+
+ h1, h2, h3, h4 {
+ @extend .orange;
+ }
+}
+
// Side nav
ul.sidenav {
@extend .list;
@@ -71,13 +104,14 @@ ul.sidenav {
li.category {
@extend .#{$header-font-family};
@extend .small-caps;
- @extend .mt1;
+ @extend .f4;
+ @extend .mt2;
}
a {
@extend .nav-a-style;
@extend .f6;
}
- a.active {
+ a.active, a:hover {
@extend .orange;
}
}
@@ -92,7 +126,14 @@ ul.sidenav {
.page-info {
p {
@extend .f6;
- max-width: 100%;
+ @extend .gray;
+
+ a {
+ @extend .light-blue;
+ }
+ a:hover {
+ @extend .light-red;
+ }
}
}