diff --git a/src/windowsystem/waylandintegration.cpp b/src/windowsystem/waylandintegration.cpp
index 95c2464..d3e6ae6 100644
--- a/src/windowsystem/waylandintegration.cpp
+++ b/src/windowsystem/waylandintegration.cpp
@@ -1,235 +1,210 @@
 /*
  * Copyright 2014 Martin Gräßlin <mgraesslin@kde.org>
  * Copyright 2015 Marco Martin <mart@kde.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) version 3, or any
  * later version accepted by the membership of KDE e.V. (or its
  * successor approved by the membership of KDE e.V.), which shall
  * act as a proxy defined in Section 6 of version 3 of the license.
  *
  * This library 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
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "waylandintegration.h"
 #include "logging.h"
 
 #include <KWayland/Client/connection_thread.h>
 #include <KWayland/Client/registry.h>
 #include <KWayland/Client/compositor.h>
 #include <KWayland/Client/plasmawindowmanagement.h>
 #include <KWayland/Client/plasmashell.h>
 #include <KWayland/Client/surface.h>
 #include <KWayland/Client/blur.h>
 #include <KWayland/Client/contrast.h>
 #include <KWayland/Client/region.h>
 #include <KWayland/Client/slide.h>
 
 #include <KWindowSystem/KWindowSystem>
 
 #include <QGuiApplication>
 
 class WaylandIntegrationSingleton
 {
 public:
     WaylandIntegration self;
 };
 
 Q_GLOBAL_STATIC(WaylandIntegrationSingleton, privateWaylandIntegrationSelf)
 
 WaylandIntegration::WaylandIntegration()
     : QObject()
 {
     setupKWaylandIntegration();
 }
 
 WaylandIntegration::~WaylandIntegration()
 {}
 
 void WaylandIntegration::setupKWaylandIntegration()
 {
     using namespace KWayland::Client;
     m_waylandConnection = ConnectionThread::fromApplication(this);
     if (!m_waylandConnection) {
         qCWarning(KWAYLAND_KWS) << "Failed getting Wayland connection from QPA";
         return;
     }
-    m_registry = new Registry(this);
+    m_registry = new Registry(qApp);
     m_registry->create(m_waylandConnection);
     m_waylandCompositor = Compositor::fromApplication(this);
 
-    //when the Qt QPA closes it deletes the wl_display
-    //closing wl_display deletes the wl_registry
-    //when we destroy the kwayland wrapper we double delete
-    //as we're a singleton we're not deleted till after qApp
-    //we want to release our wayland parts first
-    connect(qApp, &QCoreApplication::aboutToQuit, this, [=]() {
-        if (m_waylandBlurManager) {
-            m_waylandBlurManager->release();
-        }
-        if (m_waylandContrastManager) {
-           m_waylandContrastManager->release();
-        }
-        if (m_waylandSlideManager) {
-            m_waylandSlideManager->release();
-        }
-        if (m_waylandCompositor) {
-            m_waylandCompositor->release();
-        }
-        if (m_wm) {
-            m_wm->release();
-        }
-        if (m_waylandPlasmaShell) {
-            m_waylandPlasmaShell->release();
-        }
-        m_registry->release();
-    });
-
     m_registry->setup();
     m_waylandConnection->roundtrip();
 }
 
 WaylandIntegration *WaylandIntegration::self()
 {
     return &privateWaylandIntegrationSelf()->self;
 }
 
 
 KWayland::Client::ConnectionThread *WaylandIntegration::waylandConnection() const
 {
     return m_waylandConnection;
 }
 
 KWayland::Client::BlurManager *WaylandIntegration::waylandBlurManager()
 {
-    if (!m_waylandBlurManager) {
+    if (!m_waylandBlurManager && m_registry) {
         const KWayland::Client::Registry::AnnouncedInterface wmInterface = m_registry->interface(KWayland::Client::Registry::Interface::Blur);
 
         if (wmInterface.name == 0) {
             return nullptr;
         }
 
-        m_waylandBlurManager = m_registry->createBlurManager(wmInterface.name, wmInterface.version, this);
+        m_waylandBlurManager = m_registry->createBlurManager(wmInterface.name, wmInterface.version, qApp);
 
         connect(m_waylandBlurManager, &KWayland::Client::BlurManager::removed, this,
             [this] () {
                 m_waylandBlurManager->deleteLater();
-                m_waylandBlurManager = nullptr;
             }
         );
     }
 
     return m_waylandBlurManager;
 }
 
 KWayland::Client::ContrastManager *WaylandIntegration::waylandContrastManager()
 {
-    if (!m_waylandContrastManager) {
+    if (!m_waylandContrastManager && m_registry) {
         const KWayland::Client::Registry::AnnouncedInterface wmInterface = m_registry->interface(KWayland::Client::Registry::Interface::Contrast);
 
         if (wmInterface.name == 0) {
             return nullptr;
         }
 
-        m_waylandContrastManager = m_registry->createContrastManager(wmInterface.name, wmInterface.version, this);
+        m_waylandContrastManager = m_registry->createContrastManager(wmInterface.name, wmInterface.version, qApp);
 
         connect(m_waylandContrastManager, &KWayland::Client::ContrastManager::removed, this,
             [this] () {
                 m_waylandContrastManager->deleteLater();
-                m_waylandContrastManager = nullptr;
             }
         );
     }
-
     return m_waylandContrastManager;
 }
 
 KWayland::Client::SlideManager *WaylandIntegration::waylandSlideManager()
 {
-    if (!m_waylandSlideManager) {
+    if (!m_waylandSlideManager && m_registry) {
         const KWayland::Client::Registry::AnnouncedInterface wmInterface = m_registry->interface(KWayland::Client::Registry::Interface::Slide);
 
         if (wmInterface.name == 0) {
             return nullptr;
         }
 
-        m_waylandSlideManager = m_registry->createSlideManager(wmInterface.name, wmInterface.version, this);
+        m_waylandSlideManager = m_registry->createSlideManager(wmInterface.name, wmInterface.version, qApp);
 
         connect(m_waylandSlideManager, &KWayland::Client::SlideManager::removed, this,
             [this] () {
                 m_waylandSlideManager->deleteLater();
-                m_waylandSlideManager = nullptr;
             }
         );
     }
 
     return m_waylandSlideManager;
 }
 
 KWayland::Client::Compositor *WaylandIntegration::waylandCompositor() const
 {
     return m_waylandCompositor;
 }
 
 KWayland::Client::PlasmaWindowManagement *WaylandIntegration::plasmaWindowManagement()
 {
     using namespace KWayland::Client;
 
-    if (!m_wm) {
+    if (!m_wm && m_registry) {
         const Registry::AnnouncedInterface wmInterface = m_registry->interface(Registry::Interface::PlasmaWindowManagement);
 
         if (wmInterface.name == 0) {
             qCWarning(KWAYLAND_KWS) << "This compositor does not support the Plasma Window Management interface";
             return nullptr;
         }
 
-        m_wm = m_registry->createPlasmaWindowManagement(wmInterface.name, wmInterface.version, this);
+        m_wm = m_registry->createPlasmaWindowManagement(wmInterface.name, wmInterface.version, qApp);
         connect(m_wm, &PlasmaWindowManagement::windowCreated, this,
             [this] (PlasmaWindow *w) {
                 emit KWindowSystem::self()->windowAdded(w->internalId());
                 emit KWindowSystem::self()->stackingOrderChanged();
                 connect(w, &PlasmaWindow::unmapped, this,
                     [w] {
                         emit KWindowSystem::self()->windowRemoved(w->internalId());
                         emit KWindowSystem::self()->stackingOrderChanged();
                     }
                 );
             }
         );
         connect(m_wm, &PlasmaWindowManagement::activeWindowChanged, this,
             [this] {
                 if (PlasmaWindow *w = m_wm->activeWindow()) {
                     emit KWindowSystem::self()->activeWindowChanged(w->internalId());
                 } else {
                     emit KWindowSystem::self()->activeWindowChanged(0);
                 }
             }
         );
         connect(m_wm, &PlasmaWindowManagement::showingDesktopChanged, KWindowSystem::self(), &KWindowSystem::showingDesktopChanged);
         qCDebug(KWAYLAND_KWS) << "Plasma Window Management interface bound";
+
+        connect(m_wm, &KWayland::Client::PlasmaWindowManagement::removed, this,
+            [this] () {
+                m_wm->deleteLater();
+            }
+        );
     }
 
     return m_wm;
 }
 
 KWayland::Client::PlasmaShell *WaylandIntegration::waylandPlasmaShell()
 {
-    if (!m_waylandPlasmaShell) {
+    if (!m_waylandPlasmaShell && m_registry) {
         const KWayland::Client::Registry::AnnouncedInterface wmInterface = m_registry->interface(KWayland::Client::Registry::Interface::PlasmaShell);
 
         if (wmInterface.name == 0) {
             return nullptr;
         }
 
-        m_waylandPlasmaShell = m_registry->createPlasmaShell(wmInterface.name, wmInterface.version, this);
+        m_waylandPlasmaShell = m_registry->createPlasmaShell(wmInterface.name, wmInterface.version, qApp);
     }
     return m_waylandPlasmaShell;
 }
diff --git a/src/windowsystem/waylandintegration.h b/src/windowsystem/waylandintegration.h
index d1ffae8..db2498a 100644
--- a/src/windowsystem/waylandintegration.h
+++ b/src/windowsystem/waylandintegration.h
@@ -1,69 +1,70 @@
 /*
  * Copyright 2014 Martin Gräßlin <mgraesslin@kde.org>
  * Copyright 2015 Marco Martin <mart@kde.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) version 3, or any
  * later version accepted by the membership of KDE e.V. (or its
  * successor approved by the membership of KDE e.V.), which shall
  * act as a proxy defined in Section 6 of version 3 of the license.
  *
  * This library 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
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library.  If not, see <http://www.gnu.org/licenses/>.
  */
 #ifndef WAYLANDINTEGRATION_H
 #define WAYLANDINTEGRATION_H
 #include <KWindowSystem/private/kwindoweffects_p.h>
 
