diff --git a/.clang-format b/.clang-format
index a75a2c2..e5530e6 100644
--- a/.clang-format
+++ b/.clang-format
@@ -104,7 +104,7 @@
 PenaltyBreakString: 1000
 PenaltyBreakTemplateDeclaration: 10
 PenaltyExcessCharacter: 1000000
-PenaltyReturnTypeOnItsOwnLine: 60
+PenaltyReturnTypeOnItsOwnLine: 150
 PenaltyIndentedWhitespace: 1
 PointerAlignment: Left
 QualifierAlignment: Left
diff --git a/include-fd/stdplus/fd/impl.hpp b/include-fd/stdplus/fd/impl.hpp
index e3991dc..10285a7 100644
--- a/include-fd/stdplus/fd/impl.hpp
+++ b/include-fd/stdplus/fd/impl.hpp
@@ -14,22 +14,22 @@
     std::span<std::byte> read(std::span<std::byte> buf) override;
     std::span<std::byte> recv(std::span<std::byte> buf,
                               RecvFlags flags) override;
-    std::tuple<std::span<std::byte>, std::span<std::byte>>
-        recvfrom(std::span<std::byte> buf, RecvFlags flags,
-                 std::span<std::byte> sockaddr) override;
+    std::tuple<std::span<std::byte>, std::span<std::byte>> recvfrom(
+        std::span<std::byte> buf, RecvFlags flags,
+        std::span<std::byte> sockaddr) override;
     std::span<const std::byte> write(std::span<const std::byte> data) override;
     std::span<const std::byte> send(std::span<const std::byte> data,
                                     SendFlags flags) override;
-    std::span<const std::byte>
-        sendto(std::span<const std::byte> data, SendFlags flags,
-               std::span<const std::byte> sockaddr) override;
+    std::span<const std::byte> sendto(
+        std::span<const std::byte> data, SendFlags flags,
+        std::span<const std::byte> sockaddr) override;
     size_t lseek(off_t offset, Whence whence) override;
     void truncate(off_t size) override;
     void bind(std::span<const std::byte> sockaddr) override;
     void connect(std::span<const std::byte> sockaddr) override;
     void listen(int backlog) override;
-    std::optional<std::tuple<int, std::span<std::byte>>>
-        accept(std::span<std::byte> sockaddr) override;
+    std::optional<std::tuple<int, std::span<std::byte>>> accept(
+        std::span<std::byte> sockaddr) override;
     void setsockopt(SockLevel level, SockOpt optname,
                     std::span<const std::byte> opt) override;
     int ioctl(unsigned long id, void* data) override;
diff --git a/include-fd/stdplus/fd/intf.hpp b/include-fd/stdplus/fd/intf.hpp
index b15cda6..2e10c73 100644
--- a/include-fd/stdplus/fd/intf.hpp
+++ b/include-fd/stdplus/fd/intf.hpp
@@ -121,23 +121,23 @@
     virtual std::span<std::byte> read(std::span<std::byte> buf) = 0;
     virtual std::span<std::byte> recv(std::span<std::byte> buf,
                                       RecvFlags flags) = 0;
-    virtual std::tuple<std::span<std::byte>, std::span<std::byte>>
-        recvfrom(std::span<std::byte> buf, RecvFlags flags,
-                 std::span<std::byte> sockaddr) = 0;
-    virtual std::span<const std::byte>
-        write(std::span<const std::byte> data) = 0;
+    virtual std::tuple<std::span<std::byte>, std::span<std::byte>> recvfrom(
+        std::span<std::byte> buf, RecvFlags flags,
+        std::span<std::byte> sockaddr) = 0;
+    virtual std::span<const std::byte> write(
+        std::span<const std::byte> data) = 0;
     virtual std::span<const std::byte> send(std::span<const std::byte> data,
                                             SendFlags flags) = 0;
-    virtual std::span<const std::byte>
-        sendto(std::span<const std::byte> data, SendFlags flags,
-               std::span<const std::byte> sockaddr) = 0;
+    virtual std::span<const std::byte> sendto(
+        std::span<const std::byte> data, SendFlags flags,
+        std::span<const std::byte> sockaddr) = 0;
     virtual size_t lseek(off_t offset, Whence whence) = 0;
     virtual void truncate(off_t size) = 0;
     virtual void bind(std::span<const std::byte> sockaddr) = 0;
     virtual void connect(std::span<const std::byte> sockaddr) = 0;
     virtual void listen(int backlog) = 0;
