diff --git a/README.md b/README.md
index 3e9c9f9..465b59c 100644
--- a/README.md
+++ b/README.md
@@ -208,6 +208,39 @@ auto [data, in] = zpp::bits::data_in();
 auto [data, out] = zpp::bits::data_out();
 ```
 
+
+* If your object and its subobjects recursively can just be byte copied, i.e don't have references or pointers or non
+trivially copyable subobjects (more accurately, your object fits into the bit cast constexpr requirements), then you don't need to specify the number of members and
+serializing your object becomes a `memcpy` operation. Unless of course you define an explicit serialization function in which
+case the members are serialized one by one separately.
+```cpp
+struct point
+{
+    int x;
+    int y;
+};
+
+auto [data, out] = zpp::bits::data_out();
+out(point{1337, 1338});
+```
+The above is serializable/deserializable without any modification by using a `memcpy` operation.
+This has the advantage of better performance most of the times, but the disadvantage is that the format becomes less portable
+due to potential padding bytes.
+
+To avoid this behavior and serialize members one by one you can either define the explicit serialization function or
+use `zpp::bits::explicit_members` and provide the number of members:
+```cpp
+struct requires_padding
+{
+    using serialize = zpp::bits::explicit_members<2>;
+
+    std::byte x;
+    int y;
+};
+```
+If you are using automatic member detection as per `ZPP_BITS_AUTODETECT_MEMBERS_MODE=1`, you may leave the
+angle brackets empty as in `zpp::bits::explicit_members<>`.
+
 * Archives can be constructed from either one of the byte types:
 ```cpp
 // Either one of these work with the below.
