@@ -171,12 +171,22 @@ int32_t GPUDisplay::InitDisplay(bool initFailure)
     if (!initFailure) {
       retVal = InitDisplay_internal();
     }
+    if (retVal == 0) {
+      buildConfig();
+      if (mConfig.listFrontendOptionHandling) {
+        mFrontend->listConfig();
+      }
+    }
   } catch (const std::runtime_error& e) {
     GPUError("%s", e.what());
     retVal = 1;
   }
-  mInitResult = retVal == 0 ? 1 : -1;
   mOldCfg = {mCfgH, mCfgL, mCfgR};
+  std::unique_lock lock(mFrontend->mExitStateMutex);
+  mInitResult = retVal == 0 ? 1 : -1;
+  mFrontend->mDisplayRunning = retVal == 0; // Only after successful initialization, StopDisplay waits for it to become false again
+  mFrontend->mInitCV.notify_all();
+  mFrontend->mInitCV.wait(lock, [this] { return mFrontend->mStartDisplayDone; }); // Both threads have finished their initialization
   return (retVal);
 }
 
@@ -791,11 +801,5 @@ void GPUDisplay::WaitTillEventShown()
 int32_t GPUDisplay::StartDisplay()
 {
   mLoadAndShowEvent = true;
-  if (mFrontend->StartDisplay()) {
-    return (1);
-  }
-  while (mInitResult == 0) {
-    Sleep(10);
-  }
-  return (mInitResult != 1);
+  return mFrontend->StartDisplay();
 }
@@ -330,7 +330,7 @@ class GPUDisplay : public GPUDisplayInterface
 
   std::vector<threadVertexBuffer> mThreadBuffers;
   std::vector<std::vector<std::array<std::array<vecpod<int32_t>, 2>, NSECTORS>>> mThreadTracks;
-  volatile int32_t mInitResult = 0;
+  int32_t mInitResult = 0; // 1 success, -1 failure, protected by mFrontend->mExitStateMutex
 
   float mFPSScale = 1, mFPSScaleadjust = 0;
   int32_t mFramesDone = 0, mFramesDoneFPS = 0;
 
@@ -18,9 +18,9 @@
 
 #ifdef _WIN32
 #include "GPUDisplayFrontendWindows.h"
-#else
-#include <pthread.h>
 #endif
+#include <system_error>
+#include <thread>
 
 #ifdef GPUCA_BUILD_EVENT_DISPLAY_X11
 #include "GPUDisplayFrontendX11.h"
@@ -61,22 +61,31 @@ class GPUDisplayGUIWrapper
 using namespace o2::gpu;
 
 GPUDisplayFrontend::GPUDisplayFrontend() : mConsole(std::make_unique<GPUDisplayConsole>(std::string(DISPLAY_WINDOW_NAME) + " Console")) {}
-GPUDisplayFrontend::~GPUDisplayFrontend() = default;
+GPUDisplayFrontend::~GPUDisplayFrontend()
+{
+  if (mFrontendThread.joinable()) { // Started but not stopped, as the detached thread before
+    mFrontendThread.detach();
+  }
+}
 
