diff --git a/include/sparrow/builder/builder.hpp b/include/sparrow/builder/builder.hpp
index 7a881a11..442b600e 100644
--- a/include/sparrow/builder/builder.hpp
+++ b/include/sparrow/builder/builder.hpp
@@ -29,6 +29,7 @@
 #include <sparrow/builder/nested_eq.hpp>
 #include <sparrow/builder/nested_less.hpp>
 #include <sparrow/layout/dictionary_encoded_array.hpp>
+#include <sparrow/layout/fixed_width_binary_array.hpp>
 #include <sparrow/layout/list_layout/list_array.hpp>
 #include <sparrow/layout/primitive_array.hpp>
 #include <sparrow/layout/struct_layout/struct_array.hpp>
@@ -132,20 +133,32 @@ namespace sparrow
         concept translate_to_struct_layout = std::ranges::input_range<T> && tuple_like<ensured_range_value_t<T>>
                                              && !all_elements_same<ensured_range_value_t<T>>;
 
+        template <class T>
+        concept fixed_width_binary_types = (mpl::fixed_size_span<T> || mpl::std_array<T>)
+                                           && std::is_same_v<std::ranges::range_value_t<T>, byte_t>;
+
         template <class T>
         concept translate_to_fixed_sized_list_layout = std::ranges::input_range<T>
                                                        && tuple_like<ensured_range_value_t<T>>
+                                                       && !((mpl::fixed_size_span<ensured_range_value_t<T>> || mpl::std_array<ensured_range_value_t<T>>) && fixed_width_binary_types<ensured_range_value_t<T>>)
                                                        && all_elements_same<ensured_range_value_t<T>>;
 
         template <class T>
         concept translate_to_variable_sized_binary_layout = std::ranges::input_range<T>
                                                             && std::ranges::input_range<ensured_range_value_t<T>>
+                                                            && !((mpl::fixed_size_span<ensured_range_value_t<T>> || mpl::std_array<ensured_range_value_t<T>>) && fixed_width_binary_types<ensured_range_value_t<T>>)
                                                             && !tuple_like<ensured_range_value_t<T>>
                                                             &&  // tuples go to struct layout
                                                             // value type of inner must be char like ( char,
                                                             // byte, uint8)
                                                             mpl::char_like<nested_ensured_range_inner_value_t<T>>;
 
+        template <class T>
+        concept translate_to_fixed_width_binary_layout = std::ranges::input_range<T>
+                                                         && ((mpl::fixed_size_span<ensured_range_value_t<T>>
+                                                              || mpl::std_array<ensured_range_value_t<T>>)
+                                                             && fixed_width_binary_types<ensured_range_value_t<T>>);
+
         template <class T>
         concept translate_to_union_layout = std::ranges::input_range<T> &&
                                             // value type must be a variant-like type
@@ -282,6 +295,18 @@ namespace sparrow
             }
         };
 
