diff --git a/CHANGELOG.md b/CHANGELOG.md
index 069dfe0..a3e0d33 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,7 +5,7 @@
 * align from serializer/deserializer
 * AdapterAccess class
 * helper class Serializer/Deserializer
-* deprecated registerBasesList from PolymorphicContext
+* removed deprecated function registerBasesList from PolymorphicContext
 * internal context from config, because it doesn't actually solve any problems, only allows to do same thing in multiple ways
 * AdapterWriter/Reader classes, and their functionality is moved to `adapters`.
 * UnsafeInputBufferAdapter, instead config option is provided to disable buffer read errors
@@ -27,6 +27,7 @@
     (e.g. you can require base class of context in extension, but provided child implementation instead)
 * renamed NetworkEndianness to Endianness in config
 * MeasureSize adapter moved to separate file `/adapter/measure_size.h`
+* removed Writer/Reader parameter from extensions serialize/deserialize methods
 
 ## improvements
 
diff --git a/include/bitsery/deserializer.h b/include/bitsery/deserializer.h
index cd480da..b3dabca 100644
--- a/include/bitsery/deserializer.h
+++ b/include/bitsery/deserializer.h
@@ -168,6 +168,7 @@ namespace bitsery {
         using BPEnabledType = BasicDeserializer<typename std::conditional<TInputAdapter::BitPackingEnabled,
             TInputAdapter,
             details::InputAdapterBitPackingWrapper<TInputAdapter>>::type, TContext>;
+        using TConfig = typename TInputAdapter::TConfig;
 
         using details::AdapterAndContextRef<TInputAdapter, TContext>::AdapterAndContextRef;
 
@@ -233,7 +234,7 @@ namespace bitsery {
             static_assert(details::IsExtensionTraitsDefined<Ext, T>::value, "Please define ExtensionTraits");
             static_assert(traits::ExtensionTraits<Ext,T>::SupportLambdaOverload,
                           "extension doesn't support overload with lambda");
-            extension.deserialize(*this, this->_adapter, obj, std::forward<Fnc>(fnc));
+            extension.deserialize(*this, obj, std::forward<Fnc>(fnc));
         }
 
         template<size_t VSIZE, typename T, typename Ext>
@@ -243,7 +244,7 @@ namespace bitsery {
                           "extension doesn't support overload with `value<N>`");
             using ExtVType = typename traits::ExtensionTraits<Ext, T>::TValue;
             using VType = typename std::conditional<std::is_void<ExtVType>::value, details::DummyType, ExtVType>::type;
-            extension.deserialize(*this, this->_adapter, obj, [](BasicDeserializer& s, VType &v) { s.value<VSIZE>(v);});
+            extension.deserialize(*this, obj, [](BasicDeserializer& s, VType &v) { s.value<VSIZE>(v);});
         }
 
         template<typename T, typename Ext>
@@ -253,7 +254,7 @@ namespace bitsery {
                           "extension doesn't support overload with `object`");
             using ExtVType = typename traits::ExtensionTraits<Ext, T>::TValue;
             using VType = typename std::conditional<std::is_void<ExtVType>::value, details::DummyType, ExtVType>::type;