-    virtual std::optional<std::tuple<int, std::span<std::byte>>>
-        accept(std::span<std::byte> sockaddr) = 0;
+    virtual std::optional<std::tuple<int, std::span<std::byte>>> accept(
+        std::span<std::byte> sockaddr) = 0;
     virtual void setsockopt(SockLevel level, SockOpt optname,
                             std::span<const std::byte> opt) = 0;
     virtual int ioctl(unsigned long id, void* data) = 0;
@@ -148,9 +148,9 @@
     virtual FileFlags fcntlGetfl() const = 0;
 
   protected:
-    virtual std::span<std::byte>
-        mmap(std::byte* window, std::size_t size, ProtFlags prot,
-             MMapFlags flags, off_t offset) = 0;
+    virtual std::span<std::byte> mmap(std::byte* window, std::size_t size,
+                                      ProtFlags prot, MMapFlags flags,
+                                      off_t offset) = 0;
     virtual void munmap(std::span<std::byte> window) = 0;
     friend class MMap;
 };
diff --git a/include/stdplus/function_view.hpp b/include/stdplus/function_view.hpp
index 2247965..58a8333 100644
--- a/include/stdplus/function_view.hpp
+++ b/include/stdplus/function_view.hpp
@@ -130,8 +130,8 @@
     {}
 
     template <bool Nx2>
-    inline function_view&
-        operator=(const function_view<R(Args...) noexcept(Nx2)>& other) noexcept
+    inline function_view& operator=(
+        const function_view<R(Args...) noexcept(Nx2)>& other) noexcept
     {
         this->fun = other.fun;
         this->obj = other.obj;
diff --git a/include/stdplus/hash.hpp b/include/stdplus/hash.hpp
index cb93dcd..28b8fca 100644
--- a/include/stdplus/hash.hpp
+++ b/include/stdplus/hash.hpp
@@ -25,18 +25,18 @@
 }
 
 template <typename T>
-constexpr std::size_t
-    hashMultiS(std::size_t seed,
-               const T& t) noexcept(noexcept(hash<T>{}(std::declval<T>())))
+constexpr std::size_t hashMultiS(std::size_t seed, const T& t) noexcept(
+    noexcept(hash<T>{}(std::declval<T>())))
 {
     return updateSeed(seed, hash<T>{}(t));
 }
 
 template <typename T, typename... Ts>
-constexpr std::size_t
-    hashMultiS(std::size_t seed, const T& t, const Ts&... ts) noexcept(
-        (noexcept(hashMultiS(0, std::declval<T>())) && ... &&
-         noexcept(hashMultiS(0, std::declval<Ts>()))))
+constexpr std::size_t hashMultiS(
+    std::size_t seed, const T& t,
+    const Ts&... ts) noexcept((noexcept(hashMultiS(0, std::declval<T>())) &&
+                               ... &&
+                               noexcept(hashMultiS(0, std::declval<Ts>()))))
 {
     return hashMultiS(hashMultiS(seed, t), ts...);
 }
@@ -49,8 +49,8 @@
 }
 
 template <typename T>
-constexpr std::size_t
-    hashMulti(const T& t) noexcept(noexcept(hash<T>{}(std::declval<T>())))
+constexpr std::size_t hashMulti(const T& t) noexcept(
+    noexcept(hash<T>{}(std::declval<T>())))
 {
     return hash<T>{}(t);
 }
