diff --git a/include/sparrow/buffer/dynamic_bitset/dynamic_bitset.hpp b/include/sparrow/buffer/dynamic_bitset/dynamic_bitset.hpp
index 6f62b2d55..60e31b99e 100644
--- a/include/sparrow/buffer/dynamic_bitset/dynamic_bitset.hpp
+++ b/include/sparrow/buffer/dynamic_bitset/dynamic_bitset.hpp
@@ -150,7 +150,7 @@ namespace sparrow
          *          and contains properly formatted bit data.
          */
         template <allocator A = default_allocator>
-        constexpr dynamic_bitset(block_type* p, size_type n, const A& a = A());
+        constexpr dynamic_bitset(block_type* p, size_type n, size_type offset, const A& a = A());
 
         /**
          * @brief Constructs a bitset using existing memory with null count tracking.
@@ -168,7 +168,13 @@ namespace sparrow
          * @post null_count() == null_count
          */
         template <allocator A = default_allocator>
-        constexpr dynamic_bitset(block_type* p, size_type n, size_type null_count, const A& a = A());
+        constexpr dynamic_bitset(
+            block_type* p,
+            size_type n,
+            size_type offset,
+            size_type null_count,
+            const A& a = A()
+        );
 
         constexpr ~dynamic_bitset() = default;
         constexpr dynamic_bitset(const dynamic_bitset&) = default;
@@ -197,7 +203,7 @@ namespace sparrow
     template <class A>
         requires(not std::same_as<A, dynamic_bitset<T>> and allocator<A>)
     constexpr dynamic_bitset<T>::dynamic_bitset(const A& a)
-        : base_type(storage_type(a), 0u)
+        : base_type(storage_type(a), 0u, 0u)
     {
         base_type::zero_unused_bits();
     }
@@ -224,16 +230,17 @@ namespace sparrow
 
     template <std::integral T>
     template <allocator A>
-    constexpr dynamic_bitset<T>::dynamic_bitset(block_type* p, size_type n, const A& a)
-        : base_type(storage_type(p, p != nullptr ? this->compute_block_count(n) : 0, a), n)
+    constexpr dynamic_bitset<T>::dynamic_bitset(block_type* p, size_type n, size_type offset, const A& a)
+        : base_type(storage_type(p, p != nullptr ? this->compute_block_count(n) : 0, a), n, offset)
     {
         base_type::zero_unused_bits();
     }
 
     template <std::integral T>
     template <allocator A>
-    constexpr dynamic_bitset<T>::dynamic_bitset(block_type* p, size_type n, size_type null_count, const A& a)
-        : base_type(storage_type(p, this->compute_block_count(n), a), n, null_count)
+    constexpr dynamic_bitset<
+        T>::dynamic_bitset(block_type* p, size_type n, size_type offset, size_type null_count, const A& a)
+        : base_type(storage_type(p, this->compute_block_count(n), a), n, offset, null_count)
     {
         base_type::zero_unused_bits();
         SPARROW_ASSERT_TRUE(base_type::null_count() == base_type::size() - base_type::count_non_null());
diff --git a/include/sparrow/buffer/dynamic_bitset/dynamic_bitset_base.hpp b/include/sparrow/buffer/dynamic_bitset/dynamic_bitset_base.hpp
index 8c0c31f50..47c5f714a 100644
--- a/include/sparrow/buffer/dynamic_bitset/dynamic_bitset_base.hpp
+++ b/include/sparrow/buffer/dynamic_bitset/dynamic_bitset_base.hpp
@@ -334,27 +334,40 @@ namespace sparrow
             return std::move(m_buffer);
         }
 
+        /**
+         * @brief Returns the bit offset from the start of the buffer.
+         *
+         * This value indicates how many bits from the beginning of the underlying storage
+         * are skipped before the bitset's logical start. It is set during construction and
+         * remains constant for the lifetime of the bitset.
+         *
+         * @return The number of bits offset from the start of the buffer.
+         */
+        [[nodiscard]] size_t offset() const noexcept;
+
     protected:
 
         /**
          * @brief Constructs a bitset with the given storage and size.
          * @param buffer The storage buffer to use
          * @param size The number of bits in the bitset
+         * @param offset The number of bits to offset from the start of the buffer
          * @post size() == size
          * @post null_count() is computed by counting unset bits
          */
-        constexpr dynamic_bitset_base(storage_type buffer, size_type size);
+        constexpr dynamic_bitset_base(storage_type buffer, size_type size, size_type offset);
 
         /**
          * @brief Constructs a bitset with the given storage, size, and null count.
          * @param buffer The storage buffer to use
          * @param size The number of bits in the bitset
          * @param null_count The number of unset bits
+         * @param offset The number of bits to offset from the start of the buffer
          * @pre null_count <= size
          * @post size() == size
          * @post null_count() == null_count
          */
-        constexpr dynamic_bitset_base(storage_type buffer, size_type size, size_type null_count);
+        constexpr dynamic_bitset_base(storage_type buffer, size_type size, size_type offset, size_type null_count);
 
         constexpr ~dynamic_bitset_base() = default;
 
@@ -540,6 +553,7 @@ namespace sparrow
         storage_type m_buffer;   ///< The underlying storage for bit data
         size_type m_size;        ///< The number of bits in the bitset
         size_type m_null_count;  ///< The number of bits set to false
+        size_t m_offset = 0;     ///< The number of bits to offset from the start of the buffer
 
         friend class bitset_iterator<self_type, true>;   ///< Const iterator needs access to internals
         friend class bitset_iterator<self_type, false>;  ///< Mutable iterator needs access to internals
@@ -598,7 +612,8 @@ namespace sparrow
         {
             return true;
         }
-        return !m_null_count || buffer().data()[block_index(pos)] & bit_mask(pos);
+        const size_t pos_with_offset = pos + m_offset;
+        return !m_null_count || buffer().data()[block_index(pos_with_offset)] & bit_mask(pos_with_offset);
     }
 
     template <typename B>
@@ -627,15 +642,16 @@ namespace sparrow
                 }
             }
         }
-        block_type& block = buffer().data()[block_index(pos)];
-        const bool old_value = block & bit_mask(pos);
+        const size_t pos_with_offset = pos + m_offset;
+        block_type& block = buffer().data()[block_index(pos_with_offset)];
+        const bool old_value = block & bit_mask(pos_with_offset);
         if (value)
         {
-            block |= bit_mask(pos);
+            block |= bit_mask(pos_with_offset);
         }
         else
         {
-            block &= block_type(~bit_mask(pos));
+            block &= block_type(~bit_mask(pos_with_offset));
         }
         update_null_count(old_value, value);
     }
@@ -790,19 +806,26 @@ namespace sparrow
 
     template <typename B>
         requires std::ranges::random_access_range<std::remove_pointer_t<B>>
-    constexpr dynamic_bitset_base<B>::dynamic_bitset_base(storage_type buf, size_type size)
+    constexpr dynamic_bitset_base<B>::dynamic_bitset_base(storage_type buf, size_type size, size_type offset)
         : m_buffer(std::move(buf))
         , m_size(size)
         , m_null_count(m_size - count_non_null())
+        , m_offset(offset)
     {
     }
 
     template <typename B>
         requires std::ranges::random_access_range<std::remove_pointer_t<B>>
-    constexpr dynamic_bitset_base<B>::dynamic_bitset_base(storage_type buf, size_type size, size_type null_count)
+    constexpr dynamic_bitset_base<B>::dynamic_bitset_base(
+        storage_type buf,
+        size_type size,
+        size_type offset,
+        size_type null_count
+    )
         : m_buffer(std::move(buf))
         , m_size(size)
         , m_null_count(null_count)
