diff --git a/modules/softwareintegration/messagehandler.cpp b/modules/softwareintegration/messagehandler.cpp
index dd2aea2758..88d11fd01d 100644
--- a/modules/softwareintegration/messagehandler.cpp
+++ b/modules/softwareintegration/messagehandler.cpp
@@ -295,7 +295,7 @@ void handleVelocityDataMessage(const std::vector<char>& message, std::shared_ptr
         simp::readPointData(message, messageOffset, nVelocities, dimensionality, velocities);
     }
     catch (const simp::SimpError& err) {
-        LERROR(fmt::format("Error when reading point data message: {}", err.message));
+        LERROR(fmt::format("Error when reading velocity data message: {}", err.message));
         return;
     }
 
diff --git a/modules/softwareintegration/network/network.cpp b/modules/softwareintegration/network/network.cpp
index 84645866f8..729b5d2e4d 100644
--- a/modules/softwareintegration/network/network.cpp
+++ b/modules/softwareintegration/network/network.cpp
@@ -62,8 +62,8 @@ void eventLoop(std::weak_ptr<NetworkState> networkStateWeakPtr) {
 void serverLoop(std::weak_ptr<NetworkState> networkStateWeakPtr) {
 	while (!networkStateWeakPtr.expired()) {
 		auto networkState = networkStateWeakPtr.lock();
-		if (networkState->shouldStopThreads) break;
-		std::unique_ptr<ghoul::io::TcpSocket> socket = networkState->server.awaitPendingTcpSocket();
+		if (networkState->shouldStopThreads|| !networkState->server || !networkState->server->isListening()) break;
+		std::unique_ptr<ghoul::io::TcpSocket> socket = networkState->server->awaitPendingTcpSocket();
 
 		if (!socket) return;
 
@@ -91,38 +91,38 @@ std::shared_ptr<NetworkState> serve(const int port) {
 	auto networkState = std::make_shared<NetworkState>();
 
 	// 4700, is the defualt port where the tcp socket will be opened to the ext. software
-	networkState->server.listen(port);
+	networkState->server = std::make_unique<ghoul::io::TcpSocketServer>();
+	networkState->server->listen(port);
 
 	std::weak_ptr<NetworkState> networkStateWeakPtr = networkState;
-	networkState->serverThread = std::thread{ [networkStateWeakPtr] {
+	networkState->serverThread = std::make_unique<std::thread>([networkStateWeakPtr] {
 		serverLoop(networkStateWeakPtr);
-	} };
+	});
 
-	networkState->eventLoopThread = std::thread{ [networkStateWeakPtr] {
+	networkState->eventLoopThread = std::make_unique<std::thread>([networkStateWeakPtr] {
 		eventLoop(networkStateWeakPtr);
-	} };
+	});
 
 	return networkState;
 };
 
 void stopServer(std::shared_ptr<NetworkState> networkState) {
+	if (networkState->hasStopped) return;
+	networkState->hasStopped = true;
+
 	networkState->shouldStopThreads = true;
 
 	networkState->incomingMessages.interrupt();
 
-	networkState->server.close();
+	networkState->server->close();
 	
 	{
 		std::lock_guard guardSoftwareConnections(networkState->softwareConnectionsMutex);
 		networkState->softwareConnections.clear();
 	}
 
-	if (networkState->serverThread.joinable()) {
-		networkState->serverThread.join();
-	}
-	if (networkState->eventLoopThread.joinable()) {
-		networkState->eventLoopThread.join();
-	}
+	networkState->serverThread->join();
+	networkState->eventLoopThread->join();
 }
 
 SoftwareConnectionLostError::SoftwareConnectionLostError(const std::string& msg)
diff --git a/modules/softwareintegration/network/network.h b/modules/softwareintegration/network/network.h
index 13546c0616..ce59e0d16e 100644
--- a/modules/softwareintegration/network/network.h
+++ b/modules/softwareintegration/network/network.h
@@ -48,15 +48,16 @@ struct IncomingMessage {
 };
 
 struct NetworkState {
-	ghoul::io::TcpSocketServer server;
+	std::unique_ptr<ghoul::io::TcpSocketServer> server;
 
-	std::thread serverThread;
-	std::thread eventLoopThread;
+	std::unique_ptr<std::thread> serverThread;
+	std::unique_ptr<std::thread> eventLoopThread;
 
 	std::unordered_map<size_t, std::shared_ptr<SoftwareConnection>> softwareConnections{};
 	std::mutex softwareConnectionsMutex{};
 
 	std::atomic_bool shouldStopThreads{ false };
+	std::atomic_bool hasStopped{ false };
 
 	InterruptibleConcurrentQueue<IncomingMessage> incomingMessages{};
 };