@@ -67,9 +67,9 @@
 {
 
 template <typename T>
-constexpr std::size_t
-    hashArr(std::size_t seed, const T* ts,
-            std::size_t n) noexcept(noexcept(hashMulti(std::declval<T>())))
+constexpr std::size_t hashArr(
+    std::size_t seed, const T* ts,
+    std::size_t n) noexcept(noexcept(hashMulti(std::declval<T>())))
 {
     if (n == 1)
     {
@@ -79,9 +79,8 @@
 }
 
 template <typename T>
-constexpr std::size_t
-    hashArr(const T* ts,
-            std::size_t n) noexcept(noexcept(hashMulti(std::declval<T>())))
+constexpr std::size_t hashArr(const T* ts, std::size_t n) noexcept(
+    noexcept(hashMulti(std::declval<T>())))
 {
     if (n == 0)
     {
diff --git a/include/stdplus/net/addr/subnet.hpp b/include/stdplus/net/addr/subnet.hpp
index b5e5731..3273ec7 100644
--- a/include/stdplus/net/addr/subnet.hpp
+++ b/include/stdplus/net/addr/subnet.hpp
@@ -15,8 +15,8 @@
 {
 
 // AddressSan doesn't understand our masking of shift UB
-__attribute__((no_sanitize("undefined"))) constexpr uint32_t
-    addr32Mask(std::ptrdiff_t pfx) noexcept
+__attribute__((no_sanitize("undefined"))) constexpr uint32_t addr32Mask(
+    std::ptrdiff_t pfx) noexcept
 {
     // NOLINTNEXTLINE(clang-analyzer-core.UndefinedBinaryOperatorResult)
     // NOLINTNEXTLINE(clang-analyzer-core.BitwiseShift)
diff --git a/include/stdplus/str/buf.hpp b/include/stdplus/str/buf.hpp
index 472dbb8..cd6e0eb 100644
--- a/include/stdplus/str/buf.hpp
+++ b/include/stdplus/str/buf.hpp
@@ -404,8 +404,8 @@
         return end();
     }
 
-    constexpr bool
-        operator==(std::basic_string_view<CharT> other) const noexcept
+    constexpr bool operator==(
+        std::basic_string_view<CharT> other) const noexcept
     {
         return std::basic_string_view<CharT>{*this} == other;
     }
diff --git a/include/stdplus/variant.hpp b/include/stdplus/variant.hpp
index 77c812d..add2bdb 100644
--- a/include/stdplus/variant.hpp
+++ b/include/stdplus/variant.hpp
@@ -93,15 +93,15 @@
 }
 
 template <typename... Vs>
-constexpr bool
-    variantEqFuzzy(const std::variant<Vs...>& vs, const auto& t) noexcept
+constexpr bool variantEqFuzzy(const std::variant<Vs...>& vs,
+                              const auto& t) noexcept
 {
     return variantEq<detail::VeqFuzzy>(vs, t);
 }
 
 template <typename... Vs>
-constexpr bool
-    variantEqStrict(const std::variant<Vs...>& vs, const auto& t) noexcept
+constexpr bool variantEqStrict(const std::variant<Vs...>& vs,
+                               const auto& t) noexcept
 {
     return variantEq<detail::VeqStrict>(vs, t);
 }
diff --git a/include/stdplus/zstring.hpp b/include/stdplus/zstring.hpp
index 101cd3b..3726cd8 100644
--- a/include/stdplus/zstring.hpp
+++ b/include/stdplus/zstring.hpp
@@ -38,8 +38,8 @@
 
 #ifndef NDEBUG
 template <typename CharT>
-constexpr std::size_t
-    zstring_validate(const CharT* str, std::size_t min, std::size_t max)
+constexpr std::size_t zstring_validate(const CharT* str, std::size_t min,
+                                       std::size_t max)
 {
     auto ret = zstring_find_term(str, min, max);
     if (ret < 0)
@@ -142,8 +142,8 @@
     {
         return data_ + size;
     }
-    constexpr basic_zstring<const CharT, Traits>
-        csuffix(size_type size) const noexcept
+    constexpr basic_zstring<const CharT, Traits> csuffix(
+        size_type size) const noexcept
     {
         return data_ + size;
     }
@@ -195,8 +195,8 @@
     }
 
     template <typename CharT1>
-    constexpr Traits::comparison_category
-        operator<=>(basic_zstring<CharT1, Traits> rhs) const noexcept
+    constexpr Traits::comparison_category operator<=>(
+        basic_zstring<CharT1, Traits> rhs) const noexcept
     {
         return compare(rhs.data()) <=> 0;
     }
@@ -211,8 +211,8 @@
     {
         return compare(rhs.data(), rhs.size()) <=> 0;
     }
-    constexpr Traits::comparison_category
-        operator<=>(std::basic_string_view<decay_t, Traits> rhs) const noexcept
+    constexpr Traits::comparison_category operator<=>(
+        std::basic_string_view<decay_t, Traits> rhs) const noexcept
     {
         return compare(rhs.data(), rhs.size()) <=> 0;
     }
@@ -227,9 +227,9 @@
 };
 
 template <typename CharT, typename Traits>
-std::basic_ostream<std::remove_const_t<CharT>, Traits>&
-    operator<<(std::basic_ostream<std::remove_const_t<CharT>, Traits>& os,
-               basic_zstring<CharT, Traits> v)
+std::basic_ostream<std::remove_const_t<CharT>, Traits>& operator<<(
+    std::basic_ostream<std::remove_const_t<CharT>, Traits>& os,
+    basic_zstring<CharT, Traits> v)
 {
     return os << v.c_str();
 }
diff --git a/include/stdplus/zstring_view.hpp b/include/stdplus/zstring_view.hpp
index 809c2a5..3cb2506 100644
--- a/include/stdplus/zstring_view.hpp
+++ b/include/stdplus/zstring_view.hpp
@@ -24,8 +24,8 @@
 {
 
 template <typename CharT, typename Traits>
-constexpr auto
-    unsafe_zstring_view(std::basic_string_view<CharT, Traits> sv) noexcept
+constexpr auto unsafe_zstring_view(
+    std::basic_string_view<CharT, Traits> sv) noexcept
 {
     using SV = basic_zstring_view<CharT, Traits>;
     return SV(typename SV::unsafe(), sv);
@@ -276,13 +276,13 @@
         return basic_zstring_view(unsafe(), sv.substr(pos));
     }
 
-    constexpr bool
-        operator==(std::basic_string_view<CharT, Traits> rhs) const noexcept
+    constexpr bool operator==(
+        std::basic_string_view<CharT, Traits> rhs) const noexcept
     {
         return size() == rhs.size() && compare(rhs) == 0;
     }
-    constexpr Traits::comparison_category
-        operator<=>(std::basic_string_view<CharT, Traits> rhs) const noexcept
+    constexpr Traits::comparison_category operator<=>(
+        std::basic_string_view<CharT, Traits> rhs) const noexcept
     {
         return compare(rhs) <=> 0;
     }
@@ -299,9 +299,8 @@
 };
 
 template <typename CharT, typename Traits>
-std::basic_ostream<CharT, Traits>&
-    operator<<(std::basic_ostream<CharT, Traits>& os,
-               basic_zstring_view<CharT, Traits> v)
+std::basic_ostream<CharT, Traits>& operator<<(
+    std::basic_ostream<CharT, Traits>& os, basic_zstring_view<CharT, Traits> v)
 {
     return os << static_cast<std::basic_string_view<CharT, Traits>>(v);
 }
diff --git a/src/fd/impl.cpp b/src/fd/impl.cpp
index 5f9fe7f..673c7fd 100644
--- a/src/fd/impl.cpp
+++ b/src/fd/impl.cpp
@@ -71,9 +71,9 @@
                        static_cast<int>(flags)));
 }
 
