diff --git a/docs/01_try-installation.md b/docs/01_try-installation.md
index ebd0e29..3af3edd 100644
--- a/docs/01_try-installation.md
+++ b/docs/01_try-installation.md
@@ -14,12 +14,11 @@
 The Docker-based installation requires **Docker** and **Docker Compose** to be installed on the target machine.
 Installation instructions can be found below.
 
-<div class="admonition info">
-    <div class="admonition-title">Install Docker</div>
-    <p>Go to https://docs.docker.com/installation/ and follow the instructions to install Docker for your OS. Make sure
-        docker can be started as a non-root user (described in the installation manual, don’t forget to log out and in
-        again) and check that Docker is installed correctly by executing docker-run hello-world</p>
-</div>
+:::info Install Docker
+Go to https://docs.docker.com/installation/ and follow the instructions to install Docker for your OS. Make sure
+docker can be started as a non-root user (described in the installation manual, don’t forget to log out and in
+again) and check that Docker is installed correctly by executing docker-run hello-world
+:::
 
 ### Supported operating systems
 
@@ -51,13 +50,12 @@
     <img src="/img/01_try-installation/04_home.png" alt="Home page"/>
 </div>
 
-<div class="admonition error">
-    <div class="admonition-title">Errors during the installation process</div>
-    <p>In most cases, errors during the installation are due to an under-powered system.<br/>
-        If there is a problem with any of the components, please restart the whole system (<code>docker-compose
-            down</code> and eventually also delete the volumes).
-        Please also make sure that you've assigned enough memory available to Docker.</p>
-</div>
+:::danger Errors during the installation process
+In most cases, errors during the installation are due to an under-powered system.
+If there is a problem with any of the components, please restart the whole system (`docker-compose
+down` and eventually also delete the volumes).
+Please also make sure that you've assigned enough memory available to Docker.
+:::
 
 ## Next Steps
 
diff --git a/docs/06_extend-first-processor.md b/docs/06_extend-first-processor.md
index b567182..9608050 100644
--- a/docs/06_extend-first-processor.md
+++ b/docs/06_extend-first-processor.md
@@ -26,22 +26,19 @@
 If you see such an IP or the extensions service complains that it cannot resolve the IP, you can manually set the IP address of the extensions service. You can do so by providing an <code>SP_HOST</code> environment variable.
 
 
-To check if the service is up and running, open the browser on *'localhost:8090'* (or the port defined in the service definition). The machine-readable description of the processor should be visible as shown below.
-
 <img src="/img/archetype/endpoint.png" width="90%" alt="Project Structure"/>
 
+To check if the service is up and running, open the browser on *'localhost:8090'* (or the port defined in the service definition). The machine-readable description of the processor should be visible as shown below.
 
-<div class="admonition error">
-<div class="admonition-title">Common Problems</div>
-<p>
+
+:::caution Common Problems
 If the service description is not shown on 'localhost:8090', you might have to change the port address.
 This needs to be done in the configuration of your service, further explained in the configurations part of the developer guide.
 
 If the service does not show up in the StreamPipes installation menu, click on 'MANAGE ENDPOINTS' and add 'http://<span></span>YOUR_IP_OR_DNS_NAME:8090'.
 Use the IP or DNS name you provided as the SP_HOST variable or the IP (if resolvable) found by the auto-discovery service printed in the console.
 After adding the endpoint, a new processor with the name *Example* should show up.
-</p>
-</div>
+:::
 
 Now you can go to StreamPipes.
 Your new processor *'Example'* should now show up in the installation menu ("Install Pipeline Elements" in the left navigation bar).
diff --git a/docs/06_extend-sdk-functions.md b/docs/06_extend-sdk-functions.md
index 837b9bb..659690b 100644
--- a/docs/06_extend-sdk-functions.md
+++ b/docs/06_extend-sdk-functions.md
@@ -24,11 +24,13 @@
 
 ## Writing a function
 
-<div class="admonition warning">
-    <div class="admonition-title">Work in Progress</div>
-    <p>Functions are currently in preview mode and are not yet recommended for production usage. 
-APIs are subject to change in a future version.</p>
-</div>
+:::caution Work in Progress
+
+Functions are currently in preview mode and are not yet recommended for production usage. 
+APIs are subject to change in a future version.
+
+:::
+
 
 To define a function, create a new extensions service using the [Maven Archetypes](06_extend-archetypes.md) or use an already existing service.
 
diff --git a/docs/06_extend-sdk-output-strategies.md b/docs/06_extend-sdk-output-strategies.md
index 1c00f07..feb2248 100644
--- a/docs/06_extend-sdk-output-strategies.md
+++ b/docs/06_extend-sdk-output-strategies.md
@@ -10,12 +10,12 @@
 
 The following reference describes how output strategies can be defined using the SDK.
 