+#include <QPointer>
 
 namespace KWayland
 {
     namespace Client
     {
         class BlurManager;
         class ContrastManager;
         class Compositor;
         class ConnectionThread;
         class PlasmaWindowManagement;
         class PlasmaShell;
         class Registry;
         class SlideManager;
     }
 }
 
 class WaylandIntegration : public QObject
 {
 public:
     explicit WaylandIntegration();
     ~WaylandIntegration();
     void setupKWaylandIntegration();
 
     static WaylandIntegration *self();
 
     KWayland::Client::ConnectionThread *waylandConnection() const;
     KWayland::Client::BlurManager *waylandBlurManager();
     KWayland::Client::ContrastManager *waylandContrastManager();
     KWayland::Client::SlideManager *waylandSlideManager();
     KWayland::Client::Compositor *waylandCompositor() const;
     KWayland::Client::PlasmaWindowManagement *plasmaWindowManagement();
     KWayland::Client::PlasmaShell *waylandPlasmaShell();
 
 private:
-    KWayland::Client::ConnectionThread *m_waylandConnection = nullptr;
-    KWayland::Client::BlurManager *m_waylandBlurManager = nullptr;
-    KWayland::Client::ContrastManager *m_waylandContrastManager = nullptr;
-    KWayland::Client::SlideManager *m_waylandSlideManager = nullptr;
-    KWayland::Client::Compositor *m_waylandCompositor = nullptr;
-    KWayland::Client::PlasmaWindowManagement *m_wm = nullptr;
-    KWayland::Client::PlasmaShell *m_waylandPlasmaShell = nullptr;
-    KWayland::Client::Registry *m_registry = nullptr;
+    QPointer<KWayland::Client::ConnectionThread> m_waylandConnection;
+    QPointer<KWayland::Client::Compositor> m_waylandCompositor;
+    QPointer<KWayland::Client::Registry> m_registry;
+    QPointer<KWayland::Client::BlurManager> m_waylandBlurManager;
+    QPointer<KWayland::Client::ContrastManager> m_waylandContrastManager;
+    QPointer<KWayland::Client::SlideManager> m_waylandSlideManager;
+    QPointer<KWayland::Client::PlasmaWindowManagement> m_wm;
+    QPointer<KWayland::Client::PlasmaShell> m_waylandPlasmaShell;
 };
 
 #endif