diff --git a/include/stdplus/pinned.hpp b/include/stdplus/pinned.hpp
new file mode 100644
index 0000000..085ea8d
--- /dev/null
+++ b/include/stdplus/pinned.hpp
@@ -0,0 +1,106 @@
+#pragma once
+#include <functional>
+#include <memory>
+#include <type_traits>
+#include <utility>
+
+namespace stdplus
+{
+namespace detail
+{
+
+template <typename T, bool F = std::is_fundamental_v<T>>
+struct PinWrap
+{
+    using type = T;
+};
+
+template <typename T>
+struct PinWrap<T, true>
+{
+    using type = struct
+    {
+        T v;
+        constexpr operator T&()
+        {
+            return v;
+        }
+        constexpr operator T() const
+        {
+            return v;
+        }
+    };
+};
+
+} // namespace detail
+
+/** @brief Lightweight class wrapper that removes move operations from a class
+ *         in order to guarantee the contents stay pinned to a specific location
+ *         in memory.
+ */
+template <typename T, typename CT = detail::PinWrap<T>::type>
+struct Pinned : CT
+{
+    using type = T;
+
+    Pinned(Pinned&&) = delete;
+    Pinned& operator=(Pinned&&) = delete;
+
+    template <typename... Args>
+    constexpr Pinned(Args&&... args) noexcept(
+        noexcept(CT(std::declval<Args>()...))) :
+        CT(std::forward<Args>(args)...)
+    {
+    }
+
+    template <typename Arg>
+    constexpr Pinned& operator=(Arg&& arg) noexcept(
+        noexcept(std::declval<CT>() = std::declval<Arg>()))
+    {
+        static_cast<CT&>(*this) = std::forward<Arg>(arg);
+        return *this;
+    }
+};
+
+template <typename T>
+struct PinnedRef : std::reference_wrapper<T>
+{
+    using type = T;
+    using wrapper = std::reference_wrapper<T>;
+
+    template <typename U,
+              std::enable_if_t<
+                  !std::is_move_constructible_v<std::remove_cvref_t<U>> &&
+                      !std::is_move_assignable_v<std::remove_cvref_t<U>>,
+                  bool> = true>
+    constexpr PinnedRef(U& u) noexcept : wrapper(u)
+    {
+    }
+
+    template <typename U>
+    constexpr PinnedRef(Pinned<U>& u) noexcept : wrapper(u)
+    {
+    }
+    template <typename U,
+              std::enable_if_t<!std::is_same_v<U, void> && std::is_const_v<T>,
+                               bool> = true>
+    constexpr PinnedRef(const Pinned<U>& u) noexcept : wrapper(u)
+    {
+    }
+
+    template <typename U>
+    constexpr PinnedRef(const std::unique_ptr<U>& u) noexcept : wrapper(*u)
+    {
+    }
+
+    template <typename U>
+    constexpr PinnedRef(const std::shared_ptr<U>& u) noexcept : wrapper(*u)
+    {
+    }
+};
+
+} // namespace stdplus
+
+template <class T>
+typename stdplus::Pinned<T>&&
+    std::move(stdplus::Pinned<T>& t) noexcept = delete;
diff --git a/test/meson.build b/test/meson.build
index 2a6645f..16e1e77 100644
--- a/test/meson.build
+++ b/test/meson.build
@@ -3,6 +3,7 @@
   'exception': [stdplus_dep, gtest_main_dep],
   'handle/copyable': [stdplus_dep, gtest_main_dep],
   'handle/managed': [stdplus_dep, gtest_main_dep],
+  'pinned': [stdplus_dep, gtest_main_dep],
   'raw': [stdplus_dep, gmock_dep, gtest_main_dep],
   'signal': [stdplus_dep, gtest_main_dep],
   'util/cexec': [stdplus_dep, gtest_main_dep],
