diff --git a/.gitmodules b/.gitmodules
new file mode 100644
index 0000000..8242b2f
--- /dev/null
+++ b/.gitmodules
@@ -0,0 +1,3 @@
+[submodule "modules/nlohmann_json"]
+	path = modules/nlohmann_json
+	url = https://github.com/nlohmann/json.git
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 510f932..4846caf 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -235,6 +235,7 @@ file(
     ${PROJECT_SOURCE_DIR}/include/iris/*.hpp
     ${PROJECT_SOURCE_DIR}/include/iris/*.ipp
 )
+list(FILTER IRIS_HEADERS EXCLUDE REGEX /include/iris/marshal[./])
 
 if(MSVC)
     add_custom_command(
@@ -262,6 +263,37 @@ source_group(TREE ${PROJECT_SOURCE_DIR}/include/iris PREFIX iris FILES ${IRIS_HE
 target_include_directories(iris INTERFACE ${PROJECT_SOURCE_DIR}/include)
 
 
+# -----------------------------------------------------------------
+# Additional sublibraries
+
+file(
+    GLOB_RECURSE IRIS_MARSHAL_HEADERS
+    ${PROJECT_SOURCE_DIR}/include/iris/marshal/*.hpp
+    ${PROJECT_SOURCE_DIR}/include/iris/marshal*.hpp
+)
+
+add_library(iris_marshal INTERFACE)
+add_library(Iris::Marshal ALIAS iris_marshal)
+
+target_sources(iris_marshal PRIVATE FILE_SET HEADERS TYPE HEADERS FILES ${IRIS_MARSHAL_HEADERS})
+source_group(TREE ${PROJECT_SOURCE_DIR}/include/iris PREFIX iris FILES ${IRIS_MARSHAL_HEADERS})
+
+set_target_properties(
+    iris_marshal PROPERTIES
+        CXX_EXTENSIONS OFF
+        EXCLUDE_FROM_ALL true
+        # EXCLUDE_FROM_DEFAULT_BUILD true
+)
+
+if(NOT NLOHMANN_JSON_FOUND)
+    set(JSON_BuildTests OFF CACHE INTERNAL "")
+    set(JSON_Install OFF CACHE INTERNAL "")
+    set(JSON_ImplicitConversions OFF)
+    add_subdirectory(modules/nlohmann_json EXCLUDE_FROM_ALL)
+endif()
+
+target_link_libraries(iris_marshal INTERFACE nlohmann_json::nlohmann_json Iris::Iris)
+
 # -----------------------------------------------------------------
 # Test
 
diff --git a/include/iris/marshal/adapt.hpp b/include/iris/marshal/adapt.hpp
new file mode 100644
index 0000000..2515852
--- /dev/null
+++ b/include/iris/marshal/adapt.hpp
@@ -0,0 +1,282 @@
+#ifndef IRIS_ZZ_MARSHAL_ADAPT_HPP
+#define IRIS_ZZ_MARSHAL_ADAPT_HPP
+
+// SPDX-License-Identifier: MIT
+
+#include <iris/config.hpp> // IWYU pragma: keep
+
+#include <iris/marshal/serialize_traits.hpp> // IWYU pragma: keep
+#include <iris/marshal/detail/field.hpp> // IWYU pragma: keep
+
+#include <iris/alloy/adapt.hpp> // IWYU pragma: export
+
+#include <iris/pp/tuple.hpp>
+#include <iris/pp/seq.hpp>
+#include <iris/pp/stringize.hpp>
+#include <iris/pp/cat.hpp>
+#include <iris/pp/arg.hpp>
+
+#include <type_traits>
+
+namespace iris::marshal {
+
+namespace detail {
+
+template<class T>
+struct is_value_semantics_preferred : std::false_type
+{};
+
+template<class T>
+    requires
+        std::is_arithmetic_v<T> ||
+        std::is_reference_v<T> ||
+        std::is_pointer_v<T> ||
+        std::is_enum_v<T>
+struct is_value_semantics_preferred<T> : std::true_type
+{};
+
+template<class T>
+using getter_return_t = std::conditional_t<
+    is_value_semantics_preferred<T>::value,
+    T,
+    T const&
+>;
+
+template<class T>
+using setter_param_t = std::conditional_t<
+    is_value_semantics_preferred<T>::value,
+    T,
+    T const&
+>;
+
+} // detail
+
+
+#define IRIS_ZZ_MARSHAL_FIELD_EXPAND_CLASS_QUALIFIED_SCOPE(class_name) class_name::
+#define IRIS_ZZ_MARSHAL_FIELD_EXPAND_DECLARE_ONLY(...) ;
+#define IRIS_ZZ_MARSHAL_FIELD_EXPAND_BODY(...) __VA_ARGS__
+
+#define IRIS_ZZ_MARSHAL_FIELD_DATA_MEMBER_NAME(field_name) field_name ## _
+
+#define IRIS_ZZ_MARSHAL_FIELD_DATA_MEMBER(maybe_paren_type, field_name, ...) \
+    private: \
+        IRIS_PP_UNPAREN_IF_PAREN(maybe_paren_type) IRIS_ZZ_MARSHAL_FIELD_DATA_MEMBER_NAME(field_name){__VA_ARGS__};
+
+#define IRIS_ZZ_MARSHAL_FIELD_GETTER(class_name, maybe_paren_type, field_name, variable_name_macro, body_macro, access_mod_macro, qualified_scope_macro) \
+    access_mod_macro(public:) \
+        [[nodiscard]] iris::marshal::detail::getter_return_t<IRIS_PP_UNPAREN_IF_PAREN(maybe_paren_type)> \
+        qualified_scope_macro(class_name) IRIS_PP_CAT(get_, field_name) () const noexcept \
+        body_macro({ \
+            return variable_name_macro(field_name); \
+        })
+
+#define IRIS_ZZ_MARSHAL_FIELD_GETTER_BOOL(class_name, maybe_paren_type, field_name, variable_name_macro, body_macro, access_mod_macro, qualified_scope_macro) \
+    access_mod_macro(public:) \
+        [[nodiscard]] bool qualified_scope_macro(class_name) IRIS_PP_CAT(is_, field_name) () const noexcept \
+        body_macro({ \
+            return variable_name_macro(field_name); \
+        }) \
+    \
+    access_mod_macro(private:) \
+        [[nodiscard]] bool qualified_scope_macro(class_name) IRIS_PP_CAT(get_, field_name) () const noexcept \
+        body_macro({ \
+            return variable_name_macro(field_name); \
+        })
+
+#define IRIS_ZZ_MARSHAL_FIELD_SETTER(class_name, maybe_paren_type, field_name, variable_name_macro, body_macro, access_mod_macro, qualified_scope_macro) \
+    access_mod_macro(public:) \
+        void qualified_scope_macro(class_name) IRIS_PP_CAT(set_, field_name) (iris::marshal::detail::setter_param_t<IRIS_PP_UNPAREN_IF_PAREN(maybe_paren_type)> new_value) \
+            noexcept(std::is_nothrow_copy_assignable_v<IRIS_PP_UNPAREN_IF_PAREN(maybe_paren_type)>) \
+        body_macro({ \
+            variable_name_macro(field_name) = new_value; \
+        })
+
+
+// Default value for bool field is mandatory because it is error prone if omitted
+#define IRIS_ZZ_MARSHAL_FIELD_BOOL_GET(class_name, maybe_paren_type, field_name, variable_name_macro, body_macro, access_mod_macro, qualified_scope_macro) \
+    IRIS_ZZ_MARSHAL_FIELD_GETTER_BOOL(class_name, maybe_paren_type, field_name, variable_name_macro, body_macro, access_mod_macro, qualified_scope_macro)
+
+// Default value for bool field is mandatory because it is error prone if omitted
+#define IRIS_ZZ_MARSHAL_FIELD_BOOL_GET_SET(class_name, maybe_paren_type, field_name, variable_name_macro, body_macro, access_mod_macro, qualified_scope_macro) \
+    IRIS_ZZ_MARSHAL_FIELD_GETTER_BOOL(class_name, maybe_paren_type, field_name, variable_name_macro, body_macro, access_mod_macro, qualified_scope_macro) \
+    IRIS_ZZ_MARSHAL_FIELD_SETTER(class_name, maybe_paren_type, field_name, variable_name_macro, body_macro, access_mod_macro, qualified_scope_macro)
+
+
+#define IRIS_ZZ_MARSHAL_FIELD_TYPE_IS_bool (bool)
+
+#define IRIS_ZZ_MARSHAL_FIELD_GET_I(class_name, maybe_paren_type, field_name, variable_name_macro, body_macro, access_mod_macro, qualified_scope_macro) \
+    IRIS_ZZ_MARSHAL_FIELD_GETTER(class_name, maybe_paren_type, field_name, variable_name_macro, body_macro, access_mod_macro, qualified_scope_macro)
+
+#define IRIS_MARSHAL_FIELD_GET(maybe_paren_type, field_name, ...) \
+    IRIS_ZZ_MARSHAL_FIELD_DATA_MEMBER(maybe_paren_type, field_name, __VA_ARGS__) \
+    IRIS_PP_IF( \
+        IRIS_PP_IS_PAREN( IRIS_PP_CAT_ONLY_TWO(IRIS_ZZ_MARSHAL_FIELD_TYPE_IS_, IRIS_PP_UNPAREN_IF_PAREN(maybe_paren_type)) ), \
+        IRIS_ZZ_MARSHAL_FIELD_BOOL_GET, \
+        IRIS_ZZ_MARSHAL_FIELD_GET_I \
+    ) (~, maybe_paren_type, field_name, IRIS_ZZ_MARSHAL_FIELD_DATA_MEMBER_NAME, IRIS_ZZ_MARSHAL_FIELD_EXPAND_BODY, IRIS_PP_IDENTITY, IRIS_PP_EMPTY)
+
+#define IRIS_ZZ_MARSHAL_FIELD_GET_SET_I(class_name, maybe_paren_type, field_name, variable_name_macro, body_macro, access_mod_macro, qualified_scope_macro) \
+    IRIS_ZZ_MARSHAL_FIELD_GETTER(class_name, maybe_paren_type, field_name, variable_name_macro, body_macro, access_mod_macro, qualified_scope_macro) \
+    IRIS_ZZ_MARSHAL_FIELD_SETTER(class_name, maybe_paren_type, field_name, variable_name_macro, body_macro, access_mod_macro, qualified_scope_macro)
+
+#define IRIS_MARSHAL_FIELD_GET_SET(maybe_paren_type, field_name, ...) \
+    IRIS_ZZ_MARSHAL_FIELD_DATA_MEMBER(maybe_paren_type, field_name, __VA_ARGS__) \
+    IRIS_PP_IF( \
+        IRIS_PP_IS_PAREN( IRIS_PP_CAT_ONLY_TWO(IRIS_ZZ_MARSHAL_FIELD_TYPE_IS_, IRIS_PP_UNPAREN_IF_PAREN(maybe_paren_type)) ), \
+        IRIS_ZZ_MARSHAL_FIELD_BOOL_GET_SET, \
+        IRIS_ZZ_MARSHAL_FIELD_GET_SET_I \
+    ) (~, maybe_paren_type, field_name, IRIS_ZZ_MARSHAL_FIELD_DATA_MEMBER_NAME, IRIS_ZZ_MARSHAL_FIELD_EXPAND_BODY, IRIS_PP_IDENTITY, IRIS_PP_EMPTY)
+
+#define IRIS_MARSHAL_FIELD(maybe_paren_type, field_name, ...) \
+    IRIS_MARSHAL_FIELD_GET_SET(maybe_paren_type, field_name, __VA_ARGS__)
+
+
+#define IRIS_ZZ_MARSHAL_CLASS_COMMON(class_name) \
+    public: \
+        template<class ClassT> \
+        friend struct ::iris::marshal::adapted_class_traits;
+
+#define IRIS_MARSHAL_CLASS(class_name) \
+    IRIS_ZZ_MARSHAL_CLASS_COMMON(class_name) \
+    public: \
+        [[nodiscard]] constexpr bool operator==(class_name const&) const noexcept = default;
+
+#define IRIS_MARSHAL_PIMPL_CLASS(class_name) \
+    IRIS_ZZ_MARSHAL_CLASS_COMMON(class_name) \
+    public: \
+        class_name(); \
+        class_name(class_name const&) = delete; \
+        class_name(class_name&&) noexcept; \
+        ~class_name(); \
+    \
+        class_name& operator=(class_name const&) = delete; \
+        class_name& operator=(class_name&&) noexcept; \
+    \
+    private: \
+        struct Impl; \
+        std::unique_ptr<Impl> impl_; \
+    \
+    public:
+
+// ------------------------------------------------------------
+// pimpl declare
+
+#define IRIS_ZZ_MARSHAL_PIMPL_FIELD_DECLARE_FIELD_I(maybe_paren_type, field_name, ...) \
+    IRIS_PP_IF( \
+        IRIS_PP_IS_PAREN( IRIS_PP_CAT_ONLY_TWO(IRIS_ZZ_MARSHAL_FIELD_TYPE_IS_, IRIS_PP_UNPAREN_IF_PAREN(maybe_paren_type)) ), \
+        IRIS_ZZ_MARSHAL_FIELD_BOOL_GET_SET, \
+        IRIS_ZZ_MARSHAL_FIELD_GET_SET_I \
+    ) (~, maybe_paren_type, field_name, IRIS_PP_EMPTY, IRIS_ZZ_MARSHAL_FIELD_EXPAND_DECLARE_ONLY, IRIS_PP_IDENTITY, IRIS_PP_EMPTY)
+
+#define IRIS_ZZ_MARSHAL_PIMPL_FIELD_DECLARE_I(field_def, macro_data) \
+    IRIS_ZZ_MARSHAL_PIMPL_FIELD_DECLARE_FIELD_I field_def
+
+#define IRIS_MARSHAL_PIMPL_FIELD_DECLARE(field_defs) \
+    IRIS_PP_SEQ_FOR_EACH(field_defs, IRIS_ZZ_MARSHAL_PIMPL_FIELD_DECLARE_I, ~)
+
+// ------------------------------------------------------------
+// pimpl define
+
+#define IRIS_ZZ_MARSHAL_PIMPL_FIELD_DATA_MEMBER(maybe_paren_type, field_name, ...) \
+    public: \
+        IRIS_PP_UNPAREN_IF_PAREN(maybe_paren_type) field_name{__VA_ARGS__};
+
+#define IRIS_ZZ_MARSHAL_PIMPL_FIELD_DEFS_I(field_def, macro_data) \
+    IRIS_ZZ_MARSHAL_PIMPL_FIELD_DATA_MEMBER field_def
+
+#define IRIS_MARSHAL_PIMPL_FIELD_DEFS(field_defs) \
+    IRIS_PP_SEQ_FOR_EACH(field_defs, IRIS_ZZ_MARSHAL_PIMPL_FIELD_DEFS_I, ~)
+
+
+#define IRIS_ZZ_MARSHAL_PIMPL_FIELD_VARIABLE(field_name) impl_->field_name
+
+#define IRIS_ZZ_MARSHAL_PIMPL_FIELD_ACCESS_DEFINE_FIELD_I(class_name, maybe_paren_type, field_name, ...) \
+    IRIS_PP_IF( \
+        IRIS_PP_IS_PAREN( IRIS_PP_CAT_ONLY_TWO(IRIS_ZZ_MARSHAL_FIELD_TYPE_IS_, IRIS_PP_UNPAREN_IF_PAREN(maybe_paren_type)) ), \
+        IRIS_ZZ_MARSHAL_FIELD_BOOL_GET_SET, \
+        IRIS_ZZ_MARSHAL_FIELD_GET_SET_I \
+    ) (class_name, maybe_paren_type, field_name, IRIS_ZZ_MARSHAL_PIMPL_FIELD_VARIABLE, IRIS_ZZ_MARSHAL_FIELD_EXPAND_BODY, IRIS_PP_EMPTY, IRIS_ZZ_MARSHAL_FIELD_EXPAND_CLASS_QUALIFIED_SCOPE)
+
+#define IRIS_ZZ_CONCAT_TUPLE_1_3_II(class_name, ...) (class_name, __VA_ARGS__)
+
+#define IRIS_ZZ_CONCAT_TUPLE_1_3_I(class_name, ...) \
+    IRIS_ZZ_CONCAT_TUPLE_1_3_II(class_name, __VA_ARGS__)
+
+#define IRIS_ZZ_CONCAT_TUPLE_1_3(class_name, field_def) \
+    IRIS_ZZ_CONCAT_TUPLE_1_3_I(class_name, IRIS_PP_EXPAND field_def)
+
+#define IRIS_ZZ_MARSHAL_PIMPL_INVOKE(...) __VA_ARGS__
+
+#define IRIS_ZZ_MARSHAL_PIMPL_FIELD_ACCESS_DEFINE_I(field_def, class_name) \
+    IRIS_ZZ_MARSHAL_PIMPL_INVOKE( \
+        IRIS_ZZ_MARSHAL_PIMPL_FIELD_ACCESS_DEFINE_FIELD_I \
+        IRIS_ZZ_CONCAT_TUPLE_1_3(class_name, field_def) \
+    )
+
+#define IRIS_MARSHAL_PIMPL_FIELD_ACCESS_DEFINE(class_name, field_defs) \
+    IRIS_PP_SEQ_FOR_EACH(field_defs, IRIS_ZZ_MARSHAL_PIMPL_FIELD_ACCESS_DEFINE_I, class_name)
+
+
+#define IRIS_MARSHAL_PIMPL_CLASS_DEFINE(class_name) \
+    class_name::class_name() : impl_(std::make_unique<Impl>()) {} \
+    class_name::class_name(class_name&&) noexcept = default; \
+    class_name::~class_name() = default; \
+    class_name& class_name::operator=(class_name&&) noexcept = default;
+
+// ------------------------------------------------------------
+
+#define IRIS_ZZ_MARSHAL_SELECT_FIELD_TYPE(class_name, field_name) typename decltype([]<class ClassT>() consteval { \
+        if constexpr (requires { &ClassT::field_name; }) { \
+            return std::type_identity<decltype(ClassT::field_name)>{}; \
+        } else { \
+            return std::type_identity<std::remove_cvref_t<decltype(std::invoke(&ClassT::IRIS_PP_CAT(get_, field_name), std::declval<ClassT const&>()))>>{}; \
+        } \
+    }.template operator()<class_name>())::type
+
+// Select `&class_name::field_name` if it exists; otherwise `&class_name::(get|set)_field_name`
+#define IRIS_ZZ_MARSHAL_SELECT_MEMBER_ACCESS(class_name, field_name, access) []<class ClassT>() consteval { \
+        if constexpr (requires { &ClassT::field_name; }) { \
+            return &ClassT::field_name; \
+        } else { \
+            return &ClassT::IRIS_PP_CAT(access ## _, field_name); \
+        } \
+    }.template operator()<class_name>()
+
+#define IRIS_ZZ_MARSHAL_ADAPT_FIELD(field_name, class_name) \
+    ::iris::marshal::detail::field_definition< \
+        IRIS_ZZ_MARSHAL_SELECT_FIELD_TYPE(class_name, field_name), \
+        IRIS_ZZ_MARSHAL_SELECT_MEMBER_ACCESS(class_name, field_name, get), \
+        IRIS_ZZ_MARSHAL_SELECT_MEMBER_ACCESS(class_name, field_name, set) \
+    >{IRIS_PP_STRINGIZE(field_name)},
+
+#define IRIS_ZZ_MARSHAL_ADAPT_I(class_name, field_defs) \
+    template<> \
+    struct iris::marshal::adapted_class_traits<class_name> \
+    { \
+        inline static constexpr auto fields = ::iris::alloy::tuple{ \
+            IRIS_PP_SEQ_FOR_EACH( \
+                field_defs, \
+                IRIS_ZZ_MARSHAL_ADAPT_FIELD, \
+                class_name \
+            ) \
+        }; \
+    };
+
+#define IRIS_MARSHAL_ADAPT(class_name, ...) \
+    IRIS_ZZ_MARSHAL_ADAPT_I( \
+        class_name, \
+        IRIS_PP_TUPLE_TO_SEQ((__VA_ARGS__)) \
+    )
+
+#define IRIS_ZZ_MARSHAL_ADAPT_DEFS_EXTRACT_FIELD_NAME(field_def, macro_data) \
+    (IRIS_PP_TUPLE_ELEM(1, field_def))
+
+#define IRIS_MARSHAL_ADAPT_DEFS(class_name, field_defs) \
+    IRIS_ZZ_MARSHAL_ADAPT_I( \
+        class_name, \
+        IRIS_PP_SEQ_FOR_EACH(field_defs, IRIS_ZZ_MARSHAL_ADAPT_DEFS_EXTRACT_FIELD_NAME, ~) \
+    )
+
+} // iris::marshal
+
+#endif
diff --git a/include/iris/marshal/detail/field.hpp b/include/iris/marshal/detail/field.hpp
new file mode 100644
index 0000000..35b9234
--- /dev/null
+++ b/include/iris/marshal/detail/field.hpp
@@ -0,0 +1,40 @@
+#ifndef IRIS_ZZ_MARSHAL_DETAIL_FIELD_HPP
+#define IRIS_ZZ_MARSHAL_DETAIL_FIELD_HPP
+
+// SPDX-License-Identifier: MIT
+
+#include <iris/config.hpp> // IWYU pragma: keep
+
+#include <string_view>
+#include <functional>
+#include <utility>
+#include <type_traits>
+
+namespace iris::marshal::detail {
+
+template<class FieldT, auto GetMem, auto SetMem>
+struct field_definition
+{
+    using value_type = FieldT;
+    std::string_view name;
+
+    template<class ClassT>
+    [[nodiscard]] static constexpr decltype(auto) get(ClassT const& klass) noexcept
+    {
+        return std::invoke(GetMem, klass);
+    }
+
+    template<class ClassT, class T>
+    static constexpr void set(ClassT& klass, T&& value)
+    {
+        if constexpr (std::is_member_object_pointer_v<decltype(SetMem)>) {
+            (klass.*SetMem) = std::forward<T>(value);
+        } else {
+            std::invoke(SetMem, klass, std::forward<T>(value));
+        }
+    }
+};
+
+} // iris::marshal::detail
+
+#endif
diff --git a/include/iris/marshal/serialize.hpp b/include/iris/marshal/serialize.hpp
new file mode 100644
index 0000000..ef026bc
--- /dev/null
+++ b/include/iris/marshal/serialize.hpp
@@ -0,0 +1,369 @@
+#ifndef IRIS_ZZ_MARSHAL_SERIALIZE_HPP
+#define IRIS_ZZ_MARSHAL_SERIALIZE_HPP
+
+// SPDX-License-Identifier: MIT
+
+#include <iris/config.hpp> // IWYU pragma: keep
+
+#include <iris/marshal/serialize_traits.hpp>
+#include <iris/marshal/detail/field.hpp>
+
+#include <iris/alloy/utility.hpp>
+
+#include <string_view>
+#include <bitset>
+
+namespace iris::marshal {
+
+struct load_error : std::runtime_error
+{
+    using std::runtime_error::runtime_error;
+};
+
+
+template<class WriterT>
+concept writer =
+    requires {
+        typename WriterT::format;
+    } &&
+    requires(WriterT& wr, std::string_view map_key) {
+        wr.null();
+        wr.begin_array();
+        wr.end_array();
+        wr.begin_object();
+        wr.map_key(map_key);
+        wr.end_object();
+    };
+
+template<writer WriterT>
+struct basic_save_fn
+{
+    using format = WriterT::format;
+
+    template<serializable<format> T>
+        requires requires {
+            typename WriterT::document_type;
+        } && std::constructible_from<WriterT, typename WriterT::document_type&>
+    static constexpr void operator()(WriterT::document_type& res, T const& value)
+    {
+        WriterT wr{res};
+        basic_save_fn{}(wr, value);
+    }
+
+    template<serializable_scalar<format> T>
+        requires requires(WriterT& wr, T const& value) { wr.scalar(value); }
+    static constexpr void operator()(WriterT& wr, T const& value)
+    {
+        wr.scalar(value);
+    }
+
+    template<serializable_optional<format> OptionalT>
+    static constexpr void operator()(WriterT& wr, OptionalT const& opt)
+    {
+        if (opt) {
+            basic_save_fn{}(wr, *opt);
+        } else {
+            wr.null();
+        }
+    }
+
+    template<serializable_proxy<format> ProxyT>
+    static constexpr void operator()(WriterT& wr, ProxyT const& proxy)
+    {
+        basic_save_fn{}(wr, adapted_proxy_traits<ProxyT, format>::to_native_type(proxy));
+    }
+
+    template<serializable_array<format> R>
+    static constexpr void operator()(WriterT& wr, R const& arr)
+    {
+        wr.begin_array();
+        for (auto const& elem : arr) {
+            basic_save_fn{}(wr, elem);
+        }
+        wr.end_array();
+    }
+
+    template<serializable_map<format> MapT>
+    static constexpr void operator()(WriterT& wr, MapT const& map)
+    {
+        wr.begin_object();
+        for (auto const& [k, v] : map) {
+            if constexpr (adapted_proxy<ranges::range_key_t<MapT>, format>) {
+                wr.map_key(adapted_proxy_traits<ranges::range_key_t<MapT>, format>::to_native_type(k));
+            } else {
+                wr.map_key(k);
+            }
+            basic_save_fn{}(wr, v);
+        }
+        wr.end_object();
+    }
+
+    template<serializable_tuple<format> TupleT>
+    static constexpr void operator()(WriterT& wr, TupleT const& tup)
+    {
+        wr.begin_array();
+        alloy::for_each(tup, [&](auto const& elem) {
+            basic_save_fn{}(wr, elem);
+        });
+        wr.end_array();
+    }
+
+    template<serializable_class<format> ClassT>
+    static constexpr void operator()(WriterT& wr, ClassT const& klass)
+    {
+        wr.begin_object();
+        constexpr auto const& fields = adapted_class_traits<ClassT>::fields;
+        alloy::for_each(fields, [&]<class FieldT, auto GetMem, auto SetMem>(detail::field_definition<FieldT, GetMem, SetMem> const& def) {
+            if constexpr (adapted_proxy<decltype(def.name), format>) {
+                wr.map_key(adapted_proxy_traits<decltype(def.name), format>::to_native_type(def.name));
+            } else {
+                wr.map_key(def.name);
+            }
+            basic_save_fn{}(wr, def.get(klass));
+        });
+        wr.end_object();
+    }
+};
+
+
+namespace detail {
+
+struct noop_element_visitor
+{
+    template<class R>
+    void operator()(R&) const
+    {}
+};
+struct noop_member_visitor
+{
+    template<class R>
+    void operator()(std::string_view, R&) const
+    {}
+};
+
+} // detail
+
+template<class ReaderT>
+concept reader =
+    requires {
+        typename ReaderT::format;
+    } &&
+    requires(ReaderT& rd) {
+        { rd.is_null() } -> std::convertible_to<bool>;
+        { rd.array(detail::noop_element_visitor{}) } -> std::convertible_to<bool>;
+        { rd.object(detail::noop_member_visitor{}) } -> std::convertible_to<bool>;
+    };
+
+template<reader ReaderT>
+struct basic_load_fn
+{
+    using format = ReaderT::format;
+
+    template<class T>
+        requires
+            requires { typename ReaderT::document_type; } &&
+            std::constructible_from<ReaderT, typename ReaderT::document_type const&> &&
+            deserializable<T, format>
+    static constexpr void operator()(ReaderT::document_type const& doc, T& value)
+    {
+        ReaderT rd{doc};
+        basic_load_fn{}(rd, value);
+    }
+
+    template<deserializable_scalar<format> T>
+        requires requires(ReaderT& rd, T& value) {
+            { rd.scalar(value) } -> std::convertible_to<bool>;
+        }
+    static constexpr void operator()(ReaderT& rd, T& value)
+    {
+        if (!rd.scalar(value)) {
+            throw load_error{"scalar: kind mismatch"};
+        }
+    }
+
+    template<deserializable_optional<format> OptionalT>
+    static constexpr void operator()(ReaderT& rd, OptionalT& opt)
+    {
+        using value_type = adapted_optional_traits<OptionalT>::value_type;
+
+        if (rd.is_null()) {
+            opt = OptionalT{};
+            return;
+        }
+
+        value_type tmp{};
+        basic_load_fn{}(rd, tmp);
+        opt = std::move(tmp);
+    }
+
+    template<deserializable_proxy<format> ProxyT>
+    static constexpr void operator()(ReaderT& rd, ProxyT& proxy)
+    {
+        using native_type = adapted_proxy_traits<ProxyT, format>::native_type;
+
+        native_type tmp{};
+        basic_load_fn{}(rd, tmp);
+        proxy = adapted_proxy_traits<ProxyT, format>::from_native_type(std::move(tmp));
+    }
+
+    template<deserializable_array<format> R>
+        requires ranges::growable_array_writable<R&>
+    static constexpr void operator()(ReaderT& rd, R& arr)
+    {
+        R tmp{};
+
+        bool const ok = rd.array([&](ReaderT& elem_rd) {
+            std::ranges::range_value_t<R> elem{};
+            basic_load_fn{}(elem_rd, elem);
+
+            if constexpr (ranges::back_emplaceable<R>) {
+                tmp.emplace_back(std::move(elem));
+            } else {
+                tmp.emplace(std::move(elem));
+            }
+        });
+
+        if (!ok) {
+            throw load_error{"array: kind mismatch"};
+        }
+
+        arr = std::move(tmp);
+    }
+
+    template<deserializable_array<format> R>
+        requires ranges::fixed_array_writable<R&>
+    static constexpr void operator()(ReaderT& rd, R& arr)
+    {
+        auto it = std::ranges::begin(arr);
+        auto const last = std::ranges::end(arr);
+
+        bool const ok = rd.array([&](ReaderT& elem_rd) {
+            if (it == last) {
+                throw load_error{"array: too many elements"};
+            }
+            basic_load_fn{}(elem_rd, *it);
+            ++it;
+        });
+
+        if (!ok) {
+            throw load_error{"array: kind mismatch"};
+        }
+        if (it != last) {
+            throw load_error{"array: too few elements"};
+        }
+    }
+
+    template<deserializable_map<format> MapT>
+    static constexpr void operator()(ReaderT& rd, MapT& map)
+    {
+        using key_type    = MapT::key_type;
+        using mapped_type = MapT::mapped_type;
+
+        MapT tmp{};
+
+        bool const ok = rd.object([&](std::string_view map_key, ReaderT& member_rd) {
+            key_type k = [&] {
+                if constexpr (adapted_proxy<key_type, format>) {
+                    using native_type = adapted_proxy_traits<key_type, format>::native_type;
+                    return adapted_proxy_traits<key_type, format>::from_native_type(native_type{map_key});
+                } else {
+                    return key_type{map_key};
+                }
+            }();
+
+            mapped_type v{};
+            basic_load_fn{}(member_rd, v);
+
+            if constexpr (ranges::unique_mapping_container<MapT>) {
+                if (!tmp.try_emplace(std::move(k), std::move(v)).second) {
+                    throw load_error{"object: duplicate key"};
+                }
+            } else {
+                tmp.emplace(std::move(k), std::move(v));
+            }
+        });
+
+        if (!ok) {
+            throw load_error{"object: kind mismatch"};
+        }
+        map = std::move(tmp);
+    }
+
+    template<deserializable_tuple<format> TupleT>
+    static constexpr void operator()(ReaderT& rd, TupleT& tup)
+    {
+        constexpr std::size_t size = alloy::tuple_size_v<TupleT>;
+        std::size_t i = 0;
+
+        bool const ok = rd.array([&](ReaderT& elem_rd) {
+            if (i >= size) {
+                throw load_error{"tuple: too many elements"};
+            }
+            alloy::visit_at(i, [&](auto& elem) {
+                basic_load_fn{}(elem_rd, elem);
+            }, tup);
+            ++i;
+        });
+
+        if (!ok) {
+            throw load_error{"tuple: kind mismatch"};
+        }
+        if (i != size) {
+            throw load_error{"tuple: too few elements"};
+        }
+    }
+
+    template<deserializable_class<format> ClassT>
+    static constexpr void operator()(ReaderT& rd, ClassT& klass)
+    {
+        constexpr auto const& fields = adapted_class_traits<ClassT>::fields;
+
+        std::bitset<alloy::tuple_size_v<std::remove_cvref_t<decltype(fields)>>>
+        seen;
+
+        bool const ok = rd.object([&](std::string_view map_key, ReaderT& member_rd) {
+            std::size_t index = 0;
+            bool matched = false;
+
+            alloy::for_each(fields, [&]<class FieldT, auto GetMem, auto SetMem>(detail::field_definition<FieldT, GetMem, SetMem> const& def) {
+                if (!matched && basic_load_fn::field_name_matches(def.name, map_key)) {
+                    FieldT tmp{};
+                    basic_load_fn{}(member_rd, tmp);
+                    def.set(klass, std::move(tmp));
+
+                    seen.set(index);
+                    matched = true;
+                }
+                ++index;
+            });
+            // unmatched `map_key` is ignored ...
+        });
+
+        if (!ok) {
+            throw load_error{"object: kind mismatch"};
+        }
+
+        std::size_t index = 0;
+        alloy::for_each(fields, [&](auto&& /* def */) {
+            if (!seen.test(index)) {
+                throw load_error{"object: missing required field"};
+            }
+            ++index;
+        });
+    }
+
+private:
+    template<class NameT>
+    [[nodiscard]] static constexpr bool field_name_matches(NameT const& name, std::string_view map_key)
+    {
+        if constexpr (adapted_proxy<NameT, format>) {
+            return adapted_proxy_traits<NameT, format>::to_native_type(name) == map_key;
+        } else {
+            return name == map_key;
+        }
+    }
+};
+
+} // iris::marshal
+
+#endif
diff --git a/include/iris/marshal/serialize_json.hpp b/include/iris/marshal/serialize_json.hpp
new file mode 100644
index 0000000..0d32a43
--- /dev/null
+++ b/include/iris/marshal/serialize_json.hpp
@@ -0,0 +1,242 @@
+#ifndef IRIS_ZZ_MARSHAL_SERIALIZE_JSON_HPP
+#define IRIS_ZZ_MARSHAL_SERIALIZE_JSON_HPP
+
+// SPDX-License-Identifier: MIT
+
+#include <iris/config.hpp> // IWYU pragma: keep
+
+#include <iris/marshal/serialize.hpp>
+
+#include <iris/unicode/string.hpp>
+
+#include <iris/string.hpp>
+
+#include <nlohmann/json.hpp>
+
+#include <vector>
+#include <string>
+#include <string_view>
+#include <utility>
+#include <type_traits>
+
+namespace iris::marshal::json {
+
+struct format : generic_format
+{
+    template<class K>
+    static constexpr bool map_key = StringLike<K>;
+
+    template<class K>
+    static constexpr bool loadable_key = StringLike<K>;
+};
+
+} // iris::marshal::json
+
+namespace iris::marshal {
+
+template<StringLike T>
+    requires (!std::same_as<char_type_for<T>, char>)
+struct adapted_proxy_traits<T, json::format>
+{
+    using native_type = std::string;
+
+    [[nodiscard]] static native_type const& to_native_type(native_type const& t) noexcept
+    {
+        return t;
+    }
+
+    [[nodiscard]] static native_type to_native_type(native_type const&& t)
+    {
+        return t;
+    }
+
+    [[nodiscard]] static native_type to_native_type(StringLike auto const& u)
+    {
+        return unicode::transcode<char>(u);
+    }
+
+    [[nodiscard]] static T from_native_type(native_type const& t)
+    {
+        return unicode::transcode<typename decltype(std::basic_string_view{std::declval<T>()})::value_type>(t);
+    }
+};
+
+} // iris::marshal
+
+namespace iris::marshal::json {
+
+template<class T> concept serializable_proxy    = marshal::serializable_proxy<T, format>;
+template<class T> concept serializable_class    = marshal::serializable_class<T, format>;
+template<class T> concept serializable_optional = marshal::serializable_optional<T, format>;
+template<class T> concept serializable_scalar   = marshal::serializable_scalar<T, format>;
+template<class T> concept serializable_map      = marshal::serializable_map<T, format>;
+template<class T> concept serializable_array    = marshal::serializable_array<T, format>;
+template<class T> concept serializable_tuple    = marshal::serializable_tuple<T, format>;
+template<class T> concept serializable          = marshal::serializable<T, format>;
+
+template<class T> concept deserializable_proxy    = marshal::deserializable_proxy<T, format>;
+template<class T> concept deserializable_class    = marshal::deserializable_class<T, format>;
+template<class T> concept deserializable_optional = marshal::deserializable_optional<T, format>;
+template<class T> concept deserializable_scalar   = marshal::deserializable_scalar<T, format>;
+template<class T> concept deserializable_map      = marshal::deserializable_map<T, format>;
+template<class T> concept deserializable_array    = marshal::deserializable_array<T, format>;
+template<class T> concept deserializable_tuple    = marshal::deserializable_tuple<T, format>;
+template<class T> concept deserializable          = marshal::deserializable<T, format>;
+
+class dom_writer
+{
+public:
+    using format = json::format;
+    using document_type = nlohmann::json;
+
+    explicit dom_writer(document_type& node)
+        : node_(&node)
+    {}
+
+    template<class T>
+        requires format::template loadable_scalar<T>
+    void scalar(T const& value)
+    {
+        if constexpr (std::is_enum_v<T>) {
+            slot() = std::to_underlying(value);
+        } else {
+            slot() = value;
+        }
+    }
+
+    void null()
+    {
+        slot() = nullptr;
+    }
+
+    void begin_array()
+    {
+        stack_.push_back(&(slot() = document_type::array()));
+    }
+    void end_array()
+    {
+        stack_.pop_back();
+    }
+
+    void begin_object()
+    {
+        stack_.push_back(&(slot() = document_type::object()));
+    }
+    void map_key(std::string_view k)
+    {
+        pending_key_.assign(k);
+    }
+    void end_object()
+    {
+        stack_.pop_back();
+    }
+
+private:
+    [[nodiscard]] document_type& slot()
+    {
+        if (stack_.empty()) return *node_;
+        auto& parent = *stack_.back();
+        return parent.is_object() ? parent[pending_key_] : parent.emplace_back();
+    }
+
+    nlohmann::json* node_;
+    std::vector<nlohmann::json*> stack_;
+    std::string pending_key_;
+};
+
+[[maybe_unused]] inline constexpr basic_save_fn<dom_writer> save{};
+
+
+class dom_reader
+{
+public:
+    using format = json::format;
+    using document_type = nlohmann::json;
+
+    explicit dom_reader(document_type const& node)
+        : node_{&node}
+    {}
+
+    [[nodiscard]] bool is_null() const
+    {
+        return node_->is_null();
+    }
+
+    template<class T>
+        requires format::template loadable_scalar<T>
+    [[nodiscard]] bool scalar(T& value) const
+    {
+        if constexpr (std::same_as<T, bool>) {
+            if (!node_->is_boolean()) return false;
+            value = node_->get<bool>();
+
+        } else if constexpr (std::is_integral_v<T>) {
+            if (!node_->is_number_integer() && !node_->is_number_unsigned()) return false;
+            auto const wide = node_->get<std::int64_t>();
+            if (!std::in_range<T>(wide)) return false;
+            value = static_cast<T>(wide);
+
+        } else if constexpr (std::is_floating_point_v<T>) {
+            if (!node_->is_number()) return false;
+            value = node_->get<T>();
+
+        } else if constexpr (std::is_enum_v<T>) {
+            std::underlying_type_t<T> underlying;
+            if (!scalar(underlying)) return false;
+            value = static_cast<T>(underlying);
+
+        } else { // string-like
+            if (!node_->is_string()) return false;
+            value = std::string_view{node_->get_ref<document_type::string_t const&>()};
+        }
+        return true;
+    }
+
+    template<class VisitorT>
+    [[nodiscard]] bool array(VisitorT&& vis) const
+    {
+        if (!node_->is_array()) return false;
+
+        for (auto const& elem : *node_) {
+            dom_reader elem_rd{elem};
+            vis(elem_rd);
+        }
+        return true;
+    }
+
+    template<class VisitorT>
+    [[nodiscard]] bool object(VisitorT&& vis) const
+    {
+        if (!node_->is_object()) return false;
+
+        for (auto const& [map_key, member] : node_->items()) {
+            dom_reader member_rd{member};
+            vis(std::string_view{map_key}, member_rd);
+        }
+        return true;
+    }
+
+private:
+    document_type const* node_;
+};
+
+template<deserializable T>
+    requires requires(nlohmann::json const& j) {
+        basic_load_fn<dom_reader>{}(j, std::declval<T&>());
+    }
+[[nodiscard]] T load(nlohmann::json const& j)
+{
+    T value; // default-initialize
+    basic_load_fn<dom_reader>{}(j, value);
+    return value;
+}
+
+template<deserializable T>
+void load(nlohmann::json const& j, T& value)
+{
+    basic_load_fn<dom_reader>{}(j, value);
+}
+
+} // iris::marshal::json
+
+#endif
diff --git a/include/iris/marshal/serialize_traits.hpp b/include/iris/marshal/serialize_traits.hpp
new file mode 100644
index 0000000..ee098f5
--- /dev/null
+++ b/include/iris/marshal/serialize_traits.hpp
@@ -0,0 +1,392 @@
+#ifndef IRIS_ZZ_MARSHAL_SERIALIZE_TRAITS_HPP
+#define IRIS_ZZ_MARSHAL_SERIALIZE_TRAITS_HPP
+
+// SPDX-License-Identifier: MIT
+
+#include <iris/config.hpp> // IWYU pragma: keep
+
+#include <iris/alloy/traits.hpp>
+#include <iris/alloy/adapted/std_tuple.hpp>
+#include <iris/alloy/adapted/std_pair.hpp>
+
+#include <iris/string.hpp>
+#include <iris/ranges.hpp>
+
+#include <iris/bits/specialization_of.hpp>
+
+#include <concepts>
+#include <ranges>
+#include <type_traits>
+#include <optional>
+
+#include <cstddef>
+
+namespace iris::marshal {
+
+struct generic_format
+{
+    // Checks whether the *exact* type `K` is eligible for the key of this format's "map" type
+    template<class K>
+    static constexpr bool map_key = true;
+
+    // Checks whether `K` can be converted to the key of this format's "map" type
+    template<class K>
+    static constexpr bool loadable_key = true;
+
+    template<class T>
+    static constexpr bool loadable_scalar =
+        std::is_arithmetic_v<T> ||
+        std::is_enum_v<T> ||
+        StringLike<T>;
+};
+
+namespace detail {
+
+template<class Format>
+concept marshal_format = requires {
+    { Format::template map_key<int> } -> std::convertible_to<bool>;
+    { Format::template loadable_key<int> } -> std::convertible_to<bool>;
+    { Format::template loadable_scalar<int> } -> std::convertible_to<bool>;
+};
+
+} // detail
+
+// Customization point: serialize/deserialize `T` by converting it to/from `native_type`.
+template<class T, detail::marshal_format Format>
+struct adapted_proxy_traits;
+
+template<class T, detail::marshal_format Format>
+using adapted_proxy_native_type_t = adapted_proxy_traits<std::remove_cvref_t<T>, Format>::native_type;
+
+template<class T, class Format>
+concept adapted_proxy =
+    detail::marshal_format<Format> &&
+    requires(std::remove_cvref_t<T> const& v) {
+        typename adapted_proxy_native_type_t<T, Format>;
+        { adapted_proxy_traits<std::remove_cvref_t<T>, Format>::to_native_type(v) }
+            -> std::convertible_to<adapted_proxy_native_type_t<T, Format>>;
+    };
+
+namespace detail {
+
+template<class T, class Format>
+concept proxy_writable =
+    detail::marshal_format<Format> &&
+    adapted_proxy<T, Format> &&
+    requires(adapted_proxy_native_type_t<T, Format> p) {
+        { adapted_proxy_traits<std::remove_cvref_t<T>, Format>::from_native_type(std::move(p)) }
+            -> std::convertible_to<std::remove_cvref_t<T>>;
+    } &&
+    std::is_assignable_v<std::remove_cvref_t<T>&, std::remove_cvref_t<T>>;
+
+} // detail
+
+// --------------------------------------------------------------
+
+// Customization point
+template<class ClassT>
+struct adapted_class_traits;
+
+template<class T>
+concept adapted_class = requires {
+    adapted_class_traits<std::remove_cvref_t<T>>::fields;
+};
+
+// Customization point
+template<class T>
+struct adapted_optional_traits;
+
+template<class T>
+using adapted_optional_value_t = adapted_optional_traits<std::remove_cvref_t<T>>::value_type;
+
+template<class T>
+    requires is_ttp_specialization_of_v<T, std::optional>
+struct adapted_optional_traits<T>
+{
+    using value_type = T::value_type;
+};
+
+template<class T>
+concept adapted_optional = requires(T const& opt) {
+    typename adapted_optional_traits<std::remove_cvref_t<T>>::value_type;
+    static_cast<bool>(opt);
+    { *opt } -> std::convertible_to<adapted_optional_value_t<T> const&>;
+};
+
+namespace detail {
+
+template<class T>
+concept optional_writable =
+    adapted_optional<T> &&
+    std::default_initializable<std::remove_cvref_t<T>> &&
+    std::is_assignable_v<std::remove_cvref_t<T>&, std::remove_cvref_t<T>> &&
+    std::is_assignable_v<std::remove_cvref_t<T>&, adapted_optional_value_t<T>>;
+
+
+template<class T, detail::marshal_format Format>
+[[nodiscard]] consteval bool is_serializable_impl();
+
+template<class T>
+struct is_serializable_scalar : std::false_type
+{};
+
+template<class T>
+    requires
+        std::is_arithmetic_v<T> ||
+        std::is_enum_v<T> ||
+        StringLike<T>
+struct is_serializable_scalar<T> : std::true_type
+{};
+
+// ---------------------------------------------------
+
+template<class Tup, detail::marshal_format Format, std::size_t I = 0>
+[[nodiscard]] consteval bool is_tuple_elements_serializable_impl();
+
+template<class T, detail::marshal_format Format>
+consteval bool is_serializable_impl()
+{
+    using V = std::remove_cvref_t<T>;
+
+    static_assert(
+        !(adapted_class<V> && adapted_proxy<V, Format>),
+        "a type cannot be adapted both as a class and as a proxy"
+    );
+
+    if constexpr (adapted_proxy<V, Format>) {
+        return is_serializable_impl<adapted_proxy_native_type_t<V, Format>, Format>();
+
+    } else if constexpr (adapted_class<V>) {
+        return true;
+
+    } else if constexpr (adapted_optional<V>) {
+        return is_serializable_impl<adapted_optional_value_t<V>, Format>();
+
+    } else if constexpr (is_serializable_scalar<V>::value) {
+        return true;
+
+    } else if constexpr (ranges::mapping_range<V>) {
+        return
+            Format::template map_key<ranges::range_key_t<V>> &&
+            is_serializable_impl<ranges::range_key_t<V>, Format>() &&
+            is_serializable_impl<ranges::range_mapped_t<V>, Format>();
+
+    } else if constexpr (std::ranges::input_range<V>) {
+        return is_serializable_impl<std::ranges::range_value_t<V>, Format>();
+
+    } else if constexpr (alloy::TupleLike<V>) {
+        return is_tuple_elements_serializable_impl<V, Format>();
+
+    } else {
+        return false;
+    }
+}
+
+template<class Tup, detail::marshal_format Format, std::size_t I>
+consteval bool is_tuple_elements_serializable_impl()
+{
+    if constexpr (I == alloy::tuple_size_v<Tup>) {
+        return true;
+
+    } else if constexpr (!is_serializable_impl<typename alloy::tuple_element<I, Tup>::type, Format>()) {
+        return false;
+
+    } else {
+        return is_tuple_elements_serializable_impl<Tup, Format, I + 1>();
+    }
+}
+
+} // detail
+
+
+template<class T, class Format = generic_format>
+concept serializable_proxy =
+    detail::marshal_format<Format> &&
+    adapted_proxy<T, Format> &&
+    detail::is_serializable_impl<adapted_proxy_native_type_t<T, Format>, Format>();
+
+template<class T, class Format = generic_format>
+concept serializable_class =
+    detail::marshal_format<Format> &&
+    !serializable_proxy<T, Format> &&
+    adapted_class<T>;
+
+template<class T, class Format = generic_format>
+concept serializable_optional =
+    detail::marshal_format<Format> &&
+    !serializable_proxy<T, Format> &&
+    !serializable_class<T, Format> &&
+    adapted_optional<T> &&
+    detail::is_serializable_impl<adapted_optional_value_t<T>, Format>();
+
+template<class T, class Format = generic_format>
+concept serializable_scalar =
+    detail::marshal_format<Format> &&
+    !serializable_proxy<T, Format> &&
+    !serializable_class<T, Format> &&
+    !adapted_optional<T> &&
+    detail::is_serializable_scalar<std::remove_cvref_t<T>>::value;
+
+template<class T, class Format = generic_format>
+concept serializable_map =
+    detail::marshal_format<Format> &&
+    !serializable_proxy<T, Format> &&
+    !serializable_class<T, Format> &&
+    !adapted_optional<T> &&
+    !serializable_scalar<T, Format> &&
+    ranges::mapping_range<T> &&
+    Format::template map_key<ranges::range_key_t<T>> &&
+    detail::is_serializable_impl<ranges::range_key_t<T>, Format>() &&
+    detail::is_serializable_impl<ranges::range_mapped_t<T>, Format>();
+
+template<class T, class Format = generic_format>
+concept serializable_array =
+    detail::marshal_format<Format> &&
+    !serializable_proxy<T, Format> &&
+    !serializable_class<T, Format> &&
+    !adapted_optional<T> &&
+    !serializable_scalar<T, Format> &&
+    !ranges::mapping_range<T> &&
+    std::ranges::input_range<T> &&
+    detail::is_serializable_impl<std::ranges::range_value_t<T>, Format>();
+
+template<class T, class Format = generic_format>
+concept serializable_tuple =
+    detail::marshal_format<Format> &&
+    !serializable_proxy<T, Format> &&
+    !serializable_class<T, Format> &&
+    !adapted_optional<T> &&
+    !serializable_scalar<T, Format> &&
+    !std::ranges::range<T> &&
+    alloy::TupleLike<T> &&
+    detail::is_tuple_elements_serializable_impl<std::remove_cvref_t<T>, Format>();
+
+template<class T, class Format = generic_format>
+concept serializable =
+    detail::marshal_format<Format> &&
+    (
+        serializable_proxy<T, Format> ||
+        serializable_class<T, Format> ||
+        serializable_optional<T, Format> ||
+        serializable_scalar<T, Format> ||
+        serializable_map<T, Format> ||
+        serializable_array<T, Format> ||
+        serializable_tuple<T, Format>
+    );
+
+// ---------------------------------------------------
+
+namespace detail {
+
+template<class T, marshal_format Format>
+[[nodiscard]] consteval bool is_deserializable_impl();
+
+template<class T, class Format>
+concept loadable =
+    marshal_format<Format> &&
+    std::default_initializable<std::remove_cvref_t<T>> &&
+    std::movable<std::remove_cvref_t<T>> &&
+    is_deserializable_impl<std::remove_cvref_t<T>, Format>();
+
+template<class T, marshal_format Format>
+consteval bool is_deserializable_impl()
+{
+    using V = std::remove_cvref_t<T>;
+
+    if constexpr (std::is_const_v<std::remove_reference_t<T>>) {
+        return false;
+
+    } else if constexpr (!is_serializable_impl<V, Format>()) {
+        return false;
+
+    } else if constexpr (adapted_proxy<V, Format>) {
+        return loadable<adapted_proxy_native_type_t<V, Format>, Format> && proxy_writable<V, Format>;
+
+    } else if constexpr (adapted_class<V>) {
+        return true;
+
+    } else if constexpr (adapted_optional<V>) {
+        return loadable<adapted_optional_value_t<V>, Format> && optional_writable<V>;
+
+    } else if constexpr (is_serializable_scalar<V>::value) {
+        return Format::template loadable_scalar<V>;
+
+    } else if constexpr (ranges::mapping_range<V>) {
+        return
+            ranges::mapping_container<V> &&
+            Format::template loadable_key<ranges::range_key_t<V>> &&
+            loadable<ranges::range_key_t<V>, Format> &&
+            loadable<ranges::range_mapped_t<V>, Format>;
+
+    } else if constexpr (std::ranges::input_range<V>) {
+        if constexpr (ranges::growable_array_writable<V>) {
+            return loadable<std::ranges::range_value_t<V>, Format>;
+
+        } else if constexpr (ranges::fixed_array_writable<V>) {
+            return is_deserializable_impl<std::ranges::range_value_t<V>, Format>();
+
+        } else {
+            return false;
+        }
+
+    } else if constexpr (alloy::TupleLike<V>) {
+        return is_tuple_elements_serializable_impl<V, Format>();   // non-const get<I> + recurse
+
+    } else {
+        return false;
+    }
+}
+
+} // detail
+
+template<class T, class Format = generic_format>
+concept deserializable_proxy =
+    serializable_proxy<T, Format> &&
+    detail::is_deserializable_impl<T, Format>();
+
+template<class T, class Format = generic_format>
+concept deserializable_class =
+    serializable_class<T, Format> &&
+    detail::is_deserializable_impl<T, Format>();
+
+template<class T, class Format = generic_format>
+concept deserializable_optional =
+    serializable_optional<T, Format> &&
+    detail::is_deserializable_impl<T, Format>();
+
+template<class T, class Format = generic_format>
+concept deserializable_scalar =
+    serializable_scalar<T, Format> &&
+    detail::is_deserializable_impl<T, Format>();
+
+template<class T, class Format = generic_format>
+concept deserializable_map =
+    serializable_map<T, Format> &&
+    detail::loadable<T, Format>;
+
+template<class T, class Format = generic_format>
+concept deserializable_array =
+    serializable_array<T, Format> &&
+    detail::loadable<T, Format>;
+
+template<class T, class Format = generic_format>
+concept deserializable_tuple =
+    serializable_tuple<T, Format> &&
+    detail::loadable<T, Format>;
+
+template<class T, class Format = generic_format>
+concept deserializable =
+    detail::marshal_format<Format> &&
+    (
+        deserializable_proxy<T, Format> ||
+        deserializable_class<T, Format> ||
+        deserializable_optional<T, Format> ||
+        deserializable_scalar<T, Format> ||
+        deserializable_map<T, Format> ||
+        deserializable_array<T, Format> ||
+        deserializable_tuple<T, Format>
+    );
+
+} // iris::marshal
+
+#endif
diff --git a/include/iris/pp/arg.hpp b/include/iris/pp/arg.hpp
new file mode 100644
index 0000000..f2ef6d9
--- /dev/null
+++ b/include/iris/pp/arg.hpp
@@ -0,0 +1,27 @@
+#ifndef IRIS_ZZ_PP_ARG_HPP
+#define IRIS_ZZ_PP_ARG_HPP
+
+// SPDX-License-Identifier: MIT
+
+#include <iris/pp/if.hpp>
+
+#define IRIS_PP_IDENTITY(...) __VA_ARGS__
+
+#define IRIS_PP_EMPTY(...)
+
+#define IRIS_ZZ_PP_EXPAND_I(...) __VA_ARGS__
+#define IRIS_PP_EXPAND(...) IRIS_ZZ_PP_EXPAND_I(__VA_ARGS__)
+
+#define IRIS_ZZ_PP_PROBE() ~, 1
+
+#define IRIS_ZZ_PP_SECOND(a, b, ...) b
+#define IRIS_ZZ_PP_IS_PROBE(...) IRIS_ZZ_PP_SECOND(__VA_ARGS__, 0)
+#define IRIS_ZZ_PP_IS_PAREN_PROBE(...) IRIS_ZZ_PP_PROBE()
+
+#define IRIS_PP_IS_PAREN(x) IRIS_ZZ_PP_IS_PROBE(IRIS_ZZ_PP_IS_PAREN_PROBE x)
+
+#define IRIS_PP_UNPAREN(x) IRIS_PP_EXPAND x
+#define IRIS_PP_UNPAREN_IF_PAREN(x) \
+    IRIS_PP_IF(IRIS_PP_IS_PAREN(x), IRIS_PP_UNPAREN, IRIS_PP_IDENTITY) (x)
+
+#endif
diff --git a/include/iris/pp/cat.hpp b/include/iris/pp/cat.hpp
index 8ccbbc7..66e7280 100644
--- a/include/iris/pp/cat.hpp
+++ b/include/iris/pp/cat.hpp
@@ -6,4 +6,7 @@
 #define IRIS_ZZ_PP_CAT_I(a, b) a##b
 #define IRIS_PP_CAT(a, b) IRIS_ZZ_PP_CAT_I(a, b)
 