-<div class="admonition tip">
-<div class="admonition-title">Code on Github</div>
-<p>For all examples, the code can be found on <a href="https://www.github.com/apache/streampipes-examples
-/tree/dev/streampipes-pipeline-elements-examples-processors-jvm/src/main/java/org/apache/streampipes/pe/examples/jvm
-/outputstrategy/">Github</a>.</p>
-</div>
+:::tip Code on Github
+
+For all examples, the code can be found on [Github](https://www.github.com/apache/streampipes-examples/tree/dev/streampipes-pipeline-elements-examples-processors-jvm/src/main/java/org/apache/streampipes/pe/examples/jvm/outputstrategy/)
+
+:::
+
 
 ## Reference
 
diff --git a/docs/06_extend-sdk-static-properties.md b/docs/06_extend-sdk-static-properties.md
index 9422df6..39c2d5d 100644
--- a/docs/06_extend-sdk-static-properties.md
+++ b/docs/06_extend-sdk-static-properties.md
@@ -10,12 +10,11 @@
 
 The following reference describes how static properties can be defined using the SDK.
 
-<div class="admonition tip">
-<div class="admonition-title">Code on Github</div>
-<p>For all examples, the code can be found on <a href="https://github.com/apache/streampipes-examples/tree
-/dev/streampipes-pipeline-elements-examples-processors-jvm/src/main/java/org/apache/streampipes/pe/examples/jvm
-/staticproperty">Github</a>.</p>
-</div>
+:::tip Code on Github
+
+For all examples, the code can be found on [Github](https://github.com/apache/streampipes-examples/tree/dev/streampipes-pipeline-elements-examples-processors-jvm/src/main/java/org/apache/streampipes/pe/examples/jvm/staticproperty).
+
+:::
 
 ## Reference
 
@@ -169,12 +168,12 @@
 String selectedSingleValue = extractor.selectedSingleValue("id", String.class);
 ```
 
-<div class="admonition tip">
-<div class="admonition-title">Declaring options</div>
-<p>Sometimes, you may want to use an internal name that differs from the display name of an option.
-For that, you can use the method Options.from(Tuple2{'<'}String, String{'>'}) and the extractor method selectedSingleValueInternalName.</p>
-</div>
+:::tip Declaring options
 
+Sometimes, you may want to use an internal name that differs from the display name of an option.
+For that, you can use the method Options.from(Tuple2{'<'}String, String{'>'}) and the extractor method selectedSingleValueInternalName.
+
+:::tip
 
 
 ### Multi-Value Selections
@@ -258,9 +257,11 @@
 
 The parameter extraction does not differ from the extraction of static single-value parameters.
 
-<div class="admonition info">
-<div class="admonition-title">Multi-value selections</div>
-<p>Although this example shows the usage of runtime-resolvable selections using single value selections, the same also works for multi-value selections!</p>
-</div>
+
+:::info Multi-value selections
+
+Although this example shows the usage of runtime-resolvable selections using single value selections, the same also works for multi-value selections!
+
+:::
 
 
diff --git a/docs/06_extend-sdk-stream-requirements.md b/docs/06_extend-sdk-stream-requirements.md
index 9d06735..63ac0c7 100644
--- a/docs/06_extend-sdk-stream-requirements.md
+++ b/docs/06_extend-sdk-stream-requirements.md
@@ -12,10 +12,13 @@
 
 This guide covers the creation of stream requirements. Before reading this section, we recommend that you make yourself familiar with the SDK guide on [data processors](dev-guide-processor-sdk.md) and [data sinks](dev-guide-sink-sdk.md).
 
-<div class="admonition tip">
-<div class="admonition-title">Code on Github</div>
-<p>For all examples, the code can be found on <a href="https://www.github.com/apache/streampipes-examples/tree/dev/streampipes-pipeline-elements-examples-processors-jvm/src/main/java/org/apache/streampipes/pe/examples/jvm/requirements/">Github</a>.</p>
-</div>
+
+:::tip Code on Github
+
+For all examples, the code can be found on [Github](https://www.github.com/apache/streampipes-examples/tree/dev/streampipes-pipeline-elements-examples-processors-jvm/src/main/java/org/apache/streampipes/pe/examples/jvm/requirements/).
+
+:::
+
 
 ## The StreamRequirementsBuilder
 
diff --git a/docs/06_extend-tutorial-data-processors.md b/docs/06_extend-tutorial-data-processors.md
index 9e5e580..a4170cc 100644
--- a/docs/06_extend-tutorial-data-processors.md
+++ b/docs/06_extend-tutorial-data-processors.md
@@ -6,27 +6,33 @@
 
 In this tutorial, we will add a new data processor.
 
-From an architectural point of view, we will create a self-contained service that includes the description of the data processor and an implementation.
+From an architectural point of view, we will create a self-contained service that includes the description of the data
+processor and an implementation.
 
 ## Objective
 
-We are going to create a new data processor that realizes a simple geofencing algorithm - we detect vehicles that enter a specified radius around a user-defined location.
-This pipeline element will be a generic element that works with any event stream that provides geospatial coordinates in form of a latitude/longitude pair.
+We are going to create a new data processor that realizes a simple geofencing algorithm - we detect vehicles that enter
+a specified radius around a user-defined location.
+This pipeline element will be a generic element that works with any event stream that provides geospatial coordinates in
+form of a latitude/longitude pair.
 
 The algorithm outputs every location event once the position has entered the geofence.
 
+:::note
 
-<div class="admonition note">
-<div class="admonition-title">Note</div>
-<p>The implementation in this tutorial is pretty simple - our processor will fire an event every time the GPS location is inside the geofence.
-       In a real-world application, you would probably want to define a pattern that recognizes the _first_ event a vehicle enters the geofence.<br/>
-       This can be easily done using a CEP library.</p>
-</div>
+The implementation in this tutorial is pretty simple - our processor will fire an event every time the GPS location is
+inside the geofence.
+In a real-world application, you would probably want to define a pattern that recognizes the _first_ event a vehicle
+enters the geofence.
 
+This can be easily done using a CEP library.
+
+:::
 
 ## Project setup
 
-Instead of creating a new project from scratch, we recommend to use the Maven archetype to create a new project skeleton (streampipes-archetype-extensions-jvm).
+Instead of creating a new project from scratch, we recommend to use the Maven archetype to create a new project
+skeleton (streampipes-archetype-extensions-jvm).
 Enter the following command in a command line of your choice (Apache Maven needs to be installed):
 
 ```
@@ -38,10 +44,12 @@
 
 You will see a project structure similar to the structure shown in the [archetypes](06_extend-archetypes.md) section.
 
-<div class="admonition tip">
-<div class="admonition-title">Tip</div>
-<p>Besides the basic project skeleton, the sample project also includes an example Dockerfile you can use to package your application into a Docker container.</p>
-</div>
+:::tip
+
+Besides the basic project skeleton, the sample project also includes an example Dockerfile you can use to package your
+application into a Docker container.
+
+:::
 
 Now you're ready to create your first data processor for StreamPipes!
 
@@ -71,138 +79,162 @@
 
 public class GeofencingProcessor extends StreamPipesDataProcessor {
 
- private static final String LATITUDE_CENTER = "latitude-center";
- private static final String LONGITUDE_CENTER = "longitude-center";
+  private static final String LATITUDE_CENTER = "latitude-center";
+  private static final String LONGITUDE_CENTER = "longitude-center";
 
- @Override
- public DataProcessorDescription declareModel() {
-  return ProcessingElementBuilder.create("org.apache.streampipes.tutorial-geofencing")
-          .category(DataProcessorType.ENRICH)
-          .withAssets(Assets.DOCUMENTATION, Assets.ICON)
-          .build();
- }
+  @Override
+  public DataProcessorDescription declareModel() {
+    return ProcessingElementBuilder.create("org.apache.streampipes.tutorial-geofencing")
+        .category(DataProcessorType.ENRICH)
+        .withAssets(Assets.DOCUMENTATION, Assets.ICON)
+        .build();
+  }
 
- @Override
- public void onInvocation(ProcessorParams parameters, SpOutputCollector spOutputCollector, EventProcessorRuntimeContext runtimeContext) throws SpRuntimeException {
+  @Override
+  public void onInvocation(ProcessorParams parameters, SpOutputCollector spOutputCollector, EventProcessorRuntimeContext runtimeContext) throws SpRuntimeException {
 
- }
+  }
 
- @Override
- public void onEvent(Event event, SpOutputCollector collector) throws SpRuntimeException {
+  @Override
+  public void onEvent(Event event, SpOutputCollector collector) throws SpRuntimeException {
 
- }
+  }
 
- @Override
- public void onDetach() throws SpRuntimeException {
+  @Override
+  public void onDetach() throws SpRuntimeException {
 
- }
+  }
 }
 
 
 ```
 
-In this class, we need to implement three methods: The `declareModel` method is used to define abstract stream requirements such as event properties that must be present in any input stream that is later connected to the element using the StreamPipes UI.
+In this class, we need to implement three methods: The `declareModel` method is used to define abstract stream
+requirements such as event properties that must be present in any input stream that is later connected to the element
+using the StreamPipes UI.
 The second method, `onInvocation` is triggered once a pipeline is started. Finally, the `onEvent` method
 
 Similar to data sources, the SDK provides a builder class to generate the description for data processors.
 Delete the content within the ``declareModel`` method and add the following lines to the `declareModel` method:
 
 ```java
-return ProcessingElementBuilder.create("org.apache.streampipes.tutorial.geofencing", "Geofencing", "A simple geofencing data processor")
+return ProcessingElementBuilder.create("org.apache.streampipes.tutorial.geofencing","Geofencing","A simple geofencing data processor")
 ```
 
 This creates a new data processor with the ID, title and description assigned to the element builder.
-Next, we add some _stream requirements_ to the description. As we'd like to develop a generic pipeline element that works with any event that provides a lat/lng pair, we define two stream requirements as stated below:
+Next, we add some _stream requirements_ to the description. As we'd like to develop a generic pipeline element that
+works with any event that provides a lat/lng pair, we define two stream requirements as stated below:
 
 ```java
 .requiredStream(StreamRequirementsBuilder
     .create()
     .requiredPropertyWithUnaryMapping(EpRequirements.domainPropertyReq(Geo.lat),
-            Labels.from("latitude-field", "Latitude", "The event " +
-            "property containing the latitude value"), PropertyScope.MEASUREMENT_PROPERTY)
+    Labels.from("latitude-field","Latitude","The event "+
+    "property containing the latitude value"),PropertyScope.MEASUREMENT_PROPERTY)
     .requiredPropertyWithUnaryMapping(EpRequirements.domainPropertyReq(Geo.lng),
-            Labels.from("longitude-field", "Longitude", "The event " +
-                    "property containing the longitude value"), PropertyScope.MEASUREMENT_PROPERTY)
+    Labels.from("longitude-field","Longitude","The event "+
+    "property containing the longitude value"),PropertyScope.MEASUREMENT_PROPERTY)
     .build())
 ```
 
-The first line, `.requiredStream()` defines that we want a data processor with exactly one input stream. Adding more stream requirements would create elements with multiple input connectors in StreamPipes.
+The first line, `.requiredStream()` defines that we want a data processor with exactly one input stream. Adding more
+stream requirements would create elements with multiple input connectors in StreamPipes.
 Stream requirements can be assigned by using the `StreamRequirementsBuilder` class.
-In our example, we define two requirements, so-called _domain property requirements_. In contrast to _data type requirements_ where we'd expect an event property with a field of a specific data type (e.g., float), domain property requirements expect a specific domain property, e.g., from a vocabulary such as the WGS84 Geo vocab.
+In our example, we define two requirements, so-called _domain property requirements_. In contrast to _data type
+requirements_ where we'd expect an event property with a field of a specific data type (e.g., float), domain property
+requirements expect a specific domain property, e.g., from a vocabulary such as the WGS84 Geo vocab.
 
-Once a pipeline is deployed, we are interested in the actual field (and its field name) that contains the latitude and longitude values.
-In some cases, there might me more than one field that satisfies a property requirement and we would like users to select the property the geofencing component should operate on.
-Therefore, our example uses the method `requiredPropertyWithUnaryMapping`, which will map a requirement to a real event property of an input stream and  let the user choose the appropriate field in the StreamPipes UI when pipelines are defined.
+Once a pipeline is deployed, we are interested in the actual field (and its field name) that contains the latitude and
+longitude values.
+In some cases, there might me more than one field that satisfies a property requirement and we would like users to
+select the property the geofencing component should operate on.
+Therefore, our example uses the method `requiredPropertyWithUnaryMapping`, which will map a requirement to a real event
+property of an input stream and let the user choose the appropriate field in the StreamPipes UI when pipelines are
+defined.
 
-Finally, the `PropertyScope` indicates that the required property is a measurement value (in contrast to a dimension value). This allows us later to provide improved user guidance in the pipeline editor.
+Finally, the `PropertyScope` indicates that the required property is a measurement value (in contrast to a dimension
+value). This allows us later to provide improved user guidance in the pipeline editor.
 
-Besides requirements, users should be able to define the center coordinate of the Geofence and the size of the fence defined as a radius around the center in meters.
+Besides requirements, users should be able to define the center coordinate of the Geofence and the size of the fence
+defined as a radius around the center in meters.
 The radius can be defined by adding a simple required text field to the description:
 
 ```java