diff --git a/test/pinned.cpp b/test/pinned.cpp
new file mode 100644
index 0000000..c8daa3c
--- /dev/null
+++ b/test/pinned.cpp
@@ -0,0 +1,107 @@
+#include <gtest/gtest.h>
+#include <memory>
+#include <stdplus/pinned.hpp>
+#include <string>
+
+namespace stdplus
+{
+
+static_assert(noexcept(Pinned<int>(4)));
+static_assert(!noexcept(Pinned<std::string>("4")));
+
+TEST(Pinned, Basic)
+{
+    EXPECT_EQ("hi", Pinned<std::string>("hi"));
+    EXPECT_EQ("hi", Pinned<std::string>(std::string("hi")));
+    auto s = std::string("hi");
+    EXPECT_EQ("hi", Pinned<std::string>(s));
+    EXPECT_EQ("hi", Pinned<std::string>(std::move(s)));
+    Pinned<std::string> ps = "hi";
+    EXPECT_EQ("hi", Pinned<std::string>(ps));
+    // EXPECT_EQ("hi", Pinned<std::string>(std::move(ps)));
+    ps = "hi";
+    EXPECT_EQ("hi", ps);
+    s = std::string("hi");
+    ps = s;
+    EXPECT_EQ("hi", ps);
+    ps = std::move(s);
+    EXPECT_EQ("hi", ps);
+    Pinned<std::string> ps2;
+    ps2 = ps;
+    EXPECT_EQ("hi", ps2);
+    // ps2 = std::move(ps);
+    // std::string s2 = std::move(ps2);
+    EXPECT_EQ("hi", [](std::string& f) { return f; }(ps2));
+    EXPECT_EQ("hi", [](std::string f) { return f; }(ps2));
+}
+
+TEST(Pinned, Fundamental)
+{
+    Pinned<int> pi = 4;
+    EXPECT_EQ(4, [](int& f) { return f; }(pi));
+    EXPECT_EQ(4, [](int f) { return f; }(pi));
+}
+
+struct NoMove1
+{
+    NoMove1() = default;
+    NoMove1(NoMove1&&) = delete;
+    NoMove1& operator=(NoMove1&&) = default;
+};
+
+struct NoMove2
+{
+    NoMove2() = default;
+    NoMove2(NoMove2&&) = default;
+    NoMove2& operator=(NoMove2&&) = delete;
+};
+
+struct NoMove3
+{
+    NoMove3() = default;
+    NoMove3(NoMove3&&) = delete;
+    NoMove3& operator=(NoMove3&&) = delete;
+};
+
+TEST(PinnedRef, Basic)
+{
+    auto uptr = std::make_unique<std::string>("hi");
+    PinnedRef<std::string>(uptr).get()[0] = 'd';
+    EXPECT_EQ("di", *uptr);
+    PinnedRef<const std::string> cref(uptr);
+    // cref.get()[0] = 'e';
+    EXPECT_EQ("di", cref.get());
+
+    auto sptr = std::make_shared<std::string>("hi");
+    EXPECT_EQ("hi", PinnedRef<std::string>(sptr).get());
+
+    Pinned<std::string> pstr("hi");
+    EXPECT_EQ("hi", PinnedRef<std::string>(pstr).get());
+    EXPECT_EQ("hi", PinnedRef<const std::string>(pstr).get());
+    const Pinned<std::string> cpstr("hi");
+    // EXPECT_EQ("hi", PinnedRef<std::string>(cpstr).get());
+    EXPECT_EQ("hi", PinnedRef<const std::string>(cpstr).get());
+}
+
+TEST(PinnedRef, Fundamental)
+{
+    auto uptr = std::make_unique<int>(4);
+    EXPECT_EQ(4, PinnedRef<int>(uptr));
+    Pinned<int> pi = 4;
+    EXPECT_EQ(4, PinnedRef<int>(pi));
+    EXPECT_EQ(4, PinnedRef<const int>(pi));
+}
+
+TEST(PinnedREf, NoMove)
+{
+    // int i;
+    // PinnedRef<int> ri(i);
+    // NoMove1 nm1;
+    // PinnedRef<NoMove1> rnm1(nm1);
+    // NoMove2 nm2;
+    // PinnedRef<NoMove2> rnm2(nm2);
+    NoMove3 nm3;
+    PinnedRef<NoMove3> rnm3(nm3);
+}
+
+} // namespace stdplus