diff --git a/system_modules/napaudio/src/audio/component/levelmetercomponent.cpp b/system_modules/napaudio/src/audio/component/levelmetercomponent.cpp
index 2fdd1dfc85..4e68b80ca9 100755
--- a/system_modules/napaudio/src/audio/component/levelmetercomponent.cpp
+++ b/system_modules/napaudio/src/audio/component/levelmetercomponent.cpp
@@ -49,6 +49,7 @@ namespace nap
 			
 			mMeter = nodeManager.makeSafe<LevelMeterNode>(nodeManager, mResource->mAnalysisWindowSize);
 			mMeter->setType(mResource->mMeterType);
+			nodeManager.registerRootProcess(mMeter.get());
 			
 			if (mResource->mFilterInput)
 			{
diff --git a/system_modules/napaudio/src/audio/component/outputcomponent.cpp b/system_modules/napaudio/src/audio/component/outputcomponent.cpp
index 9bfe46b97e..f6f5848e41 100644
--- a/system_modules/napaudio/src/audio/component/outputcomponent.cpp
+++ b/system_modules/napaudio/src/audio/component/outputcomponent.cpp
@@ -60,6 +60,7 @@ namespace nap
 					// If the channel is out of bounds we create a PullNode instead of an OutputNode in order to process the connected DSP branch.
 					auto pullNode = nodeManager.makeSafe<PullNode>(nodeManager);
 					pullNode->audioInput.connect(*mInput->getOutputForChannel(mChannelRouting[channel]));
+					nodeManager.registerRootProcess(pullNode.get());
 					mOutputs.emplace_back(std::move(pullNode));
 					continue;
 				}
@@ -67,6 +68,7 @@ namespace nap
 					auto outputNode = nodeManager.makeSafe<OutputNode>(nodeManager);
 					outputNode->setOutputChannel(channel);
 					outputNode->audioInput.connect(*mInput->getOutputForChannel(mChannelRouting[channel]));
+					nodeManager.registerRootProcess(outputNode.get());
 					mOutputs.emplace_back(std::move(outputNode));
 				}
 			}
