diff --git a/src/helpers/Monitor.cpp b/src/helpers/Monitor.cpp
index 44ac1dcf9..c2f1ab5b9 100644
--- a/src/helpers/Monitor.cpp
+++ b/src/helpers/Monitor.cpp
@@ -175,8 +175,13 @@ void CMonitor::onConnect(bool noRule) {
 
     if (m_output->nonDesktop) {
         Debug::log(LOG, "Not configuring non-desktop output");
-        if (PROTO::lease)
-            PROTO::lease->offer(m_self.lock());
+
+        for (auto& [name, lease] : PROTO::lease) {
+            if (!lease || m_output->getBackend() != lease->getBackend())
+                continue;
+
+            lease->offer(m_self.lock());
+        }
 
         return;
     }
diff --git a/src/managers/ProtocolManager.cpp b/src/managers/ProtocolManager.cpp
index 4748debf3..f02687209 100644
--- a/src/managers/ProtocolManager.cpp
+++ b/src/managers/ProtocolManager.cpp
@@ -203,10 +203,14 @@ CProtocolManager::CProtocolManager() {
         if (b->type() != Aquamarine::AQ_BACKEND_DRM)
             continue;
 
-        PROTO::lease = makeUnique<CDRMLeaseProtocol>(&wp_drm_lease_device_v1_interface, 1, "DRMLease");
-        if (*PENABLEEXPLICIT)
+        auto lease = makeShared<CDRMLeaseProtocol>(&wp_drm_lease_device_v1_interface, 1, "DRMLease", b);
+        if (lease->good())
+            PROTO::lease.emplace(lease->getDeviceName(), lease);
+        else
+            lease.reset();
+
+        if (*PENABLEEXPLICIT && !PROTO::sync)
             PROTO::sync = makeUnique<CDRMSyncobjProtocol>(&wp_linux_drm_syncobj_manager_v1_interface, 1, "DRMSyncobj");
-        break;
     }
 
     if (!g_pHyprOpenGL->getDRMFormats().empty()) {
@@ -281,7 +285,9 @@ CProtocolManager::~CProtocolManager() {
     PROTO::xdgTag.reset();
     PROTO::xdgBell.reset();
 
-    PROTO::lease.reset();
+    for (auto& [_, lease] : PROTO::lease) {
+        lease.reset();
+    }
     PROTO::sync.reset();
     PROTO::mesaDRM.reset();
     PROTO::linuxDma.reset();
diff --git a/src/protocols/DRMLease.cpp b/src/protocols/DRMLease.cpp
index 622c907c7..891b503cf 100644
--- a/src/protocols/DRMLease.cpp
+++ b/src/protocols/DRMLease.cpp
@@ -1,7 +1,10 @@
 #include "DRMLease.hpp"
 #include "../Compositor.hpp"
 #include "../helpers/Monitor.hpp"
+#include "drm-lease-v1.hpp"
 #include "managers/eventLoop/EventLoopManager.hpp"
+#include "protocols/WaylandProtocol.hpp"
+#include <algorithm>
 #include <aquamarine/backend/DRM.hpp>
 #include <fcntl.h>
 using namespace Hyprutils::OS;
@@ -10,12 +13,18 @@ CDRMLeaseResource::CDRMLeaseResource(SP<CWpDrmLeaseV1> resource_, SP<CDRMLeaseRe
     if UNLIKELY (!good())
         return;
 
-    m_resource->setOnDestroy([this](CWpDrmLeaseV1* r) { PROTO::lease->destroyResource(this); });
-    m_resource->setDestroy([this](CWpDrmLeaseV1* r) { PROTO::lease->destroyResource(this); });
-
     m_parent    = request->m_parent;
     m_requested = request->m_requested;
 
+    m_resource->setOnDestroy([this](CWpDrmLeaseV1* r) {
+        if (m_parent && PROTO::lease.contains(m_parent->m_deviceName))
+            PROTO::lease.at(m_parent->m_deviceName)->destroyResource(this);
+    });
+    m_resource->setDestroy([this](CWpDrmLeaseV1* r) {
+        if (m_parent && PROTO::lease.contains(m_parent->m_deviceName))
+            PROTO::lease.at(m_parent->m_deviceName)->destroyResource(this);
+    });
+
     for (auto const& m : m_requested) {
         if (!m->m_monitor || m->m_monitor->m_isBeingLeased) {
             LOGM(ERR, "Rejecting lease: no monitor or monitor is being leased for {}", (m->m_monitor ? m->m_monitor->m_name : "null"));
@@ -82,11 +91,14 @@ CDRMLeaseResource::~CDRMLeaseResource() {
     m_listeners.destroyLease.reset();
 }
 
-CDRMLeaseRequestResource::CDRMLeaseRequestResource(SP<CWpDrmLeaseRequestV1> resource_) : m_resource(resource_) {
+CDRMLeaseRequestResource::CDRMLeaseRequestResource(WP<CDRMLeaseDeviceResource> parent_, SP<CWpDrmLeaseRequestV1> resource_) : m_parent(parent_), m_resource(resource_) {
     if UNLIKELY (!good())
         return;
 
-    m_resource->setOnDestroy([this](CWpDrmLeaseRequestV1* r) { PROTO::lease->destroyResource(this); });
+    m_resource->setOnDestroy([this](CWpDrmLeaseRequestV1* r) {
+        if (m_parent && PROTO::lease.contains(m_parent->m_deviceName))
+            PROTO::lease.at(m_parent->m_deviceName)->destroyResource(this);
+    });
 
     m_resource->setRequestConnector([this](CWpDrmLeaseRequestV1* r, wl_resource* conn) {
         if (!conn) {
@@ -101,7 +113,12 @@ CDRMLeaseRequestResource::CDRMLeaseRequestResource(SP<CWpDrmLeaseRequestV1> reso
             return;
         }
 
-        // TODO: when (if) we add multi, make sure this is from the correct device.
+        auto& lease = PROTO::lease.at(m_parent->m_deviceName);
+
+        if (std::ranges::find(lease->m_connectors.begin(), lease->m_connectors.end(), CONNECTOR) == lease->m_connectors.end()) {
+            m_resource->error(WP_DRM_LEASE_REQUEST_V1_ERROR_WRONG_DEVICE, "Connector requested for wrong device");
+            return;
+        }
 
         m_requested.emplace_back(CONNECTOR);
     });
@@ -118,10 +135,10 @@ CDRMLeaseRequestResource::CDRMLeaseRequestResource(SP<CWpDrmLeaseRequestV1> reso
             return;
         }
 
-        PROTO::lease->m_leases.emplace_back(RESOURCE);
+        PROTO::lease.at(m_parent->m_deviceName)->m_leases.emplace_back(RESOURCE);
 
         // per protcol, after submit, this is dead.
-        PROTO::lease->destroyResource(this);
+        PROTO::lease.at(m_parent->m_deviceName)->destroyResource(this);
     });
 }
 
@@ -134,12 +151,19 @@ SP<CDRMLeaseConnectorResource> CDRMLeaseConnectorResource::fromResource(wl_resou
     return data ? data->m_self.lock() : nullptr;
 }
 
-CDRMLeaseConnectorResource::CDRMLeaseConnectorResource(SP<CWpDrmLeaseConnectorV1> resource_, PHLMONITOR monitor_) : m_monitor(monitor_), m_resource(resource_) {
+CDRMLeaseConnectorResource::CDRMLeaseConnectorResource(WP<CDRMLeaseDeviceResource> parent_, SP<CWpDrmLeaseConnectorV1> resource_, PHLMONITOR monitor_) :
+    m_parent(parent_), m_monitor(monitor_), m_resource(resource_) {
     if UNLIKELY (!good())
         return;
 
-    m_resource->setOnDestroy([this](CWpDrmLeaseConnectorV1* r) { PROTO::lease->destroyResource(this); });
-    m_resource->setDestroy([this](CWpDrmLeaseConnectorV1* r) { PROTO::lease->destroyResource(this); });
+    m_resource->setOnDestroy([this](CWpDrmLeaseConnectorV1* r) {
+        if (m_parent && PROTO::lease.contains(m_parent->m_deviceName))
+            PROTO::lease.at(m_parent->m_deviceName)->destroyResource(this);
+    });
+    m_resource->setDestroy([this](CWpDrmLeaseConnectorV1* r) {
+        if (m_parent && PROTO::lease.contains(m_parent->m_deviceName))
+            PROTO::lease.at(m_parent->m_deviceName)->destroyResource(this);
+    });
 
     m_resource->setData(this);
 
@@ -163,15 +187,21 @@ void CDRMLeaseConnectorResource::sendData() {
     m_resource->sendDone();
 }
 
-CDRMLeaseDeviceResource::CDRMLeaseDeviceResource(SP<CWpDrmLeaseDeviceV1> resource_) : m_resource(resource_) {
+CDRMLeaseDeviceResource::CDRMLeaseDeviceResource(std::string deviceName_, SP<CWpDrmLeaseDeviceV1> resource_) : m_deviceName(deviceName_), m_resource(resource_) {
     if UNLIKELY (!good())
         return;
 
-    m_resource->setOnDestroy([this](CWpDrmLeaseDeviceV1* r) { PROTO::lease->destroyResource(this); });
-    m_resource->setRelease([this](CWpDrmLeaseDeviceV1* r) { PROTO::lease->destroyResource(this); });
+    m_resource->setOnDestroy([this](CWpDrmLeaseDeviceV1* r) {
+        if (PROTO::lease.contains(m_deviceName))
+            PROTO::lease.at(m_deviceName)->destroyResource(this);
+    });
+    m_resource->setRelease([this](CWpDrmLeaseDeviceV1* r) {
+        if (PROTO::lease.contains(m_deviceName))
+            PROTO::lease.at(m_deviceName)->destroyResource(this);
+    });
 
     m_resource->setCreateLeaseRequest([this](CWpDrmLeaseDeviceV1* r, uint32_t id) {
-        auto RESOURCE = makeShared<CDRMLeaseRequestResource>(makeShared<CWpDrmLeaseRequestV1>(m_resource->client(), m_resource->version(), id));
+        auto RESOURCE = makeShared<CDRMLeaseRequestResource>(m_self, makeShared<CWpDrmLeaseRequestV1>(m_resource->client(), m_resource->version(), id));
         if UNLIKELY (!RESOURCE) {
             m_resource->noMemory();
             return;
@@ -179,14 +209,14 @@ CDRMLeaseDeviceResource::CDRMLeaseDeviceResource(SP<CWpDrmLeaseDeviceV1> resourc
 
         RESOURCE->m_self = RESOURCE;
 
-        PROTO::lease->m_requests.emplace_back(RESOURCE);
+        PROTO::lease.at(m_deviceName)->m_requests.emplace_back(RESOURCE);
 
         LOGM(LOG, "New lease request {}", id);
 
         RESOURCE->m_parent = m_self;
     });
 
-    CFileDescriptor fd{((Aquamarine::CDRMBackend*)PROTO::lease->m_primaryDevice->m_backend.get())->getNonMasterFD()};
+    CFileDescriptor fd{PROTO::lease.at(m_deviceName)->m_backend.get()->getNonMasterFD()};
     if (!fd.isValid()) {
         LOGM(ERR, "Failed to dup fd in lease");
         return;
@@ -195,7 +225,7 @@ CDRMLeaseDeviceResource::CDRMLeaseDeviceResource(SP<CWpDrmLeaseDeviceV1> resourc
     LOGM(LOG, "Sending DRMFD {} to new lease device", fd.get());
     m_resource->sendDrmFd(fd.get());
 
-    for (auto const& m : PROTO::lease->m_primaryDevice->m_offeredOutputs) {
+    for (auto const& m : PROTO::lease.at(m_deviceName)->m_offeredOutputs) {
         if (m)
             sendConnector(m.lock());
     }
@@ -211,7 +241,7 @@ void CDRMLeaseDeviceResource::sendConnector(PHLMONITOR monitor) {
     if (std::ranges::find_if(m_connectorsSent, [monitor](const auto& e) { return e && !e->m_dead && e->m_monitor == monitor; }) != m_connectorsSent.end())
         return;
 
-    auto RESOURCE = makeShared<CDRMLeaseConnectorResource>(makeShared<CWpDrmLeaseConnectorV1>(m_resource->client(), m_resource->version(), 0), monitor);
+    auto RESOURCE = makeShared<CDRMLeaseConnectorResource>(m_self, makeShared<CWpDrmLeaseConnectorV1>(m_resource->client(), m_resource->version(), 0), monitor);
     if UNLIKELY (!RESOURCE) {
         m_resource->noMemory();
         return;
@@ -223,46 +253,33 @@ void CDRMLeaseDeviceResource::sendConnector(PHLMONITOR monitor) {
     LOGM(LOG, "Sending new connector {}", monitor->m_name);
 
     m_connectorsSent.emplace_back(RESOURCE);
-    PROTO::lease->m_connectors.emplace_back(RESOURCE);
+    PROTO::lease.at(m_deviceName)->m_connectors.emplace_back(RESOURCE);
 
     m_resource->sendConnector(RESOURCE->m_resource.get());
 
     RESOURCE->sendData();
 }
 
-CDRMLeaseDevice::CDRMLeaseDevice(SP<Aquamarine::CDRMBackend> drmBackend) : m_backend(drmBackend) {
-    auto            drm = (Aquamarine::CDRMBackend*)drmBackend.get();
+CDRMLeaseProtocol::CDRMLeaseProtocol(const wl_interface* iface, const int& ver, const std::string& name, SP<Aquamarine::IBackendImplementation> backend_) :
+    IWaylandProtocol(iface, ver, name) {
+    if (backend_->type() != Aquamarine::AQ_BACKEND_DRM)
+        return;
 
-    CFileDescriptor fd{drm->getNonMasterFD()};
+    m_backend    = ((Aquamarine::CDRMBackend*)backend_.get())->self.lock();
+    m_deviceName = m_backend->gpuName;
+
+    CFileDescriptor fd{m_backend->getNonMasterFD()};
 
     if (!fd.isValid()) {
-        LOGM(ERR, "Failed to dup fd for drm node {}", drm->gpuName);
+        LOGM(ERR, "Failed to dup fd for drm node {}", m_deviceName);
         return;
     }
 
     m_success = true;
-    m_name    = drm->gpuName;
-}
-
-CDRMLeaseProtocol::CDRMLeaseProtocol(const wl_interface* iface, const int& ver, const std::string& name) : IWaylandProtocol(iface, ver, name) {
-    for (auto const& b : g_pCompositor->m_aqBackend->getImplementations()) {
-        if (b->type() != Aquamarine::AQ_BACKEND_DRM)
-            continue;
-
-        auto drm = ((Aquamarine::CDRMBackend*)b.get())->self.lock();
-
-        m_primaryDevice = makeShared<CDRMLeaseDevice>(drm);
-
-        if (m_primaryDevice->m_success)
-            break;
-    }
-
-    if (!m_primaryDevice || !m_primaryDevice->m_success)
-        g_pEventLoopManager->doLater([]() { PROTO::lease.reset(); });
 }
 
 void CDRMLeaseProtocol::bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id) {
-    const auto RESOURCE = m_managers.emplace_back(makeShared<CDRMLeaseDeviceResource>(makeShared<CWpDrmLeaseDeviceV1>(client, ver, id)));
+    const auto RESOURCE = m_managers.emplace_back(makeShared<CDRMLeaseDeviceResource>(m_deviceName, makeShared<CWpDrmLeaseDeviceV1>(client, ver, id)));
 
     if UNLIKELY (!RESOURCE->good()) {
         wl_client_post_no_memory(client);
@@ -293,22 +310,34 @@ void CDRMLeaseProtocol::destroyResource(CDRMLeaseResource* resource) {
 }
 
 void CDRMLeaseProtocol::offer(PHLMONITOR monitor) {
-    std::erase_if(m_primaryDevice->m_offeredOutputs, [](const auto& e) { return e.expired(); });
-    if (std::ranges::find(m_primaryDevice->m_offeredOutputs, monitor) != m_primaryDevice->m_offeredOutputs.end())
+    std::erase_if(m_offeredOutputs, [](const auto& e) { return e.expired(); });
+    if (std::ranges::find(m_offeredOutputs.begin(), m_offeredOutputs.end(), monitor) != m_offeredOutputs.end())
         return;
 
     if (monitor->m_output->getBackend()->type() != Aquamarine::AQ_BACKEND_DRM)
         return;
 
-    if (monitor->m_output->getBackend() != m_primaryDevice->m_backend) {
-        LOGM(ERR, "Monitor {} cannot be leased: primaryDevice lease is for a different device", monitor->m_name);
+    if (monitor->m_output->getBackend() != m_backend) {
+        LOGM(ERR, "Monitor {} cannot be leased: lease is for a different device", monitor->m_name);
         return;
     }
 
-    m_primaryDevice->m_offeredOutputs.emplace_back(monitor);
+    m_offeredOutputs.emplace_back(monitor);
 
     for (auto const& m : m_managers) {
         m->sendConnector(monitor);
         m->m_resource->sendDone();
     }
 }
+
+std::string CDRMLeaseProtocol::getDeviceName() {
+    return m_deviceName;
+}
+
+SP<Aquamarine::IBackendImplementation> CDRMLeaseProtocol::getBackend() {
+    return m_backend;
+}
+
+bool CDRMLeaseProtocol::good() {
+    return m_success;
+}
diff --git a/src/protocols/DRMLease.hpp b/src/protocols/DRMLease.hpp
index 5ea1c4e23..404fc29d1 100644
--- a/src/protocols/DRMLease.hpp
+++ b/src/protocols/DRMLease.hpp
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <aquamarine/backend/Backend.hpp>
 #include <vector>
 #include <unordered_map>
 #include "WaylandProtocol.hpp"
@@ -40,7 +41,7 @@ class CDRMLeaseResource {
 
 class CDRMLeaseRequestResource {
   public:
-    CDRMLeaseRequestResource(SP<CWpDrmLeaseRequestV1> resource_);
+    CDRMLeaseRequestResource(WP<CDRMLeaseDeviceResource> parent_, SP<CWpDrmLeaseRequestV1> resource_);
 
     bool                                        good();
 
@@ -54,7 +55,7 @@ class CDRMLeaseRequestResource {
 
 class CDRMLeaseConnectorResource {
   public:
-    CDRMLeaseConnectorResource(SP<CWpDrmLeaseConnectorV1> resource_, PHLMONITOR monitor_);
+    CDRMLeaseConnectorResource(WP<CDRMLeaseDeviceResource> parent_, SP<CWpDrmLeaseConnectorV1> resource_, PHLMONITOR monitor_);
     static SP<CDRMLeaseConnectorResource> fromResource(wl_resource*);
 
     bool                                  good();
@@ -77,7 +78,7 @@ class CDRMLeaseConnectorResource {
 
 class CDRMLeaseDeviceResource {
   public:
-    CDRMLeaseDeviceResource(SP<CWpDrmLeaseDeviceV1> resource_);
+    CDRMLeaseDeviceResource(std::string deviceName, SP<CWpDrmLeaseDeviceV1> resource_);
 
     bool                                        good();
     void                                        sendConnector(PHLMONITOR monitor);
@@ -85,6 +86,7 @@ class CDRMLeaseDeviceResource {
     std::vector<WP<CDRMLeaseConnectorResource>> m_connectorsSent;
 
     WP<CDRMLeaseDeviceResource>                 m_self;
+    std::string                                 m_deviceName;
 
   private:
     SP<CWpDrmLeaseDeviceV1> m_resource;
@@ -92,24 +94,17 @@ class CDRMLeaseDeviceResource {
     friend class CDRMLeaseProtocol;
 };
 
-class CDRMLeaseDevice {
-  public:
-    CDRMLeaseDevice(SP<Aquamarine::CDRMBackend> drmBackend);
-
-    std::string                 m_name    = "";
-    bool                        m_success = false;
-    SP<Aquamarine::CDRMBackend> m_backend;
-
-    std::vector<PHLMONITORREF>  m_offeredOutputs;
-};
-
 class CDRMLeaseProtocol : public IWaylandProtocol {
   public:
-    CDRMLeaseProtocol(const wl_interface* iface, const int& ver, const std::string& name);
+    CDRMLeaseProtocol(const wl_interface* iface, const int& ver, const std::string& name, SP<Aquamarine::IBackendImplementation> backend);
 
-    virtual void bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id);
+    virtual void                           bindManager(wl_client* client, void* data, uint32_t ver, uint32_t id);
 
-    void         offer(PHLMONITOR monitor);
+    void                                   offer(PHLMONITOR monitor);
+
+    SP<Aquamarine::IBackendImplementation> getBackend();
+    std::string                            getDeviceName();
+    bool                                   good();
 
   private:
     void destroyResource(CDRMLeaseDeviceResource* resource);
@@ -123,7 +118,10 @@ class CDRMLeaseProtocol : public IWaylandProtocol {
     std::vector<SP<CDRMLeaseRequestResource>>   m_requests;
     std::vector<SP<CDRMLeaseResource>>          m_leases;
 
-    SP<CDRMLeaseDevice>                         m_primaryDevice;
+    std::string                                 m_deviceName = "";
+    bool                                        m_success    = false;
+    SP<Aquamarine::CDRMBackend>                 m_backend;
+    std::vector<PHLMONITORREF>                  m_offeredOutputs;
 
     friend class CDRMLeaseDeviceResource;
     friend class CDRMLeaseConnectorResource;
@@ -132,5 +130,5 @@ class CDRMLeaseProtocol : public IWaylandProtocol {
 };
 
 namespace PROTO {
-    inline UP<CDRMLeaseProtocol> lease;
+    inline std::unordered_map<std::string, SP<CDRMLeaseProtocol>> lease;
 };