-.requiredIntegerParameter("radius", "Geofence Size", "The size of the circular geofence in meters.", 0, 1000, 1)
+.requiredIntegerParameter("radius","Geofence Size","The size of the circular geofence in meters.",0,1000,1)
 ```
 
 Similar to mapping properties, text parameters have an internalId (radius), a label and a description.
 In addition, we can assign a _value specification_ to the parameter indicating the value range we support.
 Our example supports a radius value between 0 and 1000 with a granularity of 1.
-In the StreamPipes UI, a required text parameter is rendered as a text input field, in case we provide an optional value specification, a slider input is automatically generated.
+In the StreamPipes UI, a required text parameter is rendered as a text input field, in case we provide an optional value
+specification, a slider input is automatically generated.
 
 Such user-defined parameters are called _static properties_. There are many different types of static properties (see
- the [Processor SDK](06_extend-sdk-static-properties.md) for an overview).
+the [Processor SDK](06_extend-sdk-static-properties.md) for an overview).
 
-In this example, we'll further add two very simple input fields to let users provide latitude and longitude of the geofence center.
+In this example, we'll further add two very simple input fields to let users provide latitude and longitude of the
+geofence center.
 
 Add the following line to the `declareModel` method:
 
 ```java
-   .requiredFloatParameter(Labels.from(LATITUDE_KEY, "Latitude", "The latitude value"))
-   .requiredFloatParameter(Labels.from(LONGITUDE_KEY, "Longitude", "The longitude value"))
+   .requiredFloatParameter(Labels.from(LATITUDE_KEY,"Latitude","The latitude value"))
+    .requiredFloatParameter(Labels.from(LONGITUDE_KEY,"Longitude","The longitude value"))
 
 ```
 
 Now we need to define the output of our Geofencing pipeline element.
-As explained in the first section, the element should fire every time some geo-located entity arrives within the defined geofence.
+As explained in the first section, the element should fire every time some geo-located entity arrives within the defined
+geofence.
 Therefore, the processor outputs the same schema as it receives as an input.
-Although we don't know the exact input right now as it depends on the stream users connect in StreamPipes when creating pipelines, we can define an _output strategy_ as follows:
+Although we don't know the exact input right now as it depends on the stream users connect in StreamPipes when creating
+pipelines, we can define an _output strategy_ as follows:
 
 ```java
 .outputStrategy(OutputStrategies.keep())
 ```
 
 This defines a _KeepOutputStrategy_, i.e., the input event schema is not modified by the processor.
-There are many more output strategies you can define depending on the functionality you desire, e.g., _AppendOutput_ for defining a processor that enriches events or _CustomOutput_ in case you would like users to select the output by themselves.
+There are many more output strategies you can define depending on the functionality you desire, e.g., _AppendOutput_ for
+defining a processor that enriches events or _CustomOutput_ in case you would like users to select the output by
+themselves.
 
 That's it! We've now defined input requirements, required user input and an output strategy.
-In the next section, you will learn how to extract these parameters once the pipeline element is invoked after a pipeline was created.
+In the next section, you will learn how to extract these parameters once the pipeline element is invoked after a
+pipeline was created.
 
 ## Pipeline element invocation
 
-Once users start a pipeline that uses our geofencing component, the _onInvocation_ method in our class is called. The class `ProcessorParams` includes convenient access to user-configured parameters a users has selected in the pipeline editor and information on the acutal streams that are connected to the pipeline element.
+Once users start a pipeline that uses our geofencing component, the _onInvocation_ method in our class is called. The
+class `ProcessorParams` includes convenient access to user-configured parameters a users has selected in the pipeline
+editor and information on the acutal streams that are connected to the pipeline element.
 
-Next, we are interested in the fields of the input event stream that contains the latitude and longitude value we would like to compute against the geofence center location as follows:
+Next, we are interested in the fields of the input event stream that contains the latitude and longitude value we would
+like to compute against the geofence center location as follows:
 
 ```java
