diff --git a/AK/NonnullOwnPtr.h b/AK/NonnullOwnPtr.h
new file mode 100644
index 00000000000..7c8c7817f2c
--- /dev/null
+++ b/AK/NonnullOwnPtr.h
@@ -0,0 +1,157 @@
+#pragma once
+
+#include <AK/Assertions.h>
+#include <AK/LogStream.h>
+#include <AK/StdLibExtras.h>
+#include <AK/Traits.h>
+#include <AK/Types.h>
+
+namespace AK {
+
+template<typename T>
+class RefPtr;
+template<typename T>
+class NonnullRefPtr;
+template<typename T>
+class WeakPtr;
+
+template<typename T>
+class CONSUMABLE(unconsumed) NonnullOwnPtr {
+public:
+    enum AdoptTag { Adopt };
+
+    RETURN_TYPESTATE(unconsumed)
+    NonnullOwnPtr(AdoptTag, T& ptr)
+        : m_ptr(&ptr)
+    {
+    }
+    RETURN_TYPESTATE(unconsumed)
+    NonnullOwnPtr(NonnullOwnPtr&& other)
+        : m_ptr(other.leak_ptr())
+    {
+        ASSERT(m_ptr);
+    }
+    template<typename U>
+    RETURN_TYPESTATE(unconsumed)
+    NonnullOwnPtr(NonnullOwnPtr<U>&& other)
+        : m_ptr(static_cast<T*>(other.leak_ptr()))
+    {
+        ASSERT(m_ptr);
+    }
+    ~NonnullOwnPtr()
+    {
+        clear();
+#ifdef SANITIZE_PTRS
+        if constexpr (sizeof(T*) == 8)
+            m_ptr = (T*)(0xe3e3e3e3e3e3e3e3);
+        else
+            m_ptr = (T*)(0xe3e3e3e3);
+#endif
+    }
+
+    NonnullOwnPtr(const NonnullOwnPtr&) = delete;
+    template<typename U>
+    NonnullOwnPtr(const NonnullOwnPtr<U>&) = delete;
+    NonnullOwnPtr& operator=(const NonnullOwnPtr&) = delete;
+    template<typename U>
+    NonnullOwnPtr& operator=(const NonnullOwnPtr<U>&) = delete;
+
+    template<typename U>
+    NonnullOwnPtr(const RefPtr<U>&) = delete;
+    template<typename U>
+    NonnullOwnPtr(const NonnullRefPtr<U>&) = delete;
+    template<typename U>
+    NonnullOwnPtr(const WeakPtr<U>&) = delete;
+    template<typename U>
+    NonnullOwnPtr& operator=(const RefPtr<U>&) = delete;
+    template<typename U>
+    NonnullOwnPtr& operator=(const NonnullRefPtr<U>&) = delete;
+    template<typename U>
+    NonnullOwnPtr& operator=(const WeakPtr<U>&) = delete;
+
+    RETURN_TYPESTATE(unconsumed)
+    NonnullOwnPtr& operator=(NonnullOwnPtr&& other)
+    {
+        if (this != &other) {
+            delete m_ptr;
+            m_ptr = other.leak_ptr();
+            ASSERT(m_ptr);
+        }
+        return *this;
+    }
+
+    template<typename U>
+    RETURN_TYPESTATE(unconsumed)
+    NonnullOwnPtr& operator=(NonnullOwnPtr<U>&& other)
+    {
+        if (this != static_cast<void*>(&other)) {
+            delete m_ptr;
+            m_ptr = other.leak_ptr();
+            ASSERT(m_ptr);
+        }
+        return *this;
+    }
+
+    CALLABLE_WHEN(unconsumed)
+    SET_TYPESTATE(consumed)
+    T* leak_ptr()
+    {
+        return exchange(m_ptr, nullptr);
+    }
+
+    CALLABLE_WHEN(unconsumed)
+    T* ptr() { return m_ptr; }
+    CALLABLE_WHEN(unconsumed)
+    const T* ptr() const { return m_ptr; }
+
+    CALLABLE_WHEN(unconsumed)
+    T* operator->() { return m_ptr; }
+    CALLABLE_WHEN(unconsumed)
+    const T* operator->() const { return m_ptr; }
+
+    CALLABLE_WHEN(unconsumed)
+    T& operator*() { return *m_ptr; }
+    CALLABLE_WHEN(unconsumed)
+    const T& operator*() const { return *m_ptr; }
+
+    CALLABLE_WHEN(unconsumed)
+    operator const T*() const { return m_ptr; }
+    CALLABLE_WHEN(unconsumed)
+    operator T*() { return m_ptr; }
+
+private:
+    void clear()
+    {
+        if (!m_ptr)
+            return;
+        delete m_ptr;
+        m_ptr = nullptr;
+    }
+
+    T* m_ptr = nullptr;
+};
+
+template<class T, class... Args>
+inline NonnullOwnPtr<T>
+make(Args&&... args)
+{
+    return NonnullOwnPtr<T>(NonnullOwnPtr<T>::Adopt, *new T(forward<Args>(args)...));
+}
+
+template<typename T>
+struct Traits<NonnullOwnPtr<T>> : public GenericTraits<NonnullOwnPtr<T>> {
+    static unsigned hash(const NonnullOwnPtr<T>& p) { return (unsigned)p.ptr(); }
+    static void dump(const NonnullOwnPtr<T>& p) { kprintf("%p", p.ptr()); }
+    static bool equals(const NonnullOwnPtr<T>& a, const NonnullOwnPtr<T>& b) { return a.ptr() == b.ptr(); }
+};
+
+template<typename T>
+inline const LogStream& operator<<(const LogStream& stream, const NonnullOwnPtr<T>& value)
+{
+    return stream << value.ptr();
+}
+
+}
+
+using AK::make;
+using AK::NonnullOwnPtr;
diff --git a/AK/OwnPtr.h b/AK/OwnPtr.h
index ba93fd63b32..874f468751a 100644
--- a/AK/OwnPtr.h
+++ b/AK/OwnPtr.h
@@ -1,19 +1,9 @@
 #pragma once
 
