diff --git a/include/NZSL/Ast/SanitizeVisitor.hpp b/include/NZSL/Ast/SanitizeVisitor.hpp
index 42437aa..2f84381 100644
--- a/include/NZSL/Ast/SanitizeVisitor.hpp
+++ b/include/NZSL/Ast/SanitizeVisitor.hpp
@@ -16,8 +16,8 @@
 #include <NZSL/Ast/Types.hpp>
 #include <functional>
 #include <memory>
-#include <variant>
 #include <unordered_map>
+#include <variant>
 
 namespace nzsl::Ast
 {
diff --git a/src/NZSL/Ast/ConstantPropagationVisitor.cpp b/src/NZSL/Ast/ConstantPropagationVisitor.cpp
index b814494..24d7106 100644
--- a/src/NZSL/Ast/ConstantPropagationVisitor.cpp
+++ b/src/NZSL/Ast/ConstantPropagationVisitor.cpp
@@ -3,6 +3,7 @@
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
 #include <NZSL/Ast/ConstantPropagationVisitor.hpp>
+#include <NazaraUtils/TypeTraits.hpp>
 #include <NZSL/ShaderBuilder.hpp>
 #include <NZSL/Lang/Errors.hpp>
 #include <cassert>
@@ -13,25 +14,6 @@ namespace nzsl::Ast
 {
 	namespace NAZARA_ANONYMOUS_NAMESPACE
 	{
-		template <typename T>
-		struct IsCompleteHelper
-		{
-			// SFINAE: sizeof of an incomplete type is an error, but since there's another specialization it won't result in a compilation error
-			template <typename U>
-			static auto test(U*) -> std::bool_constant<sizeof(U) == sizeof(U)>;
-
-			// less specialized overload
-			static auto test(...) -> std::false_type;
-
-			using type = decltype(test(static_cast<T*>(nullptr)));
-		};
-
-		template <typename T>
-		struct IsComplete : IsCompleteHelper<T>::type {};
-
-		template<typename T>
-		inline constexpr bool IsComplete_v = IsComplete<T>::value;
-
 		template<typename T>
 		struct VectorInfo
 		{
@@ -639,7 +621,7 @@ namespace nzsl::Ast
 					{
 						using T = std::decay_t<decltype(arg)>;
 
-						if constexpr (IsComplete_v<ArrayBuilder<T>>)
+						if constexpr (Nz::IsComplete_v<ArrayBuilder<T>>)
 						{
 							ArrayBuilder<T> builder;
 							optimized = builder(expressions, node.sourceLocation);
@@ -1004,7 +986,7 @@ namespace nzsl::Ast
 			using T = std::decay_t<decltype(arg)>;
 			using CCType = CastConstant<TargetType, T>;
 
-			if constexpr (IsComplete_v<CCType>)
+			if constexpr (Nz::IsComplete_v<CCType>)
 				optimized = CCType{}(arg, sourceLocation);
 		}, operand.value);
 
@@ -1026,7 +1008,7 @@ namespace nzsl::Ast
 
 			using SPType = SwizzlePropagation<BaseType, TargetComponentCount, FromComponentCount>;
 
-			if constexpr (IsComplete_v<SPType>)
+			if constexpr (Nz::IsComplete_v<SPType>)
 				optimized = SPType{}(components, arg, sourceLocation);
 		}, operand.value);
 
@@ -1044,10 +1026,10 @@ namespace nzsl::Ast
 			using T = std::decay_t<decltype(arg)>;
 			using PCType = UnaryConstantPropagation<Type, T>;
 
-			if constexpr (IsComplete_v<PCType>)
+			if constexpr (Nz::IsComplete_v<PCType>)
 			{
 				using Op = typename PCType::Op;
-				if constexpr (IsComplete_v<Op>)
+				if constexpr (Nz::IsComplete_v<Op>)
 					optimized = Op{}(arg, sourceLocation);
 			}
 		}, operand.value);
@@ -1068,7 +1050,7 @@ namespace nzsl::Ast
 
 		using CCType = CastConstant<Vector2<TargetType>, TargetType, TargetType>;
 
-		if constexpr (IsComplete_v<CCType>)
+		if constexpr (Nz::IsComplete_v<CCType>)
 			optimized = CCType{}(v1, v2, sourceLocation);
 
 		return optimized;
@@ -1088,7 +1070,7 @@ namespace nzsl::Ast
 
 		using CCType = CastConstant<Vector3<TargetType>, TargetType, TargetType, TargetType>;
 
-		if constexpr (IsComplete_v<CCType>)
+		if constexpr (Nz::IsComplete_v<CCType>)
 			optimized = CCType{}(v1, v2, v3, sourceLocation);
 
 		return optimized;
@@ -1109,7 +1091,7 @@ namespace nzsl::Ast
 
 		using CCType = CastConstant<Vector4<TargetType>, TargetType, TargetType, TargetType, TargetType>;
 
-		if constexpr (IsComplete_v<CCType>)
+		if constexpr (Nz::IsComplete_v<CCType>)
 			optimized = CCType{}(v1, v2, v3, v4, sourceLocation);
 
 		return optimized;
diff --git a/src/NZSL/Ast/ConstantPropagationVisitor_BinaryArithmetics.cpp b/src/NZSL/Ast/ConstantPropagationVisitor_BinaryArithmetics.cpp
index 0457dd7..d3360fe 100644
--- a/src/NZSL/Ast/ConstantPropagationVisitor_BinaryArithmetics.cpp
+++ b/src/NZSL/Ast/ConstantPropagationVisitor_BinaryArithmetics.cpp
@@ -2,10 +2,11 @@
 // This file is part of the "Nazara Shading Language" project
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
+#include <NZSL/Ast/ConstantPropagationVisitor.hpp>
 #include <NazaraUtils/Algorithm.hpp>
 #include <NazaraUtils/MathUtils.hpp>
+#include <NazaraUtils/TypeTraits.hpp>
 #include <NZSL/ShaderBuilder.hpp>
-#include <NZSL/Ast/ConstantPropagationVisitor.hpp>
 #include <NZSL/Lang/Errors.hpp>
 #include <cassert>
 #include <cmath>