-String latitudeFieldName = parameters.extractor().mappingPropertyValue("latitude-field");
-String longitudeFieldName = parameters.extractor().mappingPropertyValue("longitude-field");
+String latitudeFieldName=parameters.extractor().mappingPropertyValue("latitude-field");
+    String longitudeFieldName=parameters.extractor().mappingPropertyValue("longitude-field");
 ```
 
 We use the same `internalId` we've used to define the mapping property requirements in the `declareModel` method.
 
-Next, for extracting the geofence center coordinates, add to class variables centerLatitude and centerLongitude and assign the selected values using the following statements:
+Next, for extracting the geofence center coordinates, add to class variables centerLatitude and centerLongitude and
+assign the selected values using the following statements:
 
 ```java
-this.centerLatitude = parameters.extractor().singleValueParameter(LATITUDE_CENTER, Float.class);
-this.centerLongitude = parameters.extractor().singleValueParameter(LONGITUDE_CENTER, Float.class);
+this.centerLatitude=parameters.extractor().singleValueParameter(LATITUDE_CENTER,Float.class);
+    this.centerLongitude=parameters.extractor().singleValueParameter(LONGITUDE_CENTER,Float.class);
 ```
 
 The radius value can be extracted as follows:
 
 ```java
-int radius = parameters.extractor().singleValueParameter("radius", Float.class);
+int radius=parameters.extractor().singleValueParameter("radius",Float.class);
 ```
 
-Great! That's all we need to describe a data processor for usage in StreamPipes. Your processor class should look as follows:
+Great! That's all we need to describe a data processor for usage in StreamPipes. Your processor class should look as
+follows:
 
 ```java
 package org.apache.streampipes.pe.example;
@@ -227,58 +259,58 @@
 
 public class GeofencingProcessor extends StreamPipesDataProcessor {
 
- private static final String LATITUDE_CENTER = "latitude-center";
- private static final String LONGITUDE_CENTER = "longitude-center";
+  private static final String LATITUDE_CENTER = "latitude-center";
+  private static final String LONGITUDE_CENTER = "longitude-center";
 
- private float centerLatitude;
- private float centerLongitude;
- private String latitudeFieldName;
- private String longitudeFieldName;
- 
- private int radius;
+  private float centerLatitude;
+  private float centerLongitude;
+  private String latitudeFieldName;
+  private String longitudeFieldName;
 
- @Override
- public DataProcessorDescription declareModel() {
-  return ProcessingElementBuilder.create("org.streampipes.tutorial-geofencing")
-          .category(DataProcessorType.ENRICH)
-          .withAssets(Assets.DOCUMENTATION, Assets.ICON)
-          .withLocales(Locales.EN)
-          .requiredStream(StreamRequirementsBuilder
-                  .create()
-                  .requiredPropertyWithUnaryMapping(EpRequirements.domainPropertyReq(Geo.lat),
-                          Labels.from("latitude-field", "Latitude", "The event " +
-                                  "property containing the latitude value"), PropertyScope.MEASUREMENT_PROPERTY)
-                  .requiredPropertyWithUnaryMapping(EpRequirements.domainPropertyReq(Geo.lng),
-                          Labels.from("longitude-field", "Longitude", "The event " +
-                                  "property containing the longitude value"), PropertyScope.MEASUREMENT_PROPERTY)
-                  .build())
-          .outputStrategy(OutputStrategies.keep())
-          .requiredIntegerParameter("radius", "Geofence Size", "The size of the circular geofence in meters.", 0, 1000, 1)
-          .requiredFloatParameter(Labels.from(LATITUDE_CENTER, "Latitude", "The latitude value"))
-          .requiredFloatParameter(Labels.from(LONGITUDE_CENTER, "Longitude", "The longitude value"))
-          .build();
- }
+  private int radius;
 
- @Override
- public void onInvocation(ProcessorParams parameters, 
-                          SpOutputCollector spOutputCollector, 
-                          EventProcessorRuntimeContext runtimeContext) throws SpRuntimeException {
-  this.centerLatitude = parameters.extractor().singleValueParameter(LATITUDE_CENTER, Float.class);
-  this.centerLongitude = parameters.extractor().singleValueParameter(LONGITUDE_CENTER, Float.class);
-  this.latitudeFieldName = parameters.extractor().mappingPropertyValue("latitude-field");
-  this.longitudeFieldName = parameters.extractor().mappingPropertyValue("longitude-field");
-  this.radius = parameters.extractor().singleValueParameter("radius", Integer.class);
- }
+  @Override
+  public DataProcessorDescription declareModel() {
+    return ProcessingElementBuilder.create("org.streampipes.tutorial-geofencing")
+        .category(DataProcessorType.ENRICH)
+        .withAssets(Assets.DOCUMENTATION, Assets.ICON)
+        .withLocales(Locales.EN)
+        .requiredStream(StreamRequirementsBuilder
+            .create()
+            .requiredPropertyWithUnaryMapping(EpRequirements.domainPropertyReq(Geo.lat),
+                Labels.from("latitude-field", "Latitude", "The event " +
+                    "property containing the latitude value"), PropertyScope.MEASUREMENT_PROPERTY)
+            .requiredPropertyWithUnaryMapping(EpRequirements.domainPropertyReq(Geo.lng),
+                Labels.from("longitude-field", "Longitude", "The event " +
+                    "property containing the longitude value"), PropertyScope.MEASUREMENT_PROPERTY)
+            .build())
+        .outputStrategy(OutputStrategies.keep())
+        .requiredIntegerParameter("radius", "Geofence Size", "The size of the circular geofence in meters.", 0, 1000, 1)
+        .requiredFloatParameter(Labels.from(LATITUDE_CENTER, "Latitude", "The latitude value"))
+        .requiredFloatParameter(Labels.from(LONGITUDE_CENTER, "Longitude", "The longitude value"))
+        .build();
+  }
 
- @Override
- public void onEvent(Event event, SpOutputCollector collector) throws SpRuntimeException {
+  @Override
+  public void onInvocation(ProcessorParams parameters,
+                           SpOutputCollector spOutputCollector,
+                           EventProcessorRuntimeContext runtimeContext) throws SpRuntimeException {
+    this.centerLatitude = parameters.extractor().singleValueParameter(LATITUDE_CENTER, Float.class);
+    this.centerLongitude = parameters.extractor().singleValueParameter(LONGITUDE_CENTER, Float.class);
+    this.latitudeFieldName = parameters.extractor().mappingPropertyValue("latitude-field");
+    this.longitudeFieldName = parameters.extractor().mappingPropertyValue("longitude-field");
+    this.radius = parameters.extractor().singleValueParameter("radius", Integer.class);
+  }
 
- }
+  @Override
+  public void onEvent(Event event, SpOutputCollector collector) throws SpRuntimeException {
 
- @Override
- public void onDetach() throws SpRuntimeException {
+  }
 
- }
+  @Override
+  public void onDetach() throws SpRuntimeException {
+
+  }
 }
 
 
