diff --git a/Makefile.am b/Makefile.am
index 6afa99a0..938c3dae 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -1,3 +1,3 @@
 AUTOMAKE_OPTIONS = foreign
 ACLOCAL_AMFLAGS = -I m4 -I cfg
-SUBDIRS = basic-logic comment debug function gpio light link mqtt passthrough timers tls-config variable
+SUBDIRS = basic-logic comment debug function gpio light link mqtt passthrough template timers tls-config variable
diff --git a/basic-logic/switch/MyNode.cpp b/basic-logic/switch/MyNode.cpp
index 89d84bd0..1d7c942c 100644
--- a/basic-logic/switch/MyNode.cpp
+++ b/basic-logic/switch/MyNode.cpp
@@ -76,8 +76,9 @@ void MyNode::convertType(Flows::PVariable& value, Flows::VariableType vt)
 {
 	if(vt == Flows::VariableType::tInteger)
 	{
-		value->setType(vt);
+		value->setType(Flows::VariableType::tInteger64);
 		value->integerValue = Flows::Math::getNumber(value->stringValue);
+		value->integerValue64 = value->integerValue;
 	}
 	else if(vt == Flows::VariableType::tInteger64)
 	{
@@ -230,6 +231,11 @@ bool MyNode::match(Rule& rule, Flows::PVariable& value)
 {
 	try
 	{
+		if(value->type == Flows::VariableType::tInteger)
+		{
+			value->setType(Flows::VariableType::tInteger64);
+			value->integerValue64 = value->integerValue;
+		}
 		if(rule.previousValue)
 		{
 			rule.v = _previousInputValue;
diff --git a/comment/comment.hni b/comment/comment.hni
index 64fb3e28..0c3ef07b 100644
--- a/comment/comment.hni
+++ b/comment/comment.hni
@@ -22,7 +22,7 @@
 </script>
 <script type="text/javascript">
     RED.nodes.registerType('comment',{
-        category: 'function',
+        category: 'general',
         color:"#ffffff",
         defaults: {
             name: {value:""},
diff --git a/configure.ac b/configure.ac
index bd6ab265..2448caa4 100644
--- a/configure.ac
+++ b/configure.ac
@@ -62,4 +62,4 @@ esac
 #AC_ARG_ENABLE(debug, AS_HELP_STRING([--enable-debug], [enable debugging, default: no]), [case "${enableval}" in yes) debug=true ;; no)  debug=false ;; *)   AC_MSG_ERROR([bad value ${enableval} for --enable-debug]) ;; esac], [debug=false])
 #AM_CONDITIONAL(DEBUG, test x"$debug" = x"true")
 
-AC_OUTPUT(Makefile basic-logic/Makefile comment/Makefile debug/Makefile function/Makefile gpio/Makefile light/Makefile link/Makefile mqtt/Makefile passthrough/Makefile timers/Makefile tls-config/Makefile variable/Makefile)
+AC_OUTPUT(Makefile basic-logic/Makefile comment/Makefile debug/Makefile function/Makefile gpio/Makefile light/Makefile link/Makefile mqtt/Makefile passthrough/Makefile template/Makefile timers/Makefile tls-config/Makefile variable/Makefile)
diff --git a/debug/debug.hni b/debug/debug.hni
index 9e7e9b9c..e8e46510 100644
--- a/debug/debug.hni
+++ b/debug/debug.hni
@@ -472,7 +472,6 @@
                 } else if (msg.event === "mouseLeave") {
                     options.messageMouseLeave(msg.id);
                 } else if (msg.event === "mouseClick") {
-                	console.log("Moin0");
                     options.messageSourceClick(msg.id);
                 } else if (msg.event === "clear") {
                     options.clear();
diff --git a/function/function.php b/function/function.php
index e3f7e178..0af43946 100644
--- a/function/function.php
+++ b/function/function.php
@@ -1,4 +1,6 @@
 <?php
+declare(strict_types=1);
+
 $nodeInfo;
 
 function getNodeData(string $key)
@@ -13,50 +15,95 @@ function setNodeData(string $key, $value)
 	\Homegear\Homegear::setNodeData($nodeInfo['id'], $key, $value);
 }
 
+function getFlowData(string $key)
+{
+	global $nodeInfo;
+	return \Homegear\Homegear::getNodeData($nodeInfo['info']['z'], $key);
+}
+
+function setFlowData(string $key, $value)
+{
+	global $nodeInfo;
+	\Homegear\Homegear::setNodeData($nodeInfo['info']['z'], $key, $value);
+}
+
+function getGlobalData(string $key)
+{
+	global $nodeInfo;
+	return \Homegear\Homegear::getNodeData('global', $key);
+}
+
+function setGlobalData(string $key, $value)
+{
+	global $nodeInfo;
+	\Homegear\Homegear::setNodeData('global', $key, $value);
+}
+
 function output(int $outputIndex, array $message)
 {
 	global $nodeInfo;
 	\Homegear\Homegear::nodeOutput($nodeInfo['id'], $outputIndex, $message);
 }
 
-function executeCode(int $inputIndex, array $message)
+class HomegearNode extends HomegearNodeBase
 {
-	global $nodeInfo;
-	$code = $nodeInfo["info"]["func"];
-	$hg = new \Homegear\Homegear();
-	return eval($code);
+
+private $hg = NULL;
+private $nodeInfo = NULL;
+
+public function __construct()
+{
+	$this->hg = new \Homegear\Homegear();
 }
 
-function input(array $localNodeInfo, int $inputIndex, array $message)
+public function executeCode(int $inputIndex, array $message)
+{
+	try
+	{
+		$code = $this->nodeInfo["info"]["func"];
+		$hg = new \Homegear\Homegear();
+		return eval($code);
+	}
+	catch(Exception $e)
+	{
+		$this->log(2, $e->message);
+	}
+	return NULL;
+}
+
+public function input(array $nodeInfoLocal, int $inputIndex, array $message)
 {
 	global $nodeInfo;
-	$nodeInfo = $localNodeInfo;
-	$result = executeCode($inputIndex, $message);
+	$nodeInfo = $nodeInfoLocal;
+	$this->nodeInfo = $nodeInfoLocal;
+	$result = $this->executeCode($inputIndex, $message);
 	if($result)
 	{
 		if(array_key_exists('payload', $result))
 		{
-			\Homegear\Homegear::nodeOutput($nodeInfo['id'], 0, $result);
+			$this->hg->nodeOutput($this->nodeInfo['id'], 0, $result);
 		}
 		else
 		{
-			$wireCount = count($nodeInfo['wiresOut']);
+			$wireCount = count($this->nodeInfo['wiresOut']);
 			foreach($result as $index => $value)
 			{
 				if(!$value || !is_numeric($index) || $index >= $wireCount) continue;
 				if(array_key_exists('payload', $value))
 				{
-					\Homegear\Homegear::nodeOutput($nodeInfo['id'], $index, $value);
+					$this->hg->nodeOutput($this->nodeInfo['id'], $index, $value);
 				}
 				else
 				{
 					foreach($value as $value2)
 					{
 						if(!$value2) continue;
-						\Homegear\Homegear::nodeOutput($nodeInfo['id'], $index, $value2);
+						$this->hg->nodeOutput($this->nodeInfo['id'], $index, $value2);
 					}
 				}
 			}
 		}
 	}
 }
+
+}
diff --git a/function/locales/en-US/function b/function/locales/en-US/function
index 9d03fd73..75234a8c 100644
--- a/function/locales/en-US/function
+++ b/function/locales/en-US/function
@@ -9,7 +9,7 @@
       },
       "tip": "Tip: See the Info tab for help writing functions.",
       "paletteHelp": "<p>A function block where you can write PHP code to do more interesting things.</p>",
-      "help": "<p>A function block where you can write PHP code to do more interesting things.</p><p>By convention it will have a <code>$message['payload']</code> property containing the body of the message.</p><p>The message is passed in as an associative array called <code>$message</code>. Information about the node can be found in the associative array <code>$nodeInfo</code>. The input index is passed in <code>$inputIndex</code></p><h4>Data storage</h4><p>Data can be stored by calling <code>setNodeData($key, $value)</code> and retrieved with <code>getNodeData($key)</code>.</p><h4>Sending messages</h4><p>The function can either return the messages it wants to pass on to the next nodes in the flow, or can call <code>output($outputIndex, $message)</code>.</p><p>It can return:</p><ul><li>a single message object - passed to nodes connected to the first output</li><li>an array of message objects - passed to nodes connected to the corresponding outputs</li></ul><p>If any element of the array is itself an array of messages, multiple messages are sent to the corresponding output.</p><p>If NULL is returned, either by itself or as an element of the array, no message is passed on.</p><p>See the <a target=\"_blank\" href=\"https://ref.homegear.eu\">online reference</a> for more help.</p>"
+      "help": "<p>A function block where you can write PHP code to do more interesting things.</p><p>By convention it will have a <code>$message['payload']</code> property containing the body of the message.</p><p>The message is passed in as an associative array called <code>$message</code>. Information about the node can be found in the associative array <code>$nodeInfo</code>. The input index is passed in <code>$inputIndex</code></p><h4>Data storage</h4><p>Data can be stored by calling <code>setNodeData($key, $value)</code>, <code>setFlowData($key, $value)</code> or <code>setGlobalData($key, $value)</code> and retrieved with <code>getNodeData($key)</code>, <code>getFlowData($key)</code> or <code>getGlobalData($key)</code>.</p><h4>Sending messages</h4><p>The function can either return the messages it wants to pass on to the next nodes in the flow, or can call <code>output($outputIndex, $message)</code>.</p><p>It can return:</p><ul><li>a single message object - passed to nodes connected to the first output</li><li>an array of message objects - passed to nodes connected to the corresponding outputs</li></ul><p>If any element of the array is itself an array of messages, multiple messages are sent to the corresponding output.</p><p>If NULL is returned, either by itself or as an element of the array, no message is passed on.</p><p>See the <a target=\"_blank\" href=\"https://ref.homegear.eu\">online reference</a> for more help.</p>"
     }
   }
 }
\ No newline at end of file
diff --git a/light/MyNode.cpp b/light/MyNode.cpp
index ce742753..8ff39b45 100644
--- a/light/MyNode.cpp
+++ b/light/MyNode.cpp
@@ -69,12 +69,17 @@ bool MyNode::init(Flows::PNodeInfo info)
 		}
 
 		settingsIterator = info->info->structValue->find("lighttype");
-		if(settingsIterator != info->info->structValue->end()) _isDimmer = settingsIterator->second->stringValue == "dimmer";
+		if(settingsIterator != info->info->structValue->end())
+		{
+			std::string lightType = settingsIterator->second->stringValue;
+			if(lightType == "dimmerstate") _lightType = LightType::dimmerState;
+			else if(lightType == "dimmer") _lightType = LightType::dimmer;
+		}
 
 		settingsIterator = info->info->structValue->find("twoinputs");
 		if(settingsIterator != info->info->structValue->end()) _twoInputs = settingsIterator->second->booleanValue;
 
-		if(_isDimmer)
+		if(_lightType == LightType::dimmerState)
 		{
 			std::string offValue = "0";
 			settingsIterator = info->info->structValue->find("offvalue");
@@ -90,6 +95,52 @@ bool MyNode::init(Flows::PNodeInfo info)
 			if(offValue.find('.') != std::string::npos) _offValue = std::make_shared<Flows::Variable>(Flows::Math::getDouble(offValue));
 			else _offValue = std::make_shared<Flows::Variable>(Flows::Math::getNumber(offValue));
 		}
+		else if(_lightType == LightType::dimmer)
+		{
+			std::string offValue = "0";
+			settingsIterator = info->info->structValue->find("offvalue2");
+			if(settingsIterator != info->info->structValue->end()) offValue = settingsIterator->second->stringValue;
+
+			std::string minValue = "15";
+			settingsIterator = info->info->structValue->find("minvalue");
+			if(settingsIterator != info->info->structValue->end()) minValue = settingsIterator->second->stringValue;
+
+			std::string maxValue = "0";
+			settingsIterator = info->info->structValue->find("maxvalue");
+			if(settingsIterator != info->info->structValue->end()) maxValue = settingsIterator->second->stringValue;
+
+			settingsIterator = info->info->structValue->find("step");
+			if(settingsIterator != info->info->structValue->end()) _step = Flows::Math::getDouble(settingsIterator->second->stringValue);
+			if(_step <= 0.0) _step = 0.001;
+
+			settingsIterator = info->info->structValue->find("factor");
+			if(settingsIterator != info->info->structValue->end()) _factor = Flows::Math::getDouble(settingsIterator->second->stringValue);
+			if(_factor < 0) _factor = 0;
+
+			settingsIterator = info->info->structValue->find("interval");
+			if(settingsIterator != info->info->structValue->end()) _interval = Flows::Math::getDouble(settingsIterator->second->stringValue);
+			if(_interval < 10) _interval = 10;
+
+			if(offValue.find('.') != std::string::npos) _offValue = std::make_shared<Flows::Variable>(Flows::Math::getDouble(offValue));
+			else _offValue = std::make_shared<Flows::Variable>(Flows::Math::getNumber(offValue));
+
+			if(minValue.find('.') != std::string::npos) _minValue = std::make_shared<Flows::Variable>(Flows::Math::getDouble(minValue));
+			else
+			{
+				_minValue = std::make_shared<Flows::Variable>(Flows::Math::getNumber(minValue));
+				_minValue->floatValue = _minValue->integerValue;
+			}
+
+			if(maxValue.find('.') != std::string::npos) _maxValue = std::make_shared<Flows::Variable>(Flows::Math::getDouble(maxValue));
+			else
+			{
+				_maxValue = std::make_shared<Flows::Variable>(Flows::Math::getNumber(maxValue));
+				_maxValue->floatValue = _maxValue->integerValue;
+			}
+
+			_onValue = getNodeData("currentvalue");
+			if(!(*_onValue)) _onValue = _maxValue;
+		}
 		else
 		{
 			_onValue = std::make_shared<Flows::Variable>(true);
@@ -109,22 +160,127 @@ bool MyNode::init(Flows::PNodeInfo info)
 	return false;
 }
 
-void MyNode::input(Flows::PNodeInfo info, uint32_t index, Flows::PVariable message)
+void MyNode::stop()
+{
+	try
+	{
+		_stopThread = true;
+	}
+	catch(const std::exception& ex)
+	{
+		Flows::Output::printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__, ex.what());
+	}
+	catch(...)
+	{
+		Flows::Output::printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__);
+	}
+}
+
+void MyNode::waitForStop()
+{
+	try
+	{
+		std::lock_guard<std::mutex> timerGuard(_timerMutex);
+		if(_timerThread.joinable()) _timerThread.join();
+	}
+	catch(const std::exception& ex)
+	{
+		Flows::Output::printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__, ex.what());
+	}
+	catch(...)
+	{
+		Flows::Output::printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__);
+	}
+}
+
+void MyNode::dim(bool up)
 {
 	try
 	{
-		bool value = message->structValue->at("payload")->booleanValue;
-		if(_twoInputs && !value) return;
-		bool state = _twoInputs ? (index == 0 ? true : false) : value;
 		Flows::PArray parameters = std::make_shared<Flows::Array>();
 		parameters->reserve(4);
 		parameters->push_back(std::make_shared<Flows::Variable>(_peerId));
 		parameters->push_back(std::make_shared<Flows::Variable>(_channel));
 		parameters->push_back(std::make_shared<Flows::Variable>(_variable));
-		parameters->push_back(state ? _onValue : _offValue);
+		Flows::PVariable startValue = invoke("getValue", parameters);
+
+		double currentValue = 0;
+		if(startValue->type == Flows::VariableType::tInteger) currentValue = startValue->integerValue;
+		else if(startValue->type == Flows::VariableType::tInteger64) currentValue = startValue->integerValue64;
+		else
+		{
+			startValue->type = Flows::VariableType::tFloat;
+			currentValue = startValue->floatValue;
+		}
 
-		Flows::PVariable result = invoke("setValue", parameters);
-		if(result->errorStruct) Flows::Output::printError("Error setting variable (Peer ID: " + std::to_string(_peerId) + ", channel: " + std::to_string(_channel) + ", name: " + _variable + "): " + result->structValue->at("faultString")->stringValue);
+		parameters->push_back(startValue);
+
+		while(!_stopThread)
+		{
+			if(up) currentValue += (_step + (_factor * currentValue));
+			else currentValue -= (_step + (_factor * currentValue));
+
+			if(currentValue > _maxValue->floatValue) currentValue = _maxValue->floatValue;
+			else if(currentValue < _minValue->floatValue) currentValue = _minValue->floatValue;
+
+			if(startValue->type == Flows::VariableType::tInteger) parameters->at(3)->integerValue = std::lround(currentValue);
+			else if(startValue->type == Flows::VariableType::tInteger64) parameters->at(3)->integerValue64 = std::lround(currentValue);
+			else if(startValue->type == Flows::VariableType::tFloat) parameters->at(3)->floatValue = currentValue;
+			invoke("setValue", parameters);
+			std::this_thread::sleep_for(std::chrono::milliseconds(_interval));
+			if(up && currentValue == _maxValue->floatValue) break;
+			else if(!up && currentValue == _minValue->floatValue) break;
+		}
+
+		setNodeData("currentvalue", startValue);
+		_onValue = startValue;
+	}
+	catch(const std::exception& ex)
+	{
+		Flows::Output::printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__, ex.what());
+	}
+	catch(...)
+	{
+		Flows::Output::printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__);
+	}
+}
+
+void MyNode::input(Flows::PNodeInfo info, uint32_t index, Flows::PVariable message)
+{
+	try
+	{
+		bool value = *(message->structValue->at("payload"));
+
+		if(_lightType == LightType::dimmer && index > 0)
+		{
+			std::lock_guard<std::mutex> timerGuard(_timerMutex);
+			_stopThread = true;
+			if(value)
+			{
+				if(_timerThread.joinable()) _timerThread.join();
+				_stopThread = false;
+				_timerThread = std::thread(&MyNode::dim, this, index == 1);
+			}
+			else
+			{
+				if(_timerThread.joinable()) _timerThread.join();
+			}
+		}
+		else
+		{
+			Flows::PArray parameters = std::make_shared<Flows::Array>();
+			parameters->reserve(4);
+			parameters->push_back(std::make_shared<Flows::Variable>(_peerId));
+			parameters->push_back(std::make_shared<Flows::Variable>(_channel));
+			parameters->push_back(std::make_shared<Flows::Variable>(_variable));
+
+			if(_twoInputs && !value) return;
+			bool state = _twoInputs ? (index == 0 ? true : false) : value;
+			parameters->push_back(state ? _onValue : _offValue);
+
+			Flows::PVariable result = invoke("setValue", parameters);
+			if(result->errorStruct) Flows::Output::printError("Error setting variable (Peer ID: " + std::to_string(_peerId) + ", channel: " + std::to_string(_channel) + ", name: " + _variable + "): " + result->structValue->at("faultString")->stringValue);
+		}
 	}
 	catch(const std::exception& ex)
 	{
diff --git a/light/MyNode.h b/light/MyNode.h
index f1e10de3..081356f8 100644
--- a/light/MyNode.h
+++ b/light/MyNode.h
@@ -31,6 +31,7 @@
 #define MYNODE_H_
 
 #include <homegear-node/INode.h>
+#include <thread>
 
 namespace MyNode
 {
@@ -38,20 +39,39 @@ namespace MyNode
 class MyNode: public Flows::INode
 {
 public:
+	enum class LightType
+	{
+		switchState,
+		dimmerState,
+		dimmer
+	};
+
 	MyNode(std::string path, std::string nodeNamespace, std::string type, const std::atomic_bool* frontendConnected);
 	virtual ~MyNode();
 
 	virtual bool init(Flows::PNodeInfo info);
+	virtual void stop();
+	virtual void waitForStop();
 private:
 	uint64_t _peerId = 0;
 	int32_t _channel = -1;
 	std::string _variable;
 	bool _twoInputs = false;
-	bool _isDimmer = false;
+	LightType _lightType = LightType::switchState;
+	double _step = 1.0;
+	double _factor = 0.0;
+	int32_t _interval = 0;
+
+	std::mutex _timerMutex;
+	std::atomic_bool _stopThread;
+	std::thread _timerThread;
 
 	Flows::PVariable _onValue;
 	Flows::PVariable _offValue;
+	Flows::PVariable _minValue;
+	Flows::PVariable _maxValue;
 
+	void dim(bool up);
 	virtual void input(Flows::PNodeInfo info, uint32_t index, Flows::PVariable message);
 };
 
diff --git a/light/light.hni b/light/light.hni
index 070fa3f8..9cdaa006 100644
--- a/light/light.hni
+++ b/light/light.hni
@@ -3,7 +3,7 @@
     "name": "light",
     "readableName": "Light",
     "version": "0.0.1",
-    "maxThreadCount": 0
+    "maxThreadCount": 1
 }
 </script>
 <script type="text/x-red" data-template-name="light">
@@ -11,19 +11,20 @@
         <label style="width: 110px;" for="node-input-name"><i class="fa fa-tag"></i> <span data-i18n="light.label.name"></span></label>
         <input style="width: 65%;" type="text" id="node-input-name" data-i18n="[placeholder]light.label.name">
     </div>
-    <div class="form-row">
-        <label>&nbsp;</label>
-        <input type="checkbox" id="node-input-twoinputs" style="display: inline-block; width: auto; vertical-align: top;">        
-        <label for="node-input-twoinputs" style="width: 65%" data-i18n="light.label.twoinputs"></label>
-    </div>
     <div class="form-row">
         <label style="width: 110px;" for="node-input-lighttype"><i class="fa fa-random"></i> <span data-i18n="light.label.lighttype"></span></label>
         <select type="text" id="node-input-lighttype" style="display: inline-block; width: 65%;">
             <option value="switch" data-i18n="light.label.switch"></option>
+            <option value="dimmerstate" data-i18n="light.label.dimmerstate"></option>
             <option value="dimmer" data-i18n="light.label.dimmer"></option>
         </select>
     </div>
-    <div id="node-input-dimmer" class="form-row hide">
+    <div id="node-input-twoinputs-container" class="form-row hide">
+        <label>&nbsp;</label>
+        <input type="checkbox" id="node-input-twoinputs" style="display: inline-block; width: auto; vertical-align: top;">        
+        <label for="node-input-twoinputs" style="width: 65%" data-i18n="light.label.twoinputs"></label>
+    </div>
+    <div id="node-input-dimmerstate" class="form-row hide">
         <div class="form-row">
             <label style="width: 80px; margin-left: 20px; margin-right: 10px;" for="node-input-offvalue"><span data-i18n="light.label.offvalue"></span></label>
             <input style="width: 65%;" type="text" id="node-input-offvalue">
@@ -33,6 +34,32 @@
             <input style="width: 65%;" type="text" id="node-input-onvalue">
         </div>
     </div>
+    <div id="node-input-dimmer" class="form-row hide">
+        <div class="form-row">
+            <label style="width: 80px; margin-left: 20px; margin-right: 10px;" for="node-input-offvalue2"><span data-i18n="light.label.offvalue"></span></label>
+            <input style="width: 65%;" type="text" id="node-input-offvalue2">
+        </div>
+        <div class="form-row">
+            <label style="width: 80px; margin-left: 20px; margin-right: 10px;" for="node-input-minvalue"><span data-i18n="light.label.minvalue"></span></label>
+            <input style="width: 65%;" type="text" id="node-input-minvalue">
+        </div>
+        <div class="form-row">
+            <label style="width: 80px; margin-left: 20px; margin-right: 10px;" for="node-input-maxvalue"><span data-i18n="light.label.maxvalue"></span></label>
+            <input style="width: 65%;" type="text" id="node-input-maxvalue">
+        </div>
+        <div class="form-row">
+            <label style="width: 80px; margin-left: 20px; margin-right: 10px;" for="node-input-step"><span data-i18n="light.label.step"></span></label>
+            <input style="width: 65%;" type="text" id="node-input-step">
+        </div>
+        <div class="form-row">
+            <label style="width: 80px; margin-left: 20px; margin-right: 10px;" for="node-input-factor"><span data-i18n="light.label.factor"></span></label>
+            <input style="width: 65%;" type="text" id="node-input-factor">
+        </div>
+        <div class="form-row">
+            <label style="width: 80px; margin-left: 20px; margin-right: 10px;" for="node-input-interval"><span data-i18n="light.label.interval"></span></label>
+            <input style="width: 65%;" type="text" id="node-input-interval">
+        </div>
+    </div>
     <div class="form-row">
         <label style="width: 110px;" for="node-input-variabletype"><i class="fa fa-random"></i> <span data-i18n="light.label.variabletype"></span></label>
         <select type="text" id="node-input-variabletype" style="display: inline-block; width: 65%;">
@@ -84,8 +111,14 @@
             variabletext: {value:"",validate: function(v) { if(this.variabletype == "device") return true; else return v != ""; }},
             
             lighttype: {value:"switch"},
-            offvalue: {value:"0",validate:RED.validators.number()},
-            onvalue: {value:"100",validate:RED.validators.number()},
+            offvalue: {value:"0",validate: function(v) { if(this.lighttype == "switch" || this.lighttype == "dimmer") return true; else return $.isNumeric(v); }},
+            onvalue: {value:"100",validate: function(v) { if(this.lighttype == "switch" || this.lighttype == "dimmer") return true; else return $.isNumeric(v); }},
+            offvalue2: {value:"0",validate: function(v) { if(this.lighttype == "switch" || this.lighttype == "dimmerstate") return true; else return $.isNumeric(v); }},
+            minvalue: {value:"15",validate: function(v) { if(this.lighttype == "switch" || this.lighttype == "dimmerstate") return true; else return $.isNumeric(v); }},
+            maxvalue: {value:"100",validate: function(v) { if(this.lighttype == "switch" || this.lighttype == "dimmerstate") return true; else return $.isNumeric(v); }},
+            step: {value:"1",validate: function(v) { if(this.lighttype == "switch" || this.lighttype == "dimmerstate") return true; else return $.isNumeric(v); }},
+            factor: {value:"0.03",validate: function(v) { if(this.lighttype == "switch" || this.lighttype == "dimmerstate") return true; else return $.isNumeric(v); }},
+            interval: {value:"100",validate: function(v) { if(this.lighttype == "switch" || this.lighttype == "dimmerstate") return true; else return $.isNumeric(v); }},
             twoinputs: {value:false},
             inputs: {value:1},
             name: {value:""}
@@ -314,10 +347,20 @@
             //}}}
 
             function updateSwitchOptions() {
-                if ($("#node-input-lighttype").val() == "dimmer") {
-                    $("#node-input-dimmer").show();
-                } else {
+                var lightType = $("#node-input-lighttype").val();
+                if (lightType == "dimmerstate") {
+                    $("#node-input-dimmerstate").show();
                     $("#node-input-dimmer").hide();
+                    $("#node-input-twoinputs-container").show();
+                } else if(lightType == "switch") {
+                    $("#node-input-dimmerstate").hide();
+                    $("#node-input-dimmer").hide();
+                    $("#node-input-twoinputs-container").show();
+                } else {
+                    $("#node-input-dimmerstate").hide();
+                    $("#node-input-dimmer").show();
+                    $("#node-input-twoinputs-container").hide();
+                    $("#node-input-twoinputs").prop("checked", false);
                 }
             }
             updateSwitchOptions();
@@ -326,7 +369,8 @@
             });
         },
         oneditsave: function() {
-            this.inputs = $("#node-input-twoinputs").prop('checked') ? 2 : 1;
+            if($("#node-input-lighttype").val() == "dimmer") this.inputs = 3;
+            else this.inputs = $("#node-input-twoinputs").prop('checked') ? 2 : 1;
         }
     });
 </script>