+        , m_offset(offset)
     {
     }
 
@@ -914,7 +937,7 @@ namespace sparrow
             return;
         }
         size_type old_block_count = buffer().size();
-        const size_type new_block_count = compute_block_count(n);
+        const size_type new_block_count = compute_block_count(n + m_offset);
         const block_type value = b ? block_type(~block_type(0)) : block_type(0);
 
         if (new_block_count != old_block_count)
diff --git a/include/sparrow/buffer/dynamic_bitset/dynamic_bitset_view.hpp b/include/sparrow/buffer/dynamic_bitset/dynamic_bitset_view.hpp
index 9fd5768de..b0f7adc8c 100644
--- a/include/sparrow/buffer/dynamic_bitset/dynamic_bitset_view.hpp
+++ b/include/sparrow/buffer/dynamic_bitset/dynamic_bitset_view.hpp
@@ -101,7 +101,7 @@ namespace sparrow
          * assert(view.test(0) == true);  // First bit is set
          * @endcode
          */
-        constexpr dynamic_bitset_view(block_type* p, size_type n);
+        constexpr dynamic_bitset_view(block_type* p, size_type n, size_type offset);
 
         /**
          * @brief Constructs a bitset view from external memory with null count tracking.
@@ -141,7 +141,7 @@ namespace sparrow
          * assert(view.count_non_null() == 10);
          * @endcode
          */
-        constexpr dynamic_bitset_view(block_type* p, size_type n, size_type null_count);
+        constexpr dynamic_bitset_view(block_type* p, size_type n, size_type null_count, size_type offset);
 
         constexpr ~dynamic_bitset_view() = default;
 
@@ -153,14 +153,19 @@ namespace sparrow
     };
 
     template <std::integral T>
-    constexpr dynamic_bitset_view<T>::dynamic_bitset_view(block_type* p, size_type n)
-        : base_type(storage_type(p, p != nullptr ? this->compute_block_count(n) : 0), n)
+    constexpr dynamic_bitset_view<T>::dynamic_bitset_view(block_type* p, size_type n, size_type offset)
+        : base_type(storage_type(p, p != nullptr ? this->compute_block_count(n) : 0), n, offset)
     {
     }
 
     template <std::integral T>
-    constexpr dynamic_bitset_view<T>::dynamic_bitset_view(block_type* p, size_type n, size_type null_count)
-        : base_type(storage_type(p, p != nullptr ? this->compute_block_count(n) : 0), n, null_count)
+    constexpr dynamic_bitset_view<T>::dynamic_bitset_view(
+        block_type* p,
+        size_type n,
+        size_type null_count,
+        size_type offset
+    )
+        : base_type(storage_type(p, p != nullptr ? this->compute_block_count(n) : 0), n, null_count, offset)
     {
     }
 }
diff --git a/include/sparrow/buffer/dynamic_bitset/non_owning_dynamic_bitset.hpp b/include/sparrow/buffer/dynamic_bitset/non_owning_dynamic_bitset.hpp
index 37bf03eeb..2fdd34593 100644
--- a/include/sparrow/buffer/dynamic_bitset/non_owning_dynamic_bitset.hpp
+++ b/include/sparrow/buffer/dynamic_bitset/non_owning_dynamic_bitset.hpp
@@ -30,7 +30,7 @@ namespace sparrow
         using value_type = typename base_type::value_type;
         using size_type = typename base_type::size_type;
 
-        constexpr explicit non_owning_dynamic_bitset(buffer<T>* buffer, size_type n);
+        constexpr explicit non_owning_dynamic_bitset(buffer<T>* buffer, size_type n, size_type offset);
 
         constexpr ~non_owning_dynamic_bitset() = default;
         constexpr non_owning_dynamic_bitset(const non_owning_dynamic_bitset&) = default;
@@ -49,8 +49,8 @@ namespace sparrow
     };
 
     template <std::integral T>
-    constexpr non_owning_dynamic_bitset<T>::non_owning_dynamic_bitset(buffer<T>* buffer, size_type n)
-        : base_type(buffer, n)
+    constexpr non_owning_dynamic_bitset<T>::non_owning_dynamic_bitset(buffer<T>* buffer, size_type n, size_type offset)
+        : base_type(buffer, n, offset)
     {
         SPARROW_ASSERT_TRUE(buffer != nullptr);
     }
diff --git a/include/sparrow/decimal_array.hpp b/include/sparrow/decimal_array.hpp
index 010fe35ba..74a06f73c 100644
--- a/include/sparrow/decimal_array.hpp
+++ b/include/sparrow/decimal_array.hpp
@@ -531,7 +531,7 @@ namespace sparrow
             std::move(data_buffer),
             precision,
             scale,
-            nullable ? std::make_optional<validity_bitmap>(nullptr, size) : std::nullopt,
+            nullable ? std::make_optional<validity_bitmap>(nullptr, size, 0u) : std::nullopt,
             name,
             metadata
         );
@@ -555,7 +555,7 @@ namespace sparrow
             std::move(u8_data_buffer),
             precision,
             scale,
-            nullable ? std::make_optional<validity_bitmap>(nullptr, size) : std::nullopt,
+            nullable ? std::make_optional<validity_bitmap>(nullptr, size, 0u) : std::nullopt,
             name,
             metadata
         );
diff --git a/include/sparrow/dictionary_encoded_array.hpp b/include/sparrow/dictionary_encoded_array.hpp
index 665486319..ba36cc86f 100644
--- a/include/sparrow/dictionary_encoded_array.hpp
+++ b/include/sparrow/dictionary_encoded_array.hpp
@@ -661,7 +661,7 @@ namespace sparrow
         return create_proxy_impl(
             std::forward<keys_buffer_type>(keys),
             std::forward<array>(values),
-            nullable ? std::make_optional<validity_bitmap>(nullptr, size) : std::nullopt,
+            nullable ? std::make_optional<validity_bitmap>(nullptr, size, 0u) : std::nullopt,
             std::move(name),
             std::move(metadata)
         );
diff --git a/include/sparrow/fixed_width_binary_array.hpp b/include/sparrow/fixed_width_binary_array.hpp
index b38d5993a..c468ff8d5 100644
--- a/include/sparrow/fixed_width_binary_array.hpp
+++ b/include/sparrow/fixed_width_binary_array.hpp
@@ -648,7 +648,7 @@ namespace sparrow
     )
     {
         u8_buffer<char> data_buffer{};
-        std::optional<validity_bitmap> bitmap = nullable ? std::make_optional<validity_bitmap>(nullptr, 0)
+        std::optional<validity_bitmap> bitmap = nullable ? std::make_optional<validity_bitmap>(nullptr, 0u, 0u)
                                                          : std::nullopt;
         return create_proxy_impl(
             std::move(data_buffer),
diff --git a/include/sparrow/layout/array_base.hpp b/include/sparrow/layout/array_base.hpp
index 18e420e69..4aef00ddd 100644
--- a/include/sparrow/layout/array_base.hpp
+++ b/include/sparrow/layout/array_base.hpp
@@ -641,7 +641,7 @@ namespace sparrow
     template <class D>
     constexpr auto array_crtp_base<D>::bitmap_begin() const -> const_bitmap_iterator
     {
-        return sparrow::next(this->derived_cast().get_bitmap().cbegin(), get_arrow_proxy().offset());
+        return this->derived_cast().get_bitmap().cbegin();
     }
 
     template <class D>
diff --git a/include/sparrow/layout/array_bitmap_base.hpp b/include/sparrow/layout/array_bitmap_base.hpp
index 098a464ad..5c5c72413 100644
--- a/include/sparrow/layout/array_bitmap_base.hpp
+++ b/include/sparrow/layout/array_bitmap_base.hpp
@@ -352,7 +352,7 @@ namespace sparrow
         arrow_proxy& arrow_proxy = this->get_arrow_proxy();
         SPARROW_ASSERT_TRUE(arrow_proxy.buffers().size() > bitmap_buffer_index);
         const auto bitmap_size = arrow_proxy.length() + arrow_proxy.offset();
-        return bitmap_type(arrow_proxy.buffers()[bitmap_buffer_index].data(), bitmap_size);
+        return bitmap_type(arrow_proxy.buffers()[bitmap_buffer_index].data(), bitmap_size, arrow_proxy.offset());
     }
 
     template <class D, bool is_mutable>
@@ -373,8 +373,7 @@ namespace sparrow
         SPARROW_ASSERT_TRUE(this->bitmap_cbegin() <= pos)
         SPARROW_ASSERT_TRUE(pos <= this->bitmap_cend())
         arrow_proxy& arrow_proxy = this->get_arrow_proxy();
-        const auto pos_index = static_cast<size_t>(std::distance(this->bitmap_cbegin(), pos))
-                               + arrow_proxy.offset();
+        const auto pos_index = static_cast<size_t>(std::distance(this->bitmap_cbegin(), pos));
         const auto idx = arrow_proxy.insert_bitmap(pos_index, value, count);
         return sparrow::next(this->bitmap_begin(), idx);
     }