-            extension.deserialize(*this, this->_adapter, obj, [](BasicDeserializer& s, VType &v) { s.object(v); });
+            extension.deserialize(*this, obj, [](BasicDeserializer& s, VType &v) { s.object(v); });
         }
 
         /*
diff --git a/include/bitsery/ext/compact_value.h b/include/bitsery/ext/compact_value.h
index be8582b..788674a 100644
--- a/include/bitsery/ext/compact_value.h
+++ b/include/bitsery/ext/compact_value.h
@@ -35,43 +35,43 @@ namespace bitsery {
         class CompactValueImpl {
         public:
 
-            template<typename Ser, typename Writer, typename T, typename Fnc>
-            void serialize(Ser &s, Writer &writer, const T &v, Fnc &&) const {
+            template<typename Ser, typename T, typename Fnc>
+            void serialize(Ser &s, const T &v, Fnc &&) const {
                 static_assert(std::is_integral<T>::value || std::is_enum<T>::value, "");
                 using TValue = typename IntegralFromFundamental<T>::TValue;
-                serializeImpl(s, writer, reinterpret_cast<const TValue&>(v), std::integral_constant<bool, sizeof(T) != 1>{});
+                serializeImpl(s.adapter(), reinterpret_cast<const TValue&>(v), std::integral_constant<bool, sizeof(T) != 1>{});
             }
 
-            template<typename Des, typename Reader, typename T, typename Fnc>
-            void deserialize(Des &d, Reader &reader, T &v, Fnc &&) const {
+            template<typename Des, typename T, typename Fnc>
+            void deserialize(Des &d, T &v, Fnc &&) const {
                 static_assert(std::is_integral<T>::value || std::is_enum<T>::value, "");
                 using TValue = typename IntegralFromFundamental<T>::TValue;
-                deserializeImpl(d, reader, reinterpret_cast<TValue &>(v), std::integral_constant<bool, sizeof(T) != 1>{});
+                deserializeImpl(d.adapter(), reinterpret_cast<TValue &>(v), std::integral_constant<bool, sizeof(T) != 1>{});
             }
 
         private:
 
             // if value is 1byte size, just serialize/ deserialize whole value
-            template<typename Ser, typename Writer, typename T>
-            void serializeImpl(Ser &s, Writer &, const T &v, std::false_type) const {
-                s.value1b(v);
+            template<typename Writer, typename T>
+            void serializeImpl(Writer &writer, const T &v, std::false_type) const {
+                writer.template writeBytes<1>(v);
             }
 
-            template<typename Des, typename Reader, typename T>
-            void deserializeImpl(Des &d, Reader &, T &v, std::false_type) const {
-                d.value1b(v);
+            template<typename Reader, typename T>
+            void deserializeImpl(Reader &reader, T &v, std::false_type) const {
+                reader.template readBytes<1>(v);
             }
 
             // when value is bigger than 1byte size,
-            template<typename Ser, typename Writer, typename T>
-            void serializeImpl(Ser &, Writer &writer, const T &v, std::true_type) const {
+            template<typename Writer, typename T>
+            void serializeImpl(Writer &writer, const T &v, std::true_type) const {
                 auto val = zigZagEncode(v, std::is_signed<typename IntegralFromFundamental<T>::TValue>{});
                 writeBytes(writer, val);
             }
 
 
-            template<typename Des, typename Reader, typename T>
-            void deserializeImpl(Des &, Reader &reader, T &v, std::true_type) const {
+            template<typename Reader, typename T>
+            void deserializeImpl(Reader &reader, T &v, std::true_type) const {
                 using TUnsigned = SameSizeUnsigned<T>;
                 TUnsigned res{};
                 readBytes<Reader::TConfig::CheckDataErrors>(reader, res);
diff --git a/include/bitsery/ext/entropy.h b/include/bitsery/ext/entropy.h
index 3a5dd09..4a355d8 100644
--- a/include/bitsery/ext/entropy.h
+++ b/include/bitsery/ext/entropy.h
@@ -56,24 +56,24 @@ namespace bitsery {
                       _alignBeforeData{alignBeforeData} {
             };
 
-            template<typename Ser, typename Writer, typename T, typename Fnc>
-            void serialize(Ser &s, Writer &writer, const T &obj, Fnc &&fnc) const {
+            template<typename Ser, typename T, typename Fnc>
+            void serialize(Ser &s, const T &obj, Fnc &&fnc) const {
                 assert(traits::ContainerTraits<TContainer>::size(_values) > 0);
                 auto index = details::findEntropyIndex(obj, _values);
                 s.ext(index, ext::ValueRange<size_t>{0u, traits::ContainerTraits<TContainer>::size(_values)});
                 if (_alignBeforeData)
-                    writer.align();
+                    s.adapter().align();
                 if (!index)
                     fnc(s, const_cast<T &>(obj));
             }
 
-            template<typename Des, typename Reader, typename T, typename Fnc>
-            void deserialize(Des &d, Reader &reader, T &obj, Fnc &&fnc) const {
+            template<typename Des, typename T, typename Fnc>
+            void deserialize(Des &d, T &obj, Fnc &&fnc) const {
                 assert(traits::ContainerTraits<TContainer>::size(_values) > 0);
                 size_t index{};
                 d.ext(index, ext::ValueRange<size_t>{0u, traits::ContainerTraits<TContainer>::size(_values)});
                 if (_alignBeforeData)
-                    reader.align();
+                    d.adapter().align();
                 if (index)
                     obj = *std::next(std::begin(_values), index-1);
                 else
diff --git a/include/bitsery/ext/growable.h b/include/bitsery/ext/growable.h
index 1ae794c..eb8619a 100644
--- a/include/bitsery/ext/growable.h
+++ b/include/bitsery/ext/growable.h
@@ -37,8 +37,9 @@ namespace bitsery {
         class Growable {
         public:
 
-            template<typename Ser, typename Writer, typename T, typename Fnc>
-            void serialize(Ser &ser, Writer &writer, const T &obj, Fnc &&fnc) const {
+            template<typename Ser, typename T, typename Fnc>
+            void serialize(Ser &ser, const T &obj, Fnc &&fnc) const {
+                auto& writer = ser.adapter();
                 const auto startPos = writer.currentWritePos();
                 writer.template writeBytes<4>(static_cast<uint32_t>(0));
 
@@ -50,8 +51,9 @@ namespace bitsery {
                 writer.currentWritePos(endPos);
             }
 
-            template<typename Des, typename Reader, typename T, typename Fnc>
-            void deserialize(Des &des, Reader &reader, T &obj, Fnc &&fnc) const {
+            template<typename Des, typename T, typename Fnc>
+            void deserialize(Des &des, T &obj, Fnc &&fnc) const {
+                auto& reader = des.adapter();
                 uint32_t size{};
                 const auto readEndPos = reader.currentReadEndPos();
                 const auto startPos = reader.currentReadPos();
diff --git a/include/bitsery/ext/inheritance.h b/include/bitsery/ext/inheritance.h
index c881ca4..c2c53d0 100644
--- a/include/bitsery/ext/inheritance.h
+++ b/include/bitsery/ext/inheritance.h
@@ -79,8 +79,8 @@ namespace bitsery {
         class BaseClass {
         public:
 
-            template<typename Ser, typename Writer, typename T, typename Fnc>
-            void serialize(Ser &ser, Writer &, const T &obj, Fnc &&fnc) const {
+            template<typename Ser, typename T, typename Fnc>
+            void serialize(Ser &ser, const T &obj, Fnc &&fnc) const {
                 auto& resObj = static_cast<const TBase&>(obj);
                 if (auto ctx = ser.template contextOrNull<InheritanceContext>()) {
                     ctx->beginBase(obj, resObj);
@@ -91,8 +91,8 @@ namespace bitsery {
                 }
             }
 
-            template<typename Des, typename Reader, typename T, typename Fnc>
-            void deserialize(Des &des, Reader &, T &obj, Fnc &&fnc) const {
+            template<typename Des, typename T, typename Fnc>
+            void deserialize(Des &des, T &obj, Fnc &&fnc) const {
                 auto& resObj = static_cast<TBase&>(obj);
                 if (auto ctx = des.template contextOrNull<InheritanceContext>()) {
                     ctx->beginBase(obj, resObj);
@@ -110,8 +110,8 @@ namespace bitsery {
         class VirtualBaseClass {
         public:
 
-            template<typename Ser, typename Writer, typename T, typename Fnc>
-            void serialize(Ser &ser, Writer &, const T &obj, Fnc &&fnc) const {
+            template<typename Ser, typename T, typename Fnc>
+            void serialize(Ser &ser, const T &obj, Fnc &&fnc) const {
                 auto& ctx = ser.template context<InheritanceContext>();
                 auto& resObj = static_cast<const TBase&>(obj);
                 if (ctx.beginVirtualBase(obj, resObj))
@@ -119,8 +119,8 @@ namespace bitsery {
                 ctx.end();
             }
 
-            template<typename Des, typename Reader, typename T, typename Fnc>
-            void deserialize(Des &des, Reader &, T &obj, Fnc &&fnc) const {
+            template<typename Des, typename T, typename Fnc>
+            void deserialize(Des &des, T &obj, Fnc &&fnc) const {
                 auto& ctx = des.template context<InheritanceContext>();
                 auto& resObj = static_cast<TBase&>(obj);
                 if (ctx.beginVirtualBase(obj, resObj))
diff --git a/include/bitsery/ext/std_chrono.h b/include/bitsery/ext/std_chrono.h
index 2e51cf4..4884b0a 100644
--- a/include/bitsery/ext/std_chrono.h
+++ b/include/bitsery/ext/std_chrono.h
@@ -32,14 +32,14 @@ namespace bitsery {
         class StdDuration {
         public:
 
-            template<typename Ser, typename Writer, typename T, typename Period, typename Fnc>
-            void serialize(Ser& ser, Writer&, const std::chrono::duration<T, Period>& obj, Fnc&& fnc) const {
+            template<typename Ser, typename T, typename Period, typename Fnc>
+            void serialize(Ser& ser, const std::chrono::duration<T, Period>& obj, Fnc&& fnc) const {
                 auto res = obj.count();
                 fnc(ser, res);
             }
 
-            template<typename Des, typename Reader, typename T, typename Period, typename Fnc>
-            void deserialize(Des& des, Reader&, std::chrono::duration<T, Period>& obj, Fnc&& fnc) const {
+            template<typename Des, typename T, typename Period, typename Fnc>
+            void deserialize(Des& des, std::chrono::duration<T, Period>& obj, Fnc&& fnc) const {
                 T res{};
                 fnc(des, res);
                 obj = std::chrono::duration<T, Period>{res};
@@ -49,15 +49,15 @@ namespace bitsery {
         class StdTimePoint {
         public:
 
-            template<typename Ser, typename Writer, typename Clock, typename T, typename Period, typename Fnc>
-            void serialize(Ser& ser, Writer&, const std::chrono::time_point<Clock, std::chrono::duration<T, Period>>& obj,
+            template<typename Ser, typename Clock, typename T, typename Period, typename Fnc>
+            void serialize(Ser& ser, const std::chrono::time_point<Clock, std::chrono::duration<T, Period>>& obj,
                            Fnc&& fnc) const {
                 auto res = obj.time_since_epoch().count();
                 fnc(ser, res);
             }
 
-            template<typename Des, typename Reader, typename Clock, typename T, typename Period, typename Fnc>
-            void deserialize(Des& des, Reader&, std::chrono::time_point<Clock, std::chrono::duration<T, Period>>& obj,
+            template<typename Des, typename Clock, typename T, typename Period, typename Fnc>
+            void deserialize(Des& des, std::chrono::time_point<Clock, std::chrono::duration<T, Period>>& obj,
                              Fnc&& fnc) const {
                 T res{};
                 fnc(des, res);
diff --git a/include/bitsery/ext/std_map.h b/include/bitsery/ext/std_map.h
index 5d706b1..02d42ca 100644
--- a/include/bitsery/ext/std_map.h
+++ b/include/bitsery/ext/std_map.h
@@ -37,25 +37,26 @@ namespace bitsery {
 
             constexpr explicit StdMap(size_t maxSize):_maxSize{maxSize} {}
 
-            template<typename Ser, typename Writer, typename T, typename Fnc>
-            void serialize(Ser &ser, Writer &writer, const T &obj, Fnc &&fnc) const {
+            template<typename Ser, typename T, typename Fnc>
+            void serialize(Ser &ser, const T &obj, Fnc &&fnc) const {
                 using TKey = typename T::key_type;
                 using TValue = typename T::mapped_type;
                 auto size = obj.size();
                 assert(size <= _maxSize);
-                details::writeSize(writer, size);
+                details::writeSize(ser.adapter(), size);
 
                 for (auto &v:obj)
                     fnc(ser, const_cast<TKey &>(v.first), const_cast<TValue &>(v.second));
             }
 
-            template<typename Des, typename Reader, typename T, typename Fnc>
-            void deserialize(Des &des, Reader &reader, T &obj, Fnc &&fnc) const {
+            template<typename Des, typename T, typename Fnc>
+            void deserialize(Des &des, T &obj, Fnc &&fnc) const {
                 using TKey = typename T::key_type;
                 using TValue = typename T::mapped_type;
 
                 size_t size{};
-                details::readSize(reader, size, _maxSize, std::integral_constant<bool, Reader::TConfig::CheckDataErrors>{});
+                details::readSize(des.adapter(), size, _maxSize,
+                    std::integral_constant<bool, Des::TConfig::CheckDataErrors>{});
                 obj.clear();
                 reserve(obj, size);
 
diff --git a/include/bitsery/ext/std_optional.h b/include/bitsery/ext/std_optional.h
index 7611040..ad0a708 100644
--- a/include/bitsery/ext/std_optional.h
+++ b/include/bitsery/ext/std_optional.h
@@ -40,21 +40,21 @@ namespace bitsery {
              */
             explicit StdOptional(bool alignBeforeData=true):_alignBeforeData{alignBeforeData} {}
 