diff --git a/system_modules/napaudio/src/audio/core/audionodemanager.cpp b/system_modules/napaudio/src/audio/core/audionodemanager.cpp
index 83111e4408..6e1f45045a 100644
--- a/system_modules/napaudio/src/audio/core/audionodemanager.cpp
+++ b/system_modules/napaudio/src/audio/core/audionodemanager.cpp
@@ -57,7 +57,8 @@ namespace nap
 
 				{
 					for (auto& root : mRootProcesses)
-						root->process();
+						if (root != nullptr)
+							root->update();
 				}
 
 				for (auto channel = 0; channel < mOutputChannelCount; ++channel) {
@@ -101,7 +102,8 @@ namespace nap
 
 				{
 					for (auto& root : mRootProcesses)
-						root->update();
+						if (root != nullptr)
+							root->update();
 				}
 
 				for (auto channel = 0; channel < mOutputChannelCount; ++channel) {
@@ -162,40 +164,59 @@ namespace nap
 		}
 
 
-		void NodeManager::registerProcess(Process& process)
+		void NodeManager::registerProcess(SafePtr<Process> process)
 		{
-			process.setSampleRate(mSampleRate);
-			process.setBufferSize(mInternalBufferSize);
+			process->setSampleRate(mSampleRate);
+			process->setBufferSize(mInternalBufferSize);
 			auto oldSampleRate = mSampleRate;
 			auto oldBufferSize = mInternalBufferSize;
-			enqueueTask([&, oldSampleRate, oldBufferSize]() {
+
+			enqueueTask([&, oldSampleRate, oldBufferSize, process]() {
+				// Check if the Process is not (being) deleted
+				if (process == nullptr)
+					return;
+
 				// In the extremely rare case the buffersize or the samplerate of the node manager have been changed in between the enqueueing of the task and its execution on the audio thread, we set them again.
 				// However we prefer not to, in order to avoid memory allocation on the audio thread.
 				if (oldSampleRate != mSampleRate)
-					process.setSampleRate(mSampleRate);
+					process->setSampleRate(mSampleRate);
 				if (oldBufferSize != mInternalBufferSize)
-					process.setBufferSize(mInternalBufferSize);
-				process.mRegisteredWithNodeManager.store(true);
-				mProcesses.emplace(&process);
+					process->setBufferSize(mInternalBufferSize);
+				process->mRegisteredWithNodeManager.store(true);
+				mProcesses.emplace_back(process.get());
 			});
 		}
 
 
 		void NodeManager::unregisterProcess(Process& process)
 		{
-			mProcesses.erase(&process);
+			auto it = std::find_if(mProcesses.begin(), mProcesses.end(), [&](auto& el){ return el == &process; });
+			if (it != mProcesses.end())
+				mProcesses.erase(it);
 		}
 
 
-		void NodeManager::registerRootProcess(Process& rootProcess)
+		void NodeManager::registerRootProcess(SafePtr<Process> rootProcess)
 		{
-			enqueueTask([&]() { mRootProcesses.emplace(&rootProcess); });
+			enqueueTask([&, rootProcess]()
+			{
+				if (rootProcess == nullptr)
+					return;
+				mRootProcesses.emplace_back(rootProcess);
+			});
 		}
 
 
-		void NodeManager::unregisterRootProcess(Process& rootProcess)
+		void NodeManager::unregisterRootProcess(SafePtr<Process> rootProcess)
 		{
-			mRootProcesses.erase(&rootProcess);
+			enqueueTask([&, rootProcess]()
+			{
+				if (rootProcess == nullptr)
+					return;
+				auto it = std::find_if(mRootProcesses.begin(), mRootProcesses.end(), [&](auto &el){ return el.get() == rootProcess.get(); });
+				if (it != mRootProcesses.end())
+					mRootProcesses.erase(it);
+			});
 		}
 
 
diff --git a/system_modules/napaudio/src/audio/core/audionodemanager.h b/system_modules/napaudio/src/audio/core/audionodemanager.h
index 474463315e..cbce7b32b3 100644
--- a/system_modules/napaudio/src/audio/core/audionodemanager.h
+++ b/system_modules/napaudio/src/audio/core/audionodemanager.h
@@ -136,19 +136,20 @@ namespace nap
 			void setInternalBufferSize(int size);
 
 			/**
-			 * Used by nodes to register themselves to be processed directly by the node manager
+			 * Use this to register a Process as root process. Called from control thread.
 			 * @param rootProcess The root process is a process or node that is executed on every audio callback without being connected to an input of another node.
 			 * In most cases the root process is an OutputNode.
 			 */
-			void registerRootProcess(Process& rootProcess);
+			void registerRootProcess(SafePtr<Process> rootProcess);
 
 
 			/**
-			 * Used by nodes to unregister themselves to be processed directly by the node manager.
+			 * Use this to manually unregister a Process as root process. Called from control thread.
+			 * Note: Processes also unregister themselves as root process automatically from their destructors.
 			 * @param rootProcess The root process is a process or node that is executed on every audio callback without being connected to an input of another node.
 			 * In most cases the root process is an OutputNode.
 			 */
-			void unregisterRootProcess(Process& rootProcess);
+			void unregisterRootProcess(SafePtr<Process> rootProcess);
 
 			/**
 			 * Constructs an object managed by a SafeOwner that will dispose the object in the NodeManager's DeletionQueue when it is no longer used.
@@ -161,6 +162,15 @@ namespace nap
 			SafeOwner<T> makeSafe(Args&& ... args)
 			{
 				auto owner = SafeOwner<T>(mDeletionQueue, new T(std::forward<Args>(args)...));
+
+				// If the newly constructed object is a Process, set its internal SafePtr to itself, and register it.
+				Process* process = rtti_cast<Process>(owner.getRaw());
+				if (process != nullptr)
+				{
+					process->mSelf = owner.get();
+					registerProcess(owner.get());
+				}
+
 				return owner;
 			}
 
@@ -175,6 +185,15 @@ namespace nap
 			SafeOwner<T> makeSafe(T* ptr)
 			{
 				auto owner = SafeOwner<T>(mDeletionQueue, ptr);
+
+				// If the newly constructed object is a Process, set its internal SafePtr to itself, and register it.
+				Process* process = rtti_cast<Process>(owner.getRaw());
+				if (process != nullptr)
+				{
+					process->mSelf = owner.get();
+					registerProcess(owner.get());
+				}
+
 				return owner;
 			}
 
@@ -191,7 +210,7 @@ namespace nap
 
 		private:
 			// Used by the nodes and audio processes to register themselves on construction
-			void registerProcess(Process& process);
+			void registerProcess(SafePtr<Process> process);
 
 			// Used by the nodes and audio processes to unregister themselves on destruction
 			void unregisterProcess(Process& process);
@@ -230,8 +249,8 @@ namespace nap
 
 			std::vector<float*> mInputBuffer; //  Pointing to the audio input that this node manager has to process. The format is a non-interleaved array containing a float array for each channel.
 
-			std::set<Process*> mProcesses; // all the audio processes managed by this node manager
-			std::set<Process*> mRootProcesses; // the nodes that will be processed directly by the manager on every audio callback
+			std::vector<Process*> mProcesses; // all the audio processes managed by this node manager
+			std::vector<SafePtr<Process>> mRootProcesses; // the nodes that will be processed directly by the manager on every audio callback
 
 			nap::TaskQueue mTaskQueue = { 256 }; // Queue with lambda functions to be executed before processing the next internal buffer.
 			DeletionQueue& mDeletionQueue; // Deletion queue used to safely create and destruct nodes in a threadsafe manner.
diff --git a/system_modules/napaudio/src/audio/core/audiopin.cpp b/system_modules/napaudio/src/audio/core/audiopin.cpp
index 022c68e992..18a6856e97 100644
--- a/system_modules/napaudio/src/audio/core/audiopin.cpp
+++ b/system_modules/napaudio/src/audio/core/audiopin.cpp
@@ -4,13 +4,15 @@
 
 #include "audiopin.h"
 
-// Std includes
-#include <cassert>
-
 // Audio includes
 #include <audio/core/audionode.h>
 #include <audio/core/audionodemanager.h>
 
+#include <nap/logger.h>
+
+// Std includes
+#include <cassert>
+
 RTTI_BEGIN_CLASS_NO_DEFAULT_CONSTRUCTOR(nap::audio::InputPinBase)
 	RTTI_FUNCTION("connect", &nap::audio::InputPinBase::connect)
 	RTTI_FUNCTION("disconnect", &nap::audio::InputPinBase::disconnect)
@@ -45,42 +47,98 @@ namespace nap
 		}
 
 
-		void InputPinBase::connect(OutputPin& connection)
+		void InputPinBase::connect(OutputPin& pinToConnect)
 		{
-			auto connectionPtr = &connection;
+			auto outputPin = &pinToConnect;
+			auto inputPin = this;
+			
+			// Get the safeptrs of the nodes to pass to the lambda, so these ptrs can be checked before trying to make a connection (preventing calling connectNow() with Nodes that are (being) removed).
+			auto inputNode = getNode().getSafe();
+			auto outputNode = outputPin->getNode().getSafe();
+
+			getNode().getNodeManager().enqueueTask([inputPin, outputPin, inputNode, outputNode](){
+				if (inputNode != nullptr && outputNode != nullptr)
+				{
+					auto inputNodeRaw = rtti_cast<Node>(inputNode.get());
+					auto outputNodeRaw = rtti_cast<Node>(outputNode.get());
+					assert(inputNodeRaw != nullptr);
+					assert(outputNodeRaw != nullptr);
+					if (inputNodeRaw->mInputs.find(inputPin) == inputNodeRaw->mInputs.end())
+					{
 
-			getNode().getNodeManager().enqueueTask([&, connectionPtr](){
-				connectNow(*connectionPtr);
+						Logger::warn("InputPinBase::connect(): Input pin not found for Node with type: %s", inputNodeRaw->get_type().get_name().to_string().c_str());
+					}
+					else if (outputNodeRaw->mOutputs.find(outputPin) == outputNodeRaw->mOutputs.end())
+					{
+						Logger::warn("InputPinBase::connect(): Output pin not found for Node with type: %s", outputNodeRaw->get_type().get_name().to_string().c_str());
+					}
+					else
+						inputPin->connectNow(*outputPin);
+				}
 			});
 		}
 
 
-		void InputPinBase::disconnect(OutputPin& connection)
+		void InputPinBase::disconnect(OutputPin& pinToDisconnect)
 		{
-			auto connectionPtr = &connection;
+			auto outputPin = &pinToDisconnect;
+			auto inputPin = this;
+			auto inputNode = getNode().getSafe();
+			auto outputNode = outputPin->getNode().getSafe();
 
-			getNode().getNodeManager().enqueueTask([&, connectionPtr]() {
-				disconnectNow(*connectionPtr);
+			getNode().getNodeManager().enqueueTask([inputPin, outputPin, inputNode, outputNode]() {
+				if (inputNode != nullptr && outputNode != nullptr)
+				{
+					auto inputNodeRaw = rtti_cast<Node>(inputNode.get());
+					auto outputNodeRaw = rtti_cast<Node>(outputNode.get());
+					assert(inputNodeRaw != nullptr);
+					assert(outputNodeRaw != nullptr);
+					if (inputNodeRaw->mInputs.find(inputPin) == inputNodeRaw->mInputs.end())
+					{
+
+						Logger::warn("InputPinBase::disconnect(): Input pin not found for Node with type: %s", inputNodeRaw->get_type().get_name().to_string().c_str());
+					}
+					else if (outputNodeRaw->mOutputs.find(outputPin) == outputNodeRaw->mOutputs.end())
+					{
+						Logger::warn("InputPinBase::disconnect(): Output pin not found for Node with type: %s", outputNodeRaw->get_type().get_name().to_string().c_str());
+					}
+					else
+						inputPin->disconnectNow(*outputPin);
+				}
 			});
 		}
 
 
 		void InputPinBase::disconnectAll()
 		{
-			getNode().getNodeManager().enqueueTask([&]() {
-				disconnectAllNow();
+			auto node = getNode().getSafe();
+			auto inputPin = this;
+
+			getNode().getNodeManager().enqueueTask([inputPin, node]() {
+				if (node != nullptr)
+				{
+					auto nodeRaw = rtti_cast<Node>(node.get());
+					assert(nodeRaw != nullptr);
+					if (nodeRaw->mInputs.find(inputPin) == nodeRaw->mInputs.end())
+					{
+						Logger::warn("InputPinBase::disconnectAll(): Input pin not found for Node with type: %s", nodeRaw->get_type().get_name().to_string().c_str());
+
+					}
+					else
+						inputPin->disconnectAllNow();
+				}
 			});
 		}
 
 
 		// --- InputPin --- //
-		
+
 		InputPin::~InputPin()
 		{
 			disconnectAllNow();
 		}
-		
-		
+
+
 		SampleBuffer* InputPin::pull()
 		{
 			if (mInput)
@@ -88,8 +146,8 @@ namespace nap
 			else
 				return nullptr;
 		}
-		
-		
+
+
 		void InputPin::connectNow(OutputPin& connection)
 		{
 			// remove old connection
@@ -100,8 +158,8 @@ namespace nap
 			mInput = &connection;
 			mInput->mOutputs.emplace(this);
 		}
-		
-		
+
+
 		void InputPin::disconnectNow(OutputPin& connection)
 		{
 			if (&connection == mInput)
@@ -110,8 +168,8 @@ namespace nap
 				mInput = nullptr;
 			}
 		}
-		
-		
+
+
 		void InputPin::disconnectAllNow()
 		{
 			if (mInput)
@@ -120,33 +178,33 @@ namespace nap
 				mInput = nullptr;
 			}
 		}
-		
-		
+
+
 		// --- MultiInputPin ---- //
-		
+
 		MultiInputPin::MultiInputPin(Node* node, unsigned int reservedInputCount) : InputPinBase(node)
 		{
 			mInputsCache.reserve(reservedInputCount);
 		}
-		
-		
+
+
 		MultiInputPin::~MultiInputPin()
 		{
 			disconnectAllNow();
 		}
-		
-		
+
+
 		void MultiInputPin::pull(std::vector<SampleBuffer*>& result)
 		{
 			// Make a copy of mInputs because its contents can change while pulling its content.
 			mInputsCache = mInputs;
-			
+
 			result.resize(mInputsCache.size());
 			for (auto i = 0; i < mInputsCache.size(); ++i)
 				result[i] = mInputsCache[i]->pull();
 		}
-		
-		
+
+
 		void MultiInputPin::connectNow(OutputPin& connection)
 		{
 			auto it = std::find(mInputs.begin(), mInputs.end(), &connection);
@@ -154,8 +212,8 @@ namespace nap
 				mInputs.emplace_back(&connection);
 			connection.mOutputs.emplace(this);
 		}
-		
-		
+
+
 		void MultiInputPin::disconnectNow(OutputPin& connection)
 		{
 			auto it = std::find(mInputs.begin(), mInputs.end(), &connection);
@@ -177,42 +235,42 @@ namespace nap
 			}
 			mInputsCache.clear();
 		}
-		
-		
+
+
 		void MultiInputPin::reserveInputs(unsigned int inputCount)
 		{
 			mInputsCache.shrink_to_fit();
 			mInputsCache.reserve(inputCount);
 		}
-		
-		
-		
+
+
+
 		// --- OutputPin --- //
-		
-		
+
+
 		OutputPin::OutputPin(Node* node)
 		{
 			node->mOutputs.emplace(this);
 			mNode = node;
 			setBufferSize(mNode->getBufferSize());
 		}
-		
-		
+
+
 		OutputPin::~OutputPin()
 		{
 			mNode->mOutputs.erase(this);
 			disconnectAllNow();
 		}
-		
-		
+
+
 		void OutputPin::disconnectAll()
 		{
 			getNode().getNodeManager().enqueueTask([&]() {
 				disconnectAllNow();
 			});
 		}
-		
-		
+
+
 		SampleBuffer* OutputPin::pull()
 		{
 			mNode->update();
diff --git a/system_modules/napaudio/src/audio/core/multichannel.cpp b/system_modules/napaudio/src/audio/core/multichannel.cpp
index d5f66b580a..56fa9bc587 100644
--- a/system_modules/napaudio/src/audio/core/multichannel.cpp
+++ b/system_modules/napaudio/src/audio/core/multichannel.cpp
@@ -24,14 +24,28 @@ namespace nap
 			if (channel < getInputChannelCount())
 				connect(channel, pin);
 		}
-		
-		
+
+
+		void IMultiChannelInput::tryDisconnect(unsigned int channel, OutputPin& pin)
+		{
+			if (channel < getInputChannelCount())
+				disconnect(channel, pin);
+		}
+
+
 		void IMultiChannelInput::connect(IMultiChannelOutput& inputObject)
 		{
 			for (auto channel = 0; channel < getInputChannelCount(); ++channel)
 				connect(channel, *inputObject.getOutputForChannel(channel % inputObject.getChannelCount()));
 		}
-		
+
+
+		void IMultiChannelInput::disconnect(IMultiChannelOutput& inputObject)
+		{
+			for (auto channel = 0; channel < getInputChannelCount(); ++channel)
+				disconnect(channel, *inputObject.getOutputForChannel(channel % inputObject.getChannelCount()));
+		}
+
 	}
 	
 }
diff --git a/system_modules/napaudio/src/audio/core/multichannel.h b/system_modules/napaudio/src/audio/core/multichannel.h
index ad8bf4b84f..b096c908de 100644
--- a/system_modules/napaudio/src/audio/core/multichannel.h
+++ b/system_modules/napaudio/src/audio/core/multichannel.h
@@ -58,17 +58,24 @@ namespace nap
 			virtual ~IMultiChannelInput() = default;
 
 			/**
-			 * This method has to be overwritten to connect an output pin from another object to this object's input.
+			 * This method has to be overwritten by descendants.
+			 * @return the number of input channels of audio this object receives.
+			 */
+			virtual int getInputChannelCount() const { return 0; }
+
+			/**
+			 * Needs to be overwritten to connect pin to the input(s) for the given channel.
 			 * @param channel index of the channel to connect to
 			 * @param pin pin that will be connected to this object
 			 */
-			virtual void connect(unsigned int channel, OutputPin& pin) { }
+			virtual void connect(unsigned int channel, OutputPin& pin) { assert(false); }
 
 			/**
-			 * This method has to be overwritten by descendants.
-			 * @return the number of input channels of audio this object receives.
+			 * Needs to be overwritten to disconnect pin from the input(s) for the given channel
+			 * @param channel index of the channel to disconnect from
+			 * @param pin pin that will be disconnected from this object
 			 */
-			virtual int getInputChannelCount() const { return 0; }
+			virtual void disconnect(unsigned int channel, OutputPin& pin) { assert(false); }
 
 			/**
 			 * This method calls connect() but first checks wether the given channel is not out of bounds.
@@ -77,12 +84,27 @@ namespace nap
 			 */
 			void tryConnect(unsigned int channel, OutputPin& pin);
 
+			/**
+			 * This method calls disconnect() but first checks wether the given channel is not out of bounds.
+			 * @param channel channel index to connect to
+			 * @param pin pin that will be connected to this object
+			 */
+			void tryDisconnect(unsigned int channel, OutputPin& pin);
+
 			/**
 			 * Convenience method that connects the outputs of inputObject to the inputs of this object.
 			 * If this object has more input channels than inputObject has output channels they will be repeated.
 			 * @param inputObject object to be connected to this object
 			 */
 			void connect(IMultiChannelOutput& inputObject);
+
+			/**
+			 * Convenience method that disconnects the outputs of inputObject from the inputs of this object.
+			 * If this object has more input channels than inputObject has output channels they will be repeated.
+			 * @param inputObject object to be connected to this object
+			 */
+			void disconnect(IMultiChannelOutput& inputObject);
+
 		};
 	}
 }