@@ -292,59 +324,67 @@
 
 ```java
 
-  @Override
-  public void onEvent(Event event, SpOutputCollector collector) throws SpRuntimeException {
-      float latitude = event.getFieldBySelector(latitudeFieldName).getAsPrimitive().getAsFloat();
-      float longitude = event.getFieldBySelector(longitudeFieldName).getAsPrimitive().getAsFloat();
+@Override
+public void onEvent(Event event,SpOutputCollector collector)throws SpRuntimeException{
+    float latitude=event.getFieldBySelector(latitudeFieldName).getAsPrimitive().getAsFloat();
+    float longitude=event.getFieldBySelector(longitudeFieldName).getAsPrimitive().getAsFloat();
 
-      float distance = distFrom(latitude, longitude, centerLatitude, centerLongitude);
+    float distance=distFrom(latitude,longitude,centerLatitude,centerLongitude);
 
-      if (distance <= radius) {
-      collector.collect(event);
-      }
-  }
+    if(distance<=radius){
+    collector.collect(event);
+    }
+    }
 
-  public static float distFrom(float lat1, float lng1, float lat2, float lng2) {
-    double earthRadius = 6371000;
-    double dLat = Math.toRadians(lat2-lat1);
-    double dLng = Math.toRadians(lng2-lng1);
-    double a = Math.sin(dLat/2) * Math.sin(dLat/2) +
-            Math.cos(Math.toRadians(lat1)) * Math.cos(Math.toRadians(lat2)) *
-                    Math.sin(dLng/2) * Math.sin(dLng/2);
-    double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a));
-    return (float) (earthRadius * c);
-  }
+public static float distFrom(float lat1,float lng1,float lat2,float lng2){
+    double earthRadius=6371000;
+    double dLat=Math.toRadians(lat2-lat1);
+    double dLng=Math.toRadians(lng2-lng1);
+    double a=Math.sin(dLat/2)*Math.sin(dLat/2)+
+    Math.cos(Math.toRadians(lat1))*Math.cos(Math.toRadians(lat2))*
+    Math.sin(dLng/2)*Math.sin(dLng/2);
+    double c=2*Math.atan2(Math.sqrt(a),Math.sqrt(1-a));
+    return(float)(earthRadius*c);
+    }
 
-}
+    }
 ```
 
-We won't go into details here as this isn't StreamPipes-related code, but in general the class extracts latitude and longitude fields from the input event (which is provided as a map data type) and calculates the distance between the geofence center and these coordinates.
+We won't go into details here as this isn't StreamPipes-related code, but in general the class extracts latitude and
+longitude fields from the input event (which is provided as a map data type) and calculates the distance between the
+geofence center and these coordinates.
 If the distance is below the given radius, the event is forwarded to the next operator.
 
 See the [event model](06_extend-sdk-event-model.md) guide to learn how to extract parameters from events.
 
 ## Registering the pipeline element
-The final step is to register the data processor in the `Init` method. Add the following line to the `SpServiceDefinitionBuilder`:
+
+The final step is to register the data processor in the `Init` method. Add the following line to
+the `SpServiceDefinitionBuilder`:
 
 ```java
  .registerPipelineElement(new GeofencingProcessor())
 ```
 
 ## Starting the service
-<div class="admonition tip">
-<div class="admonition-title">Tip</div>
-<p>Once you start the service, it will register in StreamPipes with the hostname. The hostname will be auto-discovered and should work out-of-the-box.
-In some cases, the detected hostname is not resolvable from within a container (where the core is running). In this case, provide a SP_HOST environment variable to override the auto-discovery.
-</p>
-</div>
 
+:::tip
 
-<div class="admonition tip">
-<div class="admonition-title">Tip</div>
-<p> The default port of all pipeline element services as defined in the `create` method is port 8090.
-       If you'd like to run multiple services at the same time on your development machine, change the port here. As an alternative, you can also provide an env variable `SP_PORT` which overrides the port settings. This is useful to use different configs for dev and prod environments.
-</p>
-</div>
+Once you start the service, it will register in StreamPipes with the hostname. The hostname will be auto-discovered and
+should work out-of-the-box.
+In some cases, the detected hostname is not resolvable from within a container (where the core is running). In this
+case, provide a SP_HOST environment variable to override the auto-discovery.
+
+:::
+
+:::tip
+
+The default port of all pipeline element services as defined in the `create` method is port 8090.
+If you'd like to run multiple services at the same time on your development machine, change the port here. As an
+alternative, you can also provide an env variable `SP_PORT` which overrides the port settings. This is useful to use
+different configs for dev and prod environments.
+
+:::
 
 Now we are ready to start our service!
 
@@ -353,7 +393,8 @@
 Execute the main method in the class `Init` we've just created.
 
 The service automatically registers itself in StreamPipes.
-To install the just created element, open the StreamPipes UI and follow the manual provided in the [user guide](03_use-install-pipeline-elements.md).
+To install the just created element, open the StreamPipes UI and follow the manual provided in
+the [user guide](03_use-install-pipeline-elements.md).
 
 ## Read more
 
diff --git a/docs/06_extend-tutorial-data-sinks.md b/docs/06_extend-tutorial-data-sinks.md
index 13064bd..69ada85 100644
--- a/docs/06_extend-tutorial-data-sinks.md
+++ b/docs/06_extend-tutorial-data-sinks.md
@@ -6,19 +6,22 @@
 
 In this tutorial, we will add a new data sink using the standalone wrapper.
 
-From an architectural point of view, we will create a self-contained service that includes the description of the data sink and a corresponding implementation.
+From an architectural point of view, we will create a self-contained service that includes the description of the data
+sink and a corresponding implementation.
 
 ## Objective
 
 We are going to create a new data sink that calls an external HTTP endpoint to forward data to an external service.
 