@@ -15,25 +16,6 @@ namespace nzsl::Ast
 {
 	namespace NAZARA_ANONYMOUS_NAMESPACE
 	{
-		template<typename T>
-		struct IsCompleteHelper
-		{
-			// SFINAE: sizeof in an incomplete type is an error, but since there's another specialization it won't result in a compilation error
-			template <typename U>
-			static auto test(U*) -> std::bool_constant<sizeof(U) == sizeof(U)>;
-
-			// less specialized overload
-			static auto test(...) -> std::false_type;
-
-			using type = decltype(test(static_cast<T*>(nullptr)));
-		};
-
-		template <typename T>
-		struct IsComplete : IsCompleteHelper<T>::type {};
-
-		template<typename T>
-		inline constexpr bool IsComplete_v = IsComplete<T>::value;
-
 		/*************************************************************************************************/
 
 		template<BinaryType Type, typename T1, typename T2>
@@ -41,211 +23,144 @@ namespace nzsl::Ast
 
 		// Addition
 		template<typename T1, typename T2>
-		struct BinaryAdditionBase
+		struct BinaryAddition
 		{
-			std::unique_ptr<ConstantValueExpression> operator()(const T1& lhs, const T2& rhs, const SourceLocation& /*sourceLocation*/)
+			static constexpr BinaryType Type = BinaryType::Add;
+			static constexpr bool AllowSingleOperand = false;
+
+			NAZARA_FORCEINLINE auto operator()(const T1& lhs, const T2& rhs, const SourceLocation& /*sourceLocation*/)
 			{
-				return ShaderBuilder::ConstantValue(lhs + rhs);
+				return lhs + rhs;
 			}
 		};
 
-		template<typename T1, typename T2>
-		struct BinaryAddition;
-
-		template<typename T1, typename T2>
-		struct BinaryConstantPropagation<BinaryType::Add, T1, T2>
-		{
-			using Op = BinaryAddition<T1, T2>;
-		};
-
 		// BitwiseAnd
 		template<typename T1, typename T2>
-		struct BinaryBitwiseAndBase
+		struct BinaryBitwiseAnd
 		{
-			std::unique_ptr<ConstantValueExpression> operator()(const T1& lhs, const T2& rhs, const SourceLocation& /*sourceLocation*/)
+			static constexpr BinaryType Type = BinaryType::BitwiseAnd;
+			static constexpr bool AllowSingleOperand = false;
+
+			NAZARA_FORCEINLINE auto operator()(const T1& lhs, const T2& rhs, const SourceLocation& /*sourceLocation*/)
 			{
-				return ShaderBuilder::ConstantValue(lhs & rhs);
+				return lhs & rhs;
 			}
 		};
 
-		template<typename T1, typename T2>
-		struct BinaryBitwiseAnd;
-
-		template<typename T1, typename T2>
-		struct BinaryConstantPropagation<BinaryType::BitwiseAnd, T1, T2>
-		{
-			using Op = BinaryBitwiseAnd<T1, T2>;
-		};
-
 		// BitwiseOr
 		template<typename T1, typename T2>
-		struct BinaryBitwiseOrBase
+		struct BinaryBitwiseOr
 		{
-			std::unique_ptr<ConstantValueExpression> operator()(const T1& lhs, const T2& rhs, const SourceLocation& /*sourceLocation*/)
+			static constexpr BinaryType Type = BinaryType::BitwiseOr;
+			static constexpr bool AllowSingleOperand = false;
+
+			NAZARA_FORCEINLINE auto operator()(const T1& lhs, const T2& rhs, const SourceLocation& /*sourceLocation*/)
 			{
-				return ShaderBuilder::ConstantValue(lhs | rhs);
+				return lhs | rhs;
 			}
 		};
 
-		template<typename T1, typename T2>
-		struct BinaryBitwiseOr;
-
-		template<typename T1, typename T2>
-		struct BinaryConstantPropagation<BinaryType::BitwiseOr, T1, T2>
-		{
-			using Op = BinaryBitwiseOr<T1, T2>;
-		};
-
 		// BitwiseXor
 		template<typename T1, typename T2>
-		struct BinaryBitwiseXorBase
+		struct BinaryBitwiseXor
 		{
-			std::unique_ptr<ConstantValueExpression> operator()(const T1& lhs, const T2& rhs, const SourceLocation& /*sourceLocation*/)
+			static constexpr BinaryType Type = BinaryType::BitwiseXor;
+			static constexpr bool AllowSingleOperand = false;
+
+			NAZARA_FORCEINLINE auto operator()(const T1& lhs, const T2& rhs, const SourceLocation& /*sourceLocation*/)
 			{
-				return ShaderBuilder::ConstantValue(lhs ^ rhs);
+				return lhs ^ rhs;
 			}
 		};
 
-		template<typename T1, typename T2>
-		struct BinaryBitwiseXor;
-
-		template<typename T1, typename T2>
-		struct BinaryConstantPropagation<BinaryType::BitwiseXor, T1, T2>
-		{
-			using Op = BinaryBitwiseXor<T1, T2>;
-		};
-
 		// Division
 		template<typename T1, typename T2>
-		struct BinaryDivisionBase
+		struct BinaryDivision
 		{
-			std::unique_ptr<ConstantValueExpression> operator()(const T1& lhs, const T2& rhs, const SourceLocation& sourceLocation)
+			static constexpr BinaryType Type = BinaryType::Divide;
+			static constexpr bool AllowSingleOperand = true;
+
+			NAZARA_FORCEINLINE auto operator()(const T1& lhs, const T2& rhs, const SourceLocation& sourceLocation)
 			{
 				if constexpr (std::is_integral_v<T2>)
 				{
 					if (rhs == 0)
 						throw CompilerIntegralDivisionByZeroError{ sourceLocation, ConstantToString(lhs), ConstantToString(rhs) };
 				}
-				else if constexpr (IsVector_v<T2>)
-				{
-					for (std::size_t i = 0; i < T2::Dimensions; ++i)
-					{
-						if (rhs[i] == 0)
-							throw CompilerIntegralDivisionByZeroError{ sourceLocation, ConstantToString(lhs), ConstantToString(rhs) };
-					}
-				}
 
-				return ShaderBuilder::ConstantValue(lhs / rhs);
+				return lhs / rhs;
 			}
 		};
 
-		template<typename T1, typename T2>
-		struct BinaryDivision;
-
-		template<typename T1, typename T2>
-		struct BinaryConstantPropagation<BinaryType::Divide, T1, T2>
-		{
-			using Op = BinaryDivision<T1, T2>;
-		};
-
 		// LogicalAnd
 		template<typename T1, typename T2>
-		struct BinaryLogicalAndBase
+		struct BinaryLogicalAnd
 		{
-			std::unique_ptr<ConstantValueExpression> operator()(const T1& lhs, const T2& rhs, const SourceLocation& /*sourceLocation*/)
+			static constexpr BinaryType Type = BinaryType::LogicalAnd;
+			static constexpr bool AllowSingleOperand = false;
+
+			NAZARA_FORCEINLINE auto operator()(const T1& lhs, const T2& rhs, const SourceLocation& /*sourceLocation*/)
 			{
-				return ShaderBuilder::ConstantValue(lhs && rhs);
+				return lhs && rhs;
 			}
 		};
 
-		template<typename T1, typename T2>
-		struct BinaryLogicalAnd;
-
-		template<typename T1, typename T2>
-		struct BinaryConstantPropagation<BinaryType::LogicalAnd, T1, T2>
-		{
-			using Op = BinaryLogicalAnd<T1, T2>;
-		};
-
 		// LogicalOr
 		template<typename T1, typename T2>
-		struct BinaryLogicalOrBase
+		struct BinaryLogicalOr
 		{
-			std::unique_ptr<ConstantValueExpression> operator()(const T1& lhs, const T2& rhs, const SourceLocation& /*sourceLocation*/)
+			static constexpr BinaryType Type = BinaryType::LogicalOr;
+			static constexpr bool AllowSingleOperand = false;
+
+			NAZARA_FORCEINLINE auto operator()(const T1& lhs, const T2& rhs, const SourceLocation& /*sourceLocation*/)
 			{
-				return ShaderBuilder::ConstantValue(lhs || rhs);
+				return lhs || rhs;
 			}
 		};
 
-		template<typename T1, typename T2>
-		struct BinaryLogicalOr;
-
-		template<typename T1, typename T2>
-		struct BinaryConstantPropagation<BinaryType::LogicalOr, T1, T2>
-		{
-			using Op = BinaryLogicalOr<T1, T2>;
-		};
-
 		// Modulo
 		template<typename T1, typename T2>
-		struct BinaryModuloBase
+		struct BinaryModulo
 		{
-			std::unique_ptr<ConstantValueExpression> operator()(const T1& lhs, const T2& rhs, const SourceLocation& sourceLocation)
+			static constexpr BinaryType Type = BinaryType::Modulo;
+			static constexpr bool AllowSingleOperand = true;
+
+			NAZARA_FORCEINLINE auto operator()(const T1& lhs, const T2& rhs, const SourceLocation& sourceLocation)
 			{
 				if constexpr (std::is_integral_v<T2>)
 				{
 					if (rhs == 0)
 						throw CompilerIntegralModuloByZeroError{ sourceLocation, ConstantToString(lhs), ConstantToString(rhs) };
 				}
-				else if constexpr (IsVector_v<T2>)
-				{
-					for (std::size_t i = 0; i < T2::Dimensions; ++i)
-					{
-						if (rhs[i] == 0)
-							throw CompilerIntegralModuloByZeroError{ sourceLocation, ConstantToString(lhs), ConstantToString(rhs) };
-					}
-				}
 
 				if constexpr (std::is_floating_point_v<T1> && std::is_floating_point_v<T2>)
-					return ShaderBuilder::ConstantValue(std::fmod(lhs, rhs));
+					return std::fmod(lhs, rhs);
 				else
-					return ShaderBuilder::ConstantValue(lhs % rhs);
+					return lhs % rhs;
 			}
 		};
 
-		template<typename T1, typename T2>
-		struct BinaryModulo;
-
-		template<typename T1, typename T2>
-		struct BinaryConstantPropagation<BinaryType::Modulo, T1, T2>
-		{
-			using Op = BinaryModulo<T1, T2>;
-		};
-
 		// Multiplication
 		template<typename T1, typename T2>
-		struct BinaryMultiplicationBase
+		struct BinaryMultiplication
 		{
-			std::unique_ptr<ConstantValueExpression> operator()(const T1& lhs, const T2& rhs, const SourceLocation& /*sourceLocation*/)
+			static constexpr BinaryType Type = BinaryType::Multiply;
+			static constexpr bool AllowSingleOperand = true;
+
+			NAZARA_FORCEINLINE auto operator()(const T1& lhs, const T2& rhs, const SourceLocation& /*sourceLocation*/)
 			{
-				return ShaderBuilder::ConstantValue(lhs * rhs);
+				return lhs * rhs;
 			}
 		};
 
-		template<typename T1, typename T2>
-		struct BinaryMultiplication;
-
-		template<typename T1, typename T2>
-		struct BinaryConstantPropagation<BinaryType::Multiply, T1, T2>
-		{
-			using Op = BinaryMultiplication<T1, T2>;
-		};
-
 		// ShiftLeft
 		template<typename T1, typename T2>
-		struct BinaryShiftLeftBase
+		struct BinaryShiftLeft
 		{
-			std::unique_ptr<ConstantValueExpression> operator()(const T1& lhs, const T2& rhs, const SourceLocation& sourceLocation)
+			static constexpr BinaryType Type = BinaryType::ShiftLeft;
+			static constexpr bool AllowSingleOperand = false;
+
+			NAZARA_FORCEINLINE auto operator()(const T1& lhs, const T2& rhs, const SourceLocation& sourceLocation)
 			{
 				if constexpr (std::is_integral_v<T2>)
 				{
@@ -259,24 +174,18 @@ namespace nzsl::Ast
 						throw CompilerBinaryTooLargeShiftError{ sourceLocation, ConstantToString(lhs), "<<", ConstantToString(rhs), ToString(GetConstantExpressionType<T1>()) };
 				}
 
-				return ShaderBuilder::ConstantValue(lhs << rhs);
+				return lhs << rhs;
 			}
 		};
 
-		template<typename T1, typename T2>
-		struct BinaryShiftLeft;
-
-		template<typename T1, typename T2>
-		struct BinaryConstantPropagation<BinaryType::ShiftLeft, T1, T2>
-		{
-			using Op = BinaryShiftLeft<T1, T2>;
-		};
-
 		// ShiftRight
 		template<typename T1, typename T2>
-		struct BinaryShiftRightBase
+		struct BinaryShiftRight
 		{
-			std::unique_ptr<ConstantValueExpression> operator()(const T1& lhs, const T2& rhs, const SourceLocation& sourceLocation)
+			static constexpr BinaryType Type = BinaryType::ShiftRight;
+			static constexpr bool AllowSingleOperand = false;
+
+			NAZARA_FORCEINLINE auto operator()(const T1& lhs, const T2& rhs, const SourceLocation& sourceLocation)
 			{
 				if constexpr (std::is_integral_v<T2>)
 				{
@@ -290,60 +199,31 @@ namespace nzsl::Ast
 						throw CompilerBinaryTooLargeShiftError{ sourceLocation, ConstantToString(lhs), ">>", ConstantToString(rhs), ToString(GetConstantExpressionType<T1>()) };
 				}
 
-				return ShaderBuilder::ConstantValue(Nz::ArithmeticRightShift(lhs, rhs));
+				return Nz::ArithmeticRightShift(lhs, rhs);
 			}
 		};
 
-		template<typename T1, typename T2>
-		struct BinaryShiftRight;
-
-		template<typename T1, typename T2>
-		struct BinaryConstantPropagation<BinaryType::ShiftRight, T1, T2>
-		{
-			using Op = BinaryShiftRight<T1, T2>;
-		};
-
 		// Subtraction
 		template<typename T1, typename T2>
-		struct BinarySubtractionBase
+		struct BinarySubtraction
 		{
-			std::unique_ptr<ConstantValueExpression> operator()(const T1& lhs, const T2& rhs, const SourceLocation& /*sourceLocation*/)
+			static constexpr BinaryType Type = BinaryType::Subtract;
+			static constexpr bool AllowSingleOperand = false;
+
+			NAZARA_FORCEINLINE auto operator()(const T1& lhs, const T2& rhs, const SourceLocation& /*sourceLocation*/)
 			{
-				return ShaderBuilder::ConstantValue(lhs - rhs);
+				return lhs - rhs;
 			}
 		};
 
-		template<typename T1, typename T2>
-		struct BinarySubtraction;
-
-		template<typename T1, typename T2>
-		struct BinaryConstantPropagation<BinaryType::Subtract, T1, T2>
-		{
-			using Op = BinarySubtraction<T1, T2>;
-		};
-
 		/*************************************************************************************************/
 
-#define EnableOptimisation(Op, ...) template<> struct Op<__VA_ARGS__> : Op##Base<__VA_ARGS__> {}
-
-		// Binary
+#define EnableOptimisation(Impl, ...) template<> struct BinaryConstantPropagation<Impl<__VA_ARGS__>::Type, __VA_ARGS__> : Impl<__VA_ARGS__> {}
 
 		EnableOptimisation(BinaryAddition, double, double);
 		EnableOptimisation(BinaryAddition, float, float);
 		EnableOptimisation(BinaryAddition, std::int32_t, std::int32_t);
 		EnableOptimisation(BinaryAddition, std::uint32_t, std::uint32_t);
-		EnableOptimisation(BinaryAddition, Vector2f32, Vector2f32);
-		EnableOptimisation(BinaryAddition, Vector3f32, Vector3f32);
-		EnableOptimisation(BinaryAddition, Vector4f32, Vector4f32);
-		EnableOptimisation(BinaryAddition, Vector2f64, Vector2f64);
-		EnableOptimisation(BinaryAddition, Vector3f64, Vector3f64);
-		EnableOptimisation(BinaryAddition, Vector4f64, Vector4f64);
-		EnableOptimisation(BinaryAddition, Vector2i32, Vector2i32);
-		EnableOptimisation(BinaryAddition, Vector3i32, Vector3i32);
-		EnableOptimisation(BinaryAddition, Vector4i32, Vector4i32);
-		EnableOptimisation(BinaryAddition, Vector2u32, Vector2u32);
-		EnableOptimisation(BinaryAddition, Vector3u32, Vector3u32);
-		EnableOptimisation(BinaryAddition, Vector4u32, Vector4u32);
 
 		EnableOptimisation(BinaryBitwiseAnd, std::int32_t, std::uint32_t);
 		EnableOptimisation(BinaryBitwiseAnd, std::uint32_t, std::int32_t);
@@ -361,130 +241,22 @@ namespace nzsl::Ast
 		EnableOptimisation(BinaryBitwiseXor, std::int32_t, std::int32_t);
 
 		EnableOptimisation(BinaryDivision, double, double);
-		EnableOptimisation(BinaryDivision, double, Vector2f64);
-		EnableOptimisation(BinaryDivision, double, Vector3f64);
-		EnableOptimisation(BinaryDivision, double, Vector4f64);
 		EnableOptimisation(BinaryDivision, float, float);
-		EnableOptimisation(BinaryDivision, float, Vector2f32);
-		EnableOptimisation(BinaryDivision, float, Vector3f32);
-		EnableOptimisation(BinaryDivision, float, Vector4f32);
 		EnableOptimisation(BinaryDivision, std::int32_t, std::int32_t);
-		EnableOptimisation(BinaryDivision, std::int32_t, Vector2i32);
-		EnableOptimisation(BinaryDivision, std::int32_t, Vector3i32);
-		EnableOptimisation(BinaryDivision, std::int32_t, Vector4i32);
 		EnableOptimisation(BinaryDivision, std::uint32_t, std::uint32_t);
-		EnableOptimisation(BinaryDivision, std::uint32_t, Vector2u32);
-		EnableOptimisation(BinaryDivision, std::uint32_t, Vector3u32);
-		EnableOptimisation(BinaryDivision, std::uint32_t, Vector4u32);
-		EnableOptimisation(BinaryDivision, Vector2f32, float);
-		EnableOptimisation(BinaryDivision, Vector2f32, Vector2f32);
-		EnableOptimisation(BinaryDivision, Vector3f32, float);
-		EnableOptimisation(BinaryDivision, Vector3f32, Vector3f32);
-		EnableOptimisation(BinaryDivision, Vector4f32, float);
-		EnableOptimisation(BinaryDivision, Vector4f32, Vector4f32);
-		EnableOptimisation(BinaryDivision, Vector2f64, double);
-		EnableOptimisation(BinaryDivision, Vector2f64, Vector2f64);
-		EnableOptimisation(BinaryDivision, Vector3f64, double);
-		EnableOptimisation(BinaryDivision, Vector3f64, Vector3f64);
-		EnableOptimisation(BinaryDivision, Vector4f64, double);
-		EnableOptimisation(BinaryDivision, Vector4f64, Vector4f64);
-		EnableOptimisation(BinaryDivision, Vector2i32, std::int32_t);
-		EnableOptimisation(BinaryDivision, Vector2i32, Vector2i32);
-		EnableOptimisation(BinaryDivision, Vector3i32, std::int32_t);
-		EnableOptimisation(BinaryDivision, Vector3i32, Vector3i32);
-		EnableOptimisation(BinaryDivision, Vector4i32, std::int32_t);
-		EnableOptimisation(BinaryDivision, Vector4i32, Vector4i32);
-		EnableOptimisation(BinaryDivision, Vector2u32, std::uint32_t);
-		EnableOptimisation(BinaryDivision, Vector2u32, Vector2u32);
-		EnableOptimisation(BinaryDivision, Vector3u32, std::uint32_t);
-		EnableOptimisation(BinaryDivision, Vector3u32, Vector3u32);
-		EnableOptimisation(BinaryDivision, Vector4u32, std::uint32_t);
-		EnableOptimisation(BinaryDivision, Vector4u32, Vector4u32);
 
 		EnableOptimisation(BinaryLogicalAnd, bool, bool);
 		EnableOptimisation(BinaryLogicalOr, bool, bool);
 
 		EnableOptimisation(BinaryModulo, double, double);
-		EnableOptimisation(BinaryModulo, double, Vector2f64);
-		EnableOptimisation(BinaryModulo, double, Vector3f64);
-		EnableOptimisation(BinaryModulo, double, Vector4f64);
 		EnableOptimisation(BinaryModulo, float, float);
-		EnableOptimisation(BinaryModulo, float, Vector2f32);
-		EnableOptimisation(BinaryModulo, float, Vector3f32);
-		EnableOptimisation(BinaryModulo, float, Vector4f32);
 		EnableOptimisation(BinaryModulo, std::int32_t, std::int32_t);
-		EnableOptimisation(BinaryModulo, std::int32_t, Vector2i32);
-		EnableOptimisation(BinaryModulo, std::int32_t, Vector3i32);
-		EnableOptimisation(BinaryModulo, std::int32_t, Vector4i32);
 		EnableOptimisation(BinaryModulo, std::uint32_t, std::uint32_t);
-		EnableOptimisation(BinaryModulo, std::uint32_t, Vector2u32);
-		EnableOptimisation(BinaryModulo, std::uint32_t, Vector3u32);
-		EnableOptimisation(BinaryModulo, std::uint32_t, Vector4u32);
-		EnableOptimisation(BinaryModulo, Vector2f32, float);
-		EnableOptimisation(BinaryModulo, Vector2f32, Vector2f32);
-		EnableOptimisation(BinaryModulo, Vector3f32, float);
-		EnableOptimisation(BinaryModulo, Vector3f32, Vector3f32);
-		EnableOptimisation(BinaryModulo, Vector4f32, float);
-		EnableOptimisation(BinaryModulo, Vector4f32, Vector4f32);
-		EnableOptimisation(BinaryModulo, Vector2f64, double);
-		EnableOptimisation(BinaryModulo, Vector2f64, Vector2f64);
-		EnableOptimisation(BinaryModulo, Vector3f64, double);
-		EnableOptimisation(BinaryModulo, Vector3f64, Vector3f64);
-		EnableOptimisation(BinaryModulo, Vector4f64, double);
-		EnableOptimisation(BinaryModulo, Vector4f64, Vector4f64);
-		EnableOptimisation(BinaryModulo, Vector2i32, std::int32_t);
-		EnableOptimisation(BinaryModulo, Vector2i32, Vector2i32);
-		EnableOptimisation(BinaryModulo, Vector3i32, std::int32_t);
-		EnableOptimisation(BinaryModulo, Vector3i32, Vector3i32);
-		EnableOptimisation(BinaryModulo, Vector4i32, std::int32_t);
-		EnableOptimisation(BinaryModulo, Vector4i32, Vector4i32);
-		EnableOptimisation(BinaryModulo, Vector2u32, std::uint32_t);
-		EnableOptimisation(BinaryModulo, Vector2u32, Vector2u32);
-		EnableOptimisation(BinaryModulo, Vector3u32, std::uint32_t);
-		EnableOptimisation(BinaryModulo, Vector3u32, Vector3u32);
-		EnableOptimisation(BinaryModulo, Vector4u32, std::uint32_t);
-		EnableOptimisation(BinaryModulo, Vector4u32, Vector4u32);
 
 		EnableOptimisation(BinaryMultiplication, double, double);
-		EnableOptimisation(BinaryMultiplication, double, Vector2f64);
-		EnableOptimisation(BinaryMultiplication, double, Vector3f64);
-		EnableOptimisation(BinaryMultiplication, double, Vector4f64);
 		EnableOptimisation(BinaryMultiplication, float, float);
-		EnableOptimisation(BinaryMultiplication, float, Vector2f32);
-		EnableOptimisation(BinaryMultiplication, float, Vector3f32);
-		EnableOptimisation(BinaryMultiplication, float, Vector4f32);
 		EnableOptimisation(BinaryMultiplication, std::int32_t, std::int32_t);
-		EnableOptimisation(BinaryMultiplication, std::int32_t, Vector2i32);
-		EnableOptimisation(BinaryMultiplication, std::int32_t, Vector3i32);
-		EnableOptimisation(BinaryMultiplication, std::int32_t, Vector4i32);
 		EnableOptimisation(BinaryMultiplication, std::uint32_t, std::uint32_t);
-		EnableOptimisation(BinaryMultiplication, std::uint32_t, Vector2u32);
-		EnableOptimisation(BinaryMultiplication, std::uint32_t, Vector3u32);
-		EnableOptimisation(BinaryMultiplication, std::uint32_t, Vector4u32);
-		EnableOptimisation(BinaryMultiplication, Vector2f32, float);
-		EnableOptimisation(BinaryMultiplication, Vector2f32, Vector2f32);
-		EnableOptimisation(BinaryMultiplication, Vector3f32, float);
-		EnableOptimisation(BinaryMultiplication, Vector3f32, Vector3f32);
-		EnableOptimisation(BinaryMultiplication, Vector4f32, float);
-		EnableOptimisation(BinaryMultiplication, Vector4f32, Vector4f32);
-		EnableOptimisation(BinaryMultiplication, Vector2f64, double);
-		EnableOptimisation(BinaryMultiplication, Vector2f64, Vector2f64);
-		EnableOptimisation(BinaryMultiplication, Vector3f64, double);
-		EnableOptimisation(BinaryMultiplication, Vector3f64, Vector3f64);
-		EnableOptimisation(BinaryMultiplication, Vector4f64, double);
-		EnableOptimisation(BinaryMultiplication, Vector4f64, Vector4f64);
-		EnableOptimisation(BinaryMultiplication, Vector2i32, std::int32_t);
-		EnableOptimisation(BinaryMultiplication, Vector2i32, Vector2i32);
-		EnableOptimisation(BinaryMultiplication, Vector3i32, std::int32_t);
-		EnableOptimisation(BinaryMultiplication, Vector3i32, Vector3i32);
-		EnableOptimisation(BinaryMultiplication, Vector4i32, std::int32_t);
-		EnableOptimisation(BinaryMultiplication, Vector4i32, Vector4i32);
-		EnableOptimisation(BinaryMultiplication, Vector2u32, std::uint32_t);
-		EnableOptimisation(BinaryMultiplication, Vector2u32, Vector2u32);
-		EnableOptimisation(BinaryMultiplication, Vector3u32, std::uint32_t);
-		EnableOptimisation(BinaryMultiplication, Vector3u32, Vector3u32);
-		EnableOptimisation(BinaryMultiplication, Vector4u32, std::uint32_t);
-		EnableOptimisation(BinaryMultiplication, Vector4u32, Vector4u32);
 
 		EnableOptimisation(BinaryShiftLeft, std::int32_t, std::int32_t);
 		EnableOptimisation(BinaryShiftLeft, std::int32_t, std::uint32_t);
@@ -500,18 +272,6 @@ namespace nzsl::Ast
 		EnableOptimisation(BinarySubtraction, float, float);
 		EnableOptimisation(BinarySubtraction, std::int32_t, std::int32_t);
 		EnableOptimisation(BinarySubtraction, std::uint32_t, std::uint32_t);
-		EnableOptimisation(BinarySubtraction, Vector2f32, Vector2f32);
-		EnableOptimisation(BinarySubtraction, Vector3f32, Vector3f32);
-		EnableOptimisation(BinarySubtraction, Vector4f32, Vector4f32);
-		EnableOptimisation(BinarySubtraction, Vector2f64, Vector2f64);
-		EnableOptimisation(BinarySubtraction, Vector3f64, Vector3f64);
-		EnableOptimisation(BinarySubtraction, Vector4f64, Vector4f64);
-		EnableOptimisation(BinarySubtraction, Vector2i32, Vector2i32);
-		EnableOptimisation(BinarySubtraction, Vector3i32, Vector3i32);
-		EnableOptimisation(BinarySubtraction, Vector4i32, Vector4i32);
-		EnableOptimisation(BinarySubtraction, Vector2u32, Vector2u32);
-		EnableOptimisation(BinarySubtraction, Vector3u32, Vector3u32);
-		EnableOptimisation(BinarySubtraction, Vector4u32, Vector4u32);
 
 #undef EnableOptimisation
 	}
@@ -547,13 +307,60 @@ namespace nzsl::Ast
 		{
 			using T1 = std::decay_t<decltype(arg1)>;
 			using T2 = std::decay_t<decltype(arg2)>;
-			using PCType = BinaryConstantPropagation<Type, T1, T2>;
+			using Op = BinaryConstantPropagation<Type, T1, T2>;
+
+			if constexpr (Nz::IsComplete_v<Op>)
+				optimized = ShaderBuilder::ConstantValue(Op{}(arg1, arg2, sourceLocation));
+			else if constexpr (IsVector_v<T1> && IsVector_v<T2>)
+			{
+				using SubOp = BinaryConstantPropagation<Type, typename T1::Base, typename T2::Base>;
+				if constexpr (Nz::IsComplete_v<SubOp> && T1::Dimensions == T2::Dimensions)
+				{
+					using RetBaseType = std::decay_t<std::invoke_result_t<SubOp, typename T1::Base, typename T2::Base, const SourceLocation&>>;
+					using RetType = Vector<RetBaseType, T1::Dimensions>;
+
+					RetType value;
+					for (std::size_t i = 0; i < T1::Dimensions; ++i)
+						value[i] = SubOp{}(arg1[i], arg2[i], sourceLocation);
+
+					optimized = ShaderBuilder::ConstantValue(value);
+				}
+			}
+			else if constexpr (IsVector_v<T1>)
+			{
+				using SubOp = BinaryConstantPropagation<Type, typename T1::Base, T2>;
+				if constexpr (Nz::IsComplete_v<SubOp>)
+				{
+					if constexpr (SubOp::AllowSingleOperand)
+					{
+						using RetBaseType = std::decay_t<std::invoke_result_t<SubOp, typename T1::Base, T2, const SourceLocation&>>;
+						using RetType = Vector<RetBaseType, T1::Dimensions>;
+
+						RetType value;
+						for (std::size_t i = 0; i < T1::Dimensions; ++i)
+							value[i] = SubOp{}(arg1[i], arg2, sourceLocation);
 
-			if constexpr (IsComplete_v<PCType>)
+						optimized = ShaderBuilder::ConstantValue(value);
+					}
+				}
+			}
+			else if constexpr (IsVector_v<T2>)
 			{
-				using Op = typename PCType::Op;
-				if constexpr (IsComplete_v<Op>)
-					optimized = Op{}(arg1, arg2, sourceLocation);
+				using SubOp = BinaryConstantPropagation<Type, T1, typename T2::Base>;
+				if constexpr (Nz::IsComplete_v<SubOp>)
+				{
+					if constexpr (SubOp::AllowSingleOperand)
+					{
+						using RetBaseType = std::decay_t<std::invoke_result_t<SubOp, T1, typename T2::Base, const SourceLocation&>>;
+						using RetType = Vector<RetBaseType, T2::Dimensions>;
+
+						RetType value;
+						for (std::size_t i = 0; i < T2::Dimensions; ++i)
+							value[i] = SubOp{}(arg1, arg2[i], sourceLocation);
+
+						optimized = ShaderBuilder::ConstantValue(value);
+					}
+				}
 			}
 		}, lhs.value, rhs.value);
 