diff --git a/system_modules/napaudio/src/audio/core/process.cpp b/system_modules/napaudio/src/audio/core/process.cpp
index 3d62a1d600..800feb211c 100644
--- a/system_modules/napaudio/src/audio/core/process.cpp
+++ b/system_modules/napaudio/src/audio/core/process.cpp
@@ -4,7 +4,6 @@
 
 #include "process.h"
 
-#include <audio/core/audionode.h>
 #include <audio/core/audionodemanager.h>
 #include <audio/core/audiopin.h>
 
@@ -22,18 +21,22 @@ namespace nap
 
 		Process::Process(NodeManager& nodeManager) : mNodeManager(&nodeManager)
 		{
-			mNodeManager->registerProcess(*this);
 		}
 
 
 		Process::Process(ParentProcess& parent) : mNodeManager(&parent.getNodeManager())
 		{
-			mNodeManager->registerProcess(*this);
 		}
 
 
 		Process::~Process()
 		{
+			// Unregister as root process, if needed
+			auto it = std::find_if(getNodeManager().mRootProcesses.begin(), getNodeManager().mRootProcesses.end(), [&](auto& e){ return e.get() == this; });
+			if (it != getNodeManager().mRootProcesses.end())
+				getNodeManager().mRootProcesses.erase(it);
+
+			// Unregister as process
 			if (mRegisteredWithNodeManager.load())
 				getNodeManager().unregisterProcess(*this);
 		}
