diff --git a/src/mpp/Constants.hpp b/src/mpp/Constants.hpp
index 4aed36729..f0abf034b 100644
--- a/src/mpp/Constants.hpp
+++ b/src/mpp/Constants.hpp
@@ -306,7 +306,7 @@ struct ExtValue { int8_t type; uint8_t offset; uint32_t size; };
 
 // The order of types must be exactly the same as in compact::Family!
 using Value_t = std::variant<
-	std::nullptr_t, bool, uint64_t, int64_t, float, double,
+	std::nullptr_t, std::monostate, bool, uint64_t, int64_t, float, double,
 	StrValue, BinValue, ArrValue, MapValue, ExtValue
 >;
 
diff --git a/src/mpp/Dec.hpp b/src/mpp/Dec.hpp
index 79bc00d8e..d732c8c68 100644
--- a/src/mpp/Dec.hpp
+++ b/src/mpp/Dec.hpp
@@ -135,7 +135,8 @@ constexpr auto detectFamily()
 			detectFamily<BUF, tnt::value_type_t<U>>());
 	} else if constexpr (tnt::is_variant_v<U>) {
 		return detectFamilyVariant<BUF, U>();
-	} else if constexpr (std::is_same_v<U, std::nullptr_t>) {
+	} else if constexpr (std::is_same_v<U, std::nullptr_t> ||
+			     std::is_same_v<U, std::monostate>) {
 		return family_sequence<compact::MP_NIL>{};
 	} else if constexpr (std::is_same_v<U, bool>) {
 		return family_sequence<compact::MP_BOOL>{};
@@ -406,6 +407,11 @@ constexpr auto get_subrules()
 		return complex_seq{};
 }
 
+struct {
+	operator std::nullptr_t() const { return {}; }
+	operator std::monostate() const { return {}; }
+} constexpr empty_value;
+
 template <compact::Family FAMILY, size_t SUBRULE, class BUF>
 auto read_value(BUF& buf)
 {
@@ -419,7 +425,7 @@ auto read_value(BUF& buf)
 			tag - RULE::simplex_tag;
 
 		if constexpr (FAMILY == compact::MP_NIL)
-			return nullptr;
+			return empty_value;
 		else if constexpr (RULE::is_bool)
 			return bool(val);
 		else if constexpr (RULE::is_simplex_log_range)
diff --git a/src/mpp/Enc.hpp b/src/mpp/Enc.hpp
index f0dda3886..168fc5a01 100644
--- a/src/mpp/Enc.hpp
+++ b/src/mpp/Enc.hpp
@@ -76,7 +76,8 @@ constexpr compact::Family detectFamily()
 	using V = std::remove_cv_t<tnt::uni_integral_base_t<U>>;
 	if constexpr (is_wrapped_family_v<T>) {
 		return T::family;
-	} else if constexpr (std::is_same_v<V, std::nullptr_t>) {
+	} else if constexpr (std::is_same_v<V, std::nullptr_t> ||
+			     std::is_same_v<V, std::monostate>) {
 		return compact::MP_NIL;
 	} else if constexpr (std::is_same_v<V, bool>) {
 		return compact::MP_BOOL;
diff --git a/src/mpp/Rules.hpp b/src/mpp/Rules.hpp
index 7bab27977..e3f4eabec 100644
--- a/src/mpp/Rules.hpp
+++ b/src/mpp/Rules.hpp
@@ -161,7 +161,7 @@ struct BaseRule {
 	using simplex_value_range_t = RuleRange<simplex_value_t>;
 };
 
-struct NilRule : BaseRule<compact::MP_NIL, std::nullptr_t> {
+struct NilRule : BaseRule<compact::MP_NIL, std::nullptr_t, std::monostate> {
 	static constexpr simplex_value_range_t simplex_value_range = {0, 0};
 	static constexpr uint8_t simplex_tag = 0xc0;
 };
diff --git a/test/EncDecTest.cpp b/test/EncDecTest.cpp
index 26498a3da..6286156f7 100644
--- a/test/EncDecTest.cpp
+++ b/test/EncDecTest.cpp
@@ -1627,8 +1627,8 @@ test_variant()
 	Buf_t buf;
 	auto run = buf.begin<true>();
 
-	using variant_t = std::variant<bool, int, std::string, nullptr_t,
-		std::optional<double>, std::vector<int>, Body>;
+	using variant_t = std::variant<bool, int, std::string, std::nullptr_t,
+		std::optional<double>, std::vector<int>, Body, std::monostate>;
 
 	variant_t wr;
 	variant_t rd;
@@ -1669,6 +1669,11 @@ test_variant()
 	mpp::encode(buf, wr);
 	mpp::decode(run, rd);
 	fail_unless(wr == rd);
+
+	wr.emplace<7>();
+	mpp::encode(buf, wr);
+	mpp::decode(run, rd);
+	fail_unless(wr == rd);
 }
 
 int main()