diff --git a/src/NZSL/Ast/ConstantPropagationVisitor_BinaryComparison.cpp b/src/NZSL/Ast/ConstantPropagationVisitor_BinaryComparison.cpp
index e59564a..ffdfe6f 100644
--- a/src/NZSL/Ast/ConstantPropagationVisitor_BinaryComparison.cpp
+++ b/src/NZSL/Ast/ConstantPropagationVisitor_BinaryComparison.cpp
@@ -2,8 +2,9 @@
 // This file is part of the "Nazara Shading Language" project
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
-#include <NZSL/Ast/ConstantPropagationVisitor.hpp>
+#include <NazaraUtils/TypeTraits.hpp>
 #include <NZSL/ShaderBuilder.hpp>
+#include <NZSL/Ast/ConstantPropagationVisitor.hpp>
 #include <NZSL/Lang/Errors.hpp>
 #include <cassert>
 #include <cmath>
@@ -13,40 +14,6 @@ namespace nzsl::Ast
 {
 	namespace NAZARA_ANONYMOUS_NAMESPACE
 	{
-		template <typename T>
-		struct IsCompleteHelper
-		{
-			// SFINAE: sizeof in an incomplete type is an error, but since there's another specialization it won't result in a compilation error
-			template <typename U>
-			static auto test(U*) -> std::bool_constant<sizeof(U) == sizeof(U)>;
-
-			// less specialized overload
-			static auto test(...) -> std::false_type;
-
-			using type = decltype(test(static_cast<T*>(nullptr)));
-		};
-
-		template <typename T>
-		struct IsComplete : IsCompleteHelper<T>::type {};
-
-		template<typename T>
-		inline constexpr bool IsComplete_v = IsComplete<T>::value;
-
-		/*************************************************************************************************/
-
-		template<typename T>
-		struct IsVector : std::false_type
-		{
-		};
-
-		template<typename T, std::size_t N>
-		struct IsVector<Vector<T, N>> : std::true_type
-		{
-		};
-
-		template<typename T>
-		inline constexpr bool IsVector_v = IsVector<T>::value;
-
 		/*************************************************************************************************/
 
 		template<BinaryType Type, typename T1, typename T2>
@@ -54,177 +21,103 @@ namespace nzsl::Ast
 
 		// CompEq
 		template<typename T1, typename T2>
-		struct BinaryCompEqBase
+		struct BinaryCompEq
 		{
-			std::unique_ptr<ConstantValueExpression> operator()(const T1& lhs, const T2& rhs, const SourceLocation& /*sourceLocation*/)
+			static constexpr BinaryType Type = BinaryType::CompEq;
+
+			NAZARA_FORCEINLINE bool operator()(const T1& lhs, const T2& rhs, const SourceLocation& /*sourceLocation*/)
 			{
-				if constexpr (IsVector_v<T1>)
-					return ShaderBuilder::ConstantValue(lhs.ComponentEq(rhs));
-				else
-					return ShaderBuilder::ConstantValue(lhs == rhs);
+				return lhs == rhs;
 			}
 		};
 
-		template<typename T1, typename T2>
-		struct BinaryCompEq;
-
-		template<typename T1, typename T2>
-		struct BinaryConstantPropagation<BinaryType::CompEq, T1, T2>
-		{
-			using Op = BinaryCompEq<T1, T2>;
-		};
-
 		// CompGe
 		template<typename T1, typename T2>
-		struct BinaryCompGeBase
+		struct BinaryCompGe
 		{
-			std::unique_ptr<ConstantValueExpression> operator()(const T1& lhs, const T2& rhs, const SourceLocation& /*sourceLocation*/)
+			static constexpr BinaryType Type = BinaryType::CompGe;
+
+			NAZARA_FORCEINLINE bool operator()(const T1& lhs, const T2& rhs, const SourceLocation& /*sourceLocation*/)
 			{
-				if constexpr (IsVector_v<T1>)
-					return ShaderBuilder::ConstantValue(lhs.ComponentGe(rhs));
-				else
-					return ShaderBuilder::ConstantValue(lhs >= rhs);
+				return lhs >= rhs;
 			}
 		};
 
-		template<typename T1, typename T2>
-		struct BinaryCompGe;
-
-		template<typename T1, typename T2>
-		struct BinaryConstantPropagation<BinaryType::CompGe, T1, T2>
-		{
-			using Op = BinaryCompGe<T1, T2>;
-		};
-
 		// CompGt
 		template<typename T1, typename T2>
-		struct BinaryCompGtBase
+		struct BinaryCompGt
 		{
-			std::unique_ptr<ConstantValueExpression> operator()(const T1& lhs, const T2& rhs, const SourceLocation& /*sourceLocation*/)
+			static constexpr BinaryType Type = BinaryType::CompGt;
+
+			NAZARA_FORCEINLINE bool operator()(const T1& lhs, const T2& rhs, const SourceLocation& /*sourceLocation*/)
 			{
-				if constexpr (IsVector_v<T1>)
-					return ShaderBuilder::ConstantValue(lhs.ComponentGt(rhs));
-				else
-					return ShaderBuilder::ConstantValue(lhs > rhs);
+				return lhs > rhs;
 			}
 		};
 
-		template<typename T1, typename T2>
-		struct BinaryCompGt;
-
-		template<typename T1, typename T2>
-		struct BinaryConstantPropagation<BinaryType::CompGt, T1, T2>
-		{
-			using Op = BinaryCompGt<T1, T2>;
-		};
-
 		// CompLe
 		template<typename T1, typename T2>
-		struct BinaryCompLeBase
+		struct BinaryCompLe
 		{
-			std::unique_ptr<ConstantValueExpression> operator()(const T1& lhs, const T2& rhs, const SourceLocation& /*sourceLocation*/)
+			static constexpr BinaryType Type = BinaryType::CompLe;
+
+			NAZARA_FORCEINLINE bool operator()(const T1& lhs, const T2& rhs, const SourceLocation& /*sourceLocation*/)
 			{
-				if constexpr (IsVector_v<T1>)
-					return ShaderBuilder::ConstantValue(lhs.ComponentLe(rhs));
-				else
-					return ShaderBuilder::ConstantValue(lhs <= rhs);
+				return lhs <= rhs;
 			}
 		};
 
-		template<typename T1, typename T2>
-		struct BinaryCompLe;
-
-		template<typename T1, typename T2>
-		struct BinaryConstantPropagation<BinaryType::CompLe, T1, T2>
-		{
-			using Op = BinaryCompLe<T1, T2>;
-		};
-
 		// CompLt
 		template<typename T1, typename T2>
-		struct BinaryCompLtBase
+		struct BinaryCompLt
 		{
-			std::unique_ptr<ConstantValueExpression> operator()(const T1& lhs, const T2& rhs, const SourceLocation& /*sourceLocation*/)
+			static constexpr BinaryType Type = BinaryType::CompLt;
+
+			NAZARA_FORCEINLINE bool operator()(const T1& lhs, const T2& rhs, const SourceLocation& /*sourceLocation*/)
 			{
-				if constexpr (IsVector_v<T1>)
-					return ShaderBuilder::ConstantValue(lhs.ComponentLt(rhs));
-				else
-					return ShaderBuilder::ConstantValue(lhs < rhs);
+				return lhs < rhs;
 			}
 		};
 
-		template<typename T1, typename T2>
-		struct BinaryCompLt;
-
-		template<typename T1, typename T2>
-		struct BinaryConstantPropagation<BinaryType::CompLt, T1, T2>
-		{
-			using Op = BinaryCompLe<T1, T2>;
-		};
-
 		// CompNe
 		template<typename T1, typename T2>
-		struct BinaryCompNeBase
+		struct BinaryCompNe
 		{
-			std::unique_ptr<ConstantValueExpression> operator()(const T1& lhs, const T2& rhs, const SourceLocation& /*sourceLocation*/)
+			static constexpr BinaryType Type = BinaryType::CompNe;
+
+			NAZARA_FORCEINLINE bool operator()(const T1& lhs, const T2& rhs, const SourceLocation& /*sourceLocation*/)
 			{
-				if constexpr (IsVector_v<T1>)
-					return ShaderBuilder::ConstantValue(lhs.ComponentNe(rhs));
-				else
-					return ShaderBuilder::ConstantValue(lhs != rhs);
+				return lhs != rhs;
 			}
 		};
 
-		template<typename T1, typename T2>
-		struct BinaryCompNe;
-
-		template<typename T1, typename T2>
-		struct BinaryConstantPropagation<BinaryType::CompNe, T1, T2>
-		{
-			using Op = BinaryCompNe<T1, T2>;
-		};
-
 		// LogicalAnd
 		template<typename T1, typename T2>
-		struct BinaryLogicalAndBase
+		struct BinaryLogicalAnd
 		{
-			std::unique_ptr<ConstantValueExpression> operator()(const T1& lhs, const T2& rhs, const SourceLocation& /*sourceLocation*/)
+			static constexpr BinaryType Type = BinaryType::LogicalAnd;
+
+			NAZARA_FORCEINLINE bool operator()(const T1& lhs, const T2& rhs, const SourceLocation& /*sourceLocation*/)
 			{
-				return ShaderBuilder::ConstantValue(lhs && rhs);
+				return lhs && rhs;
 			}
 		};
 
-		template<typename T1, typename T2>
-		struct BinaryLogicalAnd;
-
-		template<typename T1, typename T2>
-		struct BinaryConstantPropagation<BinaryType::LogicalAnd, T1, T2>
-		{
-			using Op = BinaryLogicalAnd<T1, T2>;
-		};
-
 		// LogicalOr
 		template<typename T1, typename T2>
-		struct BinaryLogicalOrBase
+		struct BinaryLogicalOr
 		{
-			std::unique_ptr<ConstantValueExpression> operator()(const T1& lhs, const T2& rhs, const SourceLocation& /*sourceLocation*/)
+			static constexpr BinaryType Type = BinaryType::LogicalOr;
+
+			NAZARA_FORCEINLINE bool operator()(const T1& lhs, const T2& rhs, const SourceLocation& /*sourceLocation*/)
 			{
-				return ShaderBuilder::ConstantValue(lhs || rhs);
+				return lhs || rhs;
 			}
 		};
 
-		template<typename T1, typename T2>
-		struct BinaryLogicalOr;
-
-		template<typename T1, typename T2>
-		struct BinaryConstantPropagation<BinaryType::LogicalOr, T1, T2>
-		{
-			using Op = BinaryLogicalOr<T1, T2>;
-		};
-
 		/*************************************************************************************************/
 
-#define EnableOptimisation(Op, ...) template<> struct Op<__VA_ARGS__> : Op##Base<__VA_ARGS__> {}
+#define EnableOptimisation(Impl, ...) template<> struct BinaryConstantPropagation<Impl<__VA_ARGS__>::Type, __VA_ARGS__> : Impl<__VA_ARGS__> {}
 
 		// Binary
 
@@ -233,113 +126,35 @@ namespace nzsl::Ast
 		EnableOptimisation(BinaryCompEq, float, float);
 		EnableOptimisation(BinaryCompEq, std::int32_t, std::int32_t);
 		EnableOptimisation(BinaryCompEq, std::uint32_t, std::uint32_t);
-		EnableOptimisation(BinaryCompEq, Vector2<bool>, Vector2<bool>);
-		EnableOptimisation(BinaryCompEq, Vector3<bool>, Vector3<bool>);
-		EnableOptimisation(BinaryCompEq, Vector4<bool>, Vector4<bool>);
-		EnableOptimisation(BinaryCompEq, Vector2f32, Vector2f32);
-		EnableOptimisation(BinaryCompEq, Vector3f32, Vector3f32);
-		EnableOptimisation(BinaryCompEq, Vector4f32, Vector4f32);
-		EnableOptimisation(BinaryCompEq, Vector2f64, Vector2f64);
-		EnableOptimisation(BinaryCompEq, Vector3f64, Vector3f64);
-		EnableOptimisation(BinaryCompEq, Vector4f64, Vector4f64);
-		EnableOptimisation(BinaryCompEq, Vector2i32, Vector2i32);
-		EnableOptimisation(BinaryCompEq, Vector3i32, Vector3i32);
-		EnableOptimisation(BinaryCompEq, Vector4i32, Vector4i32);
-		EnableOptimisation(BinaryCompEq, Vector2u32, Vector2u32);
-		EnableOptimisation(BinaryCompEq, Vector3u32, Vector3u32);
-		EnableOptimisation(BinaryCompEq, Vector4u32, Vector4u32);
 
 		EnableOptimisation(BinaryCompGe, double, double);
 		EnableOptimisation(BinaryCompGe, float, float);
 		EnableOptimisation(BinaryCompGe, std::int32_t, std::int32_t);
 		EnableOptimisation(BinaryCompGe, std::uint32_t, std::uint32_t);
-		EnableOptimisation(BinaryCompGe, Vector2f32, Vector2f32);
-		EnableOptimisation(BinaryCompGe, Vector3f32, Vector3f32);
-		EnableOptimisation(BinaryCompGe, Vector4f32, Vector4f32);
-		EnableOptimisation(BinaryCompGe, Vector2f64, Vector2f64);
-		EnableOptimisation(BinaryCompGe, Vector3f64, Vector3f64);
-		EnableOptimisation(BinaryCompGe, Vector4f64, Vector4f64);
-		EnableOptimisation(BinaryCompGe, Vector2i32, Vector2i32);
-		EnableOptimisation(BinaryCompGe, Vector3i32, Vector3i32);
-		EnableOptimisation(BinaryCompGe, Vector4i32, Vector4i32);
-		EnableOptimisation(BinaryCompGe, Vector2u32, Vector2u32);
-		EnableOptimisation(BinaryCompGe, Vector3u32, Vector3u32);
-		EnableOptimisation(BinaryCompGe, Vector4u32, Vector4u32);
 
 		EnableOptimisation(BinaryCompGt, double, double);
 		EnableOptimisation(BinaryCompGt, float, float);
 		EnableOptimisation(BinaryCompGt, std::int32_t, std::int32_t);
 		EnableOptimisation(BinaryCompGt, std::uint32_t, std::uint32_t);
-		EnableOptimisation(BinaryCompGt, Vector2f32, Vector2f32);
-		EnableOptimisation(BinaryCompGt, Vector3f32, Vector3f32);
-		EnableOptimisation(BinaryCompGt, Vector4f32, Vector4f32);
-		EnableOptimisation(BinaryCompGt, Vector2f64, Vector2f64);
-		EnableOptimisation(BinaryCompGt, Vector3f64, Vector3f64);
-		EnableOptimisation(BinaryCompGt, Vector4f64, Vector4f64);
-		EnableOptimisation(BinaryCompGt, Vector2i32, Vector2i32);
-		EnableOptimisation(BinaryCompGt, Vector3i32, Vector3i32);
-		EnableOptimisation(BinaryCompGt, Vector4i32, Vector4i32);
-		EnableOptimisation(BinaryCompGt, Vector2u32, Vector2u32);
-		EnableOptimisation(BinaryCompGt, Vector3u32, Vector3u32);
-		EnableOptimisation(BinaryCompGt, Vector4u32, Vector4u32);
 
 		EnableOptimisation(BinaryCompLe, double, double);
 		EnableOptimisation(BinaryCompLe, float, float);
 		EnableOptimisation(BinaryCompLe, std::int32_t, std::int32_t);
 		EnableOptimisation(BinaryCompLe, std::uint32_t, std::uint32_t);
-		EnableOptimisation(BinaryCompLe, Vector2f32, Vector2f32);
-		EnableOptimisation(BinaryCompLe, Vector3f32, Vector3f32);
-		EnableOptimisation(BinaryCompLe, Vector4f32, Vector4f32);
-		EnableOptimisation(BinaryCompLe, Vector2f64, Vector2f64);
-		EnableOptimisation(BinaryCompLe, Vector3f64, Vector3f64);
-		EnableOptimisation(BinaryCompLe, Vector4f64, Vector4f64);
-		EnableOptimisation(BinaryCompLe, Vector2i32, Vector2i32);
-		EnableOptimisation(BinaryCompLe, Vector3i32, Vector3i32);
-		EnableOptimisation(BinaryCompLe, Vector4i32, Vector4i32);
-		EnableOptimisation(BinaryCompLe, Vector2u32, Vector2u32);
-		EnableOptimisation(BinaryCompLe, Vector3u32, Vector3u32);
-		EnableOptimisation(BinaryCompLe, Vector4u32, Vector4u32);
 
 		EnableOptimisation(BinaryCompLt, double, double);
 		EnableOptimisation(BinaryCompLt, float, float);
 		EnableOptimisation(BinaryCompLt, std::int32_t, std::int32_t);
 		EnableOptimisation(BinaryCompLt, std::uint32_t, std::uint32_t);
-		EnableOptimisation(BinaryCompLt, Vector2f32, Vector2f32);
-		EnableOptimisation(BinaryCompLt, Vector3f32, Vector3f32);
-		EnableOptimisation(BinaryCompLt, Vector4f32, Vector4f32);
-		EnableOptimisation(BinaryCompLt, Vector2f64, Vector2f64);
-		EnableOptimisation(BinaryCompLt, Vector3f64, Vector3f64);
-		EnableOptimisation(BinaryCompLt, Vector4f64, Vector4f64);
-		EnableOptimisation(BinaryCompLt, Vector2i32, Vector2i32);
-		EnableOptimisation(BinaryCompLt, Vector3i32, Vector3i32);
-		EnableOptimisation(BinaryCompLt, Vector4i32, Vector4i32);
-		EnableOptimisation(BinaryCompLt, Vector2u32, Vector2u32);
-		EnableOptimisation(BinaryCompLt, Vector3u32, Vector3u32);
-		EnableOptimisation(BinaryCompLt, Vector4u32, Vector4u32);
 
 		EnableOptimisation(BinaryCompNe, bool, bool);
 		EnableOptimisation(BinaryCompNe, double, double);
 		EnableOptimisation(BinaryCompNe, float, float);
 		EnableOptimisation(BinaryCompNe, std::int32_t, std::int32_t);
 		EnableOptimisation(BinaryCompNe, std::uint32_t, std::uint32_t);
-		EnableOptimisation(BinaryCompNe, Vector2<bool>, Vector2<bool>);
-		EnableOptimisation(BinaryCompNe, Vector3<bool>, Vector3<bool>);
-		EnableOptimisation(BinaryCompNe, Vector4<bool>, Vector4<bool>);
-		EnableOptimisation(BinaryCompNe, Vector2f32, Vector2f32);
-		EnableOptimisation(BinaryCompNe, Vector3f32, Vector3f32);
-		EnableOptimisation(BinaryCompNe, Vector4f32, Vector4f32);
-		EnableOptimisation(BinaryCompNe, Vector2f64, Vector2f64);
-		EnableOptimisation(BinaryCompNe, Vector3f64, Vector3f64);
-		EnableOptimisation(BinaryCompNe, Vector4f64, Vector4f64);
-		EnableOptimisation(BinaryCompNe, Vector2i32, Vector2i32);
-		EnableOptimisation(BinaryCompNe, Vector3i32, Vector3i32);
-		EnableOptimisation(BinaryCompNe, Vector4i32, Vector4i32);
-		EnableOptimisation(BinaryCompNe, Vector2u32, Vector2u32);
-		EnableOptimisation(BinaryCompNe, Vector3u32, Vector3u32);
-		EnableOptimisation(BinaryCompNe, Vector4u32, Vector4u32);
 
 		EnableOptimisation(BinaryLogicalAnd, bool, bool);
-		EnableOptimisation(BinaryLogicalOr, bool, bool);
+		EnableOptimisation(BinaryLogicalOr,  bool, bool);
 
 #undef EnableOptimisation
 	}
@@ -369,13 +184,23 @@ namespace nzsl::Ast
 		{
 			using T1 = std::decay_t<decltype(arg1)>;
 			using T2 = std::decay_t<decltype(arg2)>;
-			using PCType = BinaryConstantPropagation<Type, T1, T2>;
+			using Op = BinaryConstantPropagation<Type, T1, T2>;
 
-			if constexpr (IsComplete_v<PCType>)
+			if constexpr (Nz::IsComplete_v<Op>)
+				optimized = ShaderBuilder::ConstantValue(Op{}(arg1, arg2, sourceLocation));
+			else if constexpr (IsVector_v<T1> && IsVector_v<T2>)
 			{
-				using Op = typename PCType::Op;
-				if constexpr (IsComplete_v<Op>)
-					optimized = Op{}(arg1, arg2, sourceLocation);
+				using SubOp = BinaryConstantPropagation<Type, typename T1::Base, typename T2::Base>;
+				if constexpr (Nz::IsComplete_v<SubOp> && T1::Dimensions == T2::Dimensions)
+				{
+					using RetType = Vector<bool, T1::Dimensions>;
+
+					RetType value;
+					for (std::size_t i = 0; i < T1::Dimensions; ++i)
+						value[i] = SubOp{}(arg1[i], arg2[i], sourceLocation);
+
+					optimized = ShaderBuilder::ConstantValue(value);
+				}
 			}
 		}, lhs.value, rhs.value);
 