@@ -72,9 +75,15 @@ namespace nap
 		
 		void ParentProcess::addChild(Process& child)
 		{
-			auto childPtr = &child;
-			getNodeManager().enqueueTask([&, childPtr]() {
-				auto it = std::find(mChildren.begin(), mChildren.end(), childPtr);
+			auto childPtr = child.getSafe();
+			auto parentPtr = getSafe();
+			getNodeManager().enqueueTask([&, parentPtr, childPtr]() {
+				// Check if parent and child are still valid
+				if (parentPtr == nullptr || childPtr == nullptr)
+					return;
+
+				// Check for duplicates
+				auto it = std::find_if(mChildren.begin(), mChildren.end(), [&](auto& e){ return e.get() == childPtr.get(); });
 				if (it == mChildren.end())
 					mChildren.emplace_back(childPtr);
 			});
@@ -83,9 +92,14 @@ namespace nap
 		
 		void ParentProcess::removeChild(Process& child)
 		{
-			auto childPtr = &child;
-			getNodeManager().enqueueTask([&, childPtr]() {
-				auto it = std::find(mChildren.begin(), mChildren.end(), childPtr);
+			auto childPtr = child.getSafe();
+			auto parentPtr = getSafe();
+			getNodeManager().enqueueTask([&, parentPtr, childPtr]() {
+				// Check if parent and child are still valid
+				if (parentPtr == nullptr || childPtr == nullptr)
+					return;
+
+				auto it = std::find_if(mChildren.begin(), mChildren.end(), [&](auto& e){ return e.get() == childPtr.get(); });
 				if (it != mChildren.end())
 					mChildren.erase(it);
 			});
@@ -96,7 +110,7 @@ namespace nap
 		{
 			for (auto& child : mChildren)
 			{
-				if (child != nullptr)
+				if (child != nullptr) // Check if the child is not enqueued for deletion in the meantime
 					child->update();
 			}
 		}
@@ -112,7 +126,7 @@ namespace nap
 					auto i = threadIndex;
 					while (i < mChildren.size()) {
 						auto& child = mChildren[i];
-						if (child != nullptr)
+						if (child != nullptr) // Check if the child is not enqueued for deletion in the meantime
 							child->update();
 						i += mThreadPool.getThreadCount();
 					}
@@ -125,6 +139,16 @@ namespace nap
 		
 		void ParentProcess::process()
 		{
+			// First remove children that are (being) deleted or enqueued for deletion
+			auto it = mChildren.begin();
+			while (it != mChildren.end())
+			{
+				if ((*it) == nullptr)
+					it = mChildren.erase(it);
+				else
+					it++;
+			}
+
 			switch (mMode)
 			{
 				case Mode::Sequential:
diff --git a/system_modules/napaudio/src/audio/core/process.h b/system_modules/napaudio/src/audio/core/process.h
index ec8c5cf5d9..8b7d582072 100644
--- a/system_modules/napaudio/src/audio/core/process.h
+++ b/system_modules/napaudio/src/audio/core/process.h
@@ -88,6 +88,11 @@ namespace nap
 			 */
 			DiscreteTimeValue getSampleTime() const;
 
+			/**
+			 * Returns SafePtr to this Process.
+			 */
+			SafePtr<Process> getSafe() { return mSelf; }
+
 		protected:
 			/**
 			 * Called whenever the sample rate that the node system runs on changes.
@@ -131,6 +136,8 @@ namespace nap
 
 			// Set to true when the node has made itself known with the node manager. This registration is deferred to the audio thread so it has to be tracked by this boolean.
 			std::atomic<bool> mRegisteredWithNodeManager = { false };
+
+			SafePtr<Process> mSelf = nullptr; // This is a safe pointer to self that is set by NodeManager::makeSafe(). It can be used to check whether the Process is not deleted or being deleted.
 		};
 
 
@@ -178,24 +185,13 @@ namespace nap
 			 */
 			void removeChild(Process& child);
 
-			/**
-			 * Directly triggers parallel processing of all child processes.
-			 * Child processes will be processed simultaneously on different threads in the ThreadPool.
-			 */
-			void processParallel();
-
-			/**
-			 * Directly triggers sequential (or serial) processing of all child processes.
-			 */
-			void processSequential();
-
 			/**
 			 * Process method chooses between parallel or sequential processing of the children according to mode specified by the setMode() method.
 			 */
 			void process() override;
 
 			/**
-			 * Specifies wether the child processes will be processed in parallel or sequential mode.
+			 * Specifies whether the child processes will be processed in parallel or sequential mode.
 			 * In case of parallel processing the child processes are triggered simultaneously on different threads in the ThreadPool.
 			 * In case of sequential processing they are processed one by one on the caller thread.
 			 */
@@ -207,9 +203,20 @@ namespace nap
 			Mode getMode() const { return mMode.load(); }
 
 		private:
+			/**
+			 * Directly triggers parallel processing of all child processes.
+			 * Child processes will be processed simultaneously on different threads in the ThreadPool.
+			 */
+			void processParallel();
+
+			/**
+			 * Directly triggers sequential (or serial) processing of all child processes.
+			 */
+			void processSequential();
+
 			ThreadPool& mThreadPool;
 			AsyncObserver& mAsyncObserver;
-			std::vector<Process*> mChildren;
+			std::vector<SafePtr<Process>> mChildren;
 			std::atomic<Mode> mMode = {Mode::Sequential};
 		};
 
diff --git a/system_modules/napaudio/src/audio/node/filternode.cpp b/system_modules/napaudio/src/audio/node/filternode.cpp
index 76d0b1d235..7927b9b8d4 100644
--- a/system_modules/napaudio/src/audio/node/filternode.cpp
+++ b/system_modules/napaudio/src/audio/node/filternode.cpp
@@ -126,8 +126,20 @@ namespace nap
 			calcCoeffs();
 			mIsDirty.set();
 		}
-		
-		
+
+		void FilterNode::set(EMode mode, ControllerValue frequency, ControllerValue resonance, ControllerValue band,
+			ControllerValue gain)
+		{
+			mMode = mode;
+			mFrequency = frequency;
+			mResonance = resonance;
+			mBand = band;
+			mGain = gain;
+			calcCoeffs();
+			mIsDirty.set();
+		}
+
+
 		void FilterNode::update()
 		{
 			a0.setValue(a0Dest);
diff --git a/system_modules/napaudio/src/audio/node/filternode.h b/system_modules/napaudio/src/audio/node/filternode.h
index b0bfd73a05..ac6d21ec0f 100644
--- a/system_modules/napaudio/src/audio/node/filternode.h
+++ b/system_modules/napaudio/src/audio/node/filternode.h
@@ -86,6 +86,16 @@ namespace nap
 			 */
 			void setGain(ControllerValue gain);
 
+			/**
+			 * Sets all the filter parameters at once, recalculating the coefficients only once.
+			 * @param mode lowpass, highpass, bandpass, lowpass with resonance peak or highpass with resonance peak.
+			 * @param frequency The frequency parameter of the filter in Hz.
+			 * @param resonance Sets the resonance peak of the filter. 0 means no resonance, 30 means self-oscillation.
+			 * @param band Sets the bandwith for bandpass filtering in Hz.
+			 * @param gain Sets the gaining factor of the filter's output.
+			 */
+			void set(EMode mode, ControllerValue frequency, ControllerValue resonance, ControllerValue band, ControllerValue gain);
+
 			/**
 			 * @return the mode of the filter.
 			 */
@@ -117,7 +127,7 @@ namespace nap
 
 			std::atomic<EMode> mMode = {EMode::LowPass};
 			std::atomic<ControllerValue> mFrequency = {440.f};
-			std::atomic<ControllerValue> mResonance = {0.f};
+			std::atomic<ControllerValue> mResonance = {1.f};
 			std::atomic<ControllerValue> mBand = {100.f};
 			std::atomic<ControllerValue> mGain = {1.f};
 			DirtyFlag mIsDirty;
diff --git a/system_modules/napaudio/src/audio/node/levelmeternode.cpp b/system_modules/napaudio/src/audio/node/levelmeternode.cpp
index da300b7fea..da5e07d4c3 100755
--- a/system_modules/napaudio/src/audio/node/levelmeternode.cpp
+++ b/system_modules/napaudio/src/audio/node/levelmeternode.cpp
@@ -23,20 +23,15 @@ namespace nap
 	namespace audio
 	{
 
-		LevelMeterNode::LevelMeterNode(NodeManager& nodeManager, TimeValue analysisWindowSize, bool rootProcess) : Node(nodeManager), mRootProcess(rootProcess), mAnalysisWindowSize(analysisWindowSize)
+		LevelMeterNode::LevelMeterNode(NodeManager& nodeManager, TimeValue analysisWindowSize) : Node(nodeManager), mAnalysisWindowSize(analysisWindowSize)
 		{
 			mWindowSizeInSamples = getNodeManager().getSamplesPerMillisecond() * mAnalysisWindowSize;
-			mSquaredBuffer.resize(mWindowSizeInSamples);
-            
-			if (rootProcess)
-				getNodeManager().registerRootProcess(*this);
+			mSquaredBuffer.resize(mWindowSizeInSamples, 0.f);
 		}
 
 
 		LevelMeterNode::~LevelMeterNode()
 		{
-			if (mRootProcess)
-				getNodeManager().unregisterRootProcess(*this);
 		}
 
 
@@ -50,9 +45,14 @@ namespace nap
 		{
 			auto inputBuffer = input.pull();
 
+			auto& outputBuffer = getOutputBuffer(output);
 			if (inputBuffer == nullptr)
+			{
+				std::fill(outputBuffer.begin(), outputBuffer.end(), 0.f);
 				return;
-            
+			}
+			outputBuffer = *inputBuffer;
+
 			switch (mType)
 			{
 				case EType::PEAK:
@@ -64,7 +64,7 @@ namespace nap
 							newValue = -newValue;
 						if (newValue > mPeakTemp)
 							mPeakTemp = newValue;
-						
+
 						// reset temp and update the output value once every 'window'
 						mIndex++;
 						if (mIndex == mWindowSizeInSamples)
@@ -74,7 +74,7 @@ namespace nap
 							mIndex = 0;
 						}
 					}
-					
+
 					mValue.store(mPeak);
 					break;
 
@@ -85,22 +85,33 @@ namespace nap
 						mSquaredSum -= mSquaredBuffer[mIndex];
 						mSquaredBuffer[mIndex] = sample * sample;
 						mSquaredSum += mSquaredBuffer[mIndex];
-						
+
 						// increment index
 						mIndex++;
 						if (mIndex == mSquaredBuffer.size())
+						{
+							// Recalculate the squared sum and reset the index
+							mSquaredSum = 0.f;
+							for (auto& squaredSample : mSquaredBuffer)
+								mSquaredSum += squaredSample;
 							mIndex = 0;
+						}
 					}
-					
+
 					mValue.store(mSquaredSum / (float)mSquaredBuffer.size());
 					break;
 			}
 		}
 
+
 		void LevelMeterNode::sampleRateChanged(float sampleRate)
 		{
 			mWindowSizeInSamples = getNodeManager().getSamplesPerMillisecond() * mAnalysisWindowSize;
-			mSquaredBuffer.resize(mWindowSizeInSamples);
+			mSquaredBuffer.resize(mWindowSizeInSamples, 0.f);
+			mIndex = 0;
+			mSquaredSum = 0.f;
+			mPeak = 0.f;
+			mPeakTemp = 0.f;
 		}
 
 	}
diff --git a/system_modules/napaudio/src/audio/node/levelmeternode.h b/system_modules/napaudio/src/audio/node/levelmeternode.h
index 93eb3d4a01..96257bfe3f 100755
--- a/system_modules/napaudio/src/audio/node/levelmeternode.h
+++ b/system_modules/napaudio/src/audio/node/levelmeternode.h
@@ -37,14 +37,15 @@ namespace nap
 			/**
 			 * @param nodeManager: the node manager
 			 * @param analysisWindowSize: the time window in milliseconds that will be used to generate one single output value. Also the period that corresponds to the analysis frequency.
-			 * @param rootProcess: indicates that the node is registered as root process with the AudioNodeManager and is processed automatically.
 			 */
-			LevelMeterNode(NodeManager& nodeManager, TimeValue analysisWindowSize = 10, bool rootProcess = true);
+			LevelMeterNode(NodeManager& nodeManager, TimeValue analysisWindowSize = 10);
 
 			virtual ~LevelMeterNode();
 
 			InputPin input = {this}; /**< The input for the audio signal that will be analyzed. */
 
+			OutputPin output = { this }; /**< If this output is connected the LevelMeterNode will output its input. */
+
 			/**
 			 * @return: The current level of the analyzed signal.
 			 */
diff --git a/system_modules/napaudio/src/audio/node/outputnode.cpp b/system_modules/napaudio/src/audio/node/outputnode.cpp
index 28cb79c306..0d97f1c5f6 100644
--- a/system_modules/napaudio/src/audio/node/outputnode.cpp
+++ b/system_modules/napaudio/src/audio/node/outputnode.cpp
@@ -17,18 +17,13 @@ namespace nap
 	namespace audio
 	{
 		
-		OutputNode::OutputNode(NodeManager& nodeManager, bool rootProcess) : Node(nodeManager),
-		                                                                     mRootProcess(rootProcess)
+		OutputNode::OutputNode(NodeManager& nodeManager) : Node(nodeManager)
 		{
-			if (rootProcess)
-				getNodeManager().registerRootProcess(*this);
 		}
 		
 		
 		OutputNode::~OutputNode()
 		{
-			if (mRootProcess && isRegisteredWithNodeManager())
-				getNodeManager().unregisterRootProcess(*this);
 		}
 		
 		
diff --git a/system_modules/napaudio/src/audio/node/outputnode.h b/system_modules/napaudio/src/audio/node/outputnode.h
index 68a67ed280..b4d6b35abd 100644
--- a/system_modules/napaudio/src/audio/node/outputnode.h
+++ b/system_modules/napaudio/src/audio/node/outputnode.h
@@ -27,9 +27,8 @@ namespace nap
 		public:
 			/**
 			 * @param nodeManager The node manager
-			 * @param rootProcess true if the node is registered as root process and being processed from the moment of creation. This can cause glitches if the node tree and it's parameters are still being build.
 			 */
-			OutputNode(NodeManager& nodeManager, bool rootProcess = true);
+			OutputNode(NodeManager& nodeManager);
 
 			~OutputNode() override final;
 
@@ -52,10 +51,7 @@ namespace nap
 		private:
 			void process() override;
 
-			std::atomic<int> mOutputChannel = {
-					0}; // The audio channel that this node's input will be played on by the node manager.
-
-			bool mRootProcess = false;
+			std::atomic<int> mOutputChannel = { 0 }; // The audio channel that this node's input will be played on by the node manager.
 		};
 
 
diff --git a/system_modules/napaudio/src/audio/node/pullnode.cpp b/system_modules/napaudio/src/audio/node/pullnode.cpp
index 0dbbd900b9..5bb82df6e0 100644
--- a/system_modules/napaudio/src/audio/node/pullnode.cpp
+++ b/system_modules/napaudio/src/audio/node/pullnode.cpp
@@ -14,17 +14,13 @@ namespace nap
 	namespace audio
 	{
 		
-		PullNode::PullNode(NodeManager& nodeManager, bool rootProcess) : Node(nodeManager), mRootProcess(rootProcess)
+		PullNode::PullNode(NodeManager& nodeManager) : Node(nodeManager)
 		{
-			if (rootProcess)
-				getNodeManager().registerRootProcess(*this);
 		}
 		
 		
 		PullNode::~PullNode()
 		{
-			if (mRootProcess)
-				getNodeManager().unregisterRootProcess(*this);
 		}
 		
 		
diff --git a/system_modules/napaudio/src/audio/node/pullnode.h b/system_modules/napaudio/src/audio/node/pullnode.h
index 4661cdafd1..8602ffed93 100644
--- a/system_modules/napaudio/src/audio/node/pullnode.h
+++ b/system_modules/napaudio/src/audio/node/pullnode.h
@@ -31,9 +31,8 @@ namespace nap
 		public:
 			/**
 			 * @param nodeManager: The node manager this node runs on
-			 * @param rootProcess: true if the node registered as root process and processed from creation.
 			 */
-			PullNode(NodeManager& nodeManager, bool rootProcess = true);
+			PullNode(NodeManager& nodeManager);
 			
 			~PullNode() override final;
 			
@@ -44,8 +43,6 @@ namespace nap
 		
 		private:
 			void process() override;
-			
-			bool mRootProcess = false;
 		};
 		
 		
diff --git a/system_modules/napaudio/src/audio/utility/audiotypes.h b/system_modules/napaudio/src/audio/utility/audiotypes.h
index ebdf6aa1f2..770fdb69e7 100644
--- a/system_modules/napaudio/src/audio/utility/audiotypes.h
+++ b/system_modules/napaudio/src/audio/utility/audiotypes.h
@@ -10,6 +10,7 @@
 // nap includes
 #include <utility/dllexport.h>
 #include <nap/numeric.h>
+#include <rtti/typeinfo.h>
 
 namespace nap
 {
@@ -39,6 +40,7 @@ namespace nap
 		 */
 		class NAPAPI MultiSampleBuffer
 		{
+			RTTI_ENABLE()
 		public:
 			MultiSampleBuffer() = default;
 			
diff --git a/system_modules/napaudio/src/audio/utility/linearsmoothedvalue.h b/system_modules/napaudio/src/audio/utility/linearsmoothedvalue.h
index e1912aa478..96b5c28d60 100644
--- a/system_modules/napaudio/src/audio/utility/linearsmoothedvalue.h
+++ b/system_modules/napaudio/src/audio/utility/linearsmoothedvalue.h
@@ -7,6 +7,8 @@
 // Nap includes
 #include <nap/signalslot.h>
 
+#include <atomic>
+
 namespace nap
 {
 	namespace audio
@@ -98,7 +100,7 @@ namespace nap
 			T mValue; // Value that is being controlled by this object.
 			T mIncrement; // Increment value per step of the current ramp when mode is linear.
 			T mDestination = 0; // Destination value of the current ramp.
-			std::atomic<int> mStepCount = 0; // Number of steps in the ramp.
+			std::atomic<int> mStepCount = { 0 }; // Number of steps in the ramp.
 			int mStepCounter = 0; // Current step index, 0 means at destination
 		};
 		
diff --git a/system_modules/napaudio/src/audio/utility/safeptr.h b/system_modules/napaudio/src/audio/utility/safeptr.h
index eecce57abd..8896229db7 100644
--- a/system_modules/napaudio/src/audio/utility/safeptr.h
+++ b/system_modules/napaudio/src/audio/utility/safeptr.h
@@ -467,19 +467,26 @@ namespace nap
 
 			T* get() const
 			{
-				assert(isValid());
+				if (!isValid())
+					return nullptr;
 				return static_cast<T*>((*mOwnerData)->mObject.get());
 			}
 
 			T* get()
 			{
-				assert(isValid());
+				if (!isValid())
+					return nullptr;
 				return static_cast<T*>((*mOwnerData)->mObject.get());
 			}
 
 		private:
 			void* getOwnerData() const override
-			{ return *mOwnerData; }
+			{
+				if (mOwnerData != nullptr)
+					return *mOwnerData;
+				else
+					return nullptr;
+			}
 
 			void setOwnerData(void* ownerData) override
 			{
diff --git a/system_modules/napaudio/src/audio/utility/translator.h b/system_modules/napaudio/src/audio/utility/translator.h
index bf17be380c..abb4be3755 100755
--- a/system_modules/napaudio/src/audio/utility/translator.h
+++ b/system_modules/napaudio/src/audio/utility/translator.h
@@ -12,6 +12,9 @@
 // Audio includes
 #include <audio/utility/audiofunctions.h>
 
+// Rtti include
+#include <rtti/typeinfo.h>
+
 
 namespace nap
 {
@@ -96,17 +99,17 @@ namespace nap
 		/**
 		 * A convenience translator for equal power lookups, owns a table so it does not need to be provided
 		 */
-		template<typename T>
-		class EqualPowerTranslator : public TableTranslator<T>
+		class EqualPowerTranslator : public TableTranslator<float>
 		{
+			RTTI_ENABLE()
 		public:
 			/**
 			 * constructor
 			 */
-			EqualPowerTranslator(unsigned int size) : TableTranslator<T>(size)
+			EqualPowerTranslator(unsigned int size) : TableTranslator<float>(size)
 			{
 				// fills the table using equal power function
-				TableTranslator<T>::fill([](T x) { return sin(x * math::PI_2); });
+				TableTranslator<float>::fill([](float x) { return sin(x * math::PI_2); });
 			}
 		
 		private:
diff --git a/system_modules/napfft/src/fftaudionodecomponent.cpp b/system_modules/napfft/src/fftaudionodecomponent.cpp
index a64f1f10b7..47e2d8cdaa 100644
--- a/system_modules/napfft/src/fftaudionodecomponent.cpp
+++ b/system_modules/napfft/src/fftaudionodecomponent.cpp
@@ -41,12 +41,19 @@ namespace nap
 		auto& node_manager = mAudioService->getNodeManager();
 		mFFTNode = node_manager.makeSafe<FFTNode>(node_manager);
 		mFFTNode->mInput.connect(*mInput->getOutputForChannel(mResource->mChannel));
+		mAudioService->getNodeManager().registerRootProcess(mFFTNode.get());
 		mFFTBuffer = &mFFTNode->getFFTBuffer();
 
 		return true;
 	}
 
 
+	void FFTAudioNodeComponentInstance::onDestroy()
+	{
+		mAudioService->getNodeManager().unregisterRootProcess(mFFTNode.get());
+	}
+
+
 	void FFTAudioNodeComponentInstance::setInput(audio::AudioComponentBaseInstance& input)
 	{
 		auto inputPtr = &input;
diff --git a/system_modules/napfft/src/fftaudionodecomponent.h b/system_modules/napfft/src/fftaudionodecomponent.h
index 7e7a74f295..37b8c81bf6 100644
--- a/system_modules/napfft/src/fftaudionodecomponent.h
+++ b/system_modules/napfft/src/fftaudionodecomponent.h
@@ -49,6 +49,7 @@ namespace nap
 			
 		// Initialize the component
 		virtual bool init(utility::ErrorState& errorState) override;
+		void onDestroy() override;
 			
 		/**
 		 * Connects a different audio component as input to be analyzed.
diff --git a/system_modules/napfft/src/fftnode.cpp b/system_modules/napfft/src/fftnode.cpp
index d96747b879..b71387e8fe 100644
--- a/system_modules/napfft/src/fftnode.cpp
+++ b/system_modules/napfft/src/fftnode.cpp
@@ -21,13 +21,12 @@ namespace nap
 		assert(buffer_size >= 2);
 
 		mFFTBuffer = std::make_unique<FFTBuffer>(buffer_size, overlaps);
-		getNodeManager().registerRootProcess(*this);
 	}
 
 
 	FFTNode::~FFTNode()
 	{
-		getNodeManager().unregisterRootProcess(*this);
+		getNodeManager().unregisterRootProcess(getSafe());
 	}
 
 
diff --git a/system_modules/napsequenceaudio/src/sequenceplayeraudioclock.cpp b/system_modules/napsequenceaudio/src/sequenceplayeraudioclock.cpp
index 8cbe41bc48..2d7394611e 100644
--- a/system_modules/napsequenceaudio/src/sequenceplayeraudioclock.cpp
+++ b/system_modules/napsequenceaudio/src/sequenceplayeraudioclock.cpp
@@ -23,12 +23,22 @@ namespace nap
 
         auto& node_manager = audio_service->getNodeManager();
         mAudioClockProcess = node_manager.makeSafe<SequencePlayerAudioClockProcess>(node_manager);
+
+        // Register the clock to be processed directly by the NodeManager
+        node_manager.registerRootProcess(mAudioClockProcess.get());
+
         mAudioClockProcess->connectSlot(mUpdateSlot);
     }
 
 
     void SequencePlayerAudioClock::onDestroy()
     {
+        auto* audio_service = mService.getCore().getService<audio::AudioService>();
+        assert(audio_service!=nullptr);
+
+        // Unregister the clock from being processed directly by the NodeManager
+        audio_service->getNodeManager().unregisterRootProcess(mAudioClockProcess.get());
+        
         stop();
     }
 
@@ -43,13 +53,6 @@ namespace nap
             :audio::Process(nodeManager)
     {
         mTime = nodeManager.getSampleTime();
-        getNodeManager().registerRootProcess(*this);
-    }
-
-
-    SequencePlayerAudioClockProcess::~SequencePlayerAudioClockProcess() noexcept
-    {
-        getNodeManager().unregisterRootProcess(*this);
     }
 
 
diff --git a/system_modules/napsequenceaudio/src/sequenceplayeraudioclock.h b/system_modules/napsequenceaudio/src/sequenceplayeraudioclock.h
index a628d0374e..13cbae826b 100644
--- a/system_modules/napsequenceaudio/src/sequenceplayeraudioclock.h
+++ b/system_modules/napsequenceaudio/src/sequenceplayeraudioclock.h
@@ -82,11 +82,6 @@ namespace nap
         SequencePlayerAudioClockProcess(const SequencePlayerAudioClockProcess&) = delete;
         SequencePlayerAudioClockProcess& operator=(const SequencePlayerAudioClockProcess&) = delete;
 
-        /**
-         * Deconstructor, unregisters the process from node manager
-         */
-        virtual ~SequencePlayerAudioClockProcess();
-
         /**
          * Connect update slot on audio-thread.
          * Thread-Safe