@@ -391,8 +390,7 @@ namespace sparrow
         SPARROW_ASSERT_TRUE(pos <= this->bitmap_cend());
         SPARROW_ASSERT_TRUE(first <= last);
         arrow_proxy& arrow_proxy = this->get_arrow_proxy();
-        const auto pos_index = static_cast<size_t>(std::distance(this->bitmap_cbegin(), pos))
-                               + arrow_proxy.offset();
+        const auto pos_index = static_cast<size_t>(std::distance(this->bitmap_cbegin(), pos));
         const auto idx = arrow_proxy.insert_bitmap(pos_index, std::ranges::subrange(first, last));
         return sparrow::next(this->bitmap_begin(), idx);
     }
diff --git a/include/sparrow/layout/mutable_array_base.hpp b/include/sparrow/layout/mutable_array_base.hpp
index ff3fc61c3..0df27547d 100644
--- a/include/sparrow/layout/mutable_array_base.hpp
+++ b/include/sparrow/layout/mutable_array_base.hpp
@@ -244,7 +244,7 @@ namespace sparrow
     template <class D>
     constexpr auto mutable_array_base<D>::bitmap_begin() -> bitmap_iterator
     {
-        return sparrow::next(this->derived_cast().get_bitmap().begin(), this->get_arrow_proxy().offset());
+        return this->derived_cast().get_bitmap().begin();
     }
 
     template <class D>
diff --git a/include/sparrow/layout/primitive_array_impl.hpp b/include/sparrow/layout/primitive_array_impl.hpp
index 4cc2be64c..1bf842c3a 100644
--- a/include/sparrow/layout/primitive_array_impl.hpp
+++ b/include/sparrow/layout/primitive_array_impl.hpp
@@ -547,7 +547,7 @@ namespace sparrow
         return create_proxy_impl(
             std::move(data_buffer),
             n,
-            nullable ? std::make_optional<validity_bitmap>(nullptr, 0) : std::nullopt,
+            nullable ? std::make_optional<validity_bitmap>(nullptr, 0u, 0u) : std::nullopt,
             std::move(name),
             std::move(metadata)
         );
@@ -563,7 +563,7 @@ namespace sparrow
         std::optional<METADATA_RANGE> metadata
     )
     {
-        std::optional<validity_bitmap> bitmap = nullable ? std::make_optional<validity_bitmap>(nullptr, 0)
+        std::optional<validity_bitmap> bitmap = nullable ? std::make_optional<validity_bitmap>(nullptr, 0u, 0u)
                                                          : std::nullopt;
         return create_proxy_impl(
             std::move(data_buffer),
@@ -586,7 +586,7 @@ namespace sparrow
     {
         auto data_buffer = details::primitive_data_access<T>::make_data_buffer(std::forward<R>(range));
         auto distance = static_cast<size_t>(std::ranges::distance(range));
-        std::optional<validity_bitmap> bitmap = nullable ? std::make_optional<validity_bitmap>(nullptr, 0)
+        std::optional<validity_bitmap> bitmap = nullable ? std::make_optional<validity_bitmap>(nullptr, 0u, 0u)
                                                          : std::nullopt;
         return create_proxy_impl(
             std::move(data_buffer),
diff --git a/include/sparrow/layout/primitive_data_access.hpp b/include/sparrow/layout/primitive_data_access.hpp
index 85eaab1df..99b22e8a2 100644
--- a/include/sparrow/layout/primitive_data_access.hpp
+++ b/include/sparrow/layout/primitive_data_access.hpp
@@ -172,8 +172,6 @@ namespace sparrow
             template <class F>
             [[nodiscard]] static u8_buffer<bool> make_data_buffer(size_t size, F init_func);
 
-            [[nodiscard]] size_t get_offset(size_t i) const;
-
             [[nodiscard]] adaptor_iterator adaptor_begin();
             [[nodiscard]] adaptor_iterator adaptor_end();
 
@@ -400,17 +398,17 @@ namespace sparrow
 
         [[nodiscard]] inline auto primitive_data_access<bool>::value(size_t i) -> inner_reference
         {
-            return m_view[get_offset(i)];
+            return m_view[i];
         }
 
         [[nodiscard]] inline auto primitive_data_access<bool>::value(size_t i) const -> inner_const_reference
         {
-            return m_view[get_offset(i)];
+            return m_view[i];
         }
 
         [[nodiscard]] inline auto primitive_data_access<bool>::value_begin() -> value_iterator
         {
-            return sparrow::next(m_view.begin(), get_offset(0u));
+            return m_view.begin();
         }
 
         [[nodiscard]] inline auto primitive_data_access<bool>::value_end() -> value_iterator
@@ -420,7 +418,7 @@ namespace sparrow
 
         [[nodiscard]] inline auto primitive_data_access<bool>::value_cbegin() const -> const_value_iterator
         {
-            return sparrow::next(m_view.cbegin(), get_offset(0u));
+            return m_view.cbegin();
         }
 
         [[nodiscard]] inline auto primitive_data_access<bool>::value_cend() const -> const_value_iterator
@@ -430,7 +428,7 @@ namespace sparrow
 
         inline void primitive_data_access<bool>::resize_values(size_t new_length, bool value)
         {
-            m_adaptor.resize(get_offset(new_length), value);
+            m_adaptor.resize(new_length, value);
             update_data_view();
         }
 
@@ -533,19 +531,14 @@ namespace sparrow
             }
             u8_buffer<bool> res(block_nb);
             std::uint8_t* buffer = reinterpret_cast<std::uint8_t*>(res.data());
-            bitset_view v(buffer, size);
+            bitset_view v(buffer, size, 0);
             init_func(v);
             return res;
         }
 
-        [[nodiscard]] inline size_t primitive_data_access<bool>::get_offset(size_t i) const
-        {
-            return i + get_proxy().offset();
-        }
-
         [[nodiscard]] inline auto primitive_data_access<bool>::adaptor_begin() -> adaptor_iterator
         {
-            return sparrow::next(m_adaptor.begin(), get_offset(0u));
+            return m_adaptor.begin();
         }
 
         [[nodiscard]] inline auto primitive_data_access<bool>::adaptor_end() -> adaptor_iterator
@@ -555,7 +548,7 @@ namespace sparrow
 
         [[nodiscard]] inline auto primitive_data_access<bool>::adaptor_cbegin() const -> const_adaptor_iterator
         {
-            return sparrow::next(m_adaptor.cbegin(), get_offset(0u));
+            return m_adaptor.cbegin();
         }
 
         [[nodiscard]] inline auto primitive_data_access<bool>::adaptor_cend() const -> const_adaptor_iterator
@@ -576,8 +569,8 @@ namespace sparrow
         [[nodiscard]] inline auto primitive_data_access<bool>::get_data_view() -> bitset_view
         {
             auto& proxy = get_proxy();
-            size_t size = proxy.length() + proxy.offset();
-            return bitset_view(proxy.buffers()[m_data_buffer_index].data(), size);
+            const size_t size = proxy.length();
+            return {proxy.buffers()[m_data_buffer_index].data(), size, proxy.offset()};
         }
 
         [[nodiscard]] inline auto primitive_data_access<bool>::get_data_adaptor() -> bitset_adaptor
@@ -585,18 +578,23 @@ namespace sparrow
             auto& proxy = get_proxy();
             if (proxy.is_created_with_sparrow())
             {
-                size_t size = proxy.length() + proxy.offset();
-                return bitset_adaptor(&(proxy.get_array_private_data()->buffers()[m_data_buffer_index]), size);
+                const size_t size = proxy.length();
+                return bitset_adaptor(
+                    &(proxy.get_array_private_data()->buffers()[m_data_buffer_index]),
+                    size,
+                    proxy.offset()
+                );
             }
             else
             {
-                return bitset_adaptor(&m_dummy_buffer, 0u);
+                return bitset_adaptor(&m_dummy_buffer, 0u, 0);
             }
         }
 
         inline void primitive_data_access<bool>::update_data_view()
         {
-            m_view = bitset_view(get_proxy().buffers()[m_data_buffer_index].data(), m_adaptor.size());
+            auto& proxy = get_proxy();
+            m_view = bitset_view(proxy.buffers()[m_data_buffer_index].data(), m_adaptor.size(), proxy.offset());
         }
     }
 }