-std::span<const std::byte>
-    FdImpl::sendto(std::span<const std::byte> data, SendFlags flags,
-                   std::span<const std::byte> sockaddr)
+std::span<const std::byte> FdImpl::sendto(std::span<const std::byte> data,
+                                          SendFlags flags,
+                                          std::span<const std::byte> sockaddr)
 {
     return fret(
         data, "sendto",
@@ -130,8 +130,8 @@
     CHECK_ERRNO(::listen(get(), backlog), "listen");
 }
 
-std::optional<std::tuple<int, std::span<std::byte>>>
-    FdImpl::accept(std::span<std::byte> sockaddr)
+std::optional<std::tuple<int, std::span<std::byte>>> FdImpl::accept(
+    std::span<std::byte> sockaddr)
 {
     socklen_t len = sockaddr.size();
     auto fd = ::accept(
diff --git a/src/fd/ops.cpp b/src/fd/ops.cpp
index c069a5a..66d30a5 100644
--- a/src/fd/ops.cpp
+++ b/src/fd/ops.cpp
@@ -76,9 +76,9 @@
 }
 
 template <typename Fun, typename Byte, typename... Args>
-static std::span<Byte>
-    opAligned(const char* name, Fun&& fun, Fd& fd, size_t align,
-              std::span<Byte> data, Args&&... args)
+static std::span<Byte> opAligned(const char* name, Fun&& fun, Fd& fd,
+                                 size_t align, std::span<Byte> data,
+                                 Args&&... args)
 {
     std::size_t total = 0;
     try