diff --git a/test/src/test_byte_serializable.cpp b/test/src/test_byte_serializable.cpp
new file mode 100644
index 0000000..88c2cb9
--- /dev/null
+++ b/test/src/test_byte_serializable.cpp
@@ -0,0 +1,201 @@
+#include "test.h"
+#include <compare>
+
+namespace test_byte_serializable
+{
+
+struct integers
+{
+    int x;
+    int y;
+};
+
+struct explicit_integers
+{
+    using serialize = zpp::bits::explicit_members<2>;
+    int x;
+    int y;
+};
+
+struct explicit_integers_auto
+{
+    using serialize = zpp::bits::explicit_members<>;
+    int x;
+    int y;
+};
+
+struct ref
+{
+    int & x;
+    int y;
+};
+
+struct pointer
+{
+    int * x;
+    int y;
+};
+
+struct array
+{
+    int x[5];
+    int y;
+};
+
+struct stdarray
+{
+    std::array<int, 5> x;
+    int y;
+};
+
+struct stdarray_array
+{
+    std::array<int, 5> x[5];
+    int y;
+};
+
+struct vector
+{
+    std::vector<char> x;
+    int y;
+};
+
+static_assert(zpp::bits::concepts::byte_serializable<integers>);
+static_assert(!zpp::bits::concepts::byte_serializable<explicit_integers>);
+static_assert(
+    !zpp::bits::concepts::byte_serializable<explicit_integers_auto>);
+static_assert(!zpp::bits::concepts::byte_serializable<ref>);
+static_assert(!zpp::bits::concepts::byte_serializable<pointer>);
+static_assert(zpp::bits::concepts::byte_serializable<array>);
+static_assert(zpp::bits::concepts::byte_serializable<stdarray>);
+static_assert(zpp::bits::concepts::byte_serializable<stdarray_array>);
+static_assert(!zpp::bits::concepts::byte_serializable<vector>);
+static_assert(!zpp::bits::concepts::byte_serializable<std::vector<char>>);
+static_assert(!zpp::bits::concepts::byte_serializable<std::string>);
+static_assert(!zpp::bits::concepts::byte_serializable<std::string_view>);
+static_assert(!zpp::bits::concepts::byte_serializable<std::span<char>>);
+static_assert(zpp::bits::concepts::byte_serializable<std::array<char, 2>>);
+
+class inaccessible
+{
+public:
+    inaccessible() = default;
+    inaccessible(int x, int y) : x(x), y(y)
+    {
+    }
+
+    std::strong_ordering operator<=>(const inaccessible & other) const =
+        default;
+
+public:
+    int x{};
+    int y{};
+};
+
+TEST(byte_serializable, inaccessible)
+{
+    static_assert(zpp::bits::concepts::byte_serializable<inaccessible>);
+
+    auto [data, in, out] = zpp::bits::data_in_out();
+    out(inaccessible{1337, 1338}).or_throw();
+
+    inaccessible s;
+    in(s).or_throw();
+
+    EXPECT_EQ(s, (inaccessible{1337, 1338}));
+}
+
+struct requires_padding
+{
+    std::byte b{};
+    std::int32_t i32{};
+};
+
+TEST(byte_serializable, requires_padding)
+{
+    static_assert(
+        zpp::bits::concepts::byte_serializable<requires_padding>);
+    static_assert(sizeof(requires_padding) > 5);
+
+    auto [data, in, out] = zpp::bits::data_in_out();
+    out(requires_padding{std::byte{0x25}, 0x1337}).or_throw();
+
+    EXPECT_EQ(data.size(), sizeof(requires_padding));
+    EXPECT_NE(hexlify(data),
+              "25"
+              "37130000");
+
+    requires_padding s;
+    in(s).or_throw();
+    EXPECT_EQ(in.position(), sizeof(requires_padding));
+    EXPECT_EQ(s.b, std::byte{0x25});
+    EXPECT_EQ(s.i32, 0x1337);
+}
+
+struct explicit_requires_padding
+{
+    using serialize = zpp::bits::explicit_members<2>;
+    std::byte b{};
+    std::int32_t i32{};
+};
+
+TEST(byte_serializable, explicit_requires_padding)
+{
+    static_assert(!zpp::bits::concepts::byte_serializable<
+                  explicit_requires_padding>);
+    static_assert(sizeof(requires_padding) ==
+                  sizeof(explicit_requires_padding));
+    static_assert(sizeof(explicit_requires_padding) > 5);
+
+    auto [data, in, out] = zpp::bits::data_in_out();
+    out(explicit_requires_padding{std::byte{0x25}, 0x1337}).or_throw();
+
+    EXPECT_EQ(data.size(), std::size_t{5});
+    EXPECT_EQ(hexlify(data),
+              "25"
+              "37130000");
+
+    explicit_requires_padding s;
+    in(s).or_throw();
+    EXPECT_EQ(in.position(), std::size_t{5});
+    EXPECT_EQ(s.b, std::byte{0x25});
+    EXPECT_EQ(s.i32, 0x1337);
+}
+
+#if ZPP_BITS_AUTODETECT_MEMBERS_MODE > 0
+struct explicit_requires_padding_auto
+{
+    using serialize = zpp::bits::explicit_members<>;
+    std::byte b{};
+    std::int32_t i32{};
+};
+
+static_assert(sizeof(requires_padding) ==
+              sizeof(explicit_requires_padding_auto));
+
+TEST(byte_serializable, explicit_requires_padding_auto)
+{
+    static_assert(!zpp::bits::concepts::byte_serializable<
+                  explicit_requires_padding_auto>);
+    static_assert(sizeof(requires_padding) ==
+                  sizeof(explicit_requires_padding_auto));
+    static_assert(sizeof(explicit_requires_padding_auto) > 5);
+
+    auto [data, in, out] = zpp::bits::data_in_out();
+    out(explicit_requires_padding_auto{std::byte{0x25}, 0x1337})
+        .or_throw();
+
+    EXPECT_EQ(data.size(), std::size_t{5});
+    EXPECT_EQ(hexlify(data),
+              "25"
+              "37130000");
+
+    explicit_requires_padding_auto s;
+    in(s).or_throw();
+    EXPECT_EQ(in.position(), std::size_t{5});
+    EXPECT_EQ(s.b, std::byte{0x25});
+    EXPECT_EQ(s.i32, 0x1337);
+}
+#endif
+
+} // namespace test_byte_serializable
diff --git a/zpp_bits.h b/zpp_bits.h
index 82e119f..7f511ce 100644
--- a/zpp_bits.h
+++ b/zpp_bits.h
@@ -12,6 +12,7 @@
 #include <cstddef>
 #include <cstring>
 #include <iterator>