-#include <AK/LogStream.h>
-#include <AK/StdLibExtras.h>
-#include <AK/Traits.h>
-#include <AK/Types.h>
+#include <AK/NonnullOwnPtr.h>
 
 namespace AK {
 
-template<typename T>
-class RefPtr;
-template<typename T>
-class NonnullRefPtr;
-template<typename T>
-class WeakPtr;
-
 template<typename T>
 class OwnPtr {
 public:
@@ -26,6 +16,12 @@ public:
         : m_ptr(other.leak_ptr())
     {
     }
+
+    template<typename U>
+    OwnPtr(NonnullOwnPtr<U>&& other)
+        : m_ptr(static_cast<T*>(other.leak_ptr()))
+    {
+    }
     template<typename U>
     OwnPtr(OwnPtr<U>&& other)
         : m_ptr(static_cast<T*>(other.leak_ptr()))
@@ -43,6 +39,13 @@ public:
 #endif
     }
 
+    OwnPtr(const OwnPtr&) = delete;
+    template<typename U>
+    OwnPtr(const OwnPtr<U>&) = delete;
+    OwnPtr& operator=(const OwnPtr&) = delete;
+    template<typename U>
+    OwnPtr& operator=(const OwnPtr<U>&) = delete;
+
     template<typename U>
     OwnPtr(const RefPtr<U>&) = delete;
     template<typename U>
@@ -75,6 +78,15 @@ public:
         return *this;
     }
 
+    template<typename U>
+    OwnPtr& operator=(NonnullOwnPtr<U>&& other)
+    {
+        ASSERT(m_ptr != other.ptr());
+        delete m_ptr;
+        m_ptr = other.leak_ptr();
+        return *this;
+    }
+
     OwnPtr& operator=(T* ptr)
     {
         if (m_ptr != ptr)
@@ -99,9 +111,9 @@ public:
 
     T* leak_ptr()
     {
-        T* leakedPtr = m_ptr;
+        T* leaked_ptr = m_ptr;
         m_ptr = nullptr;
-        return leakedPtr;
+        return leaked_ptr;
     }
 
     T* ptr() { return m_ptr; }
@@ -122,13 +134,6 @@ private:
     T* m_ptr = nullptr;
 };
 
-template<class T, class... Args>
-inline OwnPtr<T>
-make(Args&&... args)
-{
-    return OwnPtr<T>(new T(AK::forward<Args>(args)...));
-}
-
 template<typename T>
 struct Traits<OwnPtr<T>> : public GenericTraits<OwnPtr<T>> {
     static unsigned hash(const OwnPtr<T>& p) { return (unsigned)p.ptr(); }
@@ -144,5 +149,4 @@ inline const LogStream& operator<<(const LogStream& stream, const OwnPtr<T>& val
 
 }
 
-using AK::make;
 using AK::OwnPtr;