diff --git a/apps/RenderCadenceCompositor/render/RenderThread.cpp b/apps/RenderCadenceCompositor/render/RenderThread.cpp
index b5c50b7..8b7e25d 100644
--- a/apps/RenderCadenceCompositor/render/RenderThread.cpp
+++ b/apps/RenderCadenceCompositor/render/RenderThread.cpp
@@ -65,8 +65,16 @@ void RenderThread::Stop()
 
 RenderThread::Metrics RenderThread::GetMetrics() const
 {
-	std::lock_guard<std::mutex> lock(mMetricsMutex);
-	return mMetrics;
+	Metrics metrics;
+	metrics.renderedFrames = mRenderedFrames.load(std::memory_order_relaxed);
+	metrics.completedReadbacks = mCompletedReadbacks.load(std::memory_order_relaxed);
+	metrics.acquireMisses = mAcquireMisses.load(std::memory_order_relaxed);
+	metrics.pboQueueMisses = mPboQueueMisses.load(std::memory_order_relaxed);
+	metrics.clockOverruns = mClockOverruns.load(std::memory_order_relaxed);
+	metrics.skippedFrames = mSkippedFrames.load(std::memory_order_relaxed);
+	metrics.shaderBuildsCommitted = mShaderBuildsCommitted.load(std::memory_order_relaxed);
+	metrics.shaderBuildFailures = mShaderBuildFailures.load(std::memory_order_relaxed);
+	return metrics;
 }
 
 void RenderThread::ThreadMain()
@@ -126,19 +134,15 @@ void RenderThread::ThreadMain()
 				renderer.RenderFrame(index);
 		}))
 		{
-			std::lock_guard<std::mutex> lock(mMetricsMutex);
-			++mMetrics.pboQueueMisses;
+			mPboQueueMisses.fetch_add(1, std::memory_order_relaxed);
 		}
 
 		CountRendered();
 		++frameIndex;
 		clock.MarkRendered(RenderCadenceClock::Clock::now());
 
-		{
-			std::lock_guard<std::mutex> lock(mMetricsMutex);
-			mMetrics.clockOverruns = clock.OverrunCount();
-			mMetrics.skippedFrames = clock.SkippedFrameCount();
-		}
+		mClockOverruns.store(clock.OverrunCount(), std::memory_order_relaxed);
+		mSkippedFrames.store(clock.SkippedFrameCount(), std::memory_order_relaxed);
 	}
 
 	for (std::size_t i = 0; i < mConfig.pboDepth * 2; ++i)
@@ -177,20 +181,17 @@ void RenderThread::SignalStartupFailure(const std::string& error)
 
 void RenderThread::CountRendered()
 {
-	std::lock_guard<std::mutex> lock(mMetricsMutex);
-	++mMetrics.renderedFrames;
+	mRenderedFrames.fetch_add(1, std::memory_order_relaxed);
 }
 
 void RenderThread::CountCompleted()
 {
-	std::lock_guard<std::mutex> lock(mMetricsMutex);
-	++mMetrics.completedReadbacks;
+	mCompletedReadbacks.fetch_add(1, std::memory_order_relaxed);
 }
 
 void RenderThread::CountAcquireMiss()
 {
-	std::lock_guard<std::mutex> lock(mMetricsMutex);
-	++mMetrics.acquireMisses;
+	mAcquireMisses.fetch_add(1, std::memory_order_relaxed);
 }
 
 void RenderThread::SubmitRuntimeShaderArtifact(const RuntimeShaderArtifact& artifact)
@@ -228,8 +229,7 @@ void RenderThread::TryCommitReadyRuntimeShader(RuntimeShaderRenderer& runtimeSha
 			RenderCadenceCompositor::LogLevel::Error,
 			"render-thread",
 			"Runtime shader GL commit failed: " + commitError);
-		std::lock_guard<std::mutex> lock(mMetricsMutex);
-		++mMetrics.shaderBuildFailures;
+		mShaderBuildFailures.fetch_add(1, std::memory_order_relaxed);
 		return;
 	}
 
@@ -237,6 +237,5 @@ void RenderThread::TryCommitReadyRuntimeShader(RuntimeShaderRenderer& runtimeSha
 		RenderCadenceCompositor::LogLevel::Log,
 		"render-thread",
 		"Runtime shader committed: " + artifact.shaderId + ". " + artifact.message);
-	std::lock_guard<std::mutex> lock(mMetricsMutex);
-	++mMetrics.shaderBuildsCommitted;
+	mShaderBuildsCommitted.fetch_add(1, std::memory_order_relaxed);
 }
diff --git a/apps/RenderCadenceCompositor/render/RenderThread.h b/apps/RenderCadenceCompositor/render/RenderThread.h
index 0d05c47..f8b6670 100644
--- a/apps/RenderCadenceCompositor/render/RenderThread.h
+++ b/apps/RenderCadenceCompositor/render/RenderThread.h
@@ -70,8 +70,14 @@ private:
 	bool mStarted = false;
 	std::string mStartupError;
 
-	mutable std::mutex mMetricsMutex;
-	Metrics mMetrics;
+	std::atomic<uint64_t> mRenderedFrames{ 0 };
+	std::atomic<uint64_t> mCompletedReadbacks{ 0 };
+	std::atomic<uint64_t> mAcquireMisses{ 0 };
+	std::atomic<uint64_t> mPboQueueMisses{ 0 };
+	std::atomic<uint64_t> mClockOverruns{ 0 };
+	std::atomic<uint64_t> mSkippedFrames{ 0 };
+	std::atomic<uint64_t> mShaderBuildsCommitted{ 0 };
+	std::atomic<uint64_t> mShaderBuildFailures{ 0 };
 
 	std::mutex mShaderArtifactMutex;
 	bool mHasPendingShaderArtifact = false;