-void* GPUDisplayFrontend::FrontendThreadWrapper(void* ptr)
+void GPUDisplayFrontend::FrontendThreadWrapper()
 {
-  GPUDisplayFrontend* me = reinterpret_cast<GPUDisplayFrontend*>(ptr);
   int32_t retVal;
   try {
-    retVal = me->FrontendMain();
+    retVal = FrontendMain();
   } catch (const std::exception& e) {
     GPUError("Error in display frontend: %s", e.what());
     retVal = -1;
   }
-  if (retVal && me->mDisplay->mInitResult == 0) { // Failed before InitDisplay was called, report failure to StartDisplay(), which otherwise waits forever
-    me->InitDisplay(true);
+  if (retVal) {
+    std::unique_lock lock(mExitStateMutex);
+    if (mDisplay->mInitResult == 0) { // Failed before InitDisplay was called, report failure to StartDisplay(), which otherwise waits forever
+      lock.unlock();
+      InitDisplay(true);
+    } else {
+      mDisplay->mInitResult = -1; // Error after the initialization: StopDisplay does not reset the state for a new start
+    }
   }
-  return ((void*)(size_t)retVal);
 }
 
 void GPUDisplayFrontend::waitForFPSLimit()
@@ -341,35 +350,38 @@ int32_t& GPUDisplayFrontend::drawTextFontSize()
 
 int32_t GPUDisplayFrontend::StartDisplay()
 {
-#ifndef _WIN32
-  static pthread_t hThread;
-  if (pthread_create(&hThread, nullptr, FrontendThreadWrapper, this)) {
-    GPUError("Coult not Create frontend Thread...");
-    return (1);
-  }
-#else
-  HANDLE hThread;
-  if ((hThread = CreateThread(nullptr, nullptr, &OpenGLWrapper, this, nullptr, nullptr)) == nullptr) {
-    GPUError("Coult not Create GL Thread...");
+  try {
+    mFrontendThread = std::thread(&GPUDisplayFrontend::FrontendThreadWrapper, this);
+  } catch (const std::system_error& e) {
+    GPUError("Could not create frontend thread: %s", e.what());
     return (1);
   }
-#endif
-  mDisplay->buildConfig();
-  if (mDisplay->cfg().listFrontendOptionHandling) {
-    listConfig();
-  }
-  return (0);
+  std::unique_lock lock(mExitStateMutex);
+  mStartDisplayDone = true;
+  mInitCV.notify_all();
+  mInitCV.wait(lock, [this] { return mDisplay->mInitResult != 0; }); // Both threads have finished their initialization
+  return (mDisplay->mInitResult != 1);
 }
 
 void GPUDisplayFrontend::StopDisplay()
 {
-  std::unique_lock lock(mExitStateMutex);
-  if (mDisplayRunning) {
-    mDisplay->mCfgC.mDisplayControl.store(2);
-    StopDisplayA();
-    mDisplay->UnblockDisplay();
+  {
+    std::unique_lock lock(mExitStateMutex);
+    if (mDisplayRunning) {
+      mDisplay->mCfgC.mDisplayControl.store(2);
+      StopDisplayA();
+      mDisplay->UnblockDisplay();
+    }
+    mDisplayStoppedCV.wait(lock, [this] { return !mDisplayRunning; });
+  }
+  if (mFrontendThread.joinable()) { // Also the wrapper has finished (it sets mInitResult = -1 for errors after the initialization), not holding mExitStateMutex, which the wrapper uses
+    mFrontendThread.join();
+  }
+  std::lock_guard lock(mExitStateMutex);
+  if (mDisplay->mInitResult == 1) { // For a new StartDisplay, not after a failed initialization or an error (undefined state)
+    mStartDisplayDone = false;
+    mDisplay->mInitResult = 0;
   }
-  mDisplayStoppedCV.wait(lock, [this] { return !mDisplayRunning; });
 }
 
 void GPUDisplayFrontend::StopDisplayA() {}
@@ -18,9 +18,11 @@
 #include "GPUCommonDef.h"
 #include "GPUDisplayInterface.h"
 #include "GPUDisplayFrontendKeyVars.h"
+#include <atomic>
 #include <memory>
 #include <chrono>
 #include <mutex>
+#include <thread>
 #include <condition_variable>
 #include <string>
 #include <utility>
@@ -86,9 +88,9 @@ class GPUDisplayFrontend : public GPUDisplayFrontendInterface, public GPUDisplay
  protected:
   virtual int32_t FrontendMain() = 0;
   virtual void StopDisplayA();
-  static void* FrontendThreadWrapper(void*);
-  void waitForFPSLimit();    // Sleep until the next frame is due according to fpsRate (only in FPS_LIMIT_RATE mode, see GPUDisplayBackend::fpsLimitMode), or until an external config update is signalled
-  void signalConfigUpdate(); // Signal a config update from an external source (console keys, Qt GUI), wakes up waitForFPSLimit
+  void FrontendThreadWrapper(); // Runs FrontendMain in mFrontendThread
+  void waitForFPSLimit();       // Sleep until the next frame is due according to fpsRate (only in FPS_LIMIT_RATE mode, see GPUDisplayBackend::fpsLimitMode), or until an external config update is signalled
+  void signalConfigUpdate();    // Signal a config update from an external source (console keys, Qt GUI), wakes up waitForFPSLimit
 
   static constexpr int32_t INIT_WIDTH = 1024, INIT_HEIGHT = 768;                        // Initial window size, before maximizing
   static constexpr int32_t MIN_WIDTH = 200, MIN_HEIGHT = 150;                           // Minimum window size
@@ -104,6 +106,9 @@ class GPUDisplayFrontend : public GPUDisplayFrontendInterface, public GPUDisplay
   bool mConfigUpdatePending = false;       // Protected by mConfigUpdateMutex, set by signalConfigUpdate, cleared by HandleExternalGUISignals
   std::mutex mExitStateMutex;
   std::condition_variable mDisplayStoppedCV; // Notified with mExitStateMutex held when the frontend sets mDisplayRunning to false, StopDisplay waits for it
+  std::condition_variable mInitCV;           // With mExitStateMutex: InitDisplay (frontend thread) and StartDisplay (main thread) wait for each other at their end
+  std::thread mFrontendThread;               // Started by StartDisplay, joined by StopDisplay
+  bool mStartDisplayDone = false;            // Protected by mExitStateMutex
   std::array<uint8_t, KEY_MAP_MAX> mKeyDownMap = {};
 
   // Keyboard / Mouse actions
@@ -124,7 +129,7 @@ class GPUDisplayFrontend : public GPUDisplayFrontendInterface, public GPUDisplay
 
   frontendTypes mFrontendType = TYPE_INVALID;
   const char* mFrontendName = nullptr;
-  volatile bool mDisplayRunning = false;
+  std::atomic<bool> mDisplayRunning = false; // Set at the end of a successful InitDisplay, StopDisplay waits for it to become false again
 
   std::unique_ptr<GPUDisplayGUIChannel> mGUIChannel; // Must outlive mGUI
   std::unique_ptr<GPUDisplayGUIWrapper> mGUI;
 
@@ -332,11 +332,6 @@ int32_t GPUDisplayFrontendGlfw::FrontendMain()
     return (1);
   }
 
-  {
-    std::lock_guard lock(mExitStateMutex);
-    mDisplayRunning = true; // Only after successful initialization, StopDisplay waits for it to become false again
-  }
-
   int32_t retVal = 0;
   while (!glfwWindowShouldClose(mWindow)) {
     if (HandleUpdatesAndDrawGLScene()) {
 
@@ -28,7 +28,6 @@
 #include <X11/Xatom.h>
 #endif
 
-#include <pthread.h>
 using namespace o2::gpu;
 
 GPUDisplayFrontendGlut::GPUDisplayFrontendGlut()
@@ -230,11 +229,6 @@ int32_t GPUDisplayFrontendGlut::FrontendMain()
     fprintf(stderr, "Error initializing GL extension wrapper\n");
     return (-1);
   }
-  if (InitDisplay()) {
-    fprintf(stderr, "Error in OpenGL initialization\n");
-    return (1);
-  }
-
   auto mouseMoveFunc = [](int32_t x, int32_t y, void* p) { self(p)->mouseMoveFunc(x, y); };
   glutDisplayFuncUcall([](void* p) { self(p)->displayFunc(); }, this); // Callbacks with this as user data, freeglut >= 3.2
   glutIdleFuncUcall([](void* p) { self(p)->glutLoopFunc(); }, this);
@@ -250,9 +244,9 @@ int32_t GPUDisplayFrontendGlut::FrontendMain()
   applyInitialWindowState();
   SetVSync(vsyncEnabled());
 
-  {
-    std::lock_guard lock(mExitStateMutex);
-    mDisplayRunning = true;
+  if (InitDisplay()) {
+    fprintf(stderr, "Error in OpenGL initialization\n");
+    return (1);
   }
   glutMainLoop();
   {
 
@@ -27,10 +27,6 @@ int32_t GPUDisplayFrontendNone::FrontendMain()
   if (InitDisplay()) {
     return 1;
   }
-  {
-    std::lock_guard lock(mExitStateMutex);
-    mDisplayRunning = true;
-  }
   do {
     HandleUpdatesAndDrawGLScene();
     waitForFPSLimit();
 
@@ -564,11 +564,6 @@ int32_t GPUDisplayFrontendWayland::FrontendMain()
     return (1);
   }
 
-  {
-    std::lock_guard lock(mExitStateMutex);
-    mDisplayRunning = true;
-  }
-
   while (mDisplay->mCfgC.mDisplayControl.load() != 2) {
     bool error = false;
     while (!error && wl_display_prepare_read(mWayland) != 0) {
 
@@ -311,11 +311,6 @@ int32_t GPUDisplayFrontendX11::FrontendMain()
     return (1);
   }
 
-  {
-    std::lock_guard lock(mExitStateMutex);
-    mDisplayRunning = true;
-  }
-
   while (1) {
     do {
       if (getDisplayControl() == 2) {