diff --git a/include/msg/field.hpp b/include/msg/field.hpp
index d8c7011d..d67b6f6f 100644
--- a/include/msg/field.hpp
+++ b/include/msg/field.hpp
@@ -362,28 +362,30 @@ template <at... Ats> constexpr inline auto field_size = (0u + ... + Ats.size());
 
 template <typename T, T V = T{}> struct with_default {
     constexpr static auto default_value = V;
-    template <typename F> using default_matcher_t = msg::equal_to_t<F, V>;
     using is_mutable_t = void;
     template <T X> constexpr static auto is_compatible_value = true;
 };
 
 template <typename T, T V = T{}> struct with_const_default {
     constexpr static auto default_value = V;
-    template <typename F> using default_matcher_t = msg::equal_to_t<F, V>;
     template <T X> constexpr static auto is_compatible_value = X == V;
 };
 
 struct without_default {
-    template <typename F> using default_matcher_t = match::never_t;
     using is_mutable_t = void;
     template <auto X> constexpr static auto is_compatible_value = true;
 };
 
+struct uninitialized {
+    template <auto X> constexpr static auto is_compatible_value = true;
+};
+
 template <typename T>
 concept has_default_value = requires { T::default_value; };
 
 template <typename T>
-using has_default_value_t = std::bool_constant<has_default_value<T>>;
+using initializable_t = std::bool_constant<has_default_value<T> or
+                                           std::is_base_of_v<uninitialized, T>>;
 
 template <typename T>
 concept is_mutable_value = requires { typename T::is_mutable_t; };
@@ -489,6 +491,8 @@ class field_t : public field_spec_t<Name, T, detail::field_size<Ats...>>,
     using without_default =
         field_t<Name, T, detail::without_default, M, Ats...>;
 
+    using uninitialized = field_t<Name, T, detail::uninitialized, M, Ats...>;
+
     // ======================================================================
     // matcher values
     template <typename NewMatcher>
diff --git a/include/msg/message.hpp b/include/msg/message.hpp
index 5e59b757..a6c04360 100644
--- a/include/msg/message.hpp
+++ b/include/msg/message.hpp
@@ -497,7 +497,7 @@ struct message {
         constexpr owner_t() {
             using uninit_fields =
                 boost::mp11::mp_remove_if<boost::mp11::mp_list<Fields...>,
-                                          has_default_value_t>;
+                                          initializable_t>;
             static_assert(boost::mp11::mp_empty<uninit_fields>::value,
                           "All fields must be initialized or defaulted");
             this->set(Fields{}...);
@@ -507,7 +507,7 @@ struct message {
             using defaulted_fields = boost::mp11::mp_transform<
                 name_for,
                 boost::mp11::mp_copy_if<boost::mp11::mp_list<Fields...>,
-                                        has_default_value_t>>;
+                                        initializable_t>>;
             using initialized_fields =
                 boost::mp11::mp_transform<name_for,
                                           boost::mp11::mp_list<Vs...>>;
diff --git a/test/msg/message.cpp b/test/msg/message.cpp
index 35c2192c..929ba563 100644
--- a/test/msg/message.cpp
+++ b/test/msg/message.cpp
@@ -824,3 +824,19 @@ TEST_CASE("write indexing operator on message", "[message]") {
     CHECK((0xba11 == msg["f1"_field]));
 }
 #endif
+
+namespace {
+using bit_field1 =
+    field<"f1",
+          std::uint32_t>::located<at{0_dw, 0_msb, 0_lsb}>::with_required<1>;
+using all_fields =
+    field<"all", std::uint32_t>::located<at{0_dw, 31_msb, 0_lsb}>;
+
+using overlap_msg_defn = message<"msg", bit_field1, all_fields::uninitialized>;
+} // namespace
+
+TEST_CASE("message with uninitialized field", "[message]") {
+    owning<overlap_msg_defn> msg{};
+    auto data = msg.data();
+    CHECK(data[0] == 1);
+}