diff --git a/light/locales/en-US/light b/light/locales/en-US/light
index 77e57549..852ebdcc 100644
--- a/light/locales/en-US/light
+++ b/light/locales/en-US/light
@@ -13,9 +13,15 @@
         "name": "Name",
         "lighttype": "Light type",
         "switch": "Switch",
+        "dimmerstate": "Dimmer state",
         "dimmer": "Dimmer",
         "offvalue": "Value off",
         "onvalue": "Value on",
+        "minvalue": "Min. value",
+        "maxvalue": "Max. value",
+        "step": "Min. step",
+        "factor": "Factor",
+        "interval": "Interval",
         "twoinputs": "2-channel input"
       },
       "paletteHelp": "<p>Switches a light or a socket.</p>",
diff --git a/mqtt/mqtt-broker/MyNode.cpp b/mqtt/mqtt-broker/MyNode.cpp
index 1b2f70df..f84e40d7 100644
--- a/mqtt/mqtt-broker/MyNode.cpp
+++ b/mqtt/mqtt-broker/MyNode.cpp
@@ -153,6 +153,24 @@ void MyNode::waitForStop()
 	}
 }
 
+Flows::PVariable MyNode::getConfigParameterIncoming(std::string name)
+{
+	try
+	{
+		auto settingsIterator = _nodeInfo->info->structValue->find(name);
+		if(settingsIterator != _nodeInfo->info->structValue->end()) return settingsIterator->second;
+	}
+	catch(const std::exception& ex)
+	{
+		Flows::Output::printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__, ex.what());
+	}
+	catch(...)
+	{
+		Flows::Output::printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__);
+	}
+	return std::make_shared<Flows::Variable>();
+}
+
 //{{{ RPC methods
 Flows::PVariable MyNode::publish(Flows::PArray& parameters)
 {
diff --git a/mqtt/mqtt-broker/MyNode.h b/mqtt/mqtt-broker/MyNode.h
index a44a56b0..9a53d13a 100644
--- a/mqtt/mqtt-broker/MyNode.h
+++ b/mqtt/mqtt-broker/MyNode.h
@@ -46,6 +46,8 @@ class MyNode: public Flows::INode
 	virtual bool start();
 	virtual void stop();
 	virtual void waitForStop();
+
+	virtual Flows::PVariable getConfigParameterIncoming(std::string name);
 private:
 	Flows::PNodeInfo _nodeInfo;
 	std::unique_ptr<Mqtt> _mqtt;
diff --git a/passthrough/passthrough.hni b/passthrough/passthrough.hni
index 001ac52e..304e6310 100644
--- a/passthrough/passthrough.hni
+++ b/passthrough/passthrough.hni
@@ -19,7 +19,7 @@
 </script>
 <script type="text/javascript">
 	RED.nodes.registerType('passthrough',{
-        category: 'filter',
+        category: 'general',
         namespace: 'passthrough',
         color: "#C0DEED",
         defaults: {
diff --git a/template/Factory.cpp b/template/Factory.cpp
new file mode 100644
index 00000000..6304ad24
--- /dev/null
+++ b/template/Factory.cpp
@@ -0,0 +1,42 @@
+/* Copyright 2013-2017 Sathya Laufer
+ *
+ * Homegear is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Homegear is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Homegear.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * In addition, as a special exception, the copyright holders give
+ * permission to link the code of portions of this program with the
+ * OpenSSL library under certain conditions as described in each
+ * individual source file, and distribute linked combinations
+ * including the two.
+ * You must obey the GNU General Public License in all respects
+ * for all of the code used other than OpenSSL.  If you modify
+ * file(s) with this exception, you may extend this exception to your
+ * version of the file(s), but you are not obligated to do so.  If you
+ * do not wish to do so, delete this exception statement from your
+ * version.  If you delete this exception statement from all source
+ * files in the program, then also delete it here.
+ */
+
+#include "Factory.h"
+#include "MyNode.h"
+#include "../config.h"
+
+Flows::INode* MyFactory::createNode(std::string path, std::string nodeNamespace, std::string type, const std::atomic_bool* frontendConnected)
+{
+	return new MyNode::MyNode(path, nodeNamespace, type, frontendConnected);
+}
+
+Flows::NodeFactory* getFactory()
+{
+	return (Flows::NodeFactory*) (new MyFactory);
+}
diff --git a/template/Factory.h b/template/Factory.h
new file mode 100644
index 00000000..6e79b886
--- /dev/null
+++ b/template/Factory.h
@@ -0,0 +1,44 @@
+/* Copyright 2013-2017 Sathya Laufer
+ *
+ * Homegear is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Homegear is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Homegear.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * In addition, as a special exception, the copyright holders give
+ * permission to link the code of portions of this program with the
+ * OpenSSL library under certain conditions as described in each
+ * individual source file, and distribute linked combinations
+ * including the two.
+ * You must obey the GNU General Public License in all respects
+ * for all of the code used other than OpenSSL.  If you modify
+ * file(s) with this exception, you may extend this exception to your
+ * version of the file(s), but you are not obligated to do so.  If you
+ * do not wish to do so, delete this exception statement from your
+ * version.  If you delete this exception statement from all source
+ * files in the program, then also delete it here.
+ */
+
+#ifndef FACTORY_H
+#define FACTORY_H
+
+#include <homegear-node/NodeFactory.h>
+#include "MyNode.h"
+
+class MyFactory : Flows::NodeFactory
+{
+public:
+	virtual Flows::INode* createNode(std::string path, std::string nodeNamespace, std::string type, const std::atomic_bool* frontendConnected);
+};
+
+extern "C" Flows::NodeFactory* getFactory();
+
+#endif
diff --git a/template/Makefile.am b/template/Makefile.am
new file mode 100644
index 00000000..914087e7
--- /dev/null
+++ b/template/Makefile.am
@@ -0,0 +1,16 @@
+AUTOMAKE_OPTIONS = subdir-objects
+
+AM_CPPFLAGS = -Wall -std=c++11 -DFORTIFY_SOURCE=2 -DGCRYPT_NO_DEPRECATED
+AM_LDFLAGS = -Wl,-rpath=/lib/homegear -Wl,-rpath=/usr/lib/homegear -Wl,-rpath=/usr/local/lib/homegear
+LIBS += -Wl,-Bdynamic -lhomegear-node
+
+libdir = $(localstatedir)/lib/homegear/flows/nodes/template
+lib_LTLIBRARIES = template.la
+template_la_SOURCES = Factory.cpp MyNode.cpp
+template_la_LDFLAGS =-module -avoid-version -shared
+template_ladir = $(libdir)
+template_la_DATA = template.hni
+locale_en_usdir = $(libdir)/locales/en-US
+locale_en_us_DATA = locales/en-US/template
+install-exec-hook:
+	rm -f $(DESTDIR)$(libdir)/template.la
diff --git a/template/MyNode.cpp b/template/MyNode.cpp
new file mode 100644
index 00000000..f998b573
--- /dev/null
+++ b/template/MyNode.cpp
@@ -0,0 +1,194 @@
+/* Copyright 2013-2017 Sathya Laufer
+ *
+ * Homegear is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Homegear is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Homegear.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * In addition, as a special exception, the copyright holders give
+ * permission to link the code of portions of this program with the
+ * OpenSSL library under certain conditions as described in each
+ * individual source file, and distribute linked combinations
+ * including the two.
+ * You must obey the GNU General Public License in all respects
+ * for all of the code used other than OpenSSL.  If you modify
+ * file(s) with this exception, you may extend this exception to your
+ * version of the file(s), but you are not obligated to do so.  If you
+ * do not wish to do so, delete this exception statement from your
+ * version.  If you delete this exception statement from all source
+ * files in the program, then also delete it here.
+ */
+
+#include "MyNode.h"
+
+namespace MyNode
+{
+
+MyNode::MyNode(std::string path, std::string nodeNamespace, std::string type, const std::atomic_bool* frontendConnected) : Flows::INode(path, nodeNamespace, type, frontendConnected)
+{
+}
+
+MyNode::~MyNode()
+{
+}
+
+bool MyNode::init(Flows::PNodeInfo info)
+{
+	try
+	{
+		_nodeInfo = info;
+
+		auto settingsIterator = info->info->structValue->find("template");
+		if(settingsIterator != info->info->structValue->end()) _plainTemplate = settingsIterator->second->stringValue;
+		_template.reset(new kainjow::mustache::mustache(_plainTemplate));
+
+		settingsIterator = info->info->structValue->find("syntax");
+		if(settingsIterator != info->info->structValue->end()) _mustache = settingsIterator->second->stringValue == "mustache";
+
+		settingsIterator = info->info->structValue->find("output");
+		if(settingsIterator != info->info->structValue->end()) _parseJson = settingsIterator->second->stringValue == "json";
+
+		settingsIterator = info->info->structValue->find("field");
+		if(settingsIterator != info->info->structValue->end()) _field = settingsIterator->second->stringValue;
+
+		return true;
+	}
+	catch(const std::exception& ex)
+	{
+		Flows::Output::printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__, ex.what());
+	}
+	catch(...)
+	{
+		Flows::Output::printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__);
+	}
+	return false;
+}
+
+void MyNode::addData(bool global, std::string key)
+{
+	try
+	{
+		Flows::PArray parameters = std::make_shared<Flows::Array>();
+		parameters->reserve(2);
+		parameters->push_back(std::make_shared<Flows::Variable>(global ? "global" : _nodeInfo->info->structValue->at("z")->stringValue));
+		parameters->push_back(std::make_shared<Flows::Variable>(key));
+		Flows::PVariable result = invoke("getNodeData", parameters);
+		if(result->errorStruct) return;
+		auto data = (mustache::data*)(_data.get(global ? "global" : "flow")); //This is dirty, but works as there is no access to _data, when addData is called.
+		if(!data) return;
+		setData(*data, key, result);
+	}
+	catch(const std::exception& ex)
+	{
+		Flows::Output::printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__, ex.what());
+	}
+	catch(...)
+	{
+		Flows::Output::printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__);
+	}
+}
+
+void MyNode::setData(mustache::data& data, std::string key, Flows::PVariable value)
+{
+	try
+	{
+		if(value->type == Flows::VariableType::tBoolean)
+		{
+			mustache::data element = value->booleanValue ? mustache::data::type::bool_true : mustache::data::type::bool_false;
+			if(key.empty()) data.push_back(element); else data.set(key, element);
+		}
+		else if(value->type == Flows::VariableType::tArray)
+		{
+			mustache::data element = mustache::data::type::list;
+			for(auto arrayElement : *value->arrayValue)
+			{
+				setData(element, "", arrayElement);
+			}
+			if(key.empty()) data.push_back(element); else data.set(key, element);
+		}
+		else if(value->type == Flows::VariableType::tStruct)
+		{
+			mustache::data element = mustache::data::type::object;
+			for(auto pair : *value->structValue)
+			{
+				setData(element, pair.first, pair.second);
+			}
+			if(key.empty()) data.push_back(element); else data.set(key, element);
+		}
+		else
+		{
+			if(key.empty()) data.push_back(value->toString()); else data.set(key, value->toString());
+		}
+	}
+	catch(const std::exception& ex)
+	{
+		Flows::Output::printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__, ex.what());
+	}
+	catch(...)
+	{
+		Flows::Output::printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__);
+	}
+}
+
+void MyNode::input(Flows::PNodeInfo info, uint32_t index, Flows::PVariable message)
+{
+	try
+	{
+		std::lock_guard<std::mutex> inputGuard(_inputMutex);
+		_data = mustache::data();
+		for(auto& element : *message->structValue)
+		{
+			setData(_data, element.first, element.second);
+		}
+		_data.set("flow", mustache::data(mustache::data::type::object));
+		_data.set("global", mustache::data(mustache::data::type::object));
+
+		Flows::PVariable result;
+		if(_mustache) result = std::make_shared<Flows::Variable>(_template->render(_data, std::function<void(bool, std::string)>(std::bind(&MyNode::addData, this, std::placeholders::_1, std::placeholders::_2))));
+		else result = std::make_shared<Flows::Variable>(_plainTemplate);
+
+		Flows::PVariable outputMessage = std::make_shared<Flows::Variable>(Flows::VariableType::tStruct);
+		if(_parseJson)
+		{
+			Flows::PVariable json = _jsonDecoder.decode(result->stringValue);
+			if(_field.empty() && json->type == Flows::VariableType::tStruct)
+			{
+				outputMessage = json;
+			}
+			else
+			{
+				if(_field.empty()) _field = "payload";
+				outputMessage->structValue->emplace(_field, json);
+			}
+			output(0, outputMessage);
+		}
+		else
+		{
+			if(_field.empty()) _field = "payload";
+			outputMessage->structValue->emplace(_field, result);
+			output(0, outputMessage);
+		}
+	}
+	catch(const Flows::JsonDecoderException& ex)
+	{
+		Flows::Output::printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__, ex.what());
+	}
+	catch(const std::exception& ex)
+	{
+		Flows::Output::printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__, ex.what());
+	}
+	catch(...)
+	{
+		Flows::Output::printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__);
+	}
+}
+
+}
diff --git a/template/MyNode.h b/template/MyNode.h
new file mode 100644
index 00000000..9cbce74a
--- /dev/null
+++ b/template/MyNode.h
@@ -0,0 +1,68 @@
+/* Copyright 2013-2017 Sathya Laufer
+ *
+ * Homegear is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Homegear is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Homegear.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * In addition, as a special exception, the copyright holders give
+ * permission to link the code of portions of this program with the
+ * OpenSSL library under certain conditions as described in each
+ * individual source file, and distribute linked combinations
+ * including the two.
+ * You must obey the GNU General Public License in all respects
+ * for all of the code used other than OpenSSL.  If you modify
+ * file(s) with this exception, you may extend this exception to your
+ * version of the file(s), but you are not obligated to do so.  If you
+ * do not wish to do so, delete this exception statement from your
+ * version.  If you delete this exception statement from all source
+ * files in the program, then also delete it here.
+ */
+
+#ifndef MYNODE_H_
+#define MYNODE_H_
+
+#include <homegear-node/INode.h>
+#include <homegear-node/JsonDecoder.h>
+#include "mustache.h"
+
+using namespace kainjow;
+
+namespace MyNode
+{
+
+class MyNode: public Flows::INode
+{
+public:
+	MyNode(std::string path, std::string nodeNamespace, std::string type, const std::atomic_bool* frontendConnected);
+	virtual ~MyNode();
+
+	virtual bool init(Flows::PNodeInfo info);
+private:
+	Flows::PNodeInfo _nodeInfo;
+
+	std::string _plainTemplate;
+	Flows::JsonDecoder _jsonDecoder;
+	std::unique_ptr<mustache::mustache> _template;
+	std::string _field;
+	bool _mustache = true;
+	bool _parseJson = false;
+	std::mutex _inputMutex;
+	mustache::data _data;
+
+	void addData(bool global, std::string key);
+	void setData(mustache::data& data, std::string key, Flows::PVariable value);
+	virtual void input(Flows::PNodeInfo info, uint32_t index, Flows::PVariable message);
+};
+
+}
+
+#endif
diff --git a/template/locales/en-US/template b/template/locales/en-US/template
new file mode 100644
index 00000000..ea19c6d7
--- /dev/null
+++ b/template/locales/en-US/template
@@ -0,0 +1,19 @@
+{
+  "template/template.hni": {
+    "template": {
+      "label": {
+        "template": "Template",
+        "property": "Set property",
+        "format": "Syntax Highlight",
+        "syntax": "Format",
+        "output": "Output as",
+        "mustache": "Mustache template",
+        "plain": "Plain text",
+        "json": "Parsed JSON"
+      },
+      "templatevalue": "This is the payload: {{payload}} !",
+      "paletteHelp": "<p>Sets a property based on the provided template.</p>",
+      "help": "<p>Sets a property based on the provided template.</p><h3>Inputs</h3><dl class=\"message-properties\"><dt>$message <span class=\"property-type\">struct</span></dt><dd>A $message object containing information to populate the template.</dd></dl><h3>Outputs</h3><dl class=\"message-properties\"><dt>$message <span class=\"property-type\">struct</span></dt><dd>a $message with a property set by populating the configured template with properties from the incoming $message.</dd></dl><h3>Details</h3><p>By default this uses the <i><a href=\"http://mustache.github.io/mustache.5.html\" target=\"_blank\">mustache</a></i> format, but this can be switched off if required.</p><p>For example, when a template of: <pre>Hello {{name}}. Today is {{date}}</pre><p>receives a message containing: <pre>{\n  name: \"Fred\",\n  date: \"Monday\"\n  payload: ...\n}</pre></p><p>The resulting property will be: <pre>Hello Fred. Today is Monday</pre></p><p>It is possible to use a property from the flow context or global context. Just use <code>{{flow.name}}</code> or <code>{{global.name}}</code>.</p><p><b>Note: </b>By default, <i>mustache</i> will escape any HTML entities in the values it substitutes. To prevent this, use <code>{{{triple}}}</code> braces.</p>"
+    }
+  }
+}
\ No newline at end of file
diff --git a/template/mustache.h b/template/mustache.h
new file mode 100644
index 00000000..a2753c83
--- /dev/null
+++ b/template/mustache.h
@@ -0,0 +1,861 @@
+//
+// Copyright 2015-2017 Kevin Wojniak
+//
+// Permission is hereby granted, free of charge, to any person or organization
+// obtaining a copy of the software and accompanying documentation covered by
+// this license (the "Software") to use, reproduce, display, distribute,
+// execute, and transmit the Software, and to prepare derivative works of the
+// Software, and to permit third-parties to whom the Software is furnished to
+// do so, all subject to the following:
+//
+// The copyright notices in the Software and this entire statement, including
+// the above license grant, this restriction and the following disclaimer,
+// must be included in all copies of the Software, in whole or in part, and
+// all derivative works of the Software, unless such copies or derivative
+// works are solely in the form of machine-executable object code generated by
+// a source language processor.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+// SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+// FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+//
+
+#ifndef KAINJOW_MUSTACHE_HPP
+#define KAINJOW_MUSTACHE_HPP
+
+#include <cassert>
+#include <functional>
+#include <iostream>
+#include <memory>
+#include <sstream>
+#include <unordered_map>
+#include <vector>
+
+namespace kainjow {
+namespace mustache {
+
+template <typename string_type>
+string_type trim(const string_type& s) {
+    auto it = s.begin();
+    while (it != s.end() && isspace(*it)) {
+        it++;
+    }
+    auto rit = s.rbegin();
+    while (rit.base() != it && isspace(*rit)) {
+        rit++;
+    }
+    return {it, rit.base()};
+}
+
+template <typename string_type>
+string_type escape(const string_type& s) {
+    string_type ret;
+    ret.reserve(s.size()*2);
+    for (const auto ch : s) {
+        switch (ch) {
+            case '&':
+                ret.append({'&','a','m','p',';'});
+                break;
+            case '<':
+                ret.append({'&','l','t',';'});
+                break;
+            case '>':
+                ret.append({'&','g','t',';'});
+                break;
+            case '\"':
+                ret.append({'&','q','u','o','t',';'});
+                break;
+            case '\'':
+                ret.append({'&','a','p','o','s',';'});
+                break;
+            default:
+                ret.append(1, ch);
+                break;
+        }
+    }
+    return ret;
+}
+
+template <typename string_type>
+std::vector<string_type> split(const string_type& s, typename string_type::value_type delim) {
+    std::vector<string_type> elems;
+    std::basic_stringstream<typename string_type::value_type> ss(s);
+    string_type item;
+    while (std::getline(ss, item, delim)) {
+        elems.push_back(item);
+    }
+    return elems;
+}
+
+template <typename string_type>
+class basic_data;
+template <typename string_type>
+using basic_object = std::unordered_map<string_type, basic_data<string_type>>;
+template <typename string_type>
+using basic_list = std::vector<basic_data<string_type>>;
+template <typename string_type>
+using basic_partial = std::function<string_type()>;
+template <typename string_type>
+using basic_lambda = std::function<string_type(const string_type&)>;
+
+template <typename string_type>
+class basic_data {
+public:
+    enum class type {
+        object,
+        string,
+        list,
+        bool_true,
+        bool_false,
+        partial,
+        lambda,
+        invalid,
+    };
+
+    // Construction
+    basic_data() : basic_data(type::object) {
+    }
+    basic_data(const string_type& string) : type_{type::string} {
+        str_.reset(new string_type(string));
+    }
+    basic_data(const typename string_type::value_type* string) : type_{type::string} {
+        str_.reset(new string_type(string));
+    }
+    basic_data(const basic_object<string_type>& obj) : type_{type::object} {
+        obj_.reset(new basic_object<string_type>(obj));
+    }
+    basic_data(const basic_list<string_type>& l) : type_{type::list} {
+        list_.reset(new basic_list<string_type>(l));
+    }
+    basic_data(type t) : type_{t} {
+        switch (type_) {
+            case type::object:
+                obj_.reset(new basic_object<string_type>);
+                break;
+            case type::string:
+                str_.reset(new string_type);
+                break;
+            case type::list:
+                list_.reset(new basic_list<string_type>);
+                break;
+            default:
+                break;
+        }
+    }
+    basic_data(const string_type& name, const basic_data& var) : basic_data{} {
+        set(name, var);
+    }
+    basic_data(const basic_partial<string_type>& p) : type_{type::partial} {
+        partial_.reset(new basic_partial<string_type>(p));
+    }
+    basic_data(const basic_lambda<string_type>& l) : type_{type::lambda} {
+        lambda_.reset(new basic_lambda<string_type>(l));
+    }
+    basic_data(bool b) : type_{b ? type::bool_true : type::bool_false} {
+    }
+
+    // Copying
+    basic_data(const basic_data& dat) : type_(dat.type_) {
+        if (dat.obj_) {
+            obj_.reset(new basic_object<string_type>(*dat.obj_));
+        } else if (dat.str_) {
+            str_.reset(new string_type(*dat.str_));
+        } else if (dat.list_) {
+            list_.reset(new basic_list<string_type>(*dat.list_));
+        } else if (dat.partial_) {
+            partial_.reset(new basic_partial<string_type>(*dat.partial_));
+        } else if (dat.lambda_) {
+            lambda_.reset(new basic_lambda<string_type>(*dat.lambda_));
+        }
+    }
+
+    // Move
+    basic_data(basic_data&& dat) : type_{dat.type_} {
+        if (dat.obj_) {
+            obj_ = std::move(dat.obj_);
+        } else if (dat.str_) {
+            str_ = std::move(dat.str_);
+        } else if (dat.list_) {
+            list_ = std::move(dat.list_);
+        } else if (dat.partial_) {
+            partial_ = std::move(dat.partial_);
+        } else if (dat.lambda_) {
+            lambda_ = std::move(dat.lambda_);
+        }
+        dat.type_ = type::invalid;
+    }
+    basic_data& operator= (basic_data&& dat) {
+        if (this != &dat) {
+            obj_.reset();
+            str_.reset();
+            list_.reset();
+            partial_.reset();
+            lambda_.reset();
+            if (dat.obj_) {
+                obj_ = std::move(dat.obj_);
+            } else if (dat.str_) {
+                str_ = std::move(dat.str_);
+            } else if (dat.list_) {
+                list_ = std::move(dat.list_);
+            } else if (dat.partial_) {
+                partial_ = std::move(dat.partial_);
+            } else if (dat.lambda_) {
+                lambda_ = std::move(dat.lambda_);
+            }
+            type_ = dat.type_;
+            dat.type_ = type::invalid;
+        }
+        return *this;
+    }
+
+    // Type info
+    bool is_object() const {
+        return type_ == type::object;
+    }
+    bool is_string() const {
+        return type_ == type::string;
+    }
+    bool is_list() const {
+        return type_ == type::list;
+    }
+    bool is_bool() const {
+        return is_true() || is_false();
+    }
+    bool is_true() const {
+        return type_ == type::bool_true;
+    }
+    bool is_false() const {
+        return type_ == type::bool_false;
+    }
+    bool is_partial() const {
+        return type_ == type::partial;
+    }
+    bool is_lambda() const {
+        return type_ == type::lambda;
+    }
+    bool is_invalid() const {
+        return type_ == type::invalid;
+    }
+
+    // Object data
+    void set(const string_type& name, const basic_data& var) {
+        if (is_object()) {
+            obj_->insert(std::pair<string_type,basic_data>{name, var});
+        }
+    }
+    const basic_data* get(const string_type& name) const {
+        if (!is_object()) {
+            return nullptr;
+        }
+        const auto& it = obj_->find(name);
+        if (it == obj_->end()) {
+            return nullptr;
+        }
+        return &it->second;
+    }
+
+    // List data
+    void push_back(const basic_data& var) {
+        if (is_list()) {
+            list_->push_back(var);
+        }
+    }
+    const basic_list<string_type>& list_value() const {
+        return *list_;
+    }
+    bool is_empty_list() const {
+        return is_list() && list_->empty();
+    }
+    bool is_non_empty_list() const {
+        return is_list() && !list_->empty();
+    }
+    basic_data& operator<< (const basic_data& data) {
+        push_back(data);
+        return *this;
+    }
+
+    // String data
+    const string_type& string_value() const {
+        return *str_;
+    }
+
+    basic_data& operator[] (const string_type& key) {
+        return (*obj_)[key];
+    }
+
+    const basic_partial<string_type>& partial_value() const {
+        return (*partial_);
+    }
+
+    const basic_lambda<string_type>& lambda_value() const {
+        return (*lambda_);
+    }
+
+private:
+    type type_;
+    std::unique_ptr<basic_object<string_type>> obj_;
+    std::unique_ptr<string_type> str_;
+    std::unique_ptr<basic_list<string_type>> list_;
+    std::unique_ptr<basic_partial<string_type>> partial_;
+    std::unique_ptr<basic_lambda<string_type>> lambda_;
+};
+
+template <typename string_type>
+class delimiter_set {
+public:
+    string_type begin;
+    string_type end;
+    delimiter_set()
+        : begin(default_begin)
+        , end(default_end)
+    {}
+    bool is_default() const { return begin == default_begin && end == default_end; }
+    static const string_type default_begin;
+    static const string_type default_end;
+};
+
+template <typename string_type>
+const string_type delimiter_set<string_type>::default_begin(2, '{');
+template <typename string_type>
+const string_type delimiter_set<string_type>::default_end(2, '}');
+
+template <typename StringType>
+class basic_mustache {
+public:
+    using string_type = StringType;
+
+    basic_mustache(const string_type& input) {
+        Context ctx;
+        parse(input, ctx);
+    }
+
+    bool is_valid() const {
+        return errorMessage_.empty();
+    }
+    
+    const string_type& error_message() const {
+        return errorMessage_;
+    }
+
+    template <typename StreamType>
+    StreamType& render(const basic_data<string_type>& data, std::function<void(bool, std::string)> addData, StreamType& stream) {
+        render(data, addData, [&stream](const string_type& str) {
+            stream << str;
+        });
+        return stream;
+    }
+    
+    string_type render(const basic_data<string_type>& data, std::function<void(bool, std::string)> addData) {
+        std::basic_ostringstream<typename string_type::value_type> ss;
+        return render(data, addData, ss).str();
+    }
+
+    using RenderHandler = std::function<void(const string_type&)>;
+    void render(const basic_data<string_type>& data, std::function<void(bool, std::string)> addData, const RenderHandler& handler) {
+        if (!is_valid()) {
+            return;
+        }
+        Context ctx{&data, addData};
+        render(handler, ctx);
+    }
+
+private:
+    using StringSizeType = typename string_type::size_type;
+    
+    class Tag {
+    public:
+        enum class Type {
+            Invalid,
+            Variable,
+            UnescapedVariable,
+            SectionBegin,
+            SectionEnd,
+            SectionBeginInverted,
+            Comment,
+            Partial,
+            SetDelimiter,
+        };
+        string_type name;
+        Type type = Type::Invalid;
+        std::shared_ptr<string_type> sectionText;
+        std::shared_ptr<delimiter_set<string_type>> delimiterSet;
+        bool isSectionBegin() const {
+            return type == Type::SectionBegin || type == Type::SectionBeginInverted;
+        }
+        bool isSectionEnd() const {
+            return type == Type::SectionEnd;
+        }
+    };
+    
+    class Component {
+    public:
+        string_type text;
+        Tag tag;
+        std::vector<Component> children;
+        StringSizeType position = string_type::npos;
+        bool isText() const {
+            return tag.type == Tag::Type::Invalid;
+        }
+        Component() {}
+        Component(const string_type& t, StringSizeType p) : text(t), position(p) {}
+    };
+    
+    class Context {
+    public:
+        Context(const basic_data<string_type>* data, std::function<void(bool, std::string)> addData) {
+            push(data);
+            _addData.swap(addData);
+        }
+
+        Context() {
+        }
+
+        void push(const basic_data<string_type>* data) {
+            items_.insert(items_.begin(), data);
+        }
+
+        void pop() {
+            items_.erase(items_.begin());
+        }
+        
+        const basic_data<string_type>* get(const string_type& name) const {
+            // process {{.}} name
+            if (name.size() == 1 && name.at(0) == '.') {
+                return items_.front();
+            }
+            if (name.find('.') == string_type::npos) {
+                // process normal name without having to split which is slower
+                for (const auto& item : items_) {
+                    const auto var = item->get(name);
+                    if (var) {
+                        return var;
+                    }
+                }
+                return nullptr;
+            }
+            // process x.y-like name
+            auto names = split(name, '.');
+            if (names.size() == 0) {
+                names.resize(1);
+            }
+            if(names.at(0) == "flow" || names.at(0) == "global") {
+            	for (const auto& item : items_) {
+					auto var = item;
+					var = var->get(names.at(0));
+					if (!var) {
+						continue;
+					}
+					if(_addData) _addData(names.at(0) == "global", names.at(1));
+				}
+            }
+			for (const auto& item : items_) {
+				auto var = item;
+				for (const auto& n : names) {
+					var = var->get(n);
+					if (!var) {
+						break;
+					}
+				}
+				if (var) {
+					return var;
+				}
+			}
+            return nullptr;
+        }
+
+        const basic_data<string_type>* get_partial(const string_type& name) const {
+            for (const auto& item : items_) {
+                const auto var = item->get(name);
+                if (var) {
+                    return var;
+                }
+            }
+            return nullptr;
+        }
+
+        Context(const Context&) = delete;
+        Context& operator= (const Context&) = delete;
+        
+        delimiter_set<string_type> delimiterSet;
+
+    private:
+        std::vector<const basic_data<string_type>*> items_;
+        std::function<void(bool, std::string)> _addData;
+    };
+
+    class ContextPusher {
+    public:
+        ContextPusher(Context& ctx, const basic_data<string_type>* data) : ctx_(ctx) {
+            ctx.push(data);
+        }
+        ~ContextPusher() {
+            ctx_.pop();
+        }
+        ContextPusher(const ContextPusher&) = delete;
+        ContextPusher& operator= (const ContextPusher&) = delete;
+    private:
+        Context& ctx_;
+    };
+    
+    basic_mustache(const string_type& input, Context& ctx) {
+        parse(input, ctx);
+    }
+
+    void parse(const string_type& input, Context& ctx) {
+        using streamstring = std::basic_ostringstream<typename string_type::value_type>;
+        
+        const string_type braceDelimiterEndUnescaped(3, '}');
+        const StringSizeType inputSize{input.size()};
+        
+        bool currentDelimiterIsBrace{ctx.delimiterSet.is_default()};
+        
+        std::vector<Component*> sections{&rootComponent_};
+        std::vector<StringSizeType> sectionStarts;
+        
+        StringSizeType inputPosition{0};
+        while (inputPosition != inputSize) {
+            
+            // Find the next tag start delimiter
+            const StringSizeType tagLocationStart{input.find(ctx.delimiterSet.begin, inputPosition)};
+            if (tagLocationStart == string_type::npos) {
+                // No tag found. Add the remaining text.
+                const Component comp{{input, inputPosition, inputSize - inputPosition}, inputPosition};
+                sections.back()->children.push_back(comp);
+                break;
+            } else if (tagLocationStart != inputPosition) {
+                // Tag found, add text up to this tag.
+                const Component comp{{input, inputPosition, tagLocationStart - inputPosition}, inputPosition};
+                sections.back()->children.push_back(comp);
+            }
+            
+            // Find the next tag end delimiter
+            StringSizeType tagContentsLocation{tagLocationStart + ctx.delimiterSet.begin.size()};
+            const bool tagIsUnescapedVar{currentDelimiterIsBrace && tagLocationStart != (inputSize - 2) && input.at(tagContentsLocation) == ctx.delimiterSet.begin.at(0)};
+            const string_type& currentTagDelimiterEnd{tagIsUnescapedVar ? braceDelimiterEndUnescaped : ctx.delimiterSet.end};
+            const auto currentTagDelimiterEndSize = currentTagDelimiterEnd.size();
+            if (tagIsUnescapedVar) {
+                ++tagContentsLocation;
+            }
+            StringSizeType tagLocationEnd{input.find(currentTagDelimiterEnd, tagContentsLocation)};
+            if (tagLocationEnd == string_type::npos) {
+                streamstring ss;
+                ss << "Unclosed tag at " << tagLocationStart;
+                errorMessage_.assign(ss.str());
+                return;
+            }
+            
+            // Parse tag
+            const string_type tagContents{trim(string_type{input, tagContentsLocation, tagLocationEnd - tagContentsLocation})};
+            Component comp;
+            if (!tagContents.empty() && tagContents[0] == '=') {
+                if (!parseSetDelimiterTag(tagContents, ctx.delimiterSet)) {
+                    streamstring ss;
+                    ss << "Invalid set delimiter tag at " << tagLocationStart;
+                    errorMessage_.assign(ss.str());
+                    return;
+                }
+                currentDelimiterIsBrace = ctx.delimiterSet.is_default();
+                comp.tag.type = Tag::Type::SetDelimiter;
+                comp.tag.delimiterSet.reset(new delimiter_set<string_type>(ctx.delimiterSet));
+            }
+            if (comp.tag.type != Tag::Type::SetDelimiter) {
+                parseTagContents(tagIsUnescapedVar, tagContents, comp.tag);
+            }
+            comp.position = tagLocationStart;
+            sections.back()->children.push_back(comp);
+            
+            // Start next search after this tag
+            inputPosition = tagLocationEnd + currentTagDelimiterEndSize;
+
+            // Push or pop sections
+            if (comp.tag.isSectionBegin()) {
+                sections.push_back(&sections.back()->children.back());
+                sectionStarts.push_back(inputPosition);
+            } else if (comp.tag.isSectionEnd()) {
+                if (sections.size() == 1) {
+                    streamstring ss;
+                    ss << "Unopened section \"" << comp.tag.name << "\" at " << comp.position;
+                    errorMessage_.assign(ss.str());
+                    return;
+                }
+                sections.back()->tag.sectionText.reset(new string_type(input.substr(sectionStarts.back(), tagLocationStart - sectionStarts.back())));
+                sections.pop_back();
+                sectionStarts.pop_back();
+            }
+        }
+        
+        // Check for sections without an ending tag
+        walk([this](Component& comp) -> WalkControl {
+            if (!comp.tag.isSectionBegin()) {
+                return WalkControl::Continue;
+            }
+            if (comp.children.empty() || !comp.children.back().tag.isSectionEnd() || comp.children.back().tag.name != comp.tag.name) {
+                streamstring ss;
+                ss << "Unclosed section \"" << comp.tag.name << "\" at " << comp.position;
+                errorMessage_.assign(ss.str());
+                return WalkControl::Stop;
+            }
+            comp.children.pop_back(); // remove now useless end section component
+            return WalkControl::Continue;
+        });
+        if (!errorMessage_.empty()) {
+            return;
+        }
+    }
+    
+    enum class WalkControl {
+        Continue,
+        Stop,
+        Skip,
+    };
+    using WalkCallback = std::function<WalkControl(Component&)>;
+    
+    void walk(const WalkCallback& callback) {
+        walkChildren(callback, rootComponent_);
+    }
+
+    void walkChildren(const WalkCallback& callback, Component& comp) {
+        for (auto& childComp : comp.children) {
+            if (walkComponent(callback, childComp) != WalkControl::Continue) {
+                break;
+            }
+        }
+    }
+    
+    WalkControl walkComponent(const WalkCallback& callback, Component& comp) {
+        WalkControl control{callback(comp)};
+        if (control == WalkControl::Stop) {
+            return control;
+        } else if (control == WalkControl::Skip) {
+            return WalkControl::Continue;
+        }
+        for (auto& childComp : comp.children) {
+            control = walkComponent(callback, childComp);
+            assert(control == WalkControl::Continue);
+        }
+        return control;
+    }
+    
+    bool isSetDelimiterValid(const string_type& delimiter) {
+        // "Custom delimiters may not contain whitespace or the equals sign."
+        for (const auto ch : delimiter) {
+            if (ch == '=' || isspace(ch)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    
+    bool parseSetDelimiterTag(const string_type& contents, delimiter_set<string_type>& delimiterSet) {
+        // Smallest legal tag is "=X X="
+        if (contents.size() < 5) {
+            return false;
+        }
+        if (contents.back() != '=') {
+            return false;
+        }
+        const auto contentsSubstr = trim(contents.substr(1, contents.size() - 2));
+        const auto spacepos = contentsSubstr.find(' ');
+        if (spacepos == string_type::npos) {
+            return false;
+        }
+        const auto nonspace = contentsSubstr.find_first_not_of(' ', spacepos + 1);
+        assert(nonspace != string_type::npos);
+        const string_type begin = contentsSubstr.substr(0, spacepos);
+        const string_type end = contentsSubstr.substr(nonspace, contentsSubstr.size() - nonspace);
+        if (!isSetDelimiterValid(begin) || !isSetDelimiterValid(end)) {
+            return false;
+        }
+        delimiterSet.begin = begin;
+        delimiterSet.end = end;
+        return true;
+    }
+    
+    void parseTagContents(bool isUnescapedVar, const string_type& contents, Tag& tag) {
+        if (isUnescapedVar) {
+            tag.type = Tag::Type::UnescapedVariable;
+            tag.name = contents;
+        } else if (contents.empty()) {
+            tag.type = Tag::Type::Variable;
+            tag.name.clear();
+        } else {
+            switch (contents.at(0)) {
+                case '#':
+                    tag.type = Tag::Type::SectionBegin;
+                    break;
+                case '^':
+                    tag.type = Tag::Type::SectionBeginInverted;
+                    break;
+                case '/':
+                    tag.type = Tag::Type::SectionEnd;
+                    break;
+                case '>':
+                    tag.type = Tag::Type::Partial;
+                    break;
+                case '&':
+                    tag.type = Tag::Type::UnescapedVariable;
+                    break;
+                case '!':
+                    tag.type = Tag::Type::Comment;
+                    break;
+                default:
+                    tag.type = Tag::Type::Variable;
+                    break;
+            }
+            if (tag.type == Tag::Type::Variable) {
+                tag.name = contents;
+            } else {
+                string_type name{contents};
+                name.erase(name.begin());
+                tag.name = trim(name);
+            }
+        }
+    }
+    
+    void render(const RenderHandler& handler, Context& ctx) {
+        walk([&handler, &ctx, this](Component& comp) -> WalkControl {
+            return renderComponent(handler, ctx, comp);
+        });
+    }
+    
+    string_type render(Context& ctx) {
+        std::basic_ostringstream<typename string_type::value_type> ss;
+        render([&ss](const string_type& str) {
+            ss << str;
+        }, ctx);
+        return ss.str();
+    }
+    
+    WalkControl renderComponent(const RenderHandler& handler, Context& ctx, Component& comp) {
+        if (comp.isText()) {
+            handler(comp.text);
+            return WalkControl::Continue;
+        }
+        
+        const Tag& tag{comp.tag};
+        const basic_data<string_type>* var = nullptr;
+        switch (tag.type) {
+            case Tag::Type::Variable:
+            case Tag::Type::UnescapedVariable:
+                if ((var = ctx.get(tag.name)) != nullptr) {
+                    if (!renderVariable(handler, var, ctx, tag.type == Tag::Type::Variable)) {
+                        return WalkControl::Stop;
+                    }
+                }
+                break;
+            case Tag::Type::SectionBegin:
+                if ((var = ctx.get(tag.name)) != nullptr) {
+                    if (var->is_lambda()) {
+                        if (!renderLambda(handler, var, ctx, false, *comp.tag.sectionText, true)) {
+                            return WalkControl::Stop;
+                        }
+                    } else if (!var->is_false() && !var->is_empty_list()) {
+                        renderSection(handler, ctx, comp, var);
+                    }
+                }
+                return WalkControl::Skip;
+            case Tag::Type::SectionBeginInverted:
+                if ((var = ctx.get(tag.name)) == nullptr || var->is_false() || var->is_empty_list()) {
+                    renderSection(handler, ctx, comp, var);
+                }
+                return WalkControl::Skip;
+            case Tag::Type::Partial:
+                if ((var = ctx.get_partial(tag.name)) != nullptr && var->is_partial()) {
+                    const auto partial = var->partial_value();
+                    basic_mustache tmpl{partial()};
+                    if (!tmpl.is_valid()) {
+                        errorMessage_ = tmpl.error_message();
+                    } else {
+                        tmpl.render(handler, ctx);
+                        if (!tmpl.is_valid()) {
+                            errorMessage_ = tmpl.error_message();
+                        }
+                    }
+                    if (!tmpl.is_valid()) {
+                        return WalkControl::Stop;
+                    }
+                }
+                break;
+            case Tag::Type::SetDelimiter:
+                ctx.delimiterSet = *comp.tag.delimiterSet;
+                break;
+            default:
+                break;
+        }
+        
+        return WalkControl::Continue;
+    }
+    
+    bool renderLambda(const RenderHandler& handler, const basic_data<string_type>* var, Context& ctx, bool escaped, const string_type& text, bool parseWithSameContext) {
+        const auto processTemplate = [this, &handler, var, &ctx, escaped](basic_mustache& tmpl) {
+            if (!tmpl.is_valid()) {
+                errorMessage_ = tmpl.error_message();
+            } else {
+                const string_type str{tmpl.render(ctx)};
+                if (!tmpl.is_valid()) {
+                    errorMessage_ = tmpl.error_message();
+                } else {
+                    handler(escaped ? escape(str) : str);
+                }
+            }
+            return tmpl.is_valid();
+        };
+        const auto lambdaResult = var->lambda_value()(text);
+        if (parseWithSameContext) {
+            basic_mustache tmpl{lambdaResult, ctx};
+            return processTemplate(tmpl);
+        }
+        basic_mustache tmpl{lambdaResult};
+        return processTemplate(tmpl);
+    }
+    
+    bool renderVariable(const RenderHandler& handler, const basic_data<string_type>* var, Context& ctx, bool escaped) {
+        if (var->is_string()) {
+            const auto varstr = var->string_value();
+            handler(escaped ? escape(varstr) : varstr);
+        } else if (var->is_lambda()) {
+            return renderLambda(handler, var, ctx, escaped, {}, false);
+        }
+        return true;
+    }
+
+    void renderSection(const RenderHandler& handler, Context& ctx, Component& incomp, const basic_data<string_type>* var) {
+        const auto callback = [&handler, &ctx, this](Component& comp) -> WalkControl {
+            return renderComponent(handler, ctx, comp);
+        };
+        if (var && var->is_non_empty_list()) {
+            for (const auto& item : var->list_value()) {
+                const ContextPusher ctxpusher{ctx, &item};
+                walkChildren(callback, incomp);
+            }
+        } else if (var) {
+            const ContextPusher ctxpusher{ctx, var};
+            walkChildren(callback, incomp);
+        } else {
+            walkChildren(callback, incomp);
+        }
+    }
+
+private:
+    string_type errorMessage_;
+    Component rootComponent_;
+};
+
+using mustache = basic_mustache<std::string>;
+using data = basic_data<mustache::string_type>;
+using object = basic_object<mustache::string_type>;
+using list = basic_list<mustache::string_type>;
+using partial = basic_partial<mustache::string_type>;
+using lambda = basic_lambda<mustache::string_type>;
+
+using mustachew = basic_mustache<std::wstring>;
+using dataw = basic_data<mustachew::string_type>;
+
+} // namespace mustache
+} // namespace kainjow
+
+#endif // KAINJOW_MUSTACHE_HPP
diff --git a/template/template.hni b/template/template.hni
new file mode 100644
index 00000000..ff48efbc
--- /dev/null
+++ b/template/template.hni
@@ -0,0 +1,114 @@
+<script type="text/x-homegear">
+{
+    "name": "template",
+    "readableName": "Template",
+    "version": "0.0.1",
+    "maxThreadCount": 0
+}
+</script>
+<script type="text/x-red" data-template-name="template">
+    <div class="form-row">
+        <label for="node-input-name"><i class="fa fa-tag"></i> <span data-i18n="common.label.name"></span></label>
+        <input type="text" id="node-input-name" data-i18n="[placeholder]common.label.name">
+    </div>
+    <div class="form-row">
+        <label for="node-input-field"><i class="fa fa-edit"></i> <span data-i18n="template.label.property"></span></label>
+        <input type="text" id="node-input-field" placeholder="payload">
+    </div>
+    <div class="form-row">
+        <label for="node-input-syntax"><i class="fa fa-code"></i> <span data-i18n="template.label.syntax"></span></label>
+        <select id="node-input-syntax" style="width:180px;">
+            <option value="mustache" data-i18n="template.label.mustache"></option>
+            <option value="plain" data-i18n="template.label.plain"></option>
+        </select>
+    </div>
+
+    <div class="form-row" style="position: relative; margin-bottom: 0px;">
+        <label for="node-input-template"><i class="fa fa-file-code-o"></i> <span data-i18n="template.label.template"></span></label>
+        <input type="hidden" id="node-input-template" autofocus="autofocus">
+        <div style="position: absolute; right:0;display:inline-block; text-align: right; font-size: 0.8em;">
+            <span data-i18n="template.label.format"></span>:
+            <select id="node-input-format" style="width:110px; font-size: 10px !important;  height: 24px; padding:0;">
+                <option value="handlebars">mustache</option>
+                <option value="html">HTML</option>
+                <option value="json">JSON</option>
+                <option value="javascript">Javascript</option>
+                <option value="css">CSS</option>
+                <option value="markdown">Markdown</option>
+                <option value="yaml">YAML</option>
+                <option value="text">none</option>
+            </select>
+        </div>
+    </div>
+    <div class="form-row node-text-editor-row">
+        <div style="height: 250px; min-height:150px;" class="node-text-editor" id="node-input-template-editor" ></div>
+    </div>
+    <div class="form-row">
+        <label for="node-input-output"><i class="fa fa-long-arrow-right"></i> <span data-i18n="template.label.output"></span></label>
+        <select id="node-input-output" style="width:180px;">
+            <option value="str" data-i18n="template.label.plain"></option>
+            <option value="json" data-i18n="template.label.json"></option>
+        </select>
+    </div>
+</script>
+<script type="text/javascript">
+	RED.nodes.registerType('template',{
+        category: 'function',
+        namespace: 'template',
+        color: "rgb(243, 181, 103)",
+        defaults: {
+            name: {value:""},
+            field: {value:"payload"},
+            format: {value:"handlebars"},
+            syntax: {value:"mustache"},
+            template: {value:"This is the payload: {{payload}} !"},
+            output: {value:"str"}
+        },
+        inputs:1,
+        outputs:1,
+        icon: "template.png",
+        label: function() {
+            return this.name;
+        },
+        oneditprepare: function() {
+            var that = this;
+            if (!this.syntax) {
+                this.syntax = 'mustache';
+                $("#node-input-syntax").val(this.syntax);
+            }
+
+            this.editor = RED.editor.createEditor({
+                id: 'node-input-template-editor',
+                mode: 'ace/mode/html',
+                value: $("#node-input-template").val()
+            });
+            this.editor.focus();
+
+            $("#node-input-format").change(function() {
+                var mod = "ace/mode/"+$("#node-input-format").val();
+                that.editor.getSession().setMode({
+                    path: mod,
+                    v: Date.now()
+                });
+            });
+        },
+        oneditsave: function() {
+            $("#node-input-template").val(this.editor.getValue())
+            delete this.editor;
+        },
+        oneditcancel: function() {
+            delete this.editor;
+        },
+        oneditresize: function(size) {
+            var rows = $("#dialog-form>div:not(.node-text-editor-row)");
+            var height = $("#dialog-form").height();
+            for (var i=0;i<rows.size();i++) {
+                height -= $(rows[i]).outerHeight(true);
+            }
+            var editorRow = $("#dialog-form>div.node-text-editor-row");
+            height -= (parseInt(editorRow.css("marginTop"))+parseInt(editorRow.css("marginBottom")));
+            $(".node-text-editor").css("height",height+"px");
+            this.editor.resize();
+        }
+    });
+</script>
diff --git a/timers/Makefile.am b/timers/Makefile.am
index a0d7de02..aa82c69b 100644
--- a/timers/Makefile.am
+++ b/timers/Makefile.am
@@ -6,7 +6,7 @@ LIBS += -Wl,-Bdynamic -lhomegear-node
 
 libdir = $(localstatedir)/lib/homegear/flows/nodes/timers
 
-lib_LTLIBRARIES = clock.la interval.la delay.la timer.la sun-position.la
+lib_LTLIBRARIES = clock.la interval.la delay.la timer.la slow-pwm.la sun-position.la
 
 clock_la_SOURCES = clock/Factory.cpp clock/MyNode.cpp
 clock_la_LDFLAGS =-module -avoid-version -shared
@@ -20,17 +20,21 @@ delay_la_LDFLAGS =-module -avoid-version -shared
 timer_la_SOURCES = timer/Factory.cpp timer/MyNode.cpp timer/SunTime.cpp
 timer_la_LDFLAGS =-module -avoid-version -shared
 
+slow_pwm_la_SOURCES = slow-pwm/Factory.cpp slow-pwm/MyNode.cpp
+slow_pwm_la_LDFLAGS =-module -avoid-version -shared
+
 sun_position_la_SOURCES = sun-position/Factory.cpp sun-position/MyNode.cpp sun-position/SunTime.cpp
 sun_position_la_LDFLAGS =-module -avoid-version -shared
 
 timers_ladir = $(libdir)
-timers_la_DATA = clock/clock.hni interval/interval.hni delay/delay.hni timer/timer.hni sun-position/sun-position.hni
+timers_la_DATA = clock/clock.hni interval/interval.hni delay/delay.hni timer/timer.hni slow-pwm/slow-pwm.hni sun-position/sun-position.hni
 locale_en_usdir = $(libdir)/locales/en-US
-locale_en_us_DATA = clock/locales/en-US/clock interval/locales/en-US/interval delay/locales/en-US/delay timer/locales/en-US/timer sun-position/locales/en-US/sun-position
+locale_en_us_DATA = clock/locales/en-US/clock interval/locales/en-US/interval delay/locales/en-US/delay timer/locales/en-US/timer slow-pwm/locales/en-US/slow-pwm sun-position/locales/en-US/sun-position
 
 install-exec-hook:
 	rm -f $(DESTDIR)$(libdir)/clock.la
 	rm -f $(DESTDIR)$(libdir)/interval.la
 	rm -f $(DESTDIR)$(libdir)/delay.la
 	rm -f $(DESTDIR)$(libdir)/timer.la
+	rm -f $(DESTDIR)$(libdir)/slow-pwm.la
 	rm -f $(DESTDIR)$(libdir)/sun-position.la
diff --git a/timers/interval/MyNode.cpp b/timers/interval/MyNode.cpp
index 1884c151..76058740 100644
--- a/timers/interval/MyNode.cpp
+++ b/timers/interval/MyNode.cpp
@@ -34,6 +34,7 @@ namespace MyNode
 
 MyNode::MyNode(std::string path, std::string nodeNamespace, std::string type, const std::atomic_bool* frontendConnected) : Flows::INode(path, nodeNamespace, type, frontendConnected)
 {
+	_enabled = true;
 	_stopThread = true;
 }
 
@@ -205,9 +206,9 @@ void MyNode::input(Flows::PNodeInfo info, uint32_t index, Flows::PVariable messa
 {
 	try
 	{
+		_inputTime = Flows::HelperFunctions::getTime();
 		if(index == 0)
 		{
-			_inputTime = Flows::HelperFunctions::getTime();
 			_enabled = message->structValue->at("payload")->booleanValue;
 			setNodeData("enabled", std::make_shared<Flows::Variable>(_enabled));
 			Flows::PVariable status = std::make_shared<Flows::Variable>(Flows::VariableType::tStruct);
@@ -223,16 +224,14 @@ void MyNode::input(Flows::PNodeInfo info, uint32_t index, Flows::PVariable messa
 				_stopThread = false;
 				_timerThread = std::thread(&MyNode::timer, this);
 			}
-			Flows::PVariable message = std::make_shared<Flows::Variable>(Flows::VariableType::tStruct);
-			message->structValue->emplace("payload", std::make_shared<Flows::Variable>(true));
-			output(1, message);
 		}
-		else if(index == 1 && _enabled && message->structValue->at("payload")->booleanValue)
+		else if(index == 1 && _enabled && message->structValue->at("payload"))
 		{
 			std::lock_guard<std::mutex> timerGuard(_timerMutex);
 			_stopThread = true;
 			if(_timerThread.joinable()) _timerThread.join();
 			_tick = 0;
+			_startTimeAll = Flows::HelperFunctions::getTime();
 			_stopThread = false;
 			_timerThread = std::thread(&MyNode::timer, this);
 		}
diff --git a/timers/interval/MyNode.h b/timers/interval/MyNode.h
index 0c0deb03..20a88e67 100644
--- a/timers/interval/MyNode.h
+++ b/timers/interval/MyNode.h
@@ -48,7 +48,7 @@ class MyNode: public Flows::INode
 	virtual void stop();
 	virtual void waitForStop();
 private:
-	bool _enabled = true;
+	std::atomic_bool _enabled;
 	int64_t _startTimeAll = 0;
 	int64_t _tick = 0;
 	int64_t _inputTime = 0;
diff --git a/timers/interval/locales/en-US/interval b/timers/interval/locales/en-US/interval
index f7c5b501..c505b22a 100644
--- a/timers/interval/locales/en-US/interval
+++ b/timers/interval/locales/en-US/interval
@@ -11,9 +11,9 @@
       "input1Description": "Set to <code>true</code> to enable the timer and to <code>false</code> to disable it.",
       "input2Description": "Set to <code>true</code> to reset the timer. Setting <code>EN</code> to false also resets the timer.",
       "output1Description": "Outputs the number of ticks since the timer was started.",
-      "output2Description": "Outputs <code>true</code> when the timer is finished.",
+      "output2Description": "Outputs <code>true</code> when the timer is finished after the time defined in \"Reset after\" is up.",
       "paletteHelp": "<p>Generates an periodic event in constant intervals.</p>",
-      "help": "This node generates events in constant intervals. Set <code>EN</code> to \"true\" to enable the timer. You can set \"Reset after\" to automatically disable the timer."
+      "help": "This node generates events in constant intervals. Set <code>EN</code> to \"true\" to enable the timer. You can set \"Reset after\" to automatically disable the timer. When the timer is stopped after the time defined in \"Reset after\", output <code>f</code> is set to \"true\"."
     }
   }
 }
diff --git a/timers/slow-pwm/Factory.cpp b/timers/slow-pwm/Factory.cpp
new file mode 100644
index 00000000..6304ad24
--- /dev/null
+++ b/timers/slow-pwm/Factory.cpp
@@ -0,0 +1,42 @@
+/* Copyright 2013-2017 Sathya Laufer
+ *
+ * Homegear is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Homegear is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Homegear.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * In addition, as a special exception, the copyright holders give
+ * permission to link the code of portions of this program with the
+ * OpenSSL library under certain conditions as described in each
+ * individual source file, and distribute linked combinations
+ * including the two.
+ * You must obey the GNU General Public License in all respects
+ * for all of the code used other than OpenSSL.  If you modify
+ * file(s) with this exception, you may extend this exception to your
+ * version of the file(s), but you are not obligated to do so.  If you
+ * do not wish to do so, delete this exception statement from your
+ * version.  If you delete this exception statement from all source
+ * files in the program, then also delete it here.
+ */
+
+#include "Factory.h"
+#include "MyNode.h"
+#include "../config.h"
+
+Flows::INode* MyFactory::createNode(std::string path, std::string nodeNamespace, std::string type, const std::atomic_bool* frontendConnected)
+{
+	return new MyNode::MyNode(path, nodeNamespace, type, frontendConnected);
+}
+
+Flows::NodeFactory* getFactory()
+{
+	return (Flows::NodeFactory*) (new MyFactory);
+}
diff --git a/timers/slow-pwm/Factory.h b/timers/slow-pwm/Factory.h
new file mode 100644
index 00000000..6e79b886
--- /dev/null
+++ b/timers/slow-pwm/Factory.h
@@ -0,0 +1,44 @@
+/* Copyright 2013-2017 Sathya Laufer
+ *
+ * Homegear is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Homegear is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Homegear.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * In addition, as a special exception, the copyright holders give
+ * permission to link the code of portions of this program with the
+ * OpenSSL library under certain conditions as described in each
+ * individual source file, and distribute linked combinations
+ * including the two.
+ * You must obey the GNU General Public License in all respects
+ * for all of the code used other than OpenSSL.  If you modify
+ * file(s) with this exception, you may extend this exception to your
+ * version of the file(s), but you are not obligated to do so.  If you
+ * do not wish to do so, delete this exception statement from your
+ * version.  If you delete this exception statement from all source
+ * files in the program, then also delete it here.
+ */
+
+#ifndef FACTORY_H
+#define FACTORY_H
+
+#include <homegear-node/NodeFactory.h>
+#include "MyNode.h"
+
+class MyFactory : Flows::NodeFactory
+{
+public:
+	virtual Flows::INode* createNode(std::string path, std::string nodeNamespace, std::string type, const std::atomic_bool* frontendConnected);
+};
+
+extern "C" Flows::NodeFactory* getFactory();
+
+#endif
diff --git a/timers/slow-pwm/MyNode.cpp b/timers/slow-pwm/MyNode.cpp
new file mode 100644
index 00000000..0f9217dc
--- /dev/null
+++ b/timers/slow-pwm/MyNode.cpp
@@ -0,0 +1,234 @@
+/* Copyright 2013-2017 Sathya Laufer
+ *
+ * Homegear is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Homegear is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Homegear.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * In addition, as a special exception, the copyright holders give
+ * permission to link the code of portions of this program with the
+ * OpenSSL library under certain conditions as described in each
+ * individual source file, and distribute linked combinations
+ * including the two.
+ * You must obey the GNU General Public License in all respects
+ * for all of the code used other than OpenSSL.  If you modify
+ * file(s) with this exception, you may extend this exception to your
+ * version of the file(s), but you are not obligated to do so.  If you
+ * do not wish to do so, delete this exception statement from your
+ * version.  If you delete this exception statement from all source
+ * files in the program, then also delete it here.
+ */
+
+#include "MyNode.h"
+
+namespace MyNode
+{
+
+MyNode::MyNode(std::string path, std::string nodeNamespace, std::string type, const std::atomic_bool* frontendConnected) : Flows::INode(path, nodeNamespace, type, frontendConnected)
+{
+	_stopThread = true;
+	_enabled = true;
+}
+
+MyNode::~MyNode()
+{
+	_stopThread = true;
+	waitForStop();
+}
+
+
+bool MyNode::init(Flows::PNodeInfo info)
+{
+	try
+	{
+		auto settingsIterator = info->info->structValue->find("period");
+		if(settingsIterator != info->info->structValue->end()) _period = Flows::Math::getNumber(settingsIterator->second->stringValue);
+
+		settingsIterator = info->info->structValue->find("dutycyclemin");
+		if(settingsIterator != info->info->structValue->end()) _dutyCycleMin = Flows::Math::getNumber(settingsIterator->second->stringValue);
+
+		settingsIterator = info->info->structValue->find("dutycyclemax");
+		if(settingsIterator != info->info->structValue->end()) _dutyCycleMax = Flows::Math::getNumber(settingsIterator->second->stringValue);
+
+		if(_dutyCycleMax <= _dutyCycleMin)
+		{
+			Flows::Output::printError("Error: Duty cycle maximum is smaller than or equal to duty cycle minimum. Setting both to defaults.");
+			_dutyCycleMin = 0;
+			_dutyCycleMax = 100;
+		}
+
+		if(_period < 10) _period = 10;
+
+		auto enabled = getNodeData("enabled");
+		if(enabled->type == Flows::VariableType::tBoolean) _enabled = enabled->booleanValue;
+
+		_startTimeAll = getNodeData("startTimeAll")->integerValue;
+		if(_startTimeAll == 0) _startTimeAll = Flows::HelperFunctions::getTimeSeconds();
+
+		_currentDutyCycle = getNodeData("dutycycle")->integerValue;
+
+		return true;
+	}
+	catch(const std::exception& ex)
+	{
+		Flows::Output::printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__, ex.what());
+	}
+	catch(...)
+	{
+		Flows::Output::printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__);
+	}
+	return false;
+}
+
+bool MyNode::start()
+{
+	try
+	{
+		if(!_enabled) return true;
+		std::lock_guard<std::mutex> timerGuard(_timerMutex);
+		_stopThread = false;
+		if(_timerThread.joinable()) _timerThread.join();
+		_timerThread = std::thread(&MyNode::timer, this);
+
+		return true;
+	}
+	catch(const std::exception& ex)
+	{
+		Flows::Output::printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__, ex.what());
+	}
+	catch(...)
+	{
+		Flows::Output::printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__);
+	}
+	return false;
+}
+
+void MyNode::stop()
+{
+	try
+	{
+		_stopThread = true;
+		setNodeData("startTimeAll", std::make_shared<Flows::Variable>(_startTimeAll));
+	}
+	catch(const std::exception& ex)
+	{
+		Flows::Output::printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__, ex.what());
+	}
+	catch(...)
+	{
+		Flows::Output::printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__);
+	}
+}
+
+void MyNode::waitForStop()
+{
+	try
+	{
+		std::lock_guard<std::mutex> timerGuard(_timerMutex);
+		if(_timerThread.joinable()) _timerThread.join();
+	}
+	catch(const std::exception& ex)
+	{
+		Flows::Output::printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__, ex.what());
+	}
+	catch(...)
+	{
+		Flows::Output::printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__);
+	}
+}
+
+int32_t MyNode::scale(int32_t value, int32_t valueMin, int32_t valueMax, int32_t scaleMin, int32_t scaleMax)
+{
+	double vPerc = ((double)(value - valueMin)) / (valueMax - valueMin);
+	double bigSpan = vPerc * (scaleMax - scaleMin);
+
+	return std::lround(scaleMin + bigSpan);
+}
+
+void MyNode::timer()
+{
+	int32_t pwmPosition = (Flows::HelperFunctions::getTimeSeconds() - _startTimeAll) % _period;
+	bool pwmState = pwmPosition <= _currentDutyCycle && _currentDutyCycle > _dutyCycleMin;
+	bool lastPwmState = pwmState;
+
+	Flows::PVariable message = std::make_shared<Flows::Variable>(Flows::VariableType::tStruct);
+	message->structValue->emplace("payload", std::make_shared<Flows::Variable>(pwmState));
+	output(0, message);
+
+	while(!_stopThread)
+	{
+		try
+		{
+			std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+			if(_stopThread) return;
+
+			pwmPosition = (Flows::HelperFunctions::getTimeSeconds() - _startTimeAll) % _period;
+			pwmState = pwmPosition <= _currentDutyCycle && _currentDutyCycle > _dutyCycleMin;
+			if(pwmState != lastPwmState)
+			{
+				lastPwmState = pwmState;
+				message->structValue->at("payload")->booleanValue = pwmState;
+				output(0, message);
+			}
+		}
+		catch(const std::exception& ex)
+		{
+			Flows::Output::printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__, ex.what());
+		}
+		catch(...)
+		{
+			Flows::Output::printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__);
+		}
+	}
+}
+
+void MyNode::input(Flows::PNodeInfo info, uint32_t index, Flows::PVariable message)
+{
+	try
+	{
+		if(index == 0)
+		{
+			int32_t dutyCycle = message->structValue->at("payload")->integerValue64;
+			if(dutyCycle > _dutyCycleMax) dutyCycle = _dutyCycleMax;
+			else if(dutyCycle < _dutyCycleMin) dutyCycle = _dutyCycleMin;
+			dutyCycle = std::lround((double)_period * (((double)(dutyCycle - _dutyCycleMin)) / (_dutyCycleMax - _dutyCycleMin)));
+			_currentDutyCycle = dutyCycle;
+			setNodeData("dutycycle", std::make_shared<Flows::Variable>(dutyCycle));
+		}
+		else if(index == 1)
+		{
+			_enabled = message->structValue->at("payload")->booleanValue;
+			setNodeData("enabled", std::make_shared<Flows::Variable>(_enabled));
+			Flows::PVariable status = std::make_shared<Flows::Variable>(Flows::VariableType::tStruct);
+			status->structValue->emplace("text", std::make_shared<Flows::Variable>(_enabled ? "enabled" : "disabled"));
+			nodeEvent("statusTop/" + _id, status);
+			std::lock_guard<std::mutex> timerGuard(_timerMutex);
+			_stopThread = true;
+			if(_timerThread.joinable()) _timerThread.join();
+			if(_enabled)
+			{
+				_startTimeAll = Flows::HelperFunctions::getTimeSeconds();
+				_stopThread = false;
+				_timerThread = std::thread(&MyNode::timer, this);
+			}
+		}
+	}
+	catch(const std::exception& ex)
+	{
+		Flows::Output::printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__, ex.what());
+	}
+	catch(...)
+	{
+		Flows::Output::printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__);
+	}
+}
+
+}
diff --git a/timers/slow-pwm/MyNode.h b/timers/slow-pwm/MyNode.h
new file mode 100644
index 00000000..efcf1ffe
--- /dev/null
+++ b/timers/slow-pwm/MyNode.h
@@ -0,0 +1,70 @@
+/* Copyright 2013-2017 Sathya Laufer
+ *
+ * Homegear is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Homegear is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Homegear.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * In addition, as a special exception, the copyright holders give
+ * permission to link the code of portions of this program with the
+ * OpenSSL library under certain conditions as described in each
+ * individual source file, and distribute linked combinations
+ * including the two.
+ * You must obey the GNU General Public License in all respects
+ * for all of the code used other than OpenSSL.  If you modify
+ * file(s) with this exception, you may extend this exception to your
+ * version of the file(s), but you are not obligated to do so.  If you
+ * do not wish to do so, delete this exception statement from your
+ * version.  If you delete this exception statement from all source
+ * files in the program, then also delete it here.
+ */
+
+#ifndef MYNODE_H_
+#define MYNODE_H_
+
+#include <homegear-node/INode.h>
+#include <thread>
+#include <mutex>
+
+namespace MyNode
+{
+
+class MyNode: public Flows::INode
+{
+public:
+	MyNode(std::string path, std::string nodeNamespace, std::string type, const std::atomic_bool* frontendConnected);
+	virtual ~MyNode();
+
+	virtual bool init(Flows::PNodeInfo info);
+	virtual bool start();
+	virtual void stop();
+	virtual void waitForStop();
+private:
+	std::atomic_bool _enabled;
+	uint32_t _period = 1800;
+	int32_t _dutyCycleMin = 0;
+	int32_t _dutyCycleMax = 100;
+	std::atomic<int32_t> _currentDutyCycle;
+
+	int32_t _startTimeAll = 0;
+
+	std::mutex _timerMutex;
+	std::atomic_bool _stopThread;
+	std::thread _timerThread;
+
+	int32_t scale(int32_t value, int32_t valueMin, int32_t valueMax, int32_t scaleMin, int32_t scaleMax);
+	void timer();
+	virtual void input(Flows::PNodeInfo info, uint32_t index, Flows::PVariable message);
+};
+
+}
+
+#endif
diff --git a/timers/slow-pwm/locales/en-US/slow-pwm b/timers/slow-pwm/locales/en-US/slow-pwm
new file mode 100644
index 00000000..8fe1da79
--- /dev/null
+++ b/timers/slow-pwm/locales/en-US/slow-pwm
@@ -0,0 +1,17 @@
+{
+  "timers/slow-pwm.hni": {
+    "slow-pwm": {
+      "label": {
+        "period": "Period",
+        "period2": "Period in seconds",
+        "dutycyclemin": "Minimum duty cycle value",
+        "dutycyclemax": "Maximum duty cycle value",
+        "name": "Name"
+      },
+      "input1Description": "The duty cycle.",
+      "output1Description": "Outputs \"true\" on high and \"false\" on low value.",
+      "paletteHelp": "<p>Generates a PWM signal.</p>",
+      "help": "This node generates a slow PWM signal. Input the duty cycle lenght to <code>D</code>. Set <code>Period</code> to the period in seconds. The minimum period is 10 seconds, the duty cycle resolution is 1 second. Set <code>EN</code> to \"false\" to disable the PWM."
+    }
+  }
+}
diff --git a/timers/slow-pwm/slow-pwm.hni b/timers/slow-pwm/slow-pwm.hni
new file mode 100644
index 00000000..f4eba8cf
--- /dev/null
+++ b/timers/slow-pwm/slow-pwm.hni
@@ -0,0 +1,62 @@
+<script type="text/x-homegear">
+{
+    "name": "slow-pwm",
+    "readableName": "Slow PWM",
+    "version": "0.0.1",
+    "maxThreadCount": 1
+}
+</script>
+<script type="text/x-red" data-template-name="slow-pwm">
+    <div class="form-row">
+        <label for="node-input-name"><i class="fa fa-tag"></i> <span data-i18n="common.label.name"></span></label>
+        <input type="text" id="node-input-name" data-i18n="[placeholder]common.label.name"/>
+    </div>
+    <div class="form-row">
+        <label for="node-input-period"><i class="fa fa-id-badge"></i> <span data-i18n="slow-pwm.label.period"></span></label>
+        <input type="text" id="node-input-period" data-i18n="[placeholder]slow-pwm.label.period2">
+    </div>
+    <div class="form-row">
+        <label for="node-input-dutycyclemin"><i class="fa fa-id-badge"></i> <span data-i18n="slow-pwm.label.dutycyclemin"></span></label>
+        <input type="text" id="node-input-dutycyclemin">
+    </div>
+    <div class="form-row">
+        <label for="node-input-dutycyclemax"><i class="fa fa-id-badge"></i> <span data-i18n="slow-pwm.label.dutycyclemax"></span></label>
+        <input type="text" id="node-input-dutycyclemax">
+    </div>
+</script>
+<script type="text/javascript">
+    RED.nodes.registerType('slow-pwm',{
+        category: 'time',
+        namespace: 'timers',
+        color:"#FFCC66",
+        defaults: {
+            period: {value:"",required:true,validate:RED.validators.number()},
+            dutycyclemin: {value:"0",required:true,validate:RED.validators.number()},
+            dutycyclemax: {value:"100",required:true,validate:RED.validators.number()},
+            name: {value:""}
+        },
+        inputs:2,
+        inputInfo: [
+            {
+                label: "D",
+                types: ["int"]
+            },
+            {
+                label: "EN",
+                types: ["boolean"]
+            }
+        ],
+        outputs:1,
+        outputInfo: [
+            {
+                label: "p",
+                types: ["boolean"]
+            }
+        ],
+        icon: "serial.png",
+        label: function() {
+            if(this.name) return this.name;
+            return "slow-pwm";
+        }
+    });
+</script>
diff --git a/timers/sun-position/MyNode.cpp b/timers/sun-position/MyNode.cpp
index 4963563f..7d351c6f 100644
--- a/timers/sun-position/MyNode.cpp
+++ b/timers/sun-position/MyNode.cpp
@@ -139,6 +139,18 @@ void MyNode::waitForStop()
 void MyNode::timer()
 {
 	int32_t i = 0;
+	{
+		std::random_device rd;
+		std::mt19937 gen(rd());
+		std::uniform_int_distribution<> dis(0, 60);
+		int32_t randomInterval = dis(gen);
+		for(i = 0; i < randomInterval; i++)
+		{
+			std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+			if(_stopThread) break;
+		}
+	}
+
 	Flows::PVariable message = std::make_shared<Flows::Variable>(Flows::VariableType::tStruct);
 	Flows::PVariable sunPositionPayload = std::make_shared<Flows::Variable>(Flows::VariableType::tStruct);
 	message->structValue->emplace("payload", sunPositionPayload);
@@ -151,6 +163,7 @@ void MyNode::timer()
 				std::this_thread::sleep_for(std::chrono::milliseconds(1000));
 				if(_stopThread) break;
 			}