+#include <limits>
 #include <memory>
 #include <optional>
 #include <span>
@@ -49,6 +50,18 @@ constexpr ToType bit_cast(FromType const & from) noexcept
 } // namespace std
 #endif
 
+template <std::size_t Count>
+struct members
+{
+    constexpr static std::size_t value = Count;
+};
+
+template <std::size_t Count = std::numeric_limits<std::size_t>::max()>
+struct explicit_members
+{
+    constexpr static std::size_t value = Count;
+};
+
 namespace concepts
 {
 namespace detail
@@ -141,6 +154,23 @@ concept unspecialized =
     !container<Type> && !owning_pointer<Type> && !tuple<Type> &&
     !variant<Type> && !optional<Type> &&
     !std::is_array_v<std::remove_cvref_t<Type>>;
+
+template <typename Type>
+concept byte_serializable = requires
+{
+    requires std::is_trivially_copyable_v<std::remove_cvref_t<Type>>;
+    requires std::integral_constant<
+        int,
+        (std::bit_cast<std::remove_cvref_t<Type>>(
+             std::array<std::byte, sizeof(Type)>()),
+         0)>::value
+    == 0;
+}
+&&(!requires {
+    requires std::same_as<
+        explicit_members<std::remove_cvref_t<Type>::serialize::value>,
+        typename std::remove_cvref_t<Type>::serialize>;
+});
 } // namespace concepts
 
 template <typename Item>
@@ -333,12 +363,6 @@ constexpr auto failure(errc code)
     return std::errc{} != code;
 }
 