+#define IRIS_ZZ_PP_CAT_ONLY_TWO_I(a, b, ...) a##b
+#define IRIS_PP_CAT_ONLY_TWO(a, b, ...) IRIS_ZZ_PP_CAT_ONLY_TWO_I(a, b)
+
 #endif
diff --git a/modules/nlohmann_json b/modules/nlohmann_json
new file mode 160000
index 0000000..734fd30
--- /dev/null
+++ b/modules/nlohmann_json
@@ -0,0 +1 @@
+Subproject commit 734fd305a19995673c5b83b4a30c06a96ff5c9b0
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 96f1630..6d72e40 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -195,11 +195,14 @@ if(PROJECT_IS_TOP_LEVEL)
             snippet
             alloy
             alloy_visit
+            marshal
         )
         foreach(test_name IN LISTS IRIS_TEST_IRIS_TESTS)
             iris_define_internal_test(${test_name} ${test_name}.cpp)
         endforeach()
 
+        target_link_libraries(iris_marshal_test PRIVATE Iris::Marshal)
+
         set(
             IRIS_TEST_NGRAM_TESTS
             ngram
diff --git a/test/marshal.cpp b/test/marshal.cpp
new file mode 100644
index 0000000..efca8a7
--- /dev/null
+++ b/test/marshal.cpp
@@ -0,0 +1,429 @@
+#include "iris_test.hpp"
+
+#include <iris/alloy/adapted/std_pair.hpp>
+#include <iris/alloy/adapted/std_tuple.hpp>
+
+#include <iris/marshal/serialize_traits.hpp>
+#include <iris/marshal/adapt.hpp>
+#include <iris/marshal/serialize_json.hpp>
+
+#include <iris/format.hpp>
+
+#include <concepts>
+#include <string>
+#include <string_view>
+#include <vector>
+#include <map>
+#include <unordered_map>
+#include <flat_map>
+
+using namespace std::string_view_literals;
+
+namespace marshal = iris::marshal;
+namespace json = marshal::json;
+
+using marshal::generic_format;
+
+enum non_scoped_enum : int {};
+enum struct scoped_enum : int {};
+
+struct NonSerializable {};
+
+
+TEST_CASE("marshal: type traits (generic_format)")
+{
+    STATIC_CHECK(marshal::detail::marshal_format<generic_format>);
+    STATIC_CHECK(!marshal::serializable_array<int*>);
+}
+
+TEST_CASE("marshal: type traits (json::format)")
+{
+    STATIC_CHECK(marshal::detail::marshal_format<json::format>);
+    STATIC_CHECK(marshal::writer<json::dom_writer>);
+
+    // CharT = char
+    {
+        STATIC_CHECK(!marshal::adapted_proxy<char const*, json::format>);
+        STATIC_CHECK(!marshal::adapted_proxy<std::string, json::format>);
+        STATIC_CHECK(!marshal::adapted_proxy<std::string_view, json::format>);
+    }
+    // CharT = char32_t
+    {
+        STATIC_CHECK(marshal::adapted_proxy<char32_t const*, json::format>);
+        STATIC_CHECK(std::same_as<marshal::adapted_proxy_native_type_t<char32_t const*, json::format>, std::string>);
+        STATIC_CHECK(marshal::detail::proxy_writable<char32_t const*, json::format>);
+
+        STATIC_CHECK(marshal::adapted_proxy<std::u32string, json::format>);
+        STATIC_CHECK(std::same_as<marshal::adapted_proxy_native_type_t<std::u32string, json::format>, std::string>);
+        STATIC_CHECK(marshal::detail::proxy_writable<std::u32string, json::format>);
+
+        STATIC_CHECK(marshal::adapted_proxy<std::u32string_view, json::format>);
+        STATIC_CHECK(std::same_as<marshal::adapted_proxy_native_type_t<std::u32string_view, json::format>, std::string>);
+        STATIC_CHECK(marshal::detail::proxy_writable<std::u32string_view, json::format>);
+    }
+}
+
+TEST_CASE("marshal: serialize (builtin types)")
+{
+    STATIC_CHECK(!json::serializable<NonSerializable>);
+
+    STATIC_CHECK(json::serializable_scalar<int const>);
+    STATIC_CHECK(!json::deserializable_scalar<int const>);
+
+#define IRIS_CHECK_SERIALIZABLE(kind, ...) \
+    STATIC_CHECK(json::serializable_ ## kind<__VA_ARGS__>); \
+    STATIC_CHECK(json::deserializable_ ## kind<__VA_ARGS__>);
+
+    IRIS_CHECK_SERIALIZABLE(scalar, int);
+    IRIS_CHECK_SERIALIZABLE(scalar, non_scoped_enum);
+    IRIS_CHECK_SERIALIZABLE(scalar, scoped_enum);
+
+    IRIS_CHECK_SERIALIZABLE(scalar, std::string);
+    IRIS_CHECK_SERIALIZABLE(scalar, std::string_view);
+    IRIS_CHECK_SERIALIZABLE(proxy, std::u32string);
+    IRIS_CHECK_SERIALIZABLE(proxy, std::u32string_view);
+
+    IRIS_CHECK_SERIALIZABLE(optional, std::optional<int>);
+    IRIS_CHECK_SERIALIZABLE(optional, std::optional<std::string>);
+    IRIS_CHECK_SERIALIZABLE(optional, std::optional<std::u32string>);
+    STATIC_CHECK(!json::serializable<std::optional<NonSerializable>>);
+
+    IRIS_CHECK_SERIALIZABLE(tuple, std::pair<int, int>);
+    IRIS_CHECK_SERIALIZABLE(tuple, std::tuple<int, int>);
+    IRIS_CHECK_SERIALIZABLE(tuple, std::pair<std::string, int>);
+    IRIS_CHECK_SERIALIZABLE(tuple, std::tuple<std::string, int>);
+    IRIS_CHECK_SERIALIZABLE(tuple, std::pair<std::u32string, int>);
+    IRIS_CHECK_SERIALIZABLE(tuple, std::tuple<std::u32string, int>);
+    STATIC_CHECK(!json::serializable<std::pair<int, NonSerializable>>);
+    STATIC_CHECK(!json::serializable<std::tuple<int, NonSerializable>>);
+
+    IRIS_CHECK_SERIALIZABLE(array, std::vector<int>);
+    IRIS_CHECK_SERIALIZABLE(array, std::vector<std::string>);
+    IRIS_CHECK_SERIALIZABLE(array, std::vector<std::u32string>);
+    STATIC_CHECK(!json::serializable<std::vector<NonSerializable>>);
+
+    IRIS_CHECK_SERIALIZABLE(map, std::map<char const*, int>);
+    IRIS_CHECK_SERIALIZABLE(map, std::map<std::string_view, int>);
+    IRIS_CHECK_SERIALIZABLE(map, std::map<std::string, int>);
+
+    IRIS_CHECK_SERIALIZABLE(map, std::map<char32_t const*, int>);
+    IRIS_CHECK_SERIALIZABLE(map, std::map<std::u32string_view, int>);
+    IRIS_CHECK_SERIALIZABLE(map, std::map<std::u32string, int>);
+
+    STATIC_CHECK(!json::serializable_map<std::map<int, int>>);
+    STATIC_CHECK(!json::serializable_array<std::map<int, int>>);
+    STATIC_CHECK(!json::serializable<std::map<int, NonSerializable>>);
+
+    // NOT map
+    IRIS_CHECK_SERIALIZABLE(array, std::vector<std::pair<std::string, int>>);
+    STATIC_CHECK(!json::serializable_map<std::vector<std::pair<std::string, int>>>);
+    STATIC_CHECK(!json::deserializable_map<std::vector<std::pair<std::string, int>>>);
+
+    // Adapted map
+    {
+        using PipedPairVec = decltype(std::declval<std::vector<std::pair<std::string, int>>>() | iris::ranges::as_map);
+        STATIC_CHECK(json::serializable_map<PipedPairVec>);
+        STATIC_CHECK(!json::deserializable_map<PipedPairVec>);
+    }
+
+#undef IRIS_CHECK_SERIALIZABLE
+
+    {
+        nlohmann::json j;
+        int const value = 42;
+        json::save(j, value);
+        CHECK(j.get<int>() == value);
+        CHECK(json::load<int>(j) == value);
+    }
+
+    {
+        nlohmann::json j;
+        auto const value = non_scoped_enum{42};
+        json::save(j, value);
+        CHECK(j.get<non_scoped_enum>() == value);
+        CHECK(json::load<non_scoped_enum>(j) == value);
+    }
+    {
+        nlohmann::json j;
+        auto const value = scoped_enum{42};
+        json::save(j, value);
+        CHECK(j.get<scoped_enum>() == value);
+        CHECK(json::load<scoped_enum>(j) == value);
+    }
+
+    {
+        nlohmann::json j;
+        std::string const str = "foo";
+        json::save(j, str);
+        CHECK(j.get<std::string>() == str);
+        CHECK(json::load<std::string>(j) == str);
+    }
+    {
+        nlohmann::json j;
+        std::u32string const str = U"あいう";
+        json::save(j, str);
+        CHECK(iris::to_u32string_ref(j.get<std::string>()) == str);
+        CHECK(json::load<std::u32string>(j) == str);
+    }
+
+    {
+        nlohmann::json j;
+        std::vector<int> const arr{0, 1, 2};
+        json::save(j, arr);
+        CHECK(j.get<std::vector<int>>() == arr);
+        CHECK(json::load<std::vector<int>>(j) == arr);
+    }
+    {
+        nlohmann::json j;
+        std::vector<std::string> const arr{"foo", "bar"};
+        json::save(j, arr);
+        CHECK(j.get<std::vector<std::string>>() == arr);
+        CHECK(json::load<std::vector<std::string>>(j) == arr);
+    }
+    {
+        nlohmann::json j;
+        std::vector<std::u32string> const arr{U"foo", U"あいう"};
+        json::save(j, arr);
+        CHECK(json::load<std::vector<std::u32string>>(j) == arr);
+    }
+
+    {
+        nlohmann::json j;
+        std::vector<std::pair<std::string, int>> const arr{{"foo", 0}};
+        json::save(j, arr);
+        CHECK(j.get<std::vector<std::pair<std::string, int>>>() == arr);
+        CHECK(json::load<std::vector<std::pair<std::string, int>>>(j) == arr);
+    }
+    {
+        nlohmann::json j;
+        std::vector<std::pair<std::u32string, int>> const arr{{U"あいう", 0}};
+        json::save(j, arr);
+        CHECK(json::load<std::vector<std::pair<std::u32string, int>>>(j) == arr);
+    }
+
+    {
+        nlohmann::json j;
+        std::map<std::string, int> const map{{"foo", 0}, {"bar", 1}};
+        json::save(j, map);
+        CHECK(j.get<std::map<std::string, int>>() == map);
+        CHECK(json::load<std::map<std::string, int>>(j) == map);
+    }
+    {
+        nlohmann::json j;
+        std::map<std::string, std::string> const map{{"foo", "0"}, {"bar", "1"}};
+        json::save(j, map);
+        CHECK(j.get<std::map<std::string, std::string>>() == map);
+        CHECK(json::load<std::map<std::string, std::string>>(j) == map);
+    }
+    {
+        nlohmann::json j;
+        std::map<std::u32string, int> const map{{U"foo", 0}, {U"あいう", 1}};
+        json::save(j, map);
+        CHECK(json::load<std::map<std::u32string, int>>(j) == map);
+    }
+    {
+        nlohmann::json j;
+        std::map<std::u32string, std::u32string> const map{{U"foo", U"0"}, {U"あいう", U"1"}};
+        json::save(j, map);
+        CHECK(json::load<std::map<std::u32string, std::u32string>>(j) == map);
+    }
+
+    {
+        nlohmann::json j;
+        std::unordered_map<std::string, int> const map{{"foo", 0}, {"bar", 1}};
+        json::save(j, map);
+        CHECK(j.get<std::map<std::string, int>>() == std::map<std::string, int>{std::from_range, map});
+        CHECK(json::load<std::unordered_map<std::string, int>>(j) == map);
+    }
+
+    {
+        nlohmann::json j;
+        std::flat_map<std::string, int> const map{{"foo", 0}, {"bar", 1}};
+        json::save(j, map);
+        CHECK(j.get<std::map<std::string, int>>() == std::map<std::string, int>{std::from_range, map});
+        CHECK(json::load<std::flat_map<std::string, int>>(j) == map);
+    }
+
+    {
+        nlohmann::json j;
+        std::multimap<std::string, int> const map{{"foo", 0}, {"bar", 1}};
+        json::save(j, map);
+        CHECK(j.get<std::multimap<std::string, int>>() == map);
+        CHECK(json::load<std::multimap<std::string, int>>(j) == map);
+    }
+
+    {
+        nlohmann::json j;
+        std::pair const pair{0, 1};
+        json::save(j, pair);
+        CHECK(j.get<std::pair<int, int>>() == pair);
+        CHECK(json::load<std::pair<int, int>>(j) == pair);
+    }
+
+    {
+        nlohmann::json j;
+        std::pair<std::string, int> const pair{"foo", 0};
+        json::save(j, pair);
+        CHECK(j.get<std::pair<std::string, int>>() == pair);
+        CHECK(json::load<std::pair<std::string, int>>(j) == pair);
+    }
+    {
+        nlohmann::json j;
+        std::pair<std::u32string, int> const pair{U"あいう", 0};
+        json::save(j, pair);
+        CHECK(json::load<std::pair<std::u32string, int>>(j) == pair);
+    }
+
+    {
+        nlohmann::json j;
+        std::tuple const tup{0, 1, 2};
+        json::save(j, tup);
+        CHECK(j.get<std::tuple<int, int, int>>() == tup);
+        CHECK(json::load<std::tuple<int, int, int>>(j) == tup);
+    }
+
+    {
+        nlohmann::json j;
+        std::optional<int> const opt = 42;
+        json::save(j, opt);
+        CHECK(j.get<std::optional<int>>() == opt);
+        CHECK(json::load<std::optional<int>>(j) == opt);
+    }
+    {
+        nlohmann::json j;
+        std::optional<std::string> const opt = "foo";
+        json::save(j, opt);
+        CHECK(j.get<std::optional<std::string>>() == opt);
+        CHECK(json::load<std::optional<std::string>>(j) == opt);
+    }
+    {
+        nlohmann::json j;
+        std::optional<std::u32string> const opt = U"あいう";
+        json::save(j, opt);
+        CHECK(json::load<std::optional<std::u32string>>(j) == opt);
+    }
+
+    {
+        nlohmann::json j;
+        std::vector<std::optional<int>> const vec_opt = {42, std::nullopt, 44};
+        json::save(j, vec_opt);
+        CHECK(j.get<std::vector<std::optional<int>>>() == vec_opt);
+        CHECK(json::load<std::vector<std::optional<int>>>(j) == vec_opt);
+    }
+}
+
+
+struct MyData
+{
+    IRIS_MARSHAL_CLASS(MyData)
+
+    IRIS_MARSHAL_FIELD(std::string, name)
+    IRIS_MARSHAL_FIELD(std::string, text, "empty text")
+    IRIS_MARSHAL_FIELD((std::pair<int, int>), pair)
+    IRIS_MARSHAL_FIELD(int, age)
+    IRIS_MARSHAL_FIELD(bool, enabled, true)
+
+    std::string public_mem_str;
+};
+
+IRIS_MARSHAL_ADAPT(
+    MyData, name, text, age, enabled, public_mem_str
+);
+
+template<>
+struct std::formatter<MyData> : iris::no_spec_formatter<char>
+{
+    template<class Ctx>
+    static Ctx::iterator format(MyData const& my_data, Ctx& ctx)
+    {
+        return std::format_to(
+            ctx.out(),
+            "{{name: \"{}\", text: \"{}\", pair: ({},{}), age: {}, enabled: {}}}",
+            my_data.get_name(),
+            my_data.get_text(),
+            my_data.get_pair().first, my_data.get_pair().second,
+            my_data.get_age(),
+            my_data.is_enabled()
+        );
+    }
+};
+
+TEST_CASE("marshal: serialize (class type)")
+{
+    STATIC_CHECK(marshal::serializable_class<MyData>);
+    STATIC_CHECK(!marshal::serializable_tuple<MyData>);
+
+    {
+        MyData my_data;
+
+        STATIC_CHECK(std::same_as<decltype(my_data.get_name()), std::string const&>);
+        CHECK(my_data.get_name().empty());
+        my_data.set_name("foo");
+        CHECK(my_data.get_name() == "foo"sv);
+
+        CHECK(my_data.get_text() == "empty text"sv);
+
+        STATIC_CHECK(std::same_as<decltype(my_data.get_age()), int>);
+        CHECK(my_data.get_age() == 0);
+
+        STATIC_CHECK(std::same_as<decltype(my_data.is_enabled()), bool>);
+        CHECK(my_data.is_enabled() == true);
+    }
+
+    {
+        nlohmann::json j;
+        MyData my_data;
+        my_data.set_name("foo");
+        my_data.set_age(42);
+        my_data.set_enabled(true);
+        json::save(j, my_data);
+
+        CHECK(j.at("name").get<std::string>() == "foo"sv);
+        CHECK(j.at("text").get<std::string>() == "empty text"sv);
+        CHECK(j.at("age").get<int>() == 42);
+        CHECK(j.at("enabled").get<bool>() == true);
+
+        CHECK(json::load<MyData>(j) == my_data);
+    }
+}
+
+// ----------------------------------------------------
+// pimpl related
+
+#define IRIS_TEST_MY_PIMPL_DATA_FIELD_DEFS \
+    (((std::map<std::string, int>), int_map)) \
+    ((int, age))
+
+struct MyPimplData
+{
+    IRIS_MARSHAL_PIMPL_CLASS(MyPimplData)
+    IRIS_MARSHAL_PIMPL_FIELD_DECLARE(IRIS_TEST_MY_PIMPL_DATA_FIELD_DEFS)
+};
+
+IRIS_MARSHAL_ADAPT_DEFS(MyPimplData, IRIS_TEST_MY_PIMPL_DATA_FIELD_DEFS);
+
+// ----------------------------------
+
+struct MyPimplData::Impl
+{
+    IRIS_MARSHAL_PIMPL_FIELD_DEFS(IRIS_TEST_MY_PIMPL_DATA_FIELD_DEFS)
+};
+
+IRIS_MARSHAL_PIMPL_CLASS_DEFINE(MyPimplData);
+IRIS_MARSHAL_PIMPL_FIELD_ACCESS_DEFINE(MyPimplData, IRIS_TEST_MY_PIMPL_DATA_FIELD_DEFS);
+
+TEST_CASE("marshal: pimpl")
+{
+    nlohmann::json j;
+    MyPimplData p_data;
+    p_data.set_age(42);
+    p_data.set_int_map({{"foo", 5}});
+
+    json::save(j, p_data);
+    CHECK(j.at("age").get<int>() == 42);
+    CHECK(j.at("int_map").get<std::map<std::string, int>>() == std::map<std::string, int>{{"foo", 5}});
+
+    auto const loaded_p_data = json::load<MyPimplData>(j);
+    CHECK(loaded_p_data.get_age() == p_data.get_age());
+    CHECK(loaded_p_data.get_int_map() == p_data.get_int_map());
+}