+			if(_stopThread) break;
 			auto sunPosition = _sunTime.getPosition(Flows::HelperFunctions::getTime(), _latitude, _longitude);
 			sunPositionPayload->structValue->clear();
 			sunPositionPayload->structValue->emplace("azimuth", std::make_shared<Flows::Variable>((double)sunPosition.azimuth));
diff --git a/timers/sun-position/MyNode.h b/timers/sun-position/MyNode.h
index a91d7c17..75ffa586 100644
--- a/timers/sun-position/MyNode.h
+++ b/timers/sun-position/MyNode.h
@@ -34,6 +34,7 @@
 #include <homegear-node/INode.h>
 #include <thread>
 #include <mutex>
+#include <random>
 
 namespace MyNode
 {
diff --git a/timers/sun-position/SunTime.h b/timers/sun-position/SunTime.h
index 80c56ab0..b8d85d0e 100644
--- a/timers/sun-position/SunTime.h
+++ b/timers/sun-position/SunTime.h
@@ -46,6 +46,7 @@
 #include <homegear-node/HelperFunctions.h>
 #include <unordered_map>
 #include <vector>
+#include <cmath>
 
 namespace MyNode
 {
diff --git a/timers/timer/MyNode.h b/timers/timer/MyNode.h
index d0bf71fb..2045dc38 100644
--- a/timers/timer/MyNode.h
+++ b/timers/timer/MyNode.h
@@ -51,7 +51,7 @@ class MyNode: public Flows::INode
 	virtual void waitForStop();
 private:
 	SunTime _sunTime;
-	bool _enabled = false;
+	std::atomic_bool _enabled;
 	bool _outputOnStartUp = false;
 	std::string _onTime;
 	std::string _onTimeType;
diff --git a/timers/timer/SunTime.h b/timers/timer/SunTime.h
index 80c56ab0..b8d85d0e 100644
--- a/timers/timer/SunTime.h
+++ b/timers/timer/SunTime.h
@@ -46,6 +46,7 @@
 #include <homegear-node/HelperFunctions.h>
 #include <unordered_map>
 #include <vector>
+#include <cmath>
 
 namespace MyNode
 {
diff --git a/variable/constant/MyNode.cpp b/variable/constant/MyNode.cpp
index 2c6c1dab..6336b5ce 100644
--- a/variable/constant/MyNode.cpp
+++ b/variable/constant/MyNode.cpp
@@ -62,11 +62,15 @@ bool MyNode::init(Flows::PNodeInfo info)
 		{
 			_value->setType(Flows::VariableType::tInteger64);
 			_value->integerValue64 = Flows::Math::getNumber64(payload);
+			_value->integerValue = (int32_t)_value->integerValue64;
+			_value->floatValue = _value->integerValue64;
 		}
 		else if(payloadType == "float")
 		{
 			_value->setType(Flows::VariableType::tFloat);
 			_value->floatValue = Flows::Math::getDouble(payload);
+			_value->integerValue = _value->floatValue;
+			_value->integerValue64 = _value->floatValue;
 		}
 		else if(payloadType == "string")
 		{
diff --git a/variable/variable-out/variable-out.hni b/variable/variable-out/variable-out.hni
index 78d80a1c..8abec7da 100644
--- a/variable/variable-out/variable-out.hni
+++ b/variable/variable-out/variable-out.hni
@@ -286,12 +286,6 @@
                     updatePeerIdOptions();
                 });
             //}}}
-        },
-        oneditsave: function() {
-            if(!$("#node-input-peerid").val()) $("#node-input-peerid").val("0");
-            if(!$("#node-input-channel").val()) $("#node-input-channel").val("-1");
-            if(!$("#node-input-variabletext").val()) $("#node-input-variabletext").val($("#node-input-variable").val());
-            if(!$("#node-input-variable").val()) $("#node-input-variable").val($("#node-input-variabletext").val());
         }
     });
 </script>