diff --git a/include/Nazara/Core/Flags.hpp b/include/Nazara/Core/Flags.hpp
index ad96212fe..e56d723e5 100644
--- a/include/Nazara/Core/Flags.hpp
+++ b/include/Nazara/Core/Flags.hpp
@@ -22,6 +22,7 @@ namespace Nz
 			constexpr Flags(E enumVal);
 
 			explicit constexpr operator bool() const;
+			explicit constexpr operator UInt32() const;
 
 			constexpr Flags operator~() const;
 			constexpr Flags operator&(Flags rhs) const;
diff --git a/include/Nazara/Core/Flags.inl b/include/Nazara/Core/Flags.inl
index fa8dd4950..7a23861a2 100644
--- a/include/Nazara/Core/Flags.inl
+++ b/include/Nazara/Core/Flags.inl
@@ -33,6 +33,12 @@ namespace Nz
 		return m_value != 0;
 	}
 
+	template<typename E>
+	constexpr Flags<E>::operator UInt32() const
+	{
+		return m_value;
+	}
+
 	template<typename E>
 	constexpr Flags<E> Flags<E>::operator~() const
 	{
diff --git a/include/Nazara/Lua/LuaInstance.inl b/include/Nazara/Lua/LuaInstance.inl
index 9bc20c73a..db5c1e225 100644
--- a/include/Nazara/Lua/LuaInstance.inl
+++ b/include/Nazara/Lua/LuaInstance.inl
@@ -4,6 +4,7 @@
 
 #include <Nazara/Lua/LuaInstance.hpp>
 #include <Nazara/Core/Algorithm.hpp>
+#include <Nazara/Core/Flags.hpp>
 #include <Nazara/Core/MemoryHelper.hpp>
 #include <Nazara/Core/StringStream.hpp>
 #include <limits>
@@ -99,19 +100,40 @@ namespace Nz
 	}
 
 	template<typename T>
-	std::enable_if_t<std::is_enum<T>::value, unsigned int> LuaImplQueryArg(const LuaInstance& instance, int index, T* arg, TypeTag<T>)
+	std::enable_if_t<std::is_enum<T>::value && !EnableFlagsOperators<T>::value, unsigned int> LuaImplQueryArg(const LuaInstance& instance, int index, T* arg, TypeTag<T>)
 	{
 		using UnderlyingT = std::underlying_type_t<T>;
 		return LuaImplQueryArg(instance, index, reinterpret_cast<UnderlyingT*>(arg), TypeTag<UnderlyingT>());
 	}
 
 	template<typename T>
-	std::enable_if_t<std::is_enum<T>::value, unsigned int> LuaImplQueryArg(const LuaInstance& instance, int index, T* arg, T defValue, TypeTag<T>)
+	std::enable_if_t<std::is_enum<T>::value && !EnableFlagsOperators<T>::value, unsigned int> LuaImplQueryArg(const LuaInstance& instance, int index, T* arg, T defValue, TypeTag<T>)
 	{
 		using UnderlyingT = std::underlying_type_t<T>;
 		return LuaImplQueryArg(instance, index, reinterpret_cast<UnderlyingT*>(arg), static_cast<UnderlyingT>(defValue), TypeTag<UnderlyingT>());
 	}
 
+	template<typename T>
+	std::enable_if_t<std::is_enum<T>::value && EnableFlagsOperators<T>::value, unsigned int> LuaImplQueryArg(const LuaInstance& instance, int index, T* arg, TypeTag<T>)
+	{
+		Flags<T> flags;
+		return LuaImplQueryArg(instance, index, &flags, TypeTag<decltype(flags)>());
+	}
+
+	template<typename T>
+	std::enable_if_t<std::is_enum<T>::value && EnableFlagsOperators<T>::value, unsigned int> LuaImplQueryArg(const LuaInstance& instance, int index, T* arg, T defValue, TypeTag<T>)
+	{
+		Flags<T> flags;
+		return LuaImplQueryArg(instance, index, &flags, Flags<T>(defValue), TypeTag<decltype(flags)>());
+	}
+
+	template<typename E>
+	unsigned int LuaImplQueryArg(const LuaInstance& instance, int index, Flags<E>* arg, TypeTag<Flags<E>>)
+	{
+		*arg = Flags<E>(instance.CheckBoundInteger<UInt32>(index));
+		return 1;
+	}
+
 	template<typename T>
 	std::enable_if_t<std::is_floating_point<T>::value, unsigned int> LuaImplQueryArg(const LuaInstance& instance, int index, T* arg, TypeTag<T>)
 	{
@@ -184,12 +206,26 @@ namespace Nz
 	}
 
 	template<typename T>
-	std::enable_if_t<std::is_enum<T>::value, int> LuaImplReplyVal(const LuaInstance& instance, T val, TypeTag<T>)
+	std::enable_if_t<std::is_enum<T>::value && !EnableFlagsOperators<T>::value, int> LuaImplReplyVal(const LuaInstance& instance, T val, TypeTag<T>)
 	{
 		using EnumT = typename std::underlying_type<T>::type;
 		return LuaImplReplyVal(instance, static_cast<EnumT>(val), TypeTag<EnumT>());
 	}
 
+	template<typename T>
+	std::enable_if_t<std::is_enum<T>::value && EnableFlagsOperators<T>::value, int> LuaImplReplyVal(const LuaInstance& instance, T val, TypeTag<T>)
+	{
+		Flags<T> flags(val);
+		return LuaImplReplyVal(instance, flags, TypeTag<decltype(flags)>());
+	}
+
+	template<typename E>
+	int LuaImplReplyVal(const LuaInstance& instance, Flags<E> val, TypeTag<Flags<E>>)
+	{
+		UInt32 bitField(val);
+		return LuaImplReplyVal(instance, bitField, TypeTag<decltype(bitField)>());
+	}
+
 	template<typename T>
 	std::enable_if_t<std::is_integral<T>::value, int> LuaImplReplyVal(const LuaInstance& instance, T val, TypeTag<T>)
 	{