diff --git a/tests/src/Tests/ErrorsTests.cpp b/tests/src/Tests/ErrorsTests.cpp
index a9aa422..d00d981 100644
--- a/tests/src/Tests/ErrorsTests.cpp
+++ b/tests/src/Tests/ErrorsTests.cpp
@@ -325,7 +325,7 @@ module;
 
 const V = vec4[i32](7, 6, 5, 4) / vec4[i32](3, 2, 1, 0);
 
-)"), "(5,11 -> 55): CIntegralDivisionByZero error: integral division by zero in expression (vec4[i32](7, 6, 5, 4) / vec4[i32](3, 2, 1, 0))");
+)"), "(5,11 -> 55): CIntegralDivisionByZero error: integral division by zero in expression (4 / 0)");
 
 			CHECK_THROWS_WITH(Compile(R"(
 [nzsl_version("1.0")]
@@ -341,7 +341,7 @@ module;
 
 const V = vec4[i32](7, 6, 5, 4) % vec4[i32](3, 2, 1, 0);
 
-)"), "(5,11 -> 55): CIntegralModuloByZero error: integral modulo by zero in expression (vec4[i32](7, 6, 5, 4) % vec4[i32](3, 2, 1, 0))");
+)"), "(5,11 -> 55): CIntegralModuloByZero error: integral modulo by zero in expression (4 % 0)");
 
 			CHECK_THROWS_WITH(Compile(R"(
 [nzsl_version("1.0")]