diff --git a/include/stdplus/net/addr/sock.hpp b/include/stdplus/net/addr/sock.hpp
index 9a0238d..e1f2e74 100644
--- a/include/stdplus/net/addr/sock.hpp
+++ b/include/stdplus/net/addr/sock.hpp
@@ -1,5 +1,6 @@
 #pragma once
 #include <netinet/in.h>
+#include <sys/un.h>
 
 #include <stdplus/net/addr/ip.hpp>
 #include <stdplus/numeric/endian.hpp>
@@ -7,6 +8,7 @@
 
 #include <array>
 #include <cstdint>
+#include <string_view>
 
 namespace stdplus
 {
@@ -14,7 +16,8 @@
 struct SockAddrBuf : sockaddr
 {
     static inline constexpr std::size_t maxLen =
-        std::max({sizeof(sockaddr_in), sizeof(sockaddr_in6)}) -
+        std::max(
+            {sizeof(sockaddr_in), sizeof(sockaddr_in6), sizeof(sockaddr_un)}) -
         sizeof(sockaddr);
     std::array<std::uint8_t, maxLen> buf;
     std::uint8_t len;
@@ -118,10 +121,96 @@
 struct IsSockAddr<Sock6Addr> : std::true_type
 {};
 
+struct SockUAddr
+{
+    static inline constexpr std::size_t maxLen =
+        std::size(sockaddr_un{}.sun_path);
+
+    constexpr explicit SockUAddr(std::string_view path) : len_(path.size())
+    {
+        if (path.empty())
+        {
+            return;
+        }
+        bool abstract = path[0] == '@' || path[0] == '\0';
+        // Abstract sockets are not null terminated but path sockets are
+        if (path.size() >= maxLen + (abstract ? 1 : 0))
+        {
+            throw std::invalid_argument("Socket path too long");
+        }
+        if (!abstract && path.find('\0') != path.npos)
+        {
+            throw std::invalid_argument("Null bytes in non-abtract path");
+        }
+        buf_[0] = abstract ? '@' : path[0];
+        std::copy(path.begin() + 1, path.end(), buf_.begin() + 1);
+    }
+
+    constexpr bool operator==(const SockUAddr& rhs) const noexcept
+    {
+        return path() == rhs.path();
+    }
+
+    constexpr std::string_view path() const noexcept
+    {
+        return {buf_.data(), len_};
+    }
+
+    constexpr sockaddr_un sockaddr() const noexcept
+    {
+        sockaddr_un ret;
+        fill(ret);
+        return ret;
+    }
+    constexpr operator sockaddr_un() const noexcept
+    {
+        return sockaddr();
+    }
+
+    constexpr std::size_t sockaddrLen() const noexcept
+    {
+        return sizeof(sockaddr_un{}.sun_family) + len_ +
+               (len_ > 0 && buf_[0] != '@' ? 1 : 0);
+    }
+
+    constexpr SockAddrBuf buf() const noexcept
+    {
+        SockAddrBuf ret;
+        fill(reinterpret_cast<sockaddr_un&>(ret));
+        ret.len = sockaddrLen();
+        return ret;
+    }
+    constexpr operator SockAddrBuf() const noexcept
+    {
+        return buf();
+    }
+
+  private:
+    std::array<char, maxLen> buf_ = {};
+    std::uint8_t len_;
+    static_assert(maxLen <= std::numeric_limits<decltype(len_)>::max());
+
+    constexpr void fill(sockaddr_un& v) const noexcept
+    {
+        v.sun_family = AF_UNIX;
+        bool abstract = buf_[0] == '@';
+        v.sun_path[0] = abstract ? '\0' : buf_[0];
+        std::copy(buf_.begin() + 1, buf_.begin() + len_, v.sun_path + 1);
+        if (abstract)
+        {
+            v.sun_path[len_] = '\0';
+        }
+    };
+};
+
+template <>
+struct IsSockAddr<SockUAddr> : std::true_type
+{};
+
 namespace detail
 {
 
-using SockAnyAddrV = std::variant<Sock4Addr, Sock6Addr>;
+using SockAnyAddrV = std::variant<Sock4Addr, Sock6Addr, SockUAddr>;
 
 } // namespace detail
 
diff --git a/test/net/addr/sock.cpp b/test/net/addr/sock.cpp
index 4aee5c5..372092e 100644
--- a/test/net/addr/sock.cpp
+++ b/test/net/addr/sock.cpp
@@ -1,7 +1,11 @@
 #include <stdplus/net/addr/sock.hpp>
 
+#include <string_view>
+
 #include <gtest/gtest.h>
 
+using std::literals::string_view_literals::operator""sv;
+
 namespace stdplus
 {
 
@@ -41,14 +45,62 @@
     EXPECT_EQ(sizeof(sockaddr_in6), addr1.sockaddrLen());
 }
 
+TEST(SockUAddr, Basic)
+{
+    // Non-abstract Requires null-terminator
+    EXPECT_THROW(SockUAddr(std::string(SockUAddr::maxLen, 'a')),
+                 std::invalid_argument);
+    EXPECT_NO_THROW(SockUAddr(std::string(SockUAddr::maxLen - 1, 'a')));
+
+    // Abstract can use the full space
+    EXPECT_THROW(SockUAddr(std::string(SockUAddr::maxLen + 1, '\0')),
+                 std::invalid_argument);
+    EXPECT_NO_THROW(SockUAddr(std::string(SockUAddr::maxLen, '\0')));
+
+    EXPECT_THROW(SockUAddr("hi\0o"sv), std::invalid_argument);
+
+    constexpr SockUAddr addr1{"@hi"sv};
+    constexpr SockUAddr addr2{"\0hi"sv};
+    constexpr SockUAddr addr3{"/nope"sv};
+    constexpr SockUAddr addr4{""sv};
+
+    EXPECT_EQ(addr1, addr1);
+    EXPECT_EQ(addr1, addr2);
+    EXPECT_NE(addr3, addr1);
+    EXPECT_NE(addr4, addr1);
+    EXPECT_NE(addr4, addr3);
+
+    EXPECT_EQ(addr1.path(), "@hi"sv);
+    EXPECT_EQ(addr2.path(), "@hi"sv);
+    EXPECT_EQ(addr3.path(), "/nope"sv);
+    EXPECT_EQ(addr4.path(), ""sv);
+
+    auto addr = addr1.sockaddr();
+    EXPECT_EQ(AF_UNIX, addr.sun_family);
+    EXPECT_EQ("\0hi"sv, std::string_view(addr.sun_path, 3));
+    auto buf = addr2.buf();
+    auto ptr = reinterpret_cast<std::uint8_t*>(&buf);
+    EXPECT_TRUE(
+        std::equal(ptr, ptr + buf.len, reinterpret_cast<std::uint8_t*>(&addr)));
+    addr = addr3;
+    EXPECT_EQ("/nope\0"sv, std::string_view(addr.sun_path, 6));
+    EXPECT_EQ(addr1.sockaddrLen(), sizeof(addr.sun_family) + 3);
+    EXPECT_EQ(addr2.sockaddrLen(), sizeof(addr.sun_family) + 3);
+    EXPECT_EQ(addr3.sockaddrLen(), sizeof(addr.sun_family) + 6);
+    EXPECT_EQ(addr4.sockaddrLen(), sizeof(addr.sun_family));
+}
+
 TEST(SockAnyAddr, Basic)
 {
     constexpr SockAnyAddr addr1(std::in_place_type<Sock4Addr>, In4Addr{255},
                                 3959);
+    constexpr SockAnyAddr addr2(std::in_place_type<SockUAddr>, "/hi"sv);
+    EXPECT_NE(addr1, addr2);
     EXPECT_EQ(addr1, addr1);
     auto buf = addr1.buf();
     EXPECT_EQ(buf.len, sizeof(sockaddr_in));
     EXPECT_EQ(addr1.sockaddrLen(), sizeof(sockaddr_in));
+    EXPECT_EQ(addr2.sockaddrLen(), sizeof(sa_family_t) + 4);
 }
 
 } // namespace stdplus