-template <std::size_t Count>
-struct members
-{
-    constexpr static std::size_t value = Count;
-};
-
 struct access
 {
     template <typename Item>
@@ -404,15 +428,10 @@ struct access
     {
         return visit_members<Size>(
             item, [&](auto &&... items) constexpr {
-                if constexpr (std::is_trivially_copyable_v<
-                                  std::remove_cvref_t<decltype(item)>>) {
+                if constexpr (concepts::byte_serializable<decltype(item)>) {
                     if constexpr (sizeof...(items) > 1 &&
-                                  (... &&
-                                   (std::is_fundamental_v<
-                                        std::remove_cvref_t<
-                                            decltype(items)>> ||
-                                    std::is_enum_v<std::remove_cvref_t<
-                                        decltype(items)>>))) {
+                                  (... && concepts::byte_serializable<
+                                              decltype(items)>)) {
                         return serializer.serialize_one(as_bytes(item));
                     } else {
                         return serializer.serialize_many(items...);
@@ -423,23 +442,34 @@ struct access
             });
     }
 
-    constexpr static auto serialize_members(
-        auto &serializer, auto &item) requires std::is_same_v <
-        members<std::remove_cvref_t<decltype(item)>::serialize::value>,
-    typename std::remove_cvref_t<decltype(item)>::serialize >
-        &&(std::remove_cvref_t<decltype(item)>::serialize::value <=
-           max_members_serialize)
+    constexpr static auto
+        serialize_members(auto & serializer, auto & item) requires(
+            std::is_same_v<
+                members<
+                    std::remove_cvref_t<decltype(item)>::serialize::value>,
+                typename std::remove_cvref_t<decltype(item)>::serialize> ||
+            std::is_same_v<explicit_members<std::remove_cvref_t<
+                               decltype(item)>::serialize::value>,
+                           typename std::remove_cvref_t<
+                               decltype(item)>::serialize>) &&
+        (std::remove_cvref_t<decltype(item)>::serialize::value <=
+         max_members_serialize)
     {
         return serialize_members<
             std::remove_cvref_t<decltype(item)>::serialize::value>(
             serializer, item);
     }
 
-    constexpr static auto serialize_members(auto & serializer,
-                                            auto & item) requires
-        std::is_same_v<
-            members<std::remove_cvref_t<decltype(serialize(item))>::value>,
-            std::remove_cvref_t<decltype(serialize(item))>> &&
+    constexpr static auto
+        serialize_members(auto & serializer, auto & item) requires(
+            std::is_same_v<
+                members<
+                    std::remove_cvref_t<decltype(serialize(item))>::value>,
+                std::remove_cvref_t<decltype(serialize(item))>> ||
+            std::is_same_v<
+                explicit_members<
+                    std::remove_cvref_t<decltype(serialize(item))>::value>,
+                std::remove_cvref_t<decltype(serialize(item))>>) &&
         (std::remove_cvref_t<decltype(serialize(item))>::value <=
          max_members_serialize)
     {
@@ -450,11 +480,26 @@ struct access
 
     constexpr static auto
     serialize_members(auto & serializer, auto & item) requires(
-            (number_of_members<std::remove_cvref_t<decltype(item)>>() >= 0) &&
-            !requires { typename std::remove_cvref_t<decltype(item)>::serialize; } &&
-            !requires { std::remove_cvref_t<decltype(item)>::serialize(serializer, item); } &&
-            !requires { serialize(item); } && !requires { serialize(serializer, item); })
-
+        (number_of_members<std::remove_cvref_t<decltype(item)>>() >= 0) &&
+        (
+            !requires {
+                typename std::remove_cvref_t<decltype(item)>::serialize;
+            } ||
+            requires {
+                requires std::same_as <
+                    explicit_members<std::remove_cvref_t<
+                        decltype(item)>::serialize::value>,
+                typename std::remove_cvref_t<decltype(item)>::serialize > ;
+                requires std::remove_cvref_t<
+                    decltype(item)>::serialize::value ==
+                    std::numeric_limits<std::size_t>::max();
+            }) &&
+        !requires {
+            std::remove_cvref_t<decltype(item)>::serialize(serializer,
+                                                           item);
+        } &&
+        !requires { serialize(item); } &&
+        !requires { serialize(serializer, item); })
     {
         return serialize_members<
             number_of_members<std::remove_cvref_t<decltype(item)>>()>(
@@ -475,6 +520,9 @@ class basic_out
     template <typename>
     friend struct option;
 
+    template <typename... Types>
+    using template_type = basic_out<Types...>;
+
     friend access;
 
     template <typename, concepts::container>
@@ -564,7 +612,11 @@ class basic_out
         using type = std::remove_cvref_t<decltype(item)>;
         static_assert(!std::is_pointer_v<type>);
 
-        if constexpr (std::is_fundamental_v<type> || std::is_enum_v<type>) {
+        if constexpr (requires { type::serialize(*this, item); }) {
+            return type::serialize(*this, item);
+        } else if constexpr (requires { serialize(*this, item); }) {
+            return serialize(*this, item);
+        } else if constexpr (std::is_fundamental_v<type> || std::is_enum_v<type>) {
             auto size = m_data.size();
             if (m_position + sizeof(item) > size) [[unlikely]] {
                 if constexpr (is_resizable) {
@@ -622,10 +674,8 @@ class basic_out
             }
             m_position += item_size_in_bytes;
             return {};
-        } else if constexpr (requires { type::serialize(*this, item); }) {
-            return type::serialize(*this, item);
-        } else if constexpr (requires { serialize(*this, item); }) {
-            return serialize(*this, item);
+        } else if constexpr (concepts::byte_serializable<type>) {
+            return serialize_one(as_bytes(item));
         } else {
             return access::serialize_members(*this, item);
         }
@@ -636,8 +686,7 @@ class basic_out
     {
         using value_type = std::remove_cvref_t<decltype(array[0])>;
 
-        if constexpr (std::is_fundamental_v<value_type> ||
-                       std::is_enum_v<value_type>) {
+        if constexpr (concepts::byte_serializable<value_type>) {
             return serialize_one(bytes(array));
         } else {
             for (auto & item : array) {
@@ -673,12 +722,11 @@ class basic_out
             }
         }
 
-        if constexpr ((std::is_fundamental_v<value_type> ||
-                       std::is_enum_v<value_type>)&&std::
-                          is_base_of_v<std::random_access_iterator_tag,
-                                       typename std::iterator_traits<
-                                           typename type::iterator>::
-                                           iterator_category> &&
+        if constexpr (concepts::byte_serializable<value_type> &&
+                      std::is_base_of_v<std::random_access_iterator_tag,
+                                        typename std::iterator_traits<
+                                            typename type::iterator>::
+                                            iterator_category> &&
                       requires { container.data(); }) {
             return serialize_one(bytes(container));
         } else {
@@ -760,6 +808,9 @@ template <concepts::byte_view ByteView>
 class out : public basic_out<ByteView>
 {
 public:
+    template <typename... Types>
+    using template_type = out<Types...>;
+
     using basic_out<ByteView>::basic_out;
 
     constexpr auto operator()(auto &&... items)
@@ -793,6 +844,9 @@ template <concepts::byte_view ByteView>
 class in
 {
 public:
+    template <typename... Types>
+    using template_type = in<Types...>;
+
     template <typename>
     friend struct option;
 
@@ -868,7 +922,11 @@ class in
         using type = std::remove_cvref_t<decltype(item)>;
         static_assert(!std::is_pointer_v<type>);
 
-        if constexpr (std::is_fundamental_v<type> || std::is_enum_v<type>) {
+        if constexpr (requires { type::serialize(*this, item); }) {
+            return type::serialize(*this, item);
+        } else if constexpr (requires { serialize(*this, item); }) {
+            return serialize(*this, item);
+        } else if constexpr (std::is_fundamental_v<type> || std::is_enum_v<type>) {
             auto size = m_data.size();
             if (m_position + sizeof(item) > size) [[unlikely]] {
                 return std::errc::result_out_of_range;
@@ -921,10 +979,8 @@ class in
             }
             m_position += item_size_in_bytes;
             return {};
-        } else if constexpr (requires { type::serialize(*this, item); }) {
-            return type::serialize(*this, item);
-        } else if constexpr (requires { serialize(*this, item); }) {
-            return serialize(*this, item);
+        } else if constexpr (concepts::byte_serializable<type>) {
+            return serialize_one(as_bytes(item));
         } else {
             return access::serialize_members(*this, item);
         }
@@ -935,8 +991,7 @@ class in
     {
         using value_type = std::remove_cvref_t<decltype(array[0])>;
 
-        if constexpr (std::is_fundamental_v<value_type> ||
-                       std::is_enum_v<value_type>) {
+        if constexpr (concepts::byte_serializable<value_type>) {
             return serialize_one(bytes(array));
         } else {
             for (auto & item : array) {
@@ -981,12 +1036,11 @@ class in
             }
         }
 
-        if constexpr ((std::is_fundamental_v<value_type> ||
-                       std::is_enum_v<value_type>)&&std::
-                          is_base_of_v<std::random_access_iterator_tag,
-                                       typename std::iterator_traits<
-                                           typename type::iterator>::
-                                           iterator_category> &&
+        if constexpr (concepts::byte_serializable<value_type> &&
+                      std::is_base_of_v<std::random_access_iterator_tag,
+                                        typename std::iterator_traits<
+                                            typename type::iterator>::
+                                            iterator_category> &&
                       requires { container.data(); }) {
             return serialize_one(bytes(container));
         } else {