-            template<typename Ser, typename Writer, typename T, typename Fnc>
-            void serialize(Ser &ser, Writer &writer, const std::optional<T> &obj, Fnc &&fnc) const {
+            template<typename Ser, typename T, typename Fnc>
+            void serialize(Ser &ser, const std::optional<T> &obj, Fnc &&fnc) const {
                 ser.boolValue(static_cast<bool>(obj));
                 if (_alignBeforeData)
-                    writer.align();
+                    ser.adapter().align();
                 if (obj)
                     fnc(ser, const_cast<T&>(*obj));
             }
 
-            template<typename Des, typename Reader, typename T, typename Fnc>
-            void deserialize(Des &des, Reader &reader, std::optional<T> &obj, Fnc &&fnc) const {
+            template<typename Des, typename T, typename Fnc>
+            void deserialize(Des &des, std::optional<T> &obj, Fnc &&fnc) const {
                 bool exists{};
                 des.boolValue(exists);
                 if (_alignBeforeData)
-                    reader.align();
+                    des.adapter().align();
                 if (exists) {
                     obj = ::bitsery::Access::create<T>();
                     fnc(des, *obj);
diff --git a/include/bitsery/ext/std_queue.h b/include/bitsery/ext/std_queue.h
index 0ffe49c..3f935fa 100644
--- a/include/bitsery/ext/std_queue.h
+++ b/include/bitsery/ext/std_queue.h
@@ -71,24 +71,24 @@ namespace bitsery {
             explicit StdQueue(size_t maxSize):_maxSize{maxSize} {};
 
             //for queue
-            template<typename Ser, typename Writer, typename T, typename C, typename Fnc>
-            void serialize(Ser &ser, Writer &, const std::queue<T,C> &obj, Fnc &&fnc) const {
+            template<typename Ser, typename T, typename C, typename Fnc>
+            void serialize(Ser &ser, const std::queue<T,C> &obj, Fnc &&fnc) const {
                 ser.container(QueueCnt<T,C>::getContainer(obj), _maxSize, std::forward<Fnc>(fnc));
             }
 
-            template<typename Des, typename Reader, typename T, typename C, typename Fnc>
-            void deserialize(Des &des, Reader &, std::queue<T,C> &obj, Fnc &&fnc) const {
+            template<typename Des, typename T, typename C, typename Fnc>
+            void deserialize(Des &des, std::queue<T,C> &obj, Fnc &&fnc) const {
                 des.container(QueueCnt<T,C>::getContainer(obj), _maxSize, std::forward<Fnc>(fnc));
             }
 
             //for priority_queue
-            template<typename Ser, typename Writer, typename T, typename C, typename Comp, typename Fnc>
-            void serialize(Ser &ser, Writer &, const std::priority_queue<T,C, Comp> &obj, Fnc &&fnc) const {
+            template<typename Ser, typename T, typename C, typename Comp, typename Fnc>
+            void serialize(Ser &ser, const std::priority_queue<T,C, Comp> &obj, Fnc &&fnc) const {
                 ser.container(PriorityQueueCnt<T,C, Comp>::getContainer(obj), _maxSize, std::forward<Fnc>(fnc));
             }
 
-            template<typename Des, typename Reader, typename T, typename C, typename Comp, typename Fnc>
-            void deserialize(Des &des, Reader &, std::priority_queue<T,C, Comp> &obj, Fnc &&fnc) const {
+            template<typename Des, typename T, typename C, typename Comp, typename Fnc>
+            void deserialize(Des &des, std::priority_queue<T,C, Comp> &obj, Fnc &&fnc) const {
                 des.container(PriorityQueueCnt<T,C, Comp>::getContainer(obj), _maxSize, std::forward<Fnc>(fnc));
             }
 
diff --git a/include/bitsery/ext/std_set.h b/include/bitsery/ext/std_set.h
index 885a8ec..b9383ca 100644
--- a/include/bitsery/ext/std_set.h
+++ b/include/bitsery/ext/std_set.h
@@ -37,23 +37,23 @@ namespace bitsery {
 
             constexpr explicit StdSet(size_t maxSize):_maxSize{maxSize} {}
 
-            template<typename Ser, typename Writer, typename T, typename Fnc>
-            void serialize(Ser &ser, Writer &writer, const T &obj, Fnc &&fnc) const {
+            template<typename Ser, typename T, typename Fnc>
+            void serialize(Ser &ser, const T &obj, Fnc &&fnc) const {
                 using TKey = typename T::key_type;
                 auto size = obj.size();
                 assert(size <= _maxSize);
-                details::writeSize(writer, size);
+                details::writeSize(ser.adapter(), size);
 
                 for (auto &v:obj)
                     fnc(ser, const_cast<TKey &>(v));
             }
 
-            template<typename Des, typename Reader, typename T, typename Fnc>
-            void deserialize(Des &des, Reader &reader, T &obj, Fnc &&fnc) const {
+            template<typename Des, typename T, typename Fnc>
+            void deserialize(Des &des, T &obj, Fnc &&fnc) const {
                 using TKey = typename T::key_type;
 
                 size_t size{};
-                details::readSize(reader, size, _maxSize, std::integral_constant<bool, Reader::TConfig::CheckDataErrors>{});
+                details::readSize(des.adapter(), size, _maxSize, std::integral_constant<bool, Des::TConfig::CheckDataErrors>{});
                 obj.clear();
                 reserve(obj, size);
                 auto hint = obj.begin();
diff --git a/include/bitsery/ext/std_stack.h b/include/bitsery/ext/std_stack.h
index 1338d59..6feba94 100644
--- a/include/bitsery/ext/std_stack.h
+++ b/include/bitsery/ext/std_stack.h
@@ -53,13 +53,13 @@ namespace bitsery {
         public:
             explicit StdStack(size_t maxSize):_maxSize{maxSize} {};
 
-            template<typename Ser, typename Writer, typename T, typename C, typename Fnc>
-            void serialize(Ser &ser, Writer &, const std::stack<T,C> &obj, Fnc &&fnc) const {
+            template<typename Ser, typename T, typename C, typename Fnc>
+            void serialize(Ser &ser, const std::stack<T,C> &obj, Fnc &&fnc) const {
                 ser.container(StackCnt<T,C>::getContainer(obj), _maxSize, std::forward<Fnc>(fnc));
             }
 
-            template<typename Des, typename Reader, typename T, typename C, typename Fnc>
-            void deserialize(Des &des, Reader &, std::stack<T,C> &obj, Fnc &&fnc) const {
+            template<typename Des, typename T, typename C, typename Fnc>
+            void deserialize(Des &des, std::stack<T,C> &obj, Fnc &&fnc) const {
                 des.container(StackCnt<T,C>::getContainer(obj), _maxSize, std::forward<Fnc>(fnc));
             }
 
diff --git a/include/bitsery/ext/std_tuple.h b/include/bitsery/ext/std_tuple.h
index 25cc578..d698243 100644
--- a/include/bitsery/ext/std_tuple.h
+++ b/include/bitsery/ext/std_tuple.h
@@ -36,13 +36,13 @@ namespace bitsery {
         class StdTuple : public details::CompositeTypeOverloadsUtils<std::tuple, Overloads...> {
         public:
 
-            template<typename Ser, typename Writer, typename Fnc, typename ...Ts>
-            void serialize(Ser& ser, Writer&, const std::tuple<Ts...>& obj, Fnc&&) const {
+            template<typename Ser, typename Fnc, typename ...Ts>
+            void serialize(Ser& ser, const std::tuple<Ts...>& obj, Fnc&&) const {
                 serializeAll(ser, const_cast<std::tuple<Ts...>&>(obj));
             }
 
-            template<typename Des, typename Reader, typename Fnc, typename ...Ts>
-            void deserialize(Des& des, Reader&, std::tuple<Ts...>& obj, Fnc&&) const {
+            template<typename Des, typename Fnc, typename ...Ts>
+            void deserialize(Des& des, std::tuple<Ts...>& obj, Fnc&&) const {
                 serializeAll(des, obj);
             }
 
diff --git a/include/bitsery/ext/std_variant.h b/include/bitsery/ext/std_variant.h
index e85c087..f5dd17f 100644
--- a/include/bitsery/ext/std_variant.h
+++ b/include/bitsery/ext/std_variant.h
@@ -36,21 +36,21 @@ namespace bitsery {
         class StdVariant : public details::CompositeTypeOverloadsUtils<std::variant, Overloads...> {
         public:
 
-            template<typename Ser, typename Writer, typename Fnc, typename ...Ts>
-            void serialize(Ser& ser, Writer& writer, const std::variant<Ts...>& obj, Fnc&&) const {
+            template<typename Ser, typename Fnc, typename ...Ts>
+            void serialize(Ser& ser, const std::variant<Ts...>& obj, Fnc&&) const {
                 auto index = obj.index();
                 assert(index != std::variant_npos);
-                details::writeSize(writer, index);
+                details::writeSize(ser.adapter(), index);
                 this->execIndex(index, const_cast<std::variant<Ts...>&>(obj), [this, &ser](auto& data, auto index) {
                     constexpr size_t Index = decltype(index)::value;
                     this->serializeType(ser, std::get<Index>(data));
                 });
             }
 
-            template<typename Des, typename Reader, typename Fnc, typename ...Ts>
-            void deserialize(Des& des, Reader& reader, std::variant<Ts...>& obj, Fnc&&) const {
+            template<typename Des, typename Fnc, typename ...Ts>
+            void deserialize(Des& des, std::variant<Ts...>& obj, Fnc&&) const {
                 size_t index{};
-                details::readSize(reader, index, sizeof...(Ts), std::integral_constant<bool, Reader::TConfig::CheckDataErrors>{});
+                details::readSize(des.adapter(), index, sizeof...(Ts), std::integral_constant<bool, Des::TConfig::CheckDataErrors>{});
                 this->execIndex(index, obj, [this, &des](auto& data, auto index) {
                     constexpr size_t Index = decltype(index)::value;
                     using TElem = typename std::variant_alternative<Index, std::variant<Ts...>>::type;
diff --git a/include/bitsery/ext/utils/pointer_utils.h b/include/bitsery/ext/utils/pointer_utils.h
index 7421e00..d9e12c1 100644
--- a/include/bitsery/ext/utils/pointer_utils.h
+++ b/include/bitsery/ext/utils/pointer_utils.h
@@ -287,29 +287,29 @@ namespace bitsery {
                     _resource{resource} {
                 }
 
-                template<typename Ser, typename Writer, typename T, typename Fnc>
-                void serialize(Ser& ser, Writer& w, const T& obj, Fnc&& fnc) const {
+                template<typename Ser, typename T, typename Fnc>
+                void serialize(Ser& ser, const T& obj, Fnc&& fnc) const {
 
                     auto ptr = TPtrManager<T>::getPtr(const_cast<T&>(obj));
                     if (ptr) {
                         auto& ctx = ser.template context<pointer_utils::PointerLinkingContextSerialization>();
                         auto& ptrInfo = ctx.getInfoByPtr(getBasePtr(ptr), TPtrManager<T>::getOwnership());
-                        details::writeSize(w, ptrInfo.id);
+                        details::writeSize(ser.adapter(), ptrInfo.id);
                         if (TPtrManager<T>::getOwnership() != PointerOwnershipType::Observer) {
                             if (!ptrInfo.isSharedProcessed)
-                                serializeImpl(ser, ptr, std::forward<Fnc>(fnc), w, IsPolymorphic<T>{});
+                                serializeImpl(ser, ptr, std::forward<Fnc>(fnc), IsPolymorphic<T>{});
                         }
                     } else {
                         assert(_ptrType == PointerType::Nullable);
-                        details::writeSize(w, 0);
+                        details::writeSize(ser.adapter(), 0);
                     }
 
                 }
 
-                template<typename Des, typename Reader, typename T, typename Fnc>
-                void deserialize(Des& des, Reader& r, T& obj, Fnc&& fnc) const {
+                template<typename Des, typename T, typename Fnc>
+                void deserialize(Des& des, T& obj, Fnc&& fnc) const {
                     size_t id{};
-                    details::readSize(r, id, 0, std::false_type{});
+                    details::readSize(des.adapter(), id, 0, std::false_type{});
                     auto& ctx = des.template context<pointer_utils::PointerLinkingContextDeserialization>();
                     auto prevResource = ctx.getMemResource();
                     auto memResource = _resource ? _resource : prevResource;
@@ -320,7 +320,7 @@ namespace bitsery {
                     }
                     if (id) {
                         auto& ptrInfo = ctx.getInfoById(id, TPtrManager<T>::getOwnership());
-                        deserializeImpl(memResource, ptrInfo, des, obj, std::forward<Fnc>(fnc), r, IsPolymorphic<T>{},
+                        deserializeImpl(memResource, ptrInfo, des, obj, std::forward<Fnc>(fnc), IsPolymorphic<T>{},
                                         OwnershipType<TPtrManager<T>::getOwnership()>{});
                     } else {
                         if (_ptrType == PointerType::Nullable) {
@@ -328,7 +328,7 @@ namespace bitsery {
                                 destroyPtr(memResource, des, obj, IsPolymorphic<T>{});
                             };
                         } else
-                            r.error(ReaderError::InvalidPointer);
+                            des.adapter().error(ReaderError::InvalidPointer);
                     }
                     if (_resource && _resourcePropagate) {
                         ctx.setMemResource(prevResource);
@@ -360,22 +360,22 @@ namespace bitsery {
                     return ptr;
                 }
 
-                template<typename Ser, typename TPtr, typename Fnc, typename Writer>
-                void serializeImpl(Ser& ser, TPtr& ptr, Fnc&&, Writer& w, std::true_type) const {
+                template<typename Ser, typename TPtr, typename Fnc>
+                void serializeImpl(Ser& ser, TPtr& ptr, Fnc&&, std::true_type) const {
                     const auto& ctx = ser.template context<TPolymorphicContext<RTTI>>();
-                    ctx.serialize(ser, w, *ptr);
+                    ctx.serialize(ser, *ptr);
                 }
 
-                template<typename Ser, typename TPtr, typename Fnc, typename Writer>
-                void serializeImpl(Ser& ser, TPtr& ptr, Fnc&& fnc, Writer&, std::false_type) const {
+                template<typename Ser, typename TPtr, typename Fnc>
+                void serializeImpl(Ser& ser, TPtr& ptr, Fnc&& fnc, std::false_type) const {
                     fnc(ser, *ptr);
                 }
 
-                template<typename Des, typename T, typename Fnc, typename Reader>
+                template<typename Des, typename T, typename Fnc>
                 void deserializeImpl(MemResourceBase* memResource, PLCInfoDeserializer& ptrInfo, Des& des, T& obj, Fnc&&,
-                                     Reader& r, std::true_type, OwnershipType<PointerOwnershipType::Owner>) const {
+                                     std::true_type, OwnershipType<PointerOwnershipType::Owner>) const {
                     const auto& ctx = des.template context<TPolymorphicContext<RTTI>>();
-                    ctx.deserialize(des, r, TPtrManager<T>::getPtr(obj),
+                    ctx.deserialize(des, TPtrManager<T>::getPtr(obj),
                                      [&obj, this, memResource](
                                          const std::shared_ptr<PolymorphicHandlerBase>& handler) {
                                          TPtrManager<T>::createPolymorphic(obj, memResource, handler);
@@ -387,9 +387,9 @@ namespace bitsery {
                     ptrInfo.processOwner(TPtrManager<T>::getPtr(obj));
                 }
 
-                template<typename Des, typename T, typename Fnc, typename Reader>
+                template<typename Des, typename T, typename Fnc>
                 void deserializeImpl(MemResourceBase* memResource, PLCInfoDeserializer& ptrInfo, Des& des, T& obj, Fnc&& fnc,
-                                     Reader&, std::false_type, OwnershipType<PointerOwnershipType::Owner>) const {
+                                     std::false_type, OwnershipType<PointerOwnershipType::Owner>) const {
                     auto ptr = TPtrManager<T>::getPtr(obj);
                     if (ptr) {
                         fnc(des, *ptr);
@@ -401,13 +401,12 @@ namespace bitsery {
                     ptrInfo.processOwner(ptr);
                 }
 
-                template<typename Des, typename T, typename Fnc, typename Reader>
+                template<typename Des, typename T, typename Fnc>
                 void deserializeImpl(MemResourceBase* memResource, PLCInfoDeserializer& ptrInfo, Des& des, T& obj, Fnc&&,
-                                     Reader& r, std::true_type,
-                                     OwnershipType<PointerOwnershipType::SharedOwner>) const {
+                                     std::true_type, OwnershipType<PointerOwnershipType::SharedOwner>) const {
                     if (!ptrInfo.sharedState) {
                         const auto& ctx = des.template context<TPolymorphicContext<RTTI>>();
-                        ctx.deserialize(des, r, TPtrManager<T>::getPtr(obj),
+                        ctx.deserialize(des, TPtrManager<T>::getPtr(obj),
                                          [&obj, &ptrInfo, memResource, this](
                                              const std::shared_ptr<PolymorphicHandlerBase>& handler) {
                                              TPtrManager<T>::createSharedPolymorphic(
@@ -425,9 +424,9 @@ namespace bitsery {
                     ptrInfo.processOwner(TPtrManager<T>::getPtr(obj));
                 }
 
-                template<typename Des, typename T, typename Fnc, typename Reader>
+                template<typename Des, typename T, typename Fnc>
                 void deserializeImpl(MemResourceBase* memResource, PLCInfoDeserializer& ptrInfo, Des& des, T& obj, Fnc&& fnc,
-                                     Reader&, std::false_type, OwnershipType<PointerOwnershipType::SharedOwner>) const {
+                                     std::false_type, OwnershipType<PointerOwnershipType::SharedOwner>) const {
                     if (!ptrInfo.sharedState) {
                         auto ptr = TPtrManager<T>::getPtr(obj);
                         if (ptr) {
@@ -444,17 +443,17 @@ namespace bitsery {
                     ptrInfo.processOwner(TPtrManager<T>::getPtr(obj));
                 }
 
-                template<typename Des, typename T, typename Fnc, typename Reader, typename isPolymorph>
+                template<typename Des, typename T, typename Fnc, typename isPolymorph>
                 void deserializeImpl(MemResourceBase* memResource, PLCInfoDeserializer& ptrInfo, Des& des, T& obj,
-                                     Fnc&& fnc, Reader& r, isPolymorph polymorph,
+                                     Fnc&& fnc, isPolymorph polymorph,
                                      OwnershipType<PointerOwnershipType::SharedObserver>) const {
-                    deserializeImpl(memResource, ptrInfo, des, obj, fnc, r, polymorph,
+                    deserializeImpl(memResource, ptrInfo, des, obj, fnc, polymorph,
                                     OwnershipType<PointerOwnershipType::SharedOwner>{});
                 }
 
-                template<typename Des, typename T, typename Fnc, typename Reader, typename isPolymorphic>
+                template<typename Des, typename T, typename Fnc, typename isPolymorphic>
                 void deserializeImpl(MemResourceBase* , PLCInfoDeserializer& ptrInfo, Des&, T& obj, Fnc&&,
-                                     Reader&, isPolymorphic, OwnershipType<PointerOwnershipType::Observer>) const {
+                                     isPolymorphic, OwnershipType<PointerOwnershipType::Observer>) const {
                     ptrInfo.processObserver(reinterpret_cast<void*&>(TPtrManager<T>::getPtrRef(obj)));
                 }
 
diff --git a/include/bitsery/ext/utils/polymorphism_utils.h b/include/bitsery/ext/utils/polymorphism_utils.h
index 4d0f398..d0233fd 100644
--- a/include/bitsery/ext/utils/polymorphism_utils.h
+++ b/include/bitsery/ext/utils/polymorphism_utils.h
@@ -226,8 +226,8 @@ namespace bitsery {
             }
 
 
-            template<typename Serializer, typename Writer, typename TBase>
-            void serialize(Serializer& ser, Writer& writer, TBase& obj) const {
+            template<typename Serializer, typename TBase>
+            void serialize(Serializer& ser, TBase& obj) const {
                 //get derived key
                 BaseToDerivedKey key{RTTI::template get<TBase>(), RTTI::template get<TBase>(obj)};
                 auto it = _baseToDerivedMap.find(key);
@@ -237,17 +237,17 @@ namespace bitsery {
                 auto& vec = _baseToDerivedArray.find(key.baseHash)->second;
                 auto derivedIndex = static_cast<size_t>(std::distance(vec.begin(), std::find(vec.begin(), vec.end(),
                                                                                              key.derivedHash)));
-                details::writeSize(writer, derivedIndex);
+                details::writeSize(ser.adapter(), derivedIndex);
 
                 //serialize
                 it->second->process(&ser, &obj);
             }
 
-            template<typename Deserializer, typename Reader, typename TBase, typename TCreateFnc, typename TDestroyFnc>
-            void deserialize(Deserializer& des, Reader& reader, TBase* obj,
+            template<typename Deserializer, typename TBase, typename TCreateFnc, typename TDestroyFnc>
+            void deserialize(Deserializer& des, TBase* obj,
                              TCreateFnc createFnc, TDestroyFnc destroyFnc) const {
                 size_t derivedIndex{};
-                details::readSize(reader, derivedIndex, 0, std::false_type{});
+                details::readSize(des.adapter(), derivedIndex, 0, std::false_type{});
 
                 auto baseToDerivedVecIt = _baseToDerivedArray.find(RTTI::template get<TBase>());
                 //base class is known at compile time, so we can assert on this one
@@ -267,7 +267,7 @@ namespace bitsery {
                     }
                     handler->process(&des, obj);
                 } else
-                    reader.error(ReaderError::InvalidPointer);
+                    des.adapter().error(ReaderError::InvalidPointer);
             }
 
             template<typename TBase>
diff --git a/include/bitsery/ext/value_range.h b/include/bitsery/ext/value_range.h
index 338f4b8..0ca92b8 100644
--- a/include/bitsery/ext/value_range.h
+++ b/include/bitsery/ext/value_range.h
@@ -167,18 +167,19 @@ namespace bitsery {
             constexpr ValueRange(const TValue& min, const TValue& max, Args &&... args)
                     :_range{min, max, std::forward<Args>(args)...} {}
 
-            template<typename Ser, typename Writer, typename T, typename Fnc>
-            void serialize(Ser &, Writer &writer, const T &v, Fnc &&) const {
+            template<typename Ser, typename T, typename Fnc>
+            void serialize(Ser &ser, const T &v, Fnc &&) const {
                 assert(details::isRangeValid(v, _range));
                 using BT = decltype(details::getRangeValue(v, _range));
-                writer.template writeBits<BT>(details::getRangeValue(v, _range), _range.bitsRequired);
+                ser.adapter().template writeBits<BT>(details::getRangeValue(v, _range), _range.bitsRequired);
             }
 
-            template<typename Des, typename Reader, typename T, typename Fnc>
-            void deserialize(Des &, Reader &reader, T &v, Fnc &&) const {
+            template<typename Des, typename T, typename Fnc>
+            void deserialize(Des &des, T &v, Fnc &&) const {
+                auto& reader = des.adapter();
                 reader.readBits(reinterpret_cast<details::SameSizeUnsigned<T> &>(v), _range.bitsRequired);
                 details::setRangeValue(v, _range);
-                handleInvalidRange(reader, v, std::integral_constant<bool, Reader::TConfig::CheckDataErrors>{});
+                handleInvalidRange(reader, v, std::integral_constant<bool, Des::TConfig::CheckDataErrors>{});
             }
 
             constexpr size_t getRequiredBits() const {
diff --git a/include/bitsery/serializer.h b/include/bitsery/serializer.h
index ad7bcf9..7ee4702 100644
--- a/include/bitsery/serializer.h
+++ b/include/bitsery/serializer.h
@@ -166,6 +166,7 @@ namespace bitsery {
         using BPEnabledType = BasicSerializer<typename std::conditional<TOutputAdapter::BitPackingEnabled,
                 TOutputAdapter,
                 details::OutputAdapterBitPackingWrapper<TOutputAdapter>>::type, TContext>;
+        using TConfig = typename TOutputAdapter::TConfig;
 
         using details::AdapterAndContextRef<TOutputAdapter, TContext>::AdapterAndContextRef;
 
@@ -230,7 +231,7 @@ namespace bitsery {
             static_assert(details::IsExtensionTraitsDefined<Ext, T>::value, "Please define ExtensionTraits");
             static_assert(traits::ExtensionTraits<Ext,T>::SupportLambdaOverload,
                           "extension doesn't support overload with lambda");
-            extension.serialize(*this, this->_adapter, obj, std::forward<Fnc>(fnc));
+            extension.serialize(*this, obj, std::forward<Fnc>(fnc));
         }
 
         template<size_t VSIZE, typename T, typename Ext>
@@ -240,7 +241,7 @@ namespace bitsery {
                           "extension doesn't support overload with `value<N>`");
             using ExtVType = typename traits::ExtensionTraits<Ext, T>::TValue;
             using VType = typename std::conditional<std::is_void<ExtVType>::value, details::DummyType, ExtVType>::type;
-            extension.serialize(*this, this->_adapter, obj, [](BasicSerializer& s, VType &v) { s.value<VSIZE>(v); });
+            extension.serialize(*this, obj, [](BasicSerializer& s, VType &v) { s.value<VSIZE>(v); });
         }
 
         template<typename T, typename Ext>
@@ -250,7 +251,7 @@ namespace bitsery {
                           "extension doesn't support overload with `object`");
             using ExtVType = typename traits::ExtensionTraits<Ext, T>::TValue;
             using VType = typename std::conditional<std::is_void<ExtVType>::value, details::DummyType, ExtVType>::type;
-            extension.serialize(*this, this->_adapter, obj, [](BasicSerializer& s, VType &v) { s.object(v); });
+            extension.serialize(*this, obj, [](BasicSerializer& s, VType &v) { s.object(v); });
         }
 
         /*