+        template <translate_to_fixed_width_binary_layout T, class OPTION_FLAGS>
+        struct builder<T, dont_enforce_layout, OPTION_FLAGS>
+        {
+            using type = sparrow::fixed_width_binary_array;
+
+            template <class U>
+            static type create(U&& t)
+            {
+                return type(std::move(t));
+            }
+        };
+
         template <translate_to_union_layout T, class OPTION_FLAGS>
         struct builder<T, dont_enforce_layout, OPTION_FLAGS>
         {
diff --git a/include/sparrow/layout/array_wrapper.hpp b/include/sparrow/layout/array_wrapper.hpp
index d3f8e377..52bb9d7e 100644
--- a/include/sparrow/layout/array_wrapper.hpp
+++ b/include/sparrow/layout/array_wrapper.hpp
@@ -178,7 +178,7 @@ namespace sparrow
 
     template <class T>
     array_wrapper_impl<T>::array_wrapper_impl(T&& ar)
-        : array_wrapper(this->get_data_type())
+        : array_wrapper(detail::array_access::get_arrow_proxy(ar).data_type())
         , m_storage(value_ptr<T>(std::move(ar)))
         , p_array(std::get<value_ptr<T>>(m_storage).get())
     {
@@ -186,7 +186,7 @@ namespace sparrow
 
     template <class T>
     array_wrapper_impl<T>::array_wrapper_impl(T* ar)
-        : array_wrapper(this->get_data_type())
+        : array_wrapper(detail::array_access::get_arrow_proxy(*ar).data_type())
         , m_storage(ar)
         , p_array(ar)
     {
@@ -194,7 +194,7 @@ namespace sparrow
 
     template <class T>
     array_wrapper_impl<T>::array_wrapper_impl(std::shared_ptr<T> ar)
-        : array_wrapper(this->get_data_type())
+        : array_wrapper(detail::array_access::get_arrow_proxy(*ar).data_type())
         , m_storage(std::move(ar))
         , p_array(std::get<std::shared_ptr<T>>(m_storage).get())
     {
diff --git a/include/sparrow/layout/dispatch.hpp b/include/sparrow/layout/dispatch.hpp
index 55f79f38..1b3f9b95 100644
--- a/include/sparrow/layout/dispatch.hpp
+++ b/include/sparrow/layout/dispatch.hpp
@@ -19,6 +19,7 @@
 #include "sparrow/layout/array_wrapper.hpp"
 #include "sparrow/layout/decimal_array.hpp"
 #include "sparrow/layout/dictionary_encoded_array.hpp"
+#include "sparrow/layout/fixed_width_binary_array.hpp"
 #include "sparrow/layout/list_layout/list_array.hpp"
 #include "sparrow/layout/nested_value_types.hpp"
 #include "sparrow/layout/null_array.hpp"
@@ -125,6 +126,8 @@ namespace sparrow
                     return func(unwrap_array<decimal_128_array>(ar));
                 case data_type::DECIMAL256:
                     return func(unwrap_array<decimal_256_array>(ar));
+                case data_type::FIXED_WIDTH_BINARY:
+                    return func(unwrap_array<fixed_width_binary_array>(ar));
                 default:
                     throw std::invalid_argument("array type not supported");
             }
diff --git a/include/sparrow/layout/fixed_width_binary_layout/fixed_width_binary_array.hpp b/include/sparrow/layout/fixed_width_binary_layout/fixed_width_binary_array.hpp
index f6bf490c..de4d6059 100644
--- a/include/sparrow/layout/fixed_width_binary_layout/fixed_width_binary_array.hpp
+++ b/include/sparrow/layout/fixed_width_binary_layout/fixed_width_binary_array.hpp
@@ -36,20 +36,14 @@
 
 namespace sparrow
 {
-    namespace detail
-    {
-        template <class T, class OT>
-        struct variable_size_binary_format;
-    }
-
     template <std::ranges::sized_range T, class CR>
     class fixed_width_binary_array_impl;
 
-    using fixed_binary_traits = arrow_traits<std::vector<byte_t>>;
+    using fixed_width_binary_traits = arrow_traits<std::vector<byte_t>>;
 
     using fixed_width_binary_array = fixed_width_binary_array_impl<
-        fixed_binary_traits::value_type,
-        fixed_binary_traits::const_reference>;
+        fixed_width_binary_traits::value_type,
+        fixed_width_binary_traits::const_reference>;
 
     template <std::ranges::sized_range T, class CR>
     struct array_inner_types<fixed_width_binary_array_impl<T, CR>> : array_inner_types_base
diff --git a/test/test_builder.cpp b/test/test_builder.cpp
index fc7f5aab..9a9c8a4a 100644
--- a/test/test_builder.cpp
+++ b/test/test_builder.cpp
@@ -199,6 +199,40 @@ namespace sparrow
             }
         }
 
+        TEST_CASE("fixed-width-binary")
+        {
+            // fixed_width_binary
+            {
+                std::vector<std::array<byte_t, 3>> v{
+                    {byte_t(1), byte_t(2), byte_t(3)},
+                    {byte_t(4), byte_t(5), byte_t(6)},
+                    {byte_t(7), byte_t(8), byte_t(9)}
+                };
+                auto arr = sparrow::build(v);
+                [[maybe_unused]] const auto lol = arr.get_arrow_proxy().format();
+                [[maybe_unused]] const auto lol2 = arr.get_arrow_proxy().data_type();
+                test::generic_consistency_test(arr);
+                REQUIRE_EQ(arr.size(), 3);
+                using arr_type = std::decay_t<decltype(arr)>;
+                static_assert(std::is_same_v<arr_type, sparrow::fixed_width_binary_array>);
+            }
+            // fixed_width_binary with nulls
+            {
+                std::vector<nt<std::array<byte_t, 3>>> v{
+                    std::array<byte_t, 3>{byte_t(1), byte_t(2), byte_t(3)},
+                    sparrow::nullval,
+                    std::array<byte_t, 3>{byte_t(7), byte_t(8), byte_t(9)}
+                };
+                auto arr = sparrow::build(v);
+                [[maybe_unused]] const auto lol = arr.get_arrow_proxy().format();
+                [[maybe_unused]] const auto lol2 = arr.get_arrow_proxy().data_type();
+                test::generic_consistency_test(arr);
+                REQUIRE_EQ(arr.size(), 3);
+                using arr_type = std::decay_t<decltype(arr)>;
+                static_assert(std::is_same_v<arr_type, sparrow::fixed_width_binary_array>);
+            }
+        }
+
         TEST_CASE("sparse-union")
         {
             SUBCASE("simple")