-For each incoming event, an external service is invoked using an HTTP POST request. In this example, we'll call an endpoint provided by [RequestBin](https://requestbin.com/).
-To setup your own endpoint, go to [https://requestbin.com/](https://requestbin.com/) and click "Create a request bin". Copy the URL of the newly created endpoint.
-
+For each incoming event, an external service is invoked using an HTTP POST request. In this example, we'll call an
+endpoint provided by [RequestBin](https://requestbin.com/).
+To setup your own endpoint, go to [https://requestbin.com/](https://requestbin.com/) and click "Create a request bin".
+Copy the URL of the newly created endpoint.
 
 ## Project setup
 
-Instead of creating a new project from scratch, we recommend to use the Maven archetype to create a new project skeleton (streampipes-archetype-extensions-jvm).
+Instead of creating a new project from scratch, we recommend to use the Maven archetype to create a new project
+skeleton (streampipes-archetype-extensions-jvm).
 Enter the following command in a command line of your choice (Apache Maven needs to be installed):
 
 ```
@@ -29,10 +32,12 @@
 
 You will see a project structure similar to the structure shown in the [archetypes](06_extend-archetypes.md) section.
 
-<div class="admonition tip">
-<div class="admonition-title">Tip</div>
-<p>Besides the basic project skeleton, the sample project also includes an example Dockerfile you can use to package your application into a Docker container.</p>
-</div>
+:::tip
+
+Besides the basic project skeleton, the sample project also includes an example Dockerfile you can use to package your
+application into a Docker container.
+
+:::
 
 Now you're ready to create your first data sink for StreamPipes!
 
@@ -68,10 +73,10 @@
         .withAssets(Assets.DOCUMENTATION, Assets.ICON)
         .withLocales(Locales.EN)
         .requiredStream(StreamRequirementsBuilder
-                .create()
-                .requiredPropertyWithNaryMapping(EpRequirements.anyProperty(), Labels.withId(
-                        "fields-to-send"), PropertyScope.NONE)
-                .build())
+            .create()
+            .requiredPropertyWithNaryMapping(EpRequirements.anyProperty(), Labels.withId(
+                "fields-to-send"), PropertyScope.NONE)
+            .build())
         .build();
   }
 
@@ -94,22 +99,33 @@
 
 ```
 
-In this class, we need to implement three methods: The `declareModel` method is used to define abstract stream requirements such as event properties that must be present in any input stream that is later connected to the element using the StreamPipes UI.
-The second method, `onInvocation` is called once a pipeline using this sink is started. The third method, `onEvent`, is called for every incoming event.
+In this class, we need to implement three methods: The `declareModel` method is used to define abstract stream
+requirements such as event properties that must be present in any input stream that is later connected to the element
+using the StreamPipes UI.
+The second method, `onInvocation` is called once a pipeline using this sink is started. The third method, `onEvent`, is
+called for every incoming event.
 
 The ``declareModel`` method describes the properties of our data sink:
-* ``category`` defines a category for this sink.
-* ``withAssets`` denotes that we will provide an external documentation file and an icon, which can be found in the ``resources`` folder
-* ``withLocales`` defines that we will provide an external language file, also available in the ``resources`` folder
-* ``requiredStream`` defines requirements any input stream connected to this sink must provide. In this case, we do not have any specific requirements, we just forward all incoming events to the REST sink. However, we want to let the user display a list of available fields from the connected input event, where users can select a subset. This is defined by defining a Mapping from the empty requirement. This will later on render a selection dialog in the pipeline editor.
 
-The ``onInvocation`` method is called when a pipeline containing the sink is started. Once a pipeline is started, we would like to extract user-defined parameters.
-In this example, we simply extract the fields selected by users that should be forwarded to the REST sink. Finally, we return a new configured event sink containing the parameters.
+* ``category`` defines a category for this sink.
+* ``withAssets`` denotes that we will provide an external documentation file and an icon, which can be found in
+  the ``resources`` folder
+* ``withLocales`` defines that we will provide an external language file, also available in the ``resources`` folder
+* ``requiredStream`` defines requirements any input stream connected to this sink must provide. In this case, we do not
+  have any specific requirements, we just forward all incoming events to the REST sink. However, we want to let the user
+  display a list of available fields from the connected input event, where users can select a subset. This is defined by
+  defining a Mapping from the empty requirement. This will later on render a selection dialog in the pipeline editor.
+
+The ``onInvocation`` method is called when a pipeline containing the sink is started. Once a pipeline is started, we
+would like to extract user-defined parameters.
+In this example, we simply extract the fields selected by users that should be forwarded to the REST sink. Finally, we
+return a new configured event sink containing the parameters.
 
 ## Pipeline element invocation
 
-Once users start a pipeline that uses our geofencing component, the _onInvocation_ method in our class is called. The class `SinkParams` includes a graph that contains information on the configuration parameters a users has selected in the pipeline editor and information on the acutal streams that are connected to the pipeline element.
-
+Once users start a pipeline that uses our geofencing component, the _onInvocation_ method in our class is called. The
+class `SinkParams` includes a graph that contains information on the configuration parameters a users has selected in
+the pipeline editor and information on the acutal streams that are connected to the pipeline element.
 
 ## Adding an implementation
 
@@ -123,6 +139,7 @@
 import com.google.common.base.Charsets;
 import org.apache.http.client.fluent.Request;
 import org.apache.http.entity.StringEntity;
+
 import org.apache.streampipes.commons.exceptions.SpRuntimeException;
 import org.apache.streampipes.dataformat.SpDataFormatDefinition;
 import org.apache.streampipes.dataformat.json.JsonDataFormatDefinition;
@@ -139,6 +156,7 @@
 import org.apache.streampipes.wrapper.context.EventSinkRuntimeContext;
 import org.apache.streampipes.wrapper.standalone.SinkParams;
 import org.apache.streampipes.wrapper.standalone.StreamPipesDataSink;
+
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -186,42 +204,51 @@
 }
 
 ```
-The only class variable you need to change right now is the REST_ENDPOINT_URL. Change this url to the URL provided by your request bin.
+
+The only class variable you need to change right now is the REST_ENDPOINT_URL. Change this url to the URL provided by
+your request bin.
 In the ``ònEvent`` method, we use a helper method to get a subset of the incoming event.
 Finally, we convert the resulting ``Map`` to a JSON string and call the endpoint.
 
-
 ## Preparing the service
+
 The final step is to register the sink as a pipeline element.
 
 Go to the class `Init` and register the sink:
+
 ```java
 .registerPipelineElement(new RestSink())
 ```
 
 ## Starting the service
-<div class="admonition tip">
-<div class="admonition-title">Tip</div>
-<p>Once you start the service, it will register in StreamPipes with the hostname. The hostname will be auto-discovered and should work out-of-the-box.
-In some cases, the detected hostname is not resolvable from within a container (where the core is running). In this case, provide a SP_HOST environment variable to override the auto-discovery.
-</p>
-</div>
 
+:::tip
 
-<div class="admonition tip">
-<div class="admonition-title">Tip</div>
-<p> The default port of all pipeline element services as defined in the `create` method is port 8090.
-       If you'd like to run multiple services at the same time on your development machine, change the port here. As an alternative, you can also provide an env variable `SP_PORT` which overrides the port settings. This is useful to use different configs for dev and prod environments.
-</p>
-</div>
+Once you start the service, it will register in StreamPipes with the hostname. The hostname will be auto-discovered and
+should work out-of-the-box.
+In some cases, the detected hostname is not resolvable from within a container (where the core is running). In this
+case, provide a SP_HOST environment variable to override the auto-discovery.
+
+:::
+
+:::tip
+
+The default port of all pipeline element services as defined in the `create` method is port 8090.
+If you'd like to run multiple services at the same time on your development machine, change the port here. As an
+alternative, you can also provide an env variable `SP_PORT` which overrides the port settings. This is useful to use
+different configs for dev and prod environments.
+
+:::
 
 Now we are ready to start our service!
 
 Configure your IDE to provide an environment variable called ``SP_DEBUG`` with value ``true`` when starting the project.
 
-Execute the main method in the class `Init` we've just created. The service automatically registers itself in StreamPipes.
+Execute the main method in the class `Init` we've just created. The service automatically registers itself in
+StreamPipes.
 
-To install the created element, open the StreamPipes UI and follow the manual provided in the [user guide](03_use-install-pipeline-elements.md).
+To install the created element, open the StreamPipes UI and follow the manual provided in
+the [user guide](03_use-install-pipeline-elements.md).
 
 ## Read more
 
diff --git a/docs/06_extend-tutorial-data-sources.md b/docs/06_extend-tutorial-data-sources.md
index 15dc21e..3aa9954 100644
--- a/docs/06_extend-tutorial-data-sources.md
+++ b/docs/06_extend-tutorial-data-sources.md
@@ -38,11 +38,11 @@
 
 You will see a project structure similar to the structure shown in the [archetypes](06_extend-archetypes.md) section.
 
-<div class="admonition tip">
-<div class="admonition-title">Tip</div>
-<p>Besides the basic project skeleton, the sample project also includes an example Dockerfile you can use to package your application into a Docker container.
-</p>
-</div>
+:::tip
+
+Besides the basic project skeleton, the sample project also includes an example Dockerfile you can use to package your application into a Docker container.
+
+:::
 
 ## Adding a data stream description
 
@@ -181,12 +181,12 @@
 
 ## Starting the service
 
-<div class="admonition tip">
-<div class="admonition-title">Tip</div>
-<p>Once you start the service, it will register in StreamPipes with the hostname. The hostname will be auto-discovered and should work out-of-the-box.
+:::tip
+
+Once you start the service, it will register in StreamPipes with the hostname. The hostname will be auto-discovered and should work out-of-the-box.
 In some cases, the detected hostname is not resolvable from within a container (where the core is running). In this case, provide a SP_HOST environment variable to override the auto-discovery.
-</p>
-</div>
+
+:::
 
 Now we are ready to start our first container!
 
diff --git a/docs/07_technicals-configuration.md b/docs/07_technicals-configuration.md
index 4c6d101..cc34383 100644
--- a/docs/07_technicals-configuration.md
+++ b/docs/07_technicals-configuration.md
@@ -5,17 +5,21 @@
 ---
 
 On this page we explain how the StreamPipes configuration works.
-StreamPipes allows the individual services (pipeline element containers and third-party services) to store configuration parameters in a distributed key-value store.
-This has the advantage that individual services do not need to store any configurations on the local file system, enabling us to run containers anywhere.
+StreamPipes allows the individual services (pipeline element containers and third-party services) to store configuration
+parameters in a distributed key-value store.
+This has the advantage that individual services do not need to store any configurations on the local file system,
+enabling us to run containers anywhere.
 As a key-value store we use [Consul](https://www.consul.io/), which is an essential service for all our services.
 
 <img src="/img/configuration/consul.png" width="50%" alt="Semantic description of data processor"/>
 
-
 ## Edit Configurations
+
 All services in StreamPipes can have configuration parameters.
-You can either change them in the consul user interface (which is by default running on port 8500) or directly in the StreamPipes Configurations Page.
-Once a new  pipeline element container is started, it is registered in Consul and the parameters can be edited in the configuration page, as shown below.
+You can either change them in the consul user interface (which is by default running on port 8500) or directly in the
+StreamPipes Configurations Page.
+Once a new pipeline element container is started, it is registered in Consul and the parameters can be edited in the
+configuration page, as shown below.
 To store changes in Consul, the update button must be clicked.
 
 <div class="my-carousel">
@@ -23,22 +27,30 @@
 </div>
 
 ## Configuration for Developers
+
 We provide a Configurations API for the use of configuration parameters in your services.
-Each processing element project has a “config” package [[Example]](https://github.com/apache/streampipes-extensions/tree/dev/streampipes-sinks-internal-jvm/src/main/java/org/streampipes/sinks/internal/jvm/config).
+Each processing element project has a “config”
+package [[Example]](https://github.com/apache/streampipes-extensions/tree/dev/streampipes-sinks-internal-jvm/src/main/java/org/streampipes/sinks/internal/jvm/config).
 This package usually contains two classes.
-One containing unique keys for the configuration values and one containing the getter and setter methods to access these values.
+One containing unique keys for the configuration values and one containing the getter and setter methods to access these
+values.
 For the naming of configuration keys, we recommend to use “SP” as a prefix.
-As we explain later, it is possible to set default configurations as environment variables, this prefix makes them unique on your server.
-A configuration entry needs a unique config key. For this key, a value can be specified containing the configuration, like for example the port number of the service.
-For each configuration, a description explaining the parameter can be provided, further the data type must be specified and whether it is a password or not.
+As we explain later, it is possible to set default configurations as environment variables, this prefix makes them
+unique on your server.
+A configuration entry needs a unique config key. For this key, a value can be specified containing the configuration,
+like for example the port number of the service.
+For each configuration, a description explaining the parameter can be provided, further the data type must be specified
+and whether it is a password or not.
 Below, the schema of a configuration item is shown on the left and an example of a port configuration on the right.
 
 <img src="/img/configuration/config_key.png" width="80%" alt="Semantic description of data processor"/>
 
-As a developer, you can add as many new configurations to services as you wish, but there are some that are required for all processing element containers.
+As a developer, you can add as many new configurations to services as you wish, but there are some that are required for
+all processing element containers.
 Those are **the host**, **the port**, and **the name** of the service.
 
 ## Default Values
+
 You can provide default values for the configurations, which are used when a configuration is read for the first time.
 The first option is to register a configuration parameter in the Config class.
 This is a fallback value, which is used if nothing else is defined.
@@ -46,13 +58,17 @@
 It is possible to provide a default value by setting an environment variable.
 In this case, the convention is that the key of a configuration parameter must be used as the environment variable.
 Now, this value is used instead of the value defined in the Config class.
-During development, the configuration values often need to be changed for debugging purposes, therefore we provide an .env file in all processing element projects and archetypes.
-This file can be used by your IDE to set the environment variables. (e.g., [Intellij Plugin](https://plugins.jetbrains.com/plugin/7861-envfile))
+During development, the configuration values often need to be changed for debugging purposes, therefore we provide an
+.env file in all processing element projects and archetypes.
+This file can be used by your IDE to set the environment variables. (
+e.g., [Intellij Plugin](https://plugins.jetbrains.com/plugin/7861-envfile))
 When you need to change the variable at runtime, you can do this in the StreamPipes configurations as explained before.
 Those changes take effect immediately without the need of a container restart.
 
-<div class="admonition warning">
-<div class="admonition-title">Installed pipeline elements</div>
-<p>Be cautious, when the configuration is used in the semantic description of a processing element which is already installed in StreamPipes, you have to reload this element in StreamPipes (my elements -> reload).
-   In addition, changes might affect already running pipelines.</p>
-</div>
+:::caution Installed pipeline elements
+
+Be cautious, when the configuration is used in the semantic description of a processing element which is already
+installed in StreamPipes, you have to reload this element in StreamPipes (my elements -> reload).
+In addition, changes might affect already running pipelines.
+
+:::
diff --git a/docs/user-guide-installation.md b/docs/user-guide-installation.md
deleted file mode 100644
index 74cf1fa..0000000
--- a/docs/user-guide-installation.md
+++ /dev/null
@@ -1,120 +0,0 @@
----
-id: user-guide-installation
-title: Installation
-sidebar_label: Installation
----
-## Prerequisites
-
-### Hardware
-
-* Docker (latest version, see instructions below)
-* Docker Compose (latest version., see instructions below)
-
-### Supported operating systems
-We rely on Docker and support three operating systems for the StreamPipes system
-
-* Linux
-* OSX
-* Windows 10
-    * Please note that older Windows versions are not compatible with Docker. Also Linux VMs under Windows might not work, due to network problems with docker.
-
-### Web Browser
-StreamPipes is a modern web application, therefore you need a recent version of Chrome (recommended), Firefox or Edge.
-
-### Docker
-You need to have Docker installed on your system before you continue with the installation guide.
-
-
-<div class="admonition info">
-<div class="admonition-title">Install Docker</div>
-<p>Go to https://docs.docker.com/installation/ and follow the instructions to install Docker for your OS. Make sure docker can be started as a non-root user (described in the installation manual, don’t forget to log out and in again) and check that Docker is installed correctly by executing docker-run hello-world</p>
-</div>
-
-<div class="admonition info">
-<div class="admonition-title">Configure Docker</div>
-<p>By default, Docker uses only a limited number of CPU cores and memory.
-       If you run StreamPipes on Windows or on a Mac you need to adjust the default settings.
-       To do that, click on the Docker icon in your tab bar and open the preferences.
-       Go to the advanced preferences and set the **number of CPUs to 6** (recommended) and the **Memory to 4GB**.
-       After changing the settings, Docker needs to be restarted.</p></div>
-
-
-## Install StreamPipes
-
-<div class="tab-content" id="myTabContent">
-    <div class="tab-pane fade show active" id="linux" role="tabpanel" aria-labelledby="linux-tab">
-        <ul style="padding-left:0">
-            <li class="installation-step">
-                <div class="wrapper-container" style="align-items: center;justify-content: center;">
-                    <div class="wrapper-step">
-                        <span class="fa-stack fa-2x">
-                             <i class="fas fa-circle fa-stack-2x sp-color-green"></i>
-                             <strong class="fa-stack-1x" style="color:white;">1</strong>
-                        </span>
-                    </div>
-                    <div class="wrapper-instruction">
-                        <a href="https://www.apache.org/dyn/mirrors/mirrors.cgi?action=download&filename=streampipes/installer/0.70.0/apache-streampipes-installer-0.70.0-incubating-source-release.zip">Download</a>
-                        the latest Apache StreamPipes release and extract the zip file to a directory of your choice.
-                    </div>
-                </div>
-            </li>
-            <li class="installation-step">
-                <div class="wrapper-container" style="align-items: center;justify-content: center;">
-                    <div class="wrapper-step">
-                        <span class="fa-stack fa-2x">
-                             <i class="fas fa-circle fa-stack-2x sp-color-green"></i>
-                             <strong class="fa-stack-1x" style="color:white;">2</strong>
-                        </span>
-                    </div>
-                    <div class="wrapper-instruction">
-                       In a command prompt, open the folder <code>/compose</code> and run <code>docker-compose up -d</code>.
-                    </div>
-                </div>
-            </li>
-            <li class="installation-step">
-                <div class="wrapper-container" style="align-items: center;justify-content: center;">
-                    <div class="wrapper-step">
-                        <span class="fa-stack fa-2x">
-                             <i class="fas fa-circle fa-stack-2x sp-color-green"></i>
-                             <strong class="fa-stack-1x" style="color:white;">3</strong>
-                        </span>
-                    </div>
-                    <div class="wrapper-instruction">
-                        Open your browser, navigate to http://localhost:80 (or the domain name of your server) and finish the setup according to the instructions below.
-                    </div>
-                </div>
-            </li>
-        </ul>
-        </div>
-    </div>
-
-## Setup StreamPipes
-
-Once you've opened the browser at the URL given above, you should see StreamPipes application as shown below.
-To set up the system, enter an email address and a password and click on install.
-At this point, it is not necessary to change anything in the advanced settings menu.
-The installation might take some time, continue by clicking on "Go to login page", once all components are successfully configured.
-
-
-On the login page, enter your credentials, then you should be forwarded to the home page.
-
-Congratulations! You've successfully managed to install StreamPipes. Now we're ready to build our first pipeline!
-
-<div class="my-carousel">
-    <img src="/img/quickstart/setup/01_register_user.png" alt="Set Up User"/>
-    <img src="/img/quickstart/setup/02_user_set_up.png" alt="SetUp StreamPipes Components"/>
-    <img src="/img/quickstart/setup/03_login.png" alt="Go to login page"/>
-    <img src="/img/quickstart/setup/04_home.png" alt="Home page"/>
-</div>
-
-<div class="admonition error">
-<div class="admonition-title">Errors during the installation process</div>
-<p>In most cases, errors during the installation are due to an under-powered system.<br/>
-If there is a problem with any of the components, please restart the whole system and delete the "config" directory on the server.
-   This directory is in the same folder as the docker-compose.yml file.<br/>
-   Please also make sure that your system meets the hardware requirements as mentioned in the first section of the installation guide.</p>
-</div>
-
-## Next Steps
-
-Now you can continue with the tutorial on page [First steps](user-guide-first-steps.md).
diff --git a/website-v2/static/css/custom-website.css b/website-v2/static/css/custom-website.css
index 89446e3..f90b0fe 100644
--- a/website-v2/static/css/custom-website.css
+++ b/website-v2/static/css/custom-website.css
@@ -61,7 +61,6 @@
 	font-family: 'Roboto', sans-serif;
 	color: #44444e;
 	font-size: 15px;
-	font-weight: 500;
 	margin-top: 0;
 	line-height: 1.9;
 }