diff --git a/include/sparrow/struct_array.hpp b/include/sparrow/struct_array.hpp
index 07e411a52..4245c69ee 100644
--- a/include/sparrow/struct_array.hpp
+++ b/include/sparrow/struct_array.hpp
@@ -443,7 +443,7 @@ namespace sparrow
         const size_t size = children.empty() ? 0 : children[0].size();
         return create_proxy_impl(
             std::forward<CHILDREN_RANGE>(children),
-            nullable ? std::make_optional<validity_bitmap>(nullptr, size) : std::nullopt,
+            nullable ? std::make_optional<validity_bitmap>(nullptr, size, 0u) : std::nullopt,
             std::move(name),
             std::move(metadata)
         );
diff --git a/include/sparrow/timestamp_array.hpp b/include/sparrow/timestamp_array.hpp
index ffe60b841..65e14ef92 100644
--- a/include/sparrow/timestamp_array.hpp
+++ b/include/sparrow/timestamp_array.hpp
@@ -756,7 +756,7 @@ namespace sparrow
         std::optional<METADATA_RANGE> metadata
     )
     {
-        std::optional<validity_bitmap> bitmap = nullable ? std::make_optional<validity_bitmap>(nullptr, 0)
+        std::optional<validity_bitmap> bitmap = nullable ? std::make_optional<validity_bitmap>(nullptr, 0u, 0u)
                                                          : std::nullopt;
         const auto values = range
                             | std::views::transform(
diff --git a/include/sparrow/variable_size_binary_array.hpp b/include/sparrow/variable_size_binary_array.hpp
index d964a3849..62fd23f25 100644
--- a/include/sparrow/variable_size_binary_array.hpp
+++ b/include/sparrow/variable_size_binary_array.hpp
@@ -1014,7 +1014,7 @@ namespace sparrow
         return create_proxy_impl(
             std::move(data_buffer),
             std::move(offset_buffer),
-            nullable ? std::make_optional<validity_bitmap>(nullptr, size) : std::nullopt,
+            nullable ? std::make_optional<validity_bitmap>(nullptr, size, 0u) : std::nullopt,
             std::move(name),
             std::move(metadata)
         );
diff --git a/src/arrow_interface/arrow_array_schema_proxy.cpp b/src/arrow_interface/arrow_array_schema_proxy.cpp
index 004a2a11b..01c5060b1 100644
--- a/src/arrow_interface/arrow_array_schema_proxy.cpp
+++ b/src/arrow_interface/arrow_array_schema_proxy.cpp
@@ -847,7 +847,11 @@ namespace sparrow
         if (has_bitmap(data_type()))
         {
             const auto& validity_buffer = buffers().front();
-            const dynamic_bitset_view<const std::uint8_t> bitmap(validity_buffer.data(), length() + offset());
+            const dynamic_bitset_view<const std::uint8_t> bitmap(
+                validity_buffer.data(),
+                length() + offset(),
+                offset()
+            );
             const auto null_count = bitmap.null_count();
             set_null_count(static_cast<int64_t>(null_count));
         }
@@ -895,7 +899,7 @@ namespace sparrow
         auto private_data = static_cast<arrow_array_private_data*>(array_without_sanitize().private_data);
         auto& bitmap_buffer = private_data->buffers()[bitmap_buffer_index];
         const size_t current_size = length() + offset();
-        non_owning_dynamic_bitset<uint8_t> bitmap{&bitmap_buffer, current_size};
+        non_owning_dynamic_bitset<uint8_t> bitmap{&bitmap_buffer, current_size, offset()};
         return bitmap;
     }
 
@@ -932,7 +936,7 @@ namespace sparrow
         SPARROW_ASSERT_TRUE(has_bitmap(data_type()))
         SPARROW_ASSERT_TRUE(std::cmp_less(index, length()))
         auto bitmap = get_non_owning_dynamic_bitset();
-        const auto it_first = sparrow::next(bitmap.cbegin(), index + offset());
+        const auto it_first = sparrow::next(bitmap.cbegin(), index);
         const auto it_last = sparrow::next(it_first, count);
         const auto it = bitmap.erase(it_first, it_last);
         update_buffers();
diff --git a/test/external_array_data_creation.hpp b/test/external_array_data_creation.hpp
index 246b71501..9308ed6cd 100644
--- a/test/external_array_data_creation.hpp
+++ b/test/external_array_data_creation.hpp
@@ -183,7 +183,7 @@ namespace sparrow::test
             ++nb_blocks;
         }
         buffer_type data_buf(nb_blocks);
