diff --git a/autotests/drm/drmTest.cpp b/autotests/drm/drmTest.cpp
index a3d6f20151..0ba8846ea3 100644
--- a/autotests/drm/drmTest.cpp
+++ b/autotests/drm/drmTest.cpp
@@ -38,7 +38,7 @@ static std::unique_ptr<MockGpu> findPrimaryDevice(int crtcCount)
         return nullptr;
     }
 
-    QVector<drmDevice *> devices(deviceCount);
+    QList<drmDevice *> devices(deviceCount);
     if (drmGetDevices2(0, devices.data(), devices.size()) < 0) {
         return nullptr;
     }
@@ -203,9 +203,9 @@ void DrmTest::testZeroModesHandling()
 void DrmTest::testModeGeneration_data()
 {
     QTest::addColumn<QSize>("nativeMode");
-    QTest::addColumn<QVector<QSize>>("expectedModes");
+    QTest::addColumn<QList<QSize>>("expectedModes");
 
-    QTest::newRow("2160p") << QSize(3840, 2160) << QVector<QSize>{
+    QTest::newRow("2160p") << QSize(3840, 2160) << QList<QSize>{
         QSize(1600, 1200),
         QSize(1280, 1024),
         QSize(1024, 768),
@@ -221,7 +221,7 @@ void DrmTest::testModeGeneration_data()
         QSize(1368, 768),
         QSize(1280, 720),
     };
-    QTest::newRow("1440p") << QSize(2560, 1440) << QVector<QSize>{
+    QTest::newRow("1440p") << QSize(2560, 1440) << QList<QSize>{
         QSize(1600, 1200),
         QSize(1280, 1024),
         QSize(1024, 768),
@@ -233,7 +233,7 @@ void DrmTest::testModeGeneration_data()
         QSize(1368, 768),
         QSize(1280, 720),
     };
-    QTest::newRow("1080p") << QSize(1920, 1080) << QVector<QSize>{
+    QTest::newRow("1080p") << QSize(1920, 1080) << QList<QSize>{
         QSize(1280, 1024),
         QSize(1024, 768),
         QSize(1280, 800),
@@ -243,7 +243,7 @@ void DrmTest::testModeGeneration_data()
         QSize(1280, 720),
     };
 
-    QTest::newRow("2160p 21:9") << QSize(5120, 2160) << QVector<QSize>{
+    QTest::newRow("2160p 21:9") << QSize(5120, 2160) << QList<QSize>{
         QSize(5120, 2160),
         QSize(1600, 1200),
         QSize(1280, 1024),
@@ -260,7 +260,7 @@ void DrmTest::testModeGeneration_data()
         QSize(1368, 768),
         QSize(1280, 720),
     };
-    QTest::newRow("1440p 21:9") << QSize(3440, 1440) << QVector<QSize>{
+    QTest::newRow("1440p 21:9") << QSize(3440, 1440) << QList<QSize>{
         QSize(3440, 1440),
         QSize(1600, 1200),
         QSize(1280, 1024),
@@ -273,7 +273,7 @@ void DrmTest::testModeGeneration_data()
         QSize(1368, 768),
         QSize(1280, 720),
     };
-    QTest::newRow("1080p 21:9") << QSize(2560, 1080) << QVector<QSize>{
+    QTest::newRow("1080p 21:9") << QSize(2560, 1080) << QList<QSize>{
         QSize(2560, 1080),
         QSize(1280, 1024),
         QSize(1024, 768),
@@ -298,7 +298,7 @@ void DrmTest::testModeGeneration()
     auto gpu = std::make_unique<DrmGpu>(backend.get(), mockGpu->devNode, mockGpu->fd, 0);
 
     QFETCH(QSize, nativeMode);
-    QFETCH(QVector<QSize>, expectedModes);
+    QFETCH(QList<QSize>, expectedModes);
 
     conn->modes.clear();
     conn->addMode(nativeMode.width(), nativeMode.height(), 60);
@@ -310,7 +310,7 @@ void DrmTest::testModeGeneration()
     mockGpu->connectors.removeAll(conn);
     QVERIFY(gpu->updateOutputs());
 
-    conn->props.emplace_back(conn.get(), QStringLiteral("scaling mode"), 0, DRM_MODE_PROP_ENUM, QVector<QByteArray>{"None", "Full", "Center", "Full aspect"});
+    conn->props.emplace_back(conn.get(), QStringLiteral("scaling mode"), 0, DRM_MODE_PROP_ENUM, QList<QByteArray>{"None", "Full", "Center", "Full aspect"});
     mockGpu->connectors.push_back(conn);
     QVERIFY(gpu->updateOutputs());
 
diff --git a/autotests/drm/mock_drm.cpp b/autotests/drm/mock_drm.cpp
index 44745f9ca9..495a0316d7 100644
--- a/autotests/drm/mock_drm.cpp
+++ b/autotests/drm/mock_drm.cpp
@@ -133,7 +133,7 @@ uint32_t MockObject::getPropId(const QString &propName) const
 
 //
 
-MockProperty::MockProperty(MockObject *obj, QString name, uint64_t initialValue, uint32_t flags, QVector<QByteArray> enums)
+MockProperty::MockProperty(MockObject *obj, QString name, uint64_t initialValue, uint32_t flags, QList<QByteArray> enums)
     : obj(obj)
     , id(obj->gpu->idCounter++)
     , flags(flags)
@@ -522,7 +522,7 @@ int drmModeSetCrtc(int fd, uint32_t crtcId, uint32_t bufferId,
     req->legacyEmulation = true;
     drmModeAtomicAddProperty(req, crtcId, crtc->getPropId(QStringLiteral("MODE_ID")), modeBlob);
     drmModeAtomicAddProperty(req, crtcId, crtc->getPropId(QStringLiteral("ACTIVE")), modeBlob && count);
-    QVector<uint32_t> conns;
+    QList<uint32_t> conns;
     for (int i = 0; i < count; i++) {
         conns << connectors[i];
     }
@@ -843,7 +843,7 @@ drmModeObjectPropertiesPtr drmModeObjectGetProperties(int fd, uint32_t object_id
             errno = EINVAL;
             return nullptr;
         }
-        QVector<MockProperty> props;
+        QList<MockProperty> props;
         bool deviceAtomic = gpu->clientCaps.contains(DRM_CLIENT_CAP_ATOMIC) && gpu->clientCaps[DRM_CLIENT_CAP_ATOMIC];
         for (const auto &prop : std::as_const(obj->props)) {
             if (deviceAtomic || !(prop.flags & DRM_MODE_PROP_ATOMIC)) {
@@ -899,7 +899,7 @@ int drmModeObjectSetProperty(int fd, uint32_t object_id, uint32_t object_type, u
     }
 }
 
-static QVector<drmModeAtomicReqPtr> s_atomicReqs;
+static QList<drmModeAtomicReqPtr> s_atomicReqs;
 
 drmModeAtomicReqPtr drmModeAtomicAlloc(void)
 {
@@ -963,20 +963,20 @@ int drmModeAtomicCommit(int fd, drmModeAtomicReqPtr req, uint32_t flags, void *u
         return -(errno = EINVAL);
     }
 
-    QVector<MockConnector> connCopies;
+    QList<MockConnector> connCopies;
     for (const auto &conn : std::as_const(gpu->connectors)) {
         connCopies << *conn;
     }
-    QVector<MockCrtc> crtcCopies;
+    QList<MockCrtc> crtcCopies;
     for (const auto &crtc : std::as_const(gpu->crtcs)) {
         crtcCopies << *crtc;
     }
-    QVector<MockPlane> planeCopies;
+    QList<MockPlane> planeCopies;
     for (const auto &plane : std::as_const(gpu->planes)) {
         planeCopies << *plane;
     }
 
-    QVector<MockObject*> objects;
+    QList<MockObject *> objects;
     for (int i = 0; i < connCopies.count(); i++) {
         objects << &connCopies[i];
     }
@@ -1022,10 +1022,10 @@ int drmModeAtomicCommit(int fd, drmModeAtomicReqPtr req, uint32_t flags, void *u
     // check if the desired changes are allowed
     struct Pipeline {
         MockCrtc *crtc;
-        QVector<MockConnector*> conns;
+        QList<MockConnector *> conns;
         MockPlane *primaryPlane = nullptr;
     };
-    QVector<Pipeline> pipelines;
+    QList<Pipeline> pipelines;
     for (int i = 0; i < crtcCopies.count(); i++) {
         if (crtcCopies[i].getProp(QStringLiteral("ACTIVE"))) {
             auto blob = gpu->getBlob(crtcCopies[i].getProp(QStringLiteral("MODE_ID")));
diff --git a/autotests/drm/mock_drm.h b/autotests/drm/mock_drm.h
index a013225147..4ae7db0614 100644
--- a/autotests/drm/mock_drm.h
+++ b/autotests/drm/mock_drm.h
@@ -11,9 +11,9 @@
 #include <xf86drm.h>
 #include <xf86drmMode.h>
 
+#include <QList>
 #include <QMap>
 #include <QRect>
-#include <QVector>
 #include <memory>
 #include <mutex>
 #include <vector>
@@ -27,7 +27,7 @@ class MockPlane;
 
 class MockProperty {
 public:
-    MockProperty(MockObject *obj, QString name, uint64_t initialValue, uint32_t flags, QVector<QByteArray> enums = {});
+    MockProperty(MockObject *obj, QString name, uint64_t initialValue, uint32_t flags, QList<QByteArray> enums = {});
     ~MockProperty() = default;
 
     MockObject *obj;
@@ -35,7 +35,7 @@ public:
     uint32_t flags;
     QString name;
     uint64_t value;
-    QVector<QByteArray> enums;
+    QList<QByteArray> enums;
 };
 
 class MockPropertyBlob {
@@ -60,7 +60,7 @@ public:
     uint32_t getPropId(const QString &propName) const;
 
     uint32_t id;
-    QVector<MockProperty> props;
+    QList<MockProperty> props;
     MockGpu *gpu;
 };
 
@@ -75,7 +75,7 @@ public:
     drmModeConnection connection;
     uint32_t type;
     std::shared_ptr<MockEncoder> encoder;
-    QVector<drmModeModeInfo> modes;
+    QList<drmModeModeInfo> modes;
 };
 
 class MockEncoder : public MockObject {
@@ -141,7 +141,7 @@ struct Prop {
 
 struct _drmModeAtomicReq {
     bool legacyEmulation = false;
-    QVector<Prop> props;
+    QList<Prop> props;
 };
 
 #define MOCKDRM_DEVICE_CAP_ATOMIC 0xFF
@@ -165,28 +165,28 @@ public:
     QMap<uint32_t, uint64_t> deviceCaps;
 
     uint32_t idCounter = 1;
-    QVector<MockObject*> objects;
+    QList<MockObject *> objects;
 
-    QVector<std::shared_ptr<MockConnector>> connectors;
-    QVector<drmModeConnectorPtr> drmConnectors;
+    QList<std::shared_ptr<MockConnector>> connectors;
+    QList<drmModeConnectorPtr> drmConnectors;
 
-    QVector<std::shared_ptr<MockEncoder>> encoders;
-    QVector<drmModeEncoderPtr> drmEncoders;
+    QList<std::shared_ptr<MockEncoder>> encoders;
+    QList<drmModeEncoderPtr> drmEncoders;
 
-    QVector<std::shared_ptr<MockCrtc>> crtcs;
-    QVector<drmModeCrtcPtr> drmCrtcs;
+    QList<std::shared_ptr<MockCrtc>> crtcs;
+    QList<drmModeCrtcPtr> drmCrtcs;
 
-    QVector<std::shared_ptr<MockPlane>> planes;
-    QVector<drmModePlanePtr> drmPlanes;
+    QList<std::shared_ptr<MockPlane>> planes;
+    QList<drmModePlanePtr> drmPlanes;
 
-    QVector<MockFb *> fbs;
+    QList<MockFb *> fbs;
     std::vector<std::unique_ptr<MockPropertyBlob>> propertyBlobs;
 
-    QVector<drmModeResPtr> resPtrs;
-    QVector<drmModePropertyPtr> drmProps;
-    QVector<drmModePropertyBlobPtr> drmPropertyBlobs;
-    QVector<drmModeObjectPropertiesPtr> drmObjectProperties;
-    QVector<drmModePlaneResPtr> drmPlaneRes;
+    QList<drmModeResPtr> resPtrs;
+    QList<drmModePropertyPtr> drmProps;
+    QList<drmModePropertyBlobPtr> drmPropertyBlobs;
+    QList<drmModeObjectPropertiesPtr> drmObjectProperties;
+    QList<drmModePlaneResPtr> drmPlaneRes;
     std::mutex m_mutex;
 };
 
diff --git a/autotests/integration/activation_test.cpp b/autotests/integration/activation_test.cpp
index 59d6becffb..734d6d0e09 100644
--- a/autotests/integration/activation_test.cpp
+++ b/autotests/integration/activation_test.cpp
@@ -511,7 +511,7 @@ void ActivationTest::stackScreensHorizontally()
     // Process pending wl_output bind requests before destroying all outputs.
     QTest::qWait(1);
 
-    const QVector<QRect> screenGeometries{
+    const QList<QRect> screenGeometries{
         QRect(0, 0, 1280, 1024),
         QRect(1280, 0, 1280, 1024),
     };
@@ -523,7 +523,7 @@ void ActivationTest::stackScreensVertically()
     // Process pending wl_output bind requests before destroying all outputs.
     QTest::qWait(1);
 
-    const QVector<QRect> screenGeometries{
+    const QList<QRect> screenGeometries{
         QRect(0, 0, 1280, 1024),
         QRect(0, 1024, 1280, 1024),
     };
diff --git a/autotests/integration/dbus_interface_test.cpp b/autotests/integration/dbus_interface_test.cpp
index c81388e9e9..d4de1c89bb 100644
--- a/autotests/integration/dbus_interface_test.cpp
+++ b/autotests/integration/dbus_interface_test.cpp
@@ -190,10 +190,10 @@ void TestDbusInterface::testGetWindowInfoXdgShellClient()
     // not testing shaded as that's X11
     // not testing fullscreen, maximizeHorizontal, maximizeVertical and noBorder as those require window geometry changes
 
-    const QVector<VirtualDesktop *> desktops = VirtualDesktopManager::self()->desktops();
-    QCOMPARE(window->desktops(), QVector<VirtualDesktop *>{desktops[0]});
+    const QList<VirtualDesktop *> desktops = VirtualDesktopManager::self()->desktops();
+    QCOMPARE(window->desktops(), QList<VirtualDesktop *>{desktops[0]});
     workspace()->sendWindowToDesktops(window, {desktops[1]}, false);
-    QCOMPARE(window->desktops(), QVector<VirtualDesktop *>{desktops[1]});
+    QCOMPARE(window->desktops(), QList<VirtualDesktop *>{desktops[1]});
     reply = getWindowInfo(window->internalId());
     reply.waitForFinished();
     QCOMPARE(reply.value().value(QStringLiteral("desktops")).toStringList(), window->desktopIds());
diff --git a/autotests/integration/effects/translucency_test.cpp b/autotests/integration/effects/translucency_test.cpp
index 273449a05b..7512706aed 100644
--- a/autotests/integration/effects/translucency_test.cpp
+++ b/autotests/integration/effects/translucency_test.cpp
@@ -138,7 +138,7 @@ void TranslucencyTest::testMoveAfterDesktopChange()
     // let's send the window to desktop 2
     VirtualDesktopManager *vds = VirtualDesktopManager::self();
     vds->setCount(2);
-    const QVector<VirtualDesktop *> desktops = vds->desktops();
+    const QList<VirtualDesktop *> desktops = vds->desktops();
     workspace()->sendWindowToDesktops(window, {desktops[1]}, false);
     vds->setCurrent(desktops[1]);
     QVERIFY(!m_translucencyEffect->isActive());
diff --git a/autotests/integration/inputmethod_test.cpp b/autotests/integration/inputmethod_test.cpp
index a026bba532..4f053f7af3 100644
--- a/autotests/integration/inputmethod_test.cpp
+++ b/autotests/integration/inputmethod_test.cpp
@@ -357,9 +357,9 @@ void InputMethodTest::testSwitchFocusedSurfaces()
     QSignalSpy activateSpy(kwinApp()->inputMethod(), &InputMethod::activeChanged);
     std::unique_ptr<KWayland::Client::TextInput> textInput(Test::waylandTextInputManager()->createTextInput(Test::waylandSeat()));
 
-    QVector<Window *> windows;
+    QList<Window *> windows;
     std::vector<std::unique_ptr<KWayland::Client::Surface>> surfaces;
-    QVector<Test::XdgToplevel *> toplevels;
+    QList<Test::XdgToplevel *> toplevels;
     // We create 3 surfaces
     for (int i = 0; i < 3; ++i) {
         std::unique_ptr<KWayland::Client::Surface> surface = Test::createSurface();
diff --git a/autotests/integration/kwin_wayland_test.cpp b/autotests/integration/kwin_wayland_test.cpp
index 49e4077b29..7a3bfda8a1 100644
--- a/autotests/integration/kwin_wayland_test.cpp
+++ b/autotests/integration/kwin_wayland_test.cpp
@@ -212,9 +212,9 @@ void Test::FractionalScaleV1::wp_fractional_scale_v1_preferred_scale(uint32_t sc
     m_preferredScale = scale;
 }
 
-void Test::setOutputConfig(const QVector<QRect> &geometries)
+void Test::setOutputConfig(const QList<QRect> &geometries)
 {
-    QVector<VirtualBackend::OutputInfo> converted;
+    QList<VirtualBackend::OutputInfo> converted;
     std::transform(geometries.begin(), geometries.end(), std::back_inserter(converted), [](const auto &geometry) {
         return VirtualBackend::OutputInfo{
             .geometry = geometry,
@@ -223,9 +223,9 @@ void Test::setOutputConfig(const QVector<QRect> &geometries)
     static_cast<VirtualBackend *>(kwinApp()->outputBackend())->setVirtualOutputs(converted);
 }
 
-void Test::setOutputConfig(const QVector<OutputInfo> &infos)
+void Test::setOutputConfig(const QList<OutputInfo> &infos)
 {
-    QVector<VirtualBackend::OutputInfo> converted;
+    QList<VirtualBackend::OutputInfo> converted;
     std::transform(infos.begin(), infos.end(), std::back_inserter(converted), [](const auto &info) {
         return VirtualBackend::OutputInfo{
             .geometry = info.geometry,
diff --git a/autotests/integration/kwin_wayland_test.h b/autotests/integration/kwin_wayland_test.h
index 4293936acb..b4710b9cfe 100644
--- a/autotests/integration/kwin_wayland_test.h
+++ b/autotests/integration/kwin_wayland_test.h
@@ -637,10 +637,10 @@ KWayland::Client::PointerConstraints *waylandPointerConstraints();
 KWayland::Client::AppMenuManager *waylandAppMenuManager();
 WaylandOutputManagementV2 *waylandOutputManagementV2();
 KWayland::Client::TextInputManager *waylandTextInputManager();
-QVector<KWayland::Client::Output *> waylandOutputs();
+QList<KWayland::Client::Output *> waylandOutputs();
 KWayland::Client::Output *waylandOutput(const QString &name);
 ScreencastingV1 *screencasting();
-QVector<WaylandOutputDeviceV2 *> waylandOutputDevicesV2();
+QList<WaylandOutputDeviceV2 *> waylandOutputDevicesV2();
 FakeInput *waylandFakeInput();
 
 bool waitForWaylandSurface(Window *window);
@@ -839,8 +839,8 @@ struct OutputInfo
     double scale = 1;
     bool internal = false;
 };
-void setOutputConfig(const QVector<QRect> &geometries);
-void setOutputConfig(const QVector<OutputInfo> &infos);
+void setOutputConfig(const QList<QRect> &geometries);
+void setOutputConfig(const QList<OutputInfo> &infos);
 }
 
 }
diff --git a/autotests/integration/kwinbindings_test.cpp b/autotests/integration/kwinbindings_test.cpp
index 1081f1fc79..e674e96f1b 100644
--- a/autotests/integration/kwinbindings_test.cpp
+++ b/autotests/integration/kwinbindings_test.cpp
@@ -237,11 +237,11 @@ void KWinBindingsTest::testWindowToDesktop()
     };
     invokeShortcut(desktop);
     QVERIFY(desktopsChangedSpy.wait());
-    QCOMPARE(window->desktops(), QVector<VirtualDesktop *>{desktops.at(desktop - 1)});
+    QCOMPARE(window->desktops(), QList<VirtualDesktop *>{desktops.at(desktop - 1)});
     // back to desktop 1
     invokeShortcut(1);
     QVERIFY(desktopsChangedSpy.wait());
-    QCOMPARE(window->desktops(), QVector<VirtualDesktop *>{desktops.at(0)});
+    QCOMPARE(window->desktops(), QList<VirtualDesktop *>{desktops.at(0)});
     // invoke with one desktop too many
     invokeShortcut(desktop + 1);
     // that should fail
diff --git a/autotests/integration/plasma_surface_test.cpp b/autotests/integration/plasma_surface_test.cpp
index 0794c9cbb7..10f242da82 100644
--- a/autotests/integration/plasma_surface_test.cpp
+++ b/autotests/integration/plasma_surface_test.cpp
@@ -190,7 +190,7 @@ void PlasmaSurfaceTest::testOSDPlacement()
     QCOMPARE(window->frameGeometry(), QRect(1280 / 2 - 100 / 2, 2 * 1024 / 3 - 50 / 2, 100, 50));
 
     // change the screen size
-    const QVector<QRect> geometries{QRect(0, 0, 1280, 1024), QRect(1280, 0, 1280, 1024)};
+    const QList<QRect> geometries{QRect(0, 0, 1280, 1024), QRect(1280, 0, 1280, 1024)};
     Test::setOutputConfig(geometries);
     const auto outputs = workspace()->outputs();
     QCOMPARE(outputs.count(), 2);
diff --git a/autotests/integration/pointer_input.cpp b/autotests/integration/pointer_input.cpp
index 6e44df3a65..53f0d6da31 100644
--- a/autotests/integration/pointer_input.cpp
+++ b/autotests/integration/pointer_input.cpp
@@ -41,7 +41,7 @@ namespace KWin
 static PlatformCursorImage loadReferenceThemeCursor_helper(const KXcursorTheme &theme,
                                                            const QByteArray &name)
 {
-    const QVector<KXcursorSprite> sprites = theme.shape(name);
+    const QList<KXcursorSprite> sprites = theme.shape(name);
     if (sprites.isEmpty()) {
         return PlatformCursorImage();
     }
@@ -63,7 +63,7 @@ static PlatformCursorImage loadReferenceThemeCursor(const QByteArray &name)
         return platformCursorImage;
     }
 
-    const QVector<QByteArray> alternativeNames = Cursor::cursorAlternativeNames(name);
+    const QList<QByteArray> alternativeNames = Cursor::cursorAlternativeNames(name);
     for (const QByteArray &alternativeName : alternativeNames) {
         platformCursorImage = loadReferenceThemeCursor_helper(theme, alternativeName);
         if (!platformCursorImage.isNull()) {
@@ -1535,7 +1535,7 @@ void PointerInputTest::testConfineToScreenGeometry()
     // after moving it to off-screen area
 
     // setup screen layout
-    const QVector<QRect> geometries{
+    const QList<QRect> geometries{
         QRect(0, 0, 1280, 1024),
         QRect(1280, 0, 1280, 1024),
         QRect(2560, 0, 1280, 1024),
diff --git a/autotests/integration/screen_changes_test.cpp b/autotests/integration/screen_changes_test.cpp
index 7c88062e6a..1cf16825dc 100644
--- a/autotests/integration/screen_changes_test.cpp
+++ b/autotests/integration/screen_changes_test.cpp
@@ -81,7 +81,7 @@ void ScreenChangesTest::testScreenAddRemove()
     outputAnnouncedSpy.clear();
 
     // let's announce a new output
-    const QVector<QRect> geometries{QRect(0, 0, 1280, 1024), QRect(1280, 0, 1280, 1024)};
+    const QList<QRect> geometries{QRect(0, 0, 1280, 1024), QRect(1280, 0, 1280, 1024)};
     Test::setOutputConfig(geometries);
     auto outputs = workspace()->outputs();
     QCOMPARE(outputs.count(), 2);
@@ -145,7 +145,7 @@ void ScreenChangesTest::testScreenAddRemove()
     QSignalSpy o1RemovedSpy(o1.get(), &KWayland::Client::Output::removed);
     QSignalSpy o2RemovedSpy(o2.get(), &KWayland::Client::Output::removed);
 
-    const QVector<QRect> geometries2{QRect(0, 0, 1280, 1024)};
+    const QList<QRect> geometries2{QRect(0, 0, 1280, 1024)};
     Test::setOutputConfig(geometries2);
     outputs = workspace()->outputs();
     QCOMPARE(outputs.count(), 1);
diff --git a/autotests/integration/screens_test.cpp b/autotests/integration/screens_test.cpp
index 85542fc0e8..cd253c3c03 100644
--- a/autotests/integration/screens_test.cpp
+++ b/autotests/integration/screens_test.cpp
@@ -117,14 +117,14 @@ void ScreensTest::testCurrent()
 
 void ScreensTest::testCurrentWithFollowsMouse_data()
 {
-    QTest::addColumn<QVector<QRect>>("geometries");
+    QTest::addColumn<QList<QRect>>("geometries");
     QTest::addColumn<QPoint>("cursorPos");
     QTest::addColumn<int>("expectedId");
 
-    QTest::newRow("cloned") << QVector<QRect>{{QRect{0, 0, 200, 100}, QRect{0, 0, 200, 100}}} << QPoint(50, 50) << 0;
-    QTest::newRow("adjacent-0") << QVector<QRect>{{QRect{0, 0, 200, 100}, QRect{200, 100, 400, 300}}} << QPoint(199, 99) << 0;
-    QTest::newRow("adjacent-1") << QVector<QRect>{{QRect{0, 0, 200, 100}, QRect{200, 100, 400, 300}}} << QPoint(200, 100) << 1;
-    QTest::newRow("gap") << QVector<QRect>{{QRect{0, 0, 10, 20}, QRect{20, 40, 10, 20}}} << QPoint(15, 30) << 1;
+    QTest::newRow("cloned") << QList<QRect>{{QRect{0, 0, 200, 100}, QRect{0, 0, 200, 100}}} << QPoint(50, 50) << 0;
+    QTest::newRow("adjacent-0") << QList<QRect>{{QRect{0, 0, 200, 100}, QRect{200, 100, 400, 300}}} << QPoint(199, 99) << 0;
+    QTest::newRow("adjacent-1") << QList<QRect>{{QRect{0, 0, 200, 100}, QRect{200, 100, 400, 300}}} << QPoint(200, 100) << 1;
+    QTest::newRow("gap") << QList<QRect>{{QRect{0, 0, 10, 20}, QRect{20, 40, 10, 20}}} << QPoint(15, 30) << 1;
 }
 
 void ScreensTest::testCurrentWithFollowsMouse()
@@ -135,7 +135,7 @@ void ScreensTest::testCurrentWithFollowsMouse()
     group.sync();
     workspace()->slotReconfigure();
 
-    QFETCH(QVector<QRect>, geometries);
+    QFETCH(QList<QRect>, geometries);
     Test::setOutputConfig(geometries);
 
     QFETCH(QPoint, cursorPos);
@@ -148,19 +148,19 @@ void ScreensTest::testCurrentWithFollowsMouse()
 
 void ScreensTest::testCurrentPoint_data()
 {
-    QTest::addColumn<QVector<QRect>>("geometries");
+    QTest::addColumn<QList<QRect>>("geometries");
     QTest::addColumn<QPoint>("cursorPos");
     QTest::addColumn<int>("expectedId");
 
-    QTest::newRow("cloned") << QVector<QRect>{{QRect{0, 0, 200, 100}, QRect{0, 0, 200, 100}}} << QPoint(50, 50) << 0;
-    QTest::newRow("adjacent-0") << QVector<QRect>{{QRect{0, 0, 200, 100}, QRect{200, 100, 400, 300}}} << QPoint(199, 99) << 0;
-    QTest::newRow("adjacent-1") << QVector<QRect>{{QRect{0, 0, 200, 100}, QRect{200, 100, 400, 300}}} << QPoint(200, 100) << 1;
-    QTest::newRow("gap") << QVector<QRect>{{QRect{0, 0, 10, 20}, QRect{20, 40, 10, 20}}} << QPoint(15, 30) << 1;
+    QTest::newRow("cloned") << QList<QRect>{{QRect{0, 0, 200, 100}, QRect{0, 0, 200, 100}}} << QPoint(50, 50) << 0;
+    QTest::newRow("adjacent-0") << QList<QRect>{{QRect{0, 0, 200, 100}, QRect{200, 100, 400, 300}}} << QPoint(199, 99) << 0;
+    QTest::newRow("adjacent-1") << QList<QRect>{{QRect{0, 0, 200, 100}, QRect{200, 100, 400, 300}}} << QPoint(200, 100) << 1;
+    QTest::newRow("gap") << QList<QRect>{{QRect{0, 0, 10, 20}, QRect{20, 40, 10, 20}}} << QPoint(15, 30) << 1;
 }
 
 void ScreensTest::testCurrentPoint()
 {
-    QFETCH(QVector<QRect>, geometries);
+    QFETCH(QList<QRect>, geometries);
     Test::setOutputConfig(geometries);
 
     // Disable "active screen follows mouse"
diff --git a/autotests/integration/struts_test.cpp b/autotests/integration/struts_test.cpp
index 3adf46c67f..50a2b294cb 100644
--- a/autotests/integration/struts_test.cpp
+++ b/autotests/integration/struts_test.cpp
@@ -427,7 +427,7 @@ void StrutsTest::test363804()
 {
     // this test verifies the condition described in BUG 363804
     // two screens in a vertical setup, aligned to right border with panel on the bottom screen
-    const QVector<QRect> geometries{QRect(0, 0, 1920, 1080), QRect(554, 1080, 1366, 768)};
+    const QList<QRect> geometries{QRect(0, 0, 1920, 1080), QRect(554, 1080, 1366, 768)};
     Test::setOutputConfig(geometries);
     QCOMPARE(workspace()->geometry(), QRect(0, 0, 1920, 1848));
 
@@ -504,7 +504,7 @@ void StrutsTest::testLeftScreenSmallerBottomAligned()
 {
     // this test verifies a two screen setup with the left screen smaller than the right and bottom aligned
     // the panel is on the top of the left screen, thus not at 0/0
-    const QVector<QRect> geometries{QRect(0, 282, 1366, 768), QRect(1366, 0, 1680, 1050)};
+    const QList<QRect> geometries{QRect(0, 282, 1366, 768), QRect(1366, 0, 1680, 1050)};
     Test::setOutputConfig(geometries);
     QCOMPARE(workspace()->geometry(), QRect(0, 0, 3046, 1050));
 
@@ -585,7 +585,7 @@ void StrutsTest::testWindowMoveWithPanelBetweenScreens()
     // to the other even if there is a panel in between.
 
     // left screen must be smaller than right screen
-    const QVector<QRect> geometries{QRect(0, 282, 1366, 768), QRect(1366, 0, 1680, 1050)};
+    const QList<QRect> geometries{QRect(0, 282, 1366, 768), QRect(1366, 0, 1680, 1050)};
     Test::setOutputConfig(geometries);
     QCOMPARE(workspace()->geometry(), QRect(0, 0, 3046, 1050));
 
diff --git a/autotests/integration/test_helpers.cpp b/autotests/integration/test_helpers.cpp
index ad313502f2..52b1c90843 100644
--- a/autotests/integration/test_helpers.cpp
+++ b/autotests/integration/test_helpers.cpp
@@ -280,8 +280,8 @@ static struct
     KWayland::Client::Registry *registry = nullptr;
     WaylandOutputManagementV2 *outputManagementV2 = nullptr;
     QThread *thread = nullptr;
-    QVector<KWayland::Client::Output *> outputs;
-    QVector<WaylandOutputDeviceV2 *> outputDevicesV2;
+    QList<KWayland::Client::Output *> outputs;
+    QList<WaylandOutputDeviceV2 *> outputDevicesV2;
     IdleInhibitManagerV1 *idleInhibitManagerV1 = nullptr;
     KWayland::Client::AppMenuManager *appMenu = nullptr;
     XdgDecorationManagerV1 *xdgDecorationManagerV1 = nullptr;
@@ -697,7 +697,7 @@ TextInputManagerV3 *waylandTextInputManagerV3()
     return s_waylandConnection.textInputManagerV3;
 }
 
-QVector<KWayland::Client::Output *> waylandOutputs()
+QList<KWayland::Client::Output *> waylandOutputs()
 {
     return s_waylandConnection.outputs;
 }
@@ -717,7 +717,7 @@ ScreencastingV1 *screencasting()
     return s_waylandConnection.screencastingV1;
 }
 
-QVector<KWin::Test::WaylandOutputDeviceV2 *> waylandOutputDevicesV2()
+QList<KWin::Test::WaylandOutputDeviceV2 *> waylandOutputDevicesV2()
 {
     return s_waylandConnection.outputDevicesV2;
 }
@@ -1131,7 +1131,7 @@ bool renderNodeAvailable()
         return false;
     }
 
-    QVector<drmDevice *> devices(deviceCount);
+    QList<drmDevice *> devices(deviceCount);
     if (drmGetDevices2(0, devices.data(), devices.size()) < 0) {
         return false;
     }
diff --git a/autotests/integration/virtual_desktop_test.cpp b/autotests/integration/virtual_desktop_test.cpp
index bb9f6f4cab..1ea6457306 100644
--- a/autotests/integration/virtual_desktop_test.cpp
+++ b/autotests/integration/virtual_desktop_test.cpp
@@ -160,7 +160,7 @@ void VirtualDesktopTest::testWindowOnMultipleDesktops()
     std::unique_ptr<Test::XdgToplevel> shellSurface(Test::createXdgToplevelSurface(surface.get()));
     auto window = Test::renderAndWaitForShown(surface.get(), QSize(100, 50), Qt::blue);
     QVERIFY(window);
-    QCOMPARE(window->desktops(), (QVector<VirtualDesktop *>{desktops.at(2)}));
+    QCOMPARE(window->desktops(), (QList<VirtualDesktop *>{desktops.at(2)}));
 
     // Set the window on desktop 2 as well
     window->enterDesktop(VirtualDesktopManager::self()->desktopForX11Id(2));
@@ -170,10 +170,10 @@ void VirtualDesktopTest::testWindowOnMultipleDesktops()
 
     // leave desktop 3
     window->leaveDesktop(desktops.at(2));
-    QCOMPARE(window->desktops(), (QVector<VirtualDesktop *>{desktops.at(1)}));
+    QCOMPARE(window->desktops(), (QList<VirtualDesktop *>{desktops.at(1)}));
     // leave desktop 2
     window->leaveDesktop(desktops.at(1));
-    QCOMPARE(window->desktops(), QVector<VirtualDesktop *>{});
+    QCOMPARE(window->desktops(), QList<VirtualDesktop *>{});
     // we should be on all desktops now
     QVERIFY(window->isOnAllDesktops());
     // put on desktop 1
diff --git a/autotests/integration/xdgshellwindow_test.cpp b/autotests/integration/xdgshellwindow_test.cpp
index 13169205d8..ef6e8961ae 100644
--- a/autotests/integration/xdgshellwindow_test.cpp
+++ b/autotests/integration/xdgshellwindow_test.cpp
@@ -863,7 +863,7 @@ void TestXdgShellWindow::testSendClientWithTransientToDesktop()
 
     VirtualDesktopManager *vds = VirtualDesktopManager::self();
     vds->setCount(2);
-    const QVector<VirtualDesktop *> desktops = vds->desktops();
+    const QList<VirtualDesktop *> desktops = vds->desktops();
 
     std::unique_ptr<KWayland::Client::Surface> surface{Test::createSurface()};
     std::unique_ptr<Test::XdgToplevel> shellSurface(Test::createXdgToplevelSurface(surface.get()));
@@ -883,15 +883,15 @@ void TestXdgShellWindow::testSendClientWithTransientToDesktop()
     QVERIFY(window->transients().contains(transient));
 
     // initially, the parent and the transient are on the first virtual desktop
-    QCOMPARE(window->desktops(), QVector<VirtualDesktop *>{desktops[0]});
+    QCOMPARE(window->desktops(), QList<VirtualDesktop *>{desktops[0]});
     QVERIFY(!window->isOnAllDesktops());
-    QCOMPARE(transient->desktops(), QVector<VirtualDesktop *>{desktops[0]});
+    QCOMPARE(transient->desktops(), QList<VirtualDesktop *>{desktops[0]});
     QVERIFY(!transient->isOnAllDesktops());
 
     // send the transient to the second virtual desktop
     workspace()->slotWindowToDesktop(desktops[1]);
-    QCOMPARE(window->desktops(), QVector<VirtualDesktop *>{desktops[0]});
-    QCOMPARE(transient->desktops(), QVector<VirtualDesktop *>{desktops[1]});
+    QCOMPARE(window->desktops(), QList<VirtualDesktop *>{desktops[0]});
+    QCOMPARE(transient->desktops(), QList<VirtualDesktop *>{desktops[1]});
 
     // activate c
     workspace()->activateWindow(window);
@@ -899,13 +899,13 @@ void TestXdgShellWindow::testSendClientWithTransientToDesktop()
     QVERIFY(window->isActive());
 
     // and send it to the desktop it's already on
-    QCOMPARE(window->desktops(), QVector<VirtualDesktop *>{desktops[0]});
-    QCOMPARE(transient->desktops(), QVector<VirtualDesktop *>{desktops[1]});
+    QCOMPARE(window->desktops(), QList<VirtualDesktop *>{desktops[0]});
+    QCOMPARE(transient->desktops(), QList<VirtualDesktop *>{desktops[1]});
     workspace()->slotWindowToDesktop(desktops[0]);
 
     // which should move the transient back to the desktop
-    QCOMPARE(window->desktops(), QVector<VirtualDesktop *>{desktops[0]});
-    QCOMPARE(transient->desktops(), QVector<VirtualDesktop *>{desktops[0]});
+    QCOMPARE(window->desktops(), QList<VirtualDesktop *>{desktops[0]});
+    QCOMPARE(transient->desktops(), QList<VirtualDesktop *>{desktops[0]});
 }
 
 void TestXdgShellWindow::testMinimizeWindowWithTransients()
diff --git a/autotests/libinput/device_test.cpp b/autotests/libinput/device_test.cpp
index fc08294396..31b481dc0f 100644
--- a/autotests/libinput/device_test.cpp
+++ b/autotests/libinput/device_test.cpp
@@ -966,10 +966,10 @@ void TestLibinputDevice::testSupportedButtons()
 
 void TestLibinputDevice::testAlphaNumericKeyboard_data()
 {
-    QTest::addColumn<QVector<quint32>>("supportedKeys");
+    QTest::addColumn<QList<quint32>>("supportedKeys");
     QTest::addColumn<bool>("isAlpha");
 
-    QVector<quint32> keys;
+    QList<quint32> keys;
 
     for (int i = KEY_1; i <= KEY_0; i++) {
         keys << i;
@@ -1006,7 +1006,7 @@ void TestLibinputDevice::testAlphaNumericKeyboard_data()
 
 void TestLibinputDevice::testAlphaNumericKeyboard()
 {
-    QFETCH(QVector<quint32>, supportedKeys);
+    QFETCH(QList<quint32>, supportedKeys);
     libinput_device device;
     device.keyboard = true;
     device.keys = supportedKeys;
diff --git a/autotests/libinput/mock_libinput.h b/autotests/libinput/mock_libinput.h
index 0afd87202b..1f6d3c8ce2 100644
--- a/autotests/libinput/mock_libinput.h
+++ b/autotests/libinput/mock_libinput.h
@@ -11,9 +11,9 @@
 #include <libinput.h>
 
 #include <QByteArray>
+#include <QList>
 #include <QPointF>
 #include <QSizeF>
-#include <QVector>
 
 #include <array>
 #include <chrono>
@@ -74,7 +74,7 @@ struct libinput_device
     quint32 scrollButton = 0;
     int setScrollButtonReturnValue = 0;
     Qt::MouseButtons supportedButtons;
-    QVector<quint32> keys;
+    QList<quint32> keys;
     bool enabled = true;
     int setEnableModeReturnValue = 0;
     int setTapToClickReturnValue = 0;
diff --git a/autotests/libkwineffects/kwinglplatformtest.cpp b/autotests/libkwineffects/kwinglplatformtest.cpp
index 25e9f7b0b5..98aab12d51 100644
--- a/autotests/libkwineffects/kwinglplatformtest.cpp
+++ b/autotests/libkwineffects/kwinglplatformtest.cpp
@@ -201,7 +201,7 @@ static Version readVersion(const KConfigGroup &group, const char *entry)
     if (parts.count() < 2) {
         return Version();
     }
-    QVector<qint64> versionParts;
+    QList<qint64> versionParts;
     for (int i = 0; i < parts.count(); ++i) {
         bool ok = false;
         const auto value = parts.at(i).toLongLong(&ok);
@@ -227,10 +227,10 @@ void GLPlatformTest::testDetect()
     s_gl->getString.renderer = driverGroup.readEntry("Renderer").toUtf8();
     s_gl->getString.version = driverGroup.readEntry("Version").toUtf8();
     s_gl->getString.shadingLanguageVersion = driverGroup.readEntry("ShadingLanguageVersion").toUtf8();
-    s_gl->getString.extensions = QVector<QByteArray>{QByteArrayLiteral("GL_ARB_shader_objects"),
-                                                     QByteArrayLiteral("GL_ARB_fragment_shader"),
-                                                     QByteArrayLiteral("GL_ARB_vertex_shader"),
-                                                     QByteArrayLiteral("GL_ARB_texture_non_power_of_two")};
+    s_gl->getString.extensions = QList<QByteArray>{QByteArrayLiteral("GL_ARB_shader_objects"),
+                                                   QByteArrayLiteral("GL_ARB_fragment_shader"),
+                                                   QByteArrayLiteral("GL_ARB_vertex_shader"),
+                                                   QByteArrayLiteral("GL_ARB_texture_non_power_of_two")};
     s_gl->getString.extensionsString = QByteArray();
 
     auto *gl = GLPlatform::instance();
diff --git a/autotests/libkwineffects/mock_gl.h b/autotests/libkwineffects/mock_gl.h
index ff715814ed..a548bc0685 100644
--- a/autotests/libkwineffects/mock_gl.h
+++ b/autotests/libkwineffects/mock_gl.h
@@ -10,7 +10,7 @@
 #define MOCK_GL_H
 
 #include <QByteArray>
-#include <QVector>
+#include <QList>
 
 struct MockGL
 {
@@ -19,7 +19,7 @@ struct MockGL
         QByteArray vendor;
         QByteArray renderer;
         QByteArray version;
-        QVector<QByteArray> extensions;
+        QList<QByteArray> extensions;
         QByteArray extensionsString;
         QByteArray shadingLanguageVersion;
     } getString;
diff --git a/autotests/wayland/client/test_wayland_surface.cpp b/autotests/wayland/client/test_wayland_surface.cpp
index eb23a4e63e..e5aa1ac24d 100644
--- a/autotests/wayland/client/test_wayland_surface.cpp
+++ b/autotests/wayland/client/test_wayland_surface.cpp
@@ -843,7 +843,7 @@ void TestWaylandSurface::testOutput()
     QVERIFY(surfaceCreatedSpy.wait());
     auto serverSurface = surfaceCreatedSpy.first().first().value<SurfaceInterface *>();
     QVERIFY(serverSurface);
-    QCOMPARE(serverSurface->outputs(), QVector<OutputInterface *>());
+    QCOMPARE(serverSurface->outputs(), QList<OutputInterface *>());
 
     // create another registry to get notified about added outputs
     KWayland::Client::Registry registry;
@@ -865,31 +865,31 @@ void TestWaylandSurface::testOutput()
     m_display->dispatchEvents();
 
     // now enter it
-    serverSurface->setOutputs(QVector<OutputInterface *>{serverOutput.get()});
-    QCOMPARE(serverSurface->outputs(), QVector<OutputInterface *>{serverOutput.get()});
+    serverSurface->setOutputs(QList<OutputInterface *>{serverOutput.get()});
+    QCOMPARE(serverSurface->outputs(), QList<OutputInterface *>{serverOutput.get()});
     QVERIFY(enteredSpy.wait());
     QCOMPARE(enteredSpy.count(), 1);
     QCOMPARE(enteredSpy.first().first().value<KWayland::Client::Output *>(), clientOutput.get());
-    QCOMPARE(s->outputs(), QVector<KWayland::Client::Output *>{clientOutput.get()});
+    QCOMPARE(s->outputs(), QList<KWayland::Client::Output *>{clientOutput.get()});
 
     // adding to same should not trigger
-    serverSurface->setOutputs(QVector<OutputInterface *>{serverOutput.get()});
+    serverSurface->setOutputs(QList<OutputInterface *>{serverOutput.get()});
 
     // leave again
-    serverSurface->setOutputs(QVector<OutputInterface *>());
-    QCOMPARE(serverSurface->outputs(), QVector<OutputInterface *>());
+    serverSurface->setOutputs(QList<OutputInterface *>());
+    QCOMPARE(serverSurface->outputs(), QList<OutputInterface *>());
     QVERIFY(leftSpy.wait());
     QCOMPARE(enteredSpy.count(), 1);
     QCOMPARE(leftSpy.count(), 1);
     QCOMPARE(leftSpy.first().first().value<KWayland::Client::Output *>(), clientOutput.get());
-    QCOMPARE(s->outputs(), QVector<KWayland::Client::Output *>());
+    QCOMPARE(s->outputs(), QList<KWayland::Client::Output *>());
 
     // leave again should not trigger
-    serverSurface->setOutputs(QVector<OutputInterface *>());
+    serverSurface->setOutputs(QList<OutputInterface *>());
 
     // and enter again, just to verify
-    serverSurface->setOutputs(QVector<OutputInterface *>{serverOutput.get()});
-    QCOMPARE(serverSurface->outputs(), QVector<OutputInterface *>{serverOutput.get()});
+    serverSurface->setOutputs(QList<OutputInterface *>{serverOutput.get()});
+    QCOMPARE(serverSurface->outputs(), QList<OutputInterface *>{serverOutput.get()});
     QVERIFY(enteredSpy.wait());
     QCOMPARE(enteredSpy.count(), 2);
     QCOMPARE(leftSpy.count(), 1);
@@ -899,7 +899,7 @@ void TestWaylandSurface::testOutput()
     serverOutput.reset();
     outputHandle.reset();
     QVERIFY(leftSpy.wait());
-    QCOMPARE(serverSurface->outputs(), QVector<OutputInterface *>());
+    QCOMPARE(serverSurface->outputs(), QList<OutputInterface *>());
 }
 
 void TestWaylandSurface::testInhibit()
diff --git a/autotests/wayland/server/test_datacontrol_interface.cpp b/autotests/wayland/server/test_datacontrol_interface.cpp
index efe5f70b39..00a1028060 100644
--- a/autotests/wayland/server/test_datacontrol_interface.cpp
+++ b/autotests/wayland/server/test_datacontrol_interface.cpp
@@ -158,7 +158,7 @@ private:
 
     DataControlDeviceManager *m_dataControlDeviceManager;
 
-    QVector<SurfaceInterface *> m_surfaces;
+    QList<SurfaceInterface *> m_surfaces;
 };
 
 static const QString s_socketName = QStringLiteral("kwin-wayland-datacontrol-test-0");
diff --git a/autotests/wayland/server/test_inputmethod_interface.cpp b/autotests/wayland/server/test_inputmethod_interface.cpp
index 696fee925b..efccfad4e1 100644
--- a/autotests/wayland/server/test_inputmethod_interface.cpp
+++ b/autotests/wayland/server/test_inputmethod_interface.cpp
@@ -184,7 +184,7 @@ private:
     KWin::InputMethodV1Interface *m_inputMethodIface;
     KWin::InputPanelV1Interface *m_inputPanelIface;
 
-    QVector<SurfaceInterface *> m_surfaces;
+    QList<SurfaceInterface *> m_surfaces;
 };
 
 static const QString s_socketName = QStringLiteral("kwin-wayland-server-inputmethod-test-0");
diff --git a/autotests/wayland/server/test_keyboard_shortcuts_inhibitor_interface.cpp b/autotests/wayland/server/test_keyboard_shortcuts_inhibitor_interface.cpp
index 80fb4fe686..bb4b0ca971 100644
--- a/autotests/wayland/server/test_keyboard_shortcuts_inhibitor_interface.cpp
+++ b/autotests/wayland/server/test_keyboard_shortcuts_inhibitor_interface.cpp
@@ -85,8 +85,8 @@ private:
     CompositorInterface *m_serverCompositor;
 
     KeyboardShortcutsInhibitManagerV1Interface *m_manager;
-    QVector<SurfaceInterface *> m_surfaces;
-    QVector<wl_surface *> m_clientSurfaces;
+    QList<SurfaceInterface *> m_surfaces;
+    QList<wl_surface *> m_clientSurfaces;
     KeyboardShortcutsInhibitManager *m_inhibitManagerClient = nullptr;
 };
 
diff --git a/autotests/wayland/server/test_tablet_interface.cpp b/autotests/wayland/server/test_tablet_interface.cpp
index 3e41d94fe1..57f7639e5a 100644
--- a/autotests/wayland/server/test_tablet_interface.cpp
+++ b/autotests/wayland/server/test_tablet_interface.cpp
@@ -125,9 +125,9 @@ public:
         Q_EMIT padAdded();
     }
 
-    QVector<Tablet *> m_tablets;
-    QVector<TabletPad *> m_pads;
-    QVector<Tool *> m_tools;
+    QList<Tablet *> m_tablets;
+    QList<TabletPad *> m_pads;
+    QList<Tool *> m_tools;
 
 Q_SIGNALS:
     void padAdded();
@@ -164,13 +164,13 @@ private:
 
     TabletSeat *m_tabletSeatClient = nullptr;
     TabletManagerV2Interface *m_tabletManager;
-    QVector<KWayland::Client::Surface *> m_surfacesClient;
+    QList<KWayland::Client::Surface *> m_surfacesClient;
 
     TabletV2Interface *m_tablet;
     TabletPadV2Interface *m_tabletPad = nullptr;
     TabletToolV2Interface *m_tool;
 
-    QVector<SurfaceInterface *> m_surfaces;
+    QList<SurfaceInterface *> m_surfaces;
 };
 
 static const QString s_socketName = QStringLiteral("kwin-wayland-server-tablet-test-0");
diff --git a/src/backends/drm/drm_backend.cpp b/src/backends/drm/drm_backend.cpp
index 2d06f84e0d..e3c8c81733 100644
--- a/src/backends/drm/drm_backend.cpp
+++ b/src/backends/drm/drm_backend.cpp
@@ -297,9 +297,9 @@ void DrmBackend::sceneInitialized()
     }
 }
 
-QVector<CompositingType> DrmBackend::supportedCompositors() const
+QList<CompositingType> DrmBackend::supportedCompositors() const
 {
-    return QVector<CompositingType>{OpenGLCompositing, QPainterCompositing};
+    return QList<CompositingType>{OpenGLCompositing, QPainterCompositing};
 }
 
 QString DrmBackend::supportInformation() const
@@ -352,8 +352,8 @@ size_t DrmBackend::gpuCount() const
 
 bool DrmBackend::applyOutputChanges(const OutputConfiguration &config)
 {
-    QVector<DrmOutput *> toBeEnabled;
-    QVector<DrmOutput *> toBeDisabled;
+    QList<DrmOutput *> toBeEnabled;
+    QList<DrmOutput *> toBeDisabled;
     for (const auto &gpu : std::as_const(m_gpus)) {
         const auto &outputs = gpu->drmOutputs();
         for (const auto &output : outputs) {
diff --git a/src/backends/drm/drm_backend.h b/src/backends/drm/drm_backend.h
index 4622ccd626..4144af30a5 100644
--- a/src/backends/drm/drm_backend.h
+++ b/src/backends/drm/drm_backend.h
@@ -9,10 +9,10 @@
 #pragma once
 #include "core/outputbackend.h"
 
+#include <QList>
 #include <QPointer>
 #include <QSize>
 #include <QSocketNotifier>
-#include <QVector>
 
 #include <memory>
 #include <sys/types.h>
@@ -49,7 +49,7 @@ public:
     Outputs outputs() const override;
     Session *session() const override;
 
-    QVector<CompositingType> supportedCompositors() const override;
+    QList<CompositingType> supportedCompositors() const override;
 
     QString supportInformation() const override;
     Output *createVirtualOutput(const QString &name, const QSize &size, double scale) override;
@@ -88,8 +88,8 @@ private:
     std::unique_ptr<UdevMonitor> m_udevMonitor;
     std::unique_ptr<QSocketNotifier> m_socketNotifier;
     Session *m_session;
-    QVector<DrmAbstractOutput *> m_outputs;
-    QVector<QUuid> m_recentlyUnpluggedDpmsOffOutputs;
+    QList<DrmAbstractOutput *> m_outputs;
+    QList<QUuid> m_recentlyUnpluggedDpmsOffOutputs;
 
     const QStringList m_explicitGpus;
     std::vector<std::unique_ptr<DrmGpu>> m_gpus;
diff --git a/src/backends/drm/drm_commit.cpp b/src/backends/drm/drm_commit.cpp
index 486cb73ae3..de1285427d 100644
--- a/src/backends/drm/drm_commit.cpp
+++ b/src/backends/drm/drm_commit.cpp
@@ -36,7 +36,7 @@ DrmGpu *DrmCommit::gpu() const
     return m_gpu;
 }
 
-DrmAtomicCommit::DrmAtomicCommit(const QVector<DrmPipeline *> &pipelines)
+DrmAtomicCommit::DrmAtomicCommit(const QList<DrmPipeline *> &pipelines)
     : DrmCommit(pipelines.front()->gpu())
     , m_pipelines(pipelines)
 {
diff --git a/src/backends/drm/drm_commit.h b/src/backends/drm/drm_commit.h
index 868b660b54..b9c5a9e792 100644
--- a/src/backends/drm/drm_commit.h
+++ b/src/backends/drm/drm_commit.h
@@ -49,7 +49,7 @@ protected:
 class DrmAtomicCommit : public DrmCommit
 {
 public:
-    DrmAtomicCommit(const QVector<DrmPipeline *> &pipelines);
+    DrmAtomicCommit(const QList<DrmPipeline *> &pipelines);
     DrmAtomicCommit(const DrmAtomicCommit &copy) = default;
 
     void addProperty(const DrmProperty &prop, uint64_t value);
@@ -81,7 +81,7 @@ public:
 private:
     bool doCommit(uint32_t flags);
 
-    const QVector<DrmPipeline *> m_pipelines;
+    const QList<DrmPipeline *> m_pipelines;
     std::unordered_map<const DrmProperty *, std::shared_ptr<DrmBlob>> m_blobs;
     std::unordered_map<DrmPlane *, std::shared_ptr<DrmFramebuffer>> m_buffers;
     std::unordered_set<DrmPlane *> m_planes;
diff --git a/src/backends/drm/drm_connector.cpp b/src/backends/drm/drm_connector.cpp
index 5e4b9ff0ce..ede1aabe78 100644
--- a/src/backends/drm/drm_connector.cpp
+++ b/src/backends/drm/drm_connector.cpp
@@ -326,7 +326,7 @@ void DrmConnector::disable(DrmAtomicCommit *commit)
     commit->addProperty(crtcId, 0);
 }
 
-static const QVector<QSize> s_commonModes = {
+static const QList<QSize> s_commonModes = {
     /* 4:3 (1.33) */
     QSize(1600, 1200),
     QSize(1280, 1024), /* 5:4 (1.25) */
diff --git a/src/backends/drm/drm_dmabuf_feedback.cpp b/src/backends/drm/drm_dmabuf_feedback.cpp
index 20ae152886..3e73ad1266 100644
--- a/src/backends/drm/drm_dmabuf_feedback.cpp
+++ b/src/backends/drm/drm_dmabuf_feedback.cpp
@@ -43,7 +43,7 @@ void DmabufFeedback::scanoutSuccessful(SurfaceInterface *surface)
     }
 }
 
-void DmabufFeedback::scanoutFailed(SurfaceInterface *surface, const QMap<uint32_t, QVector<uint64_t>> &formats)
+void DmabufFeedback::scanoutFailed(SurfaceInterface *surface, const QMap<uint32_t, QList<uint64_t>> &formats)
 {
     m_attemptedThisFrame = true;
     if (surface != m_surface) {
@@ -57,7 +57,7 @@ void DmabufFeedback::scanoutFailed(SurfaceInterface *surface, const QMap<uint32_
         const DmaBufAttributes *dmabufAttrs = surface->buffer()->dmabufAttributes();
         if (!m_attemptedFormats[dmabufAttrs->format].contains(dmabufAttrs->modifier)) {
             m_attemptedFormats[dmabufAttrs->format] << dmabufAttrs->modifier;
-            QVector<LinuxDmaBufV1Feedback::Tranche> scanoutTranches;
+            QList<LinuxDmaBufV1Feedback::Tranche> scanoutTranches;
             const auto tranches = m_eglBackend->tranches();
             for (const auto &tranche : tranches) {
                 LinuxDmaBufV1Feedback::Tranche scanoutTranche;
diff --git a/src/backends/drm/drm_dmabuf_feedback.h b/src/backends/drm/drm_dmabuf_feedback.h
index 3bd312af91..227b827726 100644
--- a/src/backends/drm/drm_dmabuf_feedback.h
+++ b/src/backends/drm/drm_dmabuf_feedback.h
@@ -8,9 +8,9 @@
 */
 #pragma once
 
+#include <QList>
 #include <QMap>
 #include <QPointer>
-#include <QVector>
 
 namespace KWin
 {
@@ -26,11 +26,11 @@ public:
 
     void renderingSurface();
     void scanoutSuccessful(SurfaceInterface *surface);
-    void scanoutFailed(SurfaceInterface *surface, const QMap<uint32_t, QVector<uint64_t>> &formats);
+    void scanoutFailed(SurfaceInterface *surface, const QMap<uint32_t, QList<uint64_t>> &formats);
 
 private:
     QPointer<SurfaceInterface> m_surface;
-    QMap<uint32_t, QVector<uint64_t>> m_attemptedFormats;
+    QMap<uint32_t, QList<uint64_t>> m_attemptedFormats;
     bool m_attemptedThisFrame = false;
 
     DrmGpu *const m_gpu;
diff --git a/src/backends/drm/drm_egl_layer_surface.cpp b/src/backends/drm/drm_egl_layer_surface.cpp
index 793e1de78f..171d30b1b8 100644
--- a/src/backends/drm/drm_egl_layer_surface.cpp
+++ b/src/backends/drm/drm_egl_layer_surface.cpp
@@ -27,9 +27,9 @@
 namespace KWin
 {
 
-static const QVector<uint64_t> linearModifier = {DRM_FORMAT_MOD_LINEAR};
-static const QVector<uint64_t> implicitModifier = {DRM_FORMAT_MOD_INVALID};
-static const QVector<uint32_t> cpuCopyFormats = {DRM_FORMAT_ARGB8888, DRM_FORMAT_XRGB8888};
+static const QList<uint64_t> linearModifier = {DRM_FORMAT_MOD_LINEAR};
+static const QList<uint64_t> implicitModifier = {DRM_FORMAT_MOD_INVALID};
+static const QList<uint32_t> cpuCopyFormats = {DRM_FORMAT_ARGB8888, DRM_FORMAT_XRGB8888};
 
 static const bool bufferAgeEnabled = qEnvironmentVariable("KWIN_USE_BUFFER_AGE") != QStringLiteral("0");
 
@@ -69,7 +69,7 @@ void EglGbmLayerSurface::destroyResources()
     m_oldSurface = {};
 }
 
-std::optional<OutputLayerBeginFrameInfo> EglGbmLayerSurface::startRendering(const QSize &bufferSize, TextureTransforms transformation, const QMap<uint32_t, QVector<uint64_t>> &formats, const ColorDescription &colorDescription, const QVector3D &channelFactors, bool enableColormanagement)
+std::optional<OutputLayerBeginFrameInfo> EglGbmLayerSurface::startRendering(const QSize &bufferSize, TextureTransforms transformation, const QMap<uint32_t, QList<uint64_t>> &formats, const ColorDescription &colorDescription, const QVector3D &channelFactors, bool enableColormanagement)
 {
     if (!checkSurface(bufferSize, formats)) {
         return std::nullopt;
@@ -206,7 +206,7 @@ const ColorDescription &EglGbmLayerSurface::colorDescription() const
     }
 }
 
-bool EglGbmLayerSurface::doesSurfaceFit(const QSize &size, const QMap<uint32_t, QVector<uint64_t>> &formats) const
+bool EglGbmLayerSurface::doesSurfaceFit(const QSize &size, const QMap<uint32_t, QList<uint64_t>> &formats) const
 {
     return doesSurfaceFit(m_surface.get(), size, formats);
 }
@@ -220,7 +220,7 @@ std::shared_ptr<GLTexture> EglGbmLayerSurface::texture() const
     }
 }
 
-std::shared_ptr<DrmFramebuffer> EglGbmLayerSurface::renderTestBuffer(const QSize &bufferSize, const QMap<uint32_t, QVector<uint64_t>> &formats)
+std::shared_ptr<DrmFramebuffer> EglGbmLayerSurface::renderTestBuffer(const QSize &bufferSize, const QMap<uint32_t, QList<uint64_t>> &formats)
 {
     if (checkSurface(bufferSize, formats)) {
         return m_surface->currentFramebuffer;
@@ -229,7 +229,7 @@ std::shared_ptr<DrmFramebuffer> EglGbmLayerSurface::renderTestBuffer(const QSize
     }
 }
 
-bool EglGbmLayerSurface::checkSurface(const QSize &size, const QMap<uint32_t, QVector<uint64_t>> &formats)
+bool EglGbmLayerSurface::checkSurface(const QSize &size, const QMap<uint32_t, QList<uint64_t>> &formats)
 {
     if (doesSurfaceFit(m_surface.get(), size, formats)) {
         return true;
@@ -246,7 +246,7 @@ bool EglGbmLayerSurface::checkSurface(const QSize &size, const QMap<uint32_t, QV
     return false;
 }
 
-bool EglGbmLayerSurface::doesSurfaceFit(Surface *surface, const QSize &size, const QMap<uint32_t, QVector<uint64_t>> &formats) const
+bool EglGbmLayerSurface::doesSurfaceFit(Surface *surface, const QSize &size, const QMap<uint32_t, QList<uint64_t>> &formats) const
 {
     if (!surface) {
         return false;
@@ -258,10 +258,10 @@ bool EglGbmLayerSurface::doesSurfaceFit(Surface *surface, const QSize &size, con
         && (surface->forceLinear || swapchain->modifier() == DRM_FORMAT_MOD_INVALID || formats[swapchain->format()].contains(swapchain->modifier()));
 }
 
-std::unique_ptr<EglGbmLayerSurface::Surface> EglGbmLayerSurface::createSurface(const QSize &size, const QMap<uint32_t, QVector<uint64_t>> &formats) const
+std::unique_ptr<EglGbmLayerSurface::Surface> EglGbmLayerSurface::createSurface(const QSize &size, const QMap<uint32_t, QList<uint64_t>> &formats) const
 {
-    QVector<FormatInfo> preferredFormats;
-    QVector<FormatInfo> fallbackFormats;
+    QList<FormatInfo> preferredFormats;
+    QList<FormatInfo> fallbackFormats;
     for (auto it = formats.begin(); it != formats.end(); it++) {
         const auto format = formatInfo(it.key());
         if (format.has_value() && format->bitsPerColor >= 8) {
@@ -284,7 +284,7 @@ std::unique_ptr<EglGbmLayerSurface::Surface> EglGbmLayerSurface::createSurface(c
             return lhs.bitsPerPixel < rhs.bitsPerPixel;
         }
     };
-    const auto doTestFormats = [this, &size, &formats](const QVector<FormatInfo> &gbmFormats, MultiGpuImportMode importMode) -> std::unique_ptr<Surface> {
+    const auto doTestFormats = [this, &size, &formats](const QList<FormatInfo> &gbmFormats, MultiGpuImportMode importMode) -> std::unique_ptr<Surface> {
         for (const auto &format : gbmFormats) {
             if (m_formatOption == FormatOption::RequireAlpha && format.alphaBits == 0) {
                 continue;
@@ -296,7 +296,7 @@ std::unique_ptr<EglGbmLayerSurface::Surface> EglGbmLayerSurface::createSurface(c
         }
         return nullptr;
     };
-    const auto testFormats = [this, &sort, &doTestFormats](QVector<FormatInfo> &formats) -> std::unique_ptr<Surface> {
+    const auto testFormats = [this, &sort, &doTestFormats](QList<FormatInfo> &formats) -> std::unique_ptr<Surface> {
         std::sort(formats.begin(), formats.end(), sort);
         if (m_gpu == m_eglBackend->gpu()) {
             return doTestFormats(formats, MultiGpuImportMode::None);
@@ -328,9 +328,9 @@ std::unique_ptr<EglGbmLayerSurface::Surface> EglGbmLayerSurface::createSurface(c
     }
 }
 
-static QVector<uint64_t> filterModifiers(const QVector<uint64_t> &one, const QVector<uint64_t> &two)
+static QList<uint64_t> filterModifiers(const QList<uint64_t> &one, const QList<uint64_t> &two)
 {
-    QVector<uint64_t> ret = one;
+    QList<uint64_t> ret = one;
     ret.erase(std::remove_if(ret.begin(), ret.end(), [&two](uint64_t mod) {
                   return !two.contains(mod);
               }),
@@ -338,10 +338,10 @@ static QVector<uint64_t> filterModifiers(const QVector<uint64_t> &one, const QVe
     return ret;
 }
 
-std::unique_ptr<EglGbmLayerSurface::Surface> EglGbmLayerSurface::createSurface(const QSize &size, uint32_t format, const QVector<uint64_t> &modifiers, MultiGpuImportMode importMode) const
+std::unique_ptr<EglGbmLayerSurface::Surface> EglGbmLayerSurface::createSurface(const QSize &size, uint32_t format, const QList<uint64_t> &modifiers, MultiGpuImportMode importMode) const
 {
     const bool cpuCopy = importMode == MultiGpuImportMode::DumbBuffer || m_bufferTarget == BufferTarget::Dumb;
-    QVector<uint64_t> renderModifiers;
+    QList<uint64_t> renderModifiers;
     auto ret = std::make_unique<Surface>();
     if (importMode == MultiGpuImportMode::Egl) {
         ret->importContext = m_eglBackend->contextForGpu(m_gpu);
@@ -384,7 +384,7 @@ std::unique_ptr<EglGbmLayerSurface::Surface> EglGbmLayerSurface::createSurface(c
     return ret;
 }
 
-std::shared_ptr<EglSwapchain> EglGbmLayerSurface::createGbmSwapchain(DrmGpu *gpu, EglContext *context, const QSize &size, uint32_t format, const QVector<uint64_t> &modifiers, bool preferLinear) const
+std::shared_ptr<EglSwapchain> EglGbmLayerSurface::createGbmSwapchain(DrmGpu *gpu, EglContext *context, const QSize &size, uint32_t format, const QList<uint64_t> &modifiers, bool preferLinear) const
 {
     static bool modifiersEnvSet = false;
     static const bool modifiersEnv = qEnvironmentVariableIntValue("KWIN_DRM_USE_MODIFIERS", &modifiersEnvSet) != 0;
diff --git a/src/backends/drm/drm_egl_layer_surface.h b/src/backends/drm/drm_egl_layer_surface.h
index 3cb805cf46..d316e07719 100644
--- a/src/backends/drm/drm_egl_layer_surface.h
+++ b/src/backends/drm/drm_egl_layer_surface.h
@@ -53,15 +53,15 @@ public:
     EglGbmLayerSurface(DrmGpu *gpu, EglGbmBackend *eglBackend, BufferTarget target = BufferTarget::Normal, FormatOption formatOption = FormatOption::PreferAlpha);
     ~EglGbmLayerSurface();
 
-    std::optional<OutputLayerBeginFrameInfo> startRendering(const QSize &bufferSize, TextureTransforms transformation, const QMap<uint32_t, QVector<uint64_t>> &formats, const ColorDescription &colorDescription, const QVector3D &channelFactors, bool enableColormanagement);
+    std::optional<OutputLayerBeginFrameInfo> startRendering(const QSize &bufferSize, TextureTransforms transformation, const QMap<uint32_t, QList<uint64_t>> &formats, const ColorDescription &colorDescription, const QVector3D &channelFactors, bool enableColormanagement);
     bool endRendering(const QRegion &damagedRegion);
     std::chrono::nanoseconds queryRenderTime() const;
 
-    bool doesSurfaceFit(const QSize &size, const QMap<uint32_t, QVector<uint64_t>> &formats) const;
+    bool doesSurfaceFit(const QSize &size, const QMap<uint32_t, QList<uint64_t>> &formats) const;
     std::shared_ptr<GLTexture> texture() const;
     void destroyResources();
     EglGbmBackend *eglBackend() const;
-    std::shared_ptr<DrmFramebuffer> renderTestBuffer(const QSize &bufferSize, const QMap<uint32_t, QVector<uint64_t>> &formats);
+    std::shared_ptr<DrmFramebuffer> renderTestBuffer(const QSize &bufferSize, const QMap<uint32_t, QList<uint64_t>> &formats);
 
     std::shared_ptr<DrmFramebuffer> currentBuffer() const;
     const ColorDescription &colorDescription() const;
@@ -103,11 +103,11 @@ private:
         std::chrono::steady_clock::time_point renderStart;
         std::chrono::steady_clock::time_point renderEnd;
     };
-    bool checkSurface(const QSize &size, const QMap<uint32_t, QVector<uint64_t>> &formats);
-    bool doesSurfaceFit(Surface *surface, const QSize &size, const QMap<uint32_t, QVector<uint64_t>> &formats) const;
-    std::unique_ptr<Surface> createSurface(const QSize &size, const QMap<uint32_t, QVector<uint64_t>> &formats) const;
-    std::unique_ptr<Surface> createSurface(const QSize &size, uint32_t format, const QVector<uint64_t> &modifiers, MultiGpuImportMode importMode) const;
-    std::shared_ptr<EglSwapchain> createGbmSwapchain(DrmGpu *gpu, EglContext *context, const QSize &size, uint32_t format, const QVector<uint64_t> &modifiers, bool forceLinear) const;
+    bool checkSurface(const QSize &size, const QMap<uint32_t, QList<uint64_t>> &formats);
+    bool doesSurfaceFit(Surface *surface, const QSize &size, const QMap<uint32_t, QList<uint64_t>> &formats) const;
+    std::unique_ptr<Surface> createSurface(const QSize &size, const QMap<uint32_t, QList<uint64_t>> &formats) const;
+    std::unique_ptr<Surface> createSurface(const QSize &size, uint32_t format, const QList<uint64_t> &modifiers, MultiGpuImportMode importMode) const;
+    std::shared_ptr<EglSwapchain> createGbmSwapchain(DrmGpu *gpu, EglContext *context, const QSize &size, uint32_t format, const QList<uint64_t> &modifiers, bool forceLinear) const;
 
     std::shared_ptr<DrmFramebuffer> doRenderTestBuffer(Surface *surface) const;
     std::shared_ptr<DrmFramebuffer> importBuffer(Surface *surface, EglSwapchainSlot *source) const;
diff --git a/src/backends/drm/drm_gpu.cpp b/src/backends/drm/drm_gpu.cpp
index 8b52772b82..b83f5d7d21 100644
--- a/src/backends/drm/drm_gpu.cpp
+++ b/src/backends/drm/drm_gpu.cpp
@@ -180,11 +180,11 @@ void DrmGpu::initDrmResources()
         qCCritical(KWIN_DRM) << "drmModeGetResources for getting CRTCs failed on GPU" << m_devNode;
         return;
     }
-    QVector<DrmPlane *> assignedPlanes;
+    QList<DrmPlane *> assignedPlanes;
     for (int i = 0; i < resources->count_crtcs; ++i) {
         uint32_t crtcId = resources->crtcs[i];
-        QVector<DrmPlane *> primaryCandidates;
-        QVector<DrmPlane *> cursorCandidates;
+        QList<DrmPlane *> primaryCandidates;
+        QList<DrmPlane *> cursorCandidates;
         for (const auto &plane : m_planes) {
             if (plane->isCrtcSupported(i) && !assignedPlanes.contains(plane.get())) {
                 if (plane->type.enumValue() == DrmPlane::TypeIndex::Primary) {
@@ -198,7 +198,7 @@ void DrmGpu::initDrmResources()
             qCWarning(KWIN_DRM) << "Could not find a suitable primary plane for crtc" << resources->crtcs[i];
             continue;
         }
-        const auto findBestPlane = [crtcId](const QVector<DrmPlane *> &list) {
+        const auto findBestPlane = [crtcId](const QList<DrmPlane *> &list) {
             // if the plane is already used with this crtc, prefer it
             const auto connected = std::find_if(list.begin(), list.end(), [crtcId](DrmPlane *plane) {
                 return plane->crtcId.value() == crtcId;
@@ -261,8 +261,8 @@ bool DrmGpu::updateOutputs()
     }
 
     // check for added and removed connectors
-    QVector<DrmConnector *> existing;
-    QVector<DrmOutput *> addedOutputs;
+    QList<DrmConnector *> existing;
+    QList<DrmOutput *> addedOutputs;
     for (int i = 0; i < resources->count_connectors; ++i) {
         const uint32_t currentConnector = resources->connectors[i];
         const auto it = std::find_if(m_connectors.begin(), m_connectors.end(), [currentConnector](const auto &connector) {
@@ -367,7 +367,7 @@ void DrmGpu::removeOutputs()
     }
 }
 
-DrmPipeline::Error DrmGpu::checkCrtcAssignment(QVector<DrmConnector *> connectors, const QVector<DrmCrtc *> &crtcs)
+DrmPipeline::Error DrmGpu::checkCrtcAssignment(QList<DrmConnector *> connectors, const QList<DrmCrtc *> &crtcs)
 {
     if (connectors.isEmpty() || crtcs.isEmpty()) {
         if (m_pipelines.isEmpty()) {
@@ -426,8 +426,8 @@ DrmPipeline::Error DrmGpu::checkCrtcAssignment(QVector<DrmConnector *> connector
 
 DrmPipeline::Error DrmGpu::testPendingConfiguration()
 {
-    QVector<DrmConnector *> connectors;
-    QVector<DrmCrtc *> crtcs;
+    QList<DrmConnector *> connectors;
+    QList<DrmCrtc *> crtcs;
     // only change resources that aren't currently leased away
     for (const auto &conn : m_connectors) {
         bool isLeased = std::any_of(m_drmOutputs.cbegin(), m_drmOutputs.cend(), [&conn](const auto output) {
@@ -456,7 +456,7 @@ DrmPipeline::Error DrmGpu::testPendingConfiguration()
 
 DrmPipeline::Error DrmGpu::testPipelines()
 {
-    QVector<DrmPipeline *> inactivePipelines;
+    QList<DrmPipeline *> inactivePipelines;
     std::copy_if(m_pipelines.constBegin(), m_pipelines.constEnd(), std::back_inserter(inactivePipelines), [](const auto pipeline) {
         return pipeline->enabled() && !pipeline->active();
     });
@@ -582,7 +582,7 @@ DrmBackend *DrmGpu::platform() const
     return m_platform;
 }
 
-const QVector<DrmPipeline *> DrmGpu::pipelines() const
+const QList<DrmPipeline *> DrmGpu::pipelines() const
 {
     return m_pipelines;
 }
@@ -603,9 +603,9 @@ void DrmGpu::removeVirtualOutput(DrmVirtualOutput *output)
     }
 }
 
-std::unique_ptr<DrmLease> DrmGpu::leaseOutputs(const QVector<DrmOutput *> &outputs)
+std::unique_ptr<DrmLease> DrmGpu::leaseOutputs(const QList<DrmOutput *> &outputs)
 {
-    QVector<uint32_t> objects;
+    QList<uint32_t> objects;
     for (DrmOutput *output : outputs) {
         if (output->lease() || !output->addLeaseObjects(objects)) {
             return nullptr;
@@ -630,12 +630,12 @@ std::unique_ptr<DrmLease> DrmGpu::leaseOutputs(const QVector<DrmOutput *> &outpu
     }
 }
 
-QVector<DrmVirtualOutput *> DrmGpu::virtualOutputs() const
+QList<DrmVirtualOutput *> DrmGpu::virtualOutputs() const
 {
     return m_virtualOutputs;
 }
 
-QVector<DrmOutput *> DrmGpu::drmOutputs() const
+QList<DrmOutput *> DrmGpu::drmOutputs() const
 {
     return m_drmOutputs;
 }
@@ -773,12 +773,12 @@ bool DrmGpu::maybeModeset()
     }
 }
 
-QVector<DrmObject *> DrmGpu::unusedObjects() const
+QList<DrmObject *> DrmGpu::unusedObjects() const
 {
     if (!m_atomicModeSetting) {
         return {};
     }
-    QVector<DrmObject *> ret = m_allObjects;
+    QList<DrmObject *> ret = m_allObjects;
     for (const auto &pipeline : m_pipelines) {
         ret.removeOne(pipeline->connector());
         if (pipeline->crtc()) {
@@ -906,7 +906,7 @@ std::shared_ptr<DrmFramebuffer> DrmGpu::importBuffer(GraphicsBuffer *buffer)
     return std::make_shared<DrmFramebuffer>(this, framebufferId, buffer);
 }
 
-DrmLease::DrmLease(DrmGpu *gpu, FileDescriptor &&fd, uint32_t lesseeId, const QVector<DrmOutput *> &outputs)
+DrmLease::DrmLease(DrmGpu *gpu, FileDescriptor &&fd, uint32_t lesseeId, const QList<DrmOutput *> &outputs)
     : m_gpu(gpu)
     , m_fd(std::move(fd))
     , m_lesseeId(lesseeId)
diff --git a/src/backends/drm/drm_gpu.h b/src/backends/drm/drm_gpu.h
index 2e89d5d929..27e546eea5 100644
--- a/src/backends/drm/drm_gpu.h
+++ b/src/backends/drm/drm_gpu.h
@@ -11,10 +11,10 @@
 #include "drm_pipeline.h"
 #include "utils/filedescriptor.h"
 
+#include <QList>
 #include <QPointer>
 #include <QSize>
 #include <QSocketNotifier>
-#include <QVector>
 #include <qobject.h>
 
 #include <epoxy/egl.h>
@@ -43,7 +43,7 @@ class DrmLease : public QObject
 {
     Q_OBJECT
 public:
-    DrmLease(DrmGpu *gpu, FileDescriptor &&fd, uint32_t lesseeId, const QVector<DrmOutput *> &outputs);
+    DrmLease(DrmGpu *gpu, FileDescriptor &&fd, uint32_t lesseeId, const QList<DrmOutput *> &outputs);
     ~DrmLease();
 
     FileDescriptor &fd();
@@ -56,7 +56,7 @@ private:
     DrmGpu *const m_gpu;
     FileDescriptor m_fd;
     const uint32_t m_lesseeId;
-    const QVector<DrmOutput *> m_outputs;
+    const QList<DrmOutput *> m_outputs;
 };
 
 class DrmGpu : public QObject
@@ -89,9 +89,9 @@ public:
     clockid_t presentationClock() const;
     QSize cursorSize() const;
 
-    QVector<DrmVirtualOutput *> virtualOutputs() const;
-    QVector<DrmOutput *> drmOutputs() const;
-    const QVector<DrmPipeline *> pipelines() const;
+    QList<DrmVirtualOutput *> virtualOutputs() const;
+    QList<DrmOutput *> drmOutputs() const;
+    const QList<DrmPipeline *> pipelines() const;
 
     void setEglDisplay(std::unique_ptr<EglDisplay> &&display);
 
@@ -111,7 +111,7 @@ public:
     void recreateSurfaces();
 
     FileDescriptor createNonMasterFd() const;
-    std::unique_ptr<DrmLease> leaseOutputs(const QVector<DrmOutput *> &outputs);
+    std::unique_ptr<DrmLease> leaseOutputs(const QList<DrmOutput *> &outputs);
     void waitIdle();
 
 Q_SIGNALS:
@@ -125,9 +125,9 @@ private:
     void removeOutput(DrmOutput *output);
     void initDrmResources();
 
-    DrmPipeline::Error checkCrtcAssignment(QVector<DrmConnector *> connectors, const QVector<DrmCrtc *> &crtcs);
+    DrmPipeline::Error checkCrtcAssignment(QList<DrmConnector *> connectors, const QList<DrmCrtc *> &crtcs);
     DrmPipeline::Error testPipelines();
-    QVector<DrmObject *> unusedObjects() const;
+    QList<DrmObject *> unusedObjects() const;
 
     static void pageFlipHandler(int fd, unsigned int sequence, unsigned int sec, unsigned int usec, unsigned int crtc_id, void *user_data);
 
@@ -151,11 +151,11 @@ private:
     std::vector<std::unique_ptr<DrmPlane>> m_planes;
     std::vector<std::unique_ptr<DrmCrtc>> m_crtcs;
     std::vector<std::shared_ptr<DrmConnector>> m_connectors;
-    QVector<DrmObject *> m_allObjects;
-    QVector<DrmPipeline *> m_pipelines;
+    QList<DrmObject *> m_allObjects;
+    QList<DrmPipeline *> m_pipelines;
 
-    QVector<DrmOutput *> m_drmOutputs;
-    QVector<DrmVirtualOutput *> m_virtualOutputs;
+    QList<DrmOutput *> m_drmOutputs;
+    QList<DrmVirtualOutput *> m_virtualOutputs;
 
     std::unique_ptr<QSocketNotifier> m_socketNotifier;
     QSize m_cursorSize;
diff --git a/src/backends/drm/drm_object.h b/src/backends/drm/drm_object.h
index 1ad0ea9de6..3d3e073e36 100644
--- a/src/backends/drm/drm_object.h
+++ b/src/backends/drm/drm_object.h
@@ -9,8 +9,8 @@
 #pragma once
 
 #include <QByteArray>
+#include <QList>
 #include <QMap>
-#include <QVector>
 
 #include <vector>
 
diff --git a/src/backends/drm/drm_output.cpp b/src/backends/drm/drm_output.cpp
index df1e428365..b32f0d328b 100644
--- a/src/backends/drm/drm_output.cpp
+++ b/src/backends/drm/drm_output.cpp
@@ -105,7 +105,7 @@ DrmOutput::~DrmOutput()
     m_pipeline->setOutput(nullptr);
 }
 
-bool DrmOutput::addLeaseObjects(QVector<uint32_t> &objectList)
+bool DrmOutput::addLeaseObjects(QList<uint32_t> &objectList)
 {
     if (!m_pipeline->crtc()) {
         qCWarning(KWIN_DRM) << "Can't lease connector: No suitable crtc available";
diff --git a/src/backends/drm/drm_output.h b/src/backends/drm/drm_output.h
index 5f18125fde..e803aa929a 100644
--- a/src/backends/drm/drm_output.h
+++ b/src/backends/drm/drm_output.h
@@ -12,12 +12,12 @@
 #include "drm_object.h"
 #include "drm_plane.h"
 
+#include <QList>
 #include <QObject>
 #include <QPoint>
 #include <QPointer>
 #include <QSize>
 #include <QTimer>
-#include <QVector>
 #include <chrono>
 #include <xf86drmMode.h>
 
@@ -54,7 +54,7 @@ public:
     bool updateCursorLayer() override;
 
     DrmLease *lease() const;
-    bool addLeaseObjects(QVector<uint32_t> &objectList);
+    bool addLeaseObjects(QList<uint32_t> &objectList);
     void leased(DrmLease *lease);
     void leaseEnded();
 
diff --git a/src/backends/drm/drm_pipeline.cpp b/src/backends/drm/drm_pipeline.cpp
index 9316f996c7..dedce9522e 100644
--- a/src/backends/drm/drm_pipeline.cpp
+++ b/src/backends/drm/drm_pipeline.cpp
@@ -33,9 +33,9 @@ using namespace std::literals;
 namespace KWin
 {
 
-static const QVector<uint64_t> implicitModifier = {DRM_FORMAT_MOD_INVALID};
-static const QMap<uint32_t, QVector<uint64_t>> legacyFormats = {{DRM_FORMAT_XRGB8888, implicitModifier}};
-static const QMap<uint32_t, QVector<uint64_t>> legacyCursorFormats = {{DRM_FORMAT_ARGB8888, implicitModifier}};
+static const QList<uint64_t> implicitModifier = {DRM_FORMAT_MOD_INVALID};
+static const QMap<uint32_t, QList<uint64_t>> legacyFormats = {{DRM_FORMAT_XRGB8888, implicitModifier}};
+static const QMap<uint32_t, QList<uint64_t>> legacyCursorFormats = {{DRM_FORMAT_ARGB8888, implicitModifier}};
 
 DrmPipeline::DrmPipeline(DrmConnector *conn)
     : m_connector(conn)
@@ -79,7 +79,7 @@ DrmPipeline::Error DrmPipeline::present()
     Q_ASSERT(m_pending.crtc);
     if (gpu()->atomicModeSetting()) {
         // test the full state, to take pending commits into account
-        auto fullState = std::make_unique<DrmAtomicCommit>(QVector<DrmPipeline *>{this});
+        auto fullState = std::make_unique<DrmAtomicCommit>(QList<DrmPipeline *>{this});
         if (Error err = prepareAtomicPresentation(fullState.get()); err != Error::None) {
             return err;
         }
@@ -90,7 +90,7 @@ DrmPipeline::Error DrmPipeline::present()
             return errnoToError();
         }
         // only give the actual state update to the commit thread, so that it can potentially reorder the commits
-        auto primaryPlaneUpdate = std::make_unique<DrmAtomicCommit>(QVector<DrmPipeline *>{this});
+        auto primaryPlaneUpdate = std::make_unique<DrmAtomicCommit>(QList<DrmPipeline *>{this});
         if (Error err = prepareAtomicPresentation(primaryPlaneUpdate.get()); err != Error::None) {
             return err;
         }
@@ -111,7 +111,7 @@ bool DrmPipeline::maybeModeset()
     return gpu()->maybeModeset();
 }
 
-DrmPipeline::Error DrmPipeline::commitPipelines(const QVector<DrmPipeline *> &pipelines, CommitMode mode, const QVector<DrmObject *> &unusedObjects)
+DrmPipeline::Error DrmPipeline::commitPipelines(const QList<DrmPipeline *> &pipelines, CommitMode mode, const QList<DrmObject *> &unusedObjects)
 {
     Q_ASSERT(!pipelines.isEmpty());
     if (pipelines[0]->gpu()->atomicModeSetting()) {
@@ -121,7 +121,7 @@ DrmPipeline::Error DrmPipeline::commitPipelines(const QVector<DrmPipeline *> &pi
     }
 }
 
-DrmPipeline::Error DrmPipeline::commitPipelinesAtomic(const QVector<DrmPipeline *> &pipelines, CommitMode mode, const QVector<DrmObject *> &unusedObjects)
+DrmPipeline::Error DrmPipeline::commitPipelinesAtomic(const QList<DrmPipeline *> &pipelines, CommitMode mode, const QList<DrmObject *> &unusedObjects)
 {
     auto commit = std::make_unique<DrmAtomicCommit>(pipelines);
     if (mode == CommitMode::Test) {
@@ -376,7 +376,7 @@ bool DrmPipeline::updateCursor()
             return false;
         }
         // test the full state, to take pending commits into account
-        auto fullState = std::make_unique<DrmAtomicCommit>(QVector<DrmPipeline *>{this});
+        auto fullState = std::make_unique<DrmAtomicCommit>(QList<DrmPipeline *>{this});
         if (prepareAtomicPresentation(fullState.get()) != Error::None) {
             return false;
         }
@@ -385,7 +385,7 @@ bool DrmPipeline::updateCursor()
             return false;
         }
         // only give the actual state update to the commit thread, so that it can potentially reorder the commits
-        auto cursorOnly = std::make_unique<DrmAtomicCommit>(QVector<DrmPipeline *>{this});
+        auto cursorOnly = std::make_unique<DrmAtomicCommit>(QList<DrmPipeline *>{this});
         prepareAtomicCursor(cursorOnly.get());
         cursorOnly->setCursorOnly(true);
         m_commitThread->addCommit(std::move(cursorOnly));
@@ -434,12 +434,12 @@ DrmOutput *DrmPipeline::output() const
     return m_output;
 }
 
-QMap<uint32_t, QVector<uint64_t>> DrmPipeline::formats() const
+QMap<uint32_t, QList<uint64_t>> DrmPipeline::formats() const
 {
     return m_pending.formats;
 }
 
-QMap<uint32_t, QVector<uint64_t>> DrmPipeline::cursorFormats() const
+QMap<uint32_t, QList<uint64_t>> DrmPipeline::cursorFormats() const
 {
     if (m_pending.crtc && m_pending.crtc->cursorPlane()) {
         return m_pending.crtc->cursorPlane()->formats();
@@ -502,7 +502,7 @@ DrmGammaRamp::DrmGammaRamp(DrmCrtc *crtc, const std::shared_ptr<ColorTransformat
     : m_lut(transformation, crtc->gammaRampSize())
 {
     if (crtc->gpu()->atomicModeSetting()) {
-        QVector<drm_color_lut> atomicLut(m_lut.size());
+        QList<drm_color_lut> atomicLut(m_lut.size());
         for (uint32_t i = 0; i < m_lut.size(); i++) {
             atomicLut[i].red = m_lut.red()[i];
             atomicLut[i].green = m_lut.green()[i];
diff --git a/src/backends/drm/drm_pipeline.h b/src/backends/drm/drm_pipeline.h
index cbaceb6ec5..4811398f96 100644
--- a/src/backends/drm/drm_pipeline.h
+++ b/src/backends/drm/drm_pipeline.h
@@ -9,9 +9,9 @@
 
 #pragma once
 
+#include <QList>
 #include <QPoint>
 #include <QSize>
-#include <QVector>
 
 #include <chrono>
 #include <xf86drmMode.h>
@@ -93,8 +93,8 @@ public:
     bool modesetPresentPending() const;
     void resetModesetPresentPending();
 
-    QMap<uint32_t, QVector<uint64_t>> formats() const;
-    QMap<uint32_t, QVector<uint64_t>> cursorFormats() const;
+    QMap<uint32_t, QList<uint64_t>> formats() const;
+    QMap<uint32_t, QList<uint64_t>> cursorFormats() const;
     bool pruneModifier();
 
     void setOutput(DrmOutput *output);
@@ -139,7 +139,7 @@ public:
         CommitModeset
     };
     Q_ENUM(CommitMode)
-    static Error commitPipelines(const QVector<DrmPipeline *> &pipelines, CommitMode mode, const QVector<DrmObject *> &unusedObjects = {});
+    static Error commitPipelines(const QList<DrmPipeline *> &pipelines, CommitMode mode, const QList<DrmObject *> &unusedObjects = {});
 
 private:
     bool isBufferForDirectScanout() const;
@@ -153,7 +153,7 @@ private:
     Error legacyModeset();
     Error applyPendingChangesLegacy();
     bool setCursorLegacy();
-    static Error commitPipelinesLegacy(const QVector<DrmPipeline *> &pipelines, CommitMode mode);
+    static Error commitPipelinesLegacy(const QList<DrmPipeline *> &pipelines, CommitMode mode);
 
     // atomic modesetting only
     void atomicCommitSuccessful();
@@ -161,7 +161,7 @@ private:
     Error prepareAtomicPresentation(DrmAtomicCommit *commit);
     void prepareAtomicCursor(DrmAtomicCommit *commit);
     void prepareAtomicDisable(DrmAtomicCommit *commit);
-    static Error commitPipelinesAtomic(const QVector<DrmPipeline *> &pipelines, CommitMode mode, const QVector<DrmObject *> &unusedObjects);
+    static Error commitPipelinesAtomic(const QList<DrmPipeline *> &pipelines, CommitMode mode, const QList<DrmObject *> &unusedObjects);
 
     DrmOutput *m_output = nullptr;
     DrmConnector *m_connector = nullptr;
@@ -172,7 +172,7 @@ private:
     struct State
     {
         DrmCrtc *crtc = nullptr;
-        QMap<uint32_t, QVector<uint64_t>> formats;
+        QMap<uint32_t, QList<uint64_t>> formats;
         bool active = true; // whether or not the pipeline should be currently used
         bool enabled = true; // whether or not the pipeline needs a crtc
         bool needsModeset = false;
diff --git a/src/backends/drm/drm_pipeline_legacy.cpp b/src/backends/drm/drm_pipeline_legacy.cpp
index a6c0dc6e13..47dc9b15d7 100644
--- a/src/backends/drm/drm_pipeline_legacy.cpp
+++ b/src/backends/drm/drm_pipeline_legacy.cpp
@@ -65,7 +65,7 @@ DrmPipeline::Error DrmPipeline::legacyModeset()
     return Error::None;
 }
 
-DrmPipeline::Error DrmPipeline::commitPipelinesLegacy(const QVector<DrmPipeline *> &pipelines, CommitMode mode)
+DrmPipeline::Error DrmPipeline::commitPipelinesLegacy(const QList<DrmPipeline *> &pipelines, CommitMode mode)
 {
     Error err = Error::None;
     for (const auto &pipeline : pipelines) {
diff --git a/src/backends/drm/drm_plane.cpp b/src/backends/drm/drm_plane.cpp
index 4e211a8562..1610121bca 100644
--- a/src/backends/drm/drm_plane.cpp
+++ b/src/backends/drm/drm_plane.cpp
@@ -96,7 +96,7 @@ bool DrmPlane::updateProperties()
         }
     } else {
         // if we don't have modifier support, assume the cursor needs a linear buffer
-        const QVector<uint64_t> modifiers = {type.enumValue() == TypeIndex::Cursor ? DRM_FORMAT_MOD_LINEAR : DRM_FORMAT_MOD_INVALID};
+        const QList<uint64_t> modifiers = {type.enumValue() == TypeIndex::Cursor ? DRM_FORMAT_MOD_LINEAR : DRM_FORMAT_MOD_INVALID};
         for (uint32_t i = 0; i < p->count_formats; i++) {
             m_supportedFormats.insert(p->formats[i], modifiers);
         }
@@ -127,7 +127,7 @@ bool DrmPlane::isCrtcSupported(int pipeIndex) const
     return (m_possibleCrtcs & (1 << pipeIndex));
 }
 
-QMap<uint32_t, QVector<uint64_t>> DrmPlane::formats() const
+QMap<uint32_t, QList<uint64_t>> DrmPlane::formats() const
 {
     return m_supportedFormats;
 }
diff --git a/src/backends/drm/drm_plane.h b/src/backends/drm/drm_plane.h
index 6daf1dcf3e..975358d70f 100644
--- a/src/backends/drm/drm_plane.h
+++ b/src/backends/drm/drm_plane.h
@@ -33,7 +33,7 @@ public:
     void disable(DrmAtomicCommit *commit) override;
 
     bool isCrtcSupported(int pipeIndex) const;
-    QMap<uint32_t, QVector<uint64_t>> formats() const;
+    QMap<uint32_t, QList<uint64_t>> formats() const;
 
     std::shared_ptr<DrmFramebuffer> currentBuffer() const;
     void setCurrentBuffer(const std::shared_ptr<DrmFramebuffer> &b);
@@ -83,7 +83,7 @@ public:
 private:
     std::shared_ptr<DrmFramebuffer> m_current;
 
-    QMap<uint32_t, QVector<uint64_t>> m_supportedFormats;
+    QMap<uint32_t, QList<uint64_t>> m_supportedFormats;
     uint32_t m_possibleCrtcs;
 };
 
diff --git a/src/backends/drm/drm_property.cpp b/src/backends/drm/drm_property.cpp
index 24f119f03d..f9ae9baf1b 100644
--- a/src/backends/drm/drm_property.cpp
+++ b/src/backends/drm/drm_property.cpp
@@ -17,7 +17,7 @@
 namespace KWin
 {
 
-DrmProperty::DrmProperty(DrmObject *obj, const QByteArray &name, const QVector<QByteArray> &enumNames)
+DrmProperty::DrmProperty(DrmObject *obj, const QByteArray &name, const QList<QByteArray> &enumNames)
     : m_obj(obj)
     , m_propName(name)
     , m_enumNames(enumNames)
diff --git a/src/backends/drm/drm_property.h b/src/backends/drm/drm_property.h
index ae874cc4bc..72b3b4aaaa 100644
--- a/src/backends/drm/drm_property.h
+++ b/src/backends/drm/drm_property.h
@@ -13,8 +13,8 @@
 #include "drm_logging.h"
 
 #include <QByteArray>
+#include <QList>
 #include <QMap>
-#include <QVector>
 
 #include <xf86drmMode.h>
 
@@ -27,7 +27,7 @@ class DrmPropertyList;
 class DrmProperty
 {
 public:
-    DrmProperty(DrmObject *obj, const QByteArray &name, const QVector<QByteArray> &enumNames = {});
+    DrmProperty(DrmObject *obj, const QByteArray &name, const QList<QByteArray> &enumNames = {});
 
     const QByteArray &name() const;
     DrmObject *drmObject() const;
@@ -48,7 +48,7 @@ public:
 protected:
     DrmObject *const m_obj;
     const QByteArray m_propName;
-    const QVector<QByteArray> m_enumNames;
+    const QList<QByteArray> m_enumNames;
 
     uint32_t m_propId = 0;
     // the last known value from the kernel
@@ -69,7 +69,7 @@ template<typename Enum>
 class DrmEnumProperty : public DrmProperty
 {
 public:
-    DrmEnumProperty(DrmObject *obj, const QByteArray &name, const QVector<QByteArray> &enumNames)
+    DrmEnumProperty(DrmObject *obj, const QByteArray &name, const QList<QByteArray> &enumNames)
         : DrmProperty(obj, name, enumNames)
     {
     }
diff --git a/src/backends/drm/drm_qpainter_backend.h b/src/backends/drm/drm_qpainter_backend.h
index 727d43a53b..28380dbe04 100644
--- a/src/backends/drm/drm_qpainter_backend.h
+++ b/src/backends/drm/drm_qpainter_backend.h
@@ -10,8 +10,8 @@
 #include "drm_render_backend.h"
 #include "platformsupport/scenes/qpainter/qpainterbackend.h"
 
+#include <QList>
 #include <QObject>
-#include <QVector>
 
 namespace KWin
 {
diff --git a/src/backends/drm/drm_virtual_egl_layer.cpp b/src/backends/drm/drm_virtual_egl_layer.cpp
index e1408e25d2..d948965942 100644
--- a/src/backends/drm/drm_virtual_egl_layer.cpp
+++ b/src/backends/drm/drm_virtual_egl_layer.cpp
@@ -117,7 +117,7 @@ std::shared_ptr<EglSwapchain> VirtualEglGbmLayer::createGbmSwapchain() const
                 }
             }
 
-            static const QVector<uint64_t> implicitModifier{DRM_FORMAT_MOD_INVALID};
+            static const QList<uint64_t> implicitModifier{DRM_FORMAT_MOD_INVALID};
             if (auto swapchain = EglSwapchain::create(m_eglBackend->gpu()->graphicsBufferAllocator(), m_eglBackend->contextObject(), size, format, implicitModifier)) {
                 return swapchain;
             }
diff --git a/src/backends/libinput/connection.cpp b/src/backends/libinput/connection.cpp
index 5ea67f4663..96ee0c3ad6 100644
--- a/src/backends/libinput/connection.cpp
+++ b/src/backends/libinput/connection.cpp
@@ -226,7 +226,7 @@ KWin::TabletToolId createTabletId(libinput_tablet_tool *tool, Device *dev)
         toolType = InputRedirection::Totem;
         break;
     }
-    QVector<InputRedirection::Capability> capabilities;
+    QList<InputRedirection::Capability> capabilities;
     if (libinput_tablet_tool_has_pressure(tool)) {
         capabilities << InputRedirection::Pressure;
     }
@@ -586,7 +586,7 @@ void Connection::applyScreenToDevice(Device *device)
     }
 
     Output *deviceOutput = nullptr;
-    const QVector<Output *> outputs = kwinApp()->outputBackend()->outputs();
+    const QList<Output *> outputs = kwinApp()->outputBackend()->outputs();
 
     // let's try to find a screen for it
     if (!device->outputName().isEmpty()) {
diff --git a/src/backends/libinput/connection.h b/src/backends/libinput/connection.h
index c687ec24dd..a9baf492bc 100644
--- a/src/backends/libinput/connection.h
+++ b/src/backends/libinput/connection.h
@@ -12,12 +12,12 @@
 
 #include <KSharedConfig>
 
+#include <QList>
 #include <QObject>
 #include <QPointer>
 #include <QRecursiveMutex>
 #include <QSize>
 #include <QStringList>
-#include <QVector>
 #include <deque>
 
 class QSocketNotifier;
@@ -76,7 +76,7 @@ private:
     std::unique_ptr<QSocketNotifier> m_notifier;
     QRecursiveMutex m_mutex;
     std::deque<std::unique_ptr<Event>> m_eventQueue;
-    QVector<Device *> m_devices;
+    QList<Device *> m_devices;
     KSharedConfigPtr m_config;
     std::unique_ptr<ConnectionAdaptor> m_connectionAdaptor;
     std::unique_ptr<Context> m_input;
diff --git a/src/backends/libinput/device.h b/src/backends/libinput/device.h
index d3634302e7..21c8bdec27 100644
--- a/src/backends/libinput/device.h
+++ b/src/backends/libinput/device.h
@@ -14,11 +14,11 @@
 
 #include <KConfigGroup>
 
+#include <QList>
 #include <QMatrix4x4>
 #include <QObject>
 #include <QPointer>
 #include <QSizeF>
-#include <QVector>
 
 struct libinput_device;
 
diff --git a/src/backends/libinput/events.cpp b/src/backends/libinput/events.cpp
index bd8facd3d9..c8a71970ee 100644
--- a/src/backends/libinput/events.cpp
+++ b/src/backends/libinput/events.cpp
@@ -186,9 +186,9 @@ InputRedirection::PointerButtonState PointerEvent::buttonState() const
     }
 }
 
-QVector<InputRedirection::PointerAxis> PointerEvent::axis() const
+QList<InputRedirection::PointerAxis> PointerEvent::axis() const
 {
-    QVector<InputRedirection::PointerAxis> a;
+    QList<InputRedirection::PointerAxis> a;
     if (libinput_event_pointer_has_axis(m_pointerEvent, LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL)) {
         a << InputRedirection::PointerAxisHorizontal;
     }
diff --git a/src/backends/libinput/events.h b/src/backends/libinput/events.h
index 1fc56d8f33..443bc5e487 100644
--- a/src/backends/libinput/events.h
+++ b/src/backends/libinput/events.h
@@ -84,7 +84,7 @@ public:
     uint32_t button() const;
     InputRedirection::PointerButtonState buttonState() const;
     std::chrono::microseconds time() const;
-    QVector<InputRedirection::PointerAxis> axis() const;
+    QList<InputRedirection::PointerAxis> axis() const;
     qreal scrollValue(InputRedirection::PointerAxis a) const;
     qint32 scrollValueV120(InputRedirection::PointerAxis axis) const;
 
diff --git a/src/backends/virtual/virtual_backend.cpp b/src/backends/virtual/virtual_backend.cpp
index 43a5fbb5d9..cab58170e7 100644
--- a/src/backends/virtual/virtual_backend.cpp
+++ b/src/backends/virtual/virtual_backend.cpp
@@ -26,7 +26,7 @@ static FileDescriptor findRenderDevice()
         return FileDescriptor{};
     }
 
-    QVector<drmDevice *> devices(deviceCount);
+    QList<drmDevice *> devices(deviceCount);
     if (drmGetDevices2(0, devices.data(), devices.size()) < 0) {
         return FileDescriptor{};
     }
@@ -76,9 +76,9 @@ bool VirtualBackend::initialize()
     return true;
 }
 
-QVector<CompositingType> VirtualBackend::supportedCompositors() const
+QList<CompositingType> VirtualBackend::supportedCompositors() const
 {
-    QVector<CompositingType> compositingTypes;
+    QList<CompositingType> compositingTypes;
     if (m_gbmDevice) {
         compositingTypes.append(OpenGLCompositing);
     }
@@ -123,9 +123,9 @@ Output *VirtualBackend::addOutput(const OutputInfo &info)
     return output;
 }
 
-void VirtualBackend::setVirtualOutputs(const QVector<OutputInfo> &infos)
+void VirtualBackend::setVirtualOutputs(const QList<OutputInfo> &infos)
 {
-    const QVector<VirtualOutput *> removed = m_outputs;
+    const QList<VirtualOutput *> removed = m_outputs;
 
     for (const auto &info : infos) {
         createOutput(info);
diff --git a/src/backends/virtual/virtual_backend.h b/src/backends/virtual/virtual_backend.h
index f750bd8971..4150b9fe9c 100644
--- a/src/backends/virtual/virtual_backend.h
+++ b/src/backends/virtual/virtual_backend.h
@@ -40,11 +40,11 @@ public:
         bool internal = false;
     };
     Output *addOutput(const OutputInfo &info);
-    void setVirtualOutputs(const QVector<OutputInfo> &infos);
+    void setVirtualOutputs(const QList<OutputInfo> &infos);
 
     Outputs outputs() const override;
 
-    QVector<CompositingType> supportedCompositors() const override;
+    QList<CompositingType> supportedCompositors() const override;
 
     void setEglDisplay(std::unique_ptr<EglDisplay> &&display);
     EglDisplay *sceneEglDisplayObject() const override;
@@ -57,7 +57,7 @@ Q_SIGNALS:
 private:
     VirtualOutput *createOutput(const OutputInfo &info);
 
-    QVector<VirtualOutput *> m_outputs;
+    QList<VirtualOutput *> m_outputs;
     std::unique_ptr<EglDisplay> m_display;
     FileDescriptor m_drmFileDescriptor;
     gbm_device *m_gbmDevice = nullptr;
diff --git a/src/backends/virtual/virtual_qpainter_backend.h b/src/backends/virtual/virtual_qpainter_backend.h
index 1f3f45a706..52fdf6ba20 100644
--- a/src/backends/virtual/virtual_qpainter_backend.h
+++ b/src/backends/virtual/virtual_qpainter_backend.h
@@ -11,9 +11,9 @@
 #include "core/outputlayer.h"
 #include "platformsupport/scenes/qpainter/qpainterbackend.h"
 
+#include <QList>
 #include <QMap>
 #include <QObject>
-#include <QVector>
 #include <chrono>
 #include <memory>
 
diff --git a/src/backends/wayland/wayland_backend.cpp b/src/backends/wayland/wayland_backend.cpp
index dedbb21cb8..9b2f3fe442 100644
--- a/src/backends/wayland/wayland_backend.cpp
+++ b/src/backends/wayland/wayland_backend.cpp
@@ -562,9 +562,9 @@ void WaylandBackend::togglePointerLock()
     m_pointerLockRequested = !m_pointerLockRequested;
 }
 
-QVector<CompositingType> WaylandBackend::supportedCompositors() const
+QList<CompositingType> WaylandBackend::supportedCompositors() const
 {
-    QVector<CompositingType> ret;
+    QList<CompositingType> ret;
     if (m_display->linuxDmabuf() && m_gbmDevice) {
         ret.append(OpenGLCompositing);
     }
diff --git a/src/backends/wayland/wayland_backend.h b/src/backends/wayland/wayland_backend.h
index bec23595ac..6e11f1631b 100644
--- a/src/backends/wayland/wayland_backend.h
+++ b/src/backends/wayland/wayland_backend.h
@@ -227,11 +227,11 @@ public:
     bool supportsPointerLock();
     void togglePointerLock();
 
-    QVector<CompositingType> supportedCompositors() const override;
+    QList<CompositingType> supportedCompositors() const override;
 
     WaylandOutput *findOutput(KWayland::Client::Surface *nativeSurface) const;
     Outputs outputs() const override;
-    QVector<WaylandOutput *> waylandOutputs() const
+    QList<WaylandOutput *> waylandOutputs() const
     {
         return m_outputs;
     }
@@ -265,7 +265,7 @@ private:
     std::unique_ptr<WaylandDisplay> m_display;
     std::unique_ptr<WaylandSeat> m_seat;
     WaylandEglBackend *m_eglBackend = nullptr;
-    QVector<WaylandOutput *> m_outputs;
+    QList<WaylandOutput *> m_outputs;
     bool m_pointerLockRequested = false;
     FileDescriptor m_drmFileDescriptor;
     gbm_device *m_gbmDevice = nullptr;
diff --git a/src/backends/wayland/wayland_display.cpp b/src/backends/wayland/wayland_display.cpp
index d773f045ed..b26077ffc9 100644
--- a/src/backends/wayland/wayland_display.cpp
+++ b/src/backends/wayland/wayland_display.cpp
@@ -187,7 +187,7 @@ public:
     dev_t mainDeviceId = 0;
     dev_t trancheDeviceId = 0;
     MemoryMap formatTable;
-    QHash<uint32_t, QVector<uint64_t>> formats;
+    QHash<uint32_t, QList<uint64_t>> formats;
 
 private:
     static void done(void *data, zwp_linux_dmabuf_feedback_v1 *zwp_linux_dmabuf_feedback_v1)
@@ -299,7 +299,7 @@ QByteArray WaylandLinuxDmabufV1::mainDevice() const
     return m_defaultFeedback->mainDevice;
 }
 
-QHash<uint32_t, QVector<uint64_t>> WaylandLinuxDmabufV1::formats() const
+QHash<uint32_t, QList<uint64_t>> WaylandLinuxDmabufV1::formats() const
 {
     return m_defaultFeedback->formats;
 }
diff --git a/src/backends/wayland/wayland_display.h b/src/backends/wayland/wayland_display.h
index 83b08043ba..0a987d19bf 100644
--- a/src/backends/wayland/wayland_display.h
+++ b/src/backends/wayland/wayland_display.h
@@ -46,7 +46,7 @@ public:
 
     zwp_linux_dmabuf_v1 *handle() const;
     QByteArray mainDevice() const;
-    QHash<uint32_t, QVector<uint64_t>> formats() const;
+    QHash<uint32_t, QList<uint64_t>> formats() const;
 
 private:
     static void format(void *data, struct zwp_linux_dmabuf_v1 *zwp_linux_dmabuf_v1, uint32_t format);
diff --git a/src/backends/wayland/wayland_egl_backend.cpp b/src/backends/wayland/wayland_egl_backend.cpp
index ab2c5eaf48..afd856d199 100644
--- a/src/backends/wayland/wayland_egl_backend.cpp
+++ b/src/backends/wayland/wayland_egl_backend.cpp
@@ -62,9 +62,9 @@ std::optional<OutputLayerBeginFrameInfo> WaylandEglPrimaryLayer::beginFrame()
 
     const QSize nativeSize = m_waylandOutput->modeSize();
     if (!m_swapchain || m_swapchain->size() != nativeSize) {
-        const QHash<uint32_t, QVector<uint64_t>> formatTable = m_backend->backend()->display()->linuxDmabuf()->formats();
+        const QHash<uint32_t, QList<uint64_t>> formatTable = m_backend->backend()->display()->linuxDmabuf()->formats();
         uint32_t format = DRM_FORMAT_INVALID;
-        QVector<uint64_t> modifiers;
+        QList<uint64_t> modifiers;
         for (const uint32_t &candidateFormat : {DRM_FORMAT_XRGB2101010, DRM_FORMAT_XRGB8888}) {
             auto it = formatTable.constFind(candidateFormat);
             if (it != formatTable.constEnd()) {
@@ -156,9 +156,9 @@ std::optional<OutputLayerBeginFrameInfo> WaylandEglCursorLayer::beginFrame()
     const auto tmp = size().expandedTo(QSize(64, 64));
     const QSize bufferSize(std::ceil(tmp.width()), std::ceil(tmp.height()));
     if (!m_swapchain || m_swapchain->size() != bufferSize) {
-        const QHash<uint32_t, QVector<uint64_t>> formatTable = m_backend->backend()->display()->linuxDmabuf()->formats();
+        const QHash<uint32_t, QList<uint64_t>> formatTable = m_backend->backend()->display()->linuxDmabuf()->formats();
         uint32_t format = DRM_FORMAT_INVALID;
-        QVector<uint64_t> modifiers;
+        QList<uint64_t> modifiers;
         for (const uint32_t &candidateFormat : {DRM_FORMAT_ARGB2101010, DRM_FORMAT_ARGB8888}) {
             auto it = formatTable.constFind(candidateFormat);
             if (it != formatTable.constEnd()) {
diff --git a/src/backends/x11/standalone/x11_standalone_backend.cpp b/src/backends/x11/standalone/x11_standalone_backend.cpp
index 852bf0e96f..876a0090a2 100644
--- a/src/backends/x11/standalone/x11_standalone_backend.cpp
+++ b/src/backends/x11/standalone/x11_standalone_backend.cpp
@@ -256,9 +256,9 @@ void X11StandaloneBackend::createEffectsHandler(Compositor *compositor, Workspac
     new EffectsHandlerImplX11(compositor, scene);
 }
 
-QVector<CompositingType> X11StandaloneBackend::supportedCompositors() const
+QList<CompositingType> X11StandaloneBackend::supportedCompositors() const
 {
-    QVector<CompositingType> compositors;
+    QList<CompositingType> compositors;
 #if HAVE_GLX
     compositors << OpenGLCompositing;
 #endif
@@ -286,9 +286,9 @@ void X11StandaloneBackend::updateOutputs()
 template<typename T>
 void X11StandaloneBackend::doUpdateOutputs()
 {
-    QVector<Output *> changed;
-    QVector<Output *> added;
-    QVector<Output *> removed = m_outputs;
+    QList<Output *> changed;
+    QList<Output *> added;
+    QList<Output *> removed = m_outputs;
 
     if (Xcb::Extensions::self()->isRandrAvailable()) {
         T resources(rootWindow());
@@ -481,7 +481,7 @@ static int currentRefreshRate()
         return refreshRate;
     }
 
-    const QVector<Output *> outputs = kwinApp()->outputBackend()->outputs();
+    const QList<Output *> outputs = kwinApp()->outputBackend()->outputs();
     if (outputs.isEmpty()) {
         return 60000;
     }
diff --git a/src/backends/x11/standalone/x11_standalone_backend.h b/src/backends/x11/standalone/x11_standalone_backend.h
index 242d9a3d97..9e6c2fca0e 100644
--- a/src/backends/x11/standalone/x11_standalone_backend.h
+++ b/src/backends/x11/standalone/x11_standalone_backend.h
@@ -52,7 +52,7 @@ public:
     xcb_window_t rootWindow() const;
 
     std::unique_ptr<OpenGLBackend> createOpenGLBackend() override;
-    QVector<CompositingType> supportedCompositors() const override;
+    QList<CompositingType> supportedCompositors() const override;
 
     void initOutputs();
     void scheduleUpdateOutputs();
@@ -101,7 +101,7 @@ private:
     std::unique_ptr<X11EventFilter> m_randrEventFilter;
     std::unique_ptr<X11Keyboard> m_keyboard;
     std::unique_ptr<RenderLoop> m_renderLoop;
-    QVector<Output *> m_outputs;
+    QList<Output *> m_outputs;
     std::unique_ptr<EglDisplay> m_eglDisplay;
 };
 
diff --git a/src/backends/x11/standalone/x11_standalone_effects_keyboard_interception_filter.cpp b/src/backends/x11/standalone/x11_standalone_effects_keyboard_interception_filter.cpp
index 6cf824f002..100e0c59f7 100644
--- a/src/backends/x11/standalone/x11_standalone_effects_keyboard_interception_filter.cpp
+++ b/src/backends/x11/standalone/x11_standalone_effects_keyboard_interception_filter.cpp
@@ -16,7 +16,7 @@ namespace KWin
 {
 
 EffectsKeyboardInterceptionX11Filter::EffectsKeyboardInterceptionX11Filter(EffectsHandlerImpl *effects, X11Keyboard *keyboard)
-    : X11EventFilter(QVector<int>{XCB_KEY_PRESS, XCB_KEY_RELEASE})
+    : X11EventFilter(QList<int>{XCB_KEY_PRESS, XCB_KEY_RELEASE})
     , m_effects(effects)
     , m_keyboard(keyboard)
 {
diff --git a/src/backends/x11/standalone/x11_standalone_effects_mouse_interception_filter.cpp b/src/backends/x11/standalone/x11_standalone_effects_mouse_interception_filter.cpp
index 5d54555100..db7fa12867 100644
--- a/src/backends/x11/standalone/x11_standalone_effects_mouse_interception_filter.cpp
+++ b/src/backends/x11/standalone/x11_standalone_effects_mouse_interception_filter.cpp
@@ -16,7 +16,7 @@ namespace KWin
 {
 
 EffectsMouseInterceptionX11Filter::EffectsMouseInterceptionX11Filter(xcb_window_t window, EffectsHandlerImpl *effects)
-    : X11EventFilter(QVector<int>{XCB_BUTTON_PRESS, XCB_BUTTON_RELEASE, XCB_MOTION_NOTIFY})
+    : X11EventFilter(QList<int>{XCB_BUTTON_PRESS, XCB_BUTTON_RELEASE, XCB_MOTION_NOTIFY})
     , m_effects(effects)
     , m_window(window)
 {
diff --git a/src/backends/x11/standalone/x11_standalone_overlaywindow.cpp b/src/backends/x11/standalone/x11_standalone_overlaywindow.cpp
index b2ffef3a72..a023d8a461 100644
--- a/src/backends/x11/standalone/x11_standalone_overlaywindow.cpp
+++ b/src/backends/x11/standalone/x11_standalone_overlaywindow.cpp
@@ -17,7 +17,7 @@
 #include "workspace.h"
 #include "x11_standalone_backend.h"
 
-#include <QVector>
+#include <QList>
 
 #include <xcb/composite.h>
 #include <xcb/shape.h>
@@ -29,7 +29,7 @@ namespace KWin
 {
 OverlayWindowX11::OverlayWindowX11(X11StandaloneBackend *backend)
     : OverlayWindow()
-    , X11EventFilter(QVector<int>{XCB_EXPOSE, XCB_VISIBILITY_NOTIFY})
+    , X11EventFilter(QList<int>{XCB_EXPOSE, XCB_VISIBILITY_NOTIFY})
     , m_backend(backend)
     , m_visible(true)
     , m_shown(false)
@@ -120,7 +120,7 @@ void OverlayWindowX11::setShape(const QRegion &reg)
     if (reg == m_shape) {
         return;
     }
-    const QVector<xcb_rectangle_t> xrects = Xcb::regionToRects(reg);
+    const QList<xcb_rectangle_t> xrects = Xcb::regionToRects(reg);
     xcb_shape_rectangles(connection(), XCB_SHAPE_SO_SET, XCB_SHAPE_SK_BOUNDING, XCB_CLIP_ORDERING_UNSORTED,
                          m_window, 0, 0, xrects.count(), xrects.data());
     setupInputShape(m_window);
diff --git a/src/backends/x11/standalone/x11_standalone_screenedges_filter.cpp b/src/backends/x11/standalone/x11_standalone_screenedges_filter.cpp
index 42d4200657..064449c52f 100644
--- a/src/backends/x11/standalone/x11_standalone_screenedges_filter.cpp
+++ b/src/backends/x11/standalone/x11_standalone_screenedges_filter.cpp
@@ -18,7 +18,7 @@ namespace KWin
 {
 
 ScreenEdgesFilter::ScreenEdgesFilter()
-    : X11EventFilter(QVector<int>{XCB_MOTION_NOTIFY, XCB_ENTER_NOTIFY, XCB_CLIENT_MESSAGE})
+    : X11EventFilter(QList<int>{XCB_MOTION_NOTIFY, XCB_ENTER_NOTIFY, XCB_CLIENT_MESSAGE})
 {
 }
 
diff --git a/src/backends/x11/standalone/x11_standalone_windowselector.cpp b/src/backends/x11/standalone/x11_standalone_windowselector.cpp
index af3aa00db9..40ba4da03c 100644
--- a/src/backends/x11/standalone/x11_standalone_windowselector.cpp
+++ b/src/backends/x11/standalone/x11_standalone_windowselector.cpp
@@ -24,7 +24,7 @@ namespace KWin
 {
 
 WindowSelector::WindowSelector()
-    : X11EventFilter(QVector<int>{
+    : X11EventFilter(QList<int>{
         XCB_BUTTON_PRESS,
         XCB_BUTTON_RELEASE,
         XCB_MOTION_NOTIFY,
diff --git a/src/backends/x11/standalone/x11_standalone_xfixes_cursor_event_filter.cpp b/src/backends/x11/standalone/x11_standalone_xfixes_cursor_event_filter.cpp
index f0d3cfcefe..5222340ca6 100644
--- a/src/backends/x11/standalone/x11_standalone_xfixes_cursor_event_filter.cpp
+++ b/src/backends/x11/standalone/x11_standalone_xfixes_cursor_event_filter.cpp
@@ -14,7 +14,7 @@ namespace KWin
 {
 
 XFixesCursorEventFilter::XFixesCursorEventFilter(X11Cursor *cursor)
-    : X11EventFilter(QVector<int>{Xcb::Extensions::self()->fixesCursorNotifyEvent()})
+    : X11EventFilter(QList<int>{Xcb::Extensions::self()->fixesCursorNotifyEvent()})
     , m_cursor(cursor)
 {
 }
diff --git a/src/backends/x11/standalone/x11_standalone_xinputintegration.cpp b/src/backends/x11/standalone/x11_standalone_xinputintegration.cpp
index b66ef7fbb2..f61b779fd7 100644
--- a/src/backends/x11/standalone/x11_standalone_xinputintegration.cpp
+++ b/src/backends/x11/standalone/x11_standalone_xinputintegration.cpp
@@ -42,7 +42,7 @@ class XInputEventFilter : public X11EventFilter
 {
 public:
     XInputEventFilter(int xi_opcode)
-        : X11EventFilter(XCB_GE_GENERIC, xi_opcode, QVector<int>{XI_RawMotion, XI_RawButtonPress, XI_RawButtonRelease, XI_RawKeyPress, XI_RawKeyRelease, XI_TouchBegin, XI_TouchUpdate, XI_TouchOwnership, XI_TouchEnd})
+        : X11EventFilter(XCB_GE_GENERIC, xi_opcode, QList<int>{XI_RawMotion, XI_RawButtonPress, XI_RawButtonRelease, XI_RawKeyPress, XI_RawKeyRelease, XI_TouchBegin, XI_TouchUpdate, XI_TouchOwnership, XI_TouchEnd})
     {
     }
     ~XInputEventFilter() override = default;
diff --git a/src/backends/x11/windowed/x11_windowed_backend.cpp b/src/backends/x11/windowed/x11_windowed_backend.cpp
index d0257e0427..4d217855f6 100644
--- a/src/backends/x11/windowed/x11_windowed_backend.cpp
+++ b/src/backends/x11/windowed/x11_windowed_backend.cpp
@@ -324,7 +324,7 @@ void X11WindowedBackend::initDri3()
     while (it.rem > 0) {
         uint32_t format = driFormatForDepth(it.data->depth);
         if (format) {
-            QVector<uint64_t> &mods = m_driFormats[format];
+            QList<uint64_t> &mods = m_driFormats[format];
 
             if (m_driMajorVersion > 1 || m_driMinorVersion >= 2) {
                 xcb_dri3_get_supported_modifiers_cookie_t cookie = xcb_dri3_get_supported_modifiers(m_connection, m_screen->root, it.data->depth, 32);
@@ -754,7 +754,7 @@ bool X11WindowedBackend::hasXInput() const
     return m_hasXInput;
 }
 
-QHash<uint32_t, QVector<uint64_t>> X11WindowedBackend::driFormats() const
+QHash<uint32_t, QList<uint64_t>> X11WindowedBackend::driFormats() const
 {
     return m_driFormats;
 }
@@ -781,9 +781,9 @@ int X11WindowedBackend::driMinorVersion() const
     return m_driMinorVersion;
 }
 
-QVector<CompositingType> X11WindowedBackend::supportedCompositors() const
+QList<CompositingType> X11WindowedBackend::supportedCompositors() const
 {
-    QVector<CompositingType> ret;
+    QList<CompositingType> ret;
     if (m_gbmDevice) {
         ret.append(OpenGLCompositing);
     }
diff --git a/src/backends/x11/windowed/x11_windowed_backend.h b/src/backends/x11/windowed/x11_windowed_backend.h
index 7e44b22147..3715b190c4 100644
--- a/src/backends/x11/windowed/x11_windowed_backend.h
+++ b/src/backends/x11/windowed/x11_windowed_backend.h
@@ -108,7 +108,7 @@ public:
 
     bool hasXInput() const;
 
-    QHash<uint32_t, QVector<uint64_t>> driFormats() const;
+    QHash<uint32_t, QList<uint64_t>> driFormats() const;
     uint32_t driFormatForDepth(int depth) const;
     int driMajorVersion() const;
     int driMinorVersion() const;
@@ -117,7 +117,7 @@ public:
     std::unique_ptr<OpenGLBackend> createOpenGLBackend() override;
     std::unique_ptr<QPainterBackend> createQPainterBackend() override;
     std::unique_ptr<InputBackend> createInputBackend() override;
-    QVector<CompositingType> supportedCompositors() const override;
+    QList<CompositingType> supportedCompositors() const override;
     Outputs outputs() const override;
 
     X11WindowedInputDevice *pointerDevice() const;
@@ -173,13 +173,13 @@ private:
     bool m_hasDri = false;
     int m_driMajorVersion = 0;
     int m_driMinorVersion = 0;
-    QHash<uint32_t, QVector<uint64_t>> m_driFormats;
+    QHash<uint32_t, QList<uint64_t>> m_driFormats;
 
     FileDescriptor m_drmFileDescriptor;
     gbm_device *m_gbmDevice = nullptr;
     std::unique_ptr<EglDisplay> m_eglDisplay;
 
-    QVector<X11WindowedOutput *> m_outputs;
+    QList<X11WindowedOutput *> m_outputs;
 };
 
 } // namespace KWin
diff --git a/src/backends/x11/windowed/x11_windowed_egl_backend.cpp b/src/backends/x11/windowed/x11_windowed_egl_backend.cpp
index 0d1b16dde3..2eec57b894 100644
--- a/src/backends/x11/windowed/x11_windowed_egl_backend.cpp
+++ b/src/backends/x11/windowed/x11_windowed_egl_backend.cpp
@@ -39,7 +39,7 @@ std::optional<OutputLayerBeginFrameInfo> X11WindowedEglPrimaryLayer::beginFrame(
     const QSize bufferSize = m_output->modeSize();
     if (!m_swapchain || m_swapchain->size() != bufferSize) {
         const uint32_t format = DRM_FORMAT_XRGB8888;
-        const QHash<uint32_t, QVector<uint64_t>> formatTable = m_backend->backend()->driFormats();
+        const QHash<uint32_t, QList<uint64_t>> formatTable = m_backend->backend()->driFormats();
         if (!formatTable.contains(format)) {
             return std::nullopt;
         }
diff --git a/src/backends/x11/windowed/x11_windowed_qpainter_backend.h b/src/backends/x11/windowed/x11_windowed_qpainter_backend.h
index 446f7c9629..16f347de38 100644
--- a/src/backends/x11/windowed/x11_windowed_qpainter_backend.h
+++ b/src/backends/x11/windowed/x11_windowed_qpainter_backend.h
@@ -12,8 +12,8 @@
 #include "platformsupport/scenes/qpainter/qpainterbackend.h"
 
 #include <QImage>
+#include <QList>
 #include <QObject>
-#include <QVector>
 
 #include <chrono>
 #include <memory>
diff --git a/src/colors/colormanager.cpp b/src/colors/colormanager.cpp
index 727d058d7a..1833853554 100644
--- a/src/colors/colormanager.cpp
+++ b/src/colors/colormanager.cpp
@@ -18,7 +18,7 @@ namespace KWin
 class ColorManagerPrivate
 {
 public:
-    QVector<ColorDevice *> devices;
+    QList<ColorDevice *> devices;
 };
 
 ColorManager::ColorManager()
@@ -36,7 +36,7 @@ ColorManager::ColorManager()
 
 ColorManager::~ColorManager() = default;
 
-QVector<ColorDevice *> ColorManager::devices() const
+QList<ColorDevice *> ColorManager::devices() const
 {
     return d->devices;
 }
diff --git a/src/colors/colormanager.h b/src/colors/colormanager.h
index d6c36ced29..96caa3b2fe 100644
--- a/src/colors/colormanager.h
+++ b/src/colors/colormanager.h
@@ -38,7 +38,7 @@ public:
     /**
      * Returns the list of all available color devices.
      */
-    QVector<ColorDevice *> devices() const;
+    QList<ColorDevice *> devices() const;
 
 Q_SIGNALS:
     /**
diff --git a/src/compositor_wayland.cpp b/src/compositor_wayland.cpp
index aaacd9b68b..bdda9e9d29 100644
--- a/src/compositor_wayland.cpp
+++ b/src/compositor_wayland.cpp
@@ -120,8 +120,8 @@ void WaylandCompositor::start()
     m_state = State::Starting;
 
     // If compositing has been restarted, try to use the last used compositing type.
-    const QVector<CompositingType> availableCompositors = kwinApp()->outputBackend()->supportedCompositors();
-    QVector<CompositingType> candidateCompositors;
+    const QList<CompositingType> availableCompositors = kwinApp()->outputBackend()->supportedCompositors();
+    QList<CompositingType> candidateCompositors;
 
     if (m_selectedCompositor != NoCompositing) {
         candidateCompositors.append(m_selectedCompositor);
diff --git a/src/compositor_x11.cpp b/src/compositor_x11.cpp
index a3d7ed0461..249d01d36f 100644
--- a/src/compositor_x11.cpp
+++ b/src/compositor_x11.cpp
@@ -280,7 +280,7 @@ void X11Compositor::start()
                                       XCB_COMPOSITE_REDIRECT_MANUAL);
 
     // Decide what compositing types can be used.
-    QVector<CompositingType> candidateCompositors = kwinApp()->outputBackend()->supportedCompositors();
+    QList<CompositingType> candidateCompositors = kwinApp()->outputBackend()->supportedCompositors();
     const auto userConfigIt = std::find(candidateCompositors.begin(), candidateCompositors.end(), options->compositingMode());
     if (userConfigIt != candidateCompositors.end()) {
         candidateCompositors.erase(userConfigIt);
diff --git a/src/core/colorlut.h b/src/core/colorlut.h
index 2d7735464f..8ff50fd694 100644
--- a/src/core/colorlut.h
+++ b/src/core/colorlut.h
@@ -8,7 +8,7 @@
 */
 #pragma once
 
-#include <QVector>
+#include <QList>
 #include <memory>
 
 #include "kwin_export.h"
@@ -30,7 +30,7 @@ public:
     std::shared_ptr<ColorTransformation> transformation() const;
 
 private:
-    QVector<uint16_t> m_data;
+    QList<uint16_t> m_data;
     const std::shared_ptr<ColorTransformation> m_transformation;
 };
 
diff --git a/src/core/graphicsbufferallocator.h b/src/core/graphicsbufferallocator.h
index cb0564190e..e66c0a23a4 100644
--- a/src/core/graphicsbufferallocator.h
+++ b/src/core/graphicsbufferallocator.h
@@ -8,8 +8,8 @@
 
 #include "kwin_export.h"
 
+#include <QList>
 #include <QSize>
-#include <QVector>
 
 namespace KWin
 {
@@ -28,7 +28,7 @@ struct GraphicsBufferOptions
     uint32_t format;
 
     /// An optional list of modifiers, see DRM_FORMAT_MOD_*.
-    QVector<uint64_t> modifiers;
+    QList<uint64_t> modifiers;
 
     /// Whether the graphics buffer should be suitable for software rendering.
     bool software = false;
diff --git a/src/core/output.h b/src/core/output.h
index bd5c21cc4e..e374d0d199 100644
--- a/src/core/output.h
+++ b/src/core/output.h
@@ -14,13 +14,13 @@
 #include "utils/edid.h"
 
 #include <QDebug>
+#include <QList>
 #include <QMatrix3x3>
 #include <QMatrix4x4>
 #include <QObject>
 #include <QRect>
 #include <QSize>
 #include <QUuid>
-#include <QVector>
 
 namespace KWin
 {
diff --git a/src/core/outputbackend.cpp b/src/core/outputbackend.cpp
index 8fb0e8b667..1219df4c55 100644
--- a/src/core/outputbackend.cpp
+++ b/src/core/outputbackend.cpp
@@ -46,8 +46,8 @@ std::unique_ptr<QPainterBackend> OutputBackend::createQPainterBackend()
 bool OutputBackend::applyOutputChanges(const OutputConfiguration &config)
 {
     const auto availableOutputs = outputs();
-    QVector<Output *> toBeEnabledOutputs;
-    QVector<Output *> toBeDisabledOutputs;
+    QList<Output *> toBeEnabledOutputs;
+    QList<Output *> toBeDisabledOutputs;
     for (const auto &output : availableOutputs) {
         if (const auto changeset = config.constChangeSet(output)) {
             if (changeset->enabled) {
diff --git a/src/core/outputbackend.h b/src/core/outputbackend.h
index 6734752497..67a9f41c37 100644
--- a/src/core/outputbackend.h
+++ b/src/core/outputbackend.h
@@ -29,12 +29,12 @@ class OutputConfiguration;
 class EglDisplay;
 class Session;
 
-class KWIN_EXPORT Outputs : public QVector<Output *>
+class KWIN_EXPORT Outputs : public QList<Output *>
 {
 public:
     Outputs(){};
     template<typename T>
-    Outputs(const QVector<T> &other)
+    Outputs(const QList<T> &other)
     {
         resize(other.size());
         std::copy(other.constBegin(), other.constEnd(), begin());
@@ -72,7 +72,7 @@ public:
      * The first item should be the most preferred one.
      * @since 5.11
      */
-    virtual QVector<CompositingType> supportedCompositors() const = 0;
+    virtual QList<CompositingType> supportedCompositors() const = 0;
 
     virtual Outputs outputs() const = 0;
     Output *findOutput(const QString &name) const;
diff --git a/src/core/renderbackend.cpp b/src/core/renderbackend.cpp
index 988d899a45..5083184a72 100644
--- a/src/core/renderbackend.cpp
+++ b/src/core/renderbackend.cpp
@@ -42,9 +42,9 @@ bool RenderBackend::testImportBuffer(GraphicsBuffer *buffer)
     return false;
 }
 
-QHash<uint32_t, QVector<uint64_t>> RenderBackend::supportedFormats() const
+QHash<uint32_t, QList<uint64_t>> RenderBackend::supportedFormats() const
 {
-    return QHash<uint32_t, QVector<uint64_t>>{{DRM_FORMAT_XRGB8888, QVector<uint64_t>{DRM_FORMAT_MOD_LINEAR}}};
+    return QHash<uint32_t, QList<uint64_t>>{{DRM_FORMAT_XRGB8888, QList<uint64_t>{DRM_FORMAT_MOD_LINEAR}}};
 }
 
 std::unique_ptr<SurfaceTexture> RenderBackend::createSurfaceTextureX11(SurfacePixmapX11 *pixmap)
diff --git a/src/core/renderbackend.h b/src/core/renderbackend.h
index ccc05ba839..fa20380629 100644
--- a/src/core/renderbackend.h
+++ b/src/core/renderbackend.h
@@ -47,7 +47,7 @@ public:
     virtual GraphicsBufferAllocator *graphicsBufferAllocator() const;
 
     virtual bool testImportBuffer(GraphicsBuffer *buffer);
-    virtual QHash<uint32_t, QVector<uint64_t>> supportedFormats() const;
+    virtual QHash<uint32_t, QList<uint64_t>> supportedFormats() const;
 
     virtual std::unique_ptr<SurfaceTexture> createSurfaceTextureX11(SurfacePixmapX11 *pixmap);
     virtual std::unique_ptr<SurfaceTexture> createSurfaceTextureWayland(SurfacePixmap *pixmap);
diff --git a/src/cursor.cpp b/src/cursor.cpp
index f91e67c924..810227ea17 100644
--- a/src/cursor.cpp
+++ b/src/cursor.cpp
@@ -330,9 +330,9 @@ void Cursor::doStopCursorTracking()
 {
 }
 
-QVector<QByteArray> Cursor::cursorAlternativeNames(const QByteArray &name)
+QList<QByteArray> Cursor::cursorAlternativeNames(const QByteArray &name)
 {
-    static const QHash<QByteArray, QVector<QByteArray>> alternatives = {
+    static const QHash<QByteArray, QList<QByteArray>> alternatives = {
         {
             QByteArrayLiteral("left_ptr"),
             {
@@ -604,7 +604,7 @@ QVector<QByteArray> Cursor::cursorAlternativeNames(const QByteArray &name)
     if (it != alternatives.end()) {
         return it.value();
     }
-    return QVector<QByteArray>();
+    return QList<QByteArray>();
 }
 
 QString Cursor::defaultThemeName()
diff --git a/src/cursor.h b/src/cursor.h
index dbb93d3b49..4edbefcdec 100644
--- a/src/cursor.h
+++ b/src/cursor.h
@@ -139,7 +139,7 @@ public:
     /**
      * @return list of alternative names for the cursor with @p name
      */
-    static QVector<QByteArray> cursorAlternativeNames(const QByteArray &name);
+    static QList<QByteArray> cursorAlternativeNames(const QByteArray &name);
     /**
      * Returns the default Xcursor theme name.
      */
@@ -304,7 +304,7 @@ private:
     static Cursors *s_self;
     Cursor *m_currentCursor = nullptr;
     Cursor *m_mouse = nullptr;
-    QVector<Cursor *> m_cursors;
+    QList<Cursor *> m_cursors;
     int m_cursorHideCounter = 0;
 };
 
diff --git a/src/cursorsource.h b/src/cursorsource.h
index aa5ecc7b7b..2fb5adc4a7 100644
--- a/src/cursorsource.h
+++ b/src/cursorsource.h
@@ -66,7 +66,7 @@ private:
 
     KXcursorTheme m_theme;
     QByteArray m_shape;
-    QVector<KXcursorSprite> m_sprites;
+    QList<KXcursorSprite> m_sprites;
     QTimer m_delayTimer;
     QImage m_image;
     int m_currentSprite = -1;
diff --git a/src/dbusinterface.cpp b/src/dbusinterface.cpp
index febdaa2dce..c7cfb78599 100644
--- a/src/dbusinterface.cpp
+++ b/src/dbusinterface.cpp
@@ -361,7 +361,7 @@ VirtualDesktopManagerDBusInterface::VirtualDesktopManagerDBusInterface(VirtualDe
 
     connect(m_manager, &VirtualDesktopManager::rowsChanged, this, &VirtualDesktopManagerDBusInterface::rowsChanged);
 
-    const QVector<VirtualDesktop *> allDesks = m_manager->desktops();
+    const QList<VirtualDesktop *> allDesks = m_manager->desktops();
     for (auto *vd : allDesks) {
         connect(vd, &VirtualDesktop::x11DesktopNumberChanged, this, [this, vd]() {
             DBusDesktopDataStruct data{.position = vd->x11DesktopNumber() - 1, .id = vd->id(), .name = vd->name()};
diff --git a/src/debug_console.cpp b/src/debug_console.cpp
index 3777229a2d..32ed02bcc3 100644
--- a/src/debug_console.cpp
+++ b/src/debug_console.cpp
@@ -899,7 +899,7 @@ static const quint32 s_windowBitMask = 0x0000FFFF;
 static const quint32 s_idDistance = 10000;
 
 template<class T>
-void DebugConsoleModel::add(int parentRow, QVector<T *> &windows, T *window)
+void DebugConsoleModel::add(int parentRow, QList<T *> &windows, T *window)
 {
     beginInsertRows(index(parentRow, 0, QModelIndex()), windows.count(), windows.count());
     windows.append(window);
@@ -907,7 +907,7 @@ void DebugConsoleModel::add(int parentRow, QVector<T *> &windows, T *window)
 }
 
 template<class T>
-void DebugConsoleModel::remove(int parentRow, QVector<T *> &windows, T *window)
+void DebugConsoleModel::remove(int parentRow, QList<T *> &windows, T *window)
 {
     const int remove = windows.indexOf(window);
     if (remove == -1) {
@@ -1032,7 +1032,7 @@ int DebugConsoleModel::rowCount(const QModelIndex &parent) const
 }
 
 template<class T>
-QModelIndex DebugConsoleModel::indexForWindow(int row, int column, const QVector<T *> &windows, int id) const
+QModelIndex DebugConsoleModel::indexForWindow(int row, int column, const QList<T *> &windows, int id) const
 {
     if (column != 0) {
         return QModelIndex();
@@ -1187,7 +1187,7 @@ QVariant DebugConsoleModel::propertyData(QObject *object, const QModelIndex &ind
 }
 
 template<class T>
-QVariant DebugConsoleModel::windowData(const QModelIndex &index, int role, const QVector<T *> windows, const std::function<QString(T *)> &toString) const
+QVariant DebugConsoleModel::windowData(const QModelIndex &index, int role, const QList<T *> windows, const std::function<QString(T *)> &toString) const
 {
     if (index.row() >= windows.count()) {
         return QVariant();
@@ -1273,7 +1273,7 @@ QVariant DebugConsoleModel::data(const QModelIndex &index, int role) const
 }
 
 template<class T>
-static T *windowForIndex(const QModelIndex &index, const QVector<T *> &windows, int id)
+static T *windowForIndex(const QModelIndex &index, const QList<T *> &windows, int id)
 {
     const qint32 row = (index.internalId() & s_windowBitMask) - (s_idDistance * id);
     if (row < 0 || row >= windows.count()) {
@@ -1561,7 +1561,7 @@ void InputDeviceModel::slotPropertyChanged()
         if (metaProperty.notifySignalIndex() == senderSignalIndex()) {
             const QModelIndex parent = index(m_devices.indexOf(device), 0, QModelIndex());
             const QModelIndex child = index(i, 1, parent);
-            Q_EMIT dataChanged(child, child, QVector<int>{Qt::DisplayRole});
+            Q_EMIT dataChanged(child, child, QList<int>{Qt::DisplayRole});
         }
     }
 }
diff --git a/src/debug_console.h b/src/debug_console.h
index f9c75a555c..ab999ea6e2 100644
--- a/src/debug_console.h
+++ b/src/debug_console.h
@@ -14,8 +14,8 @@
 #include <kwin_export.h>
 
 #include <QAbstractItemModel>
+#include <QList>
 #include <QStyledItemDelegate>
-#include <QVector>
 #include <functional>
 #include <memory>
 
@@ -55,28 +55,28 @@ private Q_SLOTS:
 
 private:
     template<class T>
-    QModelIndex indexForWindow(int row, int column, const QVector<T *> &windows, int id) const;
+    QModelIndex indexForWindow(int row, int column, const QList<T *> &windows, int id) const;
     template<class T>
     QModelIndex indexForProperty(int row, int column, const QModelIndex &parent, T *(DebugConsoleModel::*filter)(const QModelIndex &) const) const;
     template<class T>
     int propertyCount(const QModelIndex &parent, T *(DebugConsoleModel::*filter)(const QModelIndex &) const) const;
     QVariant propertyData(QObject *object, const QModelIndex &index, int role) const;
     template<class T>
-    QVariant windowData(const QModelIndex &index, int role, const QVector<T *> windows, const std::function<QString(T *)> &toString) const;
+    QVariant windowData(const QModelIndex &index, int role, const QList<T *> windows, const std::function<QString(T *)> &toString) const;
     template<class T>
-    void add(int parentRow, QVector<T *> &windows, T *window);
+    void add(int parentRow, QList<T *> &windows, T *window);
     template<class T>
-    void remove(int parentRow, QVector<T *> &windows, T *window);
+    void remove(int parentRow, QList<T *> &windows, T *window);
     WaylandWindow *waylandWindow(const QModelIndex &index) const;
     InternalWindow *internalWindow(const QModelIndex &index) const;
     X11Window *x11Window(const QModelIndex &index) const;
     X11Window *unmanaged(const QModelIndex &index) const;
     int topLevelRowCount() const;
 
-    QVector<WaylandWindow *> m_waylandWindows;
-    QVector<InternalWindow *> m_internalWindows;
-    QVector<X11Window *> m_x11Windows;
-    QVector<X11Window *> m_unmanageds;
+    QList<WaylandWindow *> m_waylandWindows;
+    QList<InternalWindow *> m_internalWindows;
+    QList<X11Window *> m_x11Windows;
+    QList<X11Window *> m_unmanageds;
 };
 
 class DebugConsoleDelegate : public QStyledItemDelegate
@@ -196,6 +196,6 @@ public:
 
 private:
     AbstractDataSource *m_source = nullptr;
-    QVector<QByteArray> m_data;
+    QList<QByteArray> m_data;
 };
 }
diff --git a/src/decorations/decorationbridge.cpp b/src/decorations/decorationbridge.cpp
index c919122600..1dd8b10c06 100644
--- a/src/decorations/decorationbridge.cpp
+++ b/src/decorations/decorationbridge.cpp
@@ -251,8 +251,8 @@ static QString settingsProperty(const QVariant &variant)
 {
     if (QLatin1String(variant.typeName()) == QLatin1String("KDecoration2::BorderSize")) {
         return QString::number(variant.toInt());
-    } else if (QLatin1String(variant.typeName()) == QLatin1String("QVector<KDecoration2::DecorationButtonType>")) {
-        const auto &b = variant.value<QVector<KDecoration2::DecorationButtonType>>();
+    } else if (QLatin1String(variant.typeName()) == QLatin1String("QList<KDecoration2::DecorationButtonType>")) {
+        const auto &b = variant.value<QList<KDecoration2::DecorationButtonType>>();
         QString buffer;
         for (auto it = b.begin(); it != b.end(); ++it) {
             if (it != b.begin()) {
diff --git a/src/decorations/settings.cpp b/src/decorations/settings.cpp
index d22ebb7846..ffd393fbdd 100644
--- a/src/decorations/settings.cpp
+++ b/src/decorations/settings.cpp
@@ -82,7 +82,7 @@ static void initButtons()
     s_buttonNames[KDecoration2::DecorationButtonType::Shade] = QChar('L');
 }
 
-static QString buttonsToString(const QVector<KDecoration2::DecorationButtonType> &buttons)
+static QString buttonsToString(const QList<KDecoration2::DecorationButtonType> &buttons)
 {
     auto buttonToString = [](KDecoration2::DecorationButtonType button) -> QChar {
         const auto it = s_buttonNames.constFind(button);
@@ -98,13 +98,13 @@ static QString buttonsToString(const QVector<KDecoration2::DecorationButtonType>
     return ret;
 }
 
-QVector<KDecoration2::DecorationButtonType> SettingsImpl::readDecorationButtons(const KConfigGroup &config,
-                                                                                const char *key,
-                                                                                const QVector<KDecoration2::DecorationButtonType> &defaultValue) const
+QList<KDecoration2::DecorationButtonType> SettingsImpl::readDecorationButtons(const KConfigGroup &config,
+                                                                              const char *key,
+                                                                              const QList<KDecoration2::DecorationButtonType> &defaultValue) const
 {
     initButtons();
-    auto buttonsFromString = [](const QString &buttons) -> QVector<KDecoration2::DecorationButtonType> {
-        QVector<KDecoration2::DecorationButtonType> ret;
+    auto buttonsFromString = [](const QString &buttons) -> QList<KDecoration2::DecorationButtonType> {
+        QList<KDecoration2::DecorationButtonType> ret;
         for (auto it = buttons.begin(); it != buttons.end(); ++it) {
             for (auto it2 = s_buttonNames.constBegin(); it2 != s_buttonNames.constEnd(); ++it2) {
                 if (it2.value() == (*it)) {
@@ -139,12 +139,12 @@ static KDecoration2::BorderSize stringToSize(const QString &name)
 void SettingsImpl::readSettings()
 {
     KConfigGroup config = kwinApp()->config()->group(QStringLiteral("org.kde.kdecoration2"));
-    const auto &left = readDecorationButtons(config, "ButtonsOnLeft", QVector<KDecoration2::DecorationButtonType>({KDecoration2::DecorationButtonType::Menu, KDecoration2::DecorationButtonType::OnAllDesktops}));
+    const auto &left = readDecorationButtons(config, "ButtonsOnLeft", QList<KDecoration2::DecorationButtonType>({KDecoration2::DecorationButtonType::Menu, KDecoration2::DecorationButtonType::OnAllDesktops}));
     if (left != m_leftButtons) {
         m_leftButtons = left;
         Q_EMIT decorationSettings()->decorationButtonsLeftChanged(m_leftButtons);
     }
-    const auto &right = readDecorationButtons(config, "ButtonsOnRight", QVector<KDecoration2::DecorationButtonType>({KDecoration2::DecorationButtonType::ContextHelp, KDecoration2::DecorationButtonType::Minimize, KDecoration2::DecorationButtonType::Maximize, KDecoration2::DecorationButtonType::Close}));
+    const auto &right = readDecorationButtons(config, "ButtonsOnRight", QList<KDecoration2::DecorationButtonType>({KDecoration2::DecorationButtonType::ContextHelp, KDecoration2::DecorationButtonType::Minimize, KDecoration2::DecorationButtonType::Maximize, KDecoration2::DecorationButtonType::Close}));
     if (right != m_rightButtons) {
         m_rightButtons = right;
         Q_EMIT decorationSettings()->decorationButtonsRightChanged(m_rightButtons);
diff --git a/src/decorations/settings.h b/src/decorations/settings.h
index faa2993f88..148bdb559b 100644
--- a/src/decorations/settings.h
+++ b/src/decorations/settings.h
@@ -32,11 +32,11 @@ public:
     {
         return m_borderSize;
     }
-    QVector<KDecoration2::DecorationButtonType> decorationButtonsLeft() const override
+    QList<KDecoration2::DecorationButtonType> decorationButtonsLeft() const override
     {
         return m_leftButtons;
     }
-    QVector<KDecoration2::DecorationButtonType> decorationButtonsRight() const override
+    QList<KDecoration2::DecorationButtonType> decorationButtonsRight() const override
     {
         return m_rightButtons;
     }
@@ -47,11 +47,11 @@ public:
 
 private:
     void readSettings();
-    QVector<KDecoration2::DecorationButtonType> readDecorationButtons(const KConfigGroup &config,
-                                                                      const char *key,
-                                                                      const QVector<KDecoration2::DecorationButtonType> &defaultValue) const;
-    QVector<KDecoration2::DecorationButtonType> m_leftButtons;
-    QVector<KDecoration2::DecorationButtonType> m_rightButtons;
+    QList<KDecoration2::DecorationButtonType> readDecorationButtons(const KConfigGroup &config,
+                                                                    const char *key,
+                                                                    const QList<KDecoration2::DecorationButtonType> &defaultValue) const;
+    QList<KDecoration2::DecorationButtonType> m_leftButtons;
+    QList<KDecoration2::DecorationButtonType> m_rightButtons;
     KDecoration2::BorderSize m_borderSize;
     bool m_autoBorderSize = true;
     bool m_closeDoubleClickMenu = false;
diff --git a/src/dpmsinputeventfilter.h b/src/dpmsinputeventfilter.h
index 90376f4d25..461a040e4b 100644
--- a/src/dpmsinputeventfilter.h
+++ b/src/dpmsinputeventfilter.h
@@ -36,7 +36,7 @@ public:
 private:
     void notify();
     QElapsedTimer m_doubleTapTimer;
-    QVector<qint32> m_touchPoints;
+    QList<qint32> m_touchPoints;
     bool m_secondTap = false;
     bool m_enableDoubleTap;
 };
diff --git a/src/effectloader.cpp b/src/effectloader.cpp
index c14c105bb3..569e86de99 100644
--- a/src/effectloader.cpp
+++ b/src/effectloader.cpp
@@ -390,7 +390,7 @@ void PluginEffectLoader::queryAndLoadAll()
     }
 }
 
-QVector<KPluginMetaData> PluginEffectLoader::findAllEffects() const
+QList<KPluginMetaData> PluginEffectLoader::findAllEffects() const
 {
     return KPluginMetaData::findPlugins(m_pluginSubDirectory);
 }
diff --git a/src/effectloader.h b/src/effectloader.h
index ddf690c894..7d8c560cf2 100644
--- a/src/effectloader.h
+++ b/src/effectloader.h
@@ -317,7 +317,7 @@ public:
     void setPluginSubDirectory(const QString &directory);
 
 private:
-    QVector<KPluginMetaData> findAllEffects() const;
+    QList<KPluginMetaData> findAllEffects() const;
     KPluginMetaData findEffect(const QString &name) const;
     EffectPluginFactory *factory(const KPluginMetaData &info) const;
     QStringList m_loadedEffects;
diff --git a/src/effects.cpp b/src/effects.cpp
index b6aedbbbb3..e805d7b938 100644
--- a/src/effects.cpp
+++ b/src/effects.cpp
@@ -128,7 +128,7 @@ EffectsHandlerImpl::EffectsHandlerImpl(Compositor *compositor, WorkspaceScene *s
     , m_effectLoader(new EffectLoader(this))
     , m_trackingCursorChanges(0)
 {
-    qRegisterMetaType<QVector<KWin::EffectWindow *>>();
+    qRegisterMetaType<QList<KWin::EffectWindow *>>();
     qRegisterMetaType<KWin::SessionState>();
     connect(m_effectLoader, &AbstractEffectLoader::effectLoaded, this, [this](Effect *effect, const QString &name) {
         effect_order.insert(effect->requestedEffectChainPosition(), EffectPair(name, effect));
@@ -369,7 +369,7 @@ void EffectsHandlerImpl::startPaint()
 {
     m_activeEffects.clear();
     m_activeEffects.reserve(loaded_effects.count());
-    for (QVector<KWin::EffectPair>::const_iterator it = loaded_effects.constBegin(); it != loaded_effects.constEnd(); ++it) {
+    for (QList<KWin::EffectPair>::const_iterator it = loaded_effects.constBegin(); it != loaded_effects.constEnd(); ++it) {
         if (it->second->isActive()) {
             m_activeEffects << it->second;
         }
@@ -720,20 +720,20 @@ void EffectsHandlerImpl::moveWindow(EffectWindow *w, const QPoint &pos, bool sna
 
 void EffectsHandlerImpl::windowToDesktop(EffectWindow *w, int desktop)
 {
-    QVector<uint> desktopIds;
+    QList<uint> desktopIds;
     if (desktop != -1) {
         desktopIds.append(desktop);
     }
     windowToDesktops(w, desktopIds);
 }
 
-void EffectsHandlerImpl::windowToDesktops(EffectWindow *w, const QVector<uint> &desktopIds)
+void EffectsHandlerImpl::windowToDesktops(EffectWindow *w, const QList<uint> &desktopIds)
 {
     auto window = static_cast<EffectWindowImpl *>(w)->window();
     if (!window->isClient() || window->isDesktop() || window->isDock()) {
         return;
     }
-    QVector<VirtualDesktop *> desktops;
+    QList<VirtualDesktop *> desktops;
     desktops.reserve(desktopIds.count());
     for (uint x11Id : desktopIds) {
         if (x11Id > VirtualDesktopManager::self()->count()) {
@@ -1242,7 +1242,7 @@ void EffectsHandlerImpl::destroyEffect(Effect *effect)
 
 void EffectsHandlerImpl::reconfigureEffect(const QString &name)
 {
-    for (QVector<EffectPair>::const_iterator it = loaded_effects.constBegin(); it != loaded_effects.constEnd(); ++it) {
+    for (QList<EffectPair>::const_iterator it = loaded_effects.constBegin(); it != loaded_effects.constEnd(); ++it) {
         if ((*it).first == name) {
             kwinApp()->config()->reparseConfiguration();
             makeOpenGLContextCurrent();
@@ -1289,7 +1289,7 @@ QList<bool> EffectsHandlerImpl::areEffectsSupported(const QStringList &names)
 void EffectsHandlerImpl::reloadEffect(Effect *effect)
 {
     QString effectName;
-    for (QVector<EffectPair>::const_iterator it = loaded_effects.constBegin(); it != loaded_effects.constEnd(); ++it) {
+    for (QList<EffectPair>::const_iterator it = loaded_effects.constBegin(); it != loaded_effects.constEnd(); ++it) {
         if ((*it).second == effect) {
             effectName = (*it).first;
             break;
@@ -1320,8 +1320,8 @@ void EffectsHandlerImpl::effectsChanged()
 QStringList EffectsHandlerImpl::activeEffects() const
 {
     QStringList ret;
-    for (QVector<KWin::EffectPair>::const_iterator it = loaded_effects.constBegin(),
-                                                   end = loaded_effects.constEnd();
+    for (QList<KWin::EffectPair>::const_iterator it = loaded_effects.constBegin(),
+                                                 end = loaded_effects.constEnd();
          it != end; ++it) {
         if (it->second->isActive()) {
             ret << it->first;
@@ -1413,7 +1413,7 @@ bool EffectsHandlerImpl::isScreenLocked() const
 QString EffectsHandlerImpl::debug(const QString &name, const QString &parameter) const
 {
     QString internalName = name.toLower();
-    for (QVector<EffectPair>::const_iterator it = loaded_effects.constBegin(); it != loaded_effects.constEnd(); ++it) {
+    for (QList<EffectPair>::const_iterator it = loaded_effects.constBegin(); it != loaded_effects.constEnd(); ++it) {
         if ((*it).first == internalName) {
             return it->second->debug(parameter);
         }
@@ -1441,7 +1441,7 @@ bool EffectsHandlerImpl::animationsSupported() const
     return m_scene->animationsSupported();
 }
 
-void EffectsHandlerImpl::highlightWindows(const QVector<EffectWindow *> &windows)
+void EffectsHandlerImpl::highlightWindows(const QList<EffectWindow *> &windows)
 {
     Effect *e = provides(Effect::HighlightWindows);
     if (!e) {
@@ -1955,10 +1955,10 @@ qlonglong EffectWindowImpl::windowId() const
     return 0;
 }
 
-QVector<uint> EffectWindowImpl::desktops() const
+QList<uint> EffectWindowImpl::desktops() const
 {
     const auto desks = m_window->desktops();
-    QVector<uint> ids;
+    QList<uint> ids;
     ids.reserve(desks.count());
     std::transform(desks.constBegin(), desks.constEnd(), std::back_inserter(ids), [](const VirtualDesktop *vd) {
         return vd->x11DesktopNumber();
diff --git a/src/effects.h b/src/effects.h
index 2614e9883b..2785fbcddc 100644
--- a/src/effects.h
+++ b/src/effects.h
@@ -217,14 +217,14 @@ public:
     bool tabletPadStripEvent(int number, int position, bool isFinger, const KWin::TabletPadId &tabletPadId, std::chrono::microseconds time);
     bool tabletPadRingEvent(int number, int position, bool isFinger, const KWin::TabletPadId &tabletPadId, std::chrono::microseconds time);
 
-    void highlightWindows(const QVector<EffectWindow *> &windows);
+    void highlightWindows(const QList<EffectWindow *> &windows);
 
     bool isPropertyTypeRegistered(xcb_atom_t atom) const
     {
         return registered_atoms.contains(atom);
     }
 
-    void windowToDesktops(EffectWindow *w, const QVector<uint> &desktops) override;
+    void windowToDesktops(EffectWindow *w, const QList<uint> &desktops) override;
 
     /**
      * Finds an effect with the given name.
@@ -305,7 +305,7 @@ private:
     void registerPropertyType(long atom, bool reg);
     void destroyEffect(Effect *effect);
 
-    typedef QVector<Effect *> EffectsList;
+    typedef QList<Effect *> EffectsList;
     typedef EffectsList::const_iterator EffectsIterator;
     EffectsList m_activeEffects;
     EffectsIterator m_currentDrawWindowIterator;
@@ -371,7 +371,7 @@ public:
     double opacity() const override;
 
     QStringList activities() const override;
-    QVector<uint> desktops() const override;
+    QList<uint> desktops() const override;
     qreal x() const override;
     qreal y() const override;
     qreal width() const override;
diff --git a/src/gestures.h b/src/gestures.h
index 7c1acb2ca8..0309ae75af 100644
--- a/src/gestures.h
+++ b/src/gestures.h
@@ -11,10 +11,10 @@
 #include "libkwineffects/kwinglobals.h"
 #include <kwin_export.h>
 
+#include <QList>
 #include <QMap>
 #include <QObject>
 #include <QPointF>
-#include <QVector>
 
 namespace KWin
 {
@@ -203,10 +203,10 @@ private:
         None,
     };
     int startSwipeGesture(uint fingerCount, const QPointF &startPos, StartPositionBehavior startPosBehavior);
-    QVector<SwipeGesture *> m_swipeGestures;
-    QVector<PinchGesture *> m_pinchGestures;
-    QVector<SwipeGesture *> m_activeSwipeGestures;
-    QVector<PinchGesture *> m_activePinchGestures;
+    QList<SwipeGesture *> m_swipeGestures;
+    QList<PinchGesture *> m_pinchGestures;
+    QList<SwipeGesture *> m_activeSwipeGestures;
+    QList<PinchGesture *> m_activePinchGestures;
     QMap<Gesture *, QMetaObject::Connection> m_destroyConnections;
 
     QPointF m_currentDelta = QPointF(0, 0);
diff --git a/src/globalshortcuts.cpp b/src/globalshortcuts.cpp
index 179ceab00e..12a727f13e 100644
--- a/src/globalshortcuts.cpp
+++ b/src/globalshortcuts.cpp
@@ -220,7 +220,7 @@ bool GlobalShortcutsManager::processKeyRelease(Qt::KeyboardModifiers mods, int k
 }
 
 template<typename ShortcutKind, typename... Args>
-bool match(QVector<GlobalShortcut> &shortcuts, Args... args)
+bool match(QList<GlobalShortcut> &shortcuts, Args... args)
 {
     for (auto &sc : shortcuts) {
         if (std::holds_alternative<ShortcutKind>(sc.shortcut())) {
diff --git a/src/globalshortcuts.h b/src/globalshortcuts.h
index 5002baab6c..fd05b419f1 100644
--- a/src/globalshortcuts.h
+++ b/src/globalshortcuts.h
@@ -115,7 +115,7 @@ private:
     void objectDeleted(QObject *object);
     bool add(GlobalShortcut sc, DeviceType device = DeviceType::Touchpad);
 
-    QVector<GlobalShortcut> m_shortcuts;
+    QList<GlobalShortcut> m_shortcuts;
 
     std::unique_ptr<KGlobalAccelD> m_kglobalAccel;
     KGlobalAccelInterface *m_kglobalAccelInterface = nullptr;
diff --git a/src/idle_inhibition.h b/src/idle_inhibition.h
index 31d254887b..6c3492afe0 100644
--- a/src/idle_inhibition.h
+++ b/src/idle_inhibition.h
@@ -9,9 +9,9 @@
 */
 #pragma once
 
+#include <QList>
 #include <QMap>
 #include <QObject>
-#include <QVector>
 
 namespace KWin
 {
diff --git a/src/input.cpp b/src/input.cpp
index 53046bd744..7eb9c3bd0b 100644
--- a/src/input.cpp
+++ b/src/input.cpp
@@ -2159,7 +2159,7 @@ public:
             }
             return TabletToolV2Interface::Wheel;
         };
-        QVector<TabletToolV2Interface::Capability> ifaceCapabilities;
+        QList<TabletToolV2Interface::Capability> ifaceCapabilities;
         ifaceCapabilities.resize(tabletToolId.m_capabilities.size());
         std::transform(tabletToolId.m_capabilities.constBegin(), tabletToolId.m_capabilities.constEnd(), ifaceCapabilities.begin(), f);
 
diff --git a/src/input.h b/src/input.h
index 86ad9e8a49..4cf4bfbc48 100644
--- a/src/input.h
+++ b/src/input.h
@@ -327,8 +327,8 @@ private:
     QList<Window *> m_idleInhibitors;
     WindowSelectorFilter *m_windowSelector = nullptr;
 
-    QVector<InputEventFilter *> m_filters;
-    QVector<InputEventSpy *> m_spies;
+    QList<InputEventFilter *> m_filters;
+    QList<InputEventSpy *> m_spies;
     KConfigWatcher::Ptr m_inputConfigWatcher;
 
     LEDs m_leds;
diff --git a/src/input_event.h b/src/input_event.h
index 6cdf67dcec..7ec33bdc5f 100644
--- a/src/input_event.h
+++ b/src/input_event.h
@@ -204,7 +204,7 @@ class TabletToolId
 public:
     QString deviceSysName;
     InputRedirection::TabletToolType m_toolType;
-    QVector<InputRedirection::Capability> m_capabilities;
+    QList<InputRedirection::Capability> m_capabilities;
     quint64 m_serialId;
     quint64 m_uniqueId;
     void *m_deviceGroupData;
diff --git a/src/kcms/common/effectsmodel.cpp b/src/kcms/common/effectsmodel.cpp
index 6efaccb067..00e49294d8 100644
--- a/src/kcms/common/effectsmodel.cpp
+++ b/src/kcms/common/effectsmodel.cpp
@@ -32,7 +32,7 @@ namespace KWin
 
 static QString translatedCategory(const QString &category)
 {
-    static const QVector<QString> knownCategories = {
+    static const QList<QString> knownCategories = {
         QStringLiteral("Accessibility"),
         QStringLiteral("Appearance"),
         QStringLiteral("Focus"),
@@ -42,7 +42,7 @@ static QString translatedCategory(const QString &category)
         QStringLiteral("Window Management"),
         QStringLiteral("Window Open/Close Animation")};
 
-    static const QVector<QString> translatedCategories = {
+    static const QList<QString> translatedCategories = {
         i18nc("Category of Desktop Effects, used as section header", "Accessibility"),
         i18nc("Category of Desktop Effects, used as section header", "Appearance"),
         i18nc("Category of Desktop Effects, used as section header", "Focus"),
@@ -485,7 +485,7 @@ void EffectsModel::save()
 {
     KConfigGroup kwinConfig(KSharedConfig::openConfig("kwinrc"), "Plugins");
 
-    QVector<EffectData> dirtyEffects;
+    QList<EffectData> dirtyEffects;
 
     for (EffectData &effect : m_effects) {
         if (!effect.changed) {
diff --git a/src/kcms/common/effectsmodel.h b/src/kcms/common/effectsmodel.h
index 0ffc5128bd..5301ea4022 100644
--- a/src/kcms/common/effectsmodel.h
+++ b/src/kcms/common/effectsmodel.h
@@ -252,8 +252,8 @@ private:
     void loadJavascriptEffects(const KConfigGroup &kwinConfig);
     void loadPluginEffects(const KConfigGroup &kwinConfig);
 
-    QVector<EffectData> m_effects;
-    QVector<EffectData> m_pendingEffects;
+    QList<EffectData> m_effects;
+    QList<EffectData> m_pendingEffects;
     int m_lastSerial = -1;
 
     Q_DISABLE_COPY(EffectsModel)
diff --git a/src/kcms/compositing/main.cpp b/src/kcms/compositing/main.cpp
index d8cd7a900f..fc4355eb4b 100644
--- a/src/kcms/compositing/main.cpp
+++ b/src/kcms/compositing/main.cpp
@@ -55,7 +55,7 @@ private:
     KWinCompositingSetting *m_settings;
 };
 
-static const QVector<qreal> s_animationMultipliers = {8, 4, 2, 1, 0.5, 0.25, 0.125, 0};
+static const QList<qreal> s_animationMultipliers = {8, 4, 2, 1, 0.5, 0.25, 0.125, 0};
 
 bool KWinCompositingKCM::compositingRequired() const
 {
diff --git a/src/kcms/decoration/declarative-plugin/buttonsmodel.cpp b/src/kcms/decoration/declarative-plugin/buttonsmodel.cpp
index 1a4b12a52b..1e3573b6ff 100644
--- a/src/kcms/decoration/declarative-plugin/buttonsmodel.cpp
+++ b/src/kcms/decoration/declarative-plugin/buttonsmodel.cpp
@@ -15,23 +15,23 @@ namespace KDecoration2
 namespace Preview
 {
 
-ButtonsModel::ButtonsModel(const QVector<DecorationButtonType> &buttons, QObject *parent)
+ButtonsModel::ButtonsModel(const QList<DecorationButtonType> &buttons, QObject *parent)
     : QAbstractListModel(parent)
     , m_buttons(buttons)
 {
 }
 
 ButtonsModel::ButtonsModel(QObject *parent)
-    : ButtonsModel(QVector<DecorationButtonType>({DecorationButtonType::Menu,
-                                                  DecorationButtonType::ApplicationMenu,
-                                                  DecorationButtonType::OnAllDesktops,
-                                                  DecorationButtonType::Minimize,
-                                                  DecorationButtonType::Maximize,
-                                                  DecorationButtonType::Close,
-                                                  DecorationButtonType::ContextHelp,
-                                                  DecorationButtonType::Shade,
-                                                  DecorationButtonType::KeepBelow,
-                                                  DecorationButtonType::KeepAbove}),
+    : ButtonsModel(QList<DecorationButtonType>({DecorationButtonType::Menu,
+                                                DecorationButtonType::ApplicationMenu,
+                                                DecorationButtonType::OnAllDesktops,
+                                                DecorationButtonType::Minimize,
+                                                DecorationButtonType::Maximize,
+                                                DecorationButtonType::Close,
+                                                DecorationButtonType::ContextHelp,
+                                                DecorationButtonType::Shade,
+                                                DecorationButtonType::KeepBelow,
+                                                DecorationButtonType::KeepAbove}),
                    parent)
 {
 }
@@ -167,7 +167,7 @@ void ButtonsModel::clear()
     endResetModel();
 }
 
-void ButtonsModel::replace(const QVector<DecorationButtonType> &buttons)
+void ButtonsModel::replace(const QList<DecorationButtonType> &buttons)
 {
     if (buttons.isEmpty()) {
         return;
diff --git a/src/kcms/decoration/declarative-plugin/buttonsmodel.h b/src/kcms/decoration/declarative-plugin/buttonsmodel.h
index b05a1b7f15..1bd97c30e8 100644
--- a/src/kcms/decoration/declarative-plugin/buttonsmodel.h
+++ b/src/kcms/decoration/declarative-plugin/buttonsmodel.h
@@ -19,14 +19,14 @@ class ButtonsModel : public QAbstractListModel
 {
     Q_OBJECT
 public:
-    explicit ButtonsModel(const QVector<DecorationButtonType> &buttons, QObject *parent = nullptr);
+    explicit ButtonsModel(const QList<DecorationButtonType> &buttons, QObject *parent = nullptr);
     explicit ButtonsModel(QObject *parent = nullptr);
     ~ButtonsModel() override;
     QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
     int rowCount(const QModelIndex &parent = QModelIndex()) const override;
     QHash<int, QByteArray> roleNames() const override;
 
-    QVector<DecorationButtonType> buttons() const
+    QList<DecorationButtonType> buttons() const
     {
         return m_buttons;
     }
@@ -37,12 +37,12 @@ public:
     Q_INVOKABLE void down(int index);
     Q_INVOKABLE void move(int sourceIndex, int targetIndex);
 
-    void replace(const QVector<DecorationButtonType> &buttons);
+    void replace(const QList<DecorationButtonType> &buttons);
     void add(DecorationButtonType type);
     Q_INVOKABLE void add(int index, int type);
 
 private:
-    QVector<DecorationButtonType> m_buttons;
+    QList<DecorationButtonType> m_buttons;
 };
 
 }
diff --git a/src/kcms/decoration/declarative-plugin/previewsettings.cpp b/src/kcms/decoration/declarative-plugin/previewsettings.cpp
index c9f2a02aa0..04bd18aaad 100644
--- a/src/kcms/decoration/declarative-plugin/previewsettings.cpp
+++ b/src/kcms/decoration/declarative-plugin/previewsettings.cpp
@@ -56,25 +56,25 @@ PreviewSettings::PreviewSettings(DecorationSettings *parent)
     , m_alphaChannelSupported(true)
     , m_onAllDesktopsAvailable(true)
     , m_closeOnDoubleClick(false)
-    , m_leftButtons(new ButtonsModel(QVector<DecorationButtonType>({DecorationButtonType::Menu,
-                                                                    DecorationButtonType::ApplicationMenu,
-                                                                    DecorationButtonType::OnAllDesktops}),
+    , m_leftButtons(new ButtonsModel(QList<DecorationButtonType>({DecorationButtonType::Menu,
+                                                                  DecorationButtonType::ApplicationMenu,
+                                                                  DecorationButtonType::OnAllDesktops}),
                                      this))
-    , m_rightButtons(new ButtonsModel(QVector<DecorationButtonType>({DecorationButtonType::ContextHelp,
-                                                                     DecorationButtonType::Minimize,
-                                                                     DecorationButtonType::Maximize,
-                                                                     DecorationButtonType::Close}),
+    , m_rightButtons(new ButtonsModel(QList<DecorationButtonType>({DecorationButtonType::ContextHelp,
+                                                                   DecorationButtonType::Minimize,
+                                                                   DecorationButtonType::Maximize,
+                                                                   DecorationButtonType::Close}),
                                       this))
-    , m_availableButtons(new ButtonsModel(QVector<DecorationButtonType>({DecorationButtonType::Menu,
-                                                                         DecorationButtonType::ApplicationMenu,
-                                                                         DecorationButtonType::OnAllDesktops,
-                                                                         DecorationButtonType::Minimize,
-                                                                         DecorationButtonType::Maximize,
-                                                                         DecorationButtonType::Close,
-                                                                         DecorationButtonType::ContextHelp,
-                                                                         DecorationButtonType::Shade,
-                                                                         DecorationButtonType::KeepBelow,
-                                                                         DecorationButtonType::KeepAbove}),
+    , m_availableButtons(new ButtonsModel(QList<DecorationButtonType>({DecorationButtonType::Menu,
+                                                                       DecorationButtonType::ApplicationMenu,
+                                                                       DecorationButtonType::OnAllDesktops,
+                                                                       DecorationButtonType::Minimize,
+                                                                       DecorationButtonType::Maximize,
+                                                                       DecorationButtonType::Close,
+                                                                       DecorationButtonType::ContextHelp,
+                                                                       DecorationButtonType::Shade,
+                                                                       DecorationButtonType::KeepBelow,
+                                                                       DecorationButtonType::KeepAbove}),
                                           this))
     , m_borderSizes(new BorderSizesModel(this))
     , m_borderSize(int(BorderSize::Normal))
@@ -152,12 +152,12 @@ void PreviewSettings::setCloseOnDoubleClickOnMenu(bool enabled)
     Q_EMIT closeOnDoubleClickOnMenuChanged(enabled);
 }
 
-QVector<DecorationButtonType> PreviewSettings::decorationButtonsLeft() const
+QList<DecorationButtonType> PreviewSettings::decorationButtonsLeft() const
 {
     return m_leftButtons->buttons();
 }
 
-QVector<DecorationButtonType> PreviewSettings::decorationButtonsRight() const
+QList<DecorationButtonType> PreviewSettings::decorationButtonsRight() const
 {
     return m_rightButtons->buttons();
 }
diff --git a/src/kcms/decoration/declarative-plugin/previewsettings.h b/src/kcms/decoration/declarative-plugin/previewsettings.h
index 176759c990..8206b9e26d 100644
--- a/src/kcms/decoration/declarative-plugin/previewsettings.h
+++ b/src/kcms/decoration/declarative-plugin/previewsettings.h
@@ -76,8 +76,8 @@ public:
         return m_borderSizes;
     }
 
-    QVector<DecorationButtonType> decorationButtonsLeft() const override;
-    QVector<DecorationButtonType> decorationButtonsRight() const override;
+    QList<DecorationButtonType> decorationButtonsLeft() const override;
+    QList<DecorationButtonType> decorationButtonsRight() const override;
 
     Q_INVOKABLE void addButtonToLeft(int row);
     Q_INVOKABLE void addButtonToRight(int row);
diff --git a/src/kcms/decoration/utils.h b/src/kcms/decoration/utils.h
index 2a1dbca69a..2f25801673 100644
--- a/src/kcms/decoration/utils.h
+++ b/src/kcms/decoration/utils.h
@@ -9,9 +9,9 @@
 #include <KDecoration2/DecorationButton>
 #include <KSharedConfig>
 
-#include <QVector>
+#include <QList>
 
-using DecorationButtonsList = QVector<KDecoration2::DecorationButtonType>;
+using DecorationButtonsList = QList<KDecoration2::DecorationButtonType>;
 
 namespace Utils
 {
diff --git a/src/kcms/desktop/desktopsmodel.cpp b/src/kcms/desktop/desktopsmodel.cpp
index fcc633f91f..eea367bea1 100644
--- a/src/kcms/desktop/desktopsmodel.cpp
+++ b/src/kcms/desktop/desktopsmodel.cpp
@@ -173,7 +173,7 @@ void DesktopsModel::setRows(int rows)
         m_rows = rows;
 
         Q_EMIT rowsChanged();
-        Q_EMIT dataChanged(index(0, 0), index(m_desktops.count() - 1, 0), QVector<int>{DesktopRow});
+        Q_EMIT dataChanged(index(0, 0), index(m_desktops.count() - 1, 0), QList<int>{DesktopRow});
 
         updateModifiedState();
     }
@@ -243,7 +243,7 @@ void DesktopsModel::setDesktopName(const QString &id, const QString &name)
 
     const QModelIndex &idx = index(m_desktops.indexOf(id), 0);
 
-    Q_EMIT dataChanged(idx, idx, QVector<int>{Qt::DisplayRole});
+    Q_EMIT dataChanged(idx, idx, QList<int>{Qt::DisplayRole});
 
     updateModifiedState();
 }
@@ -320,7 +320,7 @@ void DesktopsModel::syncWithServer()
         m_names[newId] = m_names.take(oldId);
     }
 
-    Q_EMIT dataChanged(index(0, 0), index(rowCount() - 1, 0), QVector<int>{Qt::DisplayRole});
+    Q_EMIT dataChanged(index(0, 0), index(rowCount() - 1, 0), QList<int>{Qt::DisplayRole});
 
     // Sync names.
     if (m_names != m_serverSideNames) {
@@ -557,7 +557,7 @@ void DesktopsModel::desktopCreated(const QString &id, const KWin::DBusDesktopDat
         m_names.remove(dummyId);
         m_names[id] = data.name;
         const QModelIndex &idx = index(data.position, 0);
-        Q_EMIT dataChanged(idx, idx, QVector<int>{Id});
+        Q_EMIT dataChanged(idx, idx, QList<int>{Id});
 
         updateModifiedState(/* server */ true);
     }
@@ -597,7 +597,7 @@ void DesktopsModel::desktopDataChanged(const QString &id, const KWin::DBusDeskto
 
         const QModelIndex &idx = index(desktopIndex, 0);
 
-        Q_EMIT dataChanged(idx, idx, QVector<int>{Qt::DisplayRole});
+        Q_EMIT dataChanged(idx, idx, QList<int>{Qt::DisplayRole});
     } else {
         updateModifiedState(/* server */ true);
     }
@@ -617,7 +617,7 @@ void DesktopsModel::desktopRowsChanged(uint rows)
         m_rows = m_serverSideRows;
 
         Q_EMIT rowsChanged();
-        Q_EMIT dataChanged(index(0, 0), index(m_desktops.count() - 1, 0), QVector<int>{DesktopRow});
+        Q_EMIT dataChanged(index(0, 0), index(m_desktops.count() - 1, 0), QList<int>{DesktopRow});
     } else {
         updateModifiedState(/* server */ true);
     }
@@ -640,7 +640,7 @@ void DesktopsModel::updateModifiedState(bool server)
             m_names[newId] = m_names.take(oldId);
         }
 
-        Q_EMIT dataChanged(index(0, 0), index(rowCount() - 1, 0), QVector<int>{Qt::DisplayRole});
+        Q_EMIT dataChanged(index(0, 0), index(rowCount() - 1, 0), QList<int>{Qt::DisplayRole});
     }
 
     if (m_desktops == m_serverSideDesktops
diff --git a/src/kcms/rules/rulesmodel.cpp b/src/kcms/rules/rulesmodel.cpp
index b3532a7168..b323595b80 100644
--- a/src/kcms/rules/rulesmodel.cpp
+++ b/src/kcms/rules/rulesmodel.cpp
@@ -154,7 +154,7 @@ bool RulesModel::setData(const QModelIndex &index, const QVariant &value, int ro
 
     writeToSettings(rule);
 
-    Q_EMIT dataChanged(index, index, QVector<int>{role});
+    Q_EMIT dataChanged(index, index, QList<int>{role});
     if (rule->hasFlag(RuleItem::AffectsDescription)) {
         Q_EMIT descriptionChanged();
     }
diff --git a/src/kcms/screenedges/monitor.h b/src/kcms/screenedges/monitor.h
index 68d38de583..c167de5684 100644
--- a/src/kcms/screenedges/monitor.h
+++ b/src/kcms/screenedges/monitor.h
@@ -14,7 +14,7 @@
 
 #include <QActionGroup>
 #include <QGraphicsItem>
-#include <QVector>
+#include <QList>
 #include <array>
 #include <memory>
 
@@ -77,7 +77,7 @@ private:
     std::array<std::unique_ptr<Corner>, 8> m_items;
     std::array<bool, 8> m_hidden;
     std::array<std::unique_ptr<QMenu>, 8> m_popups;
-    std::array<QVector<QAction *>, 8> m_popupActions;
+    std::array<QList<QAction *>, 8> m_popupActions;
     std::array<std::unique_ptr<QActionGroup>, 8> m_actionGroups;
 };
 
diff --git a/src/kcms/scripts/kwinscriptsdata.cpp b/src/kcms/scripts/kwinscriptsdata.cpp
index 4ed8106e62..125cfdddcd 100644
--- a/src/kcms/scripts/kwinscriptsdata.cpp
+++ b/src/kcms/scripts/kwinscriptsdata.cpp
@@ -18,7 +18,7 @@ KWinScriptsData::KWinScriptsData(QObject *parent)
 {
 }
 
-QVector<KPluginMetaData> KWinScriptsData::pluginMetaDataList() const
+QList<KPluginMetaData> KWinScriptsData::pluginMetaDataList() const
 {
     const QString scriptFolder = QStringLiteral("kwin/scripts/");
     return KPackage::PackageLoader::self()->findPackages(QStringLiteral("KWin/Script"), scriptFolder);
@@ -26,7 +26,7 @@ QVector<KPluginMetaData> KWinScriptsData::pluginMetaDataList() const
 
 bool KWinScriptsData::isDefaults() const
 {
-    QVector<KPluginMetaData> plugins = pluginMetaDataList();
+    QList<KPluginMetaData> plugins = pluginMetaDataList();
     KConfigGroup cfgGroup(m_kwinConfig, "Plugins");
     for (auto &plugin : plugins) {
         if (cfgGroup.readEntry(plugin.pluginId() + QLatin1String("Enabled"), plugin.isEnabledByDefault()) != plugin.isEnabledByDefault()) {
diff --git a/src/kcms/scripts/kwinscriptsdata.h b/src/kcms/scripts/kwinscriptsdata.h
index 1bbcabf852..b34b4c7adc 100644
--- a/src/kcms/scripts/kwinscriptsdata.h
+++ b/src/kcms/scripts/kwinscriptsdata.h
@@ -6,8 +6,8 @@
 
 #pragma once
 
+#include <QList>
 #include <QObject>
-#include <QVector>
 
 #include <KCModuleData>
 #include <KPluginMetaData>
@@ -22,7 +22,7 @@ public:
 
     bool isDefaults() const override;
 
-    QVector<KPluginMetaData> pluginMetaDataList() const;
+    QList<KPluginMetaData> pluginMetaDataList() const;
 
 private:
     KSharedConfigPtr m_kwinConfig;
diff --git a/src/keyboard_layout.cpp b/src/keyboard_layout.cpp
index 4bba404365..0cae7ea8f2 100644
--- a/src/keyboard_layout.cpp
+++ b/src/keyboard_layout.cpp
@@ -204,9 +204,9 @@ KeyboardLayoutDBusInterface::KeyboardLayoutDBusInterface(Xkb *xkb, const KConfig
     , m_configGroup(configGroup)
     , m_keyboardLayout(parent)
 {
-    qRegisterMetaType<QVector<LayoutNames>>("QVector<LayoutNames>");
+    qRegisterMetaType<QList<LayoutNames>>("QList<LayoutNames>");
     qDBusRegisterMetaType<LayoutNames>();
-    qDBusRegisterMetaType<QVector<LayoutNames>>();
+    qDBusRegisterMetaType<QList<LayoutNames>>();
 
     QDBusConnection::sessionBus().registerObject(s_keyboardObject, this, QDBusConnection::ExportAllSlots | QDBusConnection::ExportAllSignals);
     QDBusConnection::sessionBus().registerService(s_keyboardService);
@@ -242,12 +242,12 @@ uint KeyboardLayoutDBusInterface::getLayout() const
     return m_xkb->currentLayout();
 }
 
-QVector<KeyboardLayoutDBusInterface::LayoutNames> KeyboardLayoutDBusInterface::getLayoutsList() const
+QList<KeyboardLayoutDBusInterface::LayoutNames> KeyboardLayoutDBusInterface::getLayoutsList() const
 {
     // TODO: - should be handled by layout applet itself, it has nothing to do with KWin
     const QStringList displayNames = m_configGroup.readEntry("DisplayNames", QStringList());
 
-    QVector<LayoutNames> ret;
+    QList<LayoutNames> ret;
     const int layoutsSize = m_xkb->numberOfLayouts();
     const int displayNamesSize = displayNames.size();
     for (int i = 0; i < layoutsSize; ++i) {
diff --git a/src/keyboard_layout.h b/src/keyboard_layout.h
index 801ea0e9ee..53378d1bcb 100644
--- a/src/keyboard_layout.h
+++ b/src/keyboard_layout.h
@@ -9,8 +9,8 @@
 #pragma once
 
 #include "input_event_spy.h"
+#include <QList>
 #include <QObject>
-#include <QVector>
 #include <memory>
 #include <optional>
 
@@ -62,7 +62,7 @@ private:
     Xkb *m_xkb;
     xkb_layout_index_t m_layout = 0;
     KConfigGroup m_configGroup;
-    QVector<QAction *> m_layoutShortcuts;
+    QList<QAction *> m_layoutShortcuts;
     KeyboardLayoutDBusInterface *m_dbusInterface = nullptr;
     std::unique_ptr<KeyboardLayoutSwitching::Policy> m_policy;
     std::optional<uint> m_lastUsedLayout;
@@ -89,7 +89,7 @@ public Q_SLOTS:
     void switchToPreviousLayout();
     bool setLayout(uint index);
     uint getLayout() const;
-    QVector<LayoutNames> getLayoutsList() const;
+    QList<LayoutNames> getLayoutsList() const;
 
 Q_SIGNALS:
     void layoutChanged(uint index);
diff --git a/src/kscreenintegration.cpp b/src/kscreenintegration.cpp
index 9c8a3ae026..c038a50bc1 100644
--- a/src/kscreenintegration.cpp
+++ b/src/kscreenintegration.cpp
@@ -35,7 +35,7 @@ static QString outputHash(Output *output)
 }
 
 /// See KScreen::Config::connectedOutputsHash in libkscreen
-QString connectedOutputsHash(const QVector<Output *> &outputs, bool isLidClosed)
+QString connectedOutputsHash(const QList<Output *> &outputs, bool isLidClosed)
 {
     QStringList hashedOutputs;
     hashedOutputs.reserve(outputs.count());
@@ -53,7 +53,7 @@ QString connectedOutputsHash(const QVector<Output *> &outputs, bool isLidClosed)
     return QString::fromLatin1(hash.toHex());
 }
 
-static QMap<Output *, QJsonObject> outputsConfig(const QVector<Output *> &outputs, const QString &hash)
+static QMap<Output *, QJsonObject> outputsConfig(const QList<Output *> &outputs, const QString &hash)
 {
     const QString kscreenJsonPath = QStandardPaths::locate(QStandardPaths::GenericDataLocation, QStringLiteral("kscreen/") % hash);
     if (kscreenJsonPath.isEmpty()) {
@@ -177,7 +177,7 @@ std::shared_ptr<OutputMode> parseMode(Output *output, const QJsonObject &modeInf
     return (it != modes.end()) ? *it : nullptr;
 }
 
-std::optional<std::pair<OutputConfiguration, QVector<Output *>>> readOutputConfig(const QVector<Output *> &outputs, const QString &hash)
+std::optional<std::pair<OutputConfiguration, QList<Output *>>> readOutputConfig(const QList<Output *> &outputs, const QString &hash)
 {
     const auto outputsInfo = outputsConfig(outputs, hash);
     if (outputsInfo.isEmpty()) {
@@ -270,7 +270,7 @@ std::optional<std::pair<OutputConfiguration, QVector<Output *>>> readOutputConfi
         }
     });
 
-    QVector<Output *> order;
+    QList<Output *> order;
     order.reserve(outputOrder.size());
     std::transform(outputOrder.begin(), outputOrder.end(), std::back_inserter(order), [](const auto &pair) {
         return pair.second;
diff --git a/src/kscreenintegration.h b/src/kscreenintegration.h
index 96c0569ce9..a99dcc2524 100644
--- a/src/kscreenintegration.h
+++ b/src/kscreenintegration.h
@@ -10,7 +10,7 @@
 #include "core/output.h"
 #include "core/outputconfiguration.h"
 
-#include <QVector>
+#include <QList>
 #include <optional>
 
 namespace KWin
@@ -18,7 +18,7 @@ namespace KWin
 namespace KScreenIntegration
 {
 
-QString connectedOutputsHash(const QVector<Output *> &outputs, bool isLidClosed);
-std::optional<std::pair<OutputConfiguration, QVector<Output *>>> readOutputConfig(const QVector<Output *> &outputs, const QString &hash);
+QString connectedOutputsHash(const QList<Output *> &outputs, bool isLidClosed);
+std::optional<std::pair<OutputConfiguration, QList<Output *>>> readOutputConfig(const QList<Output *> &outputs, const QString &hash);
 }
 }
diff --git a/src/layers.cpp b/src/layers.cpp
index 9a20dc46a4..10a73905ac 100644
--- a/src/layers.cpp
+++ b/src/layers.cpp
@@ -130,7 +130,7 @@ void Workspace::stackScreenEdgesUnderOverrideRedirect()
     if (!rootInfo()) {
         return;
     }
-    Xcb::restackWindows(QVector<xcb_window_t>() << rootInfo()->supportWindow() << workspace()->screenEdges()->windows());
+    Xcb::restackWindows(QList<xcb_window_t>() << rootInfo()->supportWindow() << workspace()->screenEdges()->windows());
 }
 
 /**
@@ -144,7 +144,7 @@ void Workspace::propagateWindows(bool propagate_new_windows)
     }
     // restack the windows according to the stacking order
     // supportWindow > electric borders > windows > hidden windows
-    QVector<xcb_window_t> newWindowStack;
+    QList<xcb_window_t> newWindowStack;
 
     // Stack all windows under the support window. The support window is
     // not used for anything (besides the NETWM property), and it's not shown,
@@ -188,7 +188,7 @@ void Workspace::propagateWindows(bool propagate_new_windows)
     Q_ASSERT(newWindowStack.at(0) == rootInfo()->supportWindow());
     Xcb::restackWindows(newWindowStack);
 
-    QVector<xcb_window_t> cl;
+    QList<xcb_window_t> cl;
     if (propagate_new_windows) {
         cl.reserve(manual_overlays.size() + m_windows.size());
         for (const auto win : std::as_const(manual_overlays)) {
diff --git a/src/libkwineffects/kwineffects.cpp b/src/libkwineffects/kwineffects.cpp
index 7ed401d363..dcf4b75dc5 100644
--- a/src/libkwineffects/kwineffects.cpp
+++ b/src/libkwineffects/kwineffects.cpp
@@ -700,7 +700,7 @@ bool EffectWindow::isOnCurrentDesktop() const
 
 bool EffectWindow::isOnDesktop(int d) const
 {
-    const QVector<uint> ds = desktops();
+    const QList<uint> ds = desktops();
     return ds.isEmpty() || ds.contains(d);
 }
 
diff --git a/src/libkwineffects/kwineffects.h b/src/libkwineffects/kwineffects.h
index b1b229acfd..df16d3b1a4 100644
--- a/src/libkwineffects/kwineffects.h
+++ b/src/libkwineffects/kwineffects.h
@@ -29,7 +29,6 @@
 #include <QList>
 #include <QLoggingCategory>
 #include <QStack>
-#include <QVector>
 
 #include <KPluginFactory>
 #include <KSharedConfig>
@@ -981,7 +980,7 @@ public:
      *
      * @arg desktopIds a list of desktops the window should be placed on. NET::OnAllDesktops is not a valid desktop X11Id
      */
-    Q_SCRIPTABLE virtual void windowToDesktops(KWin::EffectWindow *w, const QVector<uint> &desktopIds) = 0;
+    Q_SCRIPTABLE virtual void windowToDesktops(KWin::EffectWindow *w, const QList<uint> &desktopIds) = 0;
 
     Q_SCRIPTABLE virtual void windowToScreen(KWin::EffectWindow *w, EffectScreen *screen) = 0;
     virtual void setShowingDesktop(bool showing) = 0;
@@ -1698,7 +1697,7 @@ Q_SIGNALS:
     void inputPanelChanged();
 
 protected:
-    QVector<EffectPair> loaded_effects;
+    QList<EffectPair> loaded_effects;
     // QHash< QString, EffectFactory* > effect_factories;
     CompositingType compositing_type;
 };
@@ -1817,7 +1816,7 @@ class KWINEFFECTS_EXPORT EffectWindow : public QObject
     Q_PROPERTY(qreal width READ width)
     Q_PROPERTY(qreal x READ x)
     Q_PROPERTY(qreal y READ y)
-    Q_PROPERTY(QVector<uint> desktops READ desktops)
+    Q_PROPERTY(QList<uint> desktops READ desktops)
     Q_PROPERTY(bool onAllDesktops READ isOnAllDesktops)
     Q_PROPERTY(bool onCurrentDesktop READ isOnCurrentDesktop)
     Q_PROPERTY(QRectF rect READ rect)
@@ -2135,7 +2134,7 @@ public:
      * a length of 1, on Wayland can be any subset.
      * If the list is empty it means the window is on all desktops
      */
-    virtual QVector<uint> desktops() const = 0;
+    virtual QList<uint> desktops() const = 0;
 
     virtual qreal x() const = 0;
     virtual qreal y() const = 0;
@@ -2813,7 +2812,7 @@ private:
 };
 
 class KWINEFFECTS_EXPORT WindowQuadList
-    : public QVector<WindowQuad>
+    : public QList<WindowQuad>
 {
 public:
     WindowQuadList splitAtX(double x) const;
@@ -2829,7 +2828,7 @@ public:
  * for easily converting from WindowQuad and related classes to lists of
  * GLVertex2D. This class assumes rendering happens as unindexed triangles.
  */
-class KWINEFFECTS_EXPORT RenderGeometry : public QVector<GLVertex2D>
+class KWINEFFECTS_EXPORT RenderGeometry : public QList<GLVertex2D>
 {
 public:
     /**
diff --git a/src/main.cpp b/src/main.cpp
index 65c71b9ea5..e17d5a181e 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -410,25 +410,25 @@ void Application::unregisterEventFilter(X11EventFilter *filter)
 
 bool Application::dispatchEvent(xcb_generic_event_t *event)
 {
-    static const QVector<QByteArray> s_xcbEerrors({QByteArrayLiteral("Success"),
-                                                   QByteArrayLiteral("BadRequest"),
-                                                   QByteArrayLiteral("BadValue"),
-                                                   QByteArrayLiteral("BadWindow"),
-                                                   QByteArrayLiteral("BadPixmap"),
-                                                   QByteArrayLiteral("BadAtom"),
-                                                   QByteArrayLiteral("BadCursor"),
-                                                   QByteArrayLiteral("BadFont"),
-                                                   QByteArrayLiteral("BadMatch"),
-                                                   QByteArrayLiteral("BadDrawable"),
-                                                   QByteArrayLiteral("BadAccess"),
-                                                   QByteArrayLiteral("BadAlloc"),
-                                                   QByteArrayLiteral("BadColor"),
-                                                   QByteArrayLiteral("BadGC"),
-                                                   QByteArrayLiteral("BadIDChoice"),
-                                                   QByteArrayLiteral("BadName"),
-                                                   QByteArrayLiteral("BadLength"),
-                                                   QByteArrayLiteral("BadImplementation"),
-                                                   QByteArrayLiteral("Unknown")});
+    static const QList<QByteArray> s_xcbEerrors({QByteArrayLiteral("Success"),
+                                                 QByteArrayLiteral("BadRequest"),
+                                                 QByteArrayLiteral("BadValue"),
+                                                 QByteArrayLiteral("BadWindow"),
+                                                 QByteArrayLiteral("BadPixmap"),
+                                                 QByteArrayLiteral("BadAtom"),
+                                                 QByteArrayLiteral("BadCursor"),
+                                                 QByteArrayLiteral("BadFont"),
+                                                 QByteArrayLiteral("BadMatch"),
+                                                 QByteArrayLiteral("BadDrawable"),
+                                                 QByteArrayLiteral("BadAccess"),
+                                                 QByteArrayLiteral("BadAlloc"),
+                                                 QByteArrayLiteral("BadColor"),
+                                                 QByteArrayLiteral("BadGC"),
+                                                 QByteArrayLiteral("BadIDChoice"),
+                                                 QByteArrayLiteral("BadName"),
+                                                 QByteArrayLiteral("BadLength"),
+                                                 QByteArrayLiteral("BadImplementation"),
+                                                 QByteArrayLiteral("Unknown")});
 
     kwinApp()->updateX11Time(event);
 
@@ -436,7 +436,7 @@ bool Application::dispatchEvent(xcb_generic_event_t *event)
     if (!x11EventType) {
         // let's check whether it's an error from one of the extensions KWin uses
         xcb_generic_error_t *error = reinterpret_cast<xcb_generic_error_t *>(event);
-        const QVector<Xcb::ExtensionData> extensions = Xcb::Extensions::self()->extensions();
+        const QList<Xcb::ExtensionData> extensions = Xcb::Extensions::self()->extensions();
         for (const auto &extension : extensions) {
             if (error->major_code == extension.majorOpcode) {
                 QByteArray errorName;
diff --git a/src/main_wayland.h b/src/main_wayland.h
index 9ce60ab04f..3a387dda33 100644
--- a/src/main_wayland.h
+++ b/src/main_wayland.h
@@ -70,7 +70,7 @@ private:
     QString m_sessionArgument;
 
     std::unique_ptr<Xwl::Xwayland> m_xwayland;
-    QVector<int> m_xwaylandListenFds;
+    QList<int> m_xwaylandListenFds;
     QString m_xwaylandDisplay;
     QString m_xwaylandXauthority;
     KConfigWatcher::Ptr m_settingsWatcher;
diff --git a/src/moving_client_x11_filter.cpp b/src/moving_client_x11_filter.cpp
index 456c57db79..f0e88489f8 100644
--- a/src/moving_client_x11_filter.cpp
+++ b/src/moving_client_x11_filter.cpp
@@ -16,7 +16,7 @@ namespace KWin
 {
 
 MovingClientX11Filter::MovingClientX11Filter()
-    : X11EventFilter(QVector<int>{XCB_KEY_PRESS, XCB_MOTION_NOTIFY, XCB_BUTTON_PRESS, XCB_BUTTON_RELEASE})
+    : X11EventFilter(QList<int>{XCB_KEY_PRESS, XCB_MOTION_NOTIFY, XCB_BUTTON_PRESS, XCB_BUTTON_RELEASE})
 {
 }
 
diff --git a/src/outputconfigurationstore.cpp b/src/outputconfigurationstore.cpp
index 7a5e5fffca..810a13c3b0 100644
--- a/src/outputconfigurationstore.cpp
+++ b/src/outputconfigurationstore.cpp
@@ -35,9 +35,9 @@ OutputConfigurationStore::~OutputConfigurationStore()
     save();
 }
 
-std::optional<std::tuple<OutputConfiguration, QVector<Output *>, OutputConfigurationStore::ConfigType>> OutputConfigurationStore::queryConfig(const QVector<Output *> &outputs, bool isLidClosed, QOrientationReading *orientation, bool isTabletMode)
+std::optional<std::tuple<OutputConfiguration, QList<Output *>, OutputConfigurationStore::ConfigType>> OutputConfigurationStore::queryConfig(const QList<Output *> &outputs, bool isLidClosed, QOrientationReading *orientation, bool isTabletMode)
 {
-    QVector<Output *> relevantOutputs;
+    QList<Output *> relevantOutputs;
     std::copy_if(outputs.begin(), outputs.end(), std::back_inserter(relevantOutputs), [](Output *output) {
         return !output->isNonDesktop() && !output->isPlaceholder();
     });
@@ -63,7 +63,7 @@ std::optional<std::tuple<OutputConfiguration, QVector<Output *>, OutputConfigura
     return std::make_tuple(config, order, ConfigType::Generated);
 }
 
-void OutputConfigurationStore::applyOrientationReading(OutputConfiguration &config, const QVector<Output *> &outputs, QOrientationReading *orientation, bool isTabletMode)
+void OutputConfigurationStore::applyOrientationReading(OutputConfiguration &config, const QList<Output *> &outputs, QOrientationReading *orientation, bool isTabletMode)
 {
     const auto output = std::find_if(outputs.begin(), outputs.end(), [&config](Output *output) {
         return output->isInternal() && config.changeSet(output)->enabled.value_or(output->isEnabled());
@@ -99,7 +99,7 @@ void OutputConfigurationStore::applyOrientationReading(OutputConfiguration &conf
     }
 }
 
-std::optional<std::pair<OutputConfigurationStore::Setup *, std::unordered_map<Output *, size_t>>> OutputConfigurationStore::findSetup(const QVector<Output *> &outputs, bool lidClosed)
+std::optional<std::pair<OutputConfigurationStore::Setup *, std::unordered_map<Output *, size_t>>> OutputConfigurationStore::findSetup(const QList<Output *> &outputs, bool lidClosed)
 {
     std::unordered_map<Output *, size_t> outputStates;
     for (Output *output : outputs) {
@@ -126,7 +126,7 @@ std::optional<std::pair<OutputConfigurationStore::Setup *, std::unordered_map<Ou
     }
 }
 
-std::optional<size_t> OutputConfigurationStore::findOutput(Output *output, const QVector<Output *> &allOutputs) const
+std::optional<size_t> OutputConfigurationStore::findOutput(Output *output, const QList<Output *> &allOutputs) const
 {
     const bool hasDuplicate = std::any_of(allOutputs.begin(), allOutputs.end(), [output](Output *otherOutput) {
         return otherOutput != output && otherOutput->edid().identifier() == output->edid().identifier();
@@ -142,9 +142,9 @@ std::optional<size_t> OutputConfigurationStore::findOutput(Output *output, const
     }
 }
 
-void OutputConfigurationStore::storeConfig(const QVector<Output *> &allOutputs, bool isLidClosed, const OutputConfiguration &config, const QVector<Output *> &outputOrder)
+void OutputConfigurationStore::storeConfig(const QList<Output *> &allOutputs, bool isLidClosed, const OutputConfiguration &config, const QList<Output *> &outputOrder)
 {
-    QVector<Output *> relevantOutputs;
+    QList<Output *> relevantOutputs;
     std::copy_if(allOutputs.begin(), allOutputs.end(), std::back_inserter(relevantOutputs), [](Output *output) {
         return !output->isNonDesktop() && !output->isPlaceholder();
     });
@@ -233,10 +233,10 @@ void OutputConfigurationStore::storeConfig(const QVector<Output *> &allOutputs,
     save();
 }
 
-std::pair<OutputConfiguration, QVector<Output *>> OutputConfigurationStore::setupToConfig(Setup *setup, const std::unordered_map<Output *, size_t> &outputMap) const
+std::pair<OutputConfiguration, QList<Output *>> OutputConfigurationStore::setupToConfig(Setup *setup, const std::unordered_map<Output *, size_t> &outputMap) const
 {
     OutputConfiguration ret;
-    QVector<std::pair<Output *, size_t>> priorities;
+    QList<std::pair<Output *, size_t>> priorities;
     for (const auto &[output, outputIndex] : outputMap) {
         const OutputState &state = m_outputs[outputIndex];
         const auto &setupState = *std::find_if(setup->outputs.begin(), setup->outputs.end(), [outputIndex = outputIndex](const auto &state) {
@@ -270,14 +270,14 @@ std::pair<OutputConfiguration, QVector<Output *>> OutputConfigurationStore::setu
     std::sort(priorities.begin(), priorities.end(), [](const auto &left, const auto &right) {
         return left.second < right.second;
     });
-    QVector<Output *> order;
+    QList<Output *> order;
     std::transform(priorities.begin(), priorities.end(), std::back_inserter(order), [](const auto &pair) {
         return pair.first;
     });
     return std::make_pair(ret, order);
 }
 
-std::optional<std::pair<OutputConfiguration, QVector<Output *>>> OutputConfigurationStore::generateLidClosedConfig(const QVector<Output *> &outputs)
+std::optional<std::pair<OutputConfiguration, QList<Output *>>> OutputConfigurationStore::generateLidClosedConfig(const QList<Output *> &outputs)
 {
     const auto internalIt = std::find_if(outputs.begin(), outputs.end(), [](Output *output) {
         return output->isInternal();
@@ -338,7 +338,7 @@ std::optional<std::pair<OutputConfiguration, QVector<Output *>>> OutputConfigura
     return std::make_pair(config, order);
 }
 
-std::pair<OutputConfiguration, QVector<Output *>> OutputConfigurationStore::generateConfig(const QVector<Output *> &outputs, bool isLidClosed)
+std::pair<OutputConfiguration, QList<Output *>> OutputConfigurationStore::generateConfig(const QList<Output *> &outputs, bool isLidClosed)
 {
     if (isLidClosed) {
         if (const auto closedConfig = generateLidClosedConfig(outputs)) {
@@ -346,7 +346,7 @@ std::pair<OutputConfiguration, QVector<Output *>> OutputConfigurationStore::gene
         }
     }
     OutputConfiguration ret;
-    QVector<Output *> outputOrder;
+    QList<Output *> outputOrder;
     QPoint pos(0, 0);
     for (const auto output : outputs) {
         const auto outputIndex = findOutput(output, outputs);
@@ -843,7 +843,7 @@ void OutputConfigurationStore::save()
     f.flush();
 }
 
-bool OutputConfigurationStore::isAutoRotateActive(const QVector<Output *> &outputs, bool isTabletMode) const
+bool OutputConfigurationStore::isAutoRotateActive(const QList<Output *> &outputs, bool isTabletMode) const
 {
     const auto internalIt = std::find_if(outputs.begin(), outputs.end(), [](Output *output) {
         return output->isInternal() && output->isEnabled();
diff --git a/src/outputconfigurationstore.h b/src/outputconfigurationstore.h
index 1e641fef6d..125b9531df 100644
--- a/src/outputconfigurationstore.h
+++ b/src/outputconfigurationstore.h
@@ -10,9 +10,9 @@
 
 #include "core/output.h"
 
+#include <QList>
 #include <QPoint>
 #include <QSize>
-#include <QVector>
 #include <memory>
 #include <optional>
 #include <tuple>
@@ -35,16 +35,16 @@ public:
         Preexisting,
         Generated,
     };
-    std::optional<std::tuple<OutputConfiguration, QVector<Output *>, ConfigType>> queryConfig(const QVector<Output *> &outputs, bool isLidClosed, QOrientationReading *orientation, bool isTabletMode);
+    std::optional<std::tuple<OutputConfiguration, QList<Output *>, ConfigType>> queryConfig(const QList<Output *> &outputs, bool isLidClosed, QOrientationReading *orientation, bool isTabletMode);
 
-    void storeConfig(const QVector<Output *> &allOutputs, bool isLidClosed, const OutputConfiguration &config, const QVector<Output *> &outputOrder);
+    void storeConfig(const QList<Output *> &allOutputs, bool isLidClosed, const OutputConfiguration &config, const QList<Output *> &outputOrder);
 
-    bool isAutoRotateActive(const QVector<Output *> &outputs, bool isTabletMode) const;
+    bool isAutoRotateActive(const QList<Output *> &outputs, bool isTabletMode) const;
 
 private:
-    void applyOrientationReading(OutputConfiguration &config, const QVector<Output *> &outputs, QOrientationReading *orientation, bool isTabletMode);
-    std::optional<std::pair<OutputConfiguration, QVector<Output *>>> generateLidClosedConfig(const QVector<Output *> &outputs);
-    std::pair<OutputConfiguration, QVector<Output *>> generateConfig(const QVector<Output *> &outputs, bool isLidClosed);
+    void applyOrientationReading(OutputConfiguration &config, const QList<Output *> &outputs, QOrientationReading *orientation, bool isTabletMode);
+    std::optional<std::pair<OutputConfiguration, QList<Output *>>> generateLidClosedConfig(const QList<Output *> &outputs);
+    std::pair<OutputConfiguration, QList<Output *>> generateConfig(const QList<Output *> &outputs, bool isLidClosed);
     std::shared_ptr<OutputMode> chooseMode(Output *output) const;
     double chooseScale(Output *output, OutputMode *mode) const;
     double targetDpi(Output *output) const;
@@ -84,14 +84,14 @@ private:
     struct Setup
     {
         bool lidClosed = false;
-        QVector<SetupState> outputs;
+        QList<SetupState> outputs;
     };
 
-    std::pair<OutputConfiguration, QVector<Output *>> setupToConfig(Setup *setup, const std::unordered_map<Output *, size_t> &outputMap) const;
-    std::optional<std::pair<Setup *, std::unordered_map<Output *, size_t>>> findSetup(const QVector<Output *> &outputs, bool lidClosed);
-    std::optional<size_t> findOutput(Output *output, const QVector<Output *> &allOutputs) const;
+    std::pair<OutputConfiguration, QList<Output *>> setupToConfig(Setup *setup, const std::unordered_map<Output *, size_t> &outputMap) const;
+    std::optional<std::pair<Setup *, std::unordered_map<Output *, size_t>>> findSetup(const QList<Output *> &outputs, bool lidClosed);
+    std::optional<size_t> findOutput(Output *output, const QList<Output *> &allOutputs) const;
 
-    QVector<OutputState> m_outputs;
-    QVector<Setup> m_setups;
+    QList<OutputState> m_outputs;
+    QList<Setup> m_setups;
 };
 }
diff --git a/src/placementtracker.h b/src/placementtracker.h
index d5bb27247b..7e5514fe4e 100644
--- a/src/placementtracker.h
+++ b/src/placementtracker.h
@@ -11,10 +11,10 @@
 #include "utils/common.h"
 
 #include <QHash>
+#include <QList>
 #include <QRect>
 #include <QString>
 #include <QUuid>
-#include <QVector>
 
 namespace KWin
 {
@@ -57,7 +57,7 @@ private:
     void saveFullscreen(Window *window);
     WindowData dataForWindow(Window *window) const;
 
-    QVector<Window *> m_savedWindows;
+    QList<Window *> m_savedWindows;
     QHash<QString, QHash<Window *, WindowData>> m_data;
     QHash<Window *, WindowData> m_lastRestoreData;
     QString m_currentKey;
diff --git a/src/platformsupport/scenes/opengl/abstract_egl_backend.cpp b/src/platformsupport/scenes/opengl/abstract_egl_backend.cpp
index b0118e60c4..55b963347a 100644
--- a/src/platformsupport/scenes/opengl/abstract_egl_backend.cpp
+++ b/src/platformsupport/scenes/opengl/abstract_egl_backend.cpp
@@ -151,7 +151,7 @@ void AbstractEglBackend::initWayland()
 
     auto filterFormats = [this](uint32_t bpc) {
         const auto formats = m_display->supportedDrmFormats();
-        QHash<uint32_t, QVector<uint64_t>> set;
+        QHash<uint32_t, QList<uint64_t>> set;
         for (auto it = formats.constBegin(); it != formats.constEnd(); it++) {
             const auto info = formatInfo(it.key());
             if (info && info->bitsPerColor == bpc) {
@@ -235,7 +235,7 @@ void AbstractEglBackend::setSurface(const EGLSurface &surface)
     m_surface = surface;
 }
 
-QVector<LinuxDmaBufV1Feedback::Tranche> AbstractEglBackend::tranches() const
+QList<LinuxDmaBufV1Feedback::Tranche> AbstractEglBackend::tranches() const
 {
     return m_tranches;
 }
@@ -284,7 +284,7 @@ bool AbstractEglBackend::testImportBuffer(GraphicsBuffer *buffer)
     return importBufferAsImage(buffer) != EGL_NO_IMAGE_KHR;
 }
 
-QHash<uint32_t, QVector<uint64_t>> AbstractEglBackend::supportedFormats() const
+QHash<uint32_t, QList<uint64_t>> AbstractEglBackend::supportedFormats() const
 {
     return m_display->supportedDrmFormats();
 }
diff --git a/src/platformsupport/scenes/opengl/abstract_egl_backend.h b/src/platformsupport/scenes/opengl/abstract_egl_backend.h
index 98c564e4c8..478b26a37e 100644
--- a/src/platformsupport/scenes/opengl/abstract_egl_backend.h
+++ b/src/platformsupport/scenes/opengl/abstract_egl_backend.h
@@ -38,9 +38,9 @@ public:
     EglContext *contextObject();
 
     bool testImportBuffer(GraphicsBuffer *buffer) override;
-    QHash<uint32_t, QVector<uint64_t>> supportedFormats() const override;
+    QHash<uint32_t, QList<uint64_t>> supportedFormats() const override;
 
-    QVector<LinuxDmaBufV1Feedback::Tranche> tranches() const;
+    QList<LinuxDmaBufV1Feedback::Tranche> tranches() const;
     dev_t deviceId() const;
     virtual bool prefer10bpc() const;
 
@@ -71,7 +71,7 @@ protected:
     std::shared_ptr<EglContext> m_context;
     QList<QByteArray> m_clientExtensions;
     const dev_t m_deviceId;
-    QVector<LinuxDmaBufV1Feedback::Tranche> m_tranches;
+    QList<LinuxDmaBufV1Feedback::Tranche> m_tranches;
     QHash<GraphicsBuffer *, EGLImageKHR> m_importedBuffers;
 };
 
diff --git a/src/platformsupport/scenes/opengl/egldisplay.cpp b/src/platformsupport/scenes/opengl/egldisplay.cpp
index 94e2caaed3..f5d2a4d206 100644
--- a/src/platformsupport/scenes/opengl/egldisplay.cpp
+++ b/src/platformsupport/scenes/opengl/egldisplay.cpp
@@ -167,7 +167,7 @@ bool EglDisplay::supportsNativeFence() const
 
 EGLImageKHR EglDisplay::importDmaBufAsImage(const DmaBufAttributes &dmabuf) const
 {
-    QVector<EGLint> attribs;
+    QList<EGLint> attribs;
     attribs.reserve(6 + dmabuf.planeCount * 10 + 1);
 
     attribs << EGL_WIDTH << dmabuf.width
@@ -258,19 +258,19 @@ QHash<uint32_t, QList<uint64_t>> EglDisplay::queryImportFormats(Filter filter) c
         qCCritical(KWIN_OPENGL) << "eglQueryDmaBufFormatsEXT failed!" << getEglErrorString();
         return {};
     }
-    QVector<uint32_t> formats(count);
+    QList<uint32_t> formats(count);
     if (!eglQueryDmaBufFormatsEXT(m_handle, count, (EGLint *)formats.data(), &count)) {
         qCCritical(KWIN_OPENGL) << "eglQueryDmaBufFormatsEXT with count" << count << "failed!" << getEglErrorString();
         return {};
     }
-    QHash<uint32_t, QVector<uint64_t>> ret;
+    QHash<uint32_t, QList<uint64_t>> ret;
     for (const auto format : std::as_const(formats)) {
         if (eglQueryDmaBufModifiersEXT != nullptr) {
             EGLint count = 0;
             const EGLBoolean success = eglQueryDmaBufModifiersEXT(m_handle, format, 0, nullptr, nullptr, &count);
             if (success && count > 0) {
-                QVector<uint64_t> modifiers(count);
-                QVector<EGLBoolean> externalOnly(count);
+                QList<uint64_t> modifiers(count);
+                QList<EGLBoolean> externalOnly(count);
                 if (eglQueryDmaBufModifiersEXT(m_handle, format, count, modifiers.data(), externalOnly.data(), &count)) {
                     if (filter != Filter::None) {
                         const bool external = filter == Filter::Normal;
diff --git a/src/platformsupport/scenes/opengl/eglswapchain.cpp b/src/platformsupport/scenes/opengl/eglswapchain.cpp
index 0601363e0f..01e22d90d8 100644
--- a/src/platformsupport/scenes/opengl/eglswapchain.cpp
+++ b/src/platformsupport/scenes/opengl/eglswapchain.cpp
@@ -135,7 +135,7 @@ void EglSwapchain::release(std::shared_ptr<EglSwapchainSlot> slot)
     }
 }
 
-std::shared_ptr<EglSwapchain> EglSwapchain::create(GraphicsBufferAllocator *allocator, EglContext *context, const QSize &size, uint32_t format, const QVector<uint64_t> &modifiers)
+std::shared_ptr<EglSwapchain> EglSwapchain::create(GraphicsBufferAllocator *allocator, EglContext *context, const QSize &size, uint32_t format, const QList<uint64_t> &modifiers)
 {
     if (!context->makeCurrent()) {
         return nullptr;
diff --git a/src/platformsupport/scenes/opengl/eglswapchain.h b/src/platformsupport/scenes/opengl/eglswapchain.h
index 8b6271440b..d326c26ccb 100644
--- a/src/platformsupport/scenes/opengl/eglswapchain.h
+++ b/src/platformsupport/scenes/opengl/eglswapchain.h
@@ -10,8 +10,8 @@
 
 #include "kwin_export.h"
 
+#include <QList>
 #include <QSize>
-#include <QVector>
 
 #include <cstdint>
 #include <epoxy/egl.h>
@@ -60,7 +60,7 @@ public:
     std::shared_ptr<EglSwapchainSlot> acquire();
     void release(std::shared_ptr<EglSwapchainSlot> slot);
 
-    static std::shared_ptr<EglSwapchain> create(GraphicsBufferAllocator *allocator, EglContext *context, const QSize &size, uint32_t format, const QVector<uint64_t> &modifiers);
+    static std::shared_ptr<EglSwapchain> create(GraphicsBufferAllocator *allocator, EglContext *context, const QSize &size, uint32_t format, const QList<uint64_t> &modifiers);
 
 private:
     GraphicsBufferAllocator *m_allocator;
@@ -68,7 +68,7 @@ private:
     QSize m_size;
     uint32_t m_format;
     uint64_t m_modifier;
-    QVector<std::shared_ptr<EglSwapchainSlot>> m_slots;
+    QList<std::shared_ptr<EglSwapchainSlot>> m_slots;
 };
 
 } // namespace KWin
diff --git a/src/platformsupport/scenes/qpainter/qpainterswapchain.h b/src/platformsupport/scenes/qpainter/qpainterswapchain.h
index e6f46f39b4..584704769c 100644
--- a/src/platformsupport/scenes/qpainter/qpainterswapchain.h
+++ b/src/platformsupport/scenes/qpainter/qpainterswapchain.h
@@ -13,8 +13,8 @@
 #include "kwin_export.h"
 
 #include <QImage>
+#include <QList>
 #include <QSize>
-#include <QVector>
 
 #include <memory>
 
@@ -56,7 +56,7 @@ public:
 
 private:
     GraphicsBufferAllocator *m_allocator;
-    QVector<std::shared_ptr<QPainterSwapchainSlot>> m_slots;
+    QList<std::shared_ptr<QPainterSwapchainSlot>> m_slots;
     QSize m_size;
     uint32_t m_format;
 };
diff --git a/src/pluginmanager.cpp b/src/pluginmanager.cpp
index 6873612a00..3e058caf5f 100644
--- a/src/pluginmanager.cpp
+++ b/src/pluginmanager.cpp
@@ -36,7 +36,7 @@ PluginManager::PluginManager()
         return readPluginInfo(metadata, QStringLiteral("EnabledByDefault")).toBool(false);
     };
 
-    const QVector<KPluginMetaData> plugins = KPluginMetaData::findPlugins(s_pluginDirectory);
+    const QList<KPluginMetaData> plugins = KPluginMetaData::findPlugins(s_pluginDirectory);
     for (const KPluginMetaData &metadata : plugins) {
         if (m_plugins.find(metadata.pluginId()) != m_plugins.end()) {
             qCWarning(KWIN_CORE) << "Conflicting plugin id" << metadata.pluginId();
@@ -64,7 +64,7 @@ QStringList PluginManager::loadedPlugins() const
 
 QStringList PluginManager::availablePlugins() const
 {
-    const QVector<KPluginMetaData> plugins = KPluginMetaData::findPlugins(s_pluginDirectory);
+    const QList<KPluginMetaData> plugins = KPluginMetaData::findPlugins(s_pluginDirectory);
 
     QStringList ret;
     ret.reserve(plugins.size());
diff --git a/src/plugins/backgroundcontrast/contrast.h b/src/plugins/backgroundcontrast/contrast.h
index e28553068f..39c8409af2 100644
--- a/src/plugins/backgroundcontrast/contrast.h
+++ b/src/plugins/backgroundcontrast/contrast.h
@@ -11,8 +11,8 @@
 #include "libkwineffects/glutils.h"
 #include "libkwineffects/kwineffects.h"
 
+#include <QList>
 #include <QVector2D>
-#include <QVector>
 #include <unordered_map>
 
 namespace KWin
diff --git a/src/plugins/blur/blur.h b/src/plugins/blur/blur.h
index fbb6c9a8e3..006ca9310a 100644
--- a/src/plugins/blur/blur.h
+++ b/src/plugins/blur/blur.h
@@ -10,7 +10,7 @@
 #include "libkwineffects/glutils.h"
 #include "libkwineffects/kwineffects.h"
 
-#include <QVector>
+#include <QList>
 
 #include <unordered_map>
 
@@ -128,7 +128,7 @@ private:
         int expandSize;
     };
 
-    QVector<OffsetStruct> blurOffsets;
+    QList<OffsetStruct> blurOffsets;
 
     struct BlurValuesStruct
     {
@@ -136,7 +136,7 @@ private:
         float offset;
     };
 
-    QVector<BlurValuesStruct> blurStrengthValues;
+    QList<BlurValuesStruct> blurStrengthValues;
 
     QMap<EffectWindow *, QMetaObject::Connection> windowBlurChangedConnections;
     std::unordered_map<EffectWindow *, BlurEffectData> m_windows;
diff --git a/src/plugins/highlightwindow/highlightwindow.cpp b/src/plugins/highlightwindow/highlightwindow.cpp
index 0aafc46aeb..780e2d4dca 100644
--- a/src/plugins/highlightwindow/highlightwindow.cpp
+++ b/src/plugins/highlightwindow/highlightwindow.cpp
@@ -59,7 +59,7 @@ static bool isHighlightWindow(EffectWindow *window)
 
 void HighlightWindowEffect::highlightWindows(const QStringList &windows)
 {
-    QVector<EffectWindow *> effectWindows;
+    QList<EffectWindow *> effectWindows;
     effectWindows.reserve(windows.count());
     for (const auto &window : windows) {
         if (auto effectWindow = effects->findWindow(QUuid(window)); effectWindow) {
@@ -192,7 +192,7 @@ void HighlightWindowEffect::finishHighlighting()
     m_highlightedWindows.clear();
 }
 
-void HighlightWindowEffect::highlightWindows(const QVector<KWin::EffectWindow *> &windows)
+void HighlightWindowEffect::highlightWindows(const QList<KWin::EffectWindow *> &windows)
 {
     if (windows.isEmpty()) {
         finishHighlighting();
@@ -269,7 +269,7 @@ bool HighlightWindowEffect::perform(Feature feature, const QVariantList &argumen
     if (arguments.size() != 1) {
         return false;
     }
-    highlightWindows(arguments.first().value<QVector<EffectWindow *>>());
+    highlightWindows(arguments.first().value<QList<EffectWindow *>>());
     return true;
 }
 
diff --git a/src/plugins/highlightwindow/highlightwindow.h b/src/plugins/highlightwindow/highlightwindow.h
index 3c307a64a7..1d79e21b82 100644
--- a/src/plugins/highlightwindow/highlightwindow.h
+++ b/src/plugins/highlightwindow/highlightwindow.h
@@ -46,7 +46,7 @@ private:
 
     void prepareHighlighting();
     void finishHighlighting();
-    void highlightWindows(const QVector<KWin::EffectWindow *> &windows);
+    void highlightWindows(const QList<KWin::EffectWindow *> &windows);
 
     long m_atom;
     QList<EffectWindow *> m_highlightedWindows;
diff --git a/src/plugins/krunner-integration/windowsrunnerinterface.cpp b/src/plugins/krunner-integration/windowsrunnerinterface.cpp
index b59d60bdcf..53b9a0c6df 100644
--- a/src/plugins/krunner-integration/windowsrunnerinterface.cpp
+++ b/src/plugins/krunner-integration/windowsrunnerinterface.cpp
@@ -276,7 +276,7 @@ RemoteMatch WindowsRunner::windowsMatch(const Window *window, const WindowsRunne
     match.type = type;
     QVariantMap properties;
 
-    const QVector<VirtualDesktop *> desktops = window->desktops();
+    const QList<VirtualDesktop *> desktops = window->desktops();
     bool allDesktops = window->isOnAllDesktops();
 
     const VirtualDesktop *targetDesktop = VirtualDesktopManager::self()->currentDesktop();
diff --git a/src/plugins/magnifier/magnifier.cpp b/src/plugins/magnifier/magnifier.cpp
index 620e346a7f..3987f0f3a8 100644
--- a/src/plugins/magnifier/magnifier.cpp
+++ b/src/plugins/magnifier/magnifier.cpp
@@ -142,7 +142,7 @@ void MagnifierEffect::paintScreen(const RenderTarget &renderTarget, const Render
 
             QRectF areaF = scaledRect(area, scale);
             const QRectF frame = scaledRect(area.adjusted(-FRAME_WIDTH, -FRAME_WIDTH, FRAME_WIDTH, FRAME_WIDTH), scale);
-            QVector<QVector2D> verts;
+            QList<QVector2D> verts;
             verts.reserve(4 * 6 * 2);
             // top frame
             verts.push_back(QVector2D(frame.right(), frame.top()));
diff --git a/src/plugins/mouseclick/mouseclick.cpp b/src/plugins/mouseclick/mouseclick.cpp
index abc832879d..d586f29d7f 100644
--- a/src/plugins/mouseclick/mouseclick.cpp
+++ b/src/plugins/mouseclick/mouseclick.cpp
@@ -277,7 +277,7 @@ void MouseClickEffect::drawCircleGl(const RenderViewport &viewport, const QColor
 
     GLVertexBuffer *vbo = GLVertexBuffer::streamingBuffer();
     vbo->reset();
-    QVector<QVector2D> verts;
+    QList<QVector2D> verts;
     verts.reserve(num_segments * 2);
 
     for (int ii = 0; ii < num_segments; ++ii) {
diff --git a/src/plugins/mousemark/mousemark.cpp b/src/plugins/mousemark/mousemark.cpp
index e882b68f70..7a4198980b 100644
--- a/src/plugins/mousemark/mousemark.cpp
+++ b/src/plugins/mousemark/mousemark.cpp
@@ -122,7 +122,7 @@ void MouseMarkEffect::paintScreen(const RenderTarget &renderTarget, const Render
         binder.shader()->setUniform(GLShader::ModelViewProjectionMatrix, viewport.projectionMatrix());
         binder.shader()->setColorspaceUniformsFromSRGB(renderTarget.colorDescription());
         binder.shader()->setUniform(GLShader::ColorUniform::Color, color);
-        QVector<QVector2D> verts;
+        QList<QVector2D> verts;
         for (const Mark &mark : std::as_const(marks)) {
             verts.clear();
             verts.reserve(mark.size() * 2);
diff --git a/src/plugins/mousemark/mousemark.h b/src/plugins/mousemark/mousemark.h
index 4753bfa9ed..a1f1607000 100644
--- a/src/plugins/mousemark/mousemark.h
+++ b/src/plugins/mousemark/mousemark.h
@@ -58,10 +58,10 @@ private Q_SLOTS:
     void screenLockingChanged(bool locked);
 
 private:
-    typedef QVector<QPointF> Mark;
+    typedef QList<QPointF> Mark;
     void drawMark(QPainter *painter, const Mark &mark);
     static Mark createArrow(QPointF arrow_head, QPointF arrow_tail);
-    QVector<Mark> marks;
+    QList<Mark> marks;
     Mark drawing;
     QPointF arrow_tail;
     int width;
diff --git a/src/plugins/nightcolor/nightcolormanager.cpp b/src/plugins/nightcolor/nightcolormanager.cpp
index 9523c17f1f..270b187070 100644
--- a/src/plugins/nightcolor/nightcolormanager.cpp
+++ b/src/plugins/nightcolor/nightcolormanager.cpp
@@ -640,7 +640,7 @@ int NightColorManager::currentTargetTemp() const
 
 void NightColorManager::commitGammaRamps(int temperature)
 {
-    const QVector<ColorDevice *> devices = kwinApp()->colorManager()->devices();
+    const QList<ColorDevice *> devices = kwinApp()->colorManager()->devices();
     for (ColorDevice *device : devices) {
         device->setTemperature(temperature);
     }
diff --git a/src/plugins/private/expolayout.cpp b/src/plugins/private/expolayout.cpp
index 8219779d55..5d5b957d83 100644
--- a/src/plugins/private/expolayout.cpp
+++ b/src/plugins/private/expolayout.cpp
@@ -349,12 +349,12 @@ void ExpoLayout::calculateWindowTransformationsClosest()
     // Assign slots
     const int slotWidth = area.width() / columns;
     const int slotHeight = area.height() / rows;
-    QVector<ExpoCell *> takenSlots;
+    QList<ExpoCell *> takenSlots;
     takenSlots.resize(rows * columns);
     takenSlots.fill(nullptr);
 
     // precalculate all slot centers
-    QVector<QPoint> slotCenters;
+    QList<QPoint> slotCenters;
     slotCenters.resize(rows * columns);
     for (int x = 0; x < columns; ++x) {
         for (int y = 0; y < rows; ++y) {
diff --git a/src/plugins/qpa/eglhelpers.cpp b/src/plugins/qpa/eglhelpers.cpp
index 1bdd3f2818..f3e0b884d6 100644
--- a/src/plugins/qpa/eglhelpers.cpp
+++ b/src/plugins/qpa/eglhelpers.cpp
@@ -42,7 +42,7 @@ EGLConfig configFromFormat(EglDisplay *display, const QSurfaceFormat &surfaceFor
     const EGLint renderableType = isOpenGLES() ? EGL_OPENGL_ES2_BIT : EGL_OPENGL_BIT;
 
     // Not setting samples as QtQuick doesn't need it.
-    const QVector<EGLint> attributes{
+    const QList<EGLint> attributes{
         EGL_SURFACE_TYPE, surfaceType,
         EGL_RED_SIZE, redSize,
         EGL_GREEN_SIZE, greenSize,
@@ -63,7 +63,7 @@ EGLConfig configFromFormat(EglDisplay *display, const QSurfaceFormat &surfaceFor
         return EGL_NO_CONFIG_KHR;
     }
 
-    QVector<EGLConfig> configs(configCount);
+    QList<EGLConfig> configs(configCount);
     if (!eglChooseConfig(display->handle(), attributes.data(), configs.data(), configCount, &configCount)) {
         qCWarning(KWIN_QPA, "eglChooseConfig failed: %x", eglGetError());
         return EGL_NO_CONFIG_KHR;
diff --git a/src/plugins/qpa/swapchain.cpp b/src/plugins/qpa/swapchain.cpp
index f74ad3783e..001e3081c0 100644
--- a/src/plugins/qpa/swapchain.cpp
+++ b/src/plugins/qpa/swapchain.cpp
@@ -52,7 +52,7 @@ uint32_t Swapchain::format() const
     return m_allocationOptions.format;
 }
 
-QVector<uint64_t> Swapchain::modifiers() const
+QList<uint64_t> Swapchain::modifiers() const
 {
     return m_allocationOptions.modifiers;
 }
diff --git a/src/plugins/qpa/swapchain.h b/src/plugins/qpa/swapchain.h
index 7cd57cfd8a..c5824814b7 100644
--- a/src/plugins/qpa/swapchain.h
+++ b/src/plugins/qpa/swapchain.h
@@ -25,7 +25,7 @@ public:
 
     GraphicsBuffer *acquire();
     uint32_t format() const;
-    QVector<uint64_t> modifiers() const;
+    QList<uint64_t> modifiers() const;
 
 private:
     GraphicsBufferAllocator *m_allocator;
diff --git a/src/plugins/qpa/window.cpp b/src/plugins/qpa/window.cpp
index 30573be165..588851b989 100644
--- a/src/plugins/qpa/window.cpp
+++ b/src/plugins/qpa/window.cpp
@@ -42,7 +42,7 @@ Window::~Window()
     unmap();
 }
 
-Swapchain *Window::swapchain(const QHash<uint32_t, QVector<uint64_t>> &formats)
+Swapchain *Window::swapchain(const QHash<uint32_t, QList<uint64_t>> &formats)
 {
     const QSize nativeSize = geometry().size() * devicePixelRatio();
     if (!m_swapchain || m_swapchain->size() != nativeSize
diff --git a/src/plugins/qpa/window.h b/src/plugins/qpa/window.h
index 5bbb2e666f..5b54f29fe8 100644
--- a/src/plugins/qpa/window.h
+++ b/src/plugins/qpa/window.h
@@ -37,7 +37,7 @@ public:
     void requestActivateWindow() override;
 
     InternalWindow *internalWindow() const;
-    Swapchain *swapchain(const QHash<uint32_t, QVector<uint64_t>> &formats);
+    Swapchain *swapchain(const QHash<uint32_t, QList<uint64_t>> &formats);
 
 private:
     void map();
diff --git a/src/plugins/screencast/screencaststream.cpp b/src/plugins/screencast/screencaststream.cpp
index 80428d54de..8645061b7e 100644
--- a/src/plugins/screencast/screencaststream.cpp
+++ b/src/plugins/screencast/screencaststream.cpp
@@ -161,13 +161,13 @@ void ScreenCastStream::onStreamParamChanged(uint32_t id, const struct spa_pod *f
 
     spa_format_video_raw_parse(format, &m_videoFormat);
     auto modifierProperty = spa_pod_find_prop(format, nullptr, SPA_FORMAT_VIDEO_modifier);
-    QVector<uint64_t> receivedModifiers;
+    QList<uint64_t> receivedModifiers;
     if (modifierProperty) {
         const struct spa_pod *modifierPod = &modifierProperty->value;
 
         uint32_t modifiersCount = SPA_POD_CHOICE_N_VALUES(modifierPod);
         uint64_t *modifiers = (uint64_t *)SPA_POD_CHOICE_VALUES(modifierPod);
-        receivedModifiers = QVector<uint64_t>(modifiers, modifiers + modifiersCount);
+        receivedModifiers = QList<uint64_t>(modifiers, modifiers + modifiersCount);
         // Remove duplicates
         std::sort(receivedModifiers.begin(), receivedModifiers.end());
         receivedModifiers.erase(std::unique(receivedModifiers.begin(), receivedModifiers.end()), receivedModifiers.end());
@@ -412,7 +412,7 @@ bool ScreenCastStream::createStream()
     m_hasDmaBuf = testCreateDmaBuf(m_resolution, m_drmFormat, {DRM_FORMAT_MOD_INVALID}).has_value();
 
     char buffer[2048];
-    QVector<const spa_pod *> params = buildFormats(false, buffer);
+    QList<const spa_pod *> params = buildFormats(false, buffer);
 
     pw_stream_add_listener(m_pwStream, &m_streamListener, &m_pwStreamEvents, this);
     auto flags = pw_stream_flags(PW_STREAM_FLAG_DRIVER | PW_STREAM_FLAG_ALLOC_BUFFERS);
@@ -739,7 +739,7 @@ void ScreenCastStream::enqueue()
     m_pendingBuffer = nullptr;
 }
 
-QVector<const spa_pod *> ScreenCastStream::buildFormats(bool fixate, char buffer[2048])
+QList<const spa_pod *> ScreenCastStream::buildFormats(bool fixate, char buffer[2048])
 {
     const auto format = drmFourCCToSpaVideoFormat(m_drmFormat);
     spa_pod_builder podBuilder = SPA_POD_BUILDER_INIT(buffer, 2048);
@@ -749,7 +749,7 @@ QVector<const spa_pod *> ScreenCastStream::buildFormats(bool fixate, char buffer
 
     spa_rectangle resolution = SPA_RECTANGLE(uint32_t(m_resolution.width()), uint32_t(m_resolution.height()));
 
-    QVector<const spa_pod *> params;
+    QList<const spa_pod *> params;
     params.reserve(fixate + m_hasDmaBuf + 1);
     if (fixate) {
         params.append(buildFormat(&podBuilder, SPA_VIDEO_FORMAT_BGRA, &resolution, &defFramerate, &minFramerate, &maxFramerate, {m_dmabufParams->modifier}, SPA_POD_PROP_FLAG_MANDATORY));
@@ -763,7 +763,7 @@ QVector<const spa_pod *> ScreenCastStream::buildFormats(bool fixate, char buffer
 
 spa_pod *ScreenCastStream::buildFormat(struct spa_pod_builder *b, enum spa_video_format format, struct spa_rectangle *resolution,
                                        struct spa_fraction *defaultFramerate, struct spa_fraction *minFramerate, struct spa_fraction *maxFramerate,
-                                       const QVector<uint64_t> &modifiers, quint32 modifiersFlags)
+                                       const QList<uint64_t> &modifiers, quint32 modifiersFlags)
 {
     struct spa_pod_frame f[2];
     spa_pod_builder_push_object(b, &f[0], SPA_TYPE_OBJECT_Format, SPA_PARAM_EnumFormat);
@@ -880,7 +880,7 @@ void ScreenCastStream::setCursorMode(ScreencastV1Interface::CursorMode mode, qre
     m_cursor.viewport = viewport;
 }
 
-std::optional<ScreenCastDmaBufTextureParams> ScreenCastStream::testCreateDmaBuf(const QSize &size, quint32 format, const QVector<uint64_t> &modifiers)
+std::optional<ScreenCastDmaBufTextureParams> ScreenCastStream::testCreateDmaBuf(const QSize &size, quint32 format, const QList<uint64_t> &modifiers)
 {
     AbstractEglBackend *backend = dynamic_cast<AbstractEglBackend *>(Compositor::self()->backend());
     if (!backend) {
diff --git a/src/plugins/screencast/screencaststream.h b/src/plugins/screencast/screencaststream.h
index b188147f94..19a4e541be 100644
--- a/src/plugins/screencast/screencaststream.h
+++ b/src/plugins/screencast/screencaststream.h
@@ -88,7 +88,7 @@ private:
     void onStreamRenegotiateFormat(uint64_t);
 
     bool createStream();
-    QVector<const spa_pod *> buildFormats(bool fixate, char buffer[2048]);
+    QList<const spa_pod *> buildFormats(bool fixate, char buffer[2048]);
     void updateParams();
     void coreFailed(const QString &errorMessage);
     void sendCursorData(Cursor *cursor, spa_meta_cursor *spa_cursor);
@@ -99,9 +99,9 @@ private:
     void enqueue();
     spa_pod *buildFormat(struct spa_pod_builder *b, enum spa_video_format format, struct spa_rectangle *resolution,
                          struct spa_fraction *defaultFramerate, struct spa_fraction *minFramerate, struct spa_fraction *maxFramerate,
-                         const QVector<uint64_t> &modifiers, quint32 modifiersFlags);
+                         const QList<uint64_t> &modifiers, quint32 modifiersFlags);
 
-    std::optional<ScreenCastDmaBufTextureParams> testCreateDmaBuf(const QSize &size, quint32 format, const QVector<uint64_t> &modifiers);
+    std::optional<ScreenCastDmaBufTextureParams> testCreateDmaBuf(const QSize &size, quint32 format, const QList<uint64_t> &modifiers);
     std::shared_ptr<ScreenCastDmaBufTexture> createDmaBufTexture(const ScreenCastDmaBufTextureParams &params);
 
     std::shared_ptr<PipeWireCore> m_pwCore;
@@ -119,7 +119,7 @@ private:
 
     spa_video_info_raw m_videoFormat;
     QString m_error;
-    QVector<uint64_t> m_modifiers;
+    QList<uint64_t> m_modifiers;
     std::optional<ScreenCastDmaBufTextureParams> m_dmabufParams; // when fixated
 
     struct
diff --git a/src/plugins/showpaint/showpaint.cpp b/src/plugins/showpaint/showpaint.cpp
index c04070b7fa..8d7f42d292 100644
--- a/src/plugins/showpaint/showpaint.cpp
+++ b/src/plugins/showpaint/showpaint.cpp
@@ -23,7 +23,7 @@ namespace KWin
 {
 
 static const qreal s_alpha = 0.2;
-static const QVector<QColor> s_colors{
+static const QList<QColor> s_colors{
     Qt::red,
     Qt::green,
     Qt::blue,
@@ -74,7 +74,7 @@ void ShowPaintEffect::paintGL(const QMatrix4x4 &projection, qreal scale)
     QColor color = s_colors[m_colorIndex];
     color.setAlphaF(s_alpha);
     binder.shader()->setUniform(GLShader::ColorUniform::Color, color);
-    QVector<QVector2D> verts;
+    QList<QVector2D> verts;
     verts.reserve(m_painted.rectCount() * 12);
     for (const QRect &r : m_painted) {
         const auto deviceRect = scaledRect(r, scale);
diff --git a/src/plugins/slide/slide.h b/src/plugins/slide/slide.h
index e29a7f1eb3..88c652740a 100644
--- a/src/plugins/slide/slide.h
+++ b/src/plugins/slide/slide.h
@@ -120,7 +120,7 @@ private:
     struct
     {
         bool wrap;
-        QVector<int> visibleDesktops;
+        QList<int> visibleDesktops;
     } m_paintCtx;
 
     struct WindowData
diff --git a/src/plugins/snaphelper/snaphelper.cpp b/src/plugins/snaphelper/snaphelper.cpp
index acaf56935f..bc483d9071 100644
--- a/src/plugins/snaphelper/snaphelper.cpp
+++ b/src/plugins/snaphelper/snaphelper.cpp
@@ -119,7 +119,7 @@ void SnapHelperEffect::paintScreen(const RenderTarget &renderTarget, const Rende
         binder.shader()->setUniform(GLShader::ColorUniform::Color, color);
 
         glLineWidth(s_lineWidth);
-        QVector<QVector2D> verts;
+        QList<QVector2D> verts;
         verts.reserve(screens.count() * 24);
         for (EffectScreen *screen : screens) {
             const QRectF rect = effects->clientArea(ScreenArea, screen, effects->currentDesktop());
diff --git a/src/plugins/stickykeys/stickykeys.h b/src/plugins/stickykeys/stickykeys.h
index b1047bd342..50a1b936a2 100644
--- a/src/plugins/stickykeys/stickykeys.h
+++ b/src/plugins/stickykeys/stickykeys.h
@@ -29,5 +29,5 @@ private:
 
     KConfigWatcher::Ptr m_configWatcher;
     QMap<int, KeyState> m_keyStates;
-    QVector<int> m_modifiers = {Qt::Key_Shift, Qt::Key_Control, Qt::Key_Alt, Qt::Key_AltGr, Qt::Key_Meta};
+    QList<int> m_modifiers = {Qt::Key_Shift, Qt::Key_Control, Qt::Key_Alt, Qt::Key_AltGr, Qt::Key_Meta};
 };
diff --git a/src/plugins/thumbnailaside/thumbnailaside.cpp b/src/plugins/thumbnailaside/thumbnailaside.cpp
index f9e8b69342..bb0c896471 100644
--- a/src/plugins/thumbnailaside/thumbnailaside.cpp
+++ b/src/plugins/thumbnailaside/thumbnailaside.cpp
@@ -159,7 +159,7 @@ void ThumbnailAsideEffect::arrange()
         return;
     }
     int height = 0;
-    QVector<int> pos(windows.size());
+    QList<int> pos(windows.size());
     qreal mwidth = 0;
     for (const Data &d : std::as_const(windows)) {
         height += d.window->height();
diff --git a/src/plugins/touchpoints/touchpoints.cpp b/src/plugins/touchpoints/touchpoints.cpp
index 758e45df0f..1124d0864b 100644
--- a/src/plugins/touchpoints/touchpoints.cpp
+++ b/src/plugins/touchpoints/touchpoints.cpp
@@ -204,7 +204,7 @@ void TouchPointsEffect::drawCircleGl(const RenderViewport &viewport, const QColo
     GLVertexBuffer *vbo = GLVertexBuffer::streamingBuffer();
     vbo->reset();
     ShaderManager::instance()->getBoundShader()->setUniform(GLShader::ColorUniform::Color, color);
-    QVector<QVector2D> verts;
+    QList<QVector2D> verts;
     verts.reserve(num_segments);
 
     for (int ii = 0; ii < num_segments; ++ii) {
diff --git a/src/plugins/touchpoints/touchpoints.h b/src/plugins/touchpoints/touchpoints.h
index 01df569f56..3286826a51 100644
--- a/src/plugins/touchpoints/touchpoints.h
+++ b/src/plugins/touchpoints/touchpoints.h
@@ -78,7 +78,7 @@ private:
         bool press;
         QColor color;
     };
-    QVector<TouchPoint> m_points;
+    QList<TouchPoint> m_points;
     QHash<quint32, QPointF> m_latestPositions;
     QHash<quint32, Qt::GlobalColor> m_colors;
     std::chrono::milliseconds m_lastPresentTime = std::chrono::milliseconds::zero();
diff --git a/src/plugins/wobblywindows/wobblywindows.cpp b/src/plugins/wobblywindows/wobblywindows.cpp
index bb02665ead..98611886d8 100644
--- a/src/plugins/wobblywindows/wobblywindows.cpp
+++ b/src/plugins/wobblywindows/wobblywindows.cpp
@@ -955,7 +955,7 @@ bool WobblyWindowsEffect::updateWindowWobblyDatas(EffectWindow *w, qreal time)
     return true;
 }
 
-void WobblyWindowsEffect::heightRingLinearMean(QVector<Pair> &data, WindowWobblyInfos &wwi)
+void WobblyWindowsEffect::heightRingLinearMean(QList<Pair> &data, WindowWobblyInfos &wwi)
 {
     Pair neibourgs[8];
 
diff --git a/src/plugins/wobblywindows/wobblywindows.h b/src/plugins/wobblywindows/wobblywindows.h
index b0eaab318a..62ab954000 100644
--- a/src/plugins/wobblywindows/wobblywindows.h
+++ b/src/plugins/wobblywindows/wobblywindows.h
@@ -105,21 +105,21 @@ private:
 
     struct WindowWobblyInfos
     {
-        QVector<Pair> origin;
-        QVector<Pair> position;
-        QVector<Pair> velocity;
-        QVector<Pair> acceleration;
-        QVector<Pair> buffer;
+        QList<Pair> origin;
+        QList<Pair> position;
+        QList<Pair> velocity;
+        QList<Pair> acceleration;
+        QList<Pair> buffer;
 
         // if true, the physics system moves this point based only on it "normal" destination
         // given by the window position, ignoring neighbour points.
-        QVector<bool> constraint;
+        QList<bool> constraint;
 
         unsigned int width;
         unsigned int height;
         unsigned int count;
 
-        QVector<Pair> bezierSurface;
+        QList<Pair> bezierSurface;
         unsigned int bezierWidth;
         unsigned int bezierHeight;
         unsigned int bezierCount;
@@ -161,7 +161,7 @@ private:
 
     WobblyWindowsEffect::Pair computeBezierPoint(const WindowWobblyInfos &wwi, Pair point) const;
 
-    static void heightRingLinearMean(QVector<Pair> &data, WindowWobblyInfos &wwi);
+    static void heightRingLinearMean(QList<Pair> &data, WindowWobblyInfos &wwi);
 
     void setParameterSet(const ParameterSet &pset);
 };
diff --git a/src/pointer_input.cpp b/src/pointer_input.cpp
index 94482d4961..322916d0a8 100644
--- a/src/pointer_input.cpp
+++ b/src/pointer_input.cpp
@@ -206,13 +206,13 @@ private:
         QPointF deltaNonAccelerated;
         std::chrono::microseconds time;
     };
-    static QVector<ScheduledPosition> s_scheduledPositions;
+    static QList<ScheduledPosition> s_scheduledPositions;
 
     PointerInputRedirection *m_pointer;
 };
 
 int PositionUpdateBlocker::s_counter = 0;
-QVector<PositionUpdateBlocker::ScheduledPosition> PositionUpdateBlocker::s_scheduledPositions;
+QList<PositionUpdateBlocker::ScheduledPosition> PositionUpdateBlocker::s_scheduledPositions;
 
 void PointerInputRedirection::processMotionAbsolute(const QPointF &pos, std::chrono::microseconds time, InputDevice *device)
 {
diff --git a/src/popup_input_filter.h b/src/popup_input_filter.h
index 77f08e9ccf..38515c1565 100644
--- a/src/popup_input_filter.h
+++ b/src/popup_input_filter.h
@@ -8,8 +8,8 @@
 
 #include "input.h"
 
+#include <QList>
 #include <QObject>
-#include <QVector>
 
 namespace KWin
 {
@@ -28,6 +28,6 @@ private:
     void handleWindowAdded(Window *client);
     void cancelPopups();
 
-    QVector<Window *> m_popupWindows;
+    QList<Window *> m_popupWindows;
 };
 }
diff --git a/src/rootinfo_filter.cpp b/src/rootinfo_filter.cpp
index e556f937f4..e269b5d828 100644
--- a/src/rootinfo_filter.cpp
+++ b/src/rootinfo_filter.cpp
@@ -14,7 +14,7 @@ namespace KWin
 {
 
 RootInfoFilter::RootInfoFilter(RootInfo *parent)
-    : X11EventFilter(QVector<int>{XCB_PROPERTY_NOTIFY, XCB_CLIENT_MESSAGE})
+    : X11EventFilter(QList<int>{XCB_PROPERTY_NOTIFY, XCB_CLIENT_MESSAGE})
     , m_rootInfo(parent)
 {
 }
diff --git a/src/rulebooksettings.cpp b/src/rulebooksettings.cpp
index f33714fde7..c3a26e6cb5 100644
--- a/src/rulebooksettings.cpp
+++ b/src/rulebooksettings.cpp
@@ -40,7 +40,7 @@ RuleBookSettings::~RuleBookSettings()
     qDeleteAll(m_list);
 }
 
-void RuleBookSettings::setRules(const QVector<Rules *> &rules)
+void RuleBookSettings::setRules(const QList<Rules *> &rules)
 {
     mCount = rules.count();
     mRuleGroupList.clear();
@@ -72,9 +72,9 @@ void RuleBookSettings::setRules(const QVector<Rules *> &rules)
     }
 }
 
-QVector<Rules *> RuleBookSettings::rules()
+QList<Rules *> RuleBookSettings::rules()
 {
-    QVector<Rules *> result;
+    QList<Rules *> result;
     result.reserve(m_list.count());
     for (const auto &settings : std::as_const(m_list)) {
         result.append(new Rules(settings));
diff --git a/src/rulebooksettings.h b/src/rulebooksettings.h
index 825e40823b..eeecc5ba9d 100644
--- a/src/rulebooksettings.h
+++ b/src/rulebooksettings.h
@@ -27,8 +27,8 @@ public:
     RuleBookSettings(QObject *parent = nullptr);
     ~RuleBookSettings();
 
-    void setRules(const QVector<Rules *> &);
-    QVector<Rules *> rules();
+    void setRules(const QList<Rules *> &);
+    QList<Rules *> rules();
 
     bool usrSave() override;
     void usrRead() override;
@@ -44,7 +44,7 @@ private:
     static QString generateGroupName();
 
 private:
-    QVector<RuleSettings *> m_list;
+    QList<RuleSettings *> m_list;
     QStringList m_storedGroups;
 };
 
diff --git a/src/rules.cpp b/src/rules.cpp
index 376e7c7933..6ddad43c97 100644
--- a/src/rules.cpp
+++ b/src/rules.cpp
@@ -579,7 +579,7 @@ APPLY_RULE(screen, Screen, int)
 APPLY_RULE(activity, Activity, QStringList)
 APPLY_FORCE_RULE(type, Type, NET::WindowType)
 
-bool Rules::applyDesktops(QVector<VirtualDesktop *> &vds, bool init) const
+bool Rules::applyDesktops(QList<VirtualDesktop *> &vds, bool init) const
 {
     if (checkSetRule(desktopsrule, init)) {
         vds.clear();
@@ -719,7 +719,7 @@ QDebug &operator<<(QDebug &stream, const Rules *r)
 void WindowRules::update(Window *c, int selection)
 {
     bool updated = false;
-    for (QVector<Rules *>::ConstIterator it = rules.constBegin();
+    for (QList<Rules *>::ConstIterator it = rules.constBegin();
          it != rules.constEnd();
          ++it) {
         if ((*it)->update(c, selection)) { // no short-circuiting here
@@ -731,34 +731,34 @@ void WindowRules::update(Window *c, int selection)
     }
 }
 
-#define CHECK_RULE(rule, type)                                        \
-    type WindowRules::check##rule(type arg, bool init) const          \
-    {                                                                 \
-        if (rules.count() == 0)                                       \
-            return arg;                                               \
-        type ret = arg;                                               \
-        for (QVector<Rules *>::ConstIterator it = rules.constBegin(); \
-             it != rules.constEnd();                                  \
-             ++it) {                                                  \
-            if ((*it)->apply##rule(ret, init))                        \
-                break;                                                \
-        }                                                             \
-        return ret;                                                   \
-    }
-
-#define CHECK_FORCE_RULE(rule, type)                             \
-    type WindowRules::check##rule(type arg) const                \
-    {                                                            \
-        if (rules.count() == 0)                                  \
-            return arg;                                          \
-        type ret = arg;                                          \
-        for (QVector<Rules *>::ConstIterator it = rules.begin(); \
-             it != rules.end();                                  \
-             ++it) {                                             \
-            if ((*it)->apply##rule(ret))                         \
-                break;                                           \
-        }                                                        \
-        return ret;                                              \
+#define CHECK_RULE(rule, type)                                      \
+    type WindowRules::check##rule(type arg, bool init) const        \
+    {                                                               \
+        if (rules.count() == 0)                                     \
+            return arg;                                             \
+        type ret = arg;                                             \
+        for (QList<Rules *>::ConstIterator it = rules.constBegin(); \
+             it != rules.constEnd();                                \
+             ++it) {                                                \
+            if ((*it)->apply##rule(ret, init))                      \
+                break;                                              \
+        }                                                           \
+        return ret;                                                 \
+    }
+
+#define CHECK_FORCE_RULE(rule, type)                           \
+    type WindowRules::check##rule(type arg) const              \
+    {                                                          \
+        if (rules.count() == 0)                                \
+            return arg;                                        \
+        type ret = arg;                                        \
+        for (QList<Rules *>::ConstIterator it = rules.begin(); \
+             it != rules.end();                                \
+             ++it) {                                           \
+            if ((*it)->apply##rule(ret))                       \
+                break;                                         \
+        }                                                      \
+        return ret;                                            \
     }
 
 CHECK_FORCE_RULE(Placement, PlacementPolicy)
@@ -798,7 +798,7 @@ CHECK_FORCE_RULE(OpacityActive, int)
 CHECK_FORCE_RULE(OpacityInactive, int)
 CHECK_RULE(IgnoreGeometry, bool)
 
-CHECK_RULE(Desktops, QVector<VirtualDesktop *>)
+CHECK_RULE(Desktops, QList<VirtualDesktop *>)
 CHECK_RULE(Activity, QStringList)
 CHECK_FORCE_RULE(Type, NET::WindowType)
 CHECK_RULE(MaximizeVert, MaximizeMode)
@@ -875,7 +875,7 @@ void RuleBook::deleteAll()
 
 WindowRules RuleBook::find(const Window *window) const
 {
-    QVector<Rules *> ret;
+    QList<Rules *> ret;
     for (Rules *rule : m_rules) {
         if (rule->match(window)) {
             qCDebug(KWIN_CORE) << "Rule found:" << rule << ":" << window;
@@ -935,7 +935,7 @@ void RuleBook::save()
 void RuleBook::discardUsed(Window *c, bool withdrawn)
 {
     bool updated = false;
-    for (QVector<Rules *>::Iterator it = m_rules.begin();
+    for (QList<Rules *>::Iterator it = m_rules.begin();
          it != m_rules.end();) {
         if (c->rules()->contains(*it)) {
             if ((*it)->discardUsed(withdrawn)) {
diff --git a/src/rules.h b/src/rules.h
index eb3835a62b..05cb4c0b34 100644
--- a/src/rules.h
+++ b/src/rules.h
@@ -9,8 +9,8 @@
 
 #pragma once
 
+#include <QList>
 #include <QRectF>
-#include <QVector>
 #include <netwm_def.h>
 
 #include "options.h"
@@ -33,7 +33,7 @@ class VirtualDesktop;
 class WindowRules
 {
 public:
-    explicit WindowRules(const QVector<Rules *> &rules);
+    explicit WindowRules(const QList<Rules *> &rules);
     WindowRules();
     void update(Window *, int selection);
     bool contains(const Rules *rule) const;
@@ -50,7 +50,7 @@ public:
     int checkOpacityActive(int s) const;
     int checkOpacityInactive(int s) const;
     bool checkIgnoreGeometry(bool ignore, bool init = false) const;
-    QVector<VirtualDesktop *> checkDesktops(QVector<VirtualDesktop *> desktops, bool init = false) const;
+    QList<VirtualDesktop *> checkDesktops(QList<VirtualDesktop *> desktops, bool init = false) const;
     Output *checkOutput(Output *output, bool init = false) const;
     QStringList checkActivity(QStringList activity, bool init = false) const;
     NET::WindowType checkType(NET::WindowType type) const;
@@ -81,7 +81,7 @@ public:
 private:
     MaximizeMode checkMaximizeVert(MaximizeMode mode, bool init) const;
     MaximizeMode checkMaximizeHoriz(MaximizeMode mode, bool init) const;
-    QVector<Rules *> rules;
+    QList<Rules *> rules;
 };
 
 #endif
@@ -156,7 +156,7 @@ public:
     bool applyOpacityActive(int &s) const;
     bool applyOpacityInactive(int &s) const;
     bool applyIgnoreGeometry(bool &ignore, bool init) const;
-    bool applyDesktops(QVector<VirtualDesktop *> &desktops, bool init) const;
+    bool applyDesktops(QList<VirtualDesktop *> &desktops, bool init) const;
     bool applyScreen(int &desktop, bool init) const;
     bool applyActivity(QStringList &activity, bool init) const;
     bool applyType(NET::WindowType &type) const;
@@ -317,7 +317,7 @@ private:
     void deleteAll();
     QTimer *m_updateTimer;
     bool m_updatesDisabled;
-    QVector<Rules *> m_rules;
+    QList<Rules *> m_rules;
     KSharedConfig::Ptr m_config;
 };
 
@@ -352,7 +352,7 @@ inline bool Rules::checkForceStop(ForceRule rule)
     return rule != UnusedForceRule;
 }
 
-inline WindowRules::WindowRules(const QVector<Rules *> &r)
+inline WindowRules::WindowRules(const QList<Rules *> &r)
     : rules(r)
 {
 }
diff --git a/src/scene/decorationitem.cpp b/src/scene/decorationitem.cpp
index 730c0a34fc..1654230c1b 100644
--- a/src/scene/decorationitem.cpp
+++ b/src/scene/decorationitem.cpp
@@ -109,7 +109,7 @@ DecorationItem::DecorationItem(KDecoration2::Decoration *decoration, Window *win
     handleOutputChanged();
 }
 
-QVector<QRectF> DecorationItem::shape() const
+QList<QRectF> DecorationItem::shape() const
 {
     QRectF left, top, right, bottom;
     m_window->layoutDecorationRects(left, top, right, bottom);
diff --git a/src/scene/decorationitem.h b/src/scene/decorationitem.h
index ce1f82f766..a795b48cd1 100644
--- a/src/scene/decorationitem.h
+++ b/src/scene/decorationitem.h
@@ -82,7 +82,7 @@ public:
     DecorationRenderer *renderer() const;
     Window *window() const;
 
-    QVector<QRectF> shape() const override final;
+    QList<QRectF> shape() const override final;
     QRegion opaque() const override final;
 
 private Q_SLOTS:
diff --git a/src/scene/item.cpp b/src/scene/item.cpp
index 4c4794a245..67955851b6 100644
--- a/src/scene/item.cpp
+++ b/src/scene/item.cpp
@@ -174,9 +174,9 @@ void Item::updateBoundingRect()
     }
 }
 
-QVector<QRectF> Item::shape() const
+QList<QRectF> Item::shape() const
 {
-    return QVector<QRectF>();
+    return QList<QRectF>();
 }
 
 QRegion Item::opaque() const
diff --git a/src/scene/item.h b/src/scene/item.h
index 692df67f5d..dc85d24684 100644
--- a/src/scene/item.h
+++ b/src/scene/item.h
@@ -9,10 +9,10 @@
 #include "libkwineffects/kwineffects.h"
 #include "libkwineffects/kwinglobals.h"
 
+#include <QList>
 #include <QMatrix4x4>
 #include <QObject>
 #include <QPointer>
-#include <QVector>
 
 #include <optional>
 
@@ -56,7 +56,7 @@ public:
      */
     QRectF boundingRect() const;
 
-    virtual QVector<QRectF> shape() const;
+    virtual QList<QRectF> shape() const;
     virtual QRegion opaque() const;
 
     /**
diff --git a/src/scene/itemrenderer_opengl.h b/src/scene/itemrenderer_opengl.h
index 7a4e2a9c0d..87a4ffd440 100644
--- a/src/scene/itemrenderer_opengl.h
+++ b/src/scene/itemrenderer_opengl.h
@@ -31,7 +31,7 @@ public:
 
     struct RenderContext
     {
-        QVector<RenderNode> renderNodes;
+        QList<RenderNode> renderNodes;
         QStack<QMatrix4x4> transformStack;
         QStack<qreal> opacityStack;
         const QMatrix4x4 projectionMatrix;
diff --git a/src/scene/itemrenderer_qpainter.cpp b/src/scene/itemrenderer_qpainter.cpp
index 91f40e620b..285a421e0d 100644
--- a/src/scene/itemrenderer_qpainter.cpp
+++ b/src/scene/itemrenderer_qpainter.cpp
@@ -180,7 +180,7 @@ void ItemRendererQPainter::renderSurfaceItem(QPainter *painter, SurfaceItem *sur
     const qreal xSourceBoxScale = sourceBox.width() / transformedSize.width();
     const qreal ySourceBoxScale = sourceBox.height() / transformedSize.height();
 
-    const QVector<QRectF> shape = surfaceItem->shape();
+    const QList<QRectF> shape = surfaceItem->shape();
     for (const QRectF rect : shape) {
         const QRectF target = surfaceToBufferTransform.map(rect, surfaceItem->size());
         const QRectF source(sourceBox.x() + target.x() * xSourceBoxScale,
diff --git a/src/scene/surfaceitem.cpp b/src/scene/surfaceitem.cpp
index bd8c08ae27..df54ff6101 100644
--- a/src/scene/surfaceitem.cpp
+++ b/src/scene/surfaceitem.cpp
@@ -193,7 +193,7 @@ WindowQuadList SurfaceItem::buildQuads() const
         return {};
     }
 
-    const QVector<QRectF> region = shape();
+    const QList<QRectF> region = shape();
     const auto size = pixmap()->size();
 
     WindowQuadList quads;
diff --git a/src/scene/surfaceitem_internal.cpp b/src/scene/surfaceitem_internal.cpp
index 6100efcf6a..9d08352ad9 100644
--- a/src/scene/surfaceitem_internal.cpp
+++ b/src/scene/surfaceitem_internal.cpp
@@ -34,7 +34,7 @@ InternalWindow *SurfaceItemInternal::window() const
     return m_window;
 }
 
-QVector<QRectF> SurfaceItemInternal::shape() const
+QList<QRectF> SurfaceItemInternal::shape() const
 {
     return {rect()};
 }
diff --git a/src/scene/surfaceitem_internal.h b/src/scene/surfaceitem_internal.h
index 371a5a1ea2..cc6891e7c6 100644
--- a/src/scene/surfaceitem_internal.h
+++ b/src/scene/surfaceitem_internal.h
@@ -25,7 +25,7 @@ public:
 
     InternalWindow *window() const;
 
-    QVector<QRectF> shape() const override;
+    QList<QRectF> shape() const override;
 
 private Q_SLOTS:
     void handleBufferGeometryChanged(const QRectF &old);
diff --git a/src/scene/surfaceitem_wayland.cpp b/src/scene/surfaceitem_wayland.cpp
index 2f947dd738..f2fbf971cc 100644
--- a/src/scene/surfaceitem_wayland.cpp
+++ b/src/scene/surfaceitem_wayland.cpp
@@ -61,7 +61,7 @@ SurfaceItemWayland::SurfaceItemWayland(SurfaceInterface *surface, Scene *scene,
     setSurfaceToBufferMatrix(surface->surfaceToBufferMatrix());
 }
 
-QVector<QRectF> SurfaceItemWayland::shape() const
+QList<QRectF> SurfaceItemWayland::shape() const
 {
     return {rect()};
 }
@@ -196,10 +196,10 @@ SurfaceItemXwayland::SurfaceItemXwayland(X11Window *window, Scene *scene, Item *
     connect(window, &X11Window::shapeChanged, this, &SurfaceItemXwayland::discardQuads);
 }
 
-QVector<QRectF> SurfaceItemXwayland::shape() const
+QList<QRectF> SurfaceItemXwayland::shape() const
 {
     const QRectF clipRect = rect() & m_window->clientGeometry().translated(-m_window->bufferGeometry().topLeft());
-    QVector<QRectF> shape = m_window->shapeRegion();
+    QList<QRectF> shape = m_window->shapeRegion();
 
     // bounded to clipRect
     for (QRectF &shapePart : shape) {
diff --git a/src/scene/surfaceitem_wayland.h b/src/scene/surfaceitem_wayland.h
index 67a001426b..dfc1544866 100644
--- a/src/scene/surfaceitem_wayland.h
+++ b/src/scene/surfaceitem_wayland.h
@@ -28,7 +28,7 @@ class KWIN_EXPORT SurfaceItemWayland : public SurfaceItem
 public:
     explicit SurfaceItemWayland(SurfaceInterface *surface, Scene *scene, Item *parent = nullptr);
 
-    QVector<QRectF> shape() const override;
+    QList<QRectF> shape() const override;
     QRegion opaque() const override;
     ContentType contentType() const override;
 
@@ -82,7 +82,7 @@ class KWIN_EXPORT SurfaceItemXwayland : public SurfaceItemWayland
 public:
     explicit SurfaceItemXwayland(X11Window *window, Scene *scene, Item *parent = nullptr);
 
-    QVector<QRectF> shape() const override;
+    QList<QRectF> shape() const override;
 
 private:
     X11Window *m_window;
diff --git a/src/scene/surfaceitem_x11.cpp b/src/scene/surfaceitem_x11.cpp
index 2857c62235..3311afbcdc 100644
--- a/src/scene/surfaceitem_x11.cpp
+++ b/src/scene/surfaceitem_x11.cpp
@@ -108,7 +108,7 @@ void SurfaceItemX11::waitForDamage()
     if (rectCount > 1 && rectCount < 16) {
         xcb_rectangle_t *rects = xcb_xfixes_fetch_region_rectangles(reply);
 
-        QVector<QRect> qtRects;
+        QList<QRect> qtRects;
         qtRects.reserve(rectCount);
 
         for (int i = 0; i < rectCount; ++i) {
@@ -156,10 +156,10 @@ void SurfaceItemX11::handleShapeChanged()
     discardQuads();
 }
 
-QVector<QRectF> SurfaceItemX11::shape() const
+QList<QRectF> SurfaceItemX11::shape() const
 {
     const QRectF clipRect = m_window->clientGeometry().translated(-m_window->bufferGeometry().topLeft());
-    QVector<QRectF> shape = m_window->shapeRegion();
+    QList<QRectF> shape = m_window->shapeRegion();
     // bounded to clipRect
     for (QRectF &shapePart : shape) {
         shapePart = shapePart.intersected(clipRect);
diff --git a/src/scene/surfaceitem_x11.h b/src/scene/surfaceitem_x11.h
index 2d2a8dec29..a9817b4d8d 100644
--- a/src/scene/surfaceitem_x11.h
+++ b/src/scene/surfaceitem_x11.h
@@ -37,7 +37,7 @@ public:
     void forgetDamage();
     void destroyDamage();
 
-    QVector<QRectF> shape() const override;
+    QList<QRectF> shape() const override;
     QRegion opaque() const override;
 
 private Q_SLOTS:
diff --git a/src/scene/workspacescene.h b/src/scene/workspacescene.h
index d7886e1d31..acd2a3c167 100644
--- a/src/scene/workspacescene.h
+++ b/src/scene/workspacescene.h
@@ -119,7 +119,7 @@ protected:
     {
         QRegion damage;
         int mask = 0;
-        QVector<Phase2Data> phase2Data;
+        QList<Phase2Data> phase2Data;
     };
 
     // The screen that is being currently painted
@@ -127,7 +127,7 @@ protected:
     SceneDelegate *painted_delegate = nullptr;
 
     // windows in their stacking order
-    QVector<WindowItem *> stacking_order;
+    QList<WindowItem *> stacking_order;
 
 private:
     void createDndIconItem();
diff --git a/src/scene/workspacescene_opengl.cpp b/src/scene/workspacescene_opengl.cpp
index 87732ccbe8..c733979e86 100644
--- a/src/scene/workspacescene_opengl.cpp
+++ b/src/scene/workspacescene_opengl.cpp
@@ -108,7 +108,7 @@ private:
     struct Data
     {
         std::shared_ptr<GLTexture> texture;
-        QVector<ShadowTextureProvider *> providers;
+        QList<ShadowTextureProvider *> providers;
     };
     QHash<KDecoration2::DecorationShadow *, Data> m_cache;
 };
diff --git a/src/screenedge.cpp b/src/screenedge.cpp
index 463490a248..9ff3c4f1f7 100644
--- a/src/screenedge.cpp
+++ b/src/screenedge.cpp
@@ -489,7 +489,7 @@ void Edge::switchDesktop(const QPoint &cursorPos)
         }
     }
     if (Window *c = Workspace::self()->moveResizeWindow()) {
-        const QVector<VirtualDesktop *> desktops{desktop};
+        const QList<VirtualDesktop *> desktops{desktop};
         if (c->rules()->checkDesktops(desktops) != desktops) {
             // user attempts to move a client to another desktop where it is ruleforced to not be
             return;
@@ -1535,9 +1535,9 @@ void ScreenEdges::ensureOnTop()
     Xcb::restackWindowsWithRaise(windows());
 }
 
-QVector<xcb_window_t> ScreenEdges::windows() const
+QList<xcb_window_t> ScreenEdges::windows() const
 {
-    QVector<xcb_window_t> wins;
+    QList<xcb_window_t> wins;
     for (const auto &edge : m_edges) {
         xcb_window_t w = edge->window();
         if (w != XCB_WINDOW_NONE) {
diff --git a/src/screenedge.h b/src/screenedge.h
index 74dee30b3d..75a6db7b41 100644
--- a/src/screenedge.h
+++ b/src/screenedge.h
@@ -23,9 +23,9 @@
 #include <KSharedConfig>
 // Qt
 #include <QDateTime>
+#include <QList>
 #include <QObject>
 #include <QRect>
-#include <QVector>
 
 #include <memory>
 #include <xcb/xcb.h>
@@ -150,7 +150,7 @@ private:
     void switchDesktop(const QPoint &cursorPos);
     void pushCursorBack(const QPoint &cursorPos);
     void reserveTouchCallBack(const TouchCallback &callback);
-    QVector<TouchCallback> touchCallBacks() const
+    QList<TouchCallback> touchCallBacks() const
     {
         return m_touchCallbacks;
     }
@@ -172,7 +172,7 @@ private:
     Window *m_client;
     Output *m_output;
     std::unique_ptr<SwipeGesture> m_gesture;
-    QVector<TouchCallback> m_touchCallbacks;
+    QList<TouchCallback> m_touchCallbacks;
     friend class ScreenEdges;
 };
 
@@ -332,10 +332,10 @@ public:
     bool isEntered(QMouseEvent *event);
 
     /**
-     * Returns a QVector of all existing screen edge windows
-     * @return all existing screen edge windows in a QVector
+     * Returns a QList of all existing screen edge windows
+     * @return all existing screen edge windows in a QList
      */
-    QVector<xcb_window_t> windows() const;
+    QList<xcb_window_t> windows() const;
 
     bool isDesktopSwitching() const;
     bool isDesktopSwitchingMovingClients() const;
diff --git a/src/scripting/scriptedeffect.cpp b/src/scripting/scriptedeffect.cpp
index 68d829a197..12fd8badf4 100644
--- a/src/scripting/scriptedeffect.cpp
+++ b/src/scripting/scriptedeffect.cpp
@@ -25,9 +25,9 @@
 // Qt
 #include <QAction>
 #include <QFile>
+#include <QList>
 #include <QQmlEngine>
 #include <QStandardPaths>
-#include <QVector>
 
 #include <optional>
 
@@ -336,7 +336,7 @@ QJSValue ScriptedEffect::animate_helper(const QJSValue &object, AnimationType an
         return QJSValue();
     }
 
-    QVector<AnimationSettings> settings{animationSettingsFromObject(object)}; // global
+    QList<AnimationSettings> settings{animationSettingsFromObject(object)}; // global
 
     QJSValue animations = object.property(QStringLiteral("animations")); // array
     if (!animations.isUndefined()) {
diff --git a/src/scripting/scripting.cpp b/src/scripting/scripting.cpp
index 3f047f9bf4..5cdbb3d257 100644
--- a/src/scripting/scripting.cpp
+++ b/src/scripting/scripting.cpp
@@ -641,7 +641,7 @@ void KWin::Scripting::init()
 {
     qRegisterMetaType<QList<KWin::Output *>>();
     qRegisterMetaType<QList<KWin::Window *>>();
-    qRegisterMetaType<QVector<KWin::VirtualDesktop *>>();
+    qRegisterMetaType<QList<KWin::VirtualDesktop *>>();
 
     qmlRegisterType<DesktopBackgroundItem>("org.kde.kwin", 3, 0, "DesktopBackground");
     qmlRegisterType<WindowThumbnailItem>("org.kde.kwin", 3, 0, "WindowThumbnail");
diff --git a/src/scripting/virtualdesktopmodel.h b/src/scripting/virtualdesktopmodel.h
index 1397913a10..3dad6ba5a6 100644
--- a/src/scripting/virtualdesktopmodel.h
+++ b/src/scripting/virtualdesktopmodel.h
@@ -40,7 +40,7 @@ private:
     void handleVirtualDesktopAdded(KWin::VirtualDesktop *desktop);
     void handleVirtualDesktopRemoved(KWin::VirtualDesktop *desktop);
 
-    QVector<KWin::VirtualDesktop *> m_virtualDesktops;
+    QList<KWin::VirtualDesktop *> m_virtualDesktops;
 };
 
 } // namespace KWin
diff --git a/src/scripting/workspace_wrapper.cpp b/src/scripting/workspace_wrapper.cpp
index 0c132cab5a..63052ce939 100644
--- a/src/scripting/workspace_wrapper.cpp
+++ b/src/scripting/workspace_wrapper.cpp
@@ -59,7 +59,7 @@ VirtualDesktop *WorkspaceWrapper::currentDesktop() const
     return VirtualDesktopManager::self()->currentDesktop();
 }
 
-QVector<VirtualDesktop *> WorkspaceWrapper::desktops() const
+QList<VirtualDesktop *> WorkspaceWrapper::desktops() const
 {
     return VirtualDesktopManager::self()->desktops();
 }
diff --git a/src/scripting/workspace_wrapper.h b/src/scripting/workspace_wrapper.h
index b05a5f6ee8..87d447828c 100644
--- a/src/scripting/workspace_wrapper.h
+++ b/src/scripting/workspace_wrapper.h
@@ -28,7 +28,7 @@ class VirtualDesktop;
 class WorkspaceWrapper : public QObject
 {
     Q_OBJECT
-    Q_PROPERTY(QVector<KWin::VirtualDesktop *> desktops READ desktops NOTIFY desktopsChanged)
+    Q_PROPERTY(QList<KWin::VirtualDesktop *> desktops READ desktops NOTIFY desktopsChanged)
     Q_PROPERTY(KWin::VirtualDesktop *currentDesktop READ currentDesktop WRITE setCurrentDesktop NOTIFY currentDesktopChanged)
     Q_PROPERTY(KWin::Window *activeWindow READ activeWindow WRITE setActiveWindow NOTIFY windowActivated)
     // TODO: write and notify?
@@ -188,7 +188,7 @@ public:
     QRect virtualScreenGeometry() const;
     QPoint cursorPos() const;
 
-    QVector<VirtualDesktop *> desktops() const;
+    QList<VirtualDesktop *> desktops() const;
     VirtualDesktop *currentDesktop() const;
     void setCurrentDesktop(VirtualDesktop *desktop);
 
diff --git a/src/shadow.cpp b/src/shadow.cpp
index 951f06e913..6afc3f1fe1 100644
--- a/src/shadow.cpp
+++ b/src/shadow.cpp
@@ -118,9 +118,9 @@ std::unique_ptr<Shadow> Shadow::createShadowFromInternalWindow(Window *window)
     return shadow;
 }
 
-QVector<uint32_t> Shadow::readX11ShadowProperty(xcb_window_t id)
+QList<uint32_t> Shadow::readX11ShadowProperty(xcb_window_t id)
 {
-    QVector<uint32_t> ret;
+    QList<uint32_t> ret;
     if (id != XCB_WINDOW_NONE) {
         Xcb::Property property(false, id, atoms->kde_net_wm_shadow, XCB_ATOM_CARDINAL, 0, 12);
         uint32_t *shadow = property.value<uint32_t *>();
@@ -134,10 +134,10 @@ QVector<uint32_t> Shadow::readX11ShadowProperty(xcb_window_t id)
     return ret;
 }
 
-bool Shadow::init(const QVector<uint32_t> &data)
+bool Shadow::init(const QList<uint32_t> &data)
 {
-    QVector<Xcb::WindowGeometry> pixmapGeometries(ShadowElementsCount);
-    QVector<xcb_get_image_cookie_t> getImageCookies(ShadowElementsCount);
+    QList<Xcb::WindowGeometry> pixmapGeometries(ShadowElementsCount);
+    QList<xcb_get_image_cookie_t> getImageCookies(ShadowElementsCount);
     auto *c = kwinApp()->x11Connection();
     for (int i = 0; i < ShadowElementsCount; ++i) {
         pixmapGeometries[i] = Xcb::WindowGeometry(data[i]);
diff --git a/src/shadow.h b/src/shadow.h
index 0cca918878..cfa7a8a1be 100644
--- a/src/shadow.h
+++ b/src/shadow.h
@@ -121,8 +121,8 @@ private:
     static std::unique_ptr<Shadow> createShadowFromDecoration(Window *window);
     static std::unique_ptr<Shadow> createShadowFromWayland(Window *window);
     static std::unique_ptr<Shadow> createShadowFromInternalWindow(Window *window);
-    static QVector<uint32_t> readX11ShadowProperty(xcb_window_t id);
-    bool init(const QVector<uint32_t> &data);
+    static QList<uint32_t> readX11ShadowProperty(xcb_window_t id);
+    bool init(const QList<uint32_t> &data);
     bool init(KDecoration2::Decoration *decoration);
     bool init(const QPointer<ShadowInterface> &shadow);
     bool init(const QWindow *window);
diff --git a/src/syncalarmx11filter.cpp b/src/syncalarmx11filter.cpp
index 1c5c6ea6a4..f4b4d49caa 100644
--- a/src/syncalarmx11filter.cpp
+++ b/src/syncalarmx11filter.cpp
@@ -16,7 +16,7 @@ namespace KWin
 {
 
 SyncAlarmX11Filter::SyncAlarmX11Filter()
-    : X11EventFilter(QVector<int>{Xcb::Extensions::self()->syncAlarmNotifyEvent()})
+    : X11EventFilter(QList<int>{Xcb::Extensions::self()->syncAlarmNotifyEvent()})
 {
 }
 
diff --git a/src/tabbox/tabbox.cpp b/src/tabbox/tabbox.cpp
index 1980ee28c1..b857db3794 100644
--- a/src/tabbox/tabbox.cpp
+++ b/src/tabbox/tabbox.cpp
@@ -264,7 +264,7 @@ void TabBoxHandlerImpl::highlightWindows(Window *window, QWindow *controller)
     if (!effects) {
         return;
     }
-    QVector<EffectWindow *> windows;
+    QList<EffectWindow *> windows;
     if (window) {
         windows << window->effectWindow();
     }
diff --git a/src/tabbox/x11_filter.cpp b/src/tabbox/x11_filter.cpp
index 5150fe1ab9..89bfc70f12 100644
--- a/src/tabbox/x11_filter.cpp
+++ b/src/tabbox/x11_filter.cpp
@@ -24,7 +24,7 @@ namespace TabBox
 {
 
 X11Filter::X11Filter()
-    : X11EventFilter(QVector<int>{XCB_KEY_PRESS, XCB_KEY_RELEASE, XCB_MOTION_NOTIFY, XCB_BUTTON_PRESS, XCB_BUTTON_RELEASE})
+    : X11EventFilter(QList<int>{XCB_KEY_PRESS, XCB_KEY_RELEASE, XCB_MOTION_NOTIFY, XCB_BUTTON_PRESS, XCB_BUTTON_RELEASE})
 {
 }
 
diff --git a/src/useractions.cpp b/src/useractions.cpp
index 851c0c7f03..f1245e8420 100644
--- a/src/useractions.cpp
+++ b/src/useractions.cpp
@@ -1012,7 +1012,7 @@ void Workspace::initShortcuts()
     VirtualDesktopManager *vds = VirtualDesktopManager::self();
     for (uint i = 0; i < vds->maximum(); ++i) {
         auto handler = [this, i]() {
-            const QVector<VirtualDesktop *> desktops = VirtualDesktopManager::self()->desktops();
+            const QList<VirtualDesktop *> desktops = VirtualDesktopManager::self()->desktops();
             if (i < uint(desktops.count())) {
                 slotWindowToDesktop(desktops[i]);
             }
diff --git a/src/utils/common.h b/src/utils/common.h
index 1f1d6f7eb7..3ddb19d73b 100644
--- a/src/utils/common.h
+++ b/src/utils/common.h
@@ -58,7 +58,7 @@ public:
 private:
     StrutArea m_area;
 };
-typedef QVector<StrutRect> StrutRects;
+typedef QList<StrutRect> StrutRects;
 
 enum ShadeMode {
     ShadeNone, // not shaded
diff --git a/src/utils/udev.h b/src/utils/udev.h
index b935e77862..cc8e096ba6 100644
--- a/src/utils/udev.h
+++ b/src/utils/udev.h
@@ -10,7 +10,7 @@
 #include <kwin_export.h>
 #include <memory>
 
-#include <QVector>
+#include <QList>
 #include <vector>
 
 #include <sys/types.h>
diff --git a/src/utils/xcbutils.cpp b/src/utils/xcbutils.cpp
index 9731f483c0..e4065c1e9b 100644
--- a/src/utils/xcbutils.cpp
+++ b/src/utils/xcbutils.cpp
@@ -47,224 +47,224 @@ static const int RENDER_MAX_MINOR = 11;
 static const int XFIXES_MAX_MAJOR = 5;
 static const int XFIXES_MAX_MINOR = 0;
 
-QVector<QByteArray> shapeOpCodes()
+QList<QByteArray> shapeOpCodes()
 {
     // see https://www.x.org/releases/X11R7.7/doc/xextproto/shape.html
     // extracted from <xcb/shape.h>
-    return QVector<QByteArray>({QByteArrayLiteral("QueryVersion"),
-                                QByteArrayLiteral("Rectangles"),
-                                QByteArrayLiteral("Mask"),
-                                QByteArrayLiteral("Combine"),
-                                QByteArrayLiteral("Offset"),
-                                QByteArrayLiteral("Extents"),
-                                QByteArrayLiteral("Input"),
-                                QByteArrayLiteral("InputSelected"),
-                                QByteArrayLiteral("GetRectangles")});
+    return QList<QByteArray>({QByteArrayLiteral("QueryVersion"),
+                              QByteArrayLiteral("Rectangles"),
+                              QByteArrayLiteral("Mask"),
+                              QByteArrayLiteral("Combine"),
+                              QByteArrayLiteral("Offset"),
+                              QByteArrayLiteral("Extents"),
+                              QByteArrayLiteral("Input"),
+                              QByteArrayLiteral("InputSelected"),
+                              QByteArrayLiteral("GetRectangles")});
 }
 
-QVector<QByteArray> randrOpCodes()
+QList<QByteArray> randrOpCodes()
 {
     // see https://www.x.org/releases/X11R7.7/doc/randrproto/randrproto.txt
     // extracted from <xcb/randr.h>
-    return QVector<QByteArray>({QByteArrayLiteral("QueryVersion"),
-                                QByteArray(""), // doesn't exist
-                                QByteArrayLiteral("SetScreenConfig"),
-                                QByteArray(""), // doesn't exits
-                                QByteArrayLiteral("SelectInput"),
-                                QByteArrayLiteral("GetScreenInfo"),
-                                QByteArrayLiteral("GetScreenSizeRange"),
-                                QByteArrayLiteral("SetScreenSize"),
-                                QByteArrayLiteral("GetScreenResources"),
-                                QByteArrayLiteral("GetOutputInfo"),
-                                QByteArrayLiteral("ListOutputProperties"),
-                                QByteArrayLiteral("QueryOutputProperty"),
-                                QByteArrayLiteral("ConfigureOutputProperty"),
-                                QByteArrayLiteral("ChangeOutputProperty"),
-                                QByteArrayLiteral("DeleteOutputProperty"),
-                                QByteArrayLiteral("GetOutputproperty"),
-                                QByteArrayLiteral("CreateMode"),
-                                QByteArrayLiteral("DestroyMode"),
-                                QByteArrayLiteral("AddOutputMode"),
-                                QByteArrayLiteral("DeleteOutputMode"),
-                                QByteArrayLiteral("GetCrtcInfo"),
-                                QByteArrayLiteral("SetCrtcConfig"),
-                                QByteArrayLiteral("GetCrtcGammaSize"),
-                                QByteArrayLiteral("GetCrtcGamma"),
-                                QByteArrayLiteral("SetCrtcGamma"),
-                                QByteArrayLiteral("GetScreenResourcesCurrent"),
-                                QByteArrayLiteral("SetCrtcTransform"),
-                                QByteArrayLiteral("GetCrtcTransform"),
-                                QByteArrayLiteral("GetPanning"),
-                                QByteArrayLiteral("SetPanning"),
-                                QByteArrayLiteral("SetOutputPrimary"),
-                                QByteArrayLiteral("GetOutputPrimary"),
-                                QByteArrayLiteral("GetProviders"),
-                                QByteArrayLiteral("GetProviderInfo"),
-                                QByteArrayLiteral("SetProviderOffloadSink"),
-                                QByteArrayLiteral("SetProviderOutputSource"),
-                                QByteArrayLiteral("ListProviderProperties"),
-                                QByteArrayLiteral("QueryProviderProperty"),
-                                QByteArrayLiteral("ConfigureProviderroperty"),
-                                QByteArrayLiteral("ChangeProviderProperty"),
-                                QByteArrayLiteral("DeleteProviderProperty"),
-                                QByteArrayLiteral("GetProviderProperty")});
-}
-
-QVector<QByteArray> randrErrorCodes()
+    return QList<QByteArray>({QByteArrayLiteral("QueryVersion"),
+                              QByteArray(""), // doesn't exist
+                              QByteArrayLiteral("SetScreenConfig"),
+                              QByteArray(""), // doesn't exits
+                              QByteArrayLiteral("SelectInput"),
+                              QByteArrayLiteral("GetScreenInfo"),
+                              QByteArrayLiteral("GetScreenSizeRange"),
+                              QByteArrayLiteral("SetScreenSize"),
+                              QByteArrayLiteral("GetScreenResources"),
+                              QByteArrayLiteral("GetOutputInfo"),
+                              QByteArrayLiteral("ListOutputProperties"),
+                              QByteArrayLiteral("QueryOutputProperty"),
+                              QByteArrayLiteral("ConfigureOutputProperty"),
+                              QByteArrayLiteral("ChangeOutputProperty"),
+                              QByteArrayLiteral("DeleteOutputProperty"),
+                              QByteArrayLiteral("GetOutputproperty"),
+                              QByteArrayLiteral("CreateMode"),
+                              QByteArrayLiteral("DestroyMode"),
+                              QByteArrayLiteral("AddOutputMode"),
+                              QByteArrayLiteral("DeleteOutputMode"),
+                              QByteArrayLiteral("GetCrtcInfo"),
+                              QByteArrayLiteral("SetCrtcConfig"),
+                              QByteArrayLiteral("GetCrtcGammaSize"),
+                              QByteArrayLiteral("GetCrtcGamma"),
+                              QByteArrayLiteral("SetCrtcGamma"),
+                              QByteArrayLiteral("GetScreenResourcesCurrent"),
+                              QByteArrayLiteral("SetCrtcTransform"),
+                              QByteArrayLiteral("GetCrtcTransform"),
+                              QByteArrayLiteral("GetPanning"),
+                              QByteArrayLiteral("SetPanning"),
+                              QByteArrayLiteral("SetOutputPrimary"),
+                              QByteArrayLiteral("GetOutputPrimary"),
+                              QByteArrayLiteral("GetProviders"),
+                              QByteArrayLiteral("GetProviderInfo"),
+                              QByteArrayLiteral("SetProviderOffloadSink"),
+                              QByteArrayLiteral("SetProviderOutputSource"),
+                              QByteArrayLiteral("ListProviderProperties"),
+                              QByteArrayLiteral("QueryProviderProperty"),
+                              QByteArrayLiteral("ConfigureProviderroperty"),
+                              QByteArrayLiteral("ChangeProviderProperty"),
+                              QByteArrayLiteral("DeleteProviderProperty"),
+                              QByteArrayLiteral("GetProviderProperty")});
+}
+
+QList<QByteArray> randrErrorCodes()
 {
     // see https://www.x.org/releases/X11R7.7/doc/randrproto/randrproto.txt
     // extracted from <xcb/randr.h>
-    return QVector<QByteArray>({QByteArrayLiteral("BadOutput"),
-                                QByteArrayLiteral("BadCrtc"),
-                                QByteArrayLiteral("BadMode"),
-                                QByteArrayLiteral("BadProvider")});
+    return QList<QByteArray>({QByteArrayLiteral("BadOutput"),
+                              QByteArrayLiteral("BadCrtc"),
+                              QByteArrayLiteral("BadMode"),
+                              QByteArrayLiteral("BadProvider")});
 }
 
-QVector<QByteArray> damageOpCodes()
+QList<QByteArray> damageOpCodes()
 {
     // see https://www.x.org/releases/X11R7.7/doc/damageproto/damageproto.txt
     // extracted from <xcb/damage.h>
-    return QVector<QByteArray>({QByteArrayLiteral("QueryVersion"),
-                                QByteArrayLiteral("Create"),
-                                QByteArrayLiteral("Destroy"),
-                                QByteArrayLiteral("Subtract"),
-                                QByteArrayLiteral("Add")});
+    return QList<QByteArray>({QByteArrayLiteral("QueryVersion"),
+                              QByteArrayLiteral("Create"),
+                              QByteArrayLiteral("Destroy"),
+                              QByteArrayLiteral("Subtract"),
+                              QByteArrayLiteral("Add")});
 }
 
-QVector<QByteArray> damageErrorCodes()
+QList<QByteArray> damageErrorCodes()
 {
     // see https://www.x.org/releases/X11R7.7/doc/damageproto/damageproto.txt
     // extracted from <xcb/damage.h>
-    return QVector<QByteArray>({QByteArrayLiteral("BadDamage")});
+    return QList<QByteArray>({QByteArrayLiteral("BadDamage")});
 }
 
-QVector<QByteArray> compositeOpCodes()
+QList<QByteArray> compositeOpCodes()
 {
     // see https://www.x.org/releases/X11R7.7/doc/compositeproto/compositeproto.txt
     // extracted from <xcb/composite.h>
-    return QVector<QByteArray>({QByteArrayLiteral("QueryVersion"),
-                                QByteArrayLiteral("RedirectWindow"),
-                                QByteArrayLiteral("RedirectSubwindows"),
-                                QByteArrayLiteral("UnredirectWindow"),
-                                QByteArrayLiteral("UnredirectSubwindows"),
-                                QByteArrayLiteral("CreateRegionFromBorderClip"),
-                                QByteArrayLiteral("NameWindowPixmap"),
-                                QByteArrayLiteral("GetOverlayWindow"),
-                                QByteArrayLiteral("ReleaseOverlayWindow")});
+    return QList<QByteArray>({QByteArrayLiteral("QueryVersion"),
+                              QByteArrayLiteral("RedirectWindow"),
+                              QByteArrayLiteral("RedirectSubwindows"),
+                              QByteArrayLiteral("UnredirectWindow"),
+                              QByteArrayLiteral("UnredirectSubwindows"),
+                              QByteArrayLiteral("CreateRegionFromBorderClip"),
+                              QByteArrayLiteral("NameWindowPixmap"),
+                              QByteArrayLiteral("GetOverlayWindow"),
+                              QByteArrayLiteral("ReleaseOverlayWindow")});
 }
 
-QVector<QByteArray> fixesOpCodes()
+QList<QByteArray> fixesOpCodes()
 {
     // see https://www.x.org/releases/X11R7.7/doc/fixesproto/fixesproto.txt
     // extracted from <xcb/xfixes.h>
-    return QVector<QByteArray>({QByteArrayLiteral("QueryVersion"),
-                                QByteArrayLiteral("ChangeSaveSet"),
-                                QByteArrayLiteral("SelectSelectionInput"),
-                                QByteArrayLiteral("SelectCursorInput"),
-                                QByteArrayLiteral("GetCursorImage"),
-                                QByteArrayLiteral("CreateRegion"),
-                                QByteArrayLiteral("CreateRegionFromBitmap"),
-                                QByteArrayLiteral("CreateRegionFromWindow"),
-                                QByteArrayLiteral("CreateRegionFromGc"),
-                                QByteArrayLiteral("CreateRegionFromPicture"),
-                                QByteArrayLiteral("DestroyRegion"),
-                                QByteArrayLiteral("SetRegion"),
-                                QByteArrayLiteral("CopyRegion"),
-                                QByteArrayLiteral("UnionRegion"),
-                                QByteArrayLiteral("IntersectRegion"),
-                                QByteArrayLiteral("SubtractRegion"),
-                                QByteArrayLiteral("InvertRegion"),
-                                QByteArrayLiteral("TranslateRegion"),
-                                QByteArrayLiteral("RegionExtents"),
-                                QByteArrayLiteral("FetchRegion"),
-                                QByteArrayLiteral("SetGcClipRegion"),
-                                QByteArrayLiteral("SetWindowShapeRegion"),
-                                QByteArrayLiteral("SetPictureClipRegion"),
-                                QByteArrayLiteral("SetCursorName"),
-                                QByteArrayLiteral("GetCursorName"),
-                                QByteArrayLiteral("GetCursorImageAndName"),
-                                QByteArrayLiteral("ChangeCursor"),
-                                QByteArrayLiteral("ChangeCursorByName"),
-                                QByteArrayLiteral("ExpandRegion"),
-                                QByteArrayLiteral("HideCursor"),
-                                QByteArrayLiteral("ShowCursor"),
-                                QByteArrayLiteral("CreatePointerBarrier"),
-                                QByteArrayLiteral("DeletePointerBarrier")});
-}
-
-QVector<QByteArray> fixesErrorCodes()
+    return QList<QByteArray>({QByteArrayLiteral("QueryVersion"),
+                              QByteArrayLiteral("ChangeSaveSet"),
+                              QByteArrayLiteral("SelectSelectionInput"),
+                              QByteArrayLiteral("SelectCursorInput"),
+                              QByteArrayLiteral("GetCursorImage"),
+                              QByteArrayLiteral("CreateRegion"),
+                              QByteArrayLiteral("CreateRegionFromBitmap"),
+                              QByteArrayLiteral("CreateRegionFromWindow"),
+                              QByteArrayLiteral("CreateRegionFromGc"),
+                              QByteArrayLiteral("CreateRegionFromPicture"),
+                              QByteArrayLiteral("DestroyRegion"),
+                              QByteArrayLiteral("SetRegion"),
+                              QByteArrayLiteral("CopyRegion"),
+                              QByteArrayLiteral("UnionRegion"),
+                              QByteArrayLiteral("IntersectRegion"),
+                              QByteArrayLiteral("SubtractRegion"),
+                              QByteArrayLiteral("InvertRegion"),
+                              QByteArrayLiteral("TranslateRegion"),
+                              QByteArrayLiteral("RegionExtents"),
+                              QByteArrayLiteral("FetchRegion"),
+                              QByteArrayLiteral("SetGcClipRegion"),
+                              QByteArrayLiteral("SetWindowShapeRegion"),
+                              QByteArrayLiteral("SetPictureClipRegion"),
+                              QByteArrayLiteral("SetCursorName"),
+                              QByteArrayLiteral("GetCursorName"),
+                              QByteArrayLiteral("GetCursorImageAndName"),
+                              QByteArrayLiteral("ChangeCursor"),
+                              QByteArrayLiteral("ChangeCursorByName"),
+                              QByteArrayLiteral("ExpandRegion"),
+                              QByteArrayLiteral("HideCursor"),
+                              QByteArrayLiteral("ShowCursor"),
+                              QByteArrayLiteral("CreatePointerBarrier"),
+                              QByteArrayLiteral("DeletePointerBarrier")});
+}
+
+QList<QByteArray> fixesErrorCodes()
 {
     // see https://www.x.org/releases/X11R7.7/doc/fixesproto/fixesproto.txt
     // extracted from <xcb/xfixes.h>
-    return QVector<QByteArray>({QByteArrayLiteral("BadRegion")});
+    return QList<QByteArray>({QByteArrayLiteral("BadRegion")});
 }
 
-QVector<QByteArray> renderOpCodes()
+QList<QByteArray> renderOpCodes()
 {
     // see https://www.x.org/releases/X11R7.7/doc/renderproto/renderproto.txt
     // extracted from <xcb/render.h>
-    return QVector<QByteArray>({QByteArrayLiteral("QueryVersion"),
-                                QByteArrayLiteral("QueryPictFormats"),
-                                QByteArrayLiteral("QueryPictIndexValues"),
-                                QByteArrayLiteral("CreatePicture"),
-                                QByteArrayLiteral("ChangePicture"),
-                                QByteArrayLiteral("SetPictureClipRectangles"),
-                                QByteArrayLiteral("FreePicture"),
-                                QByteArrayLiteral("Composite"),
-                                QByteArrayLiteral("Trapezoids"),
-                                QByteArrayLiteral("Triangles"),
-                                QByteArrayLiteral("TriStrip"),
-                                QByteArrayLiteral("TriFan"),
-                                QByteArrayLiteral("CreateGlyphSet"),
-                                QByteArrayLiteral("ReferenceGlyphSet"),
-                                QByteArrayLiteral("FreeGlyphSet"),
-                                QByteArrayLiteral("AddGlyphs"),
-                                QByteArrayLiteral("FreeGlyphs"),
-                                QByteArrayLiteral("CompositeGlyphs8"),
-                                QByteArrayLiteral("CompositeGlyphs16"),
-                                QByteArrayLiteral("CompositeGlyphs32"),
-                                QByteArrayLiteral("FillRectangles"),
-                                QByteArrayLiteral("CreateCursor"),
-                                QByteArrayLiteral("SetPictureTransform"),
-                                QByteArrayLiteral("QueryFilters"),
-                                QByteArrayLiteral("SetPictureFilter"),
-                                QByteArrayLiteral("CreateAnimCursor"),
-                                QByteArrayLiteral("AddTraps"),
-                                QByteArrayLiteral("CreateSolidFill"),
-                                QByteArrayLiteral("CreateLinearGradient"),
-                                QByteArrayLiteral("CreateRadialGradient"),
-                                QByteArrayLiteral("CreateConicalGradient")});
-}
-
-QVector<QByteArray> syncOpCodes()
+    return QList<QByteArray>({QByteArrayLiteral("QueryVersion"),
+                              QByteArrayLiteral("QueryPictFormats"),
+                              QByteArrayLiteral("QueryPictIndexValues"),
+                              QByteArrayLiteral("CreatePicture"),
+                              QByteArrayLiteral("ChangePicture"),
+                              QByteArrayLiteral("SetPictureClipRectangles"),
+                              QByteArrayLiteral("FreePicture"),
+                              QByteArrayLiteral("Composite"),
+                              QByteArrayLiteral("Trapezoids"),
+                              QByteArrayLiteral("Triangles"),
+                              QByteArrayLiteral("TriStrip"),
+                              QByteArrayLiteral("TriFan"),
+                              QByteArrayLiteral("CreateGlyphSet"),
+                              QByteArrayLiteral("ReferenceGlyphSet"),
+                              QByteArrayLiteral("FreeGlyphSet"),
+                              QByteArrayLiteral("AddGlyphs"),
+                              QByteArrayLiteral("FreeGlyphs"),
+                              QByteArrayLiteral("CompositeGlyphs8"),
+                              QByteArrayLiteral("CompositeGlyphs16"),
+                              QByteArrayLiteral("CompositeGlyphs32"),
+                              QByteArrayLiteral("FillRectangles"),
+                              QByteArrayLiteral("CreateCursor"),
+                              QByteArrayLiteral("SetPictureTransform"),
+                              QByteArrayLiteral("QueryFilters"),
+                              QByteArrayLiteral("SetPictureFilter"),
+                              QByteArrayLiteral("CreateAnimCursor"),
+                              QByteArrayLiteral("AddTraps"),
+                              QByteArrayLiteral("CreateSolidFill"),
+                              QByteArrayLiteral("CreateLinearGradient"),
+                              QByteArrayLiteral("CreateRadialGradient"),
+                              QByteArrayLiteral("CreateConicalGradient")});
+}
+
+QList<QByteArray> syncOpCodes()
 {
     // see https://www.x.org/releases/X11R7.7/doc/xextproto/sync.html
     // extracted from <xcb/sync.h>
-    return QVector<QByteArray>({QByteArrayLiteral("Initialize"),
-                                QByteArrayLiteral("ListSystemCounters"),
-                                QByteArrayLiteral("CreateCounter"),
-                                QByteArrayLiteral("DestroyCounter"),
-                                QByteArrayLiteral("QueryCounter"),
-                                QByteArrayLiteral("Await"),
-                                QByteArrayLiteral("ChangeCounter"),
-                                QByteArrayLiteral("SetCounter"),
-                                QByteArrayLiteral("CreateAlarm"),
-                                QByteArrayLiteral("ChangeAlarm"),
-                                QByteArrayLiteral("DestroyAlarm"),
-                                QByteArrayLiteral("QueryAlarm"),
-                                QByteArrayLiteral("SetPriority"),
-                                QByteArrayLiteral("GetPriority"),
-                                QByteArrayLiteral("CreateFence"),
-                                QByteArrayLiteral("TriggerFence"),
-                                QByteArrayLiteral("ResetFence"),
-                                QByteArrayLiteral("DestroyFence"),
-                                QByteArrayLiteral("QueryFence"),
-                                QByteArrayLiteral("AwaitFence")});
-}
-
-static QVector<QByteArray> glxOpCodes()
-{
-    return QVector<QByteArray>{
+    return QList<QByteArray>({QByteArrayLiteral("Initialize"),
+                              QByteArrayLiteral("ListSystemCounters"),
+                              QByteArrayLiteral("CreateCounter"),
+                              QByteArrayLiteral("DestroyCounter"),
+                              QByteArrayLiteral("QueryCounter"),
+                              QByteArrayLiteral("Await"),
+                              QByteArrayLiteral("ChangeCounter"),
+                              QByteArrayLiteral("SetCounter"),
+                              QByteArrayLiteral("CreateAlarm"),
+                              QByteArrayLiteral("ChangeAlarm"),
+                              QByteArrayLiteral("DestroyAlarm"),
+                              QByteArrayLiteral("QueryAlarm"),
+                              QByteArrayLiteral("SetPriority"),
+                              QByteArrayLiteral("GetPriority"),
+                              QByteArrayLiteral("CreateFence"),
+                              QByteArrayLiteral("TriggerFence"),
+                              QByteArrayLiteral("ResetFence"),
+                              QByteArrayLiteral("DestroyFence"),
+                              QByteArrayLiteral("QueryFence"),
+                              QByteArrayLiteral("AwaitFence")});
+}
+
+static QList<QByteArray> glxOpCodes()
+{
+    return QList<QByteArray>{
         QByteArrayLiteral(""),
         QByteArrayLiteral("Render"),
         QByteArrayLiteral("RenderLarge"),
@@ -306,9 +306,9 @@ static QVector<QByteArray> glxOpCodes()
     };
 }
 
-static QVector<QByteArray> glxErrorCodes()
+static QList<QByteArray> glxErrorCodes()
 {
-    return QVector<QByteArray>{
+    return QList<QByteArray>{
         QByteArrayLiteral("BadContext"),
         QByteArrayLiteral("BadContextState"),
         QByteArrayLiteral("BadDrawable"),
@@ -541,7 +541,7 @@ int Extensions::syncAlarmNotifyEvent() const
     return m_sync.eventBase + XCB_SYNC_ALARM_NOTIFY;
 }
 
-QVector<ExtensionData> Extensions::extensions() const
+QList<ExtensionData> Extensions::extensions() const
 {
     return {
         m_shape,
diff --git a/src/utils/xcbutils.h b/src/utils/xcbutils.h
index 61fa72ae9a..eb084fa055 100644
--- a/src/utils/xcbutils.h
+++ b/src/utils/xcbutils.h
@@ -14,9 +14,9 @@
 #include "main.h"
 #include "utils/c_ptr.h"
 
+#include <QList>
 #include <QRect>
 #include <QRegion>
-#include <QVector>
 
 #include <xcb/composite.h>
 #include <xcb/randr.h>
@@ -1462,8 +1462,8 @@ public:
     int majorOpcode;
     bool present;
     QByteArray name;
-    QVector<QByteArray> opCodes;
-    QVector<QByteArray> errorCodes;
+    QList<QByteArray> opCodes;
+    QList<QByteArray> errorCodes;
 };
 
 class KWIN_EXPORT Extensions
@@ -1507,7 +1507,7 @@ public:
         return m_sync.present;
     }
     int syncAlarmNotifyEvent() const;
-    QVector<ExtensionData> extensions() const;
+    QList<ExtensionData> extensions() const;
     bool hasGlx() const
     {
         return m_glx.present;
@@ -1944,7 +1944,7 @@ static inline WindowId createInputWindow(const QRect &geometry, uint32_t mask, c
     return window;
 }
 
-static inline void restackWindows(const QVector<xcb_window_t> &windows)
+static inline void restackWindows(const QList<xcb_window_t> &windows)
 {
     if (windows.count() < 2) {
         // only one window, nothing to do
@@ -1959,7 +1959,7 @@ static inline void restackWindows(const QVector<xcb_window_t> &windows)
     }
 }
 
-static inline void restackWindowsWithRaise(const QVector<xcb_window_t> &windows)
+static inline void restackWindowsWithRaise(const QList<xcb_window_t> &windows)
 {
     if (windows.isEmpty()) {
         return;
@@ -1990,9 +1990,9 @@ static inline xcb_rectangle_t fromQt(const QRect &rect)
     return rectangle;
 }
 
-static inline QVector<xcb_rectangle_t> regionToRects(const QRegion &region)
+static inline QList<xcb_rectangle_t> regionToRects(const QRegion &region)
 {
-    QVector<xcb_rectangle_t> rects;
+    QList<xcb_rectangle_t> rects;
     rects.reserve(region.rectCount());
     for (const QRect &rect : region) {
         rects.append(Xcb::fromQt(rect));
diff --git a/src/utils/xcursortheme.cpp b/src/utils/xcursortheme.cpp
index 95ac8bab64..11f162d576 100644
--- a/src/utils/xcursortheme.cpp
+++ b/src/utils/xcursortheme.cpp
@@ -34,7 +34,7 @@ public:
     void load(const QString &themeName, int size, qreal devicePixelRatio);
     void loadCursors(const QString &packagePath, int size, qreal devicePixelRatio);
 
-    QHash<QByteArray, QVector<KXcursorSprite>> registry;
+    QHash<QByteArray, QList<KXcursorSprite>> registry;
 };
 
 KXcursorSprite::KXcursorSprite()
@@ -81,14 +81,14 @@ std::chrono::milliseconds KXcursorSprite::delay() const
     return d->delay;
 }
 
-static QVector<KXcursorSprite> loadCursor(const QString &filePath, int desiredSize, qreal devicePixelRatio)
+static QList<KXcursorSprite> loadCursor(const QString &filePath, int desiredSize, qreal devicePixelRatio)
 {
     XcursorImages *images = XcursorFileLoadImages(QFile::encodeName(filePath), desiredSize * devicePixelRatio);
     if (!images) {
         return {};
     }
 
-    QVector<KXcursorSprite> sprites;
+    QList<KXcursorSprite> sprites;
     for (int i = 0; i < images->nimage; ++i) {
         const XcursorImage *nativeCursorImage = images->images[i];
         const qreal scale = std::max(qreal(1), qreal(nativeCursorImage->size) / desiredSize);
@@ -129,7 +129,7 @@ void KXcursorThemePrivate::loadCursors(const QString &packagePath, int size, qre
                 }
             }
         }
-        const QVector<KXcursorSprite> sprites = loadCursor(entry.absoluteFilePath(), size, devicePixelRatio);
+        const QList<KXcursorSprite> sprites = loadCursor(entry.absoluteFilePath(), size, devicePixelRatio);
         if (!sprites.isEmpty()) {
             registry.insert(shape, sprites);
         }
@@ -233,7 +233,7 @@ bool KXcursorTheme::isEmpty() const
     return d->registry.isEmpty();
 }
 
-QVector<KXcursorSprite> KXcursorTheme::shape(const QByteArray &name) const
+QList<KXcursorSprite> KXcursorTheme::shape(const QByteArray &name) const
 {
     return d->registry.value(name);
 }
diff --git a/src/utils/xcursortheme.h b/src/utils/xcursortheme.h
index 90eba2226b..cf66d943ab 100644
--- a/src/utils/xcursortheme.h
+++ b/src/utils/xcursortheme.h
@@ -9,8 +9,8 @@
 #include <kwin_export.h>
 
 #include <QImage>
+#include <QList>
 #include <QSharedDataPointer>
-#include <QVector>
 
 #include <chrono>
 
@@ -117,7 +117,7 @@ public:
     /**
      * Returns the list of cursor sprites for the cursor with the given @a name.
      */
-    QVector<KXcursorSprite> shape(const QByteArray &name) const;
+    QList<KXcursorSprite> shape(const QByteArray &name) const;
 
 private:
     QSharedDataPointer<KXcursorThemePrivate> d;
diff --git a/src/virtualdesktops.cpp b/src/virtualdesktops.cpp
index 7f64e3d9b7..173b3ddd43 100644
--- a/src/virtualdesktops.cpp
+++ b/src/virtualdesktops.cpp
@@ -135,13 +135,13 @@ void VirtualDesktop::setName(const QString &name)
 
 VirtualDesktopGrid::VirtualDesktopGrid()
     : m_size(1, 2) // Default to tow rows
-    , m_grid(QVector<QVector<VirtualDesktop *>>{QVector<VirtualDesktop *>{}, QVector<VirtualDesktop *>{}})
+    , m_grid(QList<QList<VirtualDesktop *>>{QList<VirtualDesktop *>{}, QList<VirtualDesktop *>{}})
 {
 }
 
 VirtualDesktopGrid::~VirtualDesktopGrid() = default;
 
-void VirtualDesktopGrid::update(const QSize &size, Qt::Orientation orientation, const QVector<VirtualDesktop *> &desktops)
+void VirtualDesktopGrid::update(const QSize &size, Qt::Orientation orientation, const QList<VirtualDesktop *> &desktops)
 {
     // Set private variables
     m_size = size;
@@ -153,7 +153,7 @@ void VirtualDesktopGrid::update(const QSize &size, Qt::Orientation orientation,
     auto end = desktops.end();
     if (orientation == Qt::Horizontal) {
         for (uint y = 0; y < height; ++y) {
-            QVector<VirtualDesktop *> row;
+            QList<VirtualDesktop *> row;
             for (uint x = 0; x < width && it != end; ++x) {
                 row << *it;
                 it++;
@@ -162,7 +162,7 @@ void VirtualDesktopGrid::update(const QSize &size, Qt::Orientation orientation,
         }
     } else {
         for (uint y = 0; y < height; ++y) {
-            m_grid << QVector<VirtualDesktop *>();
+            m_grid << QList<VirtualDesktop *>();
         }
         for (uint x = 0; x < width; ++x) {
             for (uint y = 0; y < height && it != end; ++y) {
diff --git a/src/virtualdesktops.h b/src/virtualdesktops.h
index dc3df6832b..673ab0a0ba 100644
--- a/src/virtualdesktops.h
+++ b/src/virtualdesktops.h
@@ -86,7 +86,7 @@ class VirtualDesktopGrid
 public:
     VirtualDesktopGrid();
     ~VirtualDesktopGrid();
-    void update(const QSize &size, Qt::Orientation orientation, const QVector<VirtualDesktop *> &desktops);
+    void update(const QSize &size, Qt::Orientation orientation, const QList<VirtualDesktop *> &desktops);
     /**
      * @returns The coords of desktop @a id in grid units.
      */
@@ -106,7 +106,7 @@ public:
 
 private:
     QSize m_size;
-    QVector<QVector<VirtualDesktop *>> m_grid;
+    QList<QList<VirtualDesktop *>> m_grid;
 };
 
 /**
@@ -249,7 +249,7 @@ public:
     /**
      * @returns all currently managed VirtualDesktops
      */
-    QVector<VirtualDesktop *> desktops() const
+    QList<VirtualDesktop *> desktops() const
     {
         return m_desktops;
     }
@@ -479,7 +479,7 @@ private:
      */
     QAction *addAction(const QString &name, const QString &label, const QKeySequence &key, void (VirtualDesktopManager::*slot)());
 
-    QVector<VirtualDesktop *> m_desktops;
+    QList<VirtualDesktop *> m_desktops;
     QPointer<VirtualDesktop> m_current;
     quint32 m_rows = 2;
     bool m_navigationWrapsAround;
diff --git a/src/virtualdesktopsdbustypes.h b/src/virtualdesktopsdbustypes.h
index 0d5485df53..b5e7296a7e 100644
--- a/src/virtualdesktopsdbustypes.h
+++ b/src/virtualdesktopsdbustypes.h
@@ -20,7 +20,7 @@ struct DBusDesktopDataStruct
     QString id;
     QString name;
 };
-typedef QVector<DBusDesktopDataStruct> DBusDesktopDataVector;
+typedef QList<DBusDesktopDataStruct> DBusDesktopDataVector;
 }
 
 const QDBusArgument &operator<<(QDBusArgument &argument, const KWin::DBusDesktopDataStruct &desk);
diff --git a/src/was_user_interaction_x11_filter.cpp b/src/was_user_interaction_x11_filter.cpp
index 1d1b89bb5e..e02a80eb03 100644
--- a/src/was_user_interaction_x11_filter.cpp
+++ b/src/was_user_interaction_x11_filter.cpp
@@ -13,7 +13,7 @@
 namespace KWin
 {
 WasUserInteractionX11Filter::WasUserInteractionX11Filter()
-    : X11EventFilter(QVector<int>{XCB_KEY_PRESS, XCB_KEY_RELEASE, XCB_BUTTON_PRESS, XCB_BUTTON_RELEASE})
+    : X11EventFilter(QList<int>{XCB_KEY_PRESS, XCB_KEY_RELEASE, XCB_BUTTON_PRESS, XCB_BUTTON_RELEASE})
 {
 }
 
diff --git a/src/wayland/appmenu.cpp b/src/wayland/appmenu.cpp
index ca233e3452..e1609e0f1d 100644
--- a/src/wayland/appmenu.cpp
+++ b/src/wayland/appmenu.cpp
@@ -21,7 +21,7 @@ class AppMenuManagerInterfacePrivate : public QtWaylandServer::org_kde_kwin_appm
 public:
     AppMenuManagerInterfacePrivate(AppMenuManagerInterface *q, Display *d);
 
-    QVector<AppMenuInterface *> appmenus;
+    QList<AppMenuInterface *> appmenus;
     AppMenuManagerInterface *q;
 
 protected:
diff --git a/src/wayland/clientconnection.cpp b/src/wayland/clientconnection.cpp
index 98e6382f0b..c2ed28029b 100644
--- a/src/wayland/clientconnection.cpp
+++ b/src/wayland/clientconnection.cpp
@@ -8,7 +8,7 @@
 #include "utils/executable_path.h"
 // Qt
 #include <QFileInfo>
-#include <QVector>
+#include <QList>
 // Wayland
 #include <wayland-server.h>
 
@@ -34,10 +34,10 @@ private:
     ClientConnection *q;
     wl_listener destroyListener;
     wl_listener destroyLateListener;
-    static QVector<ClientConnectionPrivate *> s_allClients;
+    static QList<ClientConnectionPrivate *> s_allClients;
 };
 
-QVector<ClientConnectionPrivate *> ClientConnectionPrivate::s_allClients;
+QList<ClientConnectionPrivate *> ClientConnectionPrivate::s_allClients;
 
 ClientConnectionPrivate::ClientConnectionPrivate(wl_client *c, Display *display, ClientConnection *q)
     : client(c)
diff --git a/src/wayland/display.cpp b/src/wayland/display.cpp
index dae40c3057..eb2c255997 100644
--- a/src/wayland/display.cpp
+++ b/src/wayland/display.cpp
@@ -161,9 +161,9 @@ QList<OutputDeviceV2Interface *> Display::outputDevices() const
     return d->outputdevicesV2;
 }
 
-QVector<OutputInterface *> Display::outputsIntersecting(const QRect &rect) const
+QList<OutputInterface *> Display::outputsIntersecting(const QRect &rect) const
 {
-    QVector<OutputInterface *> outputs;
+    QList<OutputInterface *> outputs;
     for (auto *output : std::as_const(d->outputs)) {
         if (output->handle()->geometry().intersects(rect)) {
             outputs << output;
@@ -172,7 +172,7 @@ QVector<OutputInterface *> Display::outputsIntersecting(const QRect &rect) const
     return outputs;
 }
 
-QVector<SeatInterface *> Display::seats() const
+QList<SeatInterface *> Display::seats() const
 {
     return d->seats;
 }
@@ -200,7 +200,7 @@ ClientConnection *Display::getConnection(wl_client *client)
     return c;
 }
 
-QVector<ClientConnection *> Display::connections() const
+QList<ClientConnection *> Display::connections() const
 {
     return d->clients;
 }
diff --git a/src/wayland/display.h b/src/wayland/display.h
index f428f1f433..e80c8845b6 100644
--- a/src/wayland/display.h
+++ b/src/wayland/display.h
@@ -98,10 +98,10 @@ public:
     /**
      * @returns All SeatInterface currently managed on the Display.
      */
-    QVector<SeatInterface *> seats() const;
+    QList<SeatInterface *> seats() const;
     QList<OutputDeviceV2Interface *> outputDevices() const;
     QList<OutputInterface *> outputs() const;
-    QVector<OutputInterface *> outputsIntersecting(const QRect &rect) const;
+    QList<OutputInterface *> outputsIntersecting(const QRect &rect) const;
 
     /**
      * Gets the ClientConnection for the given @p client.
@@ -110,7 +110,7 @@ public:
      * @return The ClientConnection for the given native client
      */
     ClientConnection *getConnection(wl_client *client);
-    QVector<ClientConnection *> connections() const;
+    QList<ClientConnection *> connections() const;
 
     /**
      * Returns the graphics buffer for the given @a resource, or @c null if there's no buffer.
diff --git a/src/wayland/display_p.h b/src/wayland/display_p.h
index 80546e7988..53af209ecc 100644
--- a/src/wayland/display_p.h
+++ b/src/wayland/display_p.h
@@ -12,7 +12,6 @@
 #include <QList>
 #include <QSocketNotifier>
 #include <QString>
-#include <QVector>
 
 struct wl_resource;
 
@@ -39,8 +38,8 @@ public:
     bool running = false;
     QList<OutputInterface *> outputs;
     QList<OutputDeviceV2Interface *> outputdevicesV2;
-    QVector<SeatInterface *> seats;
-    QVector<ClientConnection *> clients;
+    QList<SeatInterface *> seats;
+    QList<ClientConnection *> clients;
     QStringList socketNames;
 };
 
diff --git a/src/wayland/drmlease_v1.cpp b/src/wayland/drmlease_v1.cpp
index e8a32cf938..98e7945a18 100644
--- a/src/wayland/drmlease_v1.cpp
+++ b/src/wayland/drmlease_v1.cpp
@@ -308,7 +308,7 @@ DrmLeaseRequestV1Interface::~DrmLeaseRequestV1Interface()
     m_device->removeLeaseRequest(this);
 }
 
-QVector<DrmLeaseConnectorV1Interface *> DrmLeaseRequestV1Interface::connectors() const
+QList<DrmLeaseConnectorV1Interface *> DrmLeaseRequestV1Interface::connectors() const
 {
     return m_connectors;
 }
@@ -356,7 +356,7 @@ void DrmLeaseRequestV1Interface::wp_drm_lease_request_v1_submit(Resource *resour
     } else if (m_connectors.isEmpty()) {
         wl_resource_post_error(resource->handle, WP_DRM_LEASE_REQUEST_V1_ERROR_EMPTY_LEASE, "Requested lease without connectors");
     } else {
-        QVector<DrmOutput *> outputs;
+        QList<DrmOutput *> outputs;
         for (const auto &connector : m_connectors) {
             outputs.push_back(connector->output());
         }
@@ -375,7 +375,7 @@ void DrmLeaseRequestV1Interface::wp_drm_lease_request_v1_destroy_resource(Resour
     delete this;
 }
 
-DrmLeaseV1Interface::DrmLeaseV1Interface(DrmLeaseDeviceV1Interface *device, const QVector<DrmLeaseConnectorV1Interface *> &connectors, wl_resource *resource)
+DrmLeaseV1Interface::DrmLeaseV1Interface(DrmLeaseDeviceV1Interface *device, const QList<DrmLeaseConnectorV1Interface *> &connectors, wl_resource *resource)
     : wp_drm_lease_v1(resource)
     , m_device(device)
     , m_connectors(connectors)
@@ -440,7 +440,7 @@ void DrmLeaseV1Interface::wp_drm_lease_v1_destroy_resource(Resource *resource)
     delete this;
 }
 
-QVector<DrmLeaseConnectorV1Interface *> DrmLeaseV1Interface::connectors() const
+QList<DrmLeaseConnectorV1Interface *> DrmLeaseV1Interface::connectors() const
 {
     return m_connectors;
 }
diff --git a/src/wayland/drmlease_v1_p.h b/src/wayland/drmlease_v1_p.h
index 21d088116e..fd4fd7d31d 100644
--- a/src/wayland/drmlease_v1_p.h
+++ b/src/wayland/drmlease_v1_p.h
@@ -55,8 +55,8 @@ private:
     bool m_hasDrmMaster = true;
     std::map<DrmAbstractOutput *, std::unique_ptr<DrmLeaseConnectorV1Interface>> m_connectors;
     QQueue<wl_resource *> m_pendingFds;
-    QVector<DrmLeaseRequestV1Interface *> m_leaseRequests;
-    QVector<DrmLeaseV1Interface *> m_leases;
+    QList<DrmLeaseRequestV1Interface *> m_leaseRequests;
+    QList<DrmLeaseV1Interface *> m_leases;
 };
 
 class DrmLeaseConnectorV1Interface : public QObject, public QtWaylandServer::wp_drm_lease_connector_v1
@@ -87,7 +87,7 @@ public:
     DrmLeaseRequestV1Interface(DrmLeaseDeviceV1Interface *device, wl_resource *resource);
     ~DrmLeaseRequestV1Interface();
 
-    QVector<DrmLeaseConnectorV1Interface *> connectors() const;
+    QList<DrmLeaseConnectorV1Interface *> connectors() const;
     void invalidate();
 
 protected:
@@ -96,7 +96,7 @@ protected:
     void wp_drm_lease_request_v1_destroy_resource(Resource *resource) override;
 
     DrmLeaseDeviceV1Interface *const m_device;
-    QVector<DrmLeaseConnectorV1Interface *> m_connectors;
+    QList<DrmLeaseConnectorV1Interface *> m_connectors;
     bool m_invalid = false;
 };
 
@@ -104,18 +104,18 @@ class DrmLeaseV1Interface : public QObject, private QtWaylandServer::wp_drm_leas
 {
     Q_OBJECT
 public:
-    DrmLeaseV1Interface(DrmLeaseDeviceV1Interface *device, const QVector<DrmLeaseConnectorV1Interface *> &connectors, wl_resource *resource);
+    DrmLeaseV1Interface(DrmLeaseDeviceV1Interface *device, const QList<DrmLeaseConnectorV1Interface *> &connectors, wl_resource *resource);
     ~DrmLeaseV1Interface();
 
     void grant(std::unique_ptr<DrmLease> &&lease);
     void deny();
     void revoke();
 
-    QVector<DrmLeaseConnectorV1Interface *> connectors() const;
+    QList<DrmLeaseConnectorV1Interface *> connectors() const;
 
 private:
     DrmLeaseDeviceV1Interface *m_device;
-    QVector<DrmLeaseConnectorV1Interface *> m_connectors;
+    QList<DrmLeaseConnectorV1Interface *> m_connectors;
     std::unique_ptr<DrmLease> m_lease;
     bool m_finished = false;
 
diff --git a/src/wayland/inputmethod_v1.h b/src/wayland/inputmethod_v1.h
index a0229cb4c8..5b4cceb35e 100644
--- a/src/wayland/inputmethod_v1.h
+++ b/src/wayland/inputmethod_v1.h
@@ -8,8 +8,8 @@
 
 #include "kwin_export.h"
 
+#include <QList>
 #include <QObject>
-#include <QVector>
 #include <memory>
 
 #include "textinput.h"
diff --git a/src/wayland/keyboard.cpp b/src/wayland/keyboard.cpp
index 68da013726..a59c103930 100644
--- a/src/wayland/keyboard.cpp
+++ b/src/wayland/keyboard.cpp
@@ -10,7 +10,7 @@
 #include "surface.h"
 #include "utils/common.h"
 // Qt
-#include <QVector>
+#include <QList>
 
 #include <unistd.h>
 
@@ -38,7 +38,7 @@ void KeyboardInterfacePrivate::keyboard_bind_resource(Resource *resource)
     }
 
     if (focusedClient && focusedClient->client() == resource->client()) {
-        const QVector<quint32> keys = pressedKeys();
+        const QList<quint32> keys = pressedKeys();
         const QByteArray keysData = QByteArray::fromRawData(reinterpret_cast<const char *>(keys.data()), sizeof(quint32) * keys.count());
         const quint32 serial = seat->display()->nextSerial();
 
@@ -170,9 +170,9 @@ void KeyboardInterface::setModifierFocusSurface(SurfaceInterface *surface)
     }
 }
 
-QVector<quint32> KeyboardInterfacePrivate::pressedKeys() const
+QList<quint32> KeyboardInterfacePrivate::pressedKeys() const
 {
-    QVector<quint32> keys;
+    QList<quint32> keys;
     for (auto it = states.constBegin(); it != states.constEnd(); ++it) {
         if (it.value() == KeyboardKeyState::Pressed) {
             keys << it.key();
diff --git a/src/wayland/keyboard_p.h b/src/wayland/keyboard_p.h
index 65f49629fe..293caca1d7 100644
--- a/src/wayland/keyboard_p.h
+++ b/src/wayland/keyboard_p.h
@@ -60,7 +60,7 @@ public:
 
     QHash<quint32, KeyboardKeyState> states;
     bool updateKey(quint32 key, KeyboardKeyState state);
-    QVector<quint32> pressedKeys() const;
+    QList<quint32> pressedKeys() const;
 
 protected:
     void keyboard_release(Resource *resource) override;
diff --git a/src/wayland/keystate.cpp b/src/wayland/keystate.cpp
index cf3dd6b002..11d81090a1 100644
--- a/src/wayland/keystate.cpp
+++ b/src/wayland/keystate.cpp
@@ -11,7 +11,7 @@
 #include "xkb.h"
 
 #include <QDebug>
-#include <QVector>
+#include <QList>
 #include <qwayland-server-keystate.h>
 
 namespace KWin
diff --git a/src/wayland/linuxdmabufv1clientbuffer.cpp b/src/wayland/linuxdmabufv1clientbuffer.cpp
index e5f4e056e7..049f63147d 100644
--- a/src/wayland/linuxdmabufv1clientbuffer.cpp
+++ b/src/wayland/linuxdmabufv1clientbuffer.cpp
@@ -313,10 +313,10 @@ void LinuxDmaBufV1ClientBufferIntegration::setRenderBackend(RenderBackend *rende
     d->renderBackend = renderBackend;
 }
 
-void LinuxDmaBufV1ClientBufferIntegration::setSupportedFormatsWithModifiers(const QVector<LinuxDmaBufV1Feedback::Tranche> &tranches)
+void LinuxDmaBufV1ClientBufferIntegration::setSupportedFormatsWithModifiers(const QList<LinuxDmaBufV1Feedback::Tranche> &tranches)
 {
     if (LinuxDmaBufV1FeedbackPrivate::get(d->defaultFeedback.get())->m_tranches != tranches) {
-        QHash<uint32_t, QVector<uint64_t>> set;
+        QHash<uint32_t, QList<uint64_t>> set;
         for (const auto &tranche : tranches) {
             set.insert(tranche.formatTable);
         }
@@ -390,7 +390,7 @@ LinuxDmaBufV1Feedback::LinuxDmaBufV1Feedback(LinuxDmaBufV1ClientBufferIntegratio
 
 LinuxDmaBufV1Feedback::~LinuxDmaBufV1Feedback() = default;
 
-void LinuxDmaBufV1Feedback::setTranches(const QVector<Tranche> &tranches)
+void LinuxDmaBufV1Feedback::setTranches(const QList<Tranche> &tranches)
 {
     if (d->m_tranches != tranches) {
         d->m_tranches = tranches;
@@ -463,9 +463,9 @@ struct linux_dmabuf_feedback_v1_table_entry
     uint64_t modifier;
 };
 
-LinuxDmaBufV1FormatTable::LinuxDmaBufV1FormatTable(const QHash<uint32_t, QVector<uint64_t>> &supportedModifiers)
+LinuxDmaBufV1FormatTable::LinuxDmaBufV1FormatTable(const QHash<uint32_t, QList<uint64_t>> &supportedModifiers)
 {
-    QVector<linux_dmabuf_feedback_v1_table_entry> data;
+    QList<linux_dmabuf_feedback_v1_table_entry> data;
     for (auto it = supportedModifiers.begin(); it != supportedModifiers.end(); it++) {
         const uint32_t format = it.key();
         for (const uint64_t &mod : *it) {
diff --git a/src/wayland/linuxdmabufv1clientbuffer.h b/src/wayland/linuxdmabufv1clientbuffer.h
index 545c2d196c..e7a4e1e14f 100644
--- a/src/wayland/linuxdmabufv1clientbuffer.h
+++ b/src/wayland/linuxdmabufv1clientbuffer.h
@@ -38,14 +38,14 @@ public:
     {
         dev_t device;
         TrancheFlags flags;
-        QHash<uint32_t, QVector<uint64_t>> formatTable;
+        QHash<uint32_t, QList<uint64_t>> formatTable;
     };
     /**
      * Sets the list of tranches for this feedback object, with lower indices
      * indicating a higher priority / a more optimal configuration.
      * The main device does not need to be included
      */
-    void setTranches(const QVector<Tranche> &tranches);
+    void setTranches(const QList<Tranche> &tranches);
 
 private:
     LinuxDmaBufV1Feedback(LinuxDmaBufV1ClientBufferIntegrationPrivate *integration);
@@ -68,7 +68,7 @@ public:
     RenderBackend *renderBackend() const;
     void setRenderBackend(RenderBackend *renderBackend);
 
-    void setSupportedFormatsWithModifiers(const QVector<LinuxDmaBufV1Feedback::Tranche> &tranches);
+    void setSupportedFormatsWithModifiers(const QList<LinuxDmaBufV1Feedback::Tranche> &tranches);
 
 private:
     friend class LinuxDmaBufV1ClientBufferIntegrationPrivate;
diff --git a/src/wayland/linuxdmabufv1clientbuffer_p.h b/src/wayland/linuxdmabufv1clientbuffer_p.h
index f713ec46e9..9b8ebc1e1d 100644
--- a/src/wayland/linuxdmabufv1clientbuffer_p.h
+++ b/src/wayland/linuxdmabufv1clientbuffer_p.h
@@ -18,8 +18,8 @@
 #include "qwayland-server-linux-dmabuf-unstable-v1.h"
 
 #include <QDebug>
+#include <QList>
 #include <QPointer>
-#include <QVector>
 
 #include <drm_fourcc.h>
 
@@ -38,7 +38,7 @@ public:
     std::unique_ptr<LinuxDmaBufV1FormatTable> table;
     dev_t mainDevice;
     QPointer<RenderBackend> renderBackend;
-    QHash<uint32_t, QVector<uint64_t>> supportedModifiers;
+    QHash<uint32_t, QList<uint64_t>> supportedModifiers;
 
 protected:
     void zwp_linux_dmabuf_v1_bind_resource(Resource *resource) override;
@@ -105,7 +105,7 @@ private:
 class LinuxDmaBufV1FormatTable
 {
 public:
-    LinuxDmaBufV1FormatTable(const QHash<uint32_t, QVector<uint64_t>> &supportedModifiers);
+    LinuxDmaBufV1FormatTable(const QHash<uint32_t, QList<uint64_t>> &supportedModifiers);
 
     RamFile file;
     QMap<std::pair<uint32_t, uint64_t>, uint16_t> indices;
@@ -119,7 +119,7 @@ public:
     static LinuxDmaBufV1FeedbackPrivate *get(LinuxDmaBufV1Feedback *q);
     void send(Resource *resource);
 
-    QVector<LinuxDmaBufV1Feedback::Tranche> m_tranches;
+    QList<LinuxDmaBufV1Feedback::Tranche> m_tranches;
     LinuxDmaBufV1ClientBufferIntegrationPrivate *m_bufferintegration;
 
 protected:
diff --git a/src/wayland/lockscreen_overlay_v1.h b/src/wayland/lockscreen_overlay_v1.h
index 12a90556d7..121c58ceb1 100644
--- a/src/wayland/lockscreen_overlay_v1.h
+++ b/src/wayland/lockscreen_overlay_v1.h
@@ -8,8 +8,8 @@
 
 #include "kwin_export.h"
 
+#include <QList>
 #include <QObject>
-#include <QVector>
 #include <functional>
 #include <memory>
 #include <optional>
diff --git a/src/wayland/output.cpp b/src/wayland/output.cpp
index 4c51f99b40..b0c2bcf54f 100644
--- a/src/wayland/output.cpp
+++ b/src/wayland/output.cpp
@@ -13,9 +13,9 @@
 
 #include "qwayland-server-wayland.h"
 
+#include <QList>
 #include <QPointer>
 #include <QTimer>
-#include <QVector>
 
 #include <cmath>
 
@@ -290,10 +290,10 @@ void OutputInterface::remove()
     d->globalRemove();
 }
 
-QVector<wl_resource *> OutputInterface::clientResources(ClientConnection *client) const
+QList<wl_resource *> OutputInterface::clientResources(ClientConnection *client) const
 {
     const auto outputResources = d->resourceMap().values(client->client());
-    QVector<wl_resource *> ret;
+    QList<wl_resource *> ret;
     ret.reserve(outputResources.count());
 
     for (OutputInterfacePrivate::Resource *resource : outputResources) {
diff --git a/src/wayland/output.h b/src/wayland/output.h
index ed7c6be6b6..2b0ffed746 100644
--- a/src/wayland/output.h
+++ b/src/wayland/output.h
@@ -47,7 +47,7 @@ public:
     /**
      * @returns all wl_resources bound for the @p client
      */
-    QVector<wl_resource *> clientResources(ClientConnection *client) const;
+    QList<wl_resource *> clientResources(ClientConnection *client) const;
 
     /**
      * Submit changes to all clients.
diff --git a/src/wayland/output_order_v1.cpp b/src/wayland/output_order_v1.cpp
index cbec8b7eae..59c1524913 100644
--- a/src/wayland/output_order_v1.cpp
+++ b/src/wayland/output_order_v1.cpp
@@ -20,7 +20,7 @@ public:
     OutputOrderV1InterfacePrivate(Display *display);
 
     void sendList(wl_resource *resource);
-    QVector<Output *> outputOrder;
+    QList<Output *> outputOrder;
 
 protected:
     void kde_output_order_v1_bind_resource(Resource *resource) override;
@@ -35,7 +35,7 @@ OutputOrderV1Interface::OutputOrderV1Interface(Display *display, QObject *parent
 
 OutputOrderV1Interface::~OutputOrderV1Interface() = default;
 
-void OutputOrderV1Interface::setOutputOrder(const QVector<Output *> &outputOrder)
+void OutputOrderV1Interface::setOutputOrder(const QList<Output *> &outputOrder)
 {
     d->outputOrder = outputOrder;
     const auto resources = d->resourceMap();
diff --git a/src/wayland/output_order_v1.h b/src/wayland/output_order_v1.h
index 5d7c9b73e2..9cf9f891e4 100644
--- a/src/wayland/output_order_v1.h
+++ b/src/wayland/output_order_v1.h
@@ -22,7 +22,7 @@ public:
     explicit OutputOrderV1Interface(Display *display, QObject *parent);
     ~OutputOrderV1Interface() override;
 
-    void setOutputOrder(const QVector<Output *> &outputOrder);
+    void setOutputOrder(const QList<Output *> &outputOrder);
 
 private:
     std::unique_ptr<OutputOrderV1InterfacePrivate> d;
diff --git a/src/wayland/outputdevice_v2.h b/src/wayland/outputdevice_v2.h
index 95ce24d1cc..674380260f 100644
--- a/src/wayland/outputdevice_v2.h
+++ b/src/wayland/outputdevice_v2.h
@@ -8,11 +8,11 @@
 
 #include "kwin_export.h"
 
+#include <QList>
 #include <QObject>
 #include <QPoint>
 #include <QSize>
 #include <QUuid>
-#include <QVector>
 #include <memory>
 
 struct wl_resource;
diff --git a/src/wayland/outputmanagement_v2.cpp b/src/wayland/outputmanagement_v2.cpp
index 154020b8f3..346307a25b 100644
--- a/src/wayland/outputmanagement_v2.cpp
+++ b/src/wayland/outputmanagement_v2.cpp
@@ -43,7 +43,7 @@ public:
     bool applied = false;
     bool invalid = false;
     OutputConfiguration config;
-    QVector<std::pair<uint32_t, OutputDeviceV2Interface *>> outputOrder;
+    QList<std::pair<uint32_t, OutputDeviceV2Interface *>> outputOrder;
 
 protected:
     void kde_output_configuration_v2_enable(Resource *resource, wl_resource *outputdevice, int32_t enable) override;
@@ -323,7 +323,7 @@ void OutputConfigurationV2Interface::kde_output_configuration_v2_apply(Resource
         return;
     }
 
-    QVector<Output *> sortedOrder;
+    QList<Output *> sortedOrder;
     if (!outputOrder.empty()) {
         const int desktopOutputs = std::count_if(allOutputs.begin(), allOutputs.end(), [](Output *output) {
             return !output->isNonDesktop();
diff --git a/src/wayland/plasmawindowmanagement.cpp b/src/wayland/plasmawindowmanagement.cpp
index c43d041290..b46c80c0ae 100644
--- a/src/wayland/plasmawindowmanagement.cpp
+++ b/src/wayland/plasmawindowmanagement.cpp
@@ -18,7 +18,6 @@
 #include <QRect>
 #include <QThreadPool>
 #include <QUuid>
-#include <QVector>
 
 #include <qwayland-server-plasma-window-management.h>
 
@@ -55,8 +54,8 @@ public:
     QList<PlasmaWindowInterface *> windows;
     QPointer<PlasmaVirtualDesktopManagementInterface> plasmaVirtualDesktopManagementInterface = nullptr;
     quint32 windowIdCounter = 0;
-    QVector<quint32> stackingOrder;
-    QVector<QString> stackingOrderUuids;
+    QList<quint32> stackingOrder;
+    QList<QString> stackingOrderUuids;
     PlasmaWindowManagementInterface *q;
 
 protected:
@@ -314,7 +313,7 @@ QList<PlasmaWindowInterface *> PlasmaWindowManagementInterface::windows() const
     return d->windows;
 }
 
-void PlasmaWindowManagementInterface::setStackingOrder(const QVector<quint32> &stackingOrder)
+void PlasmaWindowManagementInterface::setStackingOrder(const QList<quint32> &stackingOrder)
 {
     if (d->stackingOrder == stackingOrder) {
         return;
@@ -323,7 +322,7 @@ void PlasmaWindowManagementInterface::setStackingOrder(const QVector<quint32> &s
     d->sendStackingOrderChanged();
 }
 
-void PlasmaWindowManagementInterface::setStackingOrderUuids(const QVector<QString> &stackingOrderUuids)
+void PlasmaWindowManagementInterface::setStackingOrderUuids(const QList<QString> &stackingOrderUuids)
 {
     if (d->stackingOrderUuids == stackingOrderUuids) {
         return;
diff --git a/src/wayland/plasmawindowmanagement.h b/src/wayland/plasmawindowmanagement.h
index d2d19432ae..714903753e 100644
--- a/src/wayland/plasmawindowmanagement.h
+++ b/src/wayland/plasmawindowmanagement.h
@@ -89,9 +89,9 @@ public:
     /**
      * Associate stacking order to this window management
      */
-    void setStackingOrder(const QVector<quint32> &stackingOrder);
+    void setStackingOrder(const QList<quint32> &stackingOrder);
 
-    void setStackingOrderUuids(const QVector<QString> &stackingOrderUuids);
+    void setStackingOrderUuids(const QList<QString> &stackingOrderUuids);
 
 Q_SIGNALS:
     void requestChangeShowingDesktop(ShowingDesktopState requestedState);
diff --git a/src/wayland/pointer_p.h b/src/wayland/pointer_p.h
index 4430ff34c1..6764a9a72a 100644
--- a/src/wayland/pointer_p.h
+++ b/src/wayland/pointer_p.h
@@ -9,9 +9,9 @@
 
 #include "pointer.h"
 
+#include <QList>
 #include <QPointF>
 #include <QPointer>
-#include <QVector>
 
 #include "qwayland-server-wayland.h"
 
diff --git a/src/wayland/seat.cpp b/src/wayland/seat.cpp
index 4c9232eb93..d19f153525 100644
--- a/src/wayland/seat.cpp
+++ b/src/wayland/seat.cpp
@@ -127,12 +127,12 @@ void SeatInterfacePrivate::updatePointerButtonState(quint32 button, Pointer::Sta
     it.value() = state;
 }
 
-QVector<DataDeviceInterface *> SeatInterfacePrivate::dataDevicesForSurface(SurfaceInterface *surface) const
+QList<DataDeviceInterface *> SeatInterfacePrivate::dataDevicesForSurface(SurfaceInterface *surface) const
 {
     if (!surface) {
         return {};
     }
-    QVector<DataDeviceInterface *> primarySelectionDevices;
+    QList<DataDeviceInterface *> primarySelectionDevices;
     for (auto it = dataDevices.constBegin(); it != dataDevices.constEnd(); ++it) {
         if ((*it)->client() == *surface->client()) {
             primarySelectionDevices << *it;
@@ -930,13 +930,13 @@ void SeatInterface::setFocusedKeyboardSurface(SurfaceInterface *surface)
         });
         d->globalKeyboard.focus.serial = serial;
         // selection?
-        const QVector<DataDeviceInterface *> dataDevices = d->dataDevicesForSurface(surface);
+        const QList<DataDeviceInterface *> dataDevices = d->dataDevicesForSurface(surface);
         d->globalKeyboard.focus.selections = dataDevices;
         for (auto dataDevice : dataDevices) {
             dataDevice->sendSelection(d->currentSelection);
         }
         // primary selection
-        QVector<PrimarySelectionDeviceV1Interface *> primarySelectionDevices;
+        QList<PrimarySelectionDeviceV1Interface *> primarySelectionDevices;
         for (auto it = d->primarySelectionDevices.constBegin(); it != d->primarySelectionDevices.constEnd(); ++it) {
             if ((*it)->client() == *surface->client()) {
                 primarySelectionDevices << *it;
diff --git a/src/wayland/seat_p.h b/src/wayland/seat_p.h
index 79dd4ee7b2..807344e766 100644
--- a/src/wayland/seat_p.h
+++ b/src/wayland/seat_p.h
@@ -10,9 +10,9 @@
 #include "seat.h"
 // Qt
 #include <QHash>
+#include <QList>
 #include <QMap>
 #include <QPointer>
-#include <QVector>
 
 #include <optional>
 
@@ -38,7 +38,7 @@ public:
     SeatInterfacePrivate(SeatInterface *q, Display *display);
 
     void sendCapabilities();
-    QVector<DataDeviceInterface *> dataDevicesForSurface(SurfaceInterface *surface) const;
+    QList<DataDeviceInterface *> dataDevicesForSurface(SurfaceInterface *surface) const;
     void registerPrimarySelectionDevice(PrimarySelectionDeviceV1Interface *primarySelectionDevice);
     void registerDataDevice(DataDeviceInterface *dataDevice);
     void registerDataControlDevice(DataControlDeviceV1Interface *dataDevice);
@@ -53,9 +53,9 @@ public:
     std::unique_ptr<KeyboardInterface> keyboard;
     std::unique_ptr<PointerInterface> pointer;
     std::unique_ptr<TouchInterface> touch;
-    QVector<DataDeviceInterface *> dataDevices;
-    QVector<PrimarySelectionDeviceV1Interface *> primarySelectionDevices;
-    QVector<DataControlDeviceV1Interface *> dataControlDevices;
+    QList<DataDeviceInterface *> dataDevices;
+    QList<PrimarySelectionDeviceV1Interface *> primarySelectionDevices;
+    QList<DataControlDeviceV1Interface *> dataControlDevices;
 
     QPointer<TextInputV1Interface> textInputV1;
     // TextInput v2
@@ -101,8 +101,8 @@ public:
             SurfaceInterface *surface = nullptr;
             QMetaObject::Connection destroyConnection;
             quint32 serial = 0;
-            QVector<DataDeviceInterface *> selections;
-            QVector<PrimarySelectionDeviceV1Interface *> primarySelections;
+            QList<DataDeviceInterface *> selections;
+            QList<PrimarySelectionDeviceV1Interface *> primarySelections;
         };
         Focus focus;
     };
diff --git a/src/wayland/server_decoration.cpp b/src/wayland/server_decoration.cpp
index ca89fc959c..446c19cf5e 100644
--- a/src/wayland/server_decoration.cpp
+++ b/src/wayland/server_decoration.cpp
@@ -8,7 +8,7 @@
 #include "surface.h"
 #include "utils/common.h"
 
-#include <QVector>
+#include <QList>
 
 #include <optional>
 
@@ -123,7 +123,7 @@ public:
 
 private:
     ServerSideDecorationInterface *q;
-    static QVector<ServerSideDecorationInterfacePrivate *> s_all;
+    static QList<ServerSideDecorationInterfacePrivate *> s_all;
 
 protected:
     void org_kde_kwin_server_decoration_destroy_resource(Resource *resource) override;
@@ -131,7 +131,7 @@ protected:
     void org_kde_kwin_server_decoration_request_mode(Resource *resource, uint32_t mode) override;
 };
 
-QVector<ServerSideDecorationInterfacePrivate *> ServerSideDecorationInterfacePrivate::s_all;
+QList<ServerSideDecorationInterfacePrivate *> ServerSideDecorationInterfacePrivate::s_all;
 
 void ServerSideDecorationInterfacePrivate::org_kde_kwin_server_decoration_request_mode(Resource *resource, uint32_t mode)
 {
diff --git a/src/wayland/server_decoration_palette.cpp b/src/wayland/server_decoration_palette.cpp
index 710199bc78..0048b9c5f6 100644
--- a/src/wayland/server_decoration_palette.cpp
+++ b/src/wayland/server_decoration_palette.cpp
@@ -21,7 +21,7 @@ class ServerSideDecorationPaletteManagerInterfacePrivate : public QtWaylandServe
 public:
     ServerSideDecorationPaletteManagerInterfacePrivate(ServerSideDecorationPaletteManagerInterface *q, Display *display);
 
-    QVector<ServerSideDecorationPaletteInterface *> palettes;
+    QList<ServerSideDecorationPaletteInterface *> palettes;
     ServerSideDecorationPaletteManagerInterface *q;
 
 protected:
diff --git a/src/wayland/surface.cpp b/src/wayland/surface.cpp
index 56d8787e83..c02f6b6d7c 100644
--- a/src/wayland/surface.cpp
+++ b/src/wayland/surface.cpp
@@ -934,14 +934,14 @@ bool SurfaceInterface::isMapped() const
     return d->mapped;
 }
 
-QVector<OutputInterface *> SurfaceInterface::outputs() const
+QList<OutputInterface *> SurfaceInterface::outputs() const
 {
     return d->outputs;
 }
 
-void SurfaceInterface::setOutputs(const QVector<OutputInterface *> &outputs)
+void SurfaceInterface::setOutputs(const QList<OutputInterface *> &outputs)
 {
-    QVector<OutputInterface *> removedOutputs = d->outputs;
+    QList<OutputInterface *> removedOutputs = d->outputs;
     for (auto it = outputs.constBegin(), end = outputs.constEnd(); it != end; ++it) {
         const auto o = *it;
         removedOutputs.removeOne(o);
@@ -954,7 +954,7 @@ void SurfaceInterface::setOutputs(const QVector<OutputInterface *> &outputs)
         disconnect(d->outputDestroyedConnections.take(*it));
         disconnect(d->outputBoundConnections.take(*it));
     }
-    QVector<OutputInterface *> addedOutputsOutputs = outputs;
+    QList<OutputInterface *> addedOutputsOutputs = outputs;
     for (auto it = d->outputs.constBegin(), end = d->outputs.constEnd(); it != end; ++it) {
         const auto o = *it;
         addedOutputsOutputs.removeOne(o);
diff --git a/src/wayland/surface.h b/src/wayland/surface.h
index 0560088762..d1b785cf89 100644
--- a/src/wayland/surface.h
+++ b/src/wayland/surface.h
@@ -280,13 +280,13 @@ public:
      *
      * @see outputs
      */
-    void setOutputs(const QVector<OutputInterface *> &outputs);
+    void setOutputs(const QList<OutputInterface *> &outputs);
 
     /**
      * @returns All OutputInterfaces the SurfaceInterface is on.
      * @see setOutputs
      */
-    QVector<OutputInterface *> outputs() const;
+    QList<OutputInterface *> outputs() const;
 
     /**
      * Pointer confinement installed on this SurfaceInterface.
diff --git a/src/wayland/surface_p.h b/src/wayland/surface_p.h
index 9ce1eb8036..d1425a3aa0 100644
--- a/src/wayland/surface_p.h
+++ b/src/wayland/surface_p.h
@@ -10,8 +10,8 @@
 #include "surface.h"
 // Qt
 #include <QHash>
+#include <QList>
 #include <QPointer>
-#include <QVector>
 // Wayland
 #include "qwayland-server-wayland.h"
 // C++
@@ -143,7 +143,7 @@ public:
     Transaction *firstTransaction = nullptr;
     Transaction *lastTransaction = nullptr;
 
-    QVector<OutputInterface *> outputs;
+    QList<OutputInterface *> outputs;
     std::optional<qreal> preferredBufferScale;
     std::optional<OutputTransform> preferredBufferTransform;
 
@@ -152,7 +152,7 @@ public:
     QHash<OutputInterface *, QMetaObject::Connection> outputDestroyedConnections;
     QHash<OutputInterface *, QMetaObject::Connection> outputBoundConnections;
 
-    QVector<IdleInhibitorV1Interface *> idleInhibitors;
+    QList<IdleInhibitorV1Interface *> idleInhibitors;
     ViewportInterface *viewportExtension = nullptr;
     std::unique_ptr<LinuxDmaBufV1Feedback> dmabufFeedbackV1;
     QPointer<ContentTypeV1Interface> contentTypeInterface;
diff --git a/src/wayland/tablet_v2.cpp b/src/wayland/tablet_v2.cpp
index 313c9a29fb..b817a63180 100644
--- a/src/wayland/tablet_v2.cpp
+++ b/src/wayland/tablet_v2.cpp
@@ -131,7 +131,7 @@ public:
                                  uint32_t hsl,
                                  uint32_t hih,
                                  uint32_t hil,
-                                 const QVector<TabletToolV2Interface::Capability> &capabilities)
+                                 const QList<TabletToolV2Interface::Capability> &capabilities)
         : zwp_tablet_tool_v2()
         , m_display(display)
         , m_type(type)
@@ -215,7 +215,7 @@ public:
     const uint32_t m_type;
     const uint32_t m_hardwareSerialHigh, m_hardwareSerialLow;
     const uint32_t m_hardwareIdHigh, m_hardwareIdLow;
-    const QVector<TabletToolV2Interface::Capability> m_capabilities;
+    const QList<TabletToolV2Interface::Capability> m_capabilities;
     QHash<wl_resource *, TabletSurfaceCursorV2 *> m_cursors;
     TabletToolV2Interface *const q;
 };
@@ -226,7 +226,7 @@ TabletToolV2Interface::TabletToolV2Interface(Display *display,
                                              uint32_t hsl,
                                              uint32_t hih,
                                              uint32_t hil,
-                                             const QVector<Capability> &capabilities)
+                                             const QList<Capability> &capabilities)
     : d(new TabletToolV2InterfacePrivate(this, display, type, hsh, hsl, hih, hil, capabilities))
 {
 }
@@ -578,11 +578,11 @@ public:
     TabletPadV2Interface *const q;
 
     const QString m_path;
-    QVector<quint32> m_buttons;
+    QList<quint32> m_buttons;
     const int m_modes;
 
-    QVector<TabletPadRingV2Interface *> m_rings;
-    QVector<TabletPadStripV2Interface *> m_strips;
+    QList<TabletPadRingV2Interface *> m_rings;
+    QList<TabletPadStripV2Interface *> m_strips;
     TabletPadGroupV2Interface *const m_padGroup;
     TabletSeatV2Interface *m_seat = nullptr;
     QPointer<SurfaceInterface> m_currentSurface;
@@ -740,7 +740,7 @@ public:
     }
 
     TabletSeatV2Interface *const q;
-    QHash<QString, QVector<TabletToolV2Interface *>> m_tools;
+    QHash<QString, QList<TabletToolV2Interface *>> m_tools;
     QHash<QString, TabletV2Interface *> m_tablets;
     QHash<QString, TabletPadV2Interface *> m_pads;
     Display *const m_display;
@@ -757,7 +757,7 @@ TabletSeatV2Interface::~TabletSeatV2Interface() = default;
 TabletToolV2Interface *TabletSeatV2Interface::addTool(TabletToolV2Interface::Type type,
                                                       quint64 hardwareSerial,
                                                       quint64 hardwareId,
-                                                      const QVector<TabletToolV2Interface::Capability> &capabilities,
+                                                      const QList<TabletToolV2Interface::Capability> &capabilities,
                                                       const QString &deviceSysName)
 {
     constexpr auto MAX_UINT_32 = std::numeric_limits<quint32>::max();
diff --git a/src/wayland/tablet_v2.h b/src/wayland/tablet_v2.h
index 9a5cc85630..4895fa0ee2 100644
--- a/src/wayland/tablet_v2.h
+++ b/src/wayland/tablet_v2.h
@@ -7,8 +7,8 @@
 
 #include "kwin_export.h"
 
+#include <QList>
 #include <QObject>
-#include <QVector>
 #include <memory>
 
 struct wl_resource;
@@ -149,7 +149,7 @@ private:
                                    quint32 hsl,
                                    quint32 hih,
                                    quint32 hil,
-                                   const QVector<Capability> &capability);
+                                   const QList<Capability> &capability);
     std::unique_ptr<TabletToolV2InterfacePrivate> d;
 };
 
@@ -285,7 +285,7 @@ public:
                                        quint32 currentMode,
                                        TabletV2Interface *tablet);
     TabletToolV2Interface *
-    addTool(TabletToolV2Interface::Type type, quint64 hardwareSerial, quint64 hardwareId, const QVector<TabletToolV2Interface::Capability> &capabilities, const QString &deviceSysName);
+    addTool(TabletToolV2Interface::Type type, quint64 hardwareSerial, quint64 hardwareId, const QList<TabletToolV2Interface::Capability> &capabilities, const QString &deviceSysName);
 
     TabletToolV2Interface *toolByHardwareId(quint64 hardwareId) const;
     TabletToolV2Interface *toolByHardwareSerial(quint64 hardwareSerial, TabletToolV2Interface::Type type) const;
diff --git a/src/wayland/textinput_v1_p.h b/src/wayland/textinput_v1_p.h
index a27cb1034a..ca23ef4ce4 100644
--- a/src/wayland/textinput_v1_p.h
+++ b/src/wayland/textinput_v1_p.h
@@ -11,10 +11,10 @@
 #include "wayland/surface.h"
 #include "wayland/textinput_v1.h"
 
+#include <QList>
 #include <QPointer>
 #include <QRect>
 #include <QSet>
-#include <QVector>
 
 #include <qwayland-server-text-input-unstable-v1.h>
 
diff --git a/src/wayland/textinput_v2_p.h b/src/wayland/textinput_v2_p.h
index 8b70a31e05..2cfe62eab3 100644
--- a/src/wayland/textinput_v2_p.h
+++ b/src/wayland/textinput_v2_p.h
@@ -8,10 +8,10 @@
 #include "clientconnection.h"
 #include "textinput_v2.h"
 
+#include <QList>
 #include <QPointer>
 #include <QRect>
 #include <QSet>
-#include <QVector>
 
 #include <qwayland-server-text-input-unstable-v2.h>
 
diff --git a/src/wayland/textinput_v3_p.h b/src/wayland/textinput_v3_p.h
index 6eba27b384..dcc8f05335 100644
--- a/src/wayland/textinput_v3_p.h
+++ b/src/wayland/textinput_v3_p.h
@@ -9,9 +9,9 @@
 #include "textinput_v3.h"
 
 #include <QHash>
+#include <QList>
 #include <QPointer>
 #include <QRect>
-#include <QVector>
 
 #include <qwayland-server-text-input-unstable-v3.h>
 
diff --git a/src/wayland/tools/qtwaylandscanner.cpp b/src/wayland/tools/qtwaylandscanner.cpp
index ec7a297253..2e0dd03577 100644
--- a/src/wayland/tools/qtwaylandscanner.cpp
+++ b/src/wayland/tools/qtwaylandscanner.cpp
@@ -124,13 +124,13 @@ private:
     QByteArray m_scannerName;
     QByteArray m_headerPath;
     QByteArray m_prefix;
-    QVector <QByteArray> m_includes;
+    QList <QByteArray> m_includes;
     QXmlStreamReader *m_xml = nullptr;
 };
 
 bool Scanner::parseArguments(int argc, char **argv)
 {
-    QVector<QByteArray> args;
+    QList<QByteArray> args;
     args.reserve(argc);
     for (int i = 0; i < argc; ++i)
         args << QByteArray(argv[i]);
diff --git a/src/wayland/xdgactivation_v1.h b/src/wayland/xdgactivation_v1.h
index 84e25ae985..0600371013 100644
--- a/src/wayland/xdgactivation_v1.h
+++ b/src/wayland/xdgactivation_v1.h
@@ -8,8 +8,8 @@
 
 #include "kwin_export.h"
 
+#include <QList>
 #include <QObject>
-#include <QVector>
 #include <functional>
 #include <memory>
 #include <optional>
diff --git a/src/wayland_server.cpp b/src/wayland_server.cpp
index fffae9a093..dbeac54df4 100644
--- a/src/wayland_server.cpp
+++ b/src/wayland_server.cpp
@@ -558,8 +558,8 @@ void WaylandServer::initWorkspace()
 
         connect(workspace(), &Workspace::workspaceInitialized, this, [this] {
             auto f = [this]() {
-                QVector<quint32> ids;
-                QVector<QString> uuids;
+                QList<quint32> ids;
+                QList<QString> uuids;
                 for (Window *toplevel : workspace()->stackingOrder()) {
                     if (toplevel->windowManagementInterface()) {
                         ids << toplevel->windowManagementInterface()->internalId();
@@ -625,7 +625,7 @@ void WaylandServer::initScreenLocker()
 
         new LockScreenPresentationWatcher(this);
 
-        const QVector<SeatInterface *> seatIfaces = m_display->seats();
+        const QList<SeatInterface *> seatIfaces = m_display->seats();
         for (auto *seat : seatIfaces) {
             connect(seat, &SeatInterface::timestampChanged,
                     screenLockerApp, &ScreenLocker::KSldApp::userActivity);
@@ -639,7 +639,7 @@ void WaylandServer::initScreenLocker()
             m_screenLockerClientConnection = nullptr;
         }
 
-        const QVector<SeatInterface *> seatIfaces = m_display->seats();
+        const QList<SeatInterface *> seatIfaces = m_display->seats();
         for (auto *seat : seatIfaces) {
             disconnect(seat, &SeatInterface::timestampChanged,
                        screenLockerApp, &ScreenLocker::KSldApp::userActivity);
diff --git a/src/window.cpp b/src/window.cpp
index 58fcdf6edc..5a87497dc0 100644
--- a/src/window.cpp
+++ b/src/window.cpp
@@ -731,11 +731,11 @@ void Window::doSetDemandsAttention()
 {
 }
 
-void Window::setDesktops(QVector<VirtualDesktop *> desktops)
+void Window::setDesktops(QList<VirtualDesktop *> desktops)
 {
     // on x11 we can have only one desktop at a time
     if (kwinApp()->operationMode() == Application::OperationModeX11 && desktops.size() > 1) {
-        desktops = QVector<VirtualDesktop *>({desktops.last()});
+        desktops = QList<VirtualDesktop *>({desktops.last()});
     }
 
     desktops = rules()->checkDesktops(desktops);
@@ -803,7 +803,7 @@ void Window::enterDesktop(VirtualDesktop *virtualDesktop)
 
 void Window::leaveDesktop(VirtualDesktop *virtualDesktop)
 {
-    QVector<VirtualDesktop *> currentDesktops;
+    QList<VirtualDesktop *> currentDesktops;
     if (m_desktops.isEmpty()) {
         currentDesktops = VirtualDesktopManager::self()->desktops();
     } else {
@@ -830,7 +830,7 @@ void Window::setOnAllDesktops(bool b)
     }
 }
 
-QVector<VirtualDesktop *> Window::desktops() const
+QList<VirtualDesktop *> Window::desktops() const
 {
     return m_desktops;
 }
diff --git a/src/window.h b/src/window.h
index 5537cfa248..aa0a35bd89 100644
--- a/src/window.h
+++ b/src/window.h
@@ -287,7 +287,7 @@ class KWIN_EXPORT Window : public QObject
     /**
      * The virtual desktops this client is on. If it's on all desktops, the list is empty.
      */
-    Q_PROPERTY(QVector<KWin::VirtualDesktop *> desktops READ desktops WRITE setDesktops NOTIFY desktopsChanged)
+    Q_PROPERTY(QList<KWin::VirtualDesktop *> desktops READ desktops WRITE setDesktops NOTIFY desktopsChanged)
 
     /**
      * Whether the Window is on all desktops. That is desktop is -1.
@@ -716,8 +716,8 @@ public:
     void setLockScreenOverlay(bool allowed);
 
     QStringList desktopIds() const;
-    QVector<VirtualDesktop *> desktops() const;
-    void setDesktops(QVector<VirtualDesktop *> desktops);
+    QList<VirtualDesktop *> desktops() const;
+    void setDesktops(QList<VirtualDesktop *> desktops);
     void enterDesktop(VirtualDesktop *desktop);
     void leaveDesktop(VirtualDesktop *desktop);
     bool isOnDesktop(VirtualDesktop *desktop) const;
@@ -1755,7 +1755,7 @@ protected:
     QTimer *m_autoRaiseTimer = nullptr;
     QTimer *m_shadeHoverTimer = nullptr;
     ShadeMode m_shadeMode = ShadeNone;
-    QVector<VirtualDesktop *> m_desktops;
+    QList<VirtualDesktop *> m_desktops;
 
     QStringList m_activityList;
     int m_activityUpdatesBlocked = 0;
diff --git a/src/window_property_notify_x11_filter.cpp b/src/window_property_notify_x11_filter.cpp
index 73754e86cb..10f843211f 100644
--- a/src/window_property_notify_x11_filter.cpp
+++ b/src/window_property_notify_x11_filter.cpp
@@ -15,7 +15,7 @@ namespace KWin
 {
 
 WindowPropertyNotifyX11Filter::WindowPropertyNotifyX11Filter(EffectsHandlerImpl *effects)
-    : X11EventFilter(QVector<int>{XCB_PROPERTY_NOTIFY})
+    : X11EventFilter(QList<int>{XCB_PROPERTY_NOTIFY})
     , m_effects(effects)
 {
 }
diff --git a/src/workspace.cpp b/src/workspace.cpp
index e1ed446dfa..b34cdd3ede 100644
--- a/src/workspace.cpp
+++ b/src/workspace.cpp
@@ -329,8 +329,8 @@ void Workspace::initializeX11()
         Xcb::Tree tree(kwinApp()->x11RootWindow());
         xcb_window_t *wins = xcb_query_tree_children(tree.data());
 
-        QVector<Xcb::WindowAttributes> windowAttributes(tree->children_len);
-        QVector<Xcb::WindowGeometry> windowGeometries(tree->children_len);
+        QList<Xcb::WindowAttributes> windowAttributes(tree->children_len);
+        QList<Xcb::WindowGeometry> windowGeometries(tree->children_len);
 
         // Request the attributes and geometries of all toplevel windows
         for (int i = 0; i < tree->children_len; i++) {
@@ -467,7 +467,7 @@ Workspace::~Workspace()
     _self = nullptr;
 }
 
-bool Workspace::applyOutputConfiguration(const OutputConfiguration &config, const QVector<Output *> &outputOrder)
+bool Workspace::applyOutputConfiguration(const OutputConfiguration &config, const QList<Output *> &outputOrder)
 {
     if (!kwinApp()->outputBackend()->applyOutputChanges(config)) {
         return false;
@@ -871,7 +871,7 @@ void Workspace::updateToolWindows(bool also_hide)
     // I.e. if it's not up to date
 
     // SELI TODO: But maybe it should - what if a new window has been added that's not in stacking order yet?
-    QVector<Window *> to_show, to_hide;
+    QList<Window *> to_show, to_hide;
     for (auto it = stacking_order.constBegin(); it != stacking_order.constEnd(); ++it) {
         auto c = *it;
         if (!c->isClient()) {
@@ -1276,7 +1276,7 @@ void Workspace::slotOutputBackendOutputsQueried()
     updateOutputs();
 }
 
-void Workspace::updateOutputs(const QVector<Output *> &outputOrder)
+void Workspace::updateOutputs(const QList<Output *> &outputOrder)
 {
     const auto availableOutputs = kwinApp()->outputBackend()->outputs();
     const auto oldOutputs = m_outputs;
@@ -1467,9 +1467,9 @@ void Workspace::selectWmInputEventMask()
  *
  * Takes care of transients as well.
  */
-void Workspace::sendWindowToDesktops(Window *window, const QVector<VirtualDesktop *> &desktops, bool dont_activate)
+void Workspace::sendWindowToDesktops(Window *window, const QList<VirtualDesktop *> &desktops, bool dont_activate)
 {
-    const QVector<VirtualDesktop *> oldDesktops = window->desktops();
+    const QList<VirtualDesktop *> oldDesktops = window->desktops();
     const bool wasOnCurrent = window->isOnCurrentDesktop();
     window->setDesktops(desktops);
     if (window->desktops() != desktops) { // No change or desktop forced
@@ -1726,7 +1726,7 @@ QString Workspace::supportInformation() const
     } else {
         support.append(QStringLiteral(" no\n"));
     }
-    const QVector<Output *> outputs = kwinApp()->outputBackend()->outputs();
+    const QList<Output *> outputs = kwinApp()->outputBackend()->outputs();
     support.append(QStringLiteral("Number of Screens: %1\n\n").arg(outputs.count()));
     for (int i = 0; i < outputs.count(); ++i) {
         const auto output = outputs[i];
@@ -2288,7 +2288,7 @@ QRectF Workspace::adjustClientArea(Window *window, const QRectF &area) const
  */
 void Workspace::updateClientArea()
 {
-    const QVector<VirtualDesktop *> desktops = VirtualDesktopManager::self()->desktops();
+    const QList<VirtualDesktop *> desktops = VirtualDesktopManager::self()->desktops();
 
     QHash<const VirtualDesktop *, QRectF> workAreas;
     QHash<const VirtualDesktop *, StrutRects> restrictedAreas;
@@ -2518,7 +2518,7 @@ Output *Workspace::xineramaIndexToOutput(int index) const
     return nullptr;
 }
 
-void Workspace::setOutputOrder(const QVector<Output *> &order)
+void Workspace::setOutputOrder(const QList<Output *> &order)
 {
     if (m_outputOrder != order) {
         m_outputOrder = order;
@@ -2526,7 +2526,7 @@ void Workspace::setOutputOrder(const QVector<Output *> &order)
     }
 }
 
-QVector<Output *> Workspace::outputOrder() const
+QList<Output *> Workspace::outputOrder() const
 {
     return m_outputOrder;
 }
diff --git a/src/workspace.h b/src/workspace.h
index 228dd9c8cf..065770f8c7 100644
--- a/src/workspace.h
+++ b/src/workspace.h
@@ -18,9 +18,9 @@
 #include "sm.h"
 #include "utils/common.h"
 // Qt
+#include <QList>
 #include <QStringList>
 #include <QTimer>
-#include <QVector>
 // std
 #include <functional>
 #include <memory>
@@ -174,8 +174,8 @@ public:
 
     Output *xineramaIndexToOutput(int index) const;
 
-    void setOutputOrder(const QVector<Output *> &order);
-    QVector<Output *> outputOrder() const;
+    void setOutputOrder(const QList<Output *> &order);
+    QList<Output *> outputOrder() const;
 
     Output *activeOutput() const;
     void setActiveOutput(Output *output);
@@ -288,7 +288,7 @@ public:
     Window *topWindowOnDesktop(VirtualDesktop *desktop, Output *output = nullptr, bool unconstrained = false,
                                bool only_normal = true) const;
     Window *findDesktop(bool topmost, VirtualDesktop *desktop) const;
-    void sendWindowToDesktops(Window *window, const QVector<VirtualDesktop *> &desktops, bool dont_activate);
+    void sendWindowToDesktops(Window *window, const QList<VirtualDesktop *> &desktops, bool dont_activate);
     void windowToPreviousDesktop(Window *window);
     void windowToNextDesktop(Window *window);
     void sendWindowToOutput(Window *window, Output *output);
@@ -441,7 +441,7 @@ public:
      * Apply the requested output configuration. Note that you must use this function
      * instead of Platform::applyOutputChanges().
      */
-    bool applyOutputConfiguration(const OutputConfiguration &config, const QVector<Output *> &outputOrder = {});
+    bool applyOutputConfiguration(const OutputConfiguration &config, const QList<Output *> &outputOrder = {});
 
 public Q_SLOTS:
     void performWindowOperation(KWin::Window *window, Options::WindowOperation op);
@@ -608,7 +608,7 @@ private:
     QString getPlacementTrackerHash();
 
     void updateOutputConfiguration();
-    void updateOutputs(const QVector<Output *> &outputOrder = {});
+    void updateOutputs(const QList<Output *> &outputOrder = {});
     void createDpmsFilter();
     void maybeDestroyDpmsFilter();
 
@@ -635,7 +635,7 @@ private:
     QList<Output *> m_outputs;
     Output *m_activeOutput = nullptr;
     Output *m_activeCursorOutput = nullptr;
-    QVector<Output *> m_outputOrder;
+    QList<Output *> m_outputOrder;
 
     Window *m_activeWindow;
     Window *m_lastActiveWindow;
@@ -651,7 +651,7 @@ private:
 
     QList<Window *> unconstrained_stacking_order; // Topmost last
     QList<Window *> stacking_order; // Topmost last
-    QVector<xcb_window_t> manual_overlays; // Topmost last
+    QList<xcb_window_t> manual_overlays; // Topmost last
     bool force_restacking;
     QList<Window *> should_get_focus; // Last is most recent
     QList<Window *> attention_chain;
diff --git a/src/x11eventfilter.cpp b/src/x11eventfilter.cpp
index b4d998ce35..69648d3621 100644
--- a/src/x11eventfilter.cpp
+++ b/src/x11eventfilter.cpp
@@ -13,7 +13,7 @@
 namespace KWin
 {
 
-X11EventFilter::X11EventFilter(const QVector<int> &eventTypes)
+X11EventFilter::X11EventFilter(const QList<int> &eventTypes)
     : m_eventTypes(eventTypes)
     , m_extension(0)
 {
@@ -21,12 +21,12 @@ X11EventFilter::X11EventFilter(const QVector<int> &eventTypes)
 }
 
 X11EventFilter::X11EventFilter(int eventType, int opcode, int genericEventType)
-    : X11EventFilter(eventType, opcode, QVector<int>{genericEventType})
+    : X11EventFilter(eventType, opcode, QList<int>{genericEventType})
 {
 }
 
-X11EventFilter::X11EventFilter(int eventType, int opcode, const QVector<int> &genericEventTypes)
-    : m_eventTypes(QVector<int>{eventType})
+X11EventFilter::X11EventFilter(int eventType, int opcode, const QList<int> &genericEventTypes)
+    : m_eventTypes(QList<int>{eventType})
     , m_extension(opcode)
     , m_genericEventTypes(genericEventTypes)
 {
diff --git a/src/x11eventfilter.h b/src/x11eventfilter.h
index f91f3ffe6f..ea2d7d3c77 100644
--- a/src/x11eventfilter.h
+++ b/src/x11eventfilter.h
@@ -11,7 +11,7 @@
 
 #include <xcb/xcb.h>
 
-#include <QVector>
+#include <QList>
 
 #include <kwin_export.h>
 
@@ -25,8 +25,8 @@ public:
      * Creates an event filter for the given event type.
      */
     X11EventFilter(int eventType, int opcode = 0, int genericEventType = 0);
-    X11EventFilter(int eventType, int opcode, const QVector<int> &genericEventTypes);
-    X11EventFilter(const QVector<int> &eventTypes);
+    X11EventFilter(int eventType, int opcode, const QList<int> &genericEventTypes);
+    X11EventFilter(const QList<int> &eventTypes);
 
     /**
      * Destroys the event filter.
@@ -36,7 +36,7 @@ public:
     /**
      * Returns the type of events to filter.
      */
-    QVector<int> eventTypes() const
+    QList<int> eventTypes() const
     {
         return m_eventTypes;
     }
@@ -56,7 +56,7 @@ public:
      *
      * Only used when the event type is XCB_GE_GENERIC.
      */
-    QVector<int> genericEventTypes() const
+    QList<int> genericEventTypes() const
     {
         return m_genericEventTypes;
     }
@@ -74,9 +74,9 @@ public:
     bool isGenericEvent() const;
 
 private:
-    QVector<int> m_eventTypes;
+    QList<int> m_eventTypes;
     int m_extension;
-    QVector<int> m_genericEventTypes;
+    QList<int> m_genericEventTypes;
 };
 
 } // namespace KWin
diff --git a/src/x11syncmanager.h b/src/x11syncmanager.h
index f261e480eb..9d30384654 100644
--- a/src/x11syncmanager.h
+++ b/src/x11syncmanager.h
@@ -73,7 +73,7 @@ private:
     X11SyncManager();
 
     X11SyncObject *m_currentFence = nullptr;
-    QVector<X11SyncObject *> m_fences;
+    QList<X11SyncObject *> m_fences;
     int m_next = 0;
 };
 
diff --git a/src/x11window.cpp b/src/x11window.cpp
index 73170720bb..0571d43b4b 100644
--- a/src/x11window.cpp
+++ b/src/x11window.cpp
@@ -703,14 +703,14 @@ bool X11Window::manage(xcb_window_t w, bool isMapped)
     readActivities(activitiesCookie);
 
     // Initial desktop placement
-    std::optional<QVector<VirtualDesktop *>> initialDesktops;
+    std::optional<QList<VirtualDesktop *>> initialDesktops;
     if (session) {
         if (session->onAllDesktops) {
-            initialDesktops = QVector<VirtualDesktop *>{};
+            initialDesktops = QList<VirtualDesktop *>{};
         } else {
             VirtualDesktop *desktop = VirtualDesktopManager::self()->desktopForX11Id(session->desktop);
             if (desktop) {
-                initialDesktops = QVector<VirtualDesktop *>{desktop};
+                initialDesktops = QList<VirtualDesktop *>{desktop};
             }
         }
         setOnActivities(session->activities);
@@ -739,9 +739,9 @@ bool X11Window::manage(xcb_window_t w, bool isMapped)
                 }
             }
             if (on_all) {
-                initialDesktops = QVector<VirtualDesktop *>{};
+                initialDesktops = QList<VirtualDesktop *>{};
             } else if (on_current) {
-                initialDesktops = QVector<VirtualDesktop *>{VirtualDesktopManager::self()->currentDesktop()};
+                initialDesktops = QList<VirtualDesktop *>{VirtualDesktopManager::self()->currentDesktop()};
             } else if (maincl) {
                 initialDesktops = maincl->desktops();
             }
@@ -759,11 +759,11 @@ bool X11Window::manage(xcb_window_t w, bool isMapped)
             }
             if (desktopId) {
                 if (desktopId == NET::OnAllDesktops) {
-                    initialDesktops = QVector<VirtualDesktop *>{};
+                    initialDesktops = QList<VirtualDesktop *>{};
                 } else {
                     VirtualDesktop *desktop = VirtualDesktopManager::self()->desktopForX11Id(desktopId);
                     if (desktop) {
-                        initialDesktops = QVector<VirtualDesktop *>{desktop};
+                        initialDesktops = QList<VirtualDesktop *>{desktop};
                     }
                 }
             }
@@ -786,9 +786,9 @@ bool X11Window::manage(xcb_window_t w, bool isMapped)
     // desktop so place it on the current virtual desktop.
     if (!initialDesktops.has_value()) {
         if (isDesktop()) {
-            initialDesktops = QVector<VirtualDesktop *>{};
+            initialDesktops = QList<VirtualDesktop *>{};
         } else {
-            initialDesktops = QVector<VirtualDesktop *>{VirtualDesktopManager::self()->currentDesktop()};
+            initialDesktops = QList<VirtualDesktop *>{VirtualDesktopManager::self()->currentDesktop()};
         }
     }
     setDesktops(rules()->checkDesktops(*initialDesktops, !isMapped));
@@ -1297,7 +1297,7 @@ void X11Window::updateInputWindow()
         m_decoInputExtent.setGeometry(bounds);
     }
 
-    const QVector<xcb_rectangle_t> rects = Xcb::regionToRects(region);
+    const QList<xcb_rectangle_t> rects = Xcb::regionToRects(region);
     xcb_shape_rectangles(kwinApp()->x11Connection(), XCB_SHAPE_SO_SET, XCB_SHAPE_SK_INPUT, XCB_CLIP_ORDERING_UNSORTED,
                          m_decoInputExtent, 0, 0, rects.count(), rects.constData());
 }
@@ -5037,7 +5037,7 @@ void X11Window::getWmOpaqueRegion()
     opaque_region = new_opaque_region;
 }
 
-QVector<QRectF> X11Window::shapeRegion() const
+QList<QRectF> X11Window::shapeRegion() const
 {
     if (m_shapeRegionIsValid) {
         return m_shapeRegion;
diff --git a/src/x11window.h b/src/x11window.h
index 47c115237e..f4e00e46d8 100644
--- a/src/x11window.h
+++ b/src/x11window.h
@@ -98,7 +98,7 @@ public:
     int depth() const;
     bool hasAlpha() const;
     QRegion opaqueRegion() const;
-    QVector<QRectF> shapeRegion() const;
+    QList<QRectF> shapeRegion() const;
 
     pid_t pid() const override;
     QString windowRole() const override;
@@ -490,7 +490,7 @@ private:
     xcb_visualid_t m_visual = XCB_NONE;
     int bit_depth = 24;
     QRegion opaque_region;
-    mutable QVector<QRectF> m_shapeRegion;
+    mutable QList<QRectF> m_shapeRegion;
     mutable bool m_shapeRegionIsValid = false;
     friend struct ResetupRulesProcedure;
 
diff --git a/src/xwayland/dnd.h b/src/xwayland/dnd.h
index b7a6881b0b..f4d12ca314 100644
--- a/src/xwayland/dnd.h
+++ b/src/xwayland/dnd.h
@@ -60,7 +60,7 @@ private:
 
     // active drag or null when no drag active
     Drag *m_currentDrag = nullptr;
-    QVector<Drag *> m_oldDrags;
+    QList<Drag *> m_oldDrags;
 
     XwlDropHandler *m_dropHandler;
 
diff --git a/src/xwayland/drag_wl.cpp b/src/xwayland/drag_wl.cpp
index 74f203d673..bc44d97ce3 100644
--- a/src/xwayland/drag_wl.cpp
+++ b/src/xwayland/drag_wl.cpp
@@ -252,7 +252,7 @@ void Xvisit::sendEnter()
         // need to first transfer all available mime types
         data.data32[1] |= 1;
 
-        QVector<xcb_atom_t> targets;
+        QList<xcb_atom_t> targets;
         targets.resize(mimesCount);
 
         size_t cnt = 0;
diff --git a/src/xwayland/drag_wl.h b/src/xwayland/drag_wl.h
index 7811e2f2db..f7ff72d5d9 100644
--- a/src/xwayland/drag_wl.h
+++ b/src/xwayland/drag_wl.h
@@ -12,9 +12,9 @@
 
 #include "wayland/datadevicemanager.h"
 
+#include <QList>
 #include <QPoint>
 #include <QPointer>
-#include <QVector>
 
 namespace KWin
 {
diff --git a/src/xwayland/drag_x.h b/src/xwayland/drag_x.h
index 7c55e75d82..65bfb8f33e 100644
--- a/src/xwayland/drag_x.h
+++ b/src/xwayland/drag_x.h
@@ -13,9 +13,9 @@
 
 #include "wayland/datadevicemanager.h"
 
+#include <QList>
 #include <QPoint>
 #include <QPointer>
-#include <QVector>
 
 namespace KWin
 {
@@ -28,7 +28,7 @@ enum class DragEventReply;
 class WlVisit;
 class Dnd;
 
-using Mimes = QVector<QPair<QString, xcb_atom_t>>;
+using Mimes = QList<QPair<QString, xcb_atom_t>>;
 
 class XToWlDrag : public Drag
 {
@@ -61,10 +61,10 @@ private:
     XwlDataSource m_selectionSource;
 
     X11Source *m_source;
-    QVector<QPair<xcb_timestamp_t, bool>> m_dataRequests;
+    QList<QPair<xcb_timestamp_t, bool>> m_dataRequests;
 
     WlVisit *m_visit = nullptr;
-    QVector<WlVisit *> m_oldVisits;
+    QList<WlVisit *> m_oldVisits;
 
     bool m_performed = false;
     DataDeviceManagerInterface::DnDAction m_lastSelectedDragAndDropAction = DataDeviceManagerInterface::DnDAction::None;
diff --git a/src/xwayland/lib/xwaylandsocket.cpp b/src/xwayland/lib/xwaylandsocket.cpp
index e31899c602..aa2c000891 100644
--- a/src/xwayland/lib/xwaylandsocket.cpp
+++ b/src/xwayland/lib/xwaylandsocket.cpp
@@ -177,7 +177,7 @@ XwaylandSocket::XwaylandSocket(OperationMode mode)
             continue;
         }
 
-        QVector<int> fileDescriptors;
+        QList<int> fileDescriptors;
         auto socketCleanup = qScopeGuard([&fileDescriptors]() {
             for (const int &fileDescriptor : std::as_const(fileDescriptors)) {
                 close(fileDescriptor);
@@ -232,7 +232,7 @@ bool XwaylandSocket::isValid() const
     return m_display != -1;
 }
 
-QVector<int> XwaylandSocket::fileDescriptors() const
+QList<int> XwaylandSocket::fileDescriptors() const
 {
     return m_fileDescriptors;
 }
diff --git a/src/xwayland/lib/xwaylandsocket.h b/src/xwayland/lib/xwaylandsocket.h
index 80bad35094..0ab3a126ce 100644
--- a/src/xwayland/lib/xwaylandsocket.h
+++ b/src/xwayland/lib/xwaylandsocket.h
@@ -7,8 +7,8 @@
 #pragma once
 
 #include <QByteArray>
+#include <QList>
 #include <QString>
-#include <QVector>
 
 namespace KWin
 {
@@ -28,10 +28,10 @@ public:
     int display() const;
     QString name() const;
 
-    QVector<int> fileDescriptors() const;
+    QList<int> fileDescriptors() const;
 
 private:
-    QVector<int> m_fileDescriptors;
+    QList<int> m_fileDescriptors;
     int m_display = -1;
     QString m_socketFilePath;
     QString m_lockFilePath;
diff --git a/src/xwayland/selection.h b/src/xwayland/selection.h
index 398eff060a..438fc4c6a6 100644
--- a/src/xwayland/selection.h
+++ b/src/xwayland/selection.h
@@ -8,8 +8,8 @@
 */
 #pragma once
 
+#include <QList>
 #include <QObject>
-#include <QVector>
 
 #include <xcb/xcb.h>
 
@@ -123,8 +123,8 @@ private:
     X11Source *m_xSource = nullptr;
 
     // active transfers
-    QVector<TransferWltoX *> m_wlToXTransfers;
-    QVector<TransferXtoWl *> m_xToWlTransfers;
+    QList<TransferWltoX *> m_wlToXTransfers;
+    QList<TransferXtoWl *> m_xToWlTransfers;
     QTimer *m_timeoutTransfers = nullptr;
 
     bool m_disownPending = false;
diff --git a/src/xwayland/selection_source.cpp b/src/xwayland/selection_source.cpp
index d4fbed6ca1..5d81c272a4 100644
--- a/src/xwayland/selection_source.cpp
+++ b/src/xwayland/selection_source.cpp
@@ -85,7 +85,7 @@ bool WlSource::handleSelectionRequest(xcb_selection_request_event_t *event)
 
 void WlSource::sendTargets(xcb_selection_request_event_t *event)
 {
-    QVector<xcb_atom_t> targets;
+    QList<xcb_atom_t> targets;
     targets.resize(m_offers.size() + 2);
     targets[0] = atoms->timestamp;
     targets[1] = atoms->targets;
diff --git a/src/xwayland/selection_source.h b/src/xwayland/selection_source.h
index 89a9a591e7..2910e304d6 100644
--- a/src/xwayland/selection_source.h
+++ b/src/xwayland/selection_source.h
@@ -8,8 +8,8 @@
 */
 #pragma once
 
+#include <QList>
 #include <QObject>
-#include <QVector>
 
 #include <xcb/xcb.h>
 
@@ -95,13 +95,13 @@ private:
 
     AbstractDataSource *m_dsi = nullptr;
 
-    QVector<QString> m_offers;
+    QList<QString> m_offers;
     QMetaObject::Connection m_offerConnection;
 
     Q_DISABLE_COPY(WlSource)
 };
 
-using Mimes = QVector<QPair<QString, xcb_atom_t>>;
+using Mimes = QList<QPair<QString, xcb_atom_t>>;
 
 /**
  * Representing an X data source.
diff --git a/src/xwayland/transfer.h b/src/xwayland/transfer.h
index 6f47f37e89..5d12e818d4 100644
--- a/src/xwayland/transfer.h
+++ b/src/xwayland/transfer.h
@@ -8,9 +8,9 @@
 */
 #pragma once
 
+#include <QList>
 #include <QObject>
 #include <QSocketNotifier>
-#include <QVector>
 
 #include <xcb/xcb.h>
 
@@ -133,7 +133,7 @@ private:
     /* contains all received data portioned in chunks
      * TODO: explain second QPair component
      */
-    QVector<QPair<QByteArray, int>> m_chunks;
+    QList<QPair<QByteArray, int>> m_chunks;
 
     bool m_propertyIsSet = false;
     bool m_flushPropertyOnDelete = false;
diff --git a/src/xwayland/xwaylandlauncher.cpp b/src/xwayland/xwaylandlauncher.cpp
index 72b4cab631..53789de5b9 100644
--- a/src/xwayland/xwaylandlauncher.cpp
+++ b/src/xwayland/xwaylandlauncher.cpp
@@ -54,7 +54,7 @@ XwaylandLauncher::~XwaylandLauncher()
 {
 }
 
-void XwaylandLauncher::setListenFDs(const QVector<int> &listenFds)
+void XwaylandLauncher::setListenFDs(const QList<int> &listenFds)
 {
     m_listenFds = listenFds;
 }
@@ -116,7 +116,7 @@ bool XwaylandLauncher::start()
     if (m_xwaylandProcess) {
         return false;
     }
-    QVector<int> fdsToClose;
+    QList<int> fdsToClose;
     auto cleanup = qScopeGuard([&fdsToClose] {
         for (const int fd : std::as_const(fdsToClose)) {
             close(fd);
diff --git a/src/xwayland/xwaylandlauncher.h b/src/xwayland/xwaylandlauncher.h
index f9917ecc59..3c58e81696 100644
--- a/src/xwayland/xwaylandlauncher.h
+++ b/src/xwayland/xwaylandlauncher.h
@@ -10,11 +10,11 @@
 
 #pragma once
 
+#include <QList>
 #include <QObject>
 #include <QProcess>
 #include <QSocketNotifier>
 #include <QTemporaryFile>
-#include <QVector>
 #include <memory>
 
 #include <kwin_export.h>
@@ -41,7 +41,7 @@ public:
      * That external process is responsible for setting up the DISPLAY env with a valid value.
      * Ownership of the file descriptor is not transferrred.
      */
-    void setListenFDs(const QVector<int> &listenFds);
+    void setListenFDs(const QList<int> &listenFds);
 
     /**
      * Sets the display name used by XWayland (i.e ':0')
@@ -99,7 +99,7 @@ private:
     QTimer *m_resetCrashCountTimer = nullptr;
     // this is only used when kwin is run without kwin_wayland_wrapper
     std::unique_ptr<XwaylandSocket> m_socket;
-    QVector<int> m_listenFds;
+    QList<int> m_listenFds;
     QString m_displayName;
     QString m_xAuthority;
 
diff --git a/src/xwayland/xwldrophandler.h b/src/xwayland/xwldrophandler.h
index 3826e7fa16..952121004c 100644
--- a/src/xwayland/xwldrophandler.h
+++ b/src/xwayland/xwldrophandler.h
@@ -35,7 +35,7 @@ private:
     void drop() override;
     Xvisit *m_xvisit = nullptr;
     Dnd *const m_dnd;
-    QVector<Xvisit *> m_previousVisits;
+    QList<Xvisit *> m_previousVisits;
 };
 }
 }
diff --git a/tests/x11shadowreader.cpp b/tests/x11shadowreader.cpp
index 70699f9c60..d46a49d154 100644
--- a/tests/x11shadowreader.cpp
+++ b/tests/x11shadowreader.cpp
@@ -14,10 +14,10 @@
 #include <QWidget>
 #include <private/qtx11extras_p.h>
 
-static QVector<uint32_t> readShadow(quint32 windowId)
+static QList<uint32_t> readShadow(quint32 windowId)
 {
     KWin::Xcb::Atom atom(QByteArrayLiteral("_KDE_NET_WM_SHADOW"), false, QX11Info::connection());
-    QVector<uint32_t> ret;
+    QList<uint32_t> ret;
     if (windowId != XCB_WINDOW) {
         KWin::Xcb::Property property(false, windowId, atom, XCB_ATOM_CARDINAL, 0, 12);
         uint32_t *shadow = property.value<uint32_t *>();
@@ -35,12 +35,12 @@ static QVector<uint32_t> readShadow(quint32 windowId)
     return ret;
 }
 
-static QVector<QPixmap> getPixmaps(const QVector<uint32_t> &data)
+static QList<QPixmap> getPixmaps(const QList<uint32_t> &data)
 {
-    QVector<QPixmap> ret;
+    QList<QPixmap> ret;
     static const int ShadowElementsCount = 8;
-    QVector<KWin::Xcb::WindowGeometry> pixmapGeometries(ShadowElementsCount);
-    QVector<xcb_get_image_cookie_t> getImageCookies(ShadowElementsCount);
+    QList<KWin::Xcb::WindowGeometry> pixmapGeometries(ShadowElementsCount);
+    QList<xcb_get_image_cookie_t> getImageCookies(ShadowElementsCount);
     auto *c = KWin::connection();
     for (int i = 0; i < ShadowElementsCount; ++i) {
         pixmapGeometries[i] = KWin::Xcb::WindowGeometry(data[i]);
@@ -54,7 +54,7 @@ static QVector<QPixmap> getPixmaps(const QVector<uint32_t> &data)
         auto &geo = pixmapGeometries[i];
         if (geo.isNull()) {
             discardReplies(0);
-            return QVector<QPixmap>();
+            return QList<QPixmap>();
         }
         getImageCookies[i] = xcb_get_image_unchecked(c, XCB_IMAGE_FORMAT_Z_PIXMAP, data[i],
                                                      0, 0, geo->width, geo->height, ~0);
@@ -63,7 +63,7 @@ static QVector<QPixmap> getPixmaps(const QVector<uint32_t> &data)
         auto *reply = xcb_get_image_reply(c, getImageCookies.at(i), nullptr);
         if (!reply) {
             discardReplies(i + 1);
-            return QVector<QPixmap>();
+            return QList<QPixmap>();
         }
         auto &geo = pixmapGeometries[i];
         QImage image(xcb_get_image_data(reply), geo->width, geo->height, QImage::Format_ARGB32);