-        dynamic_bitset_view<std::uint8_t> view(data_buf.data(), size);
+        dynamic_bitset_view<std::uint8_t> view(data_buf.data(), size, 0);
         for (std::size_t i = 0; i < size; ++i)
         {
             view[i] = i % 2 != 0;
diff --git a/test/test_arrow_array_schema_proxy.cpp b/test/test_arrow_array_schema_proxy.cpp
index 9f2bb1860..cb78d484c 100644
--- a/test/test_arrow_array_schema_proxy.cpp
+++ b/test/test_arrow_array_schema_proxy.cpp
@@ -500,7 +500,7 @@ TEST_SUITE("ArrowArrowSchemaProxy")
         auto buffers = proxy.buffers();
         REQUIRE_EQ(buffers.size(), 2);
         CHECK_EQ(buffers[0].size(), 2);
-        const sparrow::dynamic_bitset_view<uint8_t> bitmap(buffers[0].data(), 10);
+        const sparrow::dynamic_bitset_view<uint8_t> bitmap(buffers[0].data(), 10, 0);
         CHECK(bitmap.test(0));
         CHECK(bitmap.test(1));
         CHECK_FALSE(bitmap.test(2));
@@ -791,7 +791,7 @@ TEST_SUITE("ArrowArrowSchemaProxy")
             proxy.resize_bitmap(5);
             const auto buffers = proxy.buffers();
             REQUIRE_EQ(buffers.size(), 2);
-            const sparrow::dynamic_bitset_view<const uint8_t> bitmap(buffers[0].data(), 5);
+            const sparrow::dynamic_bitset_view<const uint8_t> bitmap(buffers[0].data(), 5, 0);
             CHECK(bitmap.test(0));
             CHECK(bitmap.test(1));
             CHECK_FALSE(bitmap.test(2));
@@ -827,7 +827,7 @@ TEST_SUITE("ArrowArrowSchemaProxy")
                 proxy.insert_bitmap(1, false);
                 const auto buffers = proxy.buffers();
                 REQUIRE_EQ(buffers.size(), 2);
-                const sparrow::dynamic_bitset_view<const uint8_t> bitmap(buffers[0].data(), 7);
+                const sparrow::dynamic_bitset_view<const uint8_t> bitmap(buffers[0].data(), 7, 0);
                 CHECK(bitmap.test(0));
                 CHECK_FALSE(bitmap.test(1));
                 CHECK(bitmap.test(2));
@@ -863,7 +863,7 @@ TEST_SUITE("ArrowArrowSchemaProxy")
                 proxy.insert_bitmap(1, false, 2);
                 const auto buffers = proxy.buffers();
                 REQUIRE_EQ(buffers.size(), 2);
-                const sparrow::dynamic_bitset_view<const uint8_t> bitmap(buffers[0].data(), 12);
+                const sparrow::dynamic_bitset_view<const uint8_t> bitmap(buffers[0].data(), 12, 0);
                 CHECK(bitmap.test(0));
                 CHECK_FALSE(bitmap.test(1));
                 CHECK_FALSE(bitmap.test(2));
@@ -905,7 +905,7 @@ TEST_SUITE("ArrowArrowSchemaProxy")
                 proxy.insert_bitmap(1, values);
                 const auto buffers = proxy.buffers();
                 REQUIRE_EQ(buffers.size(), 2);
-                const sparrow::dynamic_bitset_view<const uint8_t> bitmap(buffers[0].data(), 14);
+                const sparrow::dynamic_bitset_view<const uint8_t> bitmap(buffers[0].data(), 14, 0);
                 CHECK(bitmap.test(0));
                 CHECK_FALSE(bitmap.test(1));
                 CHECK(bitmap.test(2));
@@ -1010,7 +1010,7 @@ TEST_SUITE("ArrowArrowSchemaProxy")
             proxy.push_back_bitmap(1);
             const auto buffers = proxy.buffers();
             REQUIRE_EQ(buffers.size(), 2);
-            const sparrow::dynamic_bitset_view<const uint8_t> bitmap(buffers[0].data(), 11);
+            const sparrow::dynamic_bitset_view<const uint8_t> bitmap(buffers[0].data(), 11, 0);
             CHECK(bitmap.test(0));
             CHECK(bitmap.test(1));
             CHECK_FALSE(bitmap.test(2));
@@ -1050,7 +1050,7 @@ TEST_SUITE("ArrowArrowSchemaProxy")
             proxy.pop_back_bitmap();
             const auto buffers = proxy.buffers();
             REQUIRE_EQ(buffers.size(), 2);
-            const sparrow::dynamic_bitset_view<const uint8_t> bitmap(buffers[0].data(), 9);
+            const sparrow::dynamic_bitset_view<const uint8_t> bitmap(buffers[0].data(), 9, 0);
             CHECK(bitmap.test(0));
             CHECK(bitmap.test(1));
             CHECK_FALSE(bitmap.test(2));
diff --git a/test/test_dynamic_bitset.cpp b/test/test_dynamic_bitset.cpp
index 9aef1b399..dec8d9b09 100644
--- a/test/test_dynamic_bitset.cpp
+++ b/test/test_dynamic_bitset.cpp
@@ -179,7 +179,7 @@ namespace sparrow
                     SUBCASE("with buffer and size")
                     {
                         dynamic_bitmap_fixture bf;
-                        const bitmap b(bf.get_buffer(), s_bitmap_size);
+                        const bitmap b(bf.get_buffer(), s_bitmap_size, 0u);
                         CHECK_EQ(b.size(), s_bitmap_size);
                         CHECK_EQ(b.null_count(), s_bitmap_null_count);
                     }
@@ -195,7 +195,7 @@ namespace sparrow
                 else if constexpr (std::is_same_v<bitmap, non_owning_dynamic_bitset<std::uint8_t>>)
                 {
                     non_owning_dynamic_bitset_fixture bf;
-                    bitmap b(bf.get_buffer(), s_bitmap_size);
+                    bitmap b(bf.get_buffer(), s_bitmap_size, 0u);
                     CHECK_EQ(b.size(), s_bitmap_size);
                     CHECK_EQ(b.null_count(), s_bitmap_null_count);
                 }
@@ -205,7 +205,7 @@ namespace sparrow
             {
                 SUBCASE("from non-null buffer")
                 {
-                    bitmap bm(f.get_buffer(), s_bitmap_size);
+                    bitmap bm(f.get_buffer(), s_bitmap_size, 0u);
                     CHECK_EQ(bm.size(), s_bitmap_size);
                     CHECK_EQ(bm.null_count(), s_bitmap_null_count);
                     CHECK_EQ(bm.data(), f.p_expected_buffer);
@@ -213,7 +213,7 @@ namespace sparrow
 
                 SUBCASE("from null buffer")
                 {
-                    bitmap bm(null_f.get_buffer(), s_bitmap_size);
+                    bitmap bm(null_f.get_buffer(), s_bitmap_size, 0u);
                     CHECK_EQ(bm.size(), s_bitmap_size);
                     CHECK_EQ(bm.null_count(), 0);
                     CHECK_EQ(bm.data(), nullptr);
@@ -221,7 +221,7 @@ namespace sparrow
 
                 SUBCASE("from copy")
                 {
-                    bitmap bm(f.get_buffer(), s_bitmap_size);
+                    bitmap bm(f.get_buffer(), s_bitmap_size, 0u);
                     const bitmap& b2 = bm;
                     CHECK_EQ(b2.data(), f.p_expected_buffer);
                 }
@@ -229,7 +229,7 @@ namespace sparrow
 
             SUBCASE("copy semantic")
             {
-                const bitmap b(f.get_buffer(), s_bitmap_size);
+                const bitmap b(f.get_buffer(), s_bitmap_size, 0u);
                 bitmap b2(b);
 
                 REQUIRE_EQ(b.size(), b2.size());
@@ -251,7 +251,7 @@ namespace sparrow
 
                 const std::array<std::uint8_t, 2> blocks{37, 2};
                 fixture f3{blocks};
-                bitmap b3(f3.get_buffer(), blocks.size() * 8);
+                bitmap b3(f3.get_buffer(), blocks.size() * 8, 0u);
 
                 b2 = b3;
                 REQUIRE_EQ(b2.size(), b3.size());
@@ -274,7 +274,7 @@ namespace sparrow
 
             SUBCASE("move semantic")
             {
-                bitmap bref(f.get_buffer(), s_bitmap_size);
+                bitmap bref(f.get_buffer(), s_bitmap_size, 0u);
                 bitmap b(bref);
 
                 bitmap b2(std::move(b));
@@ -287,7 +287,7 @@ namespace sparrow
 
                 const std::array<std::uint8_t, 2> blocks{37, 2};
                 fixture f4{blocks};
-                bitmap b4(f4.get_buffer(), blocks.size() * 8);
+                bitmap b4(f4.get_buffer(), blocks.size() * 8, 0u);
                 bitmap b5(b4);
 
                 b2 = std::move(b4);
@@ -303,7 +303,7 @@ namespace sparrow
             {
                 SUBCASE("from null buffer")
                 {
-                    bitmap bm(null_f.get_buffer(), s_bitmap_size);
+                    bitmap bm(null_f.get_buffer(), s_bitmap_size, 0u);
                     CHECK_EQ(bm.size(), s_bitmap_size);
                     CHECK_EQ(bm.null_count(), 0);
                     for (size_t i = 0; i < s_bitmap_size; ++i)
@@ -328,7 +328,7 @@ namespace sparrow
 
                 SUBCASE("from non-null buffer")
                 {
-                    bitmap bm(f.get_buffer(), s_bitmap_size);
+                    bitmap bm(f.get_buffer(), s_bitmap_size, 0u);
 
                     CHECK(bm.test(2));
                     CHECK_FALSE(bm.test(3));
@@ -357,7 +357,7 @@ namespace sparrow
             {
                 SUBCASE("from null buffer")
                 {
-                    bitmap bm(null_f.get_buffer(), s_bitmap_size);
+                    bitmap bm(null_f.get_buffer(), s_bitmap_size, 0u);
                     REQUIRE_EQ(bm.size(), s_bitmap_size);
                     for (size_t i = 0; i < s_bitmap_size; ++i)
                     {
@@ -376,7 +376,7 @@ namespace sparrow
 
                 SUBCASE("from non-null buffer")
                 {
-                    bitmap bm(f.get_buffer(), s_bitmap_size);
+                    bitmap bm(f.get_buffer(), s_bitmap_size, 0u);
                     CHECK(bm[2]);
                     CHECK_FALSE(bm[3]);
                     CHECK(bm[24]);
@@ -404,7 +404,7 @@ namespace sparrow
             {
                 SUBCASE("from null buffer")
                 {
-                    bitmap bm(null_f.get_buffer(), s_bitmap_size);
+                    bitmap bm(null_f.get_buffer(), s_bitmap_size, 0u);
                     CHECK_EQ(bm.size(), s_bitmap_size);
                     CHECK_EQ(bm.null_count(), 0);
                     bm.resize(40, false);
@@ -414,7 +414,7 @@ namespace sparrow
 
                 SUBCASE("from non null buffer")
                 {
-                    bitmap bm(f.get_buffer(), s_bitmap_size);
+                    bitmap bm(f.get_buffer(), s_bitmap_size, 0u);
                     CHECK_EQ(bm.size(), s_bitmap_size);
                     CHECK_EQ(bm.null_count(), s_bitmap_null_count);
 
@@ -441,7 +441,7 @@ namespace sparrow
                 {
                     SUBCASE("from non null buffer")
                     {
-                        bitmap b(f.get_buffer(), s_bitmap_size);
+                        bitmap b(f.get_buffer(), s_bitmap_size, 0u);
                         auto iter = b.begin();
                         for (size_t i = 0; i < s_bitmap_size; ++i)
                         {
@@ -452,7 +452,7 @@ namespace sparrow
 
                     SUBCASE("from null buffer")
                     {
-                        bitmap b(null_f.get_buffer(), s_bitmap_size);
+                        bitmap b(null_f.get_buffer(), s_bitmap_size, 0u);
                         auto iter = b.begin();
                         for (size_t i = 0; i < s_bitmap_size; ++i)
                         {
@@ -466,7 +466,7 @@ namespace sparrow
                 {
                     SUBCASE("from non null buffer")
                     {
-                        bitmap b(f.get_buffer(), s_bitmap_size);
+                        bitmap b(f.get_buffer(), s_bitmap_size, 0u);
                         auto iter = b.end();
                         for (size_t i = s_bitmap_size; i > 0; --i)
                         {
@@ -476,7 +476,7 @@ namespace sparrow
                     }
                     SUBCASE("from null buffer")
                     {
-                        bitmap b(null_f.get_buffer(), s_bitmap_size);
+                        bitmap b(null_f.get_buffer(), s_bitmap_size, 0u);
                         auto iter = b.end();
                         for (size_t i = s_bitmap_size; i > 0; --i)
                         {
@@ -492,7 +492,7 @@ namespace sparrow
                     // static_assert(std::random_access_iterator<typename bitmap::iterator>);
                     static_assert(std::random_access_iterator<typename bitmap::const_iterator>);
 
-                    bitmap b(f.get_buffer(), s_bitmap_size);
+                    bitmap b(f.get_buffer(), s_bitmap_size, 0u);
                     auto iter = b.begin();
                     auto citer = b.cbegin();
 
@@ -552,7 +552,7 @@ namespace sparrow
                     {
                         SUBCASE("from non null buffer")
                         {
-                            bitmap b(f.get_buffer(), s_bitmap_size);
+                            bitmap b(f.get_buffer(), s_bitmap_size, 0u);
                             const auto pos = b.cbegin();
                             auto iter = b.insert(pos, false);
                             CHECK_EQ(b.size(), s_bitmap_size + 1);
@@ -566,7 +566,7 @@ namespace sparrow
                         }
                         SUBCASE("from null buffer")
                         {
-                            bitmap b(null_f.get_buffer(), s_bitmap_size);
+                            bitmap b(null_f.get_buffer(), s_bitmap_size, 0u);
                             const auto pos = b.cbegin();
                             auto iter = b.insert(pos, false);
                             CHECK_EQ(b.size(), s_bitmap_size + 1);
@@ -584,7 +584,7 @@ namespace sparrow
                     {
                         SUBCASE("from non null buffer")
                         {
-                            bitmap b(f.get_buffer(), s_bitmap_size);
+                            bitmap b(f.get_buffer(), s_bitmap_size, 0u);
                             const auto pos = std::next(b.cbegin(), 14);
                             auto iter = b.insert(pos, false);
                             CHECK_EQ(b.size(), s_bitmap_size + 1);
@@ -598,7 +598,7 @@ namespace sparrow
                         }
                         SUBCASE("from null buffer")
                         {
-                            bitmap b(null_f.get_buffer(), s_bitmap_size);
+                            bitmap b(null_f.get_buffer(), s_bitmap_size, 0u);
                             const auto pos = std::next(b.cbegin(), 14);
                             auto iter = b.insert(pos, false);
                             CHECK_EQ(b.size(), s_bitmap_size + 1);
@@ -616,7 +616,7 @@ namespace sparrow
                     {
                         SUBCASE("from non null buffer")
                         {
-                            bitmap b(f.get_buffer(), s_bitmap_size);
+                            bitmap b(f.get_buffer(), s_bitmap_size, 0u);
                             const auto pos = b.cend();
                             auto iter = b.insert(pos, false);
                             CHECK_EQ(b.size(), s_bitmap_size + 1);
@@ -630,7 +630,7 @@ namespace sparrow
                         }
                         SUBCASE("from null buffer")
                         {
-                            bitmap b(null_f.get_buffer(), s_bitmap_size);
+                            bitmap b(null_f.get_buffer(), s_bitmap_size, 0u);
                             const auto pos = b.cend();
                             auto iter = b.insert(pos, false);
                             CHECK_EQ(b.size(), s_bitmap_size + 1);
@@ -651,7 +651,7 @@ namespace sparrow
                     {
                         SUBCASE("from non null buffer")
                         {
-                            bitmap b(f.get_buffer(), s_bitmap_size);
+                            bitmap b(f.get_buffer(), s_bitmap_size, 0u);
                             const auto pos = b.cbegin();
                             auto iter = b.insert(pos, 3, false);
                             CHECK_EQ(b.size(), s_bitmap_size + 3);
@@ -669,7 +669,7 @@ namespace sparrow
                         }
                         SUBCASE("from null buffer")
                         {
-                            bitmap b(null_f.get_buffer(), s_bitmap_size);
+                            bitmap b(null_f.get_buffer(), s_bitmap_size, 0u);
                             const auto pos = b.cbegin();
                             auto iter = b.insert(pos, 3, false);
                             CHECK_EQ(b.size(), s_bitmap_size + 3);
@@ -691,7 +691,7 @@ namespace sparrow
                     {
                         SUBCASE("from non null buffer")
                         {
-                            bitmap b(f.get_buffer(), s_bitmap_size);
+                            bitmap b(f.get_buffer(), s_bitmap_size, 0u);
                             const auto pos = std::next(b.cbegin(), 14);
                             auto iter = b.insert(pos, 3, false);
                             CHECK_EQ(b.size(), s_bitmap_size + 3);
@@ -709,7 +709,7 @@ namespace sparrow
                         }
                         SUBCASE("from null buffer")
                         {
-                            bitmap b(null_f.get_buffer(), s_bitmap_size);
+                            bitmap b(null_f.get_buffer(), s_bitmap_size, 0u);
                             const auto pos = std::next(b.cbegin(), 14);
                             auto iter = b.insert(pos, 3, false);
                             CHECK_EQ(b.size(), s_bitmap_size + 3);
@@ -731,7 +731,7 @@ namespace sparrow
                     {
                         SUBCASE("from non null buffer")
                         {
-                            bitmap b(f.get_buffer(), s_bitmap_size);
+                            bitmap b(f.get_buffer(), s_bitmap_size, 0u);
                             auto iter = b.insert(b.cend(), 3, false);
                             CHECK_EQ(b.size(), s_bitmap_size + 3);
                             CHECK_EQ(b.null_count(), s_bitmap_null_count + 3);
@@ -748,7 +748,7 @@ namespace sparrow
                         }
                         SUBCASE("from null buffer")
                         {
-                            bitmap b(null_f.get_buffer(), s_bitmap_size);
+                            bitmap b(null_f.get_buffer(), s_bitmap_size, 0u);
                             auto iter = b.insert(b.cend(), 3, false);
                             CHECK_EQ(b.size(), s_bitmap_size + 3);
                             CHECK_EQ(b.null_count(), 3);
@@ -773,7 +773,7 @@ namespace sparrow
                 {
                     SUBCASE("from non null buffer")
                     {
-                        bitmap b(f.get_buffer(), s_bitmap_size);
+                        bitmap b(f.get_buffer(), s_bitmap_size, 0u);
                         auto iter = b.emplace(b.cbegin(), true);
                         CHECK_EQ(b.size(), s_bitmap_size + 1);
                         CHECK_EQ(b.null_count(), s_bitmap_null_count);
@@ -781,7 +781,7 @@ namespace sparrow
                     }
                     SUBCASE("from null buffer")
                     {
-                        bitmap b(null_f.get_buffer(), s_bitmap_size);
+                        bitmap b(null_f.get_buffer(), s_bitmap_size, 0u);
                         auto iter = b.emplace(b.cbegin(), true);
                         CHECK_EQ(b.size(), s_bitmap_size + 1);
                         CHECK_EQ(b.null_count(), 0);
@@ -793,7 +793,7 @@ namespace sparrow
                 {
                     SUBCASE("from non null buffer")
                     {
-                        bitmap b(f.get_buffer(), s_bitmap_size);
+                        bitmap b(f.get_buffer(), s_bitmap_size, 0u);
                         auto iter = b.emplace(std::next(b.cbegin()), true);
                         CHECK_EQ(b.size(), s_bitmap_size + 1);
                         CHECK_EQ(b.null_count(), s_bitmap_null_count);
@@ -801,7 +801,7 @@ namespace sparrow
                     }
                     SUBCASE("from null buffer")
                     {
-                        bitmap b(null_f.get_buffer(), s_bitmap_size);
+                        bitmap b(null_f.get_buffer(), s_bitmap_size, 0u);
                         auto iter = b.emplace(std::next(b.cbegin()), true);
                         CHECK_EQ(b.size(), s_bitmap_size + 1);
                         CHECK_EQ(b.null_count(), 0);
@@ -813,7 +813,7 @@ namespace sparrow
                 {
                     SUBCASE("from non null buffer")
                     {
-                        bitmap b(f.get_buffer(), s_bitmap_size);
+                        bitmap b(f.get_buffer(), s_bitmap_size, 0u);
                         auto iter = b.emplace(b.cend(), true);
                         CHECK_EQ(b.size(), s_bitmap_size + 1);
                         CHECK_EQ(b.null_count(), s_bitmap_null_count);
@@ -821,7 +821,7 @@ namespace sparrow
                     }
                     SUBCASE("from null buffer")
                     {
-                        bitmap b(null_f.get_buffer(), s_bitmap_size);
+                        bitmap b(null_f.get_buffer(), s_bitmap_size, 0u);
                         auto iter = b.emplace(b.cend(), true);
                         CHECK_EQ(b.size(), s_bitmap_size + 1);
                         CHECK_EQ(b.null_count(), 0);
@@ -845,7 +845,7 @@ namespace sparrow
                     {
                         SUBCASE("from non null buffer")
                         {
-                            bitmap b(f.get_buffer(), s_bitmap_size);
+                            bitmap b(f.get_buffer(), s_bitmap_size, 0u);
                             auto iter = b.erase(b.cbegin());
                             CHECK_EQ(b.size(), s_bitmap_size - 1);
                             CHECK_EQ(b.null_count(), s_bitmap_null_count - 1);
@@ -854,7 +854,7 @@ namespace sparrow
                         }
                         SUBCASE("from null buffer")
                         {
-                            bitmap b(null_f.get_buffer(), s_bitmap_size);
+                            bitmap b(null_f.get_buffer(), s_bitmap_size, 0u);
                             auto iter = b.erase(b.cbegin());
                             CHECK_EQ(b.size(), s_bitmap_size - 1);
                             CHECK_EQ(b.null_count(), 0);
@@ -868,7 +868,7 @@ namespace sparrow
                     {
                         SUBCASE("from non null buffer")
                         {
-                            bitmap b(f.get_buffer(), s_bitmap_size);
+                            bitmap b(f.get_buffer(), s_bitmap_size, 0u);
                             const auto pos = std::next(b.cbegin(), 2);
                             auto iter = b.erase(pos);
                             CHECK_EQ(b.size(), s_bitmap_size - 1);
@@ -878,7 +878,7 @@ namespace sparrow
                         }
                         SUBCASE("from null buffer")
                         {
-                            bitmap b(null_f.get_buffer(), s_bitmap_size);
+                            bitmap b(null_f.get_buffer(), s_bitmap_size, 0u);
                             const auto pos = std::next(b.cbegin(), 2);
                             auto iter = b.erase(pos);
                             CHECK_EQ(b.size(), s_bitmap_size - 1);
@@ -896,7 +896,7 @@ namespace sparrow
                     {
                         SUBCASE("from non null buffer")
                         {
-                            bitmap b(f.get_buffer(), s_bitmap_size);
+                            bitmap b(f.get_buffer(), s_bitmap_size, 0u);
                             auto iter = b.erase(b.cbegin(), std::next(b.cbegin()));
                             CHECK_EQ(b.size(), s_bitmap_size - 1);
                             CHECK_EQ(b.null_count(), s_bitmap_null_count - 1);
@@ -904,7 +904,7 @@ namespace sparrow
                         }
                         SUBCASE("from null buffer")
                         {
-                            bitmap b(null_f.get_buffer(), s_bitmap_size);
+                            bitmap b(null_f.get_buffer(), s_bitmap_size, 0u);
                             auto iter = b.erase(b.cbegin(), std::next(b.cbegin()));
                             CHECK_EQ(b.size(), s_bitmap_size - 1);
                             CHECK_EQ(b.null_count(), 0);
@@ -917,7 +917,7 @@ namespace sparrow
                     {
                         SUBCASE("from non null buffer")
                         {
-                            bitmap b(f.get_buffer(), s_bitmap_size);
+                            bitmap b(f.get_buffer(), s_bitmap_size, 0u);
                             const auto pos = std::next(b.cbegin());
                             auto iter = b.erase(pos, std::next(pos, 1));
                             CHECK_EQ(b.size(), s_bitmap_size - 1);
@@ -926,7 +926,7 @@ namespace sparrow
                         }
                         SUBCASE("from null buffer")
                         {
-                            bitmap b(null_f.get_buffer(), s_bitmap_size);
+                            bitmap b(null_f.get_buffer(), s_bitmap_size, 0u);
                             const auto pos = std::next(b.cbegin());
                             auto iter = b.erase(pos, std::next(pos, 1));
                             CHECK_EQ(b.size(), s_bitmap_size - 1);
@@ -940,7 +940,7 @@ namespace sparrow
                     {
                         SUBCASE("from non null buffer")
                         {
-                            bitmap b(f.get_buffer(), s_bitmap_size);
+                            bitmap b(f.get_buffer(), s_bitmap_size, 0u);
                             auto iter = b.erase(b.cbegin(), b.cend());
                             CHECK_EQ(b.size(), 0);
                             CHECK_EQ(b.null_count(), 0);
@@ -948,7 +948,7 @@ namespace sparrow
                         }
                         SUBCASE("from null buffer")
                         {
-                            bitmap b(null_f.get_buffer(), s_bitmap_size);
+                            bitmap b(null_f.get_buffer(), s_bitmap_size, 0u);
                             auto iter = b.erase(b.cbegin(), b.cend());
                             CHECK_EQ(b.size(), 0);
                             CHECK_EQ(b.null_count(), 0);
@@ -963,7 +963,7 @@ namespace sparrow
             {
                 SUBCASE("from non null buffer")
                 {
-                    const bitmap b(f.get_buffer(), s_bitmap_size);
+                    const bitmap b(f.get_buffer(), s_bitmap_size, 0u);
                     CHECK_EQ(b.at(0), false);
                     CHECK_EQ(b.at(1), true);
                     CHECK_EQ(b.at(2), true);
@@ -971,7 +971,7 @@ namespace sparrow
                 }
                 SUBCASE("from null buffer")
                 {
-                    const bitmap b(null_f.get_buffer(), s_bitmap_size);
+                    const bitmap b(null_f.get_buffer(), s_bitmap_size, 0u);
                     CHECK_EQ(b.at(0), true);
                     CHECK_EQ(b.at(1), true);
                     CHECK_EQ(b.at(2), true);
@@ -983,12 +983,12 @@ namespace sparrow
             {
                 SUBCASE("from non null buffer")
                 {
-                    const bitmap b(f.get_buffer(), s_bitmap_size);
+                    const bitmap b(f.get_buffer(), s_bitmap_size, 0u);
                     CHECK_EQ(b.front(), false);
                 }
                 SUBCASE("from null buffer")
                 {
-                    const bitmap b(null_f.get_buffer(), s_bitmap_size);
+                    const bitmap b(null_f.get_buffer(), s_bitmap_size, 0u);
                     CHECK_EQ(b.front(), true);
                 }
             }
@@ -997,12 +997,12 @@ namespace sparrow
             {
                 SUBCASE("from non null buffer")
                 {
-                    const bitmap b(f.get_buffer(), s_bitmap_size);
+                    const bitmap b(f.get_buffer(), s_bitmap_size, 0u);
                     CHECK_EQ(b.back(), false);
                 }
                 SUBCASE("from null buffer")
                 {
-                    const bitmap b(null_f.get_buffer(), s_bitmap_size);
+                    const bitmap b(null_f.get_buffer(), s_bitmap_size, 0u);
                     CHECK_EQ(b.back(), true);
                 }
             }
@@ -1011,7 +1011,7 @@ namespace sparrow
             {
                 SUBCASE("from non null buffer")
                 {
-                    bitmap b(f.get_buffer(), s_bitmap_size);
+                    bitmap b(f.get_buffer(), s_bitmap_size, 0u);
                     b.push_back(false);
                     CHECK_EQ(b.size(), s_bitmap_size + 1);
                     CHECK_EQ(b.null_count(), s_bitmap_null_count + 1);
@@ -1019,7 +1019,7 @@ namespace sparrow
                 }
                 SUBCASE("from null buffer")
                 {
-                    bitmap b(null_f.get_buffer(), s_bitmap_size);
+                    bitmap b(null_f.get_buffer(), s_bitmap_size, 0u);
                     b.push_back(false);
                     CHECK_EQ(b.size(), s_bitmap_size + 1);
                     CHECK_EQ(b.null_count(), 1);
@@ -1031,7 +1031,7 @@ namespace sparrow
             {
                 SUBCASE("on non empty bitmap")
                 {
-                    bitmap b(f.get_buffer(), s_bitmap_size);
+                    bitmap b(f.get_buffer(), s_bitmap_size, 0u);
                     b.pop_back();
                     CHECK_EQ(b.size(), s_bitmap_size - 1);
                     CHECK_EQ(b.null_count(), s_bitmap_null_count - 1);
@@ -1051,7 +1051,7 @@ namespace sparrow
                 SUBCASE("from non null buffer")
                 {
                     // as a reminder: p_buffer[0] = 38; // 00100110
-                    bitmap b(f.get_buffer(), s_bitmap_size);
+                    bitmap b(f.get_buffer(), s_bitmap_size, 0u);
                     auto iter = b.begin();
                     *iter = true;
                     CHECK_EQ(b.null_count(), s_bitmap_null_count - 1);
@@ -1079,7 +1079,7 @@ namespace sparrow
                 }
                 SUBCASE("from null buffer")
                 {
-                    bitmap b(null_f.get_buffer(), s_bitmap_size);
+                    bitmap b(null_f.get_buffer(), s_bitmap_size, 0u);
                     auto iter = b.begin();
                     *iter = true;
                     CHECK_EQ(b.null_count(), 0);
diff --git a/test/test_dynamic_bitset_view.cpp b/test/test_dynamic_bitset_view.cpp
index 77d97d7af..da8f63139 100644
--- a/test/test_dynamic_bitset_view.cpp
+++ b/test/test_dynamic_bitset_view.cpp
@@ -68,7 +68,7 @@ namespace sparrow
 
         TEST_CASE_FIXTURE(bitmap_fixture, "constructor")
         {
-            bitmap_view b(p_buffer, m_size);
+            bitmap_view b(p_buffer, m_size, 0u);
             CHECK_EQ(b.data(), p_buffer);
 
             const bitmap_view& b2 = b;
@@ -77,7 +77,7 @@ namespace sparrow
 
         TEST_CASE_FIXTURE(bitmap_fixture, "copy semantic")
         {
-            bitmap_view b(p_buffer, m_size);
+            bitmap_view b(p_buffer, m_size, 0u);
             bitmap_view b2(b);
 
             CHECK_EQ(b.size(), b2.size());
@@ -91,7 +91,7 @@ namespace sparrow
 
         TEST_CASE_FIXTURE(bitmap_fixture, "move semantic")
         {
-            bitmap_view bref(p_buffer, m_size);
+            bitmap_view bref(p_buffer, m_size, 0u);
             bitmap_view b(bref);
 
             